Like in the title. How to convert BitmapeImage to byte in metro style app. Ther is no System.drawing lib.
I need it to use in LuminanaceSource() which need source in byte[].
Have some example, but i dont know how to use it.
BitmapImage bmpImage = new BitmapImage(new Uri(file.Path));
var encoderId = Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId;
Thanks
these two methods should convert Bitmap image to byte[] and viceversa.
public BitmapImage ImageFromBuffer(Byte[] bytes)
{
MemoryStream stream = new MemoryStream(bytes);
BitmapImage image = new BitmapImage();
image.BeginInit();
image.StreamSource = stream;
image.EndInit();
return image;
}
public Byte[] BufferFromImage(BitmapImage imageSource)
{
Stream stream = imageSource.StreamSource;
Byte[] buffer = null;
if (stream != null && stream.Length > 0)
{
using (BinaryReader br = new BinaryReader(stream))
{
buffer = br.ReadBytes((Int32)stream.Length);
}
}
return buffer;
}
Related
I'm reading data from a blob in MySQL in Base64 String.
I want to convert this to a BitmapImage.
I've tried many ways, but without success.
Here is an example:
public static BitmapImage Base64ToBitmapImage(this string base64String)
{
byte[] binaryData = Convert.FromBase64String(base64String);
BitmapImage img = new BitmapImage();
img.BeginInit();
img.StreamSource = new MemoryStream(binaryData);
img.EndInit();
return img;
}
One example of blob:
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
In my project, I used this method to convert an array of bytes to BitmapImage:
public static BitmapImage? ConvertToBitmapImage(byte[]? imageData)
{
if (imageData == null || imageData.Length == 0) return null;
var image = new BitmapImage();
using (var mem = new MemoryStream(imageData))
{
mem.Position = 0;
image.BeginInit();
image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
image.CacheOption = BitmapCacheOption.OnLoad;
image.UriSource = null;
image.StreamSource = mem;
image.EndInit();
}
image.Freeze();
return image;
}
You can use this function by passing an array of bytes to it:
public static BitmapImage? Base64ToBitmapImage(this string base64String)
{
byte[] binaryData = Convert.FromBase64String(base64String);
return ConvertToBitmapImage(binaryData);
}
you can use this functions.
private string ImageToBase64String(string file)
{
Bitmap bitmap = new Bitmap(file);
MemoryStream ms = new MemoryStream();
bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
byte[] arr = new byte[ms.Length];
ms.Position = 0;
ms.Read(arr, 0, (int)ms.Length);
ms.Close();
string strBase64 = Convert.ToBase64String(arr);
return strBase64;
}
private Bitmap Base64StringToImage(string base64)
{
byte[] arr = Convert.FromBase64String(base64);
MemoryStream ms = new MemoryStream(arr);
Bitmap bitmap = new Bitmap(ms);
return bitmap;
}
The code above works fine. The cause of the problem its on MySQL return.
The value from a blob column returns returns as a byte on C# MySQL Lybrary.
And I was converting it to a Base64 String and recoverting to a byte.
I excluded this confusion in my code and problem fixed.
I have two functions: one to convert from image to byte and other to convert from byte to bitmapImage.
So, when I open the window with that images, I convert from byte to bitmapImage and it works great, but when I close and open it again it just keeps on memory and if I continue to do that time and time again it just throws an exception Out Of Memory exception
Image to byte->
private byte[] ConvertImageToBinary(Image img)
{
using (MemoryStream ss = new MemoryStream())
{
img.Save(ss, System.Drawing.Imaging.ImageFormat.Jpeg);
var s = ss.ToArray();
var jpegQuality = 50;
Image image;
using (var inputStream = new MemoryStream(s))
{
image = Image.FromStream(inputStream);
var jpegEncoder = System.Drawing.Imaging.ImageCodecInfo.GetImageDecoders()
.First(c => c.FormatID == System.Drawing.Imaging.ImageFormat.Jpeg.Guid);
var encoderParameters = new System.Drawing.Imaging.EncoderParameters(1);
encoderParameters.Param[0] = new System.Drawing.Imaging.EncoderParameter(System.Drawing.Imaging.Encoder.Quality, jpegQuality);
Byte[] outputBytes;
using (var outputStream = new MemoryStream())
{
image.Save(outputStream, jpegEncoder, encoderParameters);
return outputBytes = outputStream.ToArray();
}
}
}
}
Byte to bitmap ->
public BitmapImage ConvertBinaryToImage(byte[] array)
{
var image = new BitmapImage();
using (var ms = new MemoryStream(array))
{
image.BeginInit();
image.CacheOption = BitmapCacheOption.OnLoad; // here
image.StreamSource = ms;
image.EndInit();
image.Freeze();
}
return image;
}
When I open the WindowDragAndDrop it loads all the images
But when I close it it still uses the same amount of memory
Image is indeed disposable (https://learn.microsoft.com/en-us/dotnet/api/system.drawing.image?view=netframework-4.8), so you also need:
using (var image = Image.FromStream(inputStream)){
}
Around everywhere you use Image objects.
Since two days I try to manage my images in a WPF application but I have errors and errors errors, ...
The image is show in a System.Windows.Control.Image.
For this reason I try to work with variable BitMapImage.
Now I have the error : "Impossible to access close stream" and I can not find a solution.
I have created two function for convert :
public static BitmapImage ConvertToBitMapImage(byte[] bytes)
{
if (bytes == null || bytes.Length == 0) return null;
var image = new BitmapImage();
using (var mem = new MemoryStream(bytes))
{
mem.Position = 0;
image.BeginInit();
image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
image.CacheOption = BitmapCacheOption.OnLoad;
image.UriSource = null;
image.StreamSource = mem;
image.EndInit();
}
//image.Freeze();
return image;
}
public static byte[] ImageToByte(BitmapImage imageSource)
{
Stream stream = imageSource.StreamSource;
Byte[] buffer = null;
if (stream != null && stream.Length > 0)
{
using (BinaryReader br = new BinaryReader(stream))
{
buffer = br.ReadBytes((Int32)stream.Length);
}
}
return buffer;
}
In my object I have a property :
public BitmapImage MiniatureApp
{
get
{
if (IMAGES != null)
_MiniatureApp = Tools.BinaryImageConverter.ConvertToBitMapImage(IMAGES.IMAGE);
return _MiniatureApp;
}
set
{
if (this.IMAGES != null)
this.IMAGES.IMAGE = Tools.BinaryImageConverter.ImageToByte((BitmapImage)value);
else
{
IMAGES img = new IMAGES();
img.NOM = "";
img.IMAGE = Tools.BinaryImageConverter.ImageToByte((BitmapImage)value);
this.IMAGES = img;
}
NotifyPropertyChanged();
}
}
And in my main I do this :
FileStream fs = new FileStream(pathImage, FileMode.Open, FileAccess.Read);
byte[] data = new byte[fs.Length];
fs.Read(data, 0, System.Convert.ToInt32(fs.Length));
fs.Close();
VMAppareil.VMApp.CurrentAppareil.MiniatureApp = Tools.BinaryImageConverter.ConvertToBitMapImage(data);
Exist a solution for my problem or exist a best way to do this ?
Gobelet.
You can fix your solution replacing the ImageToByte method with the following (borrowed from https://stackoverflow.com/a/6597746/5574010)
public static byte[] ImageToByte(BitmapImage imageSource)
{
var encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(imageSource));
using (var ms = new MemoryStream())
{
encoder.Save(ms);
return ms.ToArray();
}
}
Your previous solution did not work because the ConvertToBitMapImage method close the stream that you assign to image.StreamSource as soon as your code exit the unit statement. When you call the ImageToByte method as part of the MiniatureApp setter the StreamSource will be close and you get an error.
I'm not really sure what you're doing with the getter-setter.
For getting a byte array from a file, I would have this:
public static byte[] FileToByteArray(string fileName)
{
byte[] fileData = null;
using (FileStream fs = new File.OpenRead(fileName))
{
var binaryReader = new BinaryReader(fs);
fileData = binaryReader.ReadBytes((int)fs.Length);
}
return fileData;
}
And once you have the bytes from that function, you can use ConvertToBitMapImage() and assign that to the Image.Source, like this:
byte[] bytes = FileToByteArray(fileName);
YourImage.Source = ConvertToBitMapImage(bytes);
I'm not sure why you would need to convert a BitmapImage into bytes, but you should be able to call your function directly for that:
BitmapImage bImg = new BitmapImage();
bImg.Source = ConvertToBitMapImage(bytes);
byte[] bytes = ImageToByte(bImg); // these should be the same bytes as went in
Set it up like this and step through the code to see where it snags. It's possible the bytes might need encoding when you grab it in ImageToByte().
But also, you don't just then set the byte[] directly to the IMAGES or this.IMAGES.IMAGE, because that isn't an Image object, it's a byte[]. Without knowing what your IMAGES model construct looks like with its property types, it's a little vague to know what is being set to what and why, but this seems like a bad idea to over-complicate what you should just do with function calls as it is needed, without a getter-setter and an IMAGES model in the way.
I have problem with converting BitmapImage to byte[]. I tried a lot of solutions and nothing works, every time i get different errors.
For example i found nice solutions but it also doesn't work. What's wrong with it?
I'm using Windows Phone 8.1.
public static byte[] ImageToBytes(BitmapImage img)
{
using (MemoryStream ms = new MemoryStream())
{
WriteableBitmap btmMap = new WriteableBitmap(img);
System.Windows.Media.Imaging.Extensions.SaveJpeg(btmMap, ms, img.PixelWidth, img.PixelHeight, 0, 100);
img = null;
return ms.ToArray();
}
}
this was taken from here: Convert Bitmap Image to byte array (Windows phone 8)
There is no argument given that corresponds to the required formal
parameter 'pixelHeight' of 'WriteableBitmap.WriteableBitmap(int, int)'
The type or namespace name 'Extensions' does not exist in the
namespace 'System.Windows.Media.Imaging' (are you missing an assembly
reference?)
or if somebody has got another idea how to convert it, please post it. Thanks a lot for any help!
I also tried this: BitmapImage to byte[]
but there was problem with usings
'BitmapImage' is an ambiguous reference between 'System.Windows.Media.Imaging.BitmapImage' and 'Windows.UI.Xaml.Media.Imaging.BitmapImage'
so I used "BitmapEncoder" but it doesn't have method like Save and Frame.
I think that it can't be done on this platform. I change my project to Windows Phone Silverlight/8.0 and there is working everything.
public static BitmapImage BytesToImage(byte[] bytes)
{
BitmapImage bitmapImage = new BitmapImage();
try
{
using (MemoryStream ms = new MemoryStream(bytes))
{
bitmapImage.SetSource(ms);
return bitmapImage;
}
}
finally { bitmapImage = null; }
}
public static byte[] ImageToBytes(BitmapImage img)
{
using (MemoryStream ms = new MemoryStream())
{
WriteableBitmap btmMap = new WriteableBitmap(img);
System.Windows.Media.Imaging.Extensions.SaveJpeg(btmMap, ms, img.PixelWidth, img.PixelHeight, 0, 100);
img = null;
return ms.ToArray();
}
}
see the below link it might help
https://social.msdn.microsoft.com/Forums/en-US/713c0ed1-d979-43ef-8857-bbe0b35576a9/windows-8-how-to-convert-bitmapimage-into-byte?forum=winappswithcsharp
Have you tried
MemoryStream ms = new MemoryStream();
WriteableBitmap wb = new WriteableBitmap(myImage);
wb.SaveJpeg(ms, myImage.PixelWidth, myImage.PixelHeight, 0, 100);
byte[] imageBytes = ms.ToArray();
You can also use extension method here
public static class MyExtensions
{
public static Byte[] ByteFromImage(this System.Windows.Media.Imaging.BitmapImage imageSource)
{
Stream stream = imageSource.StreamSource;
Byte[] imagebyte = null;
if (stream != null && stream.Length > 0)
{
using (BinaryReader br = new BinaryReader(stream))
{
imagebyte = br.ReadBytes((Int32)stream.Length);
}
}
return imagebyte;
}
}
and then call
System.Windows.Media.Imaging.BitmapImage myImage = new System.Windows.Media.Imaging.BitmapImage();
byte[] imageBytes = myImage.ByteFromImage();
If you're going to do any transformation on the image, you'll want to use the appropriate image encoder, then do something like below. If you're working with a multi-frame image (eg TIF), you need to add the frames one at a time to the encoder or you'll only get the first frame of the image.
MemoryStream ms = null;
TiffBitmapEncoder enc = null
enc = new TiffBitmapEncoder();
enc.Compression = TiffCompressOption.Ccitt4;
enc.Frames.Add(BitmapFrame.Create(bmpImg));
using (ms = new MemoryStream())
{
enc.Save(ms);
}
return ms.ToArray();
I receive a image/jpeg;base64 string from server.
How can I convert this string to BitmapImage and set like Image.Source ?
string imgStr = "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAAQABAAD .... ";
BitmapImage bmp = Base64StringToBitmap(imgStr);
myImage.Source = bmp;
Thanks in advance!
I find solution for my issue:
public static BitmapImage Base64StringToBitmap(string base64String)
{
byte[] byteBuffer = Convert.FromBase64String(base64String);
MemoryStream memoryStream = new MemoryStream(byteBuffer);
memoryStream.Position = 0;
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(memoryStream);
memoryStream.Close();
memoryStream = null;
byteBuffer = null;
return bitmapImage;
}