Example usage for javax.imageio ImageIO getImageWritersByFormatName

Introduction

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

Prototype

public static Iterator<ImageWriter> getImageWritersByFormatName(String formatName) 

Source Link

Document

Returns an Iterator containing all currently registered ImageWriter s that claim to be able to encode the named format.

Usage

From source file:org.dcm4che.tool.dcm2jpg.Dcm2Jpg.java

public void initImageWriter(String formatName, String suffix, String clazz, String compressionType,
        Number quality) {//w ww. ja va 2s . c  o  m
    Iterator<ImageWriter> imageWriters = ImageIO.getImageWritersByFormatName(formatName);
    if (!imageWriters.hasNext())
        throw new IllegalArgumentException(
                MessageFormat.format(rb.getString("formatNotSupported"), formatName));
    this.suffix = suffix != null ? suffix : formatName.toLowerCase();
    imageWriter = imageWriters.next();
    if (clazz != null)
        while (!clazz.equals(imageWriter.getClass().getName()))
            if (imageWriters.hasNext())
                imageWriter = imageWriters.next();
            else
                throw new IllegalArgumentException(
                        MessageFormat.format(rb.getString("noSuchImageWriter"), clazz, formatName));
    imageWriteParam = imageWriter.getDefaultWriteParam();
    if (compressionType != null || quality != null) {
        imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        if (compressionType != null)
            imageWriteParam.setCompressionType(compressionType);
        if (quality != null)
            imageWriteParam.setCompressionQuality(quality.floatValue());
    }
}

---

From source file:eu.europa.esig.dss.pades.signature.visible.ImageFactory.java

private static InputStream convertToInputStream(BufferedImage buffImage, int dpi) throws IOException {
    Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName("jpeg");
    if (!it.hasNext()) {
        throw new DSSException("No writer for JPEG found");
    }/*  w  ww.  j  a  v  a2 s. c  o  m*/
    ImageWriter writer = it.next();

    JPEGImageWriteParam jpegParams = (JPEGImageWriteParam) writer.getDefaultWriteParam();
    jpegParams.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
    jpegParams.setCompressionQuality(1);

    ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier
            .createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
    IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, jpegParams);

    initDpi(metadata, dpi);

    ByteArrayOutputStream os = new ByteArrayOutputStream();
    ImageOutputStream imageOs = ImageIO.createImageOutputStream(os);
    writer.setOutput(imageOs);
    writer.write(metadata, new IIOImage(buffImage, null, metadata), jpegParams);

    InputStream is = new ByteArrayInputStream(os.toByteArray());
    return is;
}

---

From source file:org.tinymediamanager.core.ImageCache.java

/**
 * Scale image to fit in the given width.
 * //w  ww  .  ja  v  a  2  s  .  co m
 * @param imageUrl
 *          the image url
 * @param width
 *          the width
 * @return the input stream
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 * @throws InterruptedException
 */
public static InputStream scaleImage(String imageUrl, int width) throws IOException, InterruptedException {
    Url url = new Url(imageUrl);

    BufferedImage originalImage = null;
    try {
        originalImage = createImage(url.getBytes());
    } catch (Exception e) {
        throw new IOException(e.getMessage());
    }

    Point size = new Point();
    size.x = width;
    size.y = size.x * originalImage.getHeight() / originalImage.getWidth();

    // BufferedImage scaledImage = Scaling.scale(originalImage, size.x, size.y);
    BufferedImage scaledImage = Scalr.resize(originalImage, Scalr.Method.QUALITY, Scalr.Mode.AUTOMATIC, size.x,
            size.y, Scalr.OP_ANTIALIAS);
    originalImage = null;

    ImageWriter imgWrtr = null;
    ImageWriteParam imgWrtrPrm = null;

    // here we have two different ways to create our thumb
    // a) a scaled down jpg/png (without transparency) which we have to modify since OpenJDK cannot call native jpg encoders
    // b) a scaled down png (with transparency) which we can store without any more modifying as png
    if (hasTransparentPixels(scaledImage)) {
        // transparent image -> png
        imgWrtr = ImageIO.getImageWritersByFormatName("png").next();
        imgWrtrPrm = imgWrtr.getDefaultWriteParam();

    } else {
        // non transparent image -> jpg
        // convert to rgb
        BufferedImage rgb = new BufferedImage(scaledImage.getWidth(), scaledImage.getHeight(),
                BufferedImage.TYPE_INT_RGB);
        ColorConvertOp xformOp = new ColorConvertOp(null);
        xformOp.filter(scaledImage, rgb);
        imgWrtr = ImageIO.getImageWritersByFormatName("jpg").next();
        imgWrtrPrm = imgWrtr.getDefaultWriteParam();
        imgWrtrPrm.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
        imgWrtrPrm.setCompressionQuality(0.80f);

        scaledImage = rgb;
    }

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ImageOutputStream output = ImageIO.createImageOutputStream(baos);
    imgWrtr.setOutput(output);
    IIOImage outputImage = new IIOImage(scaledImage, null, null);
    imgWrtr.write(null, outputImage, imgWrtrPrm);
    imgWrtr.dispose();
    scaledImage = null;

    byte[] bytes = baos.toByteArray();

    output.flush();
    output.close();
    baos.close();

    return new ByteArrayInputStream(bytes);
}

---

From source file:com.lingxiang2014.util.ImageUtils.java

public static void zoom(File srcFile, File destFile, int destWidth, int destHeight) {
    Assert.notNull(srcFile);/*  ww  w  . j  av a  2 s  . c  o m*/
    Assert.notNull(destFile);
    Assert.state(destWidth > 0);
    Assert.state(destHeight > 0);
    if (type == Type.jdk) {
        Graphics2D graphics2D = null;
        ImageOutputStream imageOutputStream = null;
        ImageWriter imageWriter = null;
        try {
            BufferedImage srcBufferedImage = ImageIO.read(srcFile);
            int srcWidth = srcBufferedImage.getWidth();
            int srcHeight = srcBufferedImage.getHeight();
            int width = destWidth;
            int height = destHeight;
            if (srcHeight >= srcWidth) {
                width = (int) Math.round(((destHeight * 1.0 / srcHeight) * srcWidth));
            } else {
                height = (int) Math.round(((destWidth * 1.0 / srcWidth) * srcHeight));
            }
            BufferedImage destBufferedImage = new BufferedImage(destWidth, destHeight,
                    BufferedImage.TYPE_INT_RGB);
            graphics2D = destBufferedImage.createGraphics();
            graphics2D.setBackground(BACKGROUND_COLOR);
            graphics2D.clearRect(0, 0, destWidth, destHeight);
            graphics2D.drawImage(srcBufferedImage.getScaledInstance(width, height, Image.SCALE_SMOOTH),
                    (destWidth / 2) - (width / 2), (destHeight / 2) - (height / 2), null);

            imageOutputStream = ImageIO.createImageOutputStream(destFile);
            imageWriter = ImageIO.getImageWritersByFormatName(FilenameUtils.getExtension(destFile.getName()))
                    .next();
            imageWriter.setOutput(imageOutputStream);
            ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam();
            imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            imageWriteParam.setCompressionQuality((float) (DEST_QUALITY / 100.0));
            imageWriter.write(null, new IIOImage(destBufferedImage, null, null), imageWriteParam);
            imageOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (graphics2D != null) {
                graphics2D.dispose();
            }
            if (imageWriter != null) {
                imageWriter.dispose();
            }
            if (imageOutputStream != null) {
                try {
                    imageOutputStream.close();
                } catch (IOException e) {
                }
            }
        }
    } else {
        IMOperation operation = new IMOperation();
        operation.thumbnail(destWidth, destHeight);
        operation.gravity("center");
        operation.background(toHexEncoding(BACKGROUND_COLOR));
        operation.extent(destWidth, destHeight);
        operation.quality((double) DEST_QUALITY);
        operation.addImage(srcFile.getPath());
        operation.addImage(destFile.getPath());
        if (type == Type.graphicsMagick) {
            ConvertCmd convertCmd = new ConvertCmd(true);
            if (graphicsMagickPath != null) {
                convertCmd.setSearchPath(graphicsMagickPath);
            }
            try {
                convertCmd.run(operation);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (IM4JavaException e) {
                e.printStackTrace();
            }
        } else {
            ConvertCmd convertCmd = new ConvertCmd(false);
            if (imageMagickPath != null) {
                convertCmd.setSearchPath(imageMagickPath);
            }
            try {
                convertCmd.run(operation);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (IM4JavaException e) {
                e.printStackTrace();
            }
        }
    }
}

---

From source file:FileUtils.java

/**
 * Utility method to write BufferedImage object to disk
 * @param image - BufferedImage object to save.
 * @param data - relative path to the image
 * @param format - file prefix of the image
 * @return BufferedImage representation of the image
 *
 *///from   w  w w  . j av  a2 s  .  com
public static void imageToBitmap(BufferedImage image, String data, String format) throws IOException {
    final OutputStream inb = new FileOutputStream(data);
    final ImageWriter wrt = ImageIO.getImageWritersByFormatName(format).next();
    final ImageInputStream imageInput = ImageIO.createImageOutputStream(inb);
    wrt.setOutput(imageInput);
    wrt.write(image);
    inb.close();
}

---

From source file:tvbrowserdataservice.file.ProgramField.java

/**
 * This Function loads an image using imageio,
 * resizes it to the Max-Size of Images in TVBrowser and
 * stores it as an compressed jpg.//from w w w .  ja  v a 2  s  .c om
 * <p/>
 * If the Image is smaller than the Max-Size, it isn't altered
 *
 * @param data Image-Data
 * @return resized Image-Data
 */
private static byte[] recreateImage(byte[] data) {
    byte[] newdata = null;
    BufferedImage image = null;
    try {
        // Read Image
        image = ImageIO.read(new ByteArrayInputStream(data));

        int curx = image.getWidth(null);
        int cury = image.getHeight(null);

        // If the Size is < than max, use the original Data to reduce compression
        // artefacts
        if ((curx <= MAX_IMAGE_SIZE_X) && (cury <= MAX_IMAGE_SIZE_Y)) {
            return data;
        }

        int newx = MAX_IMAGE_SIZE_X;
        int newy = (int) ((MAX_IMAGE_SIZE_X / (float) curx) * cury);

        if (newy > MAX_IMAGE_SIZE_Y) {
            newy = MAX_IMAGE_SIZE_Y;
            newx = (int) ((MAX_IMAGE_SIZE_Y / (float) cury) * curx);
        }

        BufferedImage tempPic = new BufferedImage(image.getWidth(null), image.getHeight(null),
                BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = tempPic.createGraphics();
        g2d.drawImage(image, null, null);
        g2d.dispose();

        BufferedImage newImage = UiUtilities.scaleIconToBufferedImage(tempPic, newx, newy);

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        // Find a jpeg writer
        ImageWriter writer = null;
        Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName("jpg");
        if (iter.hasNext()) {
            writer = iter.next();
        }

        if (writer != null) {
            // Prepare output file
            ImageOutputStream ios = ImageIO.createImageOutputStream(out);
            writer.setOutput(ios);

            JPEGImageWriteParam param = new JPEGImageWriteParam(null);

            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            param.setCompressionQuality(0.85f);

            // Write the image
            writer.write(null, new IIOImage(newImage, null, null), param);

            // Cleanup
            ios.flush();
            writer.dispose();
            ios.close();

            newdata = out.toByteArray();
        } else {
            mLog.severe("No JPEG-Exporter found. Image is not stored in Data");
        }

    } catch (IOException e) {
        e.printStackTrace();
        newdata = null;
    }

    return newdata;
}

---

From source file:compressor.Compressor.java

void compress_images(String src, String dest) throws IOException {

    File f = null;/*from   ww w  . j a  v a  2  s  .  co  m*/
    String[] paths;

    try {
        // create new file
        f = new File(src);

        // array of files and directory
        paths = f.list();

        File file = new File(dest + "compressed");
        if (!file.exists()) {
            if (file.mkdir()) {
                System.out.println("Directory is created!");
            } else {
                System.out.println("Failed to create directory!");
            }
        }
        dest = dest + "compressed/";

        // for each name in the path array
        for (String path : paths) {
            // prints filename and directory name

            File input = new File(src + path);
            BufferedImage image = ImageIO.read(input);

            File compressedImageFile = new File(dest + path);
            OutputStream os = new FileOutputStream(compressedImageFile);

            Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
            ImageWriter writer = (ImageWriter) writers.next();

            ImageOutputStream ios = ImageIO.createImageOutputStream(os);
            writer.setOutput(ios);

            ImageWriteParam param = writer.getDefaultWriteParam();

            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            param.setCompressionQuality(0.05f);
            writer.write(null, new IIOImage(image, null, null), param);

            os.close();
            ios.close();
            writer.dispose();

        }
    } catch (Exception e) {
    }

}

---

From source file:ImageUtils.java

/**
 * Compress and save an image to the disk. Currently this method only supports JPEG images.
 * /*from  w  ww. ja va2  s. c  o  m*/
 * @param image The image to save
 * @param toFileName The filename to use
 * @param type The image type. Use <code>ImageUtils.IMAGE_JPEG</code> to save as JPEG images,
 * or <code>ImageUtils.IMAGE_PNG</code> to save as PNG.
 */
public static void saveCompressedImage(BufferedImage image, String toFileName, int type) {
    try {
        if (type == IMAGE_PNG) {
            throw new UnsupportedOperationException("PNG compression not implemented");
        }

        Iterator iter = ImageIO.getImageWritersByFormatName("jpg");
        ImageWriter writer;
        writer = (ImageWriter) iter.next();

        ImageOutputStream ios = ImageIO.createImageOutputStream(new File(toFileName));
        writer.setOutput(ios);

        ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());

        iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        iwparam.setCompressionQuality(0.7F);

        writer.write(null, new IIOImage(image, null, null), iwparam);

        ios.flush();
        writer.dispose();
        ios.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

---

From source file:ImageIOTest.java

/**
 * Save the current image in a file/*from  ww w.  j a v a  2 s. c  o  m*/
 * @param formatName the file format
 */
public void saveFile(final String formatName) {
    if (images == null)
        return;
    Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(formatName);
    ImageWriter writer = iter.next();
    JFileChooser chooser = new JFileChooser();
    chooser.setCurrentDirectory(new File("."));
    String[] extensions = writer.getOriginatingProvider().getFileSuffixes();
    chooser.setFileFilter(new FileNameExtensionFilter("Image files", extensions));

    int r = chooser.showSaveDialog(this);
    if (r != JFileChooser.APPROVE_OPTION)
        return;
    File f = chooser.getSelectedFile();
    try {
        ImageOutputStream imageOut = ImageIO.createImageOutputStream(f);
        writer.setOutput(imageOut);

        writer.write(new IIOImage(images[0], null, null));
        for (int i = 1; i < images.length; i++) {
            IIOImage iioImage = new IIOImage(images[i], null, null);
            if (writer.canInsertImage(i))
                writer.writeInsert(i, iioImage, null);
        }
    } catch (IOException e) {
        JOptionPane.showMessageDialog(this, e);
    }
}

---

From source file:org.apache.flex.compiler.internal.embedding.transcoders.JPEGTranscoder.java

private byte[] bufferedImageToJPEG(ImageInfo imageInfo, int[] pixels) throws Exception {
    BufferedImage bufferedImage = new BufferedImage(imageInfo.width, imageInfo.height,
            BufferedImage.TYPE_INT_ARGB);
    bufferedImage.setRGB(0, 0, imageInfo.width, imageInfo.height, pixels, 0, imageInfo.width);

    ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
    ImageWriteParam writeParam = writer.getDefaultWriteParam();
    ColorModel colorModel = new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
    ImageTypeSpecifier imageTypeSpecifier = new ImageTypeSpecifier(colorModel,
            colorModel.createCompatibleSampleModel(1, 1));
    writeParam.setDestinationType(imageTypeSpecifier);
    writeParam.setSourceBands(new int[] { 0, 1, 2 });
    writeParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);

    float q = 1.0f;
    if (quality != null)
        q = quality.floatValue();//from  w  ww .  j  a va2 s  . c  om
    writeParam.setCompressionQuality(q);

    DAByteArrayOutputStream buffer = new DAByteArrayOutputStream();
    writer.setOutput(new MemoryCacheImageOutputStream(buffer));

    IIOImage ioImage = new IIOImage(bufferedImage, null, null);

    writer.write(null, ioImage, writeParam);
    writer.dispose();

    return buffer.getDirectByteArray();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »