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);
Related
When i try to convert a base64string to an Image in C#, I'm getting output as "System.Drawing.Bitmap" instead of the actual Image:
public Image DownFile(string base64String)//string file
{
//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);
image.Save("E:/Project Utilitie Connection/FileDownloadTask/Images", System.Drawing.Imaging.ImageFormat.Jpeg);
return image;
}
try a using statement for the MemoryStream, like so:
byte[] bytes = Convert.FromBase64String(base64String);
Image image;
using (MemoryStream ms = new MemoryStream(bytes))
{
image = Image.FromStream(ms);
}
return image;
The framework is converting the Image object to string which is why you are seeing System.Drawig.Bitmap
Create a response, giving it the bytes from the converted base64 string and then setting the content type for response so the client will know how to render the content.
public class ValuesController : ApiController {
[HttpGet]
public IHttpActionResult DownFile(string base64String) {
if (!string.IsNullOrWhiteSpace(base64String)) {
byte[] imageBytes = Convert.FromBase64String(base64String);
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new ByteArrayContent(imageBytes);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpg");
return ResponseMessage(response);
}
return BadRequest();
}
}
This is a very simplified example to demonstrate how it can be done. Take some time to review and understand what was done so that it can be implemented into your particular scenario.
This question already has answers here:
C# Base64 String to JPEG Image
(4 answers)
Closed 7 years ago.
As an example I have converted a canvas element with a re-sized image and posted into a hidden input field that's now encoded as
data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD...
This value then posted to the same page which I need to convert this string into an image and save onto the server.
Code Behind File (upload.aspx)
protected void btnUpload_Click(object sender, EventArgs e)
{
HttpPostedFile filePosted = Request.Files["newinput"];
string base64String = filePosted.ToString();
// 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);
System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
//I DONT KNOW HOW TO WRITE ABOVE INTO THE SaveAs CONDITION BELOW
if (filePosted != null && filePosted.ContentLength > 0)
{
string fileNameApplication = Path.GetFileName(filePosted.FileName);
string fileExtensionApplication = Path.GetExtension(fileNameApplication);
// generating a random guid for a new file at server for the uploaded file
string newFile = Guid.NewGuid().ToString() + fileExtensionApplication;
// getting a valid server path to save
string filePath = Path.Combine(Server.MapPath("~/Assets/") + Request.QueryString["id"] + "/", newFile);
if (fileNameApplication != String.Empty)
{
filePosted.SaveAs(filePath);
}
}
I'm pretty sure I need to convert this the imagedata to a binary file before saving on the server but I can't quite get how I need to amend the code above. Any ideas? The code to save to the server doesn't work.
Once I have converted this to an image and changed it's name as above - I'm storing this back to a database via LINQ - with a URL appended to it.
Any help would be greatly appreciated.
Hope below functions helps.
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 Base64 String
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
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;
}
EDIT 1 -
From the comments it seems that you are getting base64 string and you need to save it as image on server and then whenever required you need to show that image using physical server path.
Ok. Base64ToImage will give you image for your base64 string. You can save it on server using
image.Save("PATH", System.Drawing.Imaging.ImageFormat.Jpeg);
And this "PATH" you have supplied or created can be stored in DB as URL, which you can use at the time of display.
Note: Make sure that you have write access to folder where you are saving image.
EDIT-2
Your function should look like below. Please put validation code, error handling as required.
protected void btnUpload_Click(object sender, EventArgs e)
{
HttpPostedFile filePosted = Request.Files["newinput"];
string base64String = filePosted.ToString();
// 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);
System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
string newFile = Guid.NewGuid().ToString() + fileExtensionApplication;
string filePath = Path.Combine(Server.MapPath("~/Assets/") + Request.QueryString["id"] + "/", newFile);
image.Save(filepath,ImageFormat.Jpeg);
}
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;
}
I am able to convert image to base64 string and base64 string to image . And I am saving the image to a particular location. If I run for the first time, I am getting the correct image file which I gave as input. but from the second run, whatever may be the input image I pass, I am getting only the first input image.
Desired output :
I need to get back the input image that I passed.
conversion code :
public string ImageToBase64(Image image, ImageFormat format)
{
using (MemoryStream ms = new MemoryStream())
{
// Convert Image to byte[]
image.Save(ms, format);
byte[] imageBytes = ms.ToArray();
// Convert byte[] to Base64 String
string base64String = Convert.ToBase64String(imageBytes);
return base64String;
}
}
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;
}
save file code :
public void retreiveAndSaveImgFile(string base64formofstr)
{
Console.WriteLine("the incoming string :: " + base64formofstr.Length);
/* Bitmap bitmap = new Bitmap(Base64ToImage(base64formofstr));
Bitmap newBitmap = new Bitmap(bitmap);
newBitmap.SetResolution(150, 150); // resolution of the original image for which the zone template is created
newBitmap.Save("D:\\Suraya\\TesttogetCorrectPutput\\MICR_SAMPLE.tif", ImageFormat.Tiff);*/
Base64ToImage(base64formofstr).Save("D:\\Suraya\\TesttogetCorrectPutput\\MICR_SAMPLE.tif");
}
Please help me in resolving this problem.
I am not that smart with all of this but till I understand the problem you have is because of cache... As you are using the same name all time, it shows the output from the cache instead of conversion..
First Alternate is to add a time stamp to the name of image..
Second Alternate is to force the browser to reload the complete page instead of showing it from the cache..
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
}
}