Examples with ImageWriteParam javax.imageio.ImageWriteParam used on opensource projects

Example 86 with ImageWriteParam

use of javax.imageio.ImageWriteParam in project vcell by virtualcell.

the class ITextWriter method encodeJPEG.

public static ByteArrayOutputStream encodeJPEG(BufferedImage bufferedImage) throws Exception {
    ImageWriter imageWriter = ImageIO.getImageWritersBySuffix("jpeg").next();
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    ImageOutputStream imageOutputStream = ImageIO.createImageOutputStream(byteArrayOutputStream);
    imageWriter.setOutput(imageOutputStream);
    ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam();
    imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    // quality 0(very compressed, lossy) -> 1.0(less compressed,loss-less)
    imageWriteParam.setCompressionQuality(1.0f);
    IIOImage iioImage = new IIOImage(bufferedImage, null, null);
    imageWriter.write(null, iioImage, imageWriteParam);
    imageOutputStream.close();
    imageWriter.dispose();
    return byteArrayOutputStream;
}

Example 87 with ImageWriteParam

use of javax.imageio.ImageWriteParam in project freeplane by freeplane.

the class ExportToImage method exportToImage.

/**
 * Export image.
 * @param toFile
 */
public boolean exportToImage(final RenderedImage image, File chosenFile) {
    try {
        Controller.getCurrentController().getViewController().setWaitingCursor(true);
        Iterator<ImageWriter> imageWritersByFormatName = ImageIO.getImageWritersByFormatName(imageType);
        for (; ; ) {
            ImageWriter writer = imageWritersByFormatName.next();
            ImageWriteParam writeParam = writer.getDefaultWriteParam();
            ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
            IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, writeParam);
            if ((metadata.isReadOnly() || !metadata.isStandardMetadataFormatSupported()) && imageWritersByFormatName.hasNext()) {
                continue;
            }
            addDpiToMetadata(metadata);
            final FileOutputStream outFile = new FileOutputStream(chosenFile);
            final ImageOutputStream stream = ImageIO.createImageOutputStream(outFile);
            try {
                writer.setOutput(ImageIO.createImageOutputStream(outFile));
                writer.write(metadata, new IIOImage(image, null, metadata), writeParam);
                break;
            } finally {
                stream.close();
                outFile.close();
            }
        }
    } catch (final IOException e1) {
        LogUtils.warn(e1);
        UITools.errorMessage(TextUtils.getText("export_failed"));
    } finally {
        Controller.getCurrentController().getViewController().setWaitingCursor(false);
    }
    return true;
}

Example 88 with ImageWriteParam

use of javax.imageio.ImageWriteParam in project artisynth_core by artisynth.

the class AnimatedGifWriter method write.

/**
 * Writes a sequence of images to an animated GIF
 * @param file output file
 * @param frames input image sequence
 * @param delayTime time between frames (s)
 * @param loopCount number of times to loop (-1 for infinite)
 * @throws IOException if cannot write to the output file
 */
public static void write(File file, List<? extends BufferedImage> frames, double delayTime, int loopCount) throws IOException {
    ImageWriter iw;
    try {
        iw = ImageIO.getImageWritersByFormatName("gif").next();
    } catch (Exception e) {
        throw new IOException("Cannot write GIF format", e);
    }
    ImageOutputStream ios = ImageIO.createImageOutputStream(file);
    iw.setOutput(ios);
    iw.prepareWriteSequence(null);
    int count = loopCount + 1;
    if (count < 0) {
        count = 0;
    }
    for (int i = 0; i < frames.size(); i++) {
        BufferedImage src = frames.get(i);
        ImageWriteParam iwp = iw.getDefaultWriteParam();
        IIOMetadata metadata = iw.getDefaultImageMetadata(new ImageTypeSpecifier(src), iwp);
        configure(metadata, delayTime, count, i);
        IIOImage ii = new IIOImage(src, null, metadata);
        iw.writeToSequence(ii, null);
    }
    iw.endWriteSequence();
    ios.close();
}

Example 89 with ImageWriteParam

use of javax.imageio.ImageWriteParam in project imageio-ext by geosolutions-it.

the class EmptyImage method replacePixels.

public void replacePixels(RenderedImage image, ImageWriteParam param) throws IOException {
    synchronized (replacePixelsLock) {
        // Check state and parameters vis-a-vis ImageWriter specification.
        if (stream == null) {
            throw new IllegalStateException("stream == null!");
        }
        if (image == null) {
            throw new IllegalArgumentException("image == null!");
        }
        if (!inReplacePixelsNest) {
            throw new IllegalStateException("No previous call to prepareReplacePixels!");
        }
        // Subsampling values.
        int stepX = 1, stepY = 1, gridX = 0, gridY = 0;
        // Initialize the ImageWriteParam.
        if (param == null) {
            // Use the default.
            param = getDefaultWriteParam();
        } else {
            // Make a copy of the ImageWriteParam.
            ImageWriteParam paramCopy = getDefaultWriteParam();
            // Force uncompressed.
            paramCopy.setCompressionMode(ImageWriteParam.MODE_DISABLED);
            // Force tiling to remain as in the already written image.
            paramCopy.setTilingMode(ImageWriteParam.MODE_COPY_FROM_METADATA);
            // Retain source and destination region and band settings.
            paramCopy.setDestinationOffset(param.getDestinationOffset());
            paramCopy.setSourceBands(param.getSourceBands());
            paramCopy.setSourceRegion(param.getSourceRegion());
            // Save original subsampling values for subsampling the
            // replacement data - not the data re-read from the image.
            stepX = param.getSourceXSubsampling();
            stepY = param.getSourceYSubsampling();
            gridX = param.getSubsamplingXOffset();
            gridY = param.getSubsamplingYOffset();
            // Replace the param.
            param = paramCopy;
        }
        // Check band count and bit depth compatibility.
        TIFFField f = replacePixelsMetadata.getTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);
        if (f == null) {
            throw new IIOException("Cannot read destination BitsPerSample");
        }
        int[] dstBitsPerSample = f.getAsInts();
        int[] srcBitsPerSample = image.getSampleModel().getSampleSize();
        int[] sourceBands = param.getSourceBands();
        if (sourceBands != null) {
            if (sourceBands.length != dstBitsPerSample.length) {
                throw new IIOException("Source and destination have different SamplesPerPixel");
            }
            for (int i = 0; i < sourceBands.length; i++) {
                if (dstBitsPerSample[i] != srcBitsPerSample[sourceBands[i]]) {
                    throw new IIOException("Source and destination have different BitsPerSample");
                }
            }
        } else {
            int srcNumBands = image.getSampleModel().getNumBands();
            if (srcNumBands != dstBitsPerSample.length) {
                throw new IIOException("Source and destination have different SamplesPerPixel");
            }
            for (int i = 0; i < srcNumBands; i++) {
                if (dstBitsPerSample[i] != srcBitsPerSample[i]) {
                    throw new IIOException("Source and destination have different BitsPerSample");
                }
            }
        }
        // Get the source image bounds.
        Rectangle srcImageBounds = new Rectangle(image.getMinX(), image.getMinY(), image.getWidth(), image.getHeight());
        // Initialize the source rect.
        Rectangle srcRect = param.getSourceRegion();
        if (srcRect == null) {
            srcRect = srcImageBounds;
        }
        // Set subsampling grid parameters.
        int subPeriodX = stepX;
        int subPeriodY = stepY;
        int subOriginX = gridX + srcRect.x;
        int subOriginY = gridY + srcRect.y;
        // Intersect with the source bounds.
        if (!srcRect.equals(srcImageBounds)) {
            srcRect = srcRect.intersection(srcImageBounds);
            if (srcRect.isEmpty()) {
                throw new IllegalArgumentException("Source region does not intersect source image!");
            }
        }
        // Get the destination offset.
        Point dstOffset = param.getDestinationOffset();
        // Forward map source rectangle to determine destination width.
        int dMinX = XToTileX(srcRect.x, subOriginX, subPeriodX) + dstOffset.x;
        int dMinY = YToTileY(srcRect.y, subOriginY, subPeriodY) + dstOffset.y;
        int dMaxX = XToTileX(srcRect.x + srcRect.width, subOriginX, subPeriodX) + dstOffset.x;
        int dMaxY = YToTileY(srcRect.y + srcRect.height, subOriginY, subPeriodY) + dstOffset.y;
        // Initialize the destination rectangle.
        Rectangle dstRect = new Rectangle(dstOffset.x, dstOffset.y, dMaxX - dMinX, dMaxY - dMinY);
        // Intersect with the replacement region.
        dstRect = dstRect.intersection(replacePixelsRegion);
        if (dstRect.isEmpty()) {
            throw new IllegalArgumentException("Forward mapped source region does not intersect destination region!");
        }
        // Backward map to the active source region.
        int activeSrcMinX = (dstRect.x - dstOffset.x) * subPeriodX + subOriginX;
        int sxmax = (dstRect.x + dstRect.width - 1 - dstOffset.x) * subPeriodX + subOriginX;
        int activeSrcWidth = sxmax - activeSrcMinX + 1;
        int activeSrcMinY = (dstRect.y - dstOffset.y) * subPeriodY + subOriginY;
        int symax = (dstRect.y + dstRect.height - 1 - dstOffset.y) * subPeriodY + subOriginY;
        int activeSrcHeight = symax - activeSrcMinY + 1;
        Rectangle activeSrcRect = new Rectangle(activeSrcMinX, activeSrcMinY, activeSrcWidth, activeSrcHeight);
        if (activeSrcRect.intersection(srcImageBounds).isEmpty()) {
            throw new IllegalArgumentException("Backward mapped destination region does not intersect source image!");
        }
        if (reader == null) {
            reader = new TIFFImageReader(new TIFFImageReaderSpi());
        } else {
            reader.reset();
        }
        stream.mark();
        try {
            stream.seek(headerPosition);
            reader.setInput(stream);
            this.imageMetadata = replacePixelsMetadata;
            this.param = param;
            SampleModel sm = image.getSampleModel();
            ColorModel cm = image.getColorModel();
            this.numBands = sm.getNumBands();
            this.imageType = new ImageTypeSpecifier(image);
            this.periodX = param.getSourceXSubsampling();
            this.periodY = param.getSourceYSubsampling();
            this.sourceBands = null;
            int[] sBands = param.getSourceBands();
            if (sBands != null) {
                this.sourceBands = sBands;
                this.numBands = sourceBands.length;
            }
            setupMetadata(cm, sm, reader.getWidth(replacePixelsIndex), reader.getHeight(replacePixelsIndex));
            int[] scaleSampleSize = sm.getSampleSize();
            initializeScaleTables(scaleSampleSize);
            // Determine whether bilevel.
            this.isBilevel = ImageUtil.isBinary(image.getSampleModel());
            // Check for photometric inversion.
            this.isInverted = (nativePhotometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO && photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO) || (nativePhotometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO && photometricInterpretation == BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO);
            // Analyze image data suitability for direct copy.
            this.isImageSimple = (isBilevel || (!isInverted && ImageUtil.imageIsContiguous(image))) && // no value rescaling
            !isRescaling && // no subbanding
            sourceBands == null && periodX == 1 && // no subsampling
            periodY == 1 && colorConverter == null;
            int minTileX = XToTileX(dstRect.x, 0, tileWidth);
            int minTileY = YToTileY(dstRect.y, 0, tileLength);
            int maxTileX = XToTileX(dstRect.x + dstRect.width - 1, 0, tileWidth);
            int maxTileY = YToTileY(dstRect.y + dstRect.height - 1, 0, tileLength);
            TIFFCompressor encoder = new TIFFNullCompressor();
            encoder.setWriter(this);
            encoder.setStream(stream);
            encoder.setMetadata(this.imageMetadata);
            Rectangle tileRect = new Rectangle();
            for (int ty = minTileY; ty <= maxTileY; ty++) {
                for (int tx = minTileX; tx <= maxTileX; tx++) {
                    int tileIndex = ty * tilesAcross + tx;
                    boolean isEmpty = replacePixelsByteCounts[tileIndex] == 0L;
                    WritableRaster raster;
                    if (isEmpty) {
                        SampleModel tileSM = sm.createCompatibleSampleModel(tileWidth, tileLength);
                        raster = Raster.createWritableRaster(tileSM, null);
                    } else {
                        BufferedImage tileImage = reader.readTile(replacePixelsIndex, tx, ty);
                        raster = tileImage.getRaster();
                    }
                    tileRect.setLocation(tx * tileWidth, ty * tileLength);
                    tileRect.setSize(raster.getWidth(), raster.getHeight());
                    raster = raster.createWritableTranslatedChild(tileRect.x, tileRect.y);
                    Rectangle replacementRect = tileRect.intersection(dstRect);
                    int srcMinX = (replacementRect.x - dstOffset.x) * subPeriodX + subOriginX;
                    int srcXmax = (replacementRect.x + replacementRect.width - 1 - dstOffset.x) * subPeriodX + subOriginX;
                    int srcWidth = srcXmax - srcMinX + 1;
                    int srcMinY = (replacementRect.y - dstOffset.y) * subPeriodY + subOriginY;
                    int srcYMax = (replacementRect.y + replacementRect.height - 1 - dstOffset.y) * subPeriodY + subOriginY;
                    int srcHeight = srcYMax - srcMinY + 1;
                    Rectangle srcTileRect = new Rectangle(srcMinX, srcMinY, srcWidth, srcHeight);
                    Raster replacementData = image.getData(srcTileRect);
                    if (subPeriodX == 1 && subPeriodY == 1 && subOriginX == 0 && subOriginY == 0) {
                        replacementData = replacementData.createChild(srcTileRect.x, srcTileRect.y, srcTileRect.width, srcTileRect.height, replacementRect.x, replacementRect.y, sourceBands);
                    } else {
                        replacementData = subsample(replacementData, sourceBands, subOriginX, subOriginY, subPeriodX, subPeriodY, dstOffset.x, dstOffset.y, replacementRect);
                        if (replacementData == null) {
                            continue;
                        }
                    }
                    raster.setRect(replacementData);
                    if (isEmpty) {
                        stream.seek(nextSpace);
                    } else {
                        stream.seek(replacePixelsTileOffsets[tileIndex]);
                    }
                    this.image = new SingleTileRenderedImage(raster, cm);
                    int numBytes = writeTile(tileRect, encoder);
                    if (isEmpty) {
                        // Update Strip/TileOffsets and
                        // Strip/TileByteCounts fields.
                        stream.mark();
                        stream.seek(replacePixelsOffsetsPosition + 4 * tileIndex);
                        stream.writeInt((int) nextSpace);
                        stream.seek(replacePixelsByteCountsPosition + 4 * tileIndex);
                        stream.writeInt(numBytes);
                        stream.reset();
                        // Increment location of next available space.
                        nextSpace += numBytes;
                    }
                }
            }
        } catch (IOException e) {
            throw e;
        } finally {
            stream.reset();
        }
    }
}

Example 90 with ImageWriteParam

use of javax.imageio.ImageWriteParam in project imageio-ext by geosolutions-it.

the class JPEGWriterCompareTest method writeJPEG.

/**
 * Writes outs the image contained into this {@link ImageWorker} as a JPEG using the provided
 * destination , compression and compression rate.
 * <p>
 * The destination object can be anything providing that we have an {@link ImageOutputStreamSpi}
 * that recognizes it.
 *
 * @param destination
 *            where to write the internal {@link #image} as a JPEG.
 * @param compression
 *            algorithm.
 * @param compressionRate
 *            percentage of compression.
 * @param nativeAcc
 *            should we use native acceleration.
 * @return this {@link ImageWorker}.
 * @throws IOException
 *             In case an error occurs during the search for an {@link ImageOutputStream} or
 *             during the eoncding process.
 */
public static final void writeJPEG(final RenderedImage image, final Object destination, final String compression, final float compressionRate, final boolean nativeAcc) throws IOException {
    ImageWriterSpi spi = nativeAcc ? clibSPI : turboSPI;
    ImageWriter writer = spi.createWriterInstance();
    // Compression is available on both lib
    final ImageWriteParam iwp = writer.getDefaultWriteParam();
    final ImageOutputStream outStream = nativeAcc ? new MemoryCacheImageOutputStream((OutputStream) destination) : new ImageOutputStreamAdapter((OutputStream) destination);
    iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
    iwp.setCompressionType("JPEG");
    // We can control quality here.
    iwp.setCompressionQuality(compressionRate);
    if (nativeAcc) {
        // Lossy compression.
        iwp.setCompressionType(compression);
    }
    try {
        if (iwp instanceof JPEGImageWriteParam) {
            final JPEGImageWriteParam param = (JPEGImageWriteParam) iwp;
            param.setOptimizeHuffmanTables(true);
            param.setProgressiveMode(JPEGImageWriteParam.MODE_DEFAULT);
        }
        writer.setOutput(outStream);
        writer.write(null, new IIOImage(image, null, null), iwp);
    } finally {
        if (writer != null) {
            try {
                writer.dispose();
            } catch (Throwable e) {
                System.out.println(e.getLocalizedMessage());
            }
        }
        if (outStream != null) {
            try {
                ((ImageOutputStream) outStream).close();
            } catch (Throwable e) {
                System.out.println(e.getLocalizedMessage());
            }
        }
    }
}