मैं बाइट [] से बिटमैप इमेज कैसे बदल सकता हूं?

Question

मेरे पास byte[] है जो किसी छवि के कच्चे डेटा का प्रतिनिधित्व करता है। मैं इसे BitmapImage में परिवर्तित करना चाहता हूं।

मैं कई उदाहरण मैंने पाया की कोशिश की लेकिन मैं निम्नलिखित अपवाद

हो रही है "इस कार्य को पूरा करने के लिए उपयुक्त नहीं इमेजिंग घटक मिला था।"

मुझे लगता है कि ऐसा इसलिए है क्योंकि मेरा byte[] वास्तव में एक छवि का प्रतिनिधित्व नहीं करता है बल्कि केवल कच्चे बिट्स का प्रतिनिधित्व करता है। इसलिए मेरा प्रश्न ऊपर वर्णित है कि कैसे कच्चे बिट्स के बाइट [] को BitmapImage में परिवर्तित करना है।

Answer 1

अपने बाइट सरणी एक बिटमैप के कच्चे पिक्सेल डेटा होता है, तो आप बना सकते हैं एक BitmapSource स्थिर विधि BitmapSource.Create द्वारा (जो BitmapImage के आधार वर्ग है)।

हालांकि, आपको बिटमैप के कुछ पैरामीटर निर्दिष्ट करने की आवश्यकता है। आपको पहले से चौड़ाई और ऊंचाई और बफर के PixelFormat पता होना चाहिए।

byte[] buffer = ...; 

var width = 100; // for example 
var height = 100; // for example 
var dpiX = 96d; 
var dpiY = 96d; 
var pixelFormat = PixelFormats.Pbgra32; // for example 
var bytesPerPixel = (pixelFormat.BitsPerPixel + 7)/8; 
var stride = bytesPerPixel * width; 

var bitmap = BitmapSource.Create(width, height, dpiX, dpiY, 
           pixelFormat, null, buffer, stride); 

Answer 2

कच्चे बाइट्स से मेमोरीस्ट्रीम बनाएं और इसे अपने बिटमैप कन्स्ट्रक्टर में पास करें।

इस तरह

:

MemoryStream stream = new  MemoryStream(bytes); 
Bitmap image = new Bitmap(stream); 

Answer 3

public static BitmapImage LoadFromBytes(byte[] bytes) 
{ 
    using (var stream = new MemoryStream(bytes)) 
    { 
     stream.Seek(0, SeekOrigin.Begin); 
     var image = new BitmapImage(); 
     image.BeginInit(); 
     image.StreamSource = stream; 
     image.EndInit(); 

     return image; 
    } 
} 

Answer 4

मैं इसी त्रुटि में भाग गया, लेकिन ऐसा इसलिए था क्योंकि मेरी सरणी वास्तविक डेटा से भर नहीं रही थी। मेरे पास बाइट्स की एक सरणी थी जो लंबाई के बराबर थी, लेकिन मान अभी भी 0 थे - वे नहीं लिखे गए थे!

मेरा विशेष मुद्दा - और मुझे इस प्रश्न पर आने वाले अन्य लोगों के लिए संदेह है - साथ ही OracleBlob पैरामीटर के कारण था। मुझे नहीं लगता था कि मुझे इसकी ज़रूरत है, और मैंने सोचा कि मैं कुछ ऐसा कर सकता हूं:

DataSet ds = new DataSet(); 
OracleCommand cmd = new OracleCommand(strQuery, conn); 
OracleDataAdapter oraAdpt = new OracleDataAdapter(cmd); 
oraAdpt.Fill(ds) 

if (ds.Tables[0].Rows.Count > 0) 
{ 
    byte[] myArray = (bytes)ds.Tables[0]["MY_BLOB_COLUMN"]; 
} 

मैं कितना गलत था! वास्तव में उस ब्लॉब में वास्तविक बाइट्स प्राप्त करने के लिए, मुझे वास्तव में उस परिणाम को OracleBlob ऑब्जेक्ट में पढ़ने की आवश्यकता थी। एक डाटासेट/datatable भरने के बजाय, मैं ऐसा किया:

OracleBlob oBlob = null; 
byte[] myArray = null; 
OracleCommand cmd = new OracleCommand(strQuery, conn); 
OracleDataReader result = cmd.ExecuteReader(); 
result.Read(); 

if (result.HasRows) 
{ 
    oBlob = result.GetOracleBlob(0); 
    myArray = new byte[oBlob.Length]; 
    oBlob.Read(array, 0, Convert.ToInt32(myArray.Length)); 
    oBlob.Erase(); 
    oBlob.Close(); 
    oBlob.Dispose(); 
} 

फिर, मैं myArray लेने के लिए और ऐसा कर सकता है:

if (myArray != null) 
{ 
    if (myArray.Length > 0) 
    { 
     MyImage.Source = LoadBitmapFromBytes(myArray); 
    } 
} 

और दूसरी जवाब से मेरे संशोधित LoadBitmapFromBytes समारोह:

public static BitmapImage LoadBitmapFromBytes(byte[] bytes) 
{ 
    var image = new BitmapImage(); 
    using (var stream = new MemoryStream(bytes)) 
    { 
     stream.Seek(0, SeekOrigin.Begin); 
     image.BeginInit(); 
     image.StreamSource = stream; 
     image.CreateOptions = BitmapCreateOptions.PreservePixelFormat; 
     image.CacheOption = BitmapCacheOption.OnLoad; 
     image.UriSource = null; 
     image.EndInit(); 
    } 

    return image; 
}