I am trying to crop/resize user profile image using jquery plugin namely crop.js which sends user image as base64 via ajax to my controller as
$.ajax({
type: "post",
dataType: "json",
url: "${g.createLink(controller: 'personalDetail', action:'uploadUserImage')}",
data: { avatar: canvas.toDataURL() }
});
but I unable to decode this base64
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPAAAADwCAYAAAA+VemSAAAgAEl...=='
string as Image,Can you guys guide me how can I save my base64 string as image on my server?.
In the server, do something like this:
Suppose
String data = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPAAAADwCAYAAAA+VemSAAAgAEl...=='
Then:
String base64Image = data.split(",")[1];
byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(base64Image);
Then you can do whatever you like with the bytes like:
BufferedImage img = ImageIO.read(new ByteArrayInputStream(imageBytes));
This assumes a few things, that you know what the output file name will be and that your data comes as a string. I'm sure you can modify the following to meet your needs:
// Needed Imports
import java.io.ByteArrayInputStream;
import sun.misc.BASE64Decoder;
def sourceData = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPAAAADwCAYAAAA+VemSAAAgAEl...==';
// tokenize the data
def parts = sourceData.tokenize(",");
def imageString = parts[1];
// create a buffered image
BufferedImage image = null;
byte[] imageByte;
BASE64Decoder decoder = new BASE64Decoder();
imageByte = decoder.decodeBuffer(imageString);
ByteArrayInputStream bis = new ByteArrayInputStream(imageByte);
image = ImageIO.read(bis);
bis.close();
// write the image to a file
File outputfile = new File("image.png");
ImageIO.write(image, "png", outputfile);
Please note, this is just an example of what parts are involved. I haven't optimized this code at all and it's written off the top of my head.
ImageIO.write() will compress the image by default - the compressed image has a smaller size but looks strange sometimes. I use BufferedOutputStream to save the byte array data - this will keep the original image size.
Here is the code:
import javax.xml.bind.DatatypeConverter;
import java.io.*;
public class ImageTest {
public static void main(String[] args) {
String base64String = "data:image/jpeg;base64,iVBORw0KGgoAAAANSUhEUgAAAHkAAAB5C...";
String[] strings = base64String.split(",");
String extension;
switch (strings[0]) {//check image's extension
case "data:image/jpeg;base64":
extension = "jpeg";
break;
case "data:image/png;base64":
extension = "png";
break;
default://should write cases for more images types
extension = "jpg";
break;
}
//convert base64 string to binary data
byte[] data = DatatypeConverter.parseBase64Binary(strings[1]);
String path = "C:\\Users\\Ene\\Desktop\\test_image." + extension;
File file = new File(path);
try (OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(file))) {
outputStream.write(data);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Simplicity is:
import java.util.Base64;
To decode:
byte[] image = Base64.getDecoder().decode(base64string);
To encode:
String text = Base64.getEncoder().encodeToString(imageData);
Server side encoding files/Images to base64String ready for client side consumption
public Optional<String> InputStreamToBase64(Optional<InputStream> inputStream) throws IOException{
if (inputStream.isPresent()) {
ByteArrayOutputStream output = new ByteArrayOutputStream();
FileCopyUtils.copy(inputStream.get(), output);
//TODO retrieve content type from file, & replace png below with it
return Optional.ofNullable("data:image/png;base64," + DatatypeConverter.printBase64Binary(output.toByteArray()));
}
return Optional.empty();
}
Server side base64 Image/File decoder
public Optional<InputStream> Base64InputStream(Optional<String> base64String)throws IOException {
if (base64String.isPresent()) {
return Optional.ofNullable(new ByteArrayInputStream(DatatypeConverter.parseBase64Binary(base64String.get())));
}
return Optional.empty();
}
public Optional<String> InputStreamToBase64(Optional<InputStream> inputStream) throws IOException{
if (inputStream.isPresent()) {
ByteArrayOutputStream outpString base64Image = data.split(",")[1];
byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(base64Image);
Then you can do whatever you like with the bytes like:
BufferedImage img = ImageIO.read(new ByteArrayInputStream(imageBytes));ut = new ByteArrayOutputStream();
FileCopyUtils.copy(inputStream.get(), output);
//TODO retrieve content type from file, & replace png below with it
return Optional.ofNullable("data:image/png;base64," + DatatypeConverter.printBase64Binary(output.toByteArray()));
}
return Optional.empty();
Hi This is my solution
Javascript code
var base64before = document.querySelector('img').src;
var base64 = base64before.replace(/^data:image\/(png|jpg);base64,/, "");
var httpPost = new XMLHttpRequest();
var path = "your url";
var data = JSON.stringify(base64);
httpPost.open("POST", path, false);
// Set the content type of the request to json since that's what's being sent
httpPost.setRequestHeader('Content-Type', 'application/json');
httpPost.send(data);
This is my Java code.
public void saveImage(InputStream imageStream){
InputStream inStream = imageStream;
try {
String dataString = convertStreamToString(inStream);
byte[] imageBytes = javax.xml.bind.DatatypeConverter.parseBase64Binary(dataString);
BufferedImage image = ImageIO.read(new ByteArrayInputStream(imageBytes));
// write the image to a file
File outputfile = new File("/Users/paul/Desktop/testkey/myImage.png");
ImageIO.write(image, "png", outputfile);
}catch(Exception e) {
System.out.println(e.getStackTrace());
}
}
static String convertStreamToString(java.io.InputStream is) {
java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
return s.hasNext() ? s.next() : "";
}
This is Ayano's excellent answer, but in Clojure:
(:import (java.awt.image BufferedImage)
(javax.xml.bind DatatypeConverter)
(java.io File BufferedOutputStream FileOutputStream))
(defn write-svg-encountered-image [svg-img-data base-filename]
(let [[meta img-data] (str/split svg-img-data #",")
extension (case meta
"data:image/jpeg;base64" ".jpeg"
"data:image/png;base64" ".png"
(throw (Error. (format "Unrecognised image metadata in SVG:" meta))))
path (str base-filename extension)
file (File. path)
data-bytes (DatatypeConverter/parseBase64Binary img-data)
os (BufferedOutputStream. (FileOutputStream. file))]
(.write os data-bytes)))
To Convert all file types
String[] strings = expense.getAttchBase64().split(",");
String extension;
switch (strings[0]) {//check image's extension
case "data:image/jpeg;base64":
extension = "jpeg";
break;
case "data:image/png;base64":
extension = "png";
break;
case "data:application/pdf;base64":
extension = "pdf";
break;
case "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64":
extension = "docx";
break;
default://should write cases for more images types
extension = "jpg";
break;
}
//convert base64 string to binary data
byte[] data = DatatypeConverter.parseBase64Binary(strings[1]);
String fileName = UUID.randomUUID().toString();
String path = "C:\\floridatrading\\" + fileName + "." + extension;
File file = new File(path);
try (OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(file))) {
outputStream.write(data);
} catch (IOException e) {
e.printStackTrace();
}
if you need to add any new type just add It in switch .
Related
I'm trying to pull in JSON from a lambda, compress it to gzip format and upload to s3. I can do all of this except compress it to gzip. I have pulled various bit of code from here (S.O.) the first code but does not seem to work correctly. Here is what I have tried and the outcome:
this first method seems to make the file much smaller and is gzip format:
public void compressAndUpload(AmazonS3 s3, InputStream in) throws IOException {
Path tmpPath = Files.createTempFile("atest", ".json.gz");
OutputStream out = Files.newOutputStream(tmpPath);
GzipCompressorOutputStream gzOut = new GzipCompressorOutputStream(out);
IOUtils.copy(in, gzOut);
InputStream fileIn = Files.newInputStream(tmpPath);
long size = Files.size(tmpPath);
ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentType("application/x-gzip");
metadata.setContentLength(size);
s3.putObject(bucketName, "atest.json.gz", fileIn, metadata);
}
However, when I pull it to my local machine, but when I try to use 'gunzip' on it i get the following error message:
gzip: atest.json.gz: unexpected end of file
this next method when is not actually compressing the file and when i pull it down locally it says "not in gzip format"
public String handleRequest(Input input, Context context) {
try {
byte[] btArr = compress(input.getMessage());
ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentType("application/x-gzip");
metadata.setContentLength(btArr.length);
AmazonS3ClientBuilder.defaultClient().putObject(new PutObjectRequest(bucketName, "test22.json.gz",
new ByteArrayInputStream(btArr), metadata));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static byte[] compress(String str) throws Exception {
if (str == null || str.length() == 0) {
return null;
}
System.out.println("String length : " + str.length());
ByteArrayOutputStream obj=new ByteArrayOutputStream();
GzipCompressorOutputStream gzip = new GzipCompressorOutputStream(obj);
gzip.write(str.getBytes("UTF-8"));
gzip.flush(); <-------******Update: This was missing.. caused it to fail.
gzip.close();
return obj.toByteArray();
}
Am I missing a step here? I feel like this should be a fairly straight forward thing...
I am working on project where I have to download attachments that i receive from server. I have to exploit base64 data and convert it to the appropriate type and download it. It works for me perfectly with images ( base 64 => bytes => bitmap ) but I find troubles with other types ( txt , pdf ..etc )
try this
try {
File sdcard = Environment.getExternalStorageDirectory();
File file = new File(sdcard,"test.pdf");
File new_file_name = new File(sdcard,"new_file.pdf");
byte[] input_file = IOUtil.readFile(file);
byte[] encodedBytes = Base64.encode(input_file,URL_SAFE);
String encodedString = new String(encodedBytes);
byte[] decodedBytes = Base64.decode(encodedString.getBytes(),URL_SAFE);
FileOutputStream fos = new FileOutputStream(new_file_name);
fos.write(decodedBytes);
fos.flush();
fos.close();
}catch (Exception e)
{
Log.e("ERROR",e.toString());
}
And IOUtil class
public class IOUtil {
public static byte[] readFile(String file) throws IOException {
return readFile(new File(file));
}
public static byte[] readFile(File file) throws IOException {
// Open file
RandomAccessFile f = new RandomAccessFile(file, "r");
try {
// Get and check length
long longlength = f.length();
int length = (int) longlength;
if (length != longlength)
throw new IOException("File size >= 2 GB");
// Read file and return data
byte[] data = new byte[length];
f.readFully(data);
return data;
} finally {
f.close();
}
}
}
this code contain both encode and decode parts
I am trying to convert Base64 encoded string (from image) [link to convertor]. Here is how I do this: First I convert the string, which is:
String str =
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
like this:
byte[] imageString = str.getBytes("UTF-8");
and then I want to save the file on machine like this:
public boolean uploadImage(byte[] imageString, String name, String extension)
{
BufferedImage image = null;
String path = EVENT_FOLDER + name + "." + extension;
try
{
image = ImageIO.read(new ByteArrayInputStream(imageString)); //null returned here
ImageIO.write(image, extension, new File(path));
}
catch (IOException e)
{
e.printStackTrace();
return false;
}
But I am getting null on this line: image = ImageIO.read(new ByteArrayInputStream(imageString));
What did I do wrong??
What did I do wrong?
You ignored the fact that the data is Base64-encoded, not UTF-8.
To convert the string to bytes to get the original data, you need to reverse that Base64 encoding, for example using this library.
byte[] imageData = Base64.decode(str);
I have just been told to send the thumbnail of an image using data URI. I have been searching it but all I found was that its basically a textual representation of a file and can be directly used in HTML. I could not really find how to make a data URI in Java. I have an input stream of a file. Can someone please shed some light on it and point me to a way to generate this?
E.G. for an image:
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ImageIO.write(image, "png", baos);
} catch (IOException e) {
e.printStackTrace();
}
String imageString = "data:image/png;base64," +
Base64.getEncoder().encodeToString(bytes);
Example
Run the code below. If FF is the default browser, you might see something like this:
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import javax.imageio.ImageIO;
import java.util.Base64;
public class DataUriConverter {
static String getImageAsString(BufferedImage image) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// serialize the image
ImageIO.write(image, "png", baos);
// convert the written image to a byte[]
byte[] bytes = baos.toByteArray();
System.out.println("bytes.length " + bytes.length);
// THIS IS IT! Change the bytes to Base 64 Binary
String data = Base64.getEncoder().encodeToString(bytes);
// add the 'data URI prefix' before returning the image as string
return "data:image/png;base64," + data;
}
static BufferedImage getImage() {
int sz = 500;
BufferedImage image = new BufferedImage(
sz, sz, BufferedImage.TYPE_INT_ARGB);
// paint the image..
Graphics2D g = image.createGraphics();
g.setRenderingHint(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(new Color(0,0,255,63));
g.setStroke(new BasicStroke(1.5f));
for (int ii = 0; ii < sz; ii += 5) {
g.drawOval(ii, ii, sz - ii, sz - ii);
}
g.dispose();
return image;
}
public static void main(String[] args) throws Exception {
String imageString = getImageAsString(getImage());
String htmlFrag = "<html><body><img src='%1s'></body></html>";
String html = String.format(htmlFrag, imageString);
// write the HTML
File f = new File("image.html");
FileWriter fw = new FileWriter(f);
fw.write(html);
fw.flush();
fw.close();
// display the HTML
Desktop.getDesktop().open(f);
}
}
Here is my example.
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import javax.xml.bind.DatatypeConverter;
public class ToDataURI {
public static void main(String[] args) throws IOException {
// source file
File file = new File("movie.mp4");
// check content type of the file
String contentType = Files.probeContentType(file.toPath());
// read data as byte[]
byte[] data = Files.readAllBytes(file.toPath());
// convert byte[] to base64(java7)
String base64str = DatatypeConverter.printBase64Binary(data);
// convert byte[] to base64(java8)
// String base64str = Base64.getEncoder().encodeToString(data);
// cretate "data URI"
StringBuilder sb = new StringBuilder();
sb.append("data:");
sb.append(contentType);
sb.append(";base64,");
sb.append(base64str);
System.out.println(sb.toString());
}
}
Processing flow
Check file contentType
Read file data into byte[]
Convert byte[] data to base64
Create "data URI" format
You can get like
data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21p....
I'm trying to take a path of an image like:
"content://media/external/images/media/3"
and convert it into a base64 string.
Here is the code I have now:
public String ConvertandSetImagetoBase64(String imagePath) {
String base64 = null;
byte[] input = null;
try{
FileInputStream fd = new FileInputStream(imagePath);
Bitmap bmt = BitmapFactory.decodeFileDescriptor(fd.getFD());
try{
ByteArrayOutputStream stream = new ByteArrayOutputStream();
Bitmap tmp = ProfileActivity.scaleDownBitmap(bmt, 10, this);
tmp.compress(Bitmap.CompressFormat.JPEG, 10, stream);
input = stream.toByteArray();
base64 = Base64.encodeToString(input, Base64.DEFAULT);
//LocalProfileActivity.input = input;
}catch(Exception e){
Log.e(LOG_TAG,"[ONACTIVITYRESULT] Could not bind input to the bytearray: " + e.getMessage());
}
}
catch (Exception e){
Log.e("LocalProfile", "ConvertandSetImagetoBase64: Could not load selected profile image");
}
return base64;
}
content://media/external/images/media/3 is what I'm passing into the the method. Can anyone help me?
Since you are specifying the location as a URI, you could try something like:
URL url = new URL(imagePath);
Bitmap bmt = BitmapFactory.decodeStream(url.openStream());