How to change byte array taken from json to image [duplicate] - javascript

I'm writing a web page in HTML/JavaScript. I'm downloading an image from my backend using AJAX. The image is represented as raw byte array, not an URL, so I can't use the standard <img src="{url}"> approach.
How do I display the mentioned image to the user?

Try putting this HTML snippet into your served document:
<img id="ItemPreview" src="">
Then, on JavaScript side, you can dynamically modify image's src attribute with so-called Data URL.
document.getElementById("ItemPreview").src = "data:image/png;base64," + yourByteArrayAsBase64;
Alternatively, using jQuery:
$('#ItemPreview').attr('src', `data:image/png;base64,${yourByteArrayAsBase64}`);
This assumes that your image is stored in PNG format, which is quite popular. If you use some other image format (e.g. JPEG), modify the MIME type ("image/..." part) in the URL accordingly.
Similar Questions:
Displaying a byte array as an image using JavaScript
Display bytes as images on an .aspx page
'data:image/jpg;base64' and jQuery image preview in Internet Explorer
Convert from binary data to an image control in ASP.NET
How to convert a byte array into an image?

Related

Modifying Images on Webpage with Web Extension

I am currently working on a web extension that goes through all the images in the current webpage and blurs them. I have created a backend API that accepts a base64 encoded string of an image and returns the encoded string for the blurred image. My current issue is that I can't find a way to access all the images on the current webpage and get their base64 encoded string through javascript. How can I do this?
The intended architecture of the extension is as follows: the javascript file reads all the images on the webpage and encodes them into a base64 string, which is passed to the backend API. The API then blurs the image and returns a base64 encoded string of the blurred image. The javascript then decodes the string and replaces the original image with the blurred image.
Any help would be greatly appreciated.
I have tried going through all the image tags in the html of the webpage and fetching their urls, however this does not allow me to get the base64 encoding of the image(s). I would like to write a function that takes in the url to an image and returns the base64 encoding.

How to embed a large image with data uri

I currently have a large base64 image uri (Received via external JS script) and want to embed it into the HTML page. I did this successfully locally but now that it pulls it from another place it seems to not work, it loads part of the image then says "Image corrupt or truncated. URI in this note truncated due to length." This occurs both just in the <img> tag and using <canvas>, is there any way to load large images from uri? Or another way to display images from a base64 string?
What doesn't make sense is it works fine if I specify the base64 string as a javascript variable, but when I include it as a variable in an external script, it gives this error. Would breaking up the string then putting it back together fix this?
You shouldn't use data-URLs for huge files.
You could try to convert your base64 URL into a blob object and the blob object into a temporary blob url using the following javascript function:
function dataurlToBlobUrl(url){
var parts = url.split(',',2);
var mime = parts[0].substr(5).split(';')[0];
var blob = b64toBlob(parts[1],mime);
return URL.createObjectURL(blob);
}
And the b64toBlob function from here:
https://stackoverflow.com/a/16245768/5406901
Just make sure to use "URL.revokeObjectURL" whenever you no longer need the blob url.

Encrypt a Base64 encoded image into another valid Base64 encoded image

I am wanting to take a currently base64 encoded image and use a short hash say "84dskh" to "encrypt" the image into another perfectly valid base64 encoded image.
The original image does not have to be base64 encoded, ultimately I want a encrypted image of the original, but have it still be a valid image I could display in a img tag: <img src="myimage" />.
Preferably using javascript.
To encrypt the image, you would save it as a string (there may be limits there), and then when loading the image into the HTML document, use a decrypt method. Here is a related question. You may also find this library helpful (suggested within an answer).

Base64 encoded image too large

I have image data in an arrayBuffer following an xmlHttpRequest. I need to display the image in an image tag. For most browsers I can use a blob to reference the binary data but I need to support mobile Safari on iOS 5.1 which has no support for blobs. My initial thought was to base64 encode the data and just set the src attribute on the image tag like so:
this.imageTag.src = 'data:image/jpeg;base64,' + base64EncodedImage;
However, in some instances the base64EncodedImage string is over 800,000 characters long and just crashes the browser.
What other method could I use to display the image (I only have access to the arrayBuffer data and can't make any server side changes easily)?

EXIF removed when image is converted to DataURL for local storage?

Is EXIF metadata removed/deleted when an image is converted to DataURL form so it can be stored in a browsers local storage? Specifically Chrome if it makes a difference.
When you convert any image to a data URL, you're just base64 encoding the binary stream of the image file. So, in short, no.
Edit: If you are specifically drawing an image to an HTML5 Canvas and then converting its data to a data URL with its toDataUrl method, of course EXIF data of the original image would be removed, because a Canvas instance doesn't use anything but the pixel data it contains and its pixel dimensions to generate that data url (if it uses anything else its isn't obvious to me). Any data URL generated wouldn't even necessarily look like one generated from the original file as as the files could be compressed differently, even when generating lossless PNGs.
It depends how you are doing the conversion. As long as you are just base64 encoding the entire image file, then all of the metadata will be preserved. However, if you use the canvas method (https://gist.github.com/1875132) of converting an image element then I believe you will only be storing the raw image data.

Categories