public String readCustomData(byte[] imageData, String key) throws IOException{ ImageReader imageReader = ImageIO.getImageReadersByFormatName("png").next(); imageReader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(imageData)), true); // read metadata of first image IIOMetadata metadata = imageReader.getImageMetadata(0); //this cast helps getting the contents PNGMetadata pngmeta = (PNGMetadata) metadata; NodeList childNodes = pngmeta.getStandardTextNode().getChildNodes(); for (int i = 0; i < childNodes.getLength(); i++) { Node node = childNodes.item(i); String keyword = node.getAttributes().getNamedItem("keyword").getNodeValue(); String value = node.getAttributes().getNamedItem("value").getNodeValue(); if(key.equals(keyword)){ return value; } } return null; }
Iterator<ImageReader> iter = ImageIO.getImageReaders(iis); while (img==null && iter.hasNext()) { ImageReader reader = iter.next(); ImageReadParam param = reader.getDefaultReadParam(); reader.setInput(iis, false, true); img = reader.read(0, param); break; case 1: { Iterator<ImageTypeSpecifier> imageTypes = reader.getImageTypes(0); while (imageTypes.hasNext()) { ImageTypeSpecifier imageTypeSpecifier = imageTypes.next(); int bufferedImageType = imageTypeSpecifier.getBufferedImageType(); if (bufferedImageType == BufferedImage.TYPE_BYTE_GRAY) { param.setDestinationType(imageTypeSpecifier); break; reader.setInput(iis, false, true); img = reader.read(0, param); break; reader.setInput(iis, false, true); int height = reader.getHeight(0); int width = reader.getWidth(0); Iterator<ImageTypeSpecifier> imageTypes = reader.getImageTypes(0); if (imageTypes.hasNext()) { ImageTypeSpecifier imageTypeSpecifier = imageTypes.next();
try(ImageInputStream in = ImageIO.createImageInputStream(resourceFile)){ final Iterator<ImageReader> readers = ImageIO.getImageReaders(in); if (readers.hasNext()) { ImageReader reader = readers.next(); try { reader.setInput(in); return new Dimension(reader.getWidth(0), reader.getHeight(0)); } finally { reader.dispose(); } } }
private static BufferedImage readBuffereImage(ImageReader reader, int w, int h) throws IOException { ImageReadParam param = reader.getDefaultReadParam(); int srcWidth = reader.getWidth(0); int srcHeight = reader.getHeight(0); Rectangle rect = null; if ((float) w / h > (float) srcWidth / srcHeight) { h = h * srcWidth / w; w = srcWidth; rect = new Rectangle(0, (srcHeight - h) / 2, w, h); } else { w = w * srcHeight / h; h = srcHeight; rect = new Rectangle((srcWidth - w) / 2, 0, w, h); } param.setSourceRegion(rect); BufferedImage srcBuffered = reader.read(0, param); return srcBuffered; }
public static Point getImageSizeFromStream(InputStream is) { if (!initialized) { // Stops ImageIO from creating temp files when reading images // from input stream. ImageIO.setUseCache(false); initialized = true; } try { ImageInputStream imageStream = ImageIO.createImageInputStream(is); Iterator<ImageReader> readers = ImageIO.getImageReaders(imageStream); if (!readers.hasNext()) return null; ImageReader reader = readers.next(); try { reader.setInput(imageStream); return new Point(reader.getWidth(0), reader.getHeight(0)); } finally { reader.dispose(); } } catch (IOException e) { throw new RuntimeException(e); } }
/** * The metadata of PNG and JPEG can contain the width of a pixel in millimeters. * Return the the "effective" dpi calculated as <code>25.4/HorizontalPixelSize</code> * and <code>25.4/VerticalPixelSize</code>. Where 25.4 is the number of mm in inch. * * @return array of two elements: <code>{horisontalPdi, verticalDpi}</code>. * {96, 96} is the default. */ public static int[] getResolution(ImageReader r) throws IOException { int hdpi=96, vdpi=96; double mm2inch = 25.4; NodeList lst; Element node = (Element)r.getImageMetadata(0).getAsTree("javax_imageio_1.0"); lst = node.getElementsByTagName("HorizontalPixelSize"); if(lst != null && lst.getLength() == 1) hdpi = (int)(mm2inch/Float.parseFloat(((Element)lst.item(0)).getAttribute("value"))); lst = node.getElementsByTagName("VerticalPixelSize"); if(lst != null && lst.getLength() == 1) vdpi = (int)(mm2inch/Float.parseFloat(((Element)lst.item(0)).getAttribute("value"))); return new int[]{hdpi, vdpi}; }
@Test public void testTranscodeWithMetadataCMYKtoCMYK() throws IOException { ImageWriter writer = createImageWriter(); ImageReader reader = ImageIO.getImageReader(writer); ByteArrayOutputStream stream = transcode(reader, getClassLoaderResource("/jpeg/cmyk-sample-multiple-chunk-icc.jpg"), writer, ColorSpace.TYPE_CMYK); reader.reset(); reader.setInput(new ByteArrayImageInputStream(stream.toByteArray())); BufferedImage image = reader.read(0); assertNotNull(image); assertEquals(100, image.getWidth()); assertEquals(100, image.getHeight()); IIOMetadata metadata = reader.getImageMetadata(0); IIOMetadataNode standard = (IIOMetadataNode) metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName); NodeList colorSpaceType = standard.getElementsByTagName("ColorSpaceType"); assertEquals(1, colorSpaceType.getLength()); assertEquals("CMYK", ((IIOMetadataNode) colorSpaceType.item(0)).getAttribute("name")); }
private static void toGif(String src, String dst, Double precision) throws IOException, JLegofyException { ImageReader reader = ImageIO.getImageReadersByFormatName("gif").next(); ImageInputStream ciis = ImageIO.createImageInputStream(new File(src)); reader.setInput(ciis, false); int noi = reader.getNumImages(true); ImageOutputStream cios = ImageIO.createImageOutputStream(new File(dst)); GifSequenceWriter g = new GifSequenceWriter(cios, BufferedImage.TYPE_INT_RGB, 50, true); int timeBetweenFramesMS = 50; for (int i = 0; i < noi; i++) { BufferedImage image = reader.read(i); IIOMetadata metadata = reader.getImageMetadata(i); IIOMetadataNode tree = (IIOMetadataNode) metadata.getAsTree(metadata.getNativeMetadataFormatName()); NodeList children = tree.getChildNodes(); for (int j = 0; j < children.getLength(); j++) { IIOMetadataNode nodeItem = (IIOMetadataNode) children.item(j); if ("GraphicControlExtension".equals(nodeItem.getNodeName())) { timeBetweenFramesMS = Integer.parseInt(nodeItem.getAttribute("delayTime")) * 10; } } g.writeToSequence(new JLegofyEngine().toLegofy(image, precision), timeBetweenFramesMS); } cios.close(); } }
reader.setInput(inputStream); ImageReadParam param = reader.getDefaultReadParam(); param.setDestinationType(reader.getRawImageType(0)); if (param.getDestinationType() == null) { Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0); param.setDestinationType(typeSpecifier); System.err.println("param.getDestinationType(): " + param.getDestinationType()); original = reader.read(0, param); inputStream.close(); if (type <= 0 || type == original.getType()) { image = original; image = new BufferedImage(original.getWidth(), original.getHeight(), type); Graphics2D graphics = image.createGraphics(); ImageOutputStream stream = ImageIO.createImageOutputStream(output); writer.write(null, new IIOImage(image, null, null), param); System.err.println("Write time: " + (System.currentTimeMillis() - start) + " ms");
Iterator<ImageReader> it = ImageIO.getImageReaders(imageInputStream); readers : while (it.hasNext()) { ImageReader reader = it.next(); reader.setInput(imageInputStream); int numImages = reader.getNumImages(true); if (numImages == 0) { image = reader.read(0); IIOMetadata metadata = reader.getImageMetadata(0); if (metadata != null && metadata.isStandardMetadataFormatSupported()) { Node data = metadata.getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName); metadata : for (int i = 0, j = data.getChildNodes().getLength(); i < j; i++) { Node child = data.getChildNodes().item(i); if (child.getLocalName().equalsIgnoreCase("compression")) { for (int k = 0, l = child.getChildNodes().getLength(); k < l; k++) { Node child2 = child.getChildNodes().item(k); if (child2.getLocalName().equalsIgnoreCase("lossless")) { images[i] = reader.read(i);
try (ImageInputStream origInput = ImageIO.createImageInputStream(getClass().getResource(data)); ImageInputStream input = ImageIO.createImageInputStream(getClass().getResource(data))) { origReader.setInput(origInput); reader.setInput(input); IIOMetadata original = origReader.getImageMetadata(0); IIOMetadataNode origTree = (IIOMetadataNode) original.getAsTree(JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0); IIOMetadata cleaned = cleaner.cleanMetadata(origReader.getImageMetadata(0)); IIOMetadataNode cleanTree = (IIOMetadataNode) cleaned.getAsTree(JPEGImage10MetadataCleaner.JAVAX_IMAGEIO_JPEG_IMAGE_1_0); assertEquals(1, origDHT.getLength()); assertEquals(2, cleanDHT.getLength()); assertEquals(origDHTable.getLength(), cleanDHTable.getLength()); reader.dispose(); origReader.dispose();
private static Dimension getSize(File file) { try { ImageInputStream input = ImageIO.createImageInputStream(file); if (input != null) { try { Iterator<ImageReader> readers = ImageIO.getImageReaders(input); if (readers.hasNext()) { ImageReader reader = readers.next(); try { reader.setInput(input); return new Dimension(reader.getWidth(0), reader.getHeight(0)); } finally { reader.dispose(); input.close(); BufferedImage image = ImageIO.read(file); if (image != null) { return new Dimension(image.getWidth(), image.getHeight()); } else { return null;
protected void assertReadWithSourceRegionParamEqualImage(final Rectangle r, final TestData data, final int imageIndex) throws IOException { ImageReader reader = createReader(); reader.setInput(data.getInputStream()); ImageReadParam param = reader.getDefaultReadParam(); final BufferedImage roi = reader.read(imageIndex, param).getSubimage(r.x, r.y, r.width, r.height); param.setSourceRegion(r); final BufferedImage image = reader.read(imageIndex, param); assertEquals("Read image has wrong width: " + image.getWidth(), r.width, image.getWidth()); assertEquals("Read image has wrong height: " + image.getHeight(), r.height, image.getHeight()); assertImageDataEquals("Images differ", roi, image); reader.dispose();
COSDictionary params = getDecodeParams(parameters, index); ImageReadParam irp = reader.getDefaultReadParam(); irp.setSourceSubsampling(options.getSubsamplingX(), options.getSubsamplingY(), options.getSubsamplingOffsetX(), options.getSubsamplingOffsetY()); irp.setSourceRegion(options.getSourceRegion()); options.setFilterSubsampled(true); try (ImageInputStream iis = ImageIO.createImageInputStream(source)) reader.setInput(iis); image = reader.read(0, irp); if (image.getColorModel().getPixelSize() != bits) BufferedImage packedImage = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_BYTE_BINARY); Graphics graphics = packedImage.getGraphics(); reader.dispose();
@Override public void process(final InputStream rawIn, final OutputStream out) throws IOException { try (final BufferedInputStream in = new BufferedInputStream(rawIn)) { final ImageInputStream iis = ImageIO.createImageInputStream(in); if (iis == null) { throw new ProcessException("FlowFile is not in a valid format"); final Iterator<ImageReader> readers = ImageIO.getImageReaders(iis); if (!readers.hasNext()) { throw new ProcessException("FlowFile is not in a valid format"); final String formatName = reader.getFormatName(); reader.setInput(iis, true); final BufferedImage image = reader.read(0); final Image scaledImage = image.getScaledInstance(width, height, hints); final BufferedImage scaledBufferedImg; if (scaledImage instanceof BufferedImage) { if(image.getTransparency() == Transparency.OPAQUE) { imageType = BufferedImage.TYPE_INT_RGB; scaledBufferedImg = new BufferedImage(scaledImage.getWidth(null), scaledImage.getHeight(null), imageType); final Graphics2D graphics = scaledBufferedImg.createGraphics(); try { ImageIO.write(scaledBufferedImg, formatName, out);
Iterator<ImageReader> readers = ImageIO.getImageReaders(input); System.err.println("Reading using: " + reader); reader.addIIOReadWarningListener(new IIOReadWarningListener() { public void warningOccurred(ImageReader source, String warning) { System.err.println("Warning: " + arg + ": " + warning); reader.addIIOReadProgressListener(new ProgressListenerBase() { private static final int MAX_W = 78; int lastProgress = 0; reader.setInput(input); ImageReadParam param = reader.getDefaultReadParam(); int numImages = reader.getNumImages(true); for (int imageNo = 0; imageNo < numImages; imageNo++) { BufferedImage image = reader.read(imageNo, param); System.err.println("Read time: " + (System.currentTimeMillis() - start) + " ms"); showIt(image, String.format("Image: %s [%d x %d]", file.getName(), reader.getWidth(imageNo), reader.getHeight(imageNo))); int numThumbnails = reader.getNumThumbnails(imageNo); for (int thumbnailNo = 0; thumbnailNo < numThumbnails; thumbnailNo++) { BufferedImage thumbnail = reader.readThumbnail(imageNo, thumbnailNo); showIt(thumbnail, String.format("Thumbnail: %s [%d x %d]", file.getName(), thumbnail.getWidth(), thumbnail.getHeight()));
private String getNumChannels(ImageReader reader) { try { IIOMetadata imageMetadata = reader.getImageMetadata(0); if (imageMetadata == null) { return ""; } IIOMetadataNode metaTree = (IIOMetadataNode) imageMetadata.getAsTree("javax_imageio_1.0"); Element numChannelsItem = (Element) metaTree.getElementsByTagName("NumChannels").item(0); if (numChannelsItem == null) { return ""; } return numChannelsItem.getAttribute("value"); } catch (IOException | NegativeArraySizeException e) { LOG.debug("Couldn't read metadata - returning empty string", e); return ""; } }
/** * 等比缩放,居中剪切 * * @param src * @param dest * @param w * @param h * @throws IOException */ public static void scale(String src, String dest, int w, int h) throws IOException { String srcSuffix = src.substring(src.lastIndexOf(".") + 1); Iterator<ImageReader> iterator = ImageIO.getImageReadersByFormatName(srcSuffix); ImageReader reader = (ImageReader) iterator.next(); InputStream in = new FileInputStream(src); ImageInputStream iis = ImageIO.createImageInputStream(in); reader.setInput(iis); BufferedImage srcBuffered = readBuffereImage(reader, w, h); BufferedImage targetBuffered = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); Graphics graphics = targetBuffered.getGraphics(); graphics.drawImage(srcBuffered.getScaledInstance(w, h, Image.SCALE_DEFAULT), 0, 0, null); // 绘制缩小后的图 graphics.dispose(); srcBuffered.flush(); in.close(); iis.close(); ImageIO.write(targetBuffered, srcSuffix, new File(dest)); targetBuffered.flush(); }
@Test public void testReadWithSizeParam() { ImageReader reader = createReader(); TestData data = getTestData().get(0); reader.setInput(data.getInputStream()); ImageReadParam param = reader.getDefaultReadParam(); if (param.canSetSourceRenderSize()) { param.setSourceRenderSize(new Dimension(10, 10)); BufferedImage image = null; try { image = reader.read(0, param); } catch (IOException e) { failBecause("Image could not be read", e); } assertNotNull("Image was null!", image); assertEquals("Read image has wrong width: " + image.getWidth(), 10, image.getWidth()); assertEquals("Read image has wrong height: " + image.getHeight(), 10, image.getHeight()); } reader.dispose(); }
try { ImageInputStream iis = ImageIO.createImageInputStream( is ); try { Iterator<ImageReader> i = ImageIO.getImageReaders( iis ); ImageReader r = i.next(); try { r.setInput( iis ); BufferedImage img = r.read(0); if (dpi[1] == 0) dpi[1] = PIXEL_DPI; size.width = img.getWidth()*PIXEL_DPI/dpi[0]; size.height = img.getHeight()*PIXEL_DPI/dpi[1]; } finally { r.dispose(); iis.close();