public static byte[] compress(BufferedImage image, float scale) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg"); ImageWriter writer = writers.next(); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(scale); ImageOutputStream ios = ImageIO.createImageOutputStream(baos); writer.setOutput(ios); writer.write(null, new IIOImage(image, null, null), param); byte[] data = baos.toByteArray(); writer.dispose(); return data; }
protected File writeImageWithHist(BufferedImage bi) throws IOException { File f = File.createTempFile("hist_", ".png", new File(".")); ImageWriter writer = ImageIO.getImageWritersByFormatName("PNG").next(); ImageOutputStream ios = ImageIO.createImageOutputStream(f); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); ImageTypeSpecifier type = new ImageTypeSpecifier(bi); IIOMetadata imgMetadata = writer.getDefaultImageMetadata(type, param); /* add hIST node to image metadata */ imgMetadata = upgradeMetadata(imgMetadata, bi); IIOImage iio_img = new IIOImage(bi, null, // no thumbnails imgMetadata); writer.write(iio_img); ios.flush(); ios.close(); return f; }
public void write(IIOMetadata sm, IIOImage iioimage, ImageWriteParam p) throws IOException { if (stream == null) { throw new IllegalStateException("output == null!"); } if (iioimage == null) { throw new IllegalArgumentException("iioimage == null!"); } if (iioimage.hasRaster()) { throw new UnsupportedOperationException("canWriteRasters() == false!"); } resetLocal(); GIFWritableStreamMetadata streamMetadata; if (sm == null) { streamMetadata = (GIFWritableStreamMetadata)getDefaultStreamMetadata(p); } else { streamMetadata = (GIFWritableStreamMetadata)convertStreamMetadata(sm, p); } write(true, true, streamMetadata, iioimage, p); }
public void prepareInsertEmpty(int imageIndex, ImageTypeSpecifier imageType, int width, int height, IIOMetadata imageMetadata, List<? extends BufferedImage> thumbnails, ImageWriteParam param) throws IOException { checkParamsEmpty(imageType, width, height, thumbnails); this.isInsertingEmpty = true; SampleModel emptySM = imageType.getSampleModel(); RenderedImage emptyImage = new EmptyImage(0, 0, width, height, 0, 0, emptySM.getWidth(), emptySM.getHeight(), emptySM, imageType.getColorModel()); insert(imageIndex, new IIOImage(emptyImage, null, imageMetadata), param, false); }
@Override public void write(IIOMetadata streamMetadata, IIOImage image, ImageWriteParam param) throws IOException { RenderedImage img = image.getRenderedImage(); if (stream == null) { throw new IOException("Set an output first!"); } if (param == null) { param = getDefaultWriteParam(); } Rectangle sourceRegion = new Rectangle(0, 0, img.getWidth(), img.getHeight()); if (param.getSourceRegion() != null) { sourceRegion = sourceRegion.intersection(param.getSourceRegion()); } Raster raster = img.getData(sourceRegion); int quality = 85; if (param.getCompressionMode() == ImageWriteParam.MODE_EXPLICIT) { quality = (int) (param.getCompressionQuality() * 100); } try { stream.write(lib.encode(raster, quality).array()); } catch (TurboJpegException e) { throw new IOException(e); } }
/** * Encodes an image in JPEG format and writes it to an output stream. * * @param bufferedImage the image to be encoded ({@code null} not * permitted). * @param outputStream the OutputStream to write the encoded image to * ({@code null} not permitted). * * @throws IOException if there is an I/O problem. * @throws NullPointerException if {@code bufferedImage} is {@code null}. */ @Override public void encode(BufferedImage bufferedImage, OutputStream outputStream) throws IOException { Args.nullNotPermitted(bufferedImage, "bufferedImage"); Args.nullNotPermitted(outputStream, "outputStream"); Iterator iterator = ImageIO.getImageWritersByFormatName("jpeg"); ImageWriter writer = (ImageWriter) iterator.next(); ImageWriteParam p = writer.getDefaultWriteParam(); p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); p.setCompressionQuality(this.quality); ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream); writer.setOutput(ios); writer.write(null, new IIOImage(bufferedImage, null, null), p); ios.flush(); writer.dispose(); ios.close(); }
public static void saveImage(final String fileName, final BufferedImage image, ImageFormat imageFormat) { try { final File file = new File(fileName); final String extension = FileUtilities.getExtension(fileName); Iterator<ImageWriter> iter = null; if (canWriteFormat(extension)) { iter = ImageIO.getImageWritersByFormatName(extension); } else { iter = ImageIO.getImageWritersByFormatName(imageFormat.toString()); } final ImageWriter writer = iter.next(); final ImageWriteParam iwp = writer.getDefaultWriteParam(); file.getParentFile().mkdirs(); try (final FileImageOutputStream output = new FileImageOutputStream(file.getAbsoluteFile())) { writer.setOutput(output); final IIOImage outimage = new IIOImage(image, null, null); writer.write(null, outimage, iwp); writer.dispose(); } } catch (final IOException e) { log.log(Level.SEVERE, e.getMessage(), e); } }
/** * Writes a buffered image to a TIFF output stream. * @param image buffered image to write out as a TIFF * @param output output stream to write to * @throws IOException If there is an error writing to * <code>output</code>. */ private void writeTiff(BufferedImage image, OutputStream output) throws IOException { try (ImageOutputStream ios = ImageIO.createImageOutputStream(output)) { IIORegistry registry = IIORegistry.getDefaultInstance(); registry.registerServiceProviders( ServiceRegistry.lookupProviders( TIFFImageWriterSpi.class)); TIFFImageWriterSpi spi = registry.getServiceProviderByClass( TIFFImageWriterSpi.class); TIFFImageWriter writer = new TIFFImageWriter(spi); writer.setOutput(ios); writer.write(null, new IIOImage(image, null, null), null); } }
public static void writeJPG( BufferedImage rendered, float quality, File f ) { try { JPEGImageWriteParam jpegParams = new JPEGImageWriteParam( null ); jpegParams.setCompressionMode( ImageWriteParam.MODE_EXPLICIT ); jpegParams.setCompressionQuality( 1f ); ImageWriter writer = ImageIO.getImageWritersByFormatName( "jpeg" ).next(); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode( ImageWriteParam.MODE_EXPLICIT ); // Needed see javadoc param.setCompressionQuality( quality ); // Highest quality writer.setOutput( new FileImageOutputStream( f ) ); writer.write( null, new IIOImage( rendered, null, null ), jpegParams ); } catch ( Throwable th ) { th.printStackTrace(); } }
/** * Create the gif and clear down afterwards. * * @return the gif byte data * @throws IOException if the output fails */ public byte[] createGif() throws IOException { try { ImageOutputStream ios = ImageIO.createImageOutputStream(baos); // N.b. not try with closure because we need to close the stream before returning ImageWriter iw = ImageIO.getImageWritersByFormatName("gif").next(); iw.setOutput(ios); iw.prepareWriteSequence(null); int index = 0; ImageWriteParam iwp = iw.getDefaultWriteParam(); String frameDelay = String.valueOf(OptionsObject.getInstance().getGifDisplayTimeMillis() / 10L); log.debug("Frames size: {}, Free memory {}", frames.size(), Runtime.getRuntime().freeMemory()); for (BufferedImage frame : frames) { IIOMetadata metadata = iw.getDefaultImageMetadata(new ImageTypeSpecifier(frame), iwp); configureMetaData(metadata, frameDelay, index++); iw.writeToSequence(new IIOImage(frame, null, metadata), null); } iw.endWriteSequence(); ios.close(); return baos.toByteArray(); } finally { baos = null; frames = null; } }
public void writeToSequence(IIOImage image, ImageWriteParam param) throws IOException { if (stream == null) { throw new IllegalStateException("output == null!"); } if (image == null) { throw new IllegalArgumentException("image == null!"); } if (image.hasRaster()) { throw new UnsupportedOperationException("canWriteRasters() == false!"); } if (!isWritingSequence) { throw new IllegalStateException("prepareWriteSequence() was not invoked!"); } write(!wroteSequenceHeader, false, theStreamMetadata, image, param); if (!wroteSequenceHeader) { wroteSequenceHeader = true; } this.imageIndex++; }
/** * Encodes an image in JPEG format and writes it to an output stream. * * @param bufferedImage the image to be encoded (<code>null</code> not * permitted). * @param outputStream the OutputStream to write the encoded image to * (<code>null</code> not permitted). * * @throws IOException if there is an I/O problem. * @throws NullPointerException if <code>bufferedImage</code> is * <code>null</code>. */ public void encode(BufferedImage bufferedImage, OutputStream outputStream) throws IOException { if (bufferedImage == null) { throw new IllegalArgumentException("Null 'image' argument."); } if (outputStream == null) { throw new IllegalArgumentException("Null 'outputStream' argument."); } Iterator iterator = ImageIO.getImageWritersByFormatName("jpeg"); ImageWriter writer = (ImageWriter) iterator.next(); ImageWriteParam p = writer.getDefaultWriteParam(); p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); p.setCompressionQuality(this.quality); ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream); writer.setOutput(ios); writer.write(null, new IIOImage(bufferedImage, null, null), p); ios.flush(); writer.dispose(); ios.close(); }
private static Image createTestImage() throws IOException { BufferedImage frame1 = createFrame(new int[] { 0xffff0000, 0xffff0000 }); BufferedImage frame2 = createFrame(new int[] { 0xff0000ff, 0xffff0000 }); ImageWriter writer = ImageIO.getImageWritersByFormatName("GIF").next(); ImageOutputStream ios = ImageIO.createImageOutputStream(new File("lut_test.gif")); ImageWriteParam param = writer.getDefaultWriteParam(); writer.setOutput(ios); writer.prepareWriteSequence(null); writer.writeToSequence(new IIOImage(frame1, null, null), param); writer.writeToSequence(new IIOImage(frame2, null, null), param); writer.endWriteSequence(); writer.reset(); writer.dispose(); ios.flush(); ios.close(); return Toolkit.getDefaultToolkit().createImage("lut_test.gif"); }
private static ITXtTest readFrom(File f) { try { ImageInputStream iis = ImageIO.createImageInputStream(f); ImageReader r = ImageIO.getImageReaders(iis).next(); r.setInput(iis); IIOImage dst = r.readAll(0, null); // look for iTXt node IIOMetadata m = dst.getMetadata(); Node root = m.getAsTree(m.getNativeMetadataFormatName()); Node n = root.getFirstChild(); while (n != null && !"iTXt".equals(n.getNodeName())) { n = n.getNextSibling(); } if (n == null) { throw new RuntimeException("No iTXt node!"); } ITXtTest t = ITXtTest.getFromNode((IIOMetadataNode)n); return t; } catch (Throwable e) { throw new RuntimeException("Reading test failed.", e); } }
public void createAnimatedImage(BufferedImage bi, IIOMetadata metadata, ImageWriter writer, File outputFile) { try { fos = new FileOutputStream(outputFile); ImageOutputStream ios = ImageIO.createImageOutputStream(fos); System.out.println(ios); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); IIOMetadata streamData = writer.getDefaultStreamMetadata(param); writer.prepareWriteSequence(streamData); ImageTypeSpecifier specify = new ImageTypeSpecifier(bi); IIOMetadata imgData = writer.convertImageMetadata( (IIOMetadata) metadata, specify, param); GIFImageMetadata gifData = setAnimationProperties(imgData); IIOImage iim = new IIOImage(bi, null, gifData); param.setProgressiveMode(param.MODE_DISABLED); writer.writeToSequence(iim, param); writer.endWriteSequence(); ios.close(); } catch (Exception e) { e.printStackTrace(); } }
public byte[] writeTest(BufferedImage bi, ImageWriteParam p, IIOMetadata m) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); // write test image as jpeg ImageOutputStream ios = ImageIO.createImageOutputStream(baos); w.setOutput(ios); w.write(null, new IIOImage(bi, null, m), p); ios.close(); return baos.toByteArray(); }
public void doTest(String compression, int bi_type) throws IOException { System.out.println("Test " + compression + " on " + getImageTypeName(bi_type)); BufferedImage src = createTestImage(bi_type); writer.reset(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageOutputStream ios = ImageIO.createImageOutputStream(baos); writer.setOutput(ios); ImageWriteParam wparam = prepareWriteParam(compression); writer.write(null, new IIOImage(src, null, null), wparam); ios.flush(); ios.close(); // read result ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); ImageInputStream iis = ImageIO.createImageInputStream(bais); reader.reset(); reader.setInput(iis); BufferedImage dst = reader.read(0); checkResult(dst); }
private static long saveImage(final BufferedImage image, final ImageWriter writer, final ImageWriteParam writerParams, final String mode, final String suffix) throws IOException { final File imgFile = new File("WriterCompressionTest-" + mode + '.' + suffix); System.out.println("Writing file: " + imgFile.getAbsolutePath()); final ImageOutputStream imgOutStream = ImageIO.createImageOutputStream(new FileOutputStream(imgFile)); try { writer.setOutput(imgOutStream); writer.write(null, new IIOImage(image, null, null), writerParams); } finally { imgOutStream.close(); } return imgFile.length(); }
private static ITXtTest readFrom(File f) { try (ImageInputStream imageInputStream = ImageIO.createImageInputStream(f)) { ImageReader r = ImageIO.getImageReaders(imageInputStream).next(); r.setInput(imageInputStream); IIOImage dst = r.readAll(0, null); // look for iTXt node IIOMetadata m = dst.getMetadata(); Node root = m.getAsTree(m.getNativeMetadataFormatName()); Node n = root.getFirstChild(); while (n != null && !"iTXt".equals(n.getNodeName())) { n = n.getNextSibling(); } if (n == null) { throw new RuntimeException("No iTXt node!"); } ITXtTest t = ITXtTest.getFromNode((IIOMetadataNode)n); return t; } catch (Throwable e) { throw new RuntimeException("Reading test failed.", e); } }
@Test public void testEncode() throws IOException { ImageWriter writer = Streams.stream(ImageIO.getImageWritersByFormatName("jpeg")) .filter(TurboJpegImageWriter.class::isInstance) .findFirst().get(); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(0.85f); BufferedImage in = ImageIO.read(ClassLoader.getSystemResource("crop_aligned.jpg")); ByteArrayOutputStream os = new ByteArrayOutputStream(); try (ImageOutputStream ios = ImageIO.createImageOutputStream(os)) { writer.setOutput(ios); writer.write(null, new IIOImage(in, null, null), param); } os.flush(); assertThat(os.toByteArray()).isNotEmpty(); }
@Test public void testCanReuseWriter() throws IOException { ImageWriter writer = Streams.stream(ImageIO.getImageWritersByFormatName("jpeg")) .filter(TurboJpegImageWriter.class::isInstance) .findFirst().get(); BufferedImage in = ImageIO.read(ClassLoader.getSystemResource("rgb.jpg")); ByteArrayOutputStream rgb = new ByteArrayOutputStream(); try (ImageOutputStream ios = ImageIO.createImageOutputStream(rgb)) { writer.setOutput(ios); writer.write(null, new IIOImage(in, null, null), null); } rgb.flush(); in = ImageIO.read(ClassLoader.getSystemResource("crop_aligned.jpg")); ByteArrayOutputStream bw = new ByteArrayOutputStream(); try (ImageOutputStream ios = ImageIO.createImageOutputStream(bw)) { writer.setOutput(ios); writer.write(null, new IIOImage(in, null, null), null); } bw.flush(); assertThat(rgb.toByteArray()).isNotEqualTo(bw.toByteArray()); }
@Test public void testCanReuseWriter() throws IOException { BufferedImage in = ImageIO.read(ClassLoader.getSystemResource("lenna.png")); ByteArrayOutputStream lenna = new ByteArrayOutputStream(); try (ImageOutputStream ios = ImageIO.createImageOutputStream(lenna)) { writer.setOutput(ios); writer.write(null, new IIOImage(in, null, null), null); } lenna.flush(); in = ImageIO.read(ClassLoader.getSystemResource("hires.jp2")); ByteArrayOutputStream hires = new ByteArrayOutputStream(); try (ImageOutputStream ios = ImageIO.createImageOutputStream(lenna)) { writer.setOutput(ios); writer.write(null, new IIOImage(in, null, null), null); } hires.flush(); assertThat(lenna.toByteArray().length).isNotEqualTo(hires.toByteArray().length); }
public void compressSave(MultipartFile file, String uploadLocation) throws IOException { //Compresses JPG file but kills the quality. BufferedImage image = ImageIO.read(new ByteArrayInputStream(file.getBytes())); File compressedImageFile = new File(uploadLocation); OutputStream os = new FileOutputStream(compressedImageFile); Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg"); ImageWriter writer = (ImageWriter) writers.next(); ImageOutputStream ios = ImageIO.createImageOutputStream(os); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); if(param.canWriteCompressed()) { param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(0.05f); } writer.write(null, new IIOImage(image, null, null), param); }
/** * 根据质量压缩图片,不改变图片的尺寸 * * @param imgContent * 图片内容 * @param quality * 缩放比例 * @param extName * 后缀名 * @return */ public byte[] compress(byte[] imgContent, float quality, String extName) { if (quality > 1 || quality <= 0 || imgContent == null || WakaUtils.string.isEmpty(extName)) { throw new ZhhrUtilException("压缩文件失败!入参为空"); } try (InputStream is = new ByteArrayInputStream(imgContent); ByteArrayOutputStream os = new ByteArrayOutputStream(); ImageOutputStream ios = ImageIO.createImageOutputStream(os);) { BufferedImage image = ImageIO.read(is); Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(extName); ImageWriter writer = writers.next(); writer.setOutput(ios); ImageWriteParam param = writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(quality); writer.write(null, new IIOImage(image, null, null), param); writer.dispose(); return os.toByteArray(); } catch (IOException e) { throw new ZhhrUtilException(e.getMessage(), e); } }
private String convertPngToJpeg(String pngBase64) throws IOException { byte[] pngBinary = DatatypeConverter.parseBase64Binary(pngBase64); InputStream in = new ByteArrayInputStream(pngBinary); BufferedImage pngImage = ImageIO.read(in); int width = pngImage.getWidth(), height = pngImage.getHeight(); BufferedImage jpgImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB); Graphics2D g = jpgImage.createGraphics(); g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g.setBackground(Color.WHITE); g.clearRect(0, 0, width, height); g.drawImage(pngImage, 0, 0, width, height, null); g.dispose(); final ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); writer.setOutput(ImageIO.createImageOutputStream(baos)); writer.write(null, new IIOImage(jpgImage, null, null), JPEG_PARAMS); String jpgBase64 = DatatypeConverter.printBase64Binary(baos.toByteArray()); return jpgBase64; }
/** * Encodes an image in JPEG format and writes it to an output stream. * * @param bufferedImage the image to be encoded (<code>null</code> not * permitted). * @param outputStream the OutputStream to write the encoded image to * (<code>null</code> not permitted). * * @throws IOException if there is an I/O problem. * @throws NullPointerException if <code>bufferedImage</code> is * <code>null</code>. */ @Override public void encode(BufferedImage bufferedImage, OutputStream outputStream) throws IOException { ParamChecks.nullNotPermitted(bufferedImage, "bufferedImage"); ParamChecks.nullNotPermitted(outputStream, "outputStream"); Iterator iterator = ImageIO.getImageWritersByFormatName("jpeg"); ImageWriter writer = (ImageWriter) iterator.next(); ImageWriteParam p = writer.getDefaultWriteParam(); p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); p.setCompressionQuality(this.quality); ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream); writer.setOutput(ios); writer.write(null, new IIOImage(bufferedImage, null, null), p); ios.flush(); writer.dispose(); ios.close(); }
public static File createImage(BufferedImage bi) { File tempFile = null; try { tempFile = File.createTempFile("tempImageFile", ".tif"); tempFile.deleteOnExit(); TIFFImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.US); tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED); // Get tif writer and set output to file Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("tiff"); ImageWriter writer = writers.next(); IIOImage image = new IIOImage(bi, null, null); tempFile = tempImageFile(tempFile); ImageOutputStream ios = ImageIO.createImageOutputStream(tempFile); writer.setOutput(ios); writer.write(null, image, tiffWriteParam); ios.close(); writer.dispose(); } catch (Exception exc) { exc.printStackTrace(); } return tempFile; }