public File addImageExtension(File incoming) throws IOException { String format = null; ImageInputStream iis = ImageIO.createImageInputStream(incoming); Iterator<ImageReader> imageReaders = ImageIO.getImageReaders(iis); while (imageReaders.hasNext()) { ImageReader reader = (ImageReader) imageReaders.next(); format = reader.getFormatName().toLowerCase(); log.debug("filetype is: " + format); File newfile = new File("imageimage." + format); if (newfile.exists()) { newfile.delete(); } Files.copy(incoming.toPath(), newfile.toPath()); incoming.delete(); return newfile; } return null; }
/** * Gets the size of an image. * * @param name the image name * @param in the input stream * @return the size of the image * * @throws BrokenImageException if the image is faulty * @throws UnrecognizedImageTypeException if the image type is unknown * @throws IOException if reading the image goes wrong */ public Dimension run(String name, InputStream in) throws IOException { final ImageInputStream stream = new MemoryCacheImageInputStream(in); final Iterator<ImageReader> i = ImageIO.getImageReaders(stream); if (!i.hasNext()) throw new UnrecognizedImageTypeException(name); final ImageReader reader = i.next(); try { reader.setInput(stream); return new Dimension(reader.getWidth(0), reader.getHeight(0)); } finally { reader.dispose(); } }
public void runTest(Object ctx, int numReps) { final Context ictx = (Context)ctx; final ImageReader reader = ictx.reader; final boolean seekForwardOnly = ictx.seekForwardOnly; final boolean ignoreMetadata = ictx.ignoreMetadata; do { try { ImageInputStream iis = ictx.createImageInputStream(); reader.setInput(iis, seekForwardOnly, ignoreMetadata); reader.read(0); reader.reset(); iis.close(); ictx.closeOriginalStream(); } catch (IOException e) { e.printStackTrace(); } } while (--numReps >= 0); }
public static ImageReader F2IR(String input) throws IOException { final File file = new File(input); // ��ȡͼƬ��ʽ final String formatname = GetPostfix.fromFilepath(input); Iterator<ImageReader> readers; ImageReader reader; ImageInputStream iis; readers = ImageIO.getImageReadersByFormatName(formatname); reader = readers.next(); iis = ImageIO.createImageInputStream(file); reader.setInput(iis, false); return reader; }
/** * Retrieves a JPEG reader which supports native JPEG stream metadata. */ private static ImageReader getJPEGTablesReader() { ImageReader jpegReader = null; try { IIORegistry registry = IIORegistry.getDefaultInstance(); Iterator<?> readerSPIs = registry.getServiceProviders(ImageReaderSpi.class, new JPEGSPIFilter(), true); if(readerSPIs.hasNext()) { ImageReaderSpi jpegReaderSPI = (ImageReaderSpi)readerSPIs.next(); jpegReader = jpegReaderSPI.createReaderInstance(); } } catch(Exception e) { // Ignore it ... } return jpegReader; }
@Override public void newData(byte[] bytes) { if(Dashboard.visionInitialized()){ Mat m = CvProcessing.byteArray2Mat(bytes); Dashboard.setForVision(m); } if(mode == DisplayMode.Normal){ ByteArrayInputStream bis = new ByteArrayInputStream(bytes); Iterator<?> readers = ImageIO.getImageReadersByFormatName("jpeg"); ImageReader reader = (ImageReader) readers.next(); Object source = bis; try { ImageInputStream iis = ImageIO.createImageInputStream(source); reader.setInput(iis, true); ImageReadParam param = reader.getDefaultReadParam(); BufferedImage image = reader.read(0, param); setImage(image); } catch (IOException e) { } } }
private static void testType(ImageReader reader, ImageTypeSpecifier t, BufferedImage src) throws IOException { ImageReadParam p = reader.getDefaultReadParam(); p.setDestinationType(t); BufferedImage dst = reader.read(0, p); verify(src, dst, t); }
public static BufferedImage readTestImage(String fileName, BufferedImage dest, Rectangle srcROI) { BufferedImage bi = null; try { FileImageInputStream is = new FileImageInputStream(new File(fileName)); ImageReader reader = (ImageReader)ImageIO.getImageReaders(is).next(); ImageReadParam param = reader.getDefaultReadParam(); if (dest != null) { param.setDestination(dest); } if (srcROI != null) { param.setSourceRegion(srcROI); } reader.setInput(is); bi = reader.read(0, param); } catch (IOException e) { System.err.println("Error " + e + " when reading file: " + fileName); throw new RuntimeException(e); } return bi; }
/** * * @param imageFile * @param band form files with multiple band */ public TIFF(File imageFile,int band) { this.imageFile=imageFile; try { Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName("tiff"); boolean worked=false; while(readers.hasNext()&&!worked){ Object obj=readers.next(); if( obj instanceof TIFFImageReader){ reader = (TIFFImageReader)obj; iis=ImageIO.createImageInputStream(imageFile); reader.setInput(iis); try{ xSize=reader.getWidth(band); ySize=reader.getHeight(band); bounds=new Rectangle(0,0,xSize,ySize); }catch(Exception e){ bounds=null; logger.warn("Problem reading size information"); } worked=true; }else{ } } if(!worked){ logger.warn("No reader avalaible for this image"); } } catch (Exception ex) { logger.error(ex.getMessage(),ex); } }
public DestTypeTest() { w = (ImageWriter) ImageIO.getImageWritersByFormatName("jpeg").next(); w.addIIOWriteWarningListener(this); r = (ImageReader) ImageIO.getImageReadersByFormatName("jpeg").next(); r.addIIOReadWarningListener(this); }
@Test public void testUpdateIcon() throws IOException { final LinkedMultiValueMap<String, Object> multipartData = new LinkedMultiValueMap<>(); multipartData.add("icon", new InputStreamResource(getClass().getResourceAsStream("test-image.png"))); final ResponseEntity<Connector> updated = post("/api/v1/connectors/twitter/icon", multipartData, Connector.class, tokenRule.validToken(), HttpStatus.OK, multipartHeaders()); assertThat(updated.getBody().getId()).isPresent(); assertThat(updated.getBody().getIcon()).isNotBlank().startsWith("db:"); final ResponseEntity<ByteArrayResource> got = get("/api/v1/connectors/twitter/icon", ByteArrayResource.class); assertThat(got.getHeaders().getFirst("Content-Type")).isEqualTo("image/png"); try (ImageInputStream iis = ImageIO.createImageInputStream(got.getBody().getInputStream());) { final Iterator<ImageReader> readers = ImageIO.getImageReaders(iis); if (readers.hasNext()) { final ImageReader reader = readers.next(); try { reader.setInput(iis); final Dimension dimensions = new Dimension(reader.getWidth(0), reader.getHeight(0)); assertThat(dimensions.getHeight()).isEqualTo(106d).as("Wrong image height"); assertThat(dimensions.getWidth()).isEqualTo(106d).as("Wrong image width"); } finally { reader.dispose(); } } } }
public static ImageReader IS2IR(ImageInputStream input, String formatname) throws IOException { Iterator<ImageReader> readers; ImageReader reader; readers = ImageIO.getImageReadersByFormatName(formatname); reader = readers.next(); reader.setInput(input, false); return reader; }
@Override public BufferedImage read(Class<? extends BufferedImage> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { ImageInputStream imageInputStream = null; ImageReader imageReader = null; try { imageInputStream = createImageInputStream(inputMessage.getBody()); MediaType contentType = inputMessage.getHeaders().getContentType(); Iterator<ImageReader> imageReaders = ImageIO.getImageReadersByMIMEType(contentType.toString()); if (imageReaders.hasNext()) { imageReader = imageReaders.next(); ImageReadParam irp = imageReader.getDefaultReadParam(); process(irp); imageReader.setInput(imageInputStream, true); return imageReader.read(0, irp); } else { throw new HttpMessageNotReadableException( "Could not find javax.imageio.ImageReader for Content-Type [" + contentType + "]"); } } finally { if (imageReader != null) { imageReader.dispose(); } if (imageInputStream != null) { try { imageInputStream.close(); } catch (IOException ex) { // ignore } } } }
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; } }
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 Exception { Iterator<ImageReader> readers = ImageIO.getImageReadersBySuffix("simp"); ImageReader simpReader = null; if (readers.hasNext()) { simpReader = readers.next(); System.out.println("reader="+simpReader); } if (simpReader == null) { throw new RuntimeException("Reader not found."); } ImageReaderSpi spi = simpReader.getOriginatingProvider(); IIOMetadataFormat spiFmt = spi.getImageMetadataFormat("simp_metadata_1.0"); System.out.println("fmt from SPI=" + spiFmt); ByteArrayInputStream bais = new ByteArrayInputStream(simpData); ImageInputStream iis = new MemoryCacheImageInputStream(bais); simpReader.setInput(iis); BufferedImage bi = simpReader.read(0); System.out.println(bi); IIOMetadata metadata = simpReader.getImageMetadata(0); System.out.println("Image metadata="+metadata); IIOMetadataFormat format = metadata.getMetadataFormat("simp_metadata_1.0"); System.out.println("Image metadata format="+format); if (format == null) { throw new RuntimeException("MetadataFormat not found."); } }
@Test public void testCropFullWidthOffset() throws IOException { ImageReader reader = getReader("prime_shaped.jpg"); TurboJpegImageReadParam param = (TurboJpegImageReadParam) reader.getDefaultReadParam(); param.setSourceRegion(new Rectangle(21, 192, 500, 172)); BufferedImage img = reader.read(0, param); assertThat(img).hasDimensions(500, 172); }
private static void doTest(int type) throws IOException { BufferedImage src = createTestImage(type); File f = new File("test.jpg"); if (!ImageIO.write(src, "jpg", f)) { throw new RuntimeException("Failed to write test image."); } ImageInputStream iis = ImageIO.createImageInputStream(f); ImageReader reader = ImageIO.getImageReaders(iis).next(); reader.setInput(iis); Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0); ImageTypeSpecifier srgb = null; ImageTypeSpecifier gray = null; // look for gray and srgb types while ((srgb == null || gray == null) && types.hasNext()) { ImageTypeSpecifier t = types.next(); if (t.getColorModel().getColorSpace().getType() == TYPE_GRAY) { gray = t; } if (t.getColorModel().getColorSpace() == sRGB) { srgb = t; } } if (gray == null) { throw new RuntimeException("No gray type available."); } if (srgb == null) { throw new RuntimeException("No srgb type available."); } System.out.println("Read as GRAY..."); testType(reader, gray, src); System.out.println("Read as sRGB..."); testType(reader, srgb, src); }
@Test public void testCropFullHeight() throws IOException { ImageReader reader = getReader("prime_shaped.jpg"); TurboJpegImageReadParam param = (TurboJpegImageReadParam) reader.getDefaultReadParam(); param.setSourceRegion(new Rectangle(192, 0, 172, 509)); BufferedImage img = reader.read(0, param); assertThat(img).hasDimensions(172, 509); }
@Test public void testReadUnalignedRotated() throws IOException { ImageReader reader = getReader("crop_unaligned_rot90.jpg"); TurboJpegImageReadParam param = (TurboJpegImageReadParam) reader.getDefaultReadParam(); param.setSourceRegion(new Rectangle(16, 16, 339, 319)); param.setRotationDegree(90); BufferedImage img = reader.read(0, param); assertThat(img) .hasDimensions(319, 339) .hasNoPixelsOfColor(-1 /* white */); }
public void imageUpdate(ImageReader source, BufferedImage theImage, int minX, int minY, int width, int height, int periodX, int periodY, int[] bands) { System.out.println("imageUpdate"); isImageUpdateUsed = true; }
private static void testGetReaderFormatNames() { String[] names = ImageIO.getReaderFormatNames(); for (String n : names) { Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(n); if (!it.hasNext()) { throw new RuntimeException("getReaderFormatNames returned " + "an unknown name: " + n); } } }
public static BufferedImage getDestination(ImageReadParam param, Iterator imageTypes, int width, int height) throws IIOException { return ImageReader.getDestination(param, imageTypes, width, height); }
public static void main(String[] args) throws IOException { // Generate some trivial image and save it to a temporary array ByteArrayOutputStream tmp = new ByteArrayOutputStream(); ImageIO.write(new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB), "gif", tmp); // Read it back in ImageInputStream in = new MemoryCacheImageInputStream( new ByteArrayInputStream(tmp.toByteArray())); ImageReader reader = ImageIO.getImageReaders(in).next(); reader.setInput(in); // Retrieve standard image metadata tree IIOMetadata meta = reader.getImageMetadata(0); if (meta == null || !meta.isStandardMetadataFormatSupported()) { throw new Error("Test failure: Missing metadata"); } Element root = (Element) meta. getAsTree(IIOMetadataFormatImpl.standardMetadataFormatName); NodeList nodeList = root. getElementsByTagName(root.getFirstChild().getNodeName()); /* * Accessing the nth node should return null and not throw * IndexOutOfBoundsException. */ Node n = (nodeList.item(nodeList.getLength())); }
private ImageReaderSpi constructImageReaderSpi() { return new ImageReaderSpi(vendorName, version, names, suffixes, MIMETypes, readerClassName, inputTypes, writerSpiNames, false, nativeStreamMetadataFormatName, nativeStreamMetadataFormatClassName, extraStreamMetadataFormatNames, extraStreamMetadataFormatClassNames, false, nativeImageMetadataFormatName, nativeImageMetadataFormatClassName, extraImageMetadataFormatNames, extraImageMetadataFormatClassNames) { public String getDescription(Locale locale) { return null; } public boolean canDecodeInput(Object source) { return false; } public ImageReader createReaderInstance(Object extension) { return null; } }; }
@Override public void imageStarted(ImageReader source, int imageIndex) { System.out.println("imageStarted called"); if (startAbort) { source.abort(); } }
public ReadAbortTest(String format) throws Exception { try { System.out.println("Test for format " + format); bimg = new BufferedImage(width, heght, BufferedImage.TYPE_INT_RGB); Graphics2D g = bimg.createGraphics(); g.setColor(srccolor); g.fillRect(0, 0, width, heght); g.dispose(); file = File.createTempFile("src_", "." + format, new File(".")); ImageIO.write(bimg, format, file); ImageInputStream iis = ImageIO.createImageInputStream(file); Iterator iter = ImageIO.getImageReaders(iis); while (iter.hasNext()) { reader = (ImageReader) iter.next(); break; } reader.setInput(iis); reader.addIIOReadProgressListener(this); // Abort reading in IIOReadProgressListener.imageStarted(). startAbort = true; bimg = reader.read(0); startAbort = false; // Abort reading in IIOReadProgressListener.imageProgress(). progressAbort = true; bimg = reader.read(0); progressAbort = false; iis.close(); /* * All abort requests from imageStarted,imageProgress and * imageComplete from IIOReadProgressListener should be reached * otherwise throw RuntimeException. */ if (!(startAborted && progressAborted)) { throw new RuntimeException("All IIOReadProgressListener abort" + " requests are not processed for format " + format); } } catch (Exception e) { throw e; } finally { Files.delete(file.toPath()); } }
@Test public void testUpdateConnectorAndIconViaMultipart() throws IOException { final Connector initialConnector = dataManager.fetch(Connector.class, "twitter"); assertThat(initialConnector.getIcon()).isNotBlank().doesNotStartWith("db:"); final Connector connectorWithNewdescription = new Connector.Builder().createFrom(initialConnector) .description("Updated!").build(); final LinkedMultiValueMap<String, Object> multipartData = new LinkedMultiValueMap<>(); multipartData.add("connector", connectorWithNewdescription); multipartData.add("icon", new InputStreamResource(getClass().getResourceAsStream("test-image.png"))); final ResponseEntity<Void> updated = put("/api/v1/connectors/twitter", multipartData, Void.class, tokenRule.validToken(), HttpStatus.NO_CONTENT, multipartHeaders()); final ResponseEntity<Connector> updatedConnector = get("/api/v1/connectors/twitter", Connector.class); assertThat(updatedConnector.getBody().getId()).isPresent(); assertThat(updatedConnector.getBody().getIcon()).isNotBlank().startsWith("db:"); assertThat(updatedConnector.getBody().getDescription()).isNotBlank().isEqualTo("Updated!"); final ResponseEntity<ByteArrayResource> got = get("/api/v1/connectors/twitter/icon", ByteArrayResource.class); assertThat(got.getHeaders().getFirst("Content-Type")).isEqualTo("image/png"); try (ImageInputStream iis = ImageIO.createImageInputStream(got.getBody().getInputStream());) { final Iterator<ImageReader> readers = ImageIO.getImageReaders(iis); if (readers.hasNext()) { final ImageReader reader = readers.next(); try { reader.setInput(iis); final Dimension dimensions = new Dimension(reader.getWidth(0), reader.getHeight(0)); assertThat(dimensions.getHeight()).isEqualTo(106d).as("Wrong image height"); assertThat(dimensions.getWidth()).isEqualTo(106d).as("Wrong image width"); } finally { reader.dispose(); } } } }
public ImageReader createReaderInstance(Object extension) throws IIOException { return new WBMPImageReader(this); }
public void imageStarted(ImageReader source, int imageIndex) {}
public ImageReader createReaderInstance(Object extension) throws IOException { return new DummyImageReaderImpl(this); }
public void setTarget(ImageReader target) { this.target = target; }
public ImageReader createReaderInstance(Object extension) { return new PNGImageReader(this); }
public void thumbnailStarted(ImageReader source, int imageIndex, int thumbnailIndex) {}
@Override public ImageReader createReaderInstance(Object extension) throws IOException { loadLibrary(); return new OpenJp2ImageReader(this, this.lib); }
@Test public void testRead() throws IOException { ImageReader reader = getReader("rgb.jpg"); BufferedImage img = reader.read(0, null); assertThat(img).hasDimensions(512, 512); }
public void imageProgress(ImageReader source, float percentageDone) { reader.thumbnailProgress(percentageDone); }
public void setReader(ImageReader reader) { if(decompressor != null) { decompressor.setReader(reader); } super.setReader(reader); }
public void imageProgress(ImageReader source, float percentageDone) { System.out.println("Image Progress "+percentageDone); progress.add(new Float(percentageDone)); }