Java 类javax.imageio.ImageReader 实例源码

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);
}

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 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));
}