I was making an application that hides data in LSBs of a JPEG image. Knowing that JPEG is a lossy compression and has a default compression of 70%, I changed it's parameters to 100% thus assuming that it wont destroy any data in the image. Here is the code.
File output = new File(gui.getOutput()+".jpg");
ImageWriter jpgWriter = ImageIO.getImageWritersByFormatName("jpg").next();
ImageWriteParam jpgWriteParam = jpgWriter.getDefaultWriteParam();
jpgWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
jpgWriteParam.setCompressionQuality(1f);
FileImageOutputStream outputStream = new FileImageOutputStream(output);
jpgWriter.setOutput(outputStream);
IIOImage outputImage = new IIOImage(image, null, null);
jpgWriter.write(null, outputImage, jpgWriteParam);
jpgWriter.dispose();
The image that was created was indeed loss less, but the data I stored within the pixels were destroyed. (I checked it by reading the inserted data in the LSB and it wasn't the data I stored in the image).
What should I do to avoid the data being destroyed?
A must read api, and it only applies to quantization step
Related
I want to compress(reduce) image size using Java. We can upload images in jpg/jpeg/png formats. The general format of images is PNG. So, after image uploaded to the server, we need to compress(reduce file size) and convert it to PNG.
I have the next code for the compress image:
BufferedImage bufferedImage = ImageIO.read(inputStream);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
switch (imageType) {
case PNG:
case JPG:
// need Java 9+ for PNG writer support
ImageWriter writer = ImageIO.getImageWritersByFormatName(imageType.getExtension()).next();
ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
writer.setOutput(ios);
ImageWriteParam param = writer.getDefaultWriteParam();
if (param.canWriteCompressed()) {
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(0.3f);
}
writer.write(null, new IIOImage(bufferedImage, null, null), param);
writer.dispose();
return new ByteArrayInputStream(outputStream.toByteArray());
default:
log.warn("Image type unknown");
return null;
}
The problem is - after processing the image, I got the result - file size increased instead of reducing. The original image has a lower size than compressed.
Any suggestions on how to solve this issue?
Unfortunately the lossy JPEG compression compresses far better than the lossless PNG compression. You could restrict width and height of the image and scale proportionally.
So I would switch to JPEG and restrict the size.
As a solution for this problem I can recommend the API of TinyPNG.
You can use it for compressing as well as resizing the image.
It works for both .jpeg and .png.
Documentation: tinypng.com/developers/reference/java
I'm working on a project in which I have to get image from camera (cmucam4) which is connected to my computer with Xbee.
The probleme is that I can get the image data over the serial port, but when I save it as a file, the file can't be openned as image.
I noticed that when I open the file with notepad++, the file does not have a header like other images (the camera send bmp image).
I tried to save the Image using ImageIO, but I dont know how to pass the data recived to the image!!
BufferedImage img = new BufferedImage(640, 480,BufferedImage.TYPE_INT_RGB);
ImageIO.write(img, "BMP", new File("img/tmp.bmp"));
If the camera truly sends BMP format, you could just write the data to disk. However, more likely (and this seems to be the case, reading the specs from your link), the cards sends a raw bitmap, which is not the same.
Using this info from the card spec PDF:
Raw image dumps over serial or to flash card
(640:320:160:80)x(480:240:120:60) image resolution
RGB565/YUV655 color space
The RGB565 pixel layout mentioned above should match perfectly with the BufferedImage.TYPE_USHORT_565_RGB, so that should be the easiest to use.
byte[] bytes = ... // read from serial port
ShortBuffer buffer = ByteBuffer.wrap(bytes)
.order(ByteOrder.BIG_ENDIAN) // Or LITTLE_ENDIAN depending on the spec of the card
.asShortBuffer(); // Our data will be 16 bit unsigned shorts
// Create an image matching the pixel layout from the card
BufferedImage img = new BufferedImage(640, 480, BufferedImage.TYPE_USHORT_565_RGB);
// Get the pixel data from the image, and copy the data from the card into it
// (the cast here is safe, as we know this will be the case for TYPE_USHORT_565_RGB)
short[] data = ((DataBufferUShort) img.getRaster().getDataBuffer()).getData();
buffer.get(data);
// Finally, write it out as a proper BMP file
ImageIO.write(img, "BMP", new File("temp.bmp"));
PS: The above code works for me, using a byte array of length 640 * 480 * 2, initialised with random data (as I obviously don't have such a card).
I am trying to insert a 1 MB image inside neo4j using the following code:
File fnew = new File("C:\\Users\\myimage.jpg");
BufferedImage originalImage = ImageIO.read(fnew);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.flus();
ImageIO.write(originalImage, "jpg", baos);
return baos.toByteArray();
Then I insert this byte array using:
user.setProperty("photo", photo);
This all goes fine. When I try to select the photo, using the following method, it writes it on my hard drive disk as 536KB instead of the 1 MB original size.
byte[] imageInByte = (byte[]) user.getProperty("photo");
InputStream in = new ByteArrayInputStream(imageInByte);
BufferedImage bImageFromConvert = ImageIO.read(in);
ImageIO.write(bImageFromConvert, "jpg", new File("C:\\newimage.jpg"));
Now the weird part: I can see the image, open it, same resolution, I don't see any difference in terms of quality though. Looks like it is compressed.
Why is this happening?
Saving a jpg image through ImageIO results in lossy compression of the jpg (I believe the quality defaults to 70%). You can a) Change the the quality of the image when you write to file (see Setting jpg compression level with ImageIO in Java ) or b) if you don't actually need the BufferedImage, just read/write the bytes from file to database.
I am currently working with Image processing in Java. Initially I used ImageIO class to write images
ImageIO.write(image,"jpg",os);
the problem with this method is am lossing the actual image size and quality. Then I preferred ByteStream
Files.readAllBytes(fi.toPath());
to read and
fos.write(fileContent);
to write Images. This works perfectly. The issue I am facing here is I can read only files but not Images(ie, BuffreredImage image). Is it possible to read a Image rather than files here or should I move to someother IO?
Code Snippet is here,
try {
File fnew=new File("d:\\3\\IMG1.jpg");
java.io.FileOutputStream fos = new java.io.FileOutputStream(new File("d:\\3\\Test1\\4.jpg"));
File fi = new File("d:\\3\\7.jpg");
byte[] fileContent = Files.readAllBytes(fi.toPath());
fos.write(fileContent);
} catch (Exception e) {
System.out.println("Exception");
}
Any Kind of suggestions or help will be appreciated. Thanks in Advance.
the problem with this method is am lossing the actual image size and quality. Then I preferred ByteStream
When you read a JPEG with with ImageIO, it is converting the JPEG to a Bitmap automatically. Then when you write it, it is encoding to a JPEG again (which loses quality).
Just replace ImageIO.write(image,"jpg",os) with ImageIO.write(image,"png",os) and you are done. A lossless format such as PNG will not lose any data when you write the image.
BufferedImage getRGB() will get you all the actual pixel data for the image. There will be no compression or anything like JPEG. It will be the raw image.
Edited to add an example based on my comments...
BufferedImage image = ImageIO.read(new File("google.jpg"));
ImageWriter w = ImageIO.getImageWritersBySuffix("jpg").next();
ImageOutputStream out = ImageIO.createImageOutputStream(new File("output.jpg"));
w.setOutput(out);
ImageWriteParam param = new JPEGImageWriteParam(Locale.getDefault());
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(1);
w.write(null, new IIOImage(image, null, null), param);
out.close();
I was given the following code, and Eclipse marked it (at the JPEGImageEncoder line) as an error (Access restriction). I changed Eclipse options to make that code compile, but I read that the error means that that class (JPEGImageEncoder) may not be implemented by some JRE implementation (not a Sun/Oracle one).
So, what should be the code that wouldn't have access restrictions, i.e. completely safe code to do the same thing (create a JPG image)?
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(filename));
JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(out);
JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(buffImage);
param.setQuality(0.8f, false);
encoder.encode(buffImage, param);
Maybe I've misunderstood, but if all you're looking to do is save a BufferedImage object as a jpeg, you can do this (from Java 1.4 onwards):
ImageIO.write(bufferedImage,"jpg",file);
Here's a link with more information: http://download.oracle.com/javase/tutorial/2d/images/saveimage.html
As you can see, it says that JPEG, PNG, GIF, BMP and WBMP will always be supported.
If you want to set the compression/quality, it's a little more work but not too much. Assuming you have a bufferedImage and an outFile:
IIOImage outputImage = new IIOImage(bufferedImage, null, null);
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
writer.setOutput(new FileImageOutputStream(outFile));
ImageWriteParam writeParam = writer.getDefaultWriteParam();
writeParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
writeParam.setCompressionQuality(.75f); // float between 0 and 1, 1 for max quality.
writer.write( null, outputImage, writeParam);
(fixed from previous answer)