Example usage for javax.imageio ImageIO createImageInputStream

List of usage examples for javax.imageio ImageIO createImageInputStream

  1. HOME
  2. Java
  3. javax
  4. javax.imageio.*
  5. ImageIO
  6. createImageInputStream

Introduction

In this page you can find the example usage for javax.imageio ImageIO createImageInputStream.

Prototype

public static ImageInputStream createImageInputStream(Object input) throws IOException

Source Link

Document

Returns an ImageInputStream that will take its input from the given Object .

Usage

From source file:common.utils.ImageUtils.java

/**
 *
 * @param in//from  ww w.  ja  v a 2 s .  com
 * @return image from given stream or null if no readers found
 * @throws java.io.IOException
 */
public static BufferedImageHolder readImage(File in) throws IOException {
    ImageInputStream iis = ImageIO.createImageInputStream(in);
    BufferedImageHolder bih = readImage(iis);
    if (bih != null)
        bih.setFile(in);
    return bih;
}

From source file:common.utils.ImageUtils.java

/**
 *
 * @param in//from w  ww  .j  av  a 2 s . c o  m
 * @return image from given stream or null if no readers found
 * @throws java.io.IOException
 */
public static BufferedImageHolder readImage(MultipartFile in) throws IOException {
    InputStream is = in.getInputStream();
    ImageInputStream iis = ImageIO.createImageInputStream(is);
    BufferedImageHolder bih = readImage(iis);
    is.close();
    if (bih != null)
        bih.setMultipart(in);
    return bih;
}

From source file:org.geotools.gce.imagepyramid.ImagePyramidReaderTest.java

@Test
public void testForErrors() throws IOException, MismatchedDimensionException, NoSuchAuthorityCodeException {
    ///*w w w  .j  av  a  2  s.c  om*/
    // Get the resource.
    //
    final File testFile = TestData.file(this, TEST_FILE);//
    assertNotNull(testFile);

    //
    // Null argument
    //
    ImagePyramidReader reader = null;
    try {
        reader = new ImagePyramidReader(null, new Hints(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE));
    } catch (DataSourceException e) {

    }
    assertNull(reader);

    //
    // Illegal arguments
    //
    try {
        reader = new ImagePyramidReader(new FileInputStream(testFile),
                new Hints(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE));
    } catch (IllegalArgumentException e) {

    }
    assertNull(reader);
    try {
        reader = new ImagePyramidReader(ImageIO.createImageInputStream(testFile),
                new Hints(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE));
    } catch (IllegalArgumentException e) {

    }
    assertNull(reader);

    //
    // Unsopported operation
    reader = new ImagePyramidReader(testFile, new Hints(Hints.FORCE_LONGITUDE_FIRST_AXIS_ORDER, Boolean.FALSE));

    try {
        reader.getCurrentSubname();

    } catch (UnsupportedOperationException e) {
        try {
            String[] names = reader.getMetadataNames();
            assertNull(names);

        } catch (UnsupportedOperationException e1) {

        }

        try {
            String value = reader.getMetadataValue("");
            assertNull(value);
            return;
        } catch (UnsupportedOperationException e2) {
            return;
        }
    }
    assertTrue("Some of the unsopported method did not send an exception", false);

}

From source file:net.sf.webphotos.tools.Thumbnail.java

private static String getFormatName(Object o) {
    try {//from   ww  w. j av  a 2  s  . co m
        // Create an image input stream on the image
        ImageInputStream iis = ImageIO.createImageInputStream(o);

        // Find all image readers that recognize the image format
        Iterator<ImageReader> iter = ImageIO.getImageReaders(iis);
        if (!iter.hasNext()) {
            // No readers found
            return null;
        }

        // Use the first reader
        ImageReader reader = iter.next();

        // Close stream
        iis.close();

        // Return the format name
        return reader.getFormatName();
    } catch (Exception e) {
        // The image could not be read
        return null;
    }
}

From source file:net.filterlogic.util.imaging.ToTIFF.java

/**
 * //from   www.jav  a2 s . c  o m
 * @param fileName
 */
public void test6(String fileName) {
    try {
        File f = new File(fileName);

        ImageInputStream imageInputStream = ImageIO.createImageInputStream(f);
        java.util.Iterator readers = ImageIO.getImageReaders(imageInputStream);
        ImageReader reader1 = (ImageReader) readers.next();
        ImageInputStream iis = ImageIO.createImageInputStream(new FileInputStream(f));
        reader1.setInput(iis);

        int number = reader1.getNumImages(true);
        Iterator writers = ImageIO.getImageWritersByFormatName("tiff");
        ImageWriter writer = (ImageWriter) writers.next();

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ImageOutputStream ios = null;
        BufferedImage img = null;

        for (int i = 0; i < number; i++) {
            img = reader1.read(i);
            ios = ImageIO.createImageOutputStream(byteOut);
            writer.setOutput(ios);
            writer.write(img);
            ios.flush();
            img.flush();
            byteOut.flush();
        }

    } catch (Exception e) {
        System.out.println(e.toString());
    }

}

From source file:org.photovault.image.ImageIOImage.java

/**
 * Parse JPEG metadata structure and store the data in metadata and exifData fields
 * @param top The metadata object tree in format "javax_imageio_jpeg_image_1.0"
 *//*from  ww w .j av  a2s  .  c  o  m*/
private void parseJPEGMetadata(IIOMetadataNode top) {
    NodeList candidates = top.getElementsByTagName("unknown");
    for (int n = 0; n < candidates.getLength(); n++) {
        Node node = candidates.item(n);
        if (node instanceof IIOMetadataNode) {
            IIOMetadataNode m = (IIOMetadataNode) node;
            Object obj = m.getUserObject();
            if (obj instanceof byte[]) {
                byte[] data = (byte[]) obj;
                if (data[0] == 'E' && data[1] == 'x' && data[2] == 'i' && data[3] == 'f') {
                    log.debug("exif data found");
                    InputStream is = new ByteArrayInputStream(data, 6, data.length - 6);
                    try {
                        ImageInputStream metadataStream = ImageIO.createImageInputStream(is);
                        Iterator readers = ImageIO.getImageReadersByFormatName("TIFF");
                        if (readers.hasNext()) {
                            ImageReader reader = (ImageReader) readers.next();
                            reader.setInput(metadataStream);
                            IIOMetadata iioMetadata = reader.getImageMetadata(0);
                            this.metadata = TIFFDirectory.createFromMetadata(iioMetadata);
                            TIFFField exifField = this.metadata
                                    .getTIFFField(EXIFParentTIFFTagSet.TAG_EXIF_IFD_POINTER);
                        }
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                } else if (data.length > 28 && data[28] == 0) {
                    String id = null;
                    try {
                        id = new String(data, 0, 28, "utf-8");
                    } catch (UnsupportedEncodingException e) {
                        log.error(e);
                    }
                    if ("http://ns.adobe.com/xap/1.0/".equals(id)) {

                        // XMP metadata
                        try {
                            String xmpPacket = new String(data, 29, data.length - 29, "utf-8");
                            XMPMeta xmp = XMPMetaFactory.parseFromString(xmpPacket);
                            log.debug("Found XMP metadata");
                        } catch (XMPException e) {
                            log.warn("caught XMP exception while parsing metadata", e);
                        } catch (UnsupportedEncodingException e) {
                            log.error(e);
                        }
                    }
                }
            }
        }
    }
}

From source file:com.lm.lic.manager.util.GenUtil.java

public static String senseImageFormat(byte[] icon) throws Exception {
    try {//from   ww  w. jav a2 s  . c  o  m
        ByteArrayInputStream bais = new ByteArrayInputStream(icon);
        // Create an image input stream on the image
        ImageInputStream iis = ImageIO.createImageInputStream(bais);
        ImageIO.getReaderFormatNames();

        // Find all image readers that recognize the image format
        Iterator<ImageReader> iter = ImageIO.getImageReaders(iis);
        if (!iter.hasNext()) {
            return null;
        }
        ImageReader reader = iter.next();
        iis.close();
        return reader.getFormatName();
    } catch (IOException e) {
    }

    return null;
}

From source file:org.medici.bia.controller.manuscriptviewer.IIPImageServerController.java

/**
 * // w  w  w .j  a  va  2  s .c o m
 * @param fileName
 * @param pageImage
 * @param tileNumber
 * @param xCoordinate
 * @param yCoordinate
 * @param httpServletResponse
 */
@SuppressWarnings("unused")
private void generateTiledImage(String fileName, Integer pageImage, Integer tileNumber, Integer xCoordinate,
        Integer yCoordinate, HttpServletResponse httpServletResponse) {
    File imageFile = new File(
            ApplicationPropertyManager.getApplicationProperty("iipimage.image.path") + fileName);
    Integer imageWidth = new Integer(0);
    Integer imageHeight = new Integer(0);
    Integer tileWidth = new Integer(0);
    Integer tileHeight = new Integer(0);
    Integer resolutionNumber = new Integer(0);
    Integer convertedPageImage = new Integer(0);

    ImageInputStream imageInputStream = null;
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    InputStream inputStream = null;

    try {
        if (imageFile.canRead()) {
            // Reading complete tiff information
            imageInputStream = ImageIO.createImageInputStream(imageFile);
        } else {
            logger.error("File " + imageFile.toString() + " is not present on filesystem. ");
            imageFile = new File(ApplicationPropertyManager.getApplicationProperty("iipimage.image.path")
                    + ApplicationPropertyManager.getApplicationProperty("iipimage.image.notavailable"));
            if (imageFile.canRead()) {
                // Reading complete tiff information
                imageInputStream = ImageIO.createImageInputStream(imageFile);
            } else {
                logger.error("File " + imageFile.toString() + " is not present on filesystem. ");
            }
        }

        if (imageInputStream != null) {
            Iterator<ImageReader> readers = ImageIO.getImageReaders(imageInputStream);
            if (readers.hasNext()) {
                ImageReader reader = readers.next();
                reader.setInput(imageInputStream, false, true);
                tileWidth = reader.getTileWidth(0);
                tileHeight = reader.getTileHeight(0);
                imageWidth = reader.getWidth(0);
                imageHeight = reader.getHeight(0);
                // Last level is not readable, I don't know why but i remove
                // this
                resolutionNumber = reader.getNumImages(true) - 1;
                // Calculate of image position, final -1 is beacause index
                // start from 0 and not from 1
                convertedPageImage = resolutionNumber - pageImage;
                // We read our specific tile
                ImageReadParam param = reader.getDefaultReadParam();
                param.setSourceRegion(
                        new Rectangle(new Point(xCoordinate * tileWidth, yCoordinate * tileHeight),
                                new Dimension(tileWidth, tileHeight)));
                BufferedImage subImage = reader.read(convertedPageImage, param);
                // preparing image for output
                ImageIO.write(subImage, "jpeg", byteArrayOutputStream);
                inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
                // writing image to output
                httpServletResponse.setContentType("image/jpeg");
                IOUtils.copy(inputStream, httpServletResponse.getOutputStream());

                // Flushing request
                httpServletResponse.getOutputStream().flush();
            }
        } else {
            logger.error("File " + imageFile.toString() + " is not present on filesystem.");
        }
    } catch (IOException ioException) {
        logger.error(ioException);
    } finally {
        try {
            if (inputStream != null) {
                inputStream.close();
            }
        } catch (IOException ioException) {
        }
        try {
            if (byteArrayOutputStream != null) {
                byteArrayOutputStream.close();
            }
        } catch (IOException ioException) {
        }
        try {
            if (imageInputStream != null) {
                imageInputStream.close();
            }
        } catch (IOException ioException) {
        }
    }
}

From source file:org.apache.pdfbox.tools.imageio.TestImageIOUtils.java

/**
 * checks whether the resolution of an image file is as expected.
 *
 * @param filename the name of the file//from   ww  w . j  a va 2 s.c o  m
 * @param expectedResolution the expected resolution
 *
 * @throws IOException if something goes wrong
 */
private void checkResolution(String filename, int expectedResolution) throws IOException {
    assertFalse("Empty file " + filename, new File(filename).length() == 0);
    String suffix = filename.substring(filename.lastIndexOf('.') + 1);
    if ("BMP".equals(suffix.toUpperCase())) {
        // BMP reader doesn't work
        checkBmpResolution(filename, expectedResolution);
        return;
    }
    Iterator readers = ImageIO.getImageReadersBySuffix(suffix);
    assertTrue("No image reader found for suffix " + suffix, readers.hasNext());
    ImageReader reader = (ImageReader) readers.next();
    ImageInputStream iis = ImageIO.createImageInputStream(new File(filename));
    assertNotNull("No ImageInputStream created for file " + filename, iis);
    reader.setInput(iis);
    IIOMetadata imageMetadata = reader.getImageMetadata(0);
    Element root = (Element) imageMetadata.getAsTree(STANDARD_METADATA_FORMAT);
    NodeList dimensionNodes = root.getElementsByTagName("Dimension");
    assertTrue("No resolution found in image file " + filename, dimensionNodes.getLength() > 0);
    Element dimensionElement = (Element) dimensionNodes.item(0);

    NodeList pixelSizeNodes = dimensionElement.getElementsByTagName("HorizontalPixelSize");
    assertTrue("No X resolution found in image file " + filename, pixelSizeNodes.getLength() > 0);
    Node pixelSizeNode = pixelSizeNodes.item(0);
    String val = pixelSizeNode.getAttributes().getNamedItem("value").getNodeValue();
    int actualResolution = (int) Math.round(25.4 / Double.parseDouble(val));
    assertEquals("X resolution doesn't match in image file " + filename, expectedResolution, actualResolution);

    pixelSizeNodes = dimensionElement.getElementsByTagName("VerticalPixelSize");
    assertTrue("No Y resolution found in image file " + filename, pixelSizeNodes.getLength() > 0);
    pixelSizeNode = pixelSizeNodes.item(0);
    val = pixelSizeNode.getAttributes().getNamedItem("value").getNodeValue();
    actualResolution = (int) Math.round(25.4 / Double.parseDouble(val));
    assertEquals("Y resolution doesn't match", expectedResolution, actualResolution);

    iis.close();
    reader.dispose();
}

From source file:it.tidalwave.imageio.test.ImageReaderTestSupport.java

/*******************************************************************************************************************
 * /*from   w w w  . j  ava  2s.  c om*/
 * 
 ******************************************************************************************************************/
@Nonnull
protected ImageReader getImageReader(final @Nonnull String path, final @Nonnull RAWImageReadParam readParam)
        throws IOException {
    logger.info("************* TESTING FILE: %s - %s", path, readParam);

    final File file = getTestFile(path);
    final ImageReader ir = ImageIO.getImageReaders(file).next();
    assertNotNull(ir);

    if (readParam != null) {
        ((RAWImageReader) ir).setDefaultReadParam(readParam);
    }

    ir.setInput(ImageIO.createImageInputStream(file));
    return ir;
}