बाइट [] ushort []

Question

यहां मेरा प्रश्न है। थोड़ा सा स्पष्टीकरण देने के साथ मेरे साथ भालू:

मैं बफर छवि को बफर में पढ़ रहा हूं; मेरे टिफ के प्रत्येक पिक्सेल को एक यूहॉर्ट (16 बिट्स डेटा, गैर-नकारात्मक) द्वारा दर्शाया जाता है।

मेरी छवि का आकार 64 * 64 = 4096 है। जब मेरा टिफ़ बफर में लोड होता है, तो बफर की लंबाई 8192 (4096 जितनी दोगुनी होती है) होती है। मुझे लगता है कि ऐसा इसलिए है क्योंकि मेरे बफर में, कंप्यूटर एक पिक्सेल मान को स्टोर करने के लिए 2 बाइट्स का उपयोग करता है।

मैं किसी भी विशेष पिक्सेल के लिए मूल्य प्राप्त करना चाहता हूं, इस मामले में क्या मुझे हर 2 बाइट्स को 1 ushort में जोड़ना चाहिए?

उदाहरण के लिए: 00000000 11111111 -> 0000000011111111?

public static void LoadTIFF(string fileName, int pxlIdx, ref int pxlValue) 
     { 
      using (Tiff image = Tiff.Open(fileName, "r")) 
      { 
       if (image == null) 
        return; 

       FieldValue[] value = image.GetField(TiffTag.IMAGEWIDTH); 
       int width = value[0].ToInt(); 

       byte[] buffer = new byte[image.StripSize()]; 
       for (int strip = 0; strip < image.NumberOfStrips(); strip++) 
        image.ReadEncodedStrip(strip, buffer, 0, -1); 

       // do conversion here: 
       //ushort bufferHex = BitConverter.ToUInt16(buffer, 0);    

       image.Close(); 

      } 
     } 

मैं कैसे पढ़ा करते बाइट [] सुनिश्चित करने के लिए है कि मैं 16 बिट ushort पिक्सेल मूल्य प्राप्त कर सकते हैं बफ़र:

यहाँ मेरी कोड है?

धन्यवाद

Answer 1

के बाद से प्रत्येक पिक्सेल 16 बिट के रूप में प्रस्तुत किया जाता है, यह और अधिक सुविधाजनक एक प्रोग्रामिंग के नजरिए से आधा लंबाई के एक ushort[] रूप byte[] प्रतिनिधित्व करने के लिए हो सकता है, लेकिन यह जरूरी नहीं है।

सबसे अच्छा समाधान इस बात पर निर्भर करता है कि आप बफर का उपभोग कैसे करना चाहते हैं।

तुम बस के रूप में आसानी से एक सहायक विधि

ushort GetImageDataAtLocation(int x, int y) 
{ 
    offset = y * HEIGHT + x; 
    return BitConverter.ToUInt16(buffer, offset); 
} 

निर्धारित करने के लिए मूल byte[] में ऑफसेट निर्देशांक इनपुट का उपयोग करता है और एक ushort उचित बाइट्स से बना देता है कि निर्धारित कर सकते हैं।

यदि टीआईएफएफ डेटा को बड़े-एंडियन स्टोर करता है और आपका सिस्टम थोड़ा-अंतराल है, तो आपको रूपांतरण से पहले बाइट्स के क्रम को उलट करना होगा। एक तरीका यह है कि ऐसा करने के लिए है: अपने कोड कभी अलग endianness साथ प्लेटफार्म पर चला सकता है

ushort GetImageDataAtLocation(int x, int y) 
{ 
    offset = y * HEIGHT + x; 
    // Switch endianness e.g. TIFF is big-endian, host system is little-endian 
    ushort result = ((ushort)buffer[0]) << 8 + buffer[1]; 
    return result; 
} 

हैं (इंटेल और एएमडी दोनों छोटे-endian कर रहे हैं) आप उपयोग कर रनटाइम पर endianness निर्धारित कर सकते हैं

BitConverter.IsLittleEndian

BitConverter पर जानकारी के लिए http://msdn.microsoft.com/en-us/library/system.bitconverter.touint16.aspx

Answer 2

आप एक पाश में यह सब करने की ज़रूरत देखें: BitConverter.ToUInt16() 2 बाइट्स लेता है, उन्हें एक ushort में बदलने का।

चेतावनी: जैसा कि एरिक ने इंगित किया है, इसमें अंतहीनता की समस्याएं हैं (यह हमेशा प्लेटफॉर्म की अंतहीनता मानती है जिस पर यह निष्पादित हो रहा है)। केवल बिटकॉन्टर का उपयोग करें यदि आप सुनिश्चित हैं कि स्रोत बाइट स्ट्रीम एक ही अंतहीनता वाली मशीन पर उत्पादित की जाती है (टीआईएफएफ छवियों के मामले में, शायद आप इसे नहीं मान सकते हैं)।

आप कुछ LINQ का उपयोग कर सकते हैं ... उदाहरण के लिए एक अच्छा Chuncks फ़ंक्शन here है।आप इसका उपयोग इस प्रकार कर सकते हैं:

rawBytes.Chunks(2).Select(b => BitConverter.ToUInt16(b)).toArray()