I have an image content coming from Spring RestTemplate get result:
String url = "https://is2-ssl.mzstatic.com/image/" +
"thumb/Purple114/v4/15/a1/68/15a1681f-dec4-b01f-4362" +
"-e9ff1ece9c09/AppIcon-1x_U007emarketing-0-10-0-0-85" +
"-220-0.png/60x60bb.png";
String imageAsString = restTemplate.getForObject(url, String.class);
I know this is not a right way to fetch image by RestTemplate. But I should keep it for my old code.
How can I convert this value to right image byte array format?
imageAsString.getBytes() -> this is not the same with restTemplate.getForObject(url, byte[].class);
If you have an image URL, you can first read it into a BufferedImage and then write it to a FileOutputStream as follows:
public static void main(String[] args) throws IOException {
URL url = new URL("https://is2-ssl.mzstatic.com/image/" +
"thumb/Purple114/v4/15/a1/68/15a1681f-dec4-b01f-4362" +
"-e9ff1ece9c09/AppIcon-1x_U007emarketing-0-10-0-0-85" +
"-220-0.png/60x60bb.png");
BufferedImage bufferedImage = ImageIO.read(url);
ImageIO.write(bufferedImage, "png",
new FileOutputStream("resources/bufferedImage.png"));
}
Here is the image: bufferedImage.png
Related
for example, i have String like this:
data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHQAAAB0CAYAAABUmhYnAAAEd0lEQVR4Xu2c0ZLjIAwEk///6GzVvZlspWtWksNRnVcwiGmNwHaS5+v1ej38HKPAU6DHsPy3EIGexVOgh/EUqEBPU+Cw9biHCvQwBQ5bjg4V6GEKHLYcHSrQwxQ4bDk6VKCHKXDYcnSoQA9T4LDllB36fD5vlWR9fUvz0+ve9fp0/O7FU7w0n0CXhBSoDiXTRO06FBKKBLLkLvlGgkTp+UvndPzu/ul46Xq7x2/fQ8kR0wtOBaL+1J6uZ+3fPb5Aw0PRtxOWEkigAr3mCJUMuk9cM45uG3ZvJwel8dN4byW8+r1cgWYPVgRaLIlpwqWCT1cgHbr8skOgYUqkgtHwVYfQKZTiTW8rdCgQFWjtt2Pjty3TGdztOB0aHlosuVcHpglJ+h3nUFow7bE6dDOHCjRN2fBty917qEAF+jEHaI+bTlhK0Nsf/aUBpXtYdXy6noDS9dTePf74oYgWRO3dC6b57k6o7vUJFAh3Cz6dMAIV6FWB9FCQlry1f/ejQXLgt9eX6tXu0DSAtL9APysm0OYHI2mCUgVKxxOoQNOcubc/7XnF5yj3LuYPs5Ud+oc5Ry8R6GEpK1CBjlaMuwcvl1xyBC2I8im9T0xva6pPbtL1V+MjPQW6KEQJRAlAggs0vK2oCibQ4g9+LbnXb96THlQBvl5y0yclqYNQAKgAVGIJQHWPpfjf4uv+bUsagECvClCCkL46VIdecyQtKZRhlKGW3OG3LekeQ0DSBOk+1VLCdbdTAqfzlUuuQFPJe/fM9kORQAV6UYBKJslF11NJS0s8xZO2U3zpeO0lNw2g2+HV8dLbKJov1aMKWKDFfyITKKRsegqmjE7H06FpTRHoRwUoQUnu9pJLh4z0EFMdjwRI46ESWwVC8VK7QMN/TRHookDqCB1Knry261AdmmXMdG86xabzd49H83fP1+5QWkB3e7sg4eu06nra46++4K4uqHp9uyACrSKpXS/Q5kMRnUJruN6vnr7Po/VMn9KrepX3UBKgGmD1UVw6P61HoKmi0F+HfhZIhy766NDhU2F66CEgzQXjQRUjjb8aX7tDaYFpwKkgAi0SSAUXaO0Pjkk/HUoKFQ9p0wm/hjcONC2B6W3B24KKv1ZLx0vzgfQoFsyHQJe3LQINHUEZrUNre6wO1aHLw+AvO5QOHdReLbE0/vSeedyhKBWUDh00XpoAAg2/EkIAqD0FlPYXqEDp3Pix/b8/FKUOIMem7fR6j8Yr0fvlYoEWK4JAw0dplOE6dLnrqH5JrCp4NcMFejPQ6h7RnTAUT/eTKkpYiidtH99D04C6bwvS+QX65W8sUMkVaKgAlcRwuLfuNL5Ah/fQKkC6Pi2JKXB6NEjxUTslKF1P7e17KE1YbRfoZwUFuuijQ4v/l5s6VocOOzQFYv9ZBcoldzY8R08VEGiq2Ob9Bbo5oDQ8gaaKbd5foJsDSsMTaKrY5v0FujmgNDyBpopt3l+gmwNKwxNoqtjm/QW6OaA0PIGmim3eX6CbA0rDE2iq2Ob9Bbo5oDS8H8eCMw7yCzx+AAAAAElFTkSuQmCC
i want to convert it back to an image file. here's what i've tried:
public void dumpFromRawData(String rawData, String wheretoPut) throws Exception{
byte[] imageByte = rawData.getBytes();
BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(imageByte));
File file = new File(wheretoPut);
ImageIO.write(bufferedImage, "png", file);
}
where rawData is the example string above, and wheretoPut is the new image directory.. for example D:\\image.png
but when i run it, it gives me this:
Exception in thread "main" java.lang.IllegalArgumentException: image == null!
at javax.imageio.ImageTypeSpecifier.createFromRenderedImage(ImageTypeSpecifier.java:925)
at javax.imageio.ImageIO.getWriter(ImageIO.java:1592)
at javax.imageio.ImageIO.write(ImageIO.java:1520)
how could i resolve this? or is this not the correct way to convert it back to image?
The data of your image seems to be base64 encoded so you can not just convert this string into a byte array.
So you should use something like:
byte[] imageByte = Base64.decode(rawData, Base64.DEFAULT);
i finally found the solution. Thans #Chris623 for enlightening me :D
first, i need to separate the 'header' of the string file.. the data:image/png;base64, string, and then decode it to byte[]
String separator = ",";
String encoded = rawData.split(separator)[1];
byte[] decodedByte = Base64.getDecoder().decode(encoded.getBytes(StandardCharsets.UTF_8));
and then the rest of process is still the same.. the full method looks like this:
public void dumpFromRawData(String rawData, String wheretoPut, String fileName) throws Exception{
String separator = ",";
if(rawData.contains(separator)) {
// use this when the decoded string contains "," separator, like data:image/png;base64,
String encoded = rawData.split(separator)[1];
byte[] decodedByte = Base64.getDecoder().decode(encoded.getBytes(StandardCharsets.UTF_8));
// you can use this
// Path destinationFile = Paths.get(wheretoPut, fileName);
// Files.write(destinationFile, decodedByte);
// or this
BufferedImage bufferedImage = ImageIO.read(new ByteArrayInputStream(decodedByte));
File file = new File(wheretoPut+fileName);
ImageIO.write(bufferedImage, "png", file);
System.out.println("File has been Written as " + wheretoPut + fileName);
} else {
System.out.println("i haven't think about it yet.");
}
}
I need to crop an image from the web (via its url) and return an InputStream (which can be uploaded to AWS S3). I am using org.imgscalr as the library and have the following method:
public InputStream cropFile(String url) throws Exception, IOException {
BufferedImage original = ImageIO.read(new URL(url));
BufferedImage target = null;
// resize based on http://www.htmlgoodies.com/beyond/java/create-high-quality-thumbnails-using-the-imgscalr-library.html
target = Scalr.crop(original, 410, 60, 200, 300, Scalr.OP_ANTIALIAS);
InputStream is = (InputStream) ImageIO.createImageInputStream(target);
Assert.assertNotNull(is);// it always returns null!!!
return is;
}
I call the method with something like:
InputStream is = cropFile("http://fengyuanchen.github.io/cropperjs/img/picture.jpg");
and then try to upload it to AWS S3:
PutObjectRequest request = new PutObjectRequest(AWSConfig.getBucket(), key, is, meta);
s3.putObject(request);
Unfortunately, I keep getting a null input stream (at the assert point above). If I change the createImage to:
ImageIO.write(target, "jpg", new File("c:\\dest.jpg"));
Then a proper image is written (so it works).
I'm trying to crop an image received from a form upload. Before I crop it I save it, then I retrieve it again as a BufferedImage (because I don't know how to turn a part into a buffered Image). I then crop this image, but when I try to save it again I get a java.io.FileNotFoundException (access denied)
The first image gets saved correctly, I get the exception when I try to pull it back.
Is it possible to turn my part into a buffered image and then save it? Instead of doing double work. or else is there some fix to my below code.
String savePath = "path";
File fileSaveDir = new File(savePath);
if (!fileSaveDir.exists()) {
fileSaveDir.mkdir();
}
for (Part part : request.getParts()) {
//functionality to ormit non images
String fileName = extractFileName(part);
part.write(savePath + "/" + fileName);
String imagePath = savePath + "/" + fileName;
BufferedImage img = null;
try {
img = ImageIO.read(new File(imagePath));
img = img.getSubimage(0, 0, 55, 55);
ImageIO.write(img, "jpg", fileSaveDir);
} catch (IOException e) {
System.out.println(e);
}
}
ImageIO.write((RenderedImage im, String formatName, File output));
Parameters:
im a RenderedImage to be written.
formatName a String containg the informal name of the format.
output a File to be written to.
As per documentation output file parameter is the file object where it would be image written where you have passed the parent directory file object.
I'm trying to access an image located inside of a running jar.
Here is my code:
Image image = Toolkit.getDefaultToolkit().getImage(
getClass().getResource("/res/sprites/"));
The code above works absolutely fine.
The problem I'm having is a is converting it into a readable String to be used by a BufferedImage objet.
Here is my code: (pathRelativeToThis is a String)
Image path = Toolkit.getDefaultToolkit().getImage(
getClass().getResource("/res/sprites/" + pathRelativeToThis));
String image = "file://" + path.toString();
URL url = new URL(image);
BufferedImage img = ImageIO.read(url);
This doesn't work and gives javax.imageio.IIOException: Can't get input stream from URL! as an error.
What is the correct way to do this?
You can do it like this and work with stream directly:
InputStream is = getClass().getResourceAsStream("/res/sprites/" + pathRelativeToThis);
BufferedImage img = ImageIO.read(is);
is.close();
Also have you tried to pass resource URL to ImageIO directly?
URL url = getClass().getResource("/res/sprites/" + pathRelativeToThis)
BufferedImage img = ImageIO.read(url);
Remove path and just try to do this
String image = "file://" + getClass().getResource("/res/sprites/" + pathRelativeToThis);
URL url = new URL(image);
BufferedImage img = ImageIO.read(url);
I want to pass an image (screenshot of a graph) from Flex to Java over BlazeDS. The goal is that the image will be stored on the serverside.
This is my Flex routine (called after clicking a button):
protected function btn_clickHandler(event:MouseEvent):void
{
var snapshot:ImageSnapshot = ImageSnapshot.captureImage(graphViewStack.selectedChild,);
var balanceSheetImage:String = ImageSnapshot.encodeImageAsBase64(snapshot);
//Testing the image
var base64Dec:Base64Decoder = new Base64Decoder();
base64Dec.decode(balanceSheetImage);
generatedImage.load(base64Dec.toByteArray());
}
In the 'generatedImage', the image is shown, so I assume this routine works.
Now I want to decode the balanceSheetImage in Java. For this reason, I created following Java code. The value contains the string in the generatedImage, which I copy/pasted from the flex code.
import sun.misc.BASE64Decoder;
public static int createPdf() throws IOException{
String value= "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";
BASE64Decoder decoder = new BASE64Decoder();
byte[] imgBytes = decoder.decodeBuffer(value);
ByteArrayInputStream str = new ByteArrayInputStream(imgBytes);
BufferedImage bufImg = ImageIO.read(str);
File imgOutFile = new File("newLabel.png");
ImageIO.write(bufImg, "png", imgOutFile);
return -1;
}
Unfortunately, this does not work. In particular: BufferedImage is always null. Has anyone a clue why this happens?