Example usage for javax.imageio ImageIO createImageOutputStream

List of usage examples for javax.imageio ImageIO createImageOutputStream

Introduction

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

Prototype

public static ImageOutputStream createImageOutputStream(Object output) throws IOException 

Source Link

Document

Returns an ImageOutputStream that will send its output to the given Object .

Usage

From source file:org.sejda.sambox.pdmodel.graphics.image.JPEGFactory.java

private static void encodeImageToJPEGStream(BufferedImage image, float quality, int dpi, OutputStream out)
        throws IOException {
    // encode to JPEG
    ImageOutputStream ios = null;
    ImageWriter imageWriter = null;
    try {//from  w ww.  ja va2 s.  c  o m
        // find JAI writer
        imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
        ios = ImageIO.createImageOutputStream(out);
        imageWriter.setOutput(ios);

        // add compression
        JPEGImageWriteParam jpegParam = (JPEGImageWriteParam) imageWriter.getDefaultWriteParam();
        jpegParam.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
        jpegParam.setCompressionQuality(quality);

        // add metadata
        ImageTypeSpecifier imageTypeSpecifier = new ImageTypeSpecifier(image);
        IIOMetadata data = imageWriter.getDefaultImageMetadata(imageTypeSpecifier, jpegParam);
        Element tree = (Element) data.getAsTree("javax_imageio_jpeg_image_1.0");
        Element jfif = (Element) tree.getElementsByTagName("app0JFIF").item(0);
        jfif.setAttribute("Xdensity", Integer.toString(dpi));
        jfif.setAttribute("Ydensity", Integer.toString(dpi));
        jfif.setAttribute("resUnits", "1"); // 1 = dots/inch

        // write
        imageWriter.write(data, new IIOImage(image, null, null), jpegParam);
    } finally {
        // clean up
        IOUtils.closeQuietly(out);
        if (ios != null) {
            ios.close();
        }
        if (imageWriter != null) {
            imageWriter.dispose();
        }
    }
}

From source file:net.rptools.tokentool.AppActions.java

public static void saveToken(File rptok_file, boolean overwrite) {
    if (rptok_file != null) {
        if (!rptok_file.getName().toUpperCase().endsWith(".RPTOK")) {
            rptok_file = new File(rptok_file.getAbsolutePath() + ".rptok");
        }/*from  ww  w.  ja  v  a  2 s. c  om*/

        if (rptok_file.exists() && !overwrite) {
            if (!TokenTool.confirm("File exists.  Overwrite?")) {
                return;
            } else {
                rptok_file.delete();
            }
        }

        String tokenName = FilenameUtils.removeExtension(rptok_file.getName());

        try {
            // Write out the token image first or aka POG image.
            File tokenImageFile = File.createTempFile("tokenImage", ".png");

            // PW: This code addes the pHYs chunk to the
            // output png file with X & Y dpi set.
            BufferedImage tokenImg = TokenTool.getFrame().getComposedToken();
            BufferedImage portraitImg = TokenTool.getFrame().getTokenCompositionPanel().getBaseImage();

            ImageWriter writer = getImageWriterBySuffix("png");
            // Created object for outputStream so we can properly close it! No longer locks .png files until app closes!
            ImageOutputStream ios = ImageIO.createImageOutputStream(tokenImageFile);
            writer.setOutput(ios);
            ImageWriteParam param = writer.getDefaultWriteParam();

            PNGMetadata png = new PNGMetadata();
            // 39.375 inches per meter
            // I'm using the image width for the DPI under
            // the assumption that the token fits within
            // one cell.
            int resX = (int) (tokenImg.getWidth() * 39.375f);
            png.pHYs_pixelsPerUnitXAxis = resX;
            png.pHYs_pixelsPerUnitYAxis = resX;
            png.pHYs_unitSpecifier = 1; // Meters - alternative is "unknown"
            png.pHYs_present = true;

            writer.write(null, new IIOImage(tokenImg, null, png), param);
            ios.close();

            // Now write out the Portrait image, here we'll use JPEG to save space
            File portraitImageFile = File.createTempFile("portraitImage", ".jpg");
            writer.reset();
            writer = getImageWriterBySuffix("jpg");
            ios = ImageIO.createImageOutputStream(portraitImageFile);
            writer.setOutput(ios);
            param = writer.getDefaultWriteParam();

            writer.write(null, new IIOImage(portraitImg, null, null), param);
            writer.dispose();
            ios.close();

            // Lets create the token!
            Token _token = new Token();
            Asset tokenImage = null;
            tokenImage = AssetManager.createAsset(tokenImageFile);
            AssetManager.putAsset(tokenImage);
            _token = new Token(tokenName, tokenImage.getId());
            _token.setGMName(tokenName);

            // Jamz: Below calls not needed, creates extra entries in XML preventing token image from changing inside MapTool
            //_token.setImageAsset(tokenImage.getName());
            //_token.setImageAsset(tokenImage.getName(), tokenImage.getId());

            // set the image shape
            Image image = ImageIO.read(tokenImageFile);
            _token.setShape(TokenUtil.guessTokenType(image));

            // set the height/width, fixes dragging to stamp layer issue
            _token.setHeight(tokenImg.getHeight());
            _token.setWidth(tokenImg.getWidth());

            // set the portrait image asset
            Asset portrait = AssetManager.createAsset(portraitImageFile); // Change for portrait
            AssetManager.putAsset(portrait);
            _token.setPortraitImage(portrait.getId());

            // Time to write out the .rptok token file...
            PackedFile pakFile = null;
            try {
                pakFile = new PackedFile(rptok_file);
                saveAssets(_token.getAllImageAssets(), pakFile);
                pakFile.setContent(_token);
                BufferedImage thumb = ImageUtil.createCompatibleImage(image, THUMB_SIZE, THUMB_SIZE, null);
                pakFile.putFile(FILE_THUMBNAIL, ImageUtil.imageToBytes(thumb, "png"));
                pakFile.setProperty(PROP_VERSION, TokenToolFrame.VERSION);
                pakFile.save();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (pakFile != null)
                    pakFile.close();
                tokenImageFile.delete();
                portraitImageFile.delete();
            }

        } catch (IOException ioe) {
            ioe.printStackTrace();
            TokenTool.showError("Unable to write image: " + ioe);
        }
    }
}

From source file:org.bigbluebuttonproject.fileupload.document.impl.FileSystemSlideManager.java

/**
 * This method create thumbImage of the image file given and save it in outFile.
 * Compression quality is also given. thumbBounds is used for calculating the size of the thumb.
 * /*from  w w w. j a v  a  2s.c  o m*/
 * @param infile slide image to create thumb
 * @param outfile output thumb file
 * @param compressionQuality the compression quality
 * @param thumbBounds the thumb bounds
 * 
 * @throws IOException Signals that an I/O exception has occurred.
 */
public void resizeImage(File infile, File outfile, float compressionQuality, int thumbBounds)
        throws IOException {
    // Retrieve jpg image to be resized
    Image image = ImageIO.read(infile);

    // get original image size for thumb size calculation
    int imageWidth = image.getWidth(null);
    int imageHeight = image.getHeight(null);

    float thumbRatio = (float) thumbBounds / Math.max(imageWidth, imageHeight);

    int thumbWidth = (int) (imageWidth * thumbRatio);
    int thumbHeight = (int) (imageHeight * thumbRatio);

    // draw original image to thumbnail image object and
    // scale it to the new size on-the-fly
    BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);
    Graphics2D graphics2D = thumbImage.createGraphics();
    graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
    graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);

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

    ImageWriteParam iwp = writer.getDefaultWriteParam();
    iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    iwp.setCompressionQuality(compressionQuality);

    // Prepare output file
    ImageOutputStream ios = ImageIO.createImageOutputStream(outfile);
    writer.setOutput(ios);
    // write to the thumb image 
    writer.write(thumbImage);

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

From source file:org.polymap.core.data.image.ImageEncodeProcessor.java

private void imageioEncodeJPEG(Image image, ChunkedResponseOutputStream out) throws IOException {
    // this code is from http://forums.sun.com/thread.jspa?threadID=5197061
    ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
    ImageWriteParam param = writer.getDefaultWriteParam();
    param.setSourceBands(new int[] { 0, 1, 2 });
    ColorModel cm = new DirectColorModel(24, 0x00ff0000, // Red
            0x0000ff00, // Green
            0x000000ff, // Blue
            0x0); // Alpha
    param.setDestinationType(new ImageTypeSpecifier(cm, cm.createCompatibleSampleModel(1, 1)));

    ImageOutputStream imageOut = ImageIO.createImageOutputStream(out);
    writer.setOutput(imageOut);/*  w w  w .j  a v  a  2  s  .  c om*/
    writer.write(null, new IIOImage((RenderedImage) image, null, null), param);
    writer.dispose();
    imageOut.close();
}

From source file:com.mirth.connect.server.util.DICOMUtil.java

private static byte[] saveAsJpeg(ImagePlus imagePlug, int quality) {
    int imageType = BufferedImage.TYPE_INT_RGB;

    if (imagePlug.getProcessor().isDefaultLut()) {
        imageType = BufferedImage.TYPE_BYTE_GRAY;
    }/*w w w. j  a v a  2 s.  com*/

    BufferedImage bufferedImage = new BufferedImage(imagePlug.getWidth(), imagePlug.getHeight(), imageType);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    try {
        Graphics graphics = bufferedImage.createGraphics();
        graphics.drawImage(imagePlug.getImage(), 0, 0, null);
        graphics.dispose();
        ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
        writer.setOutput(ImageIO.createImageOutputStream(baos));
        ImageWriteParam param = writer.getDefaultWriteParam();
        param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        param.setCompressionQuality(quality / 100f);

        if (quality == 100) {
            param.setSourceSubsampling(1, 1, 0, 0);
        }

        IIOImage iioImage = new IIOImage(bufferedImage, null, null);
        writer.write(null, iioImage, param);
        return baos.toByteArray();
    } catch (Exception e) {
        logger.error("Error converting dcm file", e);
    } finally {
        IOUtils.closeQuietly(baos);
    }

    return null;
}

From source file:nl.b3p.kaartenbalie.service.KBImageTool.java

/** Writes a JPEG, GIF or PNG image to the outputstream.
 *
 * @param bufferedImage BufferedImage created from the given images.
 * @param dw DataWrapper object in which the request object is stored.
 * @param extension String with the extension of the file
 *
 * @throws Exception/*from  w w  w.  j  ava 2s .  c  o m*/
 */
// <editor-fold defaultstate="" desc="writeOtherImage(BufferedImage bufferedImage, DataWrapper dw, String extension) method.">
private static void writeOtherImage(BufferedImage bufferedImage, DataWrapper dw, String extension)
        throws Exception {
    //log.info("Writing JPG, GIF or PNG using ImageIO.write");
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
    ImageIO.write(bufferedImage, extension, ios);
    dw.write(baos);
    ios.flush();
    ios.close();
}

From source file:uk.co.modularaudio.service.audioanalysis.impl.analysers.StaticThumbnailAnalyser.java

@Override
public void completeAnalysis(final AnalysisContext context, final AnalysedData analysedData,
        final HashedRef hashedRef) {
    final float rmsDb = AudioMath.levelToDbF(maxRmsValue);

    final float adjustedDb = (THUMBNAIL_DB - rmsDb);

    final float adjustmentAbs = AudioMath.dbToLevelF(adjustedDb);

    final Graphics2D g2d = (Graphics2D) og2d.create(BORDER_WIDTH, BORDER_WIDTH, usableWidth, usableHeight);

    //      g2d.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
    g2d.setColor(Color.BLACK);//  www  .  j av a 2 s .  c om
    g2d.fillRect(0, 0, usableWidth, usableHeight);

    g2d.setColor(minMaxColor);

    int curDataCount = 0;
    final int oneSideHeight = (usableHeight - 1) / 2;
    final int zeroYValue = oneSideHeight;

    for (int i = 0; i < usableWidth; i++) {
        float minSample = thumbnailValues[curDataCount++] * adjustmentAbs;
        float maxSample = thumbnailValues[curDataCount++] * adjustmentAbs;
        curDataCount++;

        minSample = (minSample < -1.0f ? -1.0f : minSample);
        maxSample = (maxSample > 1.0f ? 1.0f : maxSample);

        // assume goes from +1.0 to -1.0
        final int curX = i;
        final int minY = zeroYValue + (int) (minSample * oneSideHeight);
        final int maxY = zeroYValue + (int) (maxSample * oneSideHeight);
        g2d.drawLine(curX, minY, curX, maxY);
    }

    g2d.setColor(rmsColor);

    curDataCount = 0;
    for (int i = 0; i < usableWidth; i++) {
        curDataCount += 2;
        float rms = thumbnailValues[curDataCount++] * adjustmentAbs;

        rms = (rms > 1.0f ? 1.0f : rms);

        // lSample goes from +1.0 to -1.0
        // We need it to go from 0 to height
        final int curX = i;
        final int minY = zeroYValue + (int) (rms * oneSideHeight);
        final int maxY = zeroYValue + (int) (-rms * oneSideHeight);
        g2d.drawLine(curX, minY, curX, maxY);
    }

    try {
        final ByteArrayOutputStream os = new ByteArrayOutputStream();
        final ImageOutputStream ios = ImageIO.createImageOutputStream(os);

        ImageIO.write(bufferedImage, "png", ios);
        final InputStream contents = new ByteArrayInputStream(os.toByteArray());
        // Now save this generated thumb nail onto disk then pass the path to this in the analysed data
        hashedStorageService.storeContentsInWarehouse(hashedWarehouse, hashedRef, contents);

        analysedData
                .setPathToStaticThumbnail(hashedStorageService.getPathToHashedRef(hashedWarehouse, hashedRef));
    } catch (final Exception e) {
        final String msg = "Exception caught serialising static thumb nail: " + e.toString();
        log.error(msg, e);
    }
}

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

private void encodeByImageIO(BufferedImage bi, File dest) throws IOException {
    ImageWriter writer = getImageWriter(imageWriterClassname);
    ImageOutputStream out = null;
    try {//from   w  w  w .j a v a 2s . c  om
        out = ImageIO.createImageOutputStream(dest);
        writer.setOutput(out);
        ImageWriteParam iwparam = writer.getDefaultWriteParam();
        if (iwparam.canWriteCompressed()) {
            iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            String[] compressionTypes = iwparam.getCompressionTypes();
            if (compressionTypes != null && compressionTypes.length > 0) {
                if (compressionType != null || iwparam.getCompressionType() == null) {
                    for (int i = 0; i < compressionTypes.length; i++) {
                        if (compressionType == null
                                || compressionTypes[i].compareToIgnoreCase(compressionType) == 0) {
                            iwparam.setCompressionType(compressionTypes[i]);
                            break;
                        }
                    }
                }
            }
            if (imageQuality != null)
                iwparam.setCompressionQuality(imageQuality);
        } else if (imageQuality != null) {
            System.out.println("Selected Image Writer can not compress! imageQuality is ignored!");
        }
        writer.write(null, new IIOImage(bi, null, null), iwparam);
    } finally {
        CloseUtils.safeClose(out);
        writer.dispose();
    }
}

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

/**
 * Scale image to fit in the given width.
 * /*from  w  ww . j  ava2 s. c om*/
 * @param file
 *          the original image file
 * @param width
 *          the width
 * @return the input stream
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 * @throws InterruptedException
 */
public static InputStream scaleImage(Path file, int width) throws IOException, InterruptedException {
    BufferedImage originalImage = null;
    try {
        originalImage = createImage(file);
    } 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:common.utils.ImageUtils.java

public static void writeImage(BufferedImage image, float quality, OutputStream out) throws IOException {
    ImageWriter writer = getImageWriter();
    if (writer == null)
        return;//  ww w .j a  va  2 s  .  c  om
    ImageOutputStream ios = ImageIO.createImageOutputStream(out);
    writer.setOutput(ios);
    ImageWriteParam param = writer.getDefaultWriteParam();
    //JPEGImageWriteParam param = new JPEGImageWriteParam(Locale.getDefault());
    //param.setOptimizeHuffmanTables(true);
    if (quality >= 0) {
        param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        param.setCompressionQuality(quality);
        //param.setCompressionMode(ImageWriteParam.MODE_COPY_FROM_METADATA);
        //param.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
        //param.setTilingMode(ImageWriteParam.MODE_DISABLED);
    }
    writer.write(null, new IIOImage(image, null, null), param);
}