शुरुआती लोगों के लिए निचले स्तर पर रेखापुंज के साथ काम करें

इस लेख का कारण निम्नलिखित पोस्ट था: "आगे की प्रक्रिया के लिए मैट्रिक्स में bmp छवियों को बदलना और इसके विपरीत । " एक समय में, मुझे C # में बहुत सारे शोध कोड लिखने थे, जिसने विभिन्न संपीड़न और प्रसंस्करण एल्गोरिदम को लागू किया। तथ्य यह है कि कोड खोजपूर्ण है, मैंने उल्लेख किया है कि आकस्मिक नहीं है। इस कोड में अजीबोगरीब आवश्यकताएं हैं। एक ओर, अनुकूलन बहुत महत्वपूर्ण नहीं है - विचार का परीक्षण करना महत्वपूर्ण है। हालांकि मैं चाहता हूं कि यह जांच घंटों और दिनों तक नहीं बढ़े (जब विभिन्न मापदंडों के साथ लॉन्च किया जा रहा है, या परीक्षण छवियों का एक बड़ा निकाय संसाधित किया जा रहा है)। उपर्युक्त पोस्ट में प्रयुक्त पिक्सेल luminances bmp.GetPixel (x, y) तक पहुंचने की विधि वह है जो मेरी पहली परियोजना के साथ शुरू हुई थी। यह सबसे आसान तरीका है। क्या यहां परेशान करने लायक है? चलो इसे मापें।

हम क्लासिक बिटमैप (System.Drawing.Bitmap) का उपयोग करेंगे। यह वर्ग सुविधाजनक है क्योंकि यह हमसे एन्कोडिंग रेखापुंज स्वरूपों का विवरण छिपाता है - एक नियम के रूप में, वे हमें रुचि नहीं देते हैं। इसी समय, सभी सामान्य स्वरूपों का समर्थन किया जाता है, जैसे बीएमपी, जीआईएफ, जेपीईजी, पीएनजी।

वैसे, मैं शुरुआती लोगों के लिए पहला लाभ पेश करूंगा। बिटमैप क्लास में एक कंस्ट्रक्टर है जो आपको एक पिक्चर फाइल खोलने की अनुमति देता है। लेकिन इसकी एक अप्रिय विशेषता है - यह इस फ़ाइल के लिए खुली पहुंच छोड़ देता है, इसलिए इसे बार-बार कॉल करने से निष्पादन होता है। इस व्यवहार को ठीक करने के लिए, आप इस पद्धति का उपयोग कर सकते हैं, बिटमैप को फ़ाइल को तुरंत "रिलीज़" करने के लिए मजबूर करें:

public static Bitmap LoadBitmap(string fileName) { using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read)) return new Bitmap(fs); } 

मापन विधि

हम इसे ऐरे में डिस्टिल करके और बिटमैप पर क्लासिक इमेज प्रोसेसिंग - Lena ( http://en.wikipedia.org/wiki/Lenna ) में मापेंगे। यह एक स्वतंत्र छवि है, यह बड़ी संख्या में छवि प्रसंस्करण कार्यों में पाया जा सकता है (और इस पोस्ट के शीर्षक में भी)। आकार - 512 * 512 पिक्सेल।

तकनीक के बारे में थोड़ा - ऐसे मामलों में, मैं अल्ट्रा-सटीक टाइमर का पीछा नहीं करना पसंद करता हूं, लेकिन बस एक ही कार्रवाई कई बार करता हूं। बेशक, एक तरफ, इस मामले में डेटा और कोड पहले से ही प्रोसेसर कैश में होगा। लेकिन, दूसरी ओर, हम MSIL कोड के अनुवाद से जुड़े कोड के पहले भाग की लागत को प्रोसेसर कोड और अन्य ओवरहेड लागत में अलग कर देते हैं। इसकी गारंटी देने के लिए, हम पहले प्रत्येक कोड को एक बार चलाते हैं - हम तथाकथित "वार्म-अप" करते हैं।

हम कोड को रिलीज़ में संकलित करते हैं। हम इसे निश्चित रूप से स्टूडियो के नीचे से लॉन्च नहीं करते हैं। इसके अलावा, स्टूडियो को बंद करने की भी सलाह दी जाती है - यह उन मामलों के साथ सामना किया गया था जब इसके "उपेक्षा" के बहुत तथ्य कभी-कभी परिणामों को प्रभावित करते हैं। साथ ही, अन्य अनुप्रयोगों को बंद करने की सलाह दी जाती है।

हम कई बार कोड चलाते हैं, विशिष्ट परिणाम प्राप्त करते हैं - आपको यह सुनिश्चित करने की आवश्यकता है कि यह कुछ अप्रत्याशित प्रक्रिया को प्रभावित नहीं करता है। मान लीजिए कि एक एंटीवायरस या कुछ और जाग उठा। ये सभी उपाय हमें स्थिर, दोहराने योग्य परिणाम प्राप्त करने की अनुमति देते हैं।

भोली विधि

मूल लेख में इस पद्धति का उपयोग किया गया था। इसमें Bitmap.GetPixel (x, y) विधि का उपयोग किया जाता है। हम ऐसी विधि के लिए पूर्ण कोड देते हैं, जो बिटमैप की सामग्री को तीन-आयामी बाइट सरणी में परिवर्तित करता है। इस मामले में, पहला आयाम रंग घटक (0 से 2 तक) है, दूसरा y स्थिति है, और तीसरा x स्थिति है। यह मेरी परियोजनाओं में हुआ, यदि आप डेटा को अलग तरीके से व्यवस्थित करना चाहते हैं - मुझे लगता है कि कोई समस्या नहीं होगी।

 public static byte[, ,] BitmapToByteRgbNaive(Bitmap bmp) { int width = bmp.Width, height = bmp.Height; byte[, ,] res = new byte[3, height, width]; for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { Color color = bmp.GetPixel(x, y); res[0, y, x] = color.R; res[1, y, x] = color.G; res[2, y, x] = color.B; } } return res; } 

उलटा परिवर्तन समान है, केवल डेटा ट्रांसफर एक अलग दिशा में जाता है। मैं यहां उनका कोड नहीं दूंगा - कोई भी लेख के अंत में लिंक पर परियोजना के लिए स्रोत कोड देख सकता है।

I5-2520M 2.5GHz प्रोसेसर के साथ मेरे लैपटॉप पर छवि के लिए 100 रूपांतरण और इसके विपरीत, 43.90 सेकंड की आवश्यकता है। यह पता चलता है कि 512 * 512 की छवि के साथ, डेटा ट्रांसफर पर केवल आधा सेकंड खर्च होता है!

बिटमैप डेटा के साथ प्रत्यक्ष काम

सौभाग्य से, बिटमैप वर्ग अपने डेटा तक पहुंचने का एक तेज़ तरीका प्रदान करता है। ऐसा करने के लिए, हमें BitmapData वर्ग और पते अंकगणित द्वारा दिए गए लिंक का उपयोग करने की आवश्यकता है:

 public unsafe static byte[, ,] BitmapToByteRgb(Bitmap bmp) { int width = bmp.Width, height = bmp.Height; byte[, ,] res = new byte[3, height, width]; BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); try { byte* curpos; for (int h = 0; h < height; h++) { curpos = ((byte*)bd.Scan0) + h * bd.Stride; for (int w = 0; w < width; w++) { res[2, h, w] = *(curpos++); res[1, h, w] = *(curpos++); res[0, h, w] = *(curpos++); } } } finally { bmp.UnlockBits(bd); } return res; } 

यह दृष्टिकोण हमें प्रति 100 रूपांतरण ()२ बार त्वरित) में ०.५३३ सेकंड देता है! मुझे लगता है कि यह पहले से ही सवाल का जवाब देता है - क्या यह अधिक जटिल रूपांतरण कोड लिखने के लायक है? लेकिन क्या हम अभी भी प्रबंधित कोड के भीतर रहकर प्रक्रिया को गति दे सकते हैं?

बिंदु बनाम इंगित करता है

बहुआयामी सरणियाँ सबसे तेज़ डेटा संरचनाएं नहीं हैं। यहां, सूचकांक की सीमाओं से परे जाने के लिए जांच की जाती है, तत्व की गणना गुणन और जोड़ के संचालन का उपयोग करके की जाती है। चूंकि बिटमैप डेटा के साथ काम करते समय पता अंकगणित ने पहले ही हमें महत्वपूर्ण त्वरण दिया है, शायद हम इसे बहुआयामी सरणियों के लिए भी लागू करने का प्रयास करेंगे? यहाँ प्रत्यक्ष रूपांतरण कोड है:

 public unsafe static byte[, ,] BitmapToByteRgbQ(Bitmap bmp) { int width = bmp.Width, height = bmp.Height; byte[, ,] res = new byte[3, height, width]; BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); try { byte* curpos; fixed (byte* _res = res) { byte* _r = _res, _g = _res + width*height, _b = _res + 2*width*height; for (int h = 0; h < height; h++) { curpos = ((byte*)bd.Scan0) + h * bd.Stride; for (int w = 0; w < width; w++) { *_b = *(curpos++); ++_b; *_g = *(curpos++); ++_g; *_r = *(curpos++); ++_r; } } } } finally { bmp.UnlockBits(bd); } return res; } 

परिणाम? प्रति 100 रूपांतरण पर 0.162 सेकंड। इसलिए उन्होंने "भोली" संस्करण के साथ तुलना में एक और 3.3 गुना (270 बार) त्वरित किया। यह एक ऐसा कोड था जिसका उपयोग मैंने एल्गोरिदम पर शोध करते समय किया था।

क्यों ढोते हैं?

यह पूरी तरह से स्पष्ट नहीं है कि बिटमैप से डेटा स्थानांतरित क्यों किया जा रहा है। शायद सामान्य रूप से, वहाँ सभी परिवर्तनों को करने के लिए? मैं मानता हूं कि यह संभावित विकल्पों में से एक है। लेकिन, तथ्य यह है कि फ्लोटिंग पॉइंट डेटा पर जांच करने के लिए कई एल्गोरिदम अधिक सुविधाजनक हैं। फिर इंटरफ्लो में कोई समस्या नहीं है, मध्यवर्ती चरणों में सटीकता की हानि। एक डबल / फ्लोट ऐरे में कन्वर्ट एक समान तरीके से किया जा सकता है। उलटा रूपांतरण को बाइट में परिवर्तित करते समय सत्यापन की आवश्यकता होती है। इस तरह के चेक के लिए एक सरल कोड है:

 private static byte Limit(double x) { if (x < 0) return 0; if (x > 255) return 255; return (byte)x; } 

ऐसे चेक और प्रकार के रूपांतरण जोड़ना हमारे कोड को धीमा कर देता है। डबल सरणियों पर पता अंकगणित वाला संस्करण पहले से ही 0.713 सेकंड (प्रति 100 रूपांतरण) चल रहा है। लेकिन "भोली" विकल्प की पृष्ठभूमि के खिलाफ - यह सिर्फ बिजली है।

और अगर आप तेजी से जरूरत है?

यदि आपको अधिक तेज़ चाहिए, तो हम C, Asm में ट्रांसफर, प्रोसेसिंग लिखते हैं, हम SIMD कमांड का उपयोग करते हैं। बिटमैप रैपर के बिना, सीधे रेखापुंज प्रारूप डाउनलोड करें। बेशक, इस मामले में हम सभी प्रबंधित पेशेवरों और विपक्षों के साथ, प्रबंधित कोड की सीमाओं से परे हैं। और ऐसा करने के लिए पहले से ही डीबग किए गए एल्गोरिदम के लिए समझ में आता है।

लेख का पूरा कोड यहां पाया जा सकता है: rasterconversion.codeplex.com/SourceControl/latest

अद्यतन 2013-10-08:
टिप्पणीकारों के सुझाव पर, उन्होंने कोड में मार्शल (कोपी) का उपयोग करके एक सरणी में डेटा स्थानांतरित करने का विकल्प जोड़ा। यह पूरी तरह से परीक्षण के उद्देश्य से किया जाता है - काम करने के इस तरीके की अपनी सीमाएँ हैं:

• डेटा ऑर्डर बिल्कुल वैसा ही है जैसा मूल बिटमैप में होता है। यही है, घटक मिश्रित होते हैं। यदि हम उन्हें एक-दूसरे से अलग करना चाहते हैं, तो डेटा की नकल करते हुए, किसी भी तरह से सरणी के माध्यम से साइकिल चलाना आवश्यक होगा।
• चमक का प्रकार बाइट रहता है, साथ ही, अस्थायी बिंदु के साथ मध्यवर्ती गणना करने के लिए अक्सर सुविधाजनक होता है।
• मार्शल। कोपी () एक आयामी सरणियों के साथ काम करता है। हां, वे निश्चित रूप से सबसे तेज़ हैं और हर जगह आरजीबी [x + चौड़ाई * y] लिखना बहुत मुश्किल नहीं है, लेकिन फिर भी ...

तो, दो दिशाओं में नकल करने में 0.158 सेकंड (प्रति 100 रूपांतरण) लगते हैं। पॉइंटर्स पर अधिक लचीले संस्करण की तुलना में विभिन्न लॉन्च के परिणामों की सांख्यिकीय त्रुटि के भीतर त्वरण बहुत छोटा है।

अद्यतन 2016-04-25:
उपयोगकर्ता Ant00 ने BitmapToByteRgbQ विधि के कोड में एक त्रुटि का संकेत दिया। यह समय को प्रभावित नहीं करता था, लेकिन गलत तरीके से स्थानांतरण किया गया था। वर्किंग कोड से टुकड़ों के कॉपी-पेस्ट में त्रुटि हुई। सही किया। आपकी दृढ़ता के लिए धन्यवाद (पहली बार मैंने किसी लेख में कोड की सावधानीपूर्वक जांच की है जो पहले से ही 2.5 साल पुराना है)।