Package org.geotools.image

Class ImageWorker

  • public class ImageWorker
extends Object
    Helper methods for applying JAI operations on an image. The image is specified at creation time. Successive operations can be applied by invoking the methods defined in this class, and the final image can be obtained by invoking getRenderedImage() at the end of the process.

    If an exception is thrown during a method invocation, then this ImageWorker is left in an undetermined state and should not be used anymore.

    Since:
    2.3
    Author:
    Simone Giannecchini, Bryce Nordgren, Martin Desruisseaux

    • Field Detail

      • SCALE_OP_NAME

        public static final String SCALE_OP_NAME

      • JAIEXT_ENABLED

        public static final boolean JAIEXT_ENABLED

      • USE_JAI_SCALE2

        public static final boolean USE_JAI_SCALE2

      • WARP_REDUCTION_ENABLED_KEY

        public static final String WARP_REDUCTION_ENABLED_KEY
        Controls the warp-affine reduction
        See Also:
        Constant Field Values

      • FORCE_MOSAIC_ROI_PROPERTY

        public static final Hints.Key FORCE_MOSAIC_ROI_PROPERTY
        Specify whether to set a ROI property when doing a mosaic, even when background is specified

      • PRESERVE_CHAINED_AFFINES

        public static final Hints.Key PRESERVE_CHAINED_AFFINES
        Specify whether to preserve chained affines instead of collapsing them

    • Method Detail

      • isJaiExtEnabled

        public static boolean isJaiExtEnabled()

      • getXPeriod

        public int getXPeriod()
        The x-period used by statistical operations (e.g. extrema, mean, histogram). Defaults to 1.

      • setXPeriod

        public ImageWorker setXPeriod​(int xPeriod)
        Sets the x-period used by statistical operations (e.g. extrema, mean, histogram). E.g., setting it to 2 wil make the statistical operations read one pixel and skip one pixel, and so on.

      • getYPeriod

        public int getYPeriod()
        The y-period used by statistical operations (e.g. extrema, mean, histogram). Defaults to 1.

      • setYPeriod

        public ImageWorker setYPeriod​(int yPeriod)
        Sets the x-period used by statistical operations (e.g. extrema, mean, histogram). E.g., setting it to 2 wil make the statistical operations read one pixel and skip one pixel, and so on.

      • extractNoDataProperty

        public Range extractNoDataProperty​(RenderedImage image)

      • setImage

        public final ImageWorker setImage​(RenderedImage image)
        Prepare this builder for the specified image. The images to be computed (if any) will save their tiles in the default tile cache.
        Parameters:
        image - The source image.

      • load

        public final void load​(String source,
                       int imageChoice,
                       boolean readMetadata)
        Loads an image using the provided file name and the current hints, which are used to control caching and layout.
        Parameters:
        source - Filename of the source image to read.
        imageChoice - Image index in multipage images.
        readMetadata - If true, metadata will be read.

      • getImageAsROI

        public final ROI getImageAsROI()
        Returns a Region Of Interest built from the current image. If the image is multi-bands, then this method first computes an estimation of its intensity. Next, this method binarize the image and constructs a ROI from the result.
        Returns:
        The image as a region of interest.
        See Also:
        getRenderedImage(), getPlanarImage(), getRenderedOperation()

      • getROI

        public final ROI getROI()
        Returns the region of interest currently set, or null if none. The default value is null.
        Returns:
        The current region of interest.
        See Also:
        getMinimums(), getMaximums()

      • getNoData

        public final Range getNoData()
        Returns the NoData Range currently set, or null if none. The default value is null.
        Returns:
        The current NoData Range.

      • getDestinationNoData

        public final double[] getDestinationNoData()
        Returns the NoData Range currently set, or null if none. The default value is null.
        Returns:
        The current NoData Range.

      • isNoDataNeeded

        public boolean isNoDataNeeded()
        Returns true if destination NoData values must be set and they must be used in computation

      • setNoData

        public final ImageWorker setNoData​(Range nodata)
        Set the NoData Range for checking NoData during computation.
        Parameters:
        nodata - The new NoData Range.
        Returns:
        This ImageWorker

      • setBackground

        public final ImageWorker setBackground​(double[] background)
        Set the image background value
        Parameters:
        background - The image background.
        Returns:
        This ImageWorker

      • getRenderingHint

        public final Object getRenderingHint​(RenderingHints.Key key)
        Returns the rendering hint for the specified key, or null if none.

      • setRenderingHint

        public final ImageWorker setRenderingHint​(RenderingHints.Key key,
                                          Object value)
        Sets a rendering hint tile to use for all images to be computed by this class. This method applies only to the next images to be computed; images already computed before this method call (if any) will not be affected.

        Some common examples:

        • setRenderingHint(JAI.KEY_TILE_CACHE, null) disables completly the tile cache.
        • setRenderingHint(TILING_ALLOWED, Boolean.FALSE) forces all operators to produce untiled images.
        Returns:
        This ImageWorker

      • setRenderingHints

        public final ImageWorker setRenderingHints​(RenderingHints hints)
        Set a map of rendering hints to use for all images to be computed by this class. This method applies only to the next images to be computed; images already computed before this method call (if any) will not be affected.

        If hints is null we won't modify this list.

        Returns:
        This ImageWorker
        See Also:
        #setRenderingHint(RenderingHint)

      • removeRenderingHints

        public final ImageWorker removeRenderingHints()

      • removeRenderingHint

        public final ImageWorker removeRenderingHint​(RenderingHints.Key key)
        Removes a rendering hint. Note that invoking this method is not the same than invoking setRenderingHint(key, null). This is especially true for the tile cache hint:

        • setRenderingHint(JAI.KEY_TILE_CACHE, null) disables the use of any tile cache. In other words, this method call do request a tile cache, which happen to be the "null" cache.
        • removeRenderingHint(JAI.KEY_TILE_CACHE) unsets any tile cache specified by a previous rendering hint. All images to be computed after this method call will save their tiles in the JAI default tile cache.
        Returns:
        This ImageWorker

      • getRenderingHints

        public final RenderingHints getRenderingHints()
        Returns the rendering hints for an image to be computed by this class. The default implementation returns the following hints:

        • An image layout with tiles size computed automatically from the current image size.
        • Any additional hints specified through the setRenderingHint(java.awt.RenderingHints.Key, java.lang.Object) method. If the user provided explicitly a JAI.KEY_IMAGE_LAYOUT , then the user layout has precedence over the automatic layout computed in previous step.
        Returns:
        The rendering hints to use for image computation (never null).

      • tileCacheEnabled

        public final ImageWorker tileCacheEnabled​(boolean status)
        If false, disables the tile cache. Invoking this method with value true cancel the last invocation with value false. If this method was invoking many time with value false, then this method must be invoked the same amount of time with the value true for reenabling the cache.

        Note: This method name doesn't contain the usual set prefix because it doesn't really set a flag. Instead it increments or decrements a counter.

        Returns:
        This ImageWorker

      • getTransparentPixel

        public final int getTransparentPixel()
        Returns the transparent pixel value, or -1 if none.

      • getHistogram

        public Histogram getHistogram​(int[] numBins,
                              double[] lowValues,
                              double[] highValues)
        Returns the histogram of the image.

      • getMean

        public double[] getMean()
        Returns the minimums and maximums values found in the image. Those extremas are returned as an array of the form double[2][#bands].

      • isBytes

        public final boolean isBytes()
        Returns true if the image stores its pixel values in 8 bits.
        See Also:
        rescaleToBytes()

      • isColorSpaceRGB

        public final boolean isColorSpaceRGB()
        Returns true if the image uses a RGB color space. Note that a RGB color space doesn't mean that pixel values are directly stored as RGB components. The image may be indexed as well.
        See Also:
        forceColorSpaceRGB()

      • isColorSpaceGRAYScale

        public final boolean isColorSpaceGRAYScale()
        Returns true if the image uses a GrayScale color space. Note that a GrayScale color space doesn't mean that pixel values are directly stored as GrayScale component. The image may be indexed as well.
        See Also:
        forceColorSpaceGRAYScale()

      • rescaleToBytes

        public final ImageWorker rescaleToBytes()
        Rescales the image such that it uses 8 bits. If the image already uses 8 bits, then this method does nothing. Otherwise this method computes the minimum and maximum values for each band, rescale them in the range [0 .. 255] and force the resulting image to TYPE_BYTE.
        Returns:
        This ImageWorker
        See Also:
        isBytes(), RescaleDescriptor

      • forceIndexColorModelForGIF

        public final ImageWorker forceIndexColorModelForGIF​(boolean errorDiffusion)
        Converts the image to a GIF-compliant image. This method has been created in order to convert the input image to a form that is compatible with the GIF model. It first remove the information about transparency since the error diffusion and the error dither operations are unable to process images with more than 3 bands. Afterwards the image is processed with an error diffusion operator in order to reduce the number of bands from 3 to 1 and the number of color to 216. A suitable layout is used for the final image via the rendering hints in order to take into account the different layout model for the final image.

        Tip: For optimizing writing GIF, we need to create the image untiled. This can be done by invoking setRenderingHint(TILING_ALLOWED, Boolean.FALSE) first.

        Parameters:
        errorDiffusion - Tells if I should use ErrorDiffusionDescriptor or OrderedDitherDescriptor JAi operations.
        Returns:
        this ImageWorker.
        See Also:
        isIndexed(), forceIndexColorModel(boolean), forceBitmaskIndexColorModel()

      • forceComponentColorModel

        public final ImageWorker forceComponentColorModel​(boolean checkTransparent,
                                                  boolean optimizeGray,
                                                  boolean omitAlphaOnExpand)
        Reformats the color model to a component color model preserving transparency. This is used especially in order to go from PackedColorModel to ComponentColorModel, which seems to be well accepted from PNGEncoder and TIFFEncoder. The omitAlphaOnExpand param allows to explicity avoid producing an alpha band when expanding an IndexColorModel to ComponentColorModel. This may be useful when preparing an Image for JPEG encoding which do not support alpha band, avoiding the need of a BandSelect right after the color expansion. Note that this flag has only effect when expanding from IndexColorModel so alpha is preserved if input colorModel is already a ComponentColorModel.

        This code is adapted from jai-interests mailing list archive.

        Returns:
        this ImageWorker.
        See Also:
        FormatDescriptor

      • removeIndexColorModel

        public final ImageWorker removeIndexColorModel()
        If the image has an indexed color model, removes it, and replaces it with a component color model. can be useful before a band-merge if the image in question is not meant to be color expanded.

      • forceComponentColorModel

        public final ImageWorker forceComponentColorModel​(boolean checkTransparent)
        Reformats the color model to a component color model preserving transparency. This is used especially in order to go from PackedColorModel to ComponentColorModel, which seems to be well accepted from PNGEncoder and TIFFEncoder.

        This code is adapted from jai-interests mailing list archive.

        Parameters:
        checkTransparent - tells this method to not consider fully transparent pixels when optimizing grayscale palettes.
        Returns:
        this ImageWorker.
        See Also:
        FormatDescriptor

      • forceComponentColorModel

        public final ImageWorker forceComponentColorModel​(boolean checkTransparent,
                                                  boolean optimizeGray)
        Reformats the color model to a component color model preserving transparency. This is used especially in order to go from PackedColorModel to ComponentColorModel, which seems to be well accepted from PNGEncoder and TIFFEncoder.

        This code is adapted from jai-interests mailing list archive.

        Parameters:
        checkTransparent - tells this method to not consider fully transparent pixels when optimizing grayscale palettes.
        Returns:
        this ImageWorker.
        See Also:
        FormatDescriptor

      • forceColorSpaceIHS

        public final ImageWorker forceColorSpaceIHS()
        Forces the image color model to the IHS color space. If the current color space is already of IHS type, then this method does nothing. This operation may loose the alpha channel.
        Returns:
        this ImageWorker.
        See Also:
        ColorConvertDescriptor

      • bandMerge

        public final ImageWorker bandMerge​(int writeband)
        Add the bands to the Component Color Model
        Parameters:
        writeband - number of bands after the bandmerge.
        Returns:
        this ImageWorker.

      • addBand

        public final ImageWorker addBand​(RenderedImage image,
                                 boolean before)
        Perform a BandMerge operation between the underlying image and the provided one.
        Parameters:
        image - to merge with the underlying one.
        before - true if we want to use first the provided image, false otherwise.
        Returns:
        this ImageWorker.

      • addBand

        public final ImageWorker addBand​(RenderedImage image,
                                 boolean before,
                                 boolean addAlpha,
                                 Range nodata2)
        Perform a BandMerge operation between the underlying image and the provided one.
        Parameters:
        image - to merge with the underlying one.
        before - true if we want to use first the provided image, false otherwise.
        addAlpha - true if we want to set the last image as alpha, false otherwise.
        Returns:
        this ImageWorker.

      • addBands

        public final ImageWorker addBands​(RenderedImage[] bands,
                                  boolean addAlpha,
                                  Range[] nodata2)
        Perform a BandMerge operation between the underlying image and the provided one.
        Parameters:
        bands - to merge with the underlying one.
        addAlpha - true if we want to set the last image as alpha, false otherwise.
        Returns:
        this ImageWorker.

      • addBands

        public final ImageWorker addBands​(RenderedImage[] bands,
                                  boolean addAlpha,
                                  Range[] nodata2,
                                  List<AffineTransform> transformationList)
        Perform a BandMerge operation between the underlying image and the provided one.
        Parameters:
        bands - images to merge with the underlying one.
        addAlpha - true if we want to set the last image as alpha, false otherwise.
        transformationList - List of AffineTransformation that can be applied to the input rasters in order to repoject them to the same CRS.
        Returns:
        this ImageWorker.

      • intensity

        public final ImageWorker intensity()
        Creates an image which represents approximatively the intensity of image. The result is always a single-banded image. If the image uses an IHS color space, then this method just retain the first band without any further processing. Otherwise, this method performs a simple band combine operation on the image in order to come up with a simple estimation of the intensity of the image based on the average value of the color components. It is worthwhile to note that the alpha band is stripped from the image.
        Returns:
        this ImageWorker.
        See Also:
        BandCombineDescriptor

      • retainLastBand

        public final ImageWorker retainLastBand()
        Retains unconditionally the last band of image. All other bands (if any) are discarded without any further processing.

        It is worth to point out that we use the true number of bands rather than the number of color components. This means that if we apply this method on a colormapped image we get back the image itself untouched since it originally contains 1 band although the color components are 3 or 4 as per the attached colormap.

        Returns:
        this ImageWorker.
        See Also:
        getNumBands(), retainBands(int), BandSelectDescriptor

      • retainBands

        public final ImageWorker retainBands​(int numBands)
        Retains inconditionnaly the first numBands of image. All other bands (if any) are discarted without any further processing. This method does nothing if the current image does not have a greater amount of bands than numBands.
        Parameters:
        numBands - the number of bands to retain.
        Returns:
        this ImageWorker.
        See Also:
        getNumBands(), retainFirstBand(), BandSelectDescriptor

      • retainBands

        public final ImageWorker retainBands​(int[] bands)
        Retains inconditionnaly certain bands of image. All other bands (if any) are discarded without any further processing.
        Parameters:
        bands - the bands to retain.
        Returns:
        this ImageWorker.
        See Also:
        getNumBands(), retainFirstBand(), BandSelectDescriptor

      • format

        public final ImageWorker format​(int dataType)
        Formats the underlying image to the provided data type.
        Parameters:
        dataType - to be used for this FormatDescriptor operation.
        Returns:
        this ImageWorker

      • binarize

        public final ImageWorker binarize​(int value0,
                                  int value1)
        Binarizes the image (if not already done) and replace all 0 values by value0 and all 1 values by value1. If the image should be binarized using a custom threshold value (instead of the automatic one), invoke binarize(double) explicitly before this method.
        Returns:
        this ImageWorker.
        See Also:
        isBinary(), binarize(), binarize(double), BinarizeDescriptor, LookupDescriptor

      • makeColorTransparent

        public final ImageWorker makeColorTransparent​(Color transparentColor)
                                       throws IllegalStateException
        Replaces all occurences of the given color (usually opaque) by a fully transparent color. Currents implementation supports image backed by any IndexColorModel, or by ComponentColorModel with TYPE_BYTE. More types may be added in future GeoTools versions.
        Parameters:
        transparentColor - The color to make transparent.
        Returns:
        this image worker.
        Throws:
        IllegalStateException - if the current image has an unsupported color model.

      • invert

        public final ImageWorker invert()
        Inverts the pixel values of the image.
        See Also:
        InvertDescriptor

      • mask

        public final ImageWorker mask​(RenderedImage mask,
                              boolean maskValue,
                              int newValue)
        Applies the specified mask over the current image. The mask should be binarized - if it is not, this method will do it itself. Then, for every pixels in the mask with value equals to maskValue, the corresponding pixel in the image will be set to the specified newValue.

        Note: current implementation force the color model to an indexed one. Future versions may avoid this change.

        Parameters:
        mask - The mask to apply, as a binarized image.
        maskValue - The mask value to search for (false for 0 or true for 1).
        newValue - The new value for every pixels in image corresponding to maskValue in the mask.
        Returns:
        this ImageWorker.

      • max

        public ImageWorker max​(RenderedImage[] sources)
        Copmputes a pixel-by-pixel maximum value from all the provided sources. The images must share the same raster space.

      • min

        public ImageWorker min​(RenderedImage[] sources)
        Copmputes a pixel-by-pixel minimum value from all the provided sources. The images must share the same raster space.

      • addImage

        public final ImageWorker addImage​(RenderedImage renderedImage)
        Takes two rendered or renderable source images, and adds every pair of pixels, one from each source image of the corresponding position and band. See JAI AddDescriptor for details.
        Parameters:
        renderedImage - the RenderedImage to be added to this ImageWorker.
        Returns:
        this ImageWorker.
        See Also:
        AddDescriptor

      • multiplyConst

        public final ImageWorker multiplyConst​(double[] inValues)
        Takes one rendered or renderable image and an array of double constants, and multiplies every pixel of the same band of the source by the constant from the corresponding array entry. See JAI MultiplyConstDescriptor for details.
        Parameters:
        inValues - The constants to be multiplied.
        Returns:
        this ImageWorker.
        See Also:
        MultiplyConstDescriptor

      • multiply

        public final ImageWorker multiply​(RenderedImage renderedImage)
        Takes two rendered or renderable source images, and myltiply form each pixel the related value of the second image, each one from each source image of the corresponding position and band. See JAI MultiplyDescriptor for details.
        Parameters:
        renderedImage - the RenderedImage to be multiplied to this ImageWorker.
        Returns:
        this ImageWorker.
        See Also:
        MultiplyDescriptor

      • xorConst

        public final ImageWorker xorConst​(int[] values)
        Takes one rendered or renderable image and an array of integer constants, and performs a bit-wise logical "xor" between every pixel in the same band of the source and the constant from the corresponding array entry. See JAI XorConstDescriptor for details.
        See Also:
        XorConstDescriptor

      • subtract

        public final ImageWorker subtract​(RenderedImage renderedImage)
        Takes two rendered or renderable source images, and subtract form each pixel the related value of the second image, each one from each source image of the corresponding position and band. See JAI AddDescriptor for details.
        Parameters:
        renderedImage - the RenderedImage to be subtracted to this ImageWorker.
        Returns:
        this ImageWorker.
        See Also:
        SubtractDescriptor

      • or

        public final ImageWorker or​(RenderedImage renderedImage)
        Takes two rendered or renderable source images, and do an OR for each pixel images, each one from each source image of the corresponding position and band. See JAI AddDescriptor for details.
        Parameters:
        renderedImage - the RenderedImage to be subtracted to this ImageWorker.
        Returns:
        this ImageWorker.
        See Also:
        SubtractDescriptor

      • artifactsFilter

        public final ImageWorker artifactsFilter​(int threshold,
                                         int filterSize)

      • addTransparencyToIndexColorModel

        public ImageWorker addTransparencyToIndexColorModel​(RenderedImage alphaChannel,
                                                    boolean errorDiffusion)
        Adds transparency to a preexisting image whose color model is index color model. For all pixels with the value false in the specified transparency mask, the corresponding pixel in the image is set to the transparent pixel value. All other pixels are left unchanged.
        Parameters:
        alphaChannel - The mask to apply as a binarized image.
        errorDiffusion - Tells if I should use ErrorDiffusionDescriptor or OrderedDitherDescriptor JAi operations.
        Returns:
        this ImageWorker.
        See Also:
        isTranslucent(), forceBitmaskIndexColorModel()

      • addTransparencyToIndexColorModel

        public final ImageWorker addTransparencyToIndexColorModel​(RenderedImage alphaChannel,
                                                          boolean translucent,
                                                          int transparent,
                                                          boolean errorDiffusion)
        Adds transparency to a preexisting image whose color model is index color model. First, this method creates a new index color model with the specified transparent pixel, if needed (this method may skip this step if the specified pixel is already transparent. Then for all pixels with the value false in the specified transparency mask, the corresponding pixel in the image is set to that transparent value. All other pixels are left unchanged.
        Parameters:
        alphaChannel - The mask to apply as a binarized image.
        translucent - true if translucent images are allowed, or false if the resulting images must be a bitmask.
        transparent - The value for transparent pixels, to be given to every pixels in the image corresponding to false in the mask. The special value -1 maps to the last pixel value allowed for the indexed color model.
        errorDiffusion - Tells if I should use ErrorDiffusionDescriptor or OrderedDitherDescriptor JAi operations.
        Returns:
        this ImageWorker.

      • tile

        public final ImageWorker tile()
        If the was not already tiled, tile it. Note that no tiling will be done if 'getRenderingHints()' failed to suggest a tile size. This method is for internal use by write(java.io.File) methods only.
        Returns:
        this ImageWorker.

      • applyOpacity

        public ImageWorker applyOpacity​(float opacity)
        Applies the specified opacity to the image by either adding an alpha band, or modifying the existing one by multiplication
        Parameters:
        opacity - The opacity to be applied, between 0 and 1
        Returns:
        this ImageWorker.

      • write

        public final ImageWorker write​(File output)
                        throws IOException
        Writes the image to the specified file. This method differs from ImageIO#write(String,File) in a number of ways:

        • The image writer to use is inferred from the file extension.
        • If the image writer accepts File objects as input, then the file argument is given directly without creating an ImageOutputStream object. This is important for some formats like HDF, which work only with files.
        • If the image is not tiled, then it is tiled prior to be written.
        • If some special processing is needed for a given format, then the corresponding method is invoked. Example: forceIndexColorModelForGIF(boolean).
        Returns:
        this ImageWorker.
        Throws:
        IOException

      • writePNG

        public final void writePNG​(Object destination,
                           String compression,
                           float compressionRate,
                           boolean nativeAcc,
                           boolean paletted)
                    throws IOException
        Writes outs the image contained into this ImageWorker as a PNG using the provided destination, compression and compression rate.

        The destination object can be anything providing that we have an ImageOutputStreamSpi that recognizes it.

        Parameters:
        destination - where to write the internal image as a PNG.
        compression - algorithm.
        compressionRate - percentage of compression.
        nativeAcc - should we use native acceleration.
        paletted - should we write the png as 8 bits?
        Throws:
        IOException - In case an error occurs during the search for an ImageOutputStream or during the eoncding process.

      • writeGIF

        public final ImageWorker writeGIF​(Object destination,
                                  String compression,
                                  float compressionRate)
                           throws IOException
        Writes outs the image contained into this ImageWorker as a GIF using the provided destination, compression and compression rate.

        It is worth to point out that the only compressions algorithm available with the jdk GIFImageWriter is "LZW" while the compression rates have to be confined between 0 and 1. AN acceptable values is usally 0.75f.

        The destination object can be anything providing that we have an ImageOutputStreamSpi that recognizes it.

        Parameters:
        destination - where to write the internal image as a gif.
        compression - The name of compression algorithm.
        compressionRate - percentage of compression, as a number between 0 and 1.
        Returns:
        this ImageWorker.
        Throws:
        IOException - In case an error occurs during the search for an ImageOutputStream or during the eoncding process.
        See Also:
        forceIndexColorModelForGIF(boolean)

      • writeJPEG

        public final void writeJPEG​(Object destination,
                            String compression,
                            float compressionRate,
                            boolean nativeAcc)
                     throws IOException
        Writes outs the image contained into this ImageWorker as a JPEG using the provided destination , compression and compression rate.

        The destination object can be anything providing that we have an ImageOutputStreamSpi that recognizes it.

        Parameters:
        destination - where to write the internal image as a JPEG.
        compression - algorithm.
        compressionRate - percentage of compression.
        nativeAcc - should we use native acceleration.
        Throws:
        IOException - In case an error occurs during the search for an ImageOutputStream or during the eoncding process.

      • writeTIFF

        public final void writeTIFF​(Object destination,
                            String compression,
                            float compressionRate,
                            int tileSizeX,
                            int tileSizeY)
                     throws IOException
        Writes outs the image contained into this ImageWorker as a TIFF using the provided destination, compression and compression rate and basic tiling information

        The destination object can be anything providing that we have an ImageOutputStreamSpi that recognizes it.

        Parameters:
        destination - where to write the internal image as a TIFF.
        compression - algorithm.
        compressionRate - percentage of compression.
        tileSizeX - tile size x direction (or -1 if tiling is not desired)
        tileSizeY - tile size y direction (or -1 if tiling is not desired)
        Throws:
        IOException - In case an error occurs during the search for an ImageOutputStream or during the eoncding process.

      • affine

        public ImageWorker affine​(AffineTransform tx,
                          Interpolation interpolation,
                          double[] bgValues)
        Performs an affine transform on the image, applying optimization such as affine removal in case the affine is an identity, affine merging if the affine is applied on top of another affine, and using optimized operations for integer translates

      • crop

        public ImageWorker crop​(float x,
                        float y,
                        float width,
                        float height)
        Crops the image to the specified bounds. Will use an internal operation that ensures the tile cache and tile scheduler hints are used, and will perform operation elimination in case the crop is doing nothing, or in case the crop is performed over another crop

      • function

        public ImageWorker function​(ImageFunction function,
                            int w,
                            int h,
                            float xScale,
                            float yScale,
                            float xTrans,
                            float yTrans)

      • mosaic

        public ImageWorker mosaic​(RenderedImage[] images,
                          MosaicType type,
                          PlanarImage[] alphas,
                          ROI[] rois,
                          double[][] thresholds,
                          Range[] nodata)

      • border

        public ImageWorker border​(int leftPad,
                          int rightPad,
                          int topPad,
                          int bottomPad,
                          BorderExtender ext)

      • translate

        public ImageWorker translate​(float xTrans,
                             float yTrans,
                             Interpolation interp)

      • warp

        public ImageWorker warp​(Warp warp,
                        Interpolation interp)
        Warps the underlying raster using the provided Warp object.

      • scale

        public ImageWorker scale​(double xScale,
                         double yScale,
                         double xTrans,
                         double yTrans,
                         Interpolation interp)
        Scales the underlying raster using the provided parameters.

      • lookup

        public ImageWorker lookup​(LookupTable table)
        Performs Lookup on the underlying image

      • colorIndex

        public ImageWorker colorIndex​(ColorIndexer indexer)
        Warps the underlying using the provided Warp object.

      • classify

        public ImageWorker classify​(ColorMapTransform domain1D,
                            Integer bandIndex)
        Apply a Raster classification on the underlying image.

      • piecewise

        public ImageWorker piecewise​(PiecewiseTransform1D transform,
                             Integer bandIndex)
        Apply a Generic Piecewise operation on the underlying image.

      • rescale

        public ImageWorker rescale​(double[] scale,
                           double[] offset)
        Apply a rescale operation on the underlying image.

      • bandCombine

        public ImageWorker bandCombine​(double[][] coeff)
        Apply a rescale operation on the underlying image.

      • rangeLookup

        public ImageWorker rangeLookup​(Object rangeLookup)
        Apply a rangeLookup operation on the underlying image.

      • prepareForRendering

        public ImageWorker prepareForRendering()
        Forces all NODATA pixels, as well as those outside of the ROI, to be transparent (expanding the color model as needed in order to make it so). In case the image has no ROI or no nodata, the method won't perform any change

      • show

        public final ImageWorker show()
                       throws HeadlessException
        Shows the current image in a window together with the operation chain as a tree. This method is provided mostly for debugging purpose. This method requires the gt2-widgets-swing.jar file in the classpath.
        Returns:
        this ImageWorker.
        Throws:
        HeadlessException - if gt2-widgets-swing.jar is not on the classpath, or if AWT can't create the window components.
        See Also:
        org.geotools.gui.swing.image.OperationTreeBrowser#show(RenderedImage)

      • dispose

        public final void dispose()
        Provides a hint that this ImageWorker will no longer be accessed from a reference in user space. The results are equivalent to those that occur when the program loses its last reference to this image, the garbage collector discovers this, and finalize is called. This can be used as a hint in situations where waiting for garbage collection would be overly conservative.

        Mind, this also results in disposing the JAI Image chain attached to the image the worker is applied to, so don't call this method on image changes (full/partial) that you want to use.

        ImageWorker defines this method to remove the image being disposed from the list of sinks in all of its source images. The results of referencing an ImageWorker after a call to dispose() are undefined.

      • main

        public static void main​(String[] args)
        Loads the image from the specified file, and display it in a window. This method is mostly as a convenient way to test operation chains. This method can be invoked from the command line. If an optional -operation argument is provided, the Java method (one of the image operations provided in this class) immediately following it is executed. Example: 
         java org.geotools.image.ImageWorker -operation binarize <var><filename></var>