Example usage for javax.imageio ImageIO getImageReadersBySuffix

List of usage examples for javax.imageio ImageIO getImageReadersBySuffix

Introduction

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

Prototype

public static Iterator<ImageReader> getImageReadersBySuffix(String fileSuffix) 

Source Link

Document

Returns an Iterator containing all currently registered ImageReader s that claim to be able to decode files with the given suffix.

Usage

From source file:com.moviejukebox.scanner.artwork.FanartScanner.java

public static boolean validateArtwork(IImage artworkImage, int artworkWidth, int artworkHeight,
        boolean checkAspect) {
    @SuppressWarnings("rawtypes")
    Iterator readers = ImageIO.getImageReadersBySuffix("jpeg");
    ImageReader reader = (ImageReader) readers.next();
    int urlWidth, urlHeight;
    float urlAspect;

    if (!ARTWORK_VALIDATE) {
        return true;
    }/*w  ww.  ja v a 2  s  . c om*/

    if (StringTools.isNotValidString(artworkImage.getUrl())) {
        return false;
    }

    try {
        URL url = new URL(artworkImage.getUrl());

        try (InputStream in = url.openStream(); ImageInputStream iis = ImageIO.createImageInputStream(in)) {
            reader.setInput(iis, true);
            urlWidth = reader.getWidth(0);
            urlHeight = reader.getHeight(0);
        }
    } catch (IOException error) {
        LOG.debug("ValidateFanart error: {}: can't open url", error.getMessage());
        return false; // Quit and return a false fanart
    }

    urlAspect = (float) urlWidth / (float) urlHeight;

    if (checkAspect && urlAspect < 1.0) {
        LOG.debug("ValidateFanart {} rejected: URL is portrait format", artworkImage);
        return false;
    }

    // Adjust fanart width / height by the ValidateMatch figure
    int newArtworkWidth = artworkWidth * (ARTWORK_VALIDATE_MATCH / 100);
    int newArtworkHeight = artworkHeight * (ARTWORK_VALIDATE_MATCH / 100);

    if (urlWidth < newArtworkWidth) {
        LOG.debug("{} rejected: URL width ({}) is smaller than fanart width ({})", artworkImage, urlWidth,
                newArtworkWidth);
        return false;
    }

    if (urlHeight < newArtworkHeight) {
        LOG.debug("{} rejected: URL height ({}) is smaller than fanart height ({})", artworkImage, urlHeight,
                newArtworkHeight);
        return false;
    }
    return true;
}

From source file:com.moviejukebox.scanner.artwork.PosterScanner.java

/**
 * Read an URL and get the dimensions of the image using a specific image
 * type/*ww  w. j a  va 2  s . c o m*/
 *
 * @param imageUrl
 * @param imageType
 * @return
 */
public static Dimension getUrlDimensions(String imageUrl, String imageType) {
    Dimension imageDimension = new Dimension(0, 0);

    @SuppressWarnings("rawtypes")
    Iterator readers = ImageIO.getImageReadersBySuffix(imageType);

    if (readers.hasNext()) {
        ImageReader reader = (ImageReader) readers.next();

        try (InputStream in = new URL(imageUrl).openStream();
                ImageInputStream iis = ImageIO.createImageInputStream(in)) {
            reader.setInput(iis, Boolean.TRUE);
            imageDimension.setSize(reader.getWidth(0), reader.getHeight(0));
        } catch (IOException ex) {
            LOG.debug("getUrlDimensions error: {}: can't open url: {}", ex.getMessage(), imageUrl);
        } finally {
            reader.dispose();
        }
    }

    return imageDimension;
}

From source file:net.naijatek.myalumni.modules.members.presentation.action.MaintainMemberAction.java

public ActionForward updateMemberAvatar(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {

    ActionMessages errors = new ActionMessages();
    String fileTypes = SystemConfigConstants.CONTENT_TYPE;
    String avatarDir = getSysProp().getValue("AVATAR.FILEPATH");
    MyAlumniUserContainer continer = getUserContainer(request);

    int maxFileSize = 0;
    int maxHeight = 0;
    int maxWidth = 0;
    String overwrite = "false";

    if (isCancelled(request)) {
        return mapping.findForward(BaseConstants.FWD_CANCEL);
    }/*from  w  w w .  j a  va2s.  c  o m*/

    MemberVO token = getCurrentLoggedInUser(request);
    MemberForm memberForm = (MemberForm) form;

    if (!memberSecurityCheck(request, token)) {
        return mapping.findForward(BaseConstants.FWD_LOGIN);
    }

    //  Set Max Size
    try {
        maxFileSize = Integer.parseInt(getAppProp().getValue("avatar.image.size").trim());
    } catch (Exception e) {
        maxFileSize = 120000; // 120000 Bytes  = 120 KB
    }

    // Set Max Height
    try {
        maxHeight = Integer.parseInt(getAppProp().getValue("avatar.image.height").trim());
    } catch (Exception e) {
        maxHeight = 200; // 200 px 
    }

    // Set Max Width
    try {
        maxWidth = Integer.parseInt(getAppProp().getValue("avatar.image.width").trim());
    } catch (Exception e) {
        maxWidth = 200; // 200 px 
    }

    FormFile importFile = memberForm.getAvatarUpload();
    overwrite = StringUtil.safeString(memberForm.getAvatarUploadOverwrite());
    String importFileName = getCurrentLoggedInUser(request).getMemberUserName() + "."
            + getFileExtensionForImageReader(importFile.getFileName());
    int size = importFile.getFileSize();

    //--------------------  VALIDATE THE IMAGE -----------------------------------------
    // check width and heigh of image
    logger.debug(importFileName + " ext = " + getFileExtensionForImageReader(importFileName));
    Iterator readers = ImageIO.getImageReadersBySuffix(getFileExtensionForImageReader(importFileName));
    ImageReader reader = (ImageReader) readers.next();

    try {
        ImageInputStream iis = ImageIO.createImageInputStream(importFile.getInputStream());
        reader.setInput(iis, true);
        int width = reader.getWidth(0);
        int height = reader.getHeight(0);
        logger.debug(importFile.getFileName() + ": width=" + width + ", height=" + height);
        if (width > maxWidth || height > maxHeight) {
            errors.add(BaseConstants.WARN_KEY,
                    new ActionMessage("error.dimensions", width, height, maxWidth, maxHeight));
            saveMessages(request, errors);
            return mapping.getInputForward();
        }
    } catch (IOException e) {
        System.err.println(e.getMessage() + ": can't open");
        errors.add(BaseConstants.FATAL_KEY, new ActionMessage("error.notreadable"));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    // check file name
    if (importFileName.indexOf(" ") > -1) {
        errors.add(BaseConstants.WARN_KEY, new ActionMessage("error.filename", importFileName));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    //boolean validImageName = false;
    /*      StringTokenizer st0 = new StringTokenizer(importFileName, ".");
          if (st0.hasMoreTokens()) {
            if (token.getMemberUserName().equals(st0.nextToken())) {
              //validImageName = true;
            }
            else{
              errors.add(BaseConstants.WARN_KEY, new ActionMessage("error.fileusername", token.getMemberUserName(),importFileName ));
              saveMessages(request, errors);
              return mapping.getInputForward();
            }
          }*/

    File f = new File(avatarDir + importFileName);
    if (f.exists() && (overwrite.equalsIgnoreCase("false") || overwrite.equalsIgnoreCase(""))) {
        continer.setOverWriteAvatar(true);
        errors.add(BaseConstants.WARN_KEY, new ActionMessage("error.filename.exist"));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    if (size > maxFileSize) {
        errors.add(BaseConstants.WARN_KEY,
                new ActionMessage("error.filetoobig", String.valueOf(size), String.valueOf(maxFileSize)));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    boolean validImageExtension = false;
    StringTokenizer st = new StringTokenizer(fileTypes, ",");

    logger.debug("Current Type = " + importFile.getContentType());
    while (st.hasMoreTokens()) {
        if (importFile.getContentType().equalsIgnoreCase(st.nextToken())) {
            validImageExtension = true;
        }
    }

    // check file extension
    if (!validImageExtension) {
        errors.add(BaseConstants.WARN_KEY, new ActionMessage("error.imageext", String.valueOf(fileTypes)));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    // apend the file extension 
    //avatar = avatar + "." + importFile.getContentType();

    //-------------------------------------------------------------

    if (!uploadFromLocalDrive(importFile, importFileName, avatarDir)) {
        errors.add(BaseConstants.FATAL_KEY, new ActionMessage("errors.technical.difficulty"));
        saveMessages(request, errors);
        return mapping.getInputForward();
    }

    memService.updateMemberAvatar(importFileName, token.getMemberUserName(), getLastModifiedBy(request));
    continer.setOverWriteAvatar(false);
    continer.setAvatar(importFileName);
    MemberVO memberVO = memService.getMemberProfileByUserName(token.getMemberUserName());
    BeanUtils.copyProperties(memberForm, memberVO);
    return mapping.findForward(BaseConstants.FWD_SUCCESS);
}

From source file:net.naijatek.myalumni.framework.struts.MyAlumniDispatchAction.java

protected ActionMessages validateUploadFile(HttpServletRequest request, FormFile uploadedFile,
        String fileAllowedTypes, int maxFileSize, boolean validateHeight, int maxHeight, boolean validateWidth,
        int maxWidth) {

    ActionMessages msgs = new ActionMessages();

    String fileName = uploadedFile.getFileName();
    int fileSize = uploadedFile.getFileSize();

    if (fileName == null || fileName.length() == 0) {
        msgs.add(BaseConstants.WARN_KEY, new ActionMessage("error.notreadable"));
    } else {/*from  w  w w.  j a  v a 2 s  .c o  m*/
        // Check for space in file name
        if (fileName.indexOf(" ") > -1) {
            msgs.add(BaseConstants.WARN_KEY, new ActionMessage("error.filename", fileName));
        }

        // check for file size
        if (fileSize > maxFileSize) {
            msgs.add(BaseConstants.WARN_KEY, new ActionMessage("error.filetoobig", String.valueOf(fileSize),
                    String.valueOf(maxFileSize)));
        }

        boolean validExtension = false;
        StringTokenizer st = new StringTokenizer(fileAllowedTypes, ",");
        while (st.hasMoreTokens()) {
            if (uploadedFile.getContentType().equalsIgnoreCase(st.nextToken())) {
                validExtension = true;
            }
        }

        if (!validExtension) {
            msgs.add(BaseConstants.WARN_KEY,
                    new ActionMessage("error.imageext", SystemConfigConstants.CONTENT_TYPE));
        } else {
            logger.debug(fileName + " ext = " + getFileExtensionForImageReader(fileName));
            Iterator readers = ImageIO.getImageReadersBySuffix(getFileExtensionForImageReader(fileName));
            ImageReader reader = (ImageReader) readers.next();

            try {
                ImageInputStream iis = ImageIO.createImageInputStream(uploadedFile.getInputStream());
                reader.setInput(iis, true);
                int width = reader.getWidth(0);
                int height = reader.getHeight(0);
                logger.debug(uploadedFile.getFileName() + ": width=" + width + ", height=" + height);

                if (validateHeight) {
                    if (height > maxHeight) {
                        msgs.add(BaseConstants.WARN_KEY,
                                new ActionMessage("error.heightdimensions", height, maxHeight));
                    }
                }

                if (validateWidth) {
                    if (width > maxWidth || height > maxHeight) {
                        msgs.add(BaseConstants.WARN_KEY,
                                new ActionMessage("error.widthdimensions", width, maxWidth));
                    }
                }
            } catch (IOException e) {
                msgs.add(BaseConstants.FATAL_KEY, new ActionMessage("error.notreadable"));
            }
        }
    }
    return msgs;
}

From source file:com.moviejukebox.scanner.artwork.ArtworkScanner.java

/**
 * Get the size of the file at the end of the URL
 *
 * Taken from: http://forums.sun.com/thread.jspa?threadID=528155&messageID=2537096
 *
 * @param artworkImage Artwork image to check
 * @param artworkWidth The width to check
 * @param artworkHeight The height to check
 * @param checkAspect Should the aspect ratio be checked
 * @return True if the poster is good, false otherwise
 *//* www.j av  a2s.  c o m*/
@Override
public boolean validateArtwork(IImage artworkImage, int artworkWidth, int artworkHeight, boolean checkAspect) {
    @SuppressWarnings("rawtypes")
    Iterator readers = ImageIO.getImageReadersBySuffix("jpeg");
    ImageReader reader = (ImageReader) readers.next();
    int urlWidth;
    int urlHeight;
    float urlAspect;

    if (!artworkValidate) {
        return Boolean.TRUE;
    }

    if (artworkImage.getUrl().equalsIgnoreCase(Movie.UNKNOWN)) {
        return Boolean.FALSE;
    }

    try (InputStream in = new URL(artworkImage.getUrl()).openStream();
            ImageInputStream iis = ImageIO.createImageInputStream(in)) {
        reader.setInput(iis, Boolean.TRUE);
        urlWidth = reader.getWidth(0);
        urlHeight = reader.getHeight(0);
    } catch (IOException ex) {
        LOG.debug("ValidateArtwork error: {}: can't open URL", ex.getMessage());
        return Boolean.FALSE; // Quit and return a Boolean.FALSE poster
    }

    urlAspect = (float) urlWidth / (float) urlHeight;

    if (checkAspect && urlAspect > 1.0) {
        LOG.debug("{} rejected: URL is wrong aspect (portrait/landscape)", artworkImage);
        return Boolean.FALSE;
    }

    // Adjust artwork width / height by the ValidateMatch figure
    int newArtworkWidth = artworkWidth * (artworkValidateMatch / 100);
    int newArtworkHeight = artworkHeight * (artworkValidateMatch / 100);

    if (urlWidth < newArtworkWidth) {
        LOG.debug("{} rejected: URL width ({}) is smaller than artwork width ({})", artworkImage, urlWidth,
                newArtworkWidth);
        return Boolean.FALSE;
    }

    if (urlHeight < newArtworkHeight) {
        LOG.debug("{} rejected: URL height ({}) is smaller than artwork height ({})", artworkImage, urlHeight,
                newArtworkHeight);
        return Boolean.FALSE;
    }
    return Boolean.TRUE;
}

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 w ww . j a v a2s  .  co  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:org.apache.pdfbox.tools.imageio.TestImageIOUtils.java

/**
 * checks whether the compression of a TIFF file is as expected.
 *
 * @param filename Filename// w w  w  .  ja v  a 2 s  .c  o m
 * @param expectedCompression expected TIFF compression
 *
 * @throws IOException if something goes wrong
 */
void checkTiffCompression(String filename, String expectedCompression) throws IOException {
    Iterator readers = ImageIO.getImageReadersBySuffix("tiff");
    ImageReader reader = (ImageReader) readers.next();
    ImageInputStream iis = ImageIO.createImageInputStream(new File(filename));
    reader.setInput(iis);
    IIOMetadata imageMetadata = reader.getImageMetadata(0);
    Element root = (Element) imageMetadata.getAsTree(STANDARD_METADATA_FORMAT);
    Element comprElement = (Element) root.getElementsByTagName("Compression").item(0);
    Node comprTypeNode = comprElement.getElementsByTagName("CompressionTypeName").item(0);
    String actualCompression = comprTypeNode.getAttributes().getNamedItem("value").getNodeValue();
    assertEquals("Incorrect TIFF compression in file " + filename, expectedCompression, actualCompression);
    iis.close();
    reader.dispose();
}

From source file:org.manasource.dyetool.ImageFilter.java

@Override
public boolean include(File file) {
    if (file.isDirectory()) {
        return false;
    }//www  .j  av a2  s.  c om

    return !ImageIO.getImageReadersBySuffix(FilenameUtils.getExtension(file.getName())).hasNext();
}

From source file:org.olat.core.commons.services.image.spi.AbstractImageHelper.java

private Size getImageSize(VFSLeaf media, String suffix) {
    Size result = null;//from   ww  w  .  j a va 2s  .  c  o  m
    Iterator<ImageReader> iter = ImageIO.getImageReadersBySuffix(suffix);
    if (iter.hasNext()) {
        ImageInputStream stream = null;
        InputStream mediaStream = null;
        ImageReader reader = iter.next();
        try {
            mediaStream = media.getInputStream();
            if (mediaStream != null) {
                stream = new MemoryCacheImageInputStream(mediaStream);
                reader.setInput(stream);
                int readerMinIndex = reader.getMinIndex();
                int width = reader.getWidth(readerMinIndex);
                int height = reader.getHeight(readerMinIndex);
                result = new Size(width, height, 0, 0, false);
            }
        } catch (IOException e) {
            log.error(e.getMessage());
        } finally {
            IOUtils.closeQuietly(stream);
            IOUtils.closeQuietly(mediaStream);
            reader.dispose();
        }
    } else {
        log.error("No reader found for given format: " + suffix);
    }
    return result;
}

From source file:org.olat.core.commons.services.image.spi.ImageHelperImpl.java

private static SizeAndBufferedImage calcScaledSize(ImageInputStream stream, String suffix, int maxWidth,
        int maxHeight, boolean fill) {
    Iterator<ImageReader> iter = ImageIO.getImageReadersBySuffix(suffix);
    if (iter.hasNext()) {
        ImageReader reader = iter.next();
        try {/*from   w  ww .j  a  va  2s .com*/
            reader.setInput(stream, true, true);
            int width = reader.getWidth(reader.getMinIndex());
            int height = reader.getHeight(reader.getMinIndex());
            Size size = new Size(width, height, false);
            Size scaledSize = computeScaledSize(width, height, maxWidth, maxHeight, fill);
            SizeAndBufferedImage all = new SizeAndBufferedImage(size, scaledSize);

            int readerMinIndex = reader.getMinIndex();
            ImageReadParam param = reader.getDefaultReadParam();
            Iterator<ImageTypeSpecifier> imageTypes = reader.getImageTypes(0);
            while (imageTypes.hasNext()) {
                try {
                    ImageTypeSpecifier imageTypeSpecifier = imageTypes.next();
                    int bufferedImageType = imageTypeSpecifier.getBufferedImageType();
                    if (bufferedImageType == BufferedImage.TYPE_BYTE_GRAY) {
                        param.setDestinationType(imageTypeSpecifier);
                    }

                    double memoryKB = (width * height * 4) / 1024d;
                    if (memoryKB > 2000) {// check limit at 20MB
                        double free = Runtime.getRuntime().freeMemory() / 1024d;
                        if (free > memoryKB) {
                            all.setImage(reader.read(readerMinIndex, param));
                        } else {
                            // make sub sampling to save memory
                            int ratio = (int) Math.round(Math.sqrt(memoryKB / free));
                            param.setSourceSubsampling(ratio, ratio, 0, 0);
                            all.setImage(reader.read(readerMinIndex, param));
                        }
                    } else {
                        all.setImage(reader.read(readerMinIndex, param));
                    }
                    return all;
                } catch (IllegalArgumentException e) {
                    log.warn(e.getMessage(), e);
                }
            }
        } catch (IOException e) {
            log.error(e.getMessage(), e);
        } finally {
            reader.dispose();
        }
    } else {
        log.error("No reader found for given format: " + suffix, null);
    }
    return null;
}