public static void main(String[] args) { ImageWriter w = ImageIO.getImageWritersByFormatName(format).next(); if (w == null) { throw new RuntimeException("No available writers for format " + format); } ImageWriteParam p = w.getDefaultWriteParam(); ImageTypeSpecifier t = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB); IIOMetadata m = w.getDefaultImageMetadata(t, p); System.out.println("Default image metadata is " + m); testWritableMetadata(m); IIOMetadata sm = w.getDefaultStreamMetadata(p); System.out.println("Default stream metadata is " + sm); testWritableMetadata(sm); }
void save(File file) throws IOException { ImageWriter iw = null; String name = file.getName(); int i = name.lastIndexOf('.'); if (i >= 0) { String extension = name.substring(i + 1); Iterator<ImageWriter> imageWritersBySuffix = ImageIO.getImageWritersBySuffix(extension); if (imageWritersBySuffix.hasNext()) { iw = imageWritersBySuffix.next(); } } if (iw != null) { file.delete(); ImageOutputStream ios = ImageIO.createImageOutputStream(file); iw.setOutput(ios); try { iw.write((BufferedImage) image); } finally { iw.dispose(); ios.flush(); ios.close(); } } else { ImageIO.write((BufferedImage) image, "PNG", file); } }
@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(); }
/** * 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 runTest(Object ctx, int numReps) { final Context ictx = (Context)ctx; final ImageWriter writer = ictx.writer; final BufferedImage image = ictx.image; do { try { ImageOutputStream ios = ictx.createImageOutputStream(); writer.setOutput(ios); writer.write(image); writer.reset(); ios.close(); ictx.closeOriginalStream(); } catch (IOException e) { e.printStackTrace(); } } while (--numReps >= 0); }
public static void main(String[] args) throws Exception { String format = "javax_imageio_1.0"; BufferedImage img = new BufferedImage(16, 16, BufferedImage.TYPE_INT_RGB); ImageWriter iw = ImageIO.getImageWritersByMIMEType("image/png").next(); IIOMetadata meta = iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), null); DOMImplementationRegistry registry; registry = DOMImplementationRegistry.newInstance(); DOMImplementation impl = registry.getDOMImplementation("XML 3.0"); Document doc = impl.createDocument(null, format, null); Element root, text, entry; root = doc.getDocumentElement(); root.appendChild(text = doc.createElement("Text")); text.appendChild(entry = doc.createElement("TextEntry")); // keyword isn't #REQUIRED by the standard metadata format. // However, it is required by the PNG format, so we include it here. entry.setAttribute("keyword", "Comment"); entry.setAttribute("value", "Some demo comment"); meta.mergeTree(format, root); }
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>. */ 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(); }
/** * 根据质量压缩图片,不改变图片的尺寸 * * @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); } }
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); }
public static void main(String[] args) throws IOException { String format = "GIF"; ImageWriter writer = ImageIO.getImageWritersByFormatName(format).next(); ImageWriteParam param = writer.getDefaultWriteParam(); IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(param); boolean gotException = false; try { writer.prepareWriteSequence(streamMetadata); } catch (IllegalStateException e) { gotException = true; System.out.println("Test passed."); e.printStackTrace(System.out); } if (!gotException) { throw new RuntimeException("Test failed."); } }
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 void doTest() { File pwd = new File("."); try { File f = File.createTempFile("transparency_test_", ".gif", pwd); System.out.println("file: " + f.getCanonicalPath()); ImageWriter w = ImageIO.getImageWritersByFormatName("GIF").next(); ImageWriterSpi spi = w.getOriginatingProvider(); boolean succeed_write = ImageIO.write(src, "gif", f); if (!succeed_write) { throw new RuntimeException("Test failed: failed to write src."); } dst = ImageIO.read(f); checkResult(src, dst); } catch (IOException e) { throw new RuntimeException("Test failed.", e); } }
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"); }
public static byte[] setGlitchQuality(byte[] inputImageBytes, int quality) throws Exception { Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName("png"); ImageWriter writer = (ImageWriter)iter.next(); ImageWriteParam iwp = writer.getDefaultWriteParam(); BufferedImage originalImage = ImageIO.read(new ByteArrayInputStream(inputImageBytes)); IIOImage image = new IIOImage(originalImage, null, null); ByteArrayOutputStream out=new ByteArrayOutputStream(); ImageOutputStream imageOut=ImageIO.createImageOutputStream(out); writer.setOutput(imageOut); writer.write(null, image, iwp); byte[] qualityImageBytes = out.toByteArray(); return qualityImageBytes; }
private static void init() { Iterator i = ImageIO.getImageWritersByFormatName(format); if (!i.hasNext()) { throw new RuntimeException("No available ImageWrites for "+format+" format!"); } iw = (ImageWriter)i.next(); i = ImageIO.getImageReadersByFormatName(format); if (!i.hasNext()) { throw new RuntimeException("No available ImageReaders for " +format+" format!"); } ir = (ImageReader)i.next(); }
public static void main(String[] args) throws IOException { ImageWriter iw = new PNGImageWriter(null); File f = File.createTempFile("imageio", "tmp"); ImageOutputStream ios = ImageIO.createImageOutputStream(f); try { iw.setOutput(ios); } catch (NullPointerException npe) { f.delete(); throw new RuntimeException("Got NullPointerException!"); } f.delete(); }
/** * Sets the default {@code Content-Type} to be used for writing. * @throws IllegalArgumentException if the given content type is not supported by the Java Image I/O API */ public void setDefaultContentType(MediaType defaultContentType) { Assert.notNull(defaultContentType, "'contentType' must not be null"); Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(defaultContentType.toString()); if (!imageWriters.hasNext()) { throw new IllegalArgumentException( "Content-Type [" + defaultContentType + "] is not supported by the Java Image I/O API"); } this.defaultContentType = defaultContentType; }
private boolean isWritable(MediaType mediaType) { if (mediaType == null || MediaType.ALL.equals(mediaType)) { return true; } Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByMIMEType(mediaType.toString()); return imageWriters.hasNext(); }
private static void testGetWriterMIMETypes() { String[] types = ImageIO.getWriterMIMETypes(); for (String t : types) { Iterator<ImageWriter> it = ImageIO.getImageWritersByMIMEType(t); if (!it.hasNext()) { throw new RuntimeException("getWriterMIMETypes returned " + "an unknown type: " + t); } } }
/** * Write buffered image as required format * * @param bi * @param mimeType * @return * @throws IOException */ public byte[] writeImage(BufferedImage bi, String mimeType) throws IOException { Iterator<ImageWriter> writers = ImageIO.getImageWritersByMIMEType(mimeType); if (writers.hasNext()) { ImageWriter writer = writers.next(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); writer.setOutput(ImageIO.createImageOutputStream(baos)); writer.write(bi); return baos.toByteArray(); } throw new IOException("Cannot write to this mimetype"); }
public static void main(final String[] argv) throws Exception { IIOMetadata jpegmetadata = null; ImageWriter jpgWriter = ImageIO.getImageWritersByFormatName("jpg").next(); try { jpegmetadata = createJPEGMetadata(jpgWriter); } catch (Exception e) { throw new RuntimeException(e); } ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageOutputStream output = ImageIO.createImageOutputStream(baos); jpgWriter.setOutput(output); int w=100, h=100; BufferedImage bi = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); Graphics2D g2d = bi.createGraphics(); g2d.setColor(Color.white); g2d.fillRect(0, 0, w, h); IIOImage image = new IIOImage(bi, null, jpegmetadata); jpgWriter.write(null, image, null); jpgWriter.dispose(); baos.flush(); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); ImageInputStream iis = ImageIO.createImageInputStream(bais); bi = ImageIO.read(iis); for (int i=0; i<bi.getWidth(); i++) { for(int j=0; j<bi.getHeight(); j++) { if (bi.getRGB(i, j) != Color.white.getRGB()) { throw new RuntimeException("Wrong color : " + Integer.toHexString(bi.getRGB(i, j))); } } } }
public void imageComplete(ImageWriter source) { System.out.println("Image Completed"); if (!isImageComplete) { isImageComplete = true; } else { throw new RuntimeException("The imageComplete() was called twice." + " Test failed."); } checkProgress(); }
public void imageProgress(ImageWriter source, float percentageDone) { if (20f < percentageDone && percentageDone < 80f ) { Thread t = new Thread(action); t.start(); } }
public DestTypeTest() { w = (ImageWriter) ImageIO.getImageWritersByFormatName("jpeg").next(); w.addIIOWriteWarningListener(this); r = (ImageReader) ImageIO.getImageReadersByFormatName("jpeg").next(); r.addIIOReadWarningListener(this); }
@Override public void imageStarted(ImageWriter source, int imageIndex) { System.out.println("imageStarted called"); if (startAbort) { source.abort(); } }
public static void main(String[] args) throws IOException { Iterator witer = ImageIO.getImageWritersByFormatName("png"); ImageWriter w = (ImageWriter)witer.next(); File f = File.createTempFile("WriteProgressive", ".png"); ImageOutputStream ios = ImageIO.createImageOutputStream(f); w.setOutput(ios); BufferedImage bi = new BufferedImage(100, 100, BufferedImage.TYPE_3BYTE_BGR); Graphics2D g = bi.createGraphics(); Random r = new Random(10); for (int i = 0; i < 10000; i++) { Color c = new Color(r.nextInt(256), r.nextInt(256), r.nextInt(256)); g.setColor(c); g.fillRect(r.nextInt(100), r.nextInt(100), 1, 1); } IIOImage iioimage = new IIOImage(bi, null, null); ImageWriteParam param = w.getDefaultWriteParam(); param.setProgressiveMode(ImageWriteParam.MODE_DEFAULT); try { w.write(null, iioimage, param); } catch (NullPointerException npe) { throw new RuntimeException("Got NPE during write!"); } ios.close(); BufferedImage bi2 = ImageIO.read(f); f.delete(); ImageCompare.compare(bi, bi2); }
private static void doTest(int mode) { String fileFormat = "bmp"; try { ImageWriter iw = (ImageWriter)ImageIO.getImageWritersBySuffix(fileFormat).next(); if(iw == null) { throw new RuntimeException("No available image writer for " + fileFormat + " Test failed."); } File file = new File("image." + fileFormat); ImageOutputStream ios = ImageIO.createImageOutputStream(file); iw.setOutput(ios); BufferedImage bimg = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); Graphics g = bimg.getGraphics(); g.setColor(Color.green); g.fillRect(0,0,100,100); ImageWriteParam param = iw.getDefaultWriteParam(); param.setCompressionMode(mode); IIOMetadata meta = iw.getDefaultImageMetadata(new ImageTypeSpecifier(bimg), param); IIOImage iioImg = new IIOImage(bimg, null, meta); iw.write(null, iioImg, param); } catch(Exception e) { e.printStackTrace(); throw new RuntimeException("Test failed."); } }
private static void writeTo(File f, ITXtTest t) { BufferedImage src = createBufferedImage(); try (ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(f)) { ImageTypeSpecifier imageTypeSpecifier = new ImageTypeSpecifier(src); ImageWriter imageWriter = ImageIO.getImageWritersByFormatName("PNG").next(); imageWriter.setOutput(imageOutputStream); IIOMetadata m = imageWriter.getDefaultImageMetadata(imageTypeSpecifier, null); String format = m.getNativeMetadataFormatName(); Node root = m.getAsTree(format); IIOMetadataNode iTXt = t.getNode(); root.appendChild(iTXt); m.setFromTree(format, root); imageWriter.write(new IIOImage(src, null, m)); System.out.println("Writing done."); } catch (Throwable e) { throw new RuntimeException("Writing test failed.", e); } }
private File testWriteRGB(String format, int type) throws IOException { BufferedImage bi = new BufferedImage(width, height, type); Graphics2D g = bi.createGraphics(); Color white = new Color(255, 255, 255); Color red = new Color(255, 0, 0); Color green = new Color(0, 255, 0); Color blue = new Color(0, 0, 255); g.setColor(white); g.fillRect(0, 0, width, height); g.setColor(red); g.fillRect(10, 10, 20, 20); g.setColor(green); g.fillRect(30, 30, 20, 20); g.setColor(blue); g.fillRect(50, 50, 20, 20); ImageTypeSpecifier spec = new ImageTypeSpecifier(bi); Iterator<ImageWriter> writers = ImageIO.getImageWriters(spec, format); File file = new File("BitDepth_" + biTypeNames[type] + "." + format); if (!writers.hasNext()) { System.out.println("\tNo writers available for type " + biTypeNames[type] + " BufferedImage!"); } else { ImageWriter writer = writers.next(); try (ImageOutputStream out = ImageIO.createImageOutputStream(file)) { writer.setOutput(out); writer.write(bi); } catch (Exception e) { System.out.println("\tCan't write a type " + biTypeNames[type] + " BufferedImage!"); return null; } } return file; }
private static void writeWithCompression(BufferedImage src, String compression) throws IOException { System.out.println("Compression: " + compression); ImageWriter writer = ImageIO.getImageWritersByFormatName("BMP").next(); if (writer == null) { throw new RuntimeException("Test failed: no bmp writer available"); } File fout = File.createTempFile(compression + "_", ".bmp", new File(".")); ImageOutputStream ios = ImageIO.createImageOutputStream(fout); writer.setOutput(ios); BMPImageWriteParam param = (BMPImageWriteParam) writer.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionType(compression); param.setTopDown(true); writer.write(null, new IIOImage(src, null, null), param); writer.dispose(); ios.flush(); ios.close(); BufferedImage dst = ImageIO.read(fout); verify(dst); }
/** Checks that the provided <code>ImageWriter</code> can encode * the provided <code>ImageTypeSpecifier</code> or not. If not, an * <code>IIOException</code> will be thrown. * @param writer The provided <code>ImageWriter</code>. * @param type The image to be tested. * @throws IIOException If the writer cannot encoded the provided image. */ public static final void canEncodeImage(ImageWriter writer, ImageTypeSpecifier type) throws IIOException { ImageWriterSpi spi = writer.getOriginatingProvider(); if(type != null && spi != null && !spi.canEncodeImage(type)) { throw new IIOException(I18N.getString("ImageUtil2")+" "+ writer.getClass().getName()); } }
protected void doTest() throws IOException { BufferedImage biSrc = getSrc(); ImageWriter writer = ImageIO.getImageWritersByFormatName("GIF").next(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageOutputStream ios = ImageIO.createImageOutputStream(baos); writer.setOutput(ios); ImageWriteParam writeParam = writer.getDefaultWriteParam(); IIOMetadata imageMetadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(biSrc), writeParam); IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(writeParam); IIOImage iioImg = new IIOImage(biSrc, null, imageMetadata); writer.write(streamMetadata, iioImg, writeParam); ios.close(); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); ImageInputStream iis = ImageIO.createImageInputStream(bais); ImageReader reader = ImageIO.getImageReader(writer); reader.setInput(iis); BufferedImage dst = reader.read(0); // do test int x = dx / 2; int y = height / 2; for (int i = 0; i < usedColors.length; i++) { int dstRgb = dst.getRGB(x, y); System.out.println("dstColor: " + Integer.toHexString(dstRgb)); int srcRgb = usedColors[i].getRGB(); System.out.println("srcColor: " + Integer.toHexString(srcRgb)); if (dstRgb != srcRgb) { throw new RuntimeException("wrong color " + i + ": " + Integer.toHexString(dstRgb)); } x += dx; } }
public static void main(final String[] args) throws Exception { final IIORegistry registry = IIORegistry.getDefaultInstance(); final Iterator<ImageWriterSpi> iter = registry.getServiceProviders(ImageWriterSpi.class, provider -> true, true); // Validates all supported ImageWriters while (iter.hasNext()) { final ImageWriter writer = iter.next().createWriterInstance(); System.out.println("ImageWriter = " + writer); test(writer); } System.out.println("Test passed"); }
public void imageProgress(ImageWriter source, float percentageDone) { print("imageProgress: percentageDone = " + percentageDone); if (state != IMAGE_STARTED) { error("imageProgress called without prior imageStarted!"); } if (percentageDone < prevPercentageDone) { error("percentageDone did not increase!"); } prevPercentageDone = percentageDone; }
@Override public void imageProgress(ImageWriter source, float percentageDone) { isProgressCalled = true; if (percentageDone > 50 && abortFlag) { source.abort(); } }
public static void main(final String[] args) throws IOException { final IIORegistry registry = IIORegistry.getDefaultInstance(); final Iterator<ImageWriterSpi> iter = registry.getServiceProviders( ImageWriterSpi.class, provider -> true, true); // Validates all supported ImageWriters while (iter.hasNext()) { final WriteAfterAbort writeAfterAbort = new WriteAfterAbort(); final ImageWriter writer = iter.next().createWriterInstance(); System.out.println("ImageWriter = " + writer); writeAfterAbort.test(writer); } System.out.println("Test passed"); }
public static void writeTestImage(String fileName) { BufferedImage bi = new BufferedImage(TEST_W, TEST_H, BufferedImage.TYPE_INT_RGB); Graphics g = bi.getGraphics(); g.setColor(new Color(testRGB)); g.fillRect(0, 0, TEST_W, TEST_H); try { System.err.printf("Writing %s\n", fileName); if (lowCompression) { ImageWriter iw = (ImageWriter)ImageIO.getImageWritersBySuffix("jpeg").next(); if(iw == null) { throw new RuntimeException("No available image writer for " + "jpeg " + " Test failed."); } File file = new File(fileName); ImageOutputStream ios = ImageIO.createImageOutputStream(file); iw.setOutput(ios); ImageWriteParam param = iw.getDefaultWriteParam(); param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); param.setCompressionQuality(1); IIOImage iioImg = new IIOImage(bi, null, null); iw.write(null, iioImg, param); } else { ImageIO.write(bi, "jpeg", new File(fileName)); } } catch (IOException e) { System.err.println("Error " + e + " when writing file: " + fileName); throw new RuntimeException(e); } }