I'm trying to capture the screen and then convert it to a Base64 string. This is my code:
Rectangle bounds = Screen.GetBounds(Point.Empty);
Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
using (Graphics g = Graphics.FromImage(bitmap))
{
g.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
}
// Convert the image to byte[]
System.IO.MemoryStream stream = new System.IO.MemoryStream();
bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Bmp);
byte[] imageBytes = stream.ToArray();
// Write the bytes (as a string) to the textbox
richTextBox1.Text = System.Text.Encoding.UTF8.GetString(imageBytes);
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
Using a richTextBox to debug, it shows:
BM6�~
So for some reason the bytes aren't correct which causes the base64String to become null. Any idea what I'm doing wrong? Thanks.
I found a solution for my issue:
Bitmap bImage = newImage; // Your Bitmap Image
System.IO.MemoryStream ms = new MemoryStream();
bImage.Save(ms, ImageFormat.Jpeg);
byte[] byteImage = ms.ToArray();
var SigBase64= Convert.ToBase64String(byteImage); // Get Base64
The characters you get by doing System.Text.Encoding.UTF8.GetString(imageBytes) will (almost certainly) contain unprintable characters. This could cause you to only see those few characters. If you first convert it to a base64-string, then it will contain only printable characters and can be shown in a text box:
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
// Write the bytes (as a Base64 string) to the textbox
richTextBox1.Text = base64String;
No need for byte[] ...just convert the stream directly (w/using constructs)
using (var ms = new MemoryStream())
{
using (var bitmap = new Bitmap(newImage))
{
bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
var SigBase64= Convert.ToBase64String(ms.GetBuffer()); //Get Base64
}
}
Related
I have and image with a compression type of CCITT T.6 which is converted to base64 and sent to a backend API, where base64 string will be converted back to the original image and validate the file details. My problem is whenI convert the base64 string back to its original image, the compression type for the image has now changed to LZW. Does converting an image to a base64 string change its compression type? If so how can I keep the files original compression type.
string img = "";
using (Image image = Image.FromFile(filepath))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
img = base64String;
}
}
LoadImage(img);
public void LoadImage(string base64image)
{
byte[] bytes = Convert.FromBase64String(base64image);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
File.WriteAllBytes(filepath,bytes);
}
Getting rid of the memory stream and using Convert.ToBase64String(File.ReadAllBytes(filepath)) suggested by Steeeve seems to have solved the problem. Image Compression types are now consistent after regenerating the image from a base64 string.
In order to convert bitmap to base64 i have to convert my bitmap to Image
I get this message when i'm converting an image to memorystream as img.Save(ms, img.RawFormat); after casting my image from a screenshoot bitmap like Image img = (Image)bitmap; or Image img = bitmap as Image, but it's working fine when i use local stored image like Image img = Image.FromFile(Path).
how can i avoid this error while i don't want to store the screenshoot and read it again each time
this is the code i have tried
Image img = bitmap as Image;
using (MemoryStream ms = new MemoryStream())
{
img.Save(ms, img.RawFormat);
string base64 = Convert.ToBase64String(ms.ToArray());
}
Actually, you don't have to convert Bitmab to Image while you can encode your Bitmab with Base64 directly
try this:
using (MemoryStream ms = new MemoryStream())
{
bitmab.Save(ms, ImageFormat.Jpeg); // you can change your image format as you want
byte[] imageBytes = ms.ToArray();
string base64 = Convert.ToBase64String(imageBytes);
}
How can i get in c# an image as bitmapimage from an url and pass to it some headers? (not parameters, headers)
And also i found a simple solution but i couldn't understand why it was wrong, the problem is that:
WHen i get byte[] from the server i get the image with a lot of question marks, this appends i thinks because of a different text encoding, how can i fix the code so i can get successfully the image from c# with headers and visible to bitmap?
You have to convert your image into a base64 encoded string and pass it to the headers.
using (Image image = Image.FromFile(Path))
{
using (MemoryStream m = new MemoryStream())
{
image.Save(m, image.RawFormat);
byte[] imageBytes = m.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
Then on the other side you can parse it and convert it back to an image:
public Image LoadImage()
{
//data:image/png;base64,
byte[] bytes = Convert.FromBase64String(YOUR_BASE64_ENCODED_STRING);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
return image;
}
i am trying to convert image from base64 . When i run this code i get the error ArgumentException is unhandeled parameter is not valid . Below is my code
public void LoadImage()
{
string bytes = "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";
Base64ToImage(bytes);
}
public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
// Convert byte[] to Image
ms.Write(imageBytes, 0, imageBytes.Length);
Image image1 = Image.FromStream(ms, true); // here error is generating
return image1;
}
I think that this line is more than enough, because it will create memory stream with image bytes.:
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
So this one is not needed as all bytes are already in the stream:
ms.Write(imageBytes, 0, imageBytes.Length);
To position the stream at its start replace the previous line with seek call:
ms.Seek(0, SeekOrigin.Begin);
EDIT
Maybe it has something to do with string or the format used, because with image created in place it works well:
static public void LoadImage()
{
String bytes = CreateImageBase64();
Base64ToImage(bytes);
}
static public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
ms.Seek(0, SeekOrigin.Begin);
Image image1 = Image.FromStream(ms, true); // here error is generating
return image1;
}
static String CreateImageBase64()
{
//Create image
Image image = new Bitmap(3, 3);
//Save to stream
MemoryStream ms = new MemoryStream();
image.Save(ms, ImageFormat.Jpeg);
//Save to byte array
Byte[] imageBytes = new Byte[ms.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(imageBytes, 0, imageBytes.Length);
//Save to Base64
String base64Image = Convert.ToBase64String(imageBytes);
return base64Image;
}
...
LoadImage();
EDIT:
When I've used Encoding.ASCII.GetChars() on the array converted from Base64 string I got:
??\0sr\0*com.ups.ecis.core.shipments.ShipmentDigest\n^?2??\0 Z\0isABRReturnedinResponseZ\0isABRUserIneligibleZ\0isAIAZ\0isCN22NumberPresentZ\0isCN22RequestedZ\0isCombinedMIandLabe
It looks a bit strange for an image(of course if it does not contain enormous amounts of metadata). Maybe you can show the original xml. Who knows, the xml tag can be misnamed or misused.
Try This (If you want to set image directly to Image Control)
byte[] imageBytes = Convert.FromBase64String(base64string);
img.ImageUrl = "data:image/jpg;base64," + Convert.ToBase64String(imageBytes);
I am trying to convert a Base64String to an image which needs to be saved locally.
At the moment, my code is able to save the image but when I open the saved image, it says "Invalid Image".
Code:
try
{
using (var imageFile = new StreamWriter(filePath))
{
imageFile.Write(resizeImage.Content);
imageFile.Close();
}
}
The Content is a string object which contains the Base64 String.
First, convert the base 64 string to an Image, then use the Image.Save method.
To convert from base 64 string to Image:
public Image Base64ToImage(string base64String)
{
// Convert base 64 string to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
// Convert byte[] to Image
using (var ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
{
Image image = Image.FromStream(ms, true);
return image;
}
}
To convert from Image to base 64 string:
public string ImageToBase64(Image image,System.Drawing.Imaging.ImageFormat format)
{
using (MemoryStream ms = new MemoryStream())
{
// Convert Image to byte[]
image.Save(ms, format);
byte[] imageBytes = ms.ToArray();
// Convert byte[] to base 64 string
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
Finally, you can easily to call Image.Save(filePath); to save the image.
So with the code you have provided.
var bytes = Convert.FromBase64String(resizeImage.Content);
using (var imageFile = new FileStream(filePath, FileMode.Create))
{
imageFile.Write(bytes ,0, bytes.Length);
imageFile.Flush();
}
public Image Base64ToImage(string base64String)
{
// Convert Base64 String to byte[]
byte[] imageBytes = Convert.FromBase64String(base64String);
MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
// Convert byte[] to Image
ms.Write(imageBytes, 0, imageBytes.Length);
Image image = Image.FromStream(ms, true);
return image;
}
Front :
<Image Name="camImage"/>
Back:
public async void Base64ToImage(string base64String)
{
// read stream
var bytes = Convert.FromBase64String(base64String);
var image = bytes.AsBuffer().AsStream().AsRandomAccessStream();
// decode image
var decoder = await BitmapDecoder.CreateAsync(image);
image.Seek(0);
// create bitmap
var output = new WriteableBitmap((int)decoder.PixelHeight, (int)decoder.PixelWidth);
await output.SetSourceAsync(image);
camImage.Source = output;
}