Java Advanced Imaging API v1.1 Readme

SPECIFICATION CHANGES

• Network Imaging

  A new architecture has been introduced in JAI 1.1-beta to perform Remote Imaging. The javax.media.jai.RemoteImage class which was used for Remote Imaging in JAI 1.0.x has been deprecated in JAI 1.1-beta. The main classes and interfaces for the new Remote Imaging architecture in JAI 1.1-beta can be found in the javax.media.jai.remote package. For detailed information, please refer to the Javadoc.

  An implementation of the JAI 1.1-beta Remote Imaging architecture is provided using RMI as the communication mechanism. This remote imaging protocol which uses RMI as the communication mechanism and expects instances of JAI to be running on both the client and the server is identified by the protocol name "jairmi". Thus in order to construct an instance of javax.media.jai.remote.RemoteJAI, the arguments that should be passed to the constructor should be the following: "jairmi" should be provided as the protocolName string, and the serverName string should refer to a server that has a server running which implements the "jairmi" protocol. Such a server is also provided in the JAI 1.1-beta release, the server is com.sun.media.jai.rmi.JAIRMIImageServer. Instructions on running Remote Imaging in JAI 1.1 are included above. It may be noted that this server which is compatible with the "jairmi" protocol is different from the server that was included with the JAI 1.0.x distribution (com.sun.media.jai.rmi.RMIImageImpl). The previous version of the server can still be used with a client that uses javax.media.jai.RemoteImage, but this use is discouraged as RemoteImage is deprecated as of JAI 1.1-beta.

• OperationRegistry

  Numerous changes were made to enhance the OperationRegistry and the capabilities that it provides.

  • JAI Registry File

    The registry file packaged outside the jar files is no longer part of the distribution. JAI 1.1-beta has a new way of adding user defined image operations and other registry information and for the automatic detection of these. Please read the javadoc for the OperationRegistry class for more information.

  • OperationRegistry

    The OperationRegistry has been extended to manage factories of image operation modes other than just "rendered" and "renderable". It has been extended to manage as yet unknown image operation modes as well as non-image operation modes. All mode-specific methods in OperationRegistry have therefore been deprecated. Separate mode-specific wrapper classes have been provided to allow compile-time type-safe access to the image factory management methods. (See RegistryMode, RIFRegistry, CRIFRegistry etc. for more information.)

    The OperationRegistry constructor is no longer thread safe (cf. getThreadSafeOperationRegistry() for more information).

  • OperationDescriptor

    OperationDescriptor and OperationDescriptorImpl have also been extended to manage image operation modes other than just "rendered" and "renderable". Mode-specific methods have therefore been deprecated and equivalent methods where the mode-names are explicitly specified have been added.

    The following new interfaces/classes to allow more flexible handling of parameter lists have been added :

    • ParameterListDescriptor/ParameterListDescriptorImpl
    • ParameterList/ParameterListImpl

    ParameterListDescriptor[Impl] in particular adds support for enumerated parameters as defined by the new EnumeratedParameter class.

    ParameterBlockJAI has also been rewritten to support the ParameterList interface.

    OperationDescriptorImpl now validates class types of paramDefaults against paramClasses (was not done in JAI 1.0.2).

  • Warning

    The user is strongly advised against using both the deprecated and the new API in OperationRegistry and OperationDescriptor. So it is better to either update all or none of the user code with respect to the new API.

• TileCache

  Design changes in the TileCache have been implemented in order to improve memory usage, performance and tile cache monitoring.

  • The TileCache can be globally enabled or disabled.
  • A new CachedTile interface has been provided.
  • A new cache metric has been added to allow alternate tile removal schemes to be implemented, other than the default "Least Recently Used" algorithm. Support for custom Comparators has been added.
  • Code has been inlined to improve performance.
  • Tiles that are no longer referenced will be properly garbage collected. This includes operators that go out of scope in a method.
  • The setTileCapacity() method has been deprecated.
  • The getTileCapacity() method has been deprecated.
  • New methods have been added to retrieve or set the percentage of memory in the tile cache which will be released if the tile cache becomes full.
  • Improved handling of OutOfMemoryError conditions.
  • New methods have been added to deal with multiple tiles. For example, all the tiles associated with a given operator can be retrieved in a single method call.
  • New diagnostic capabilities to allow monitoring of the tile cache.

• Improved Property (Meta-data) Management

  The handling of JAI properties (meta-data) has been enhanced and handling of Java Bean-style properties and events has been introduced. General benefits of this include the following:

  • Property names are now handled in a case-retentive as opposed to case-insensitive manner.
  • Property values are now synchronous in the manner of image data and not subject to change as a result of an upstream property having been modified.
  • Some aspects of the specification, including the use of multiple property name spaces, have been clarified.

  Some specific code changes to achieve the above include:

  • A base class PropertyChangeEventJAI of JAI-generated bean-style events was defined.
  • An event class PropertySourceChangeEvent was created to link the concepts of JAI properties and bean-style events.
  • An interface PropertyChangeEmitter was defined to allow simple identification of objects which may emit events.
  • Some modifications of the PropertySource and WritablePropertySource interfaces were made to improve generality.
  • A WritablePropertySource sub-interface was created and ImageJAI was modified to implement it instead of PropertySource. WritablePropertySource also extends PropertyChangeEmitter.
  • All classes which implement ImageJAI including PlanarImage are therefore WritablePropertySources and hence PropertyChangeEmitters.
  • Utility classes PropertySourceImpl and WritablePropertySourceImpl have been provided.
  • An OperationNode interface was created to generalize the commonalities among nodes in different types of operation chains. A helper class OperationNodeSupport was introduced for use by classes which implement OperationNode.
  • PlanarImage, CollectionImage, and RenderableOp have been modified to use helper objects of type WritablePropertySourceImpl and PropertyChangeSupportJAI.
  • RenderedOp, RenderableOp, and CollectionOp have been modified to use a helper object of type OperationNodeSupport.

• Support for Editing Rendered Op Chains

  The ability to edit chains of RenderedOps has been implemented. In JAI 1.0.2 once a node in a RenderedOp chain had been rendered it could no longer be modified.

  • Add RenderingChangeEvent for forward propagation in the chain from the edited node.
  • Add OperationDescriptor.getInvalidRegion() to determine the area which would be affected by changing the parameters or hints passed to an operation.
  • RenderedOp is made to be a generator and listener of events associated with modifying the parameters and hints of the node as well as of RenderingChangeEvents.
  • A helper object of type OperationNodeSupport is used to manage much of the event, parameter, and hint handling in a centralized manner.

• Improvements in Multi-tile Processing

  Multi-tile processing has been modified to allow control over the number of processing threads and their priority, and to introduce the concept of notification events to indicate completion of tile computation.

  • The TileScheduler now permits the number of processing threads and their priority to be set for both standard jobs and for prefetch jobs.
  • A listener interface TileComputationListener is defined which can receive notification when tiles are computed or when an error occurs.
  • A cancelTiles() method and a new version of scheduleTiles() which accepts TileComputationListeners were added to the TileScheduler interface.
  • A method queueTiles() was added to PlanarImage. This method is non-blocking and allows for notification when tiles are done. A cancelTiles() method was also added.
  • PlanarImage was modified to allow registration of TileComputationListeners which are to be notified when tiles are computed using queueTiles().
  • The OpImage and RenderedOp subclasses of PlanarImage were modified to override the new queue and cancel methods as needed.

• Non-image Data in Processing Chains

  The primary change of this nature was to enable deferring the computation of non-image data in processing chains in a manner to that which had already been available for image data.

  • Added an abstract class DeferredData which is the top-level class for data objects the computation of which is to be delayed.
  • Added a concrete DeferredProperty subclass to enable data computation deferral for image properties.
  • Added NullCRIF to simplify creating nodes in operation chains which are present merely to emit non-image data.

• Image Collection API Modifications

  Numerous changes were made to raise the quality level of the image collection API to be similar to that of the rendered image API and to provide a more general set of specific image collection implementations.

  • AttributedImage and AttributedImageCollection supersede the classes CoordinateImage, SequentialImage, ImageStack, and ImageSequence.
  • Clarified and improved support for renderable imaging in collection chains. Added RenderableCollectionImageFactory interface for use in the renderable collection mode.
  • Added chain editing and event notification analogous to that which is added to rendered chains in this release. In this context added the CollectionChangeEvent class and an update() method to the CollectionImageFactory interface.
  • Added the RenderedImageList class which provides a RenderedImage which is also a CollectionImage. As such this could be used as the class of a rendering of a node in either a collection or a rendered image chain.

• Serialization Support

  Added several classes to improve the serialization of objects in JAI.

  • Moved the formerly private SerializableRenderedImage class to the public API. This class allows serialization of an instance of any class which implements RenderedImage.
  • Added Serializer and SerializableState interfaces and the SerializerFactory to centralize and thereby simplify the process of serializing objects which are instances of classes which do not implement java.io.Serializable.

• Miscellaneous Core Modifications

  Numerous minor code modifications were effected. The changes are listed in a subsequent section; new classes are described presently.

  • CRIFImpl

    A utility class to simplify implementing ContextualRenderedImageFactory classes.

  • ColormapOpImage

    A class to be used to implement an operation which may conditionally be accelerated by transforming the colormap of the source image instead of its data.

  • GeometricOpImage

    An abstract base class for image operators that perform a geometric transformation of the source image. The core classes ScaleOpImage and WarpOpImage now extend this class. The former class hierarchy was OpImage > WarpOpImage > ScaleOpImage.

  • ColorSpaceJAI

    Adds some methods to the base ColorSpace class to enable color conversion of a raster of data at a time. This should permit efficient implementation of mathematically defined color spaces for which no ICC profile is available.

  • IHSColorSpace

    A representation of the IHS color space.

  • PixelAccessor

    A utility class that may be used to access the pixel data stored in a RenderedImage's Rasters, as well as performing pixel-to-color data translation based on the image's SampleModel and ColorModel. It also provides several static methods to determine information about the image data. This class uses two other new core classes: PackedImageData and UnpackedImageData which are used to store packed and unpacked data, respectively along with access information.

• Uncommitted Codecs Specification Modifications

  Changes were made primarily to improve the TIFF codec.

  • SeekableOutputStream:
    This class was added to enable compression in the TIFF encoder.

  • TIFF decoding:
    • Support reading 32-bit integer and floating point data.
    • Support gray-alpha (2-band) image loading.
    • Support N-banded inputs of 8X-bit depth.
    • Read YCbCr and CMYK images.
    • Read DEFLATE-compressed images.
    • Read JPEG-in-TIFF 8-bit images which are 1-band grayscale or 3-band YCbCr or RGB.
    • Support reading from an arbitrary offset to enable decoding a private IFD.

  • TIFF encoding:
    • Support writing tiled images.
    • Support writing 32-bit integer and floating point data.
    • Support writing multiple pages (images) per TIFF file.
    • Write gray-alpha images.
    • Write N-banded inputs of 8X-bit depth.
    • Write PackBits-compressed images.
    • Write DEFLATE-compressed images.
    • Write JPEG-in-TIFF 8-bit images which are 1-band grayscale or 3-band RGB.
    • Write extra user-specified fields.

  GENERAL CHANGES

• Backward compatibility

  Excluding the JAI operators, backward compatibility should have been preserved for all non-extenders of the API. This is to say that all public fields and methods of all public classes should be backward compatible with the exception of public constructors of abstract classes.

  Concerning the JAI operators, certain changes have been made which are backward incompatible:

  • Border

    • The BORDER_* constants were removed from the OperationDescriptor.
    • The "constants" parameter was deleted from the operation.
    • The "type" parameter changed from an Integer to a BorderExtender.

  • ColorConvert

    The single parameter "colorSpace" was renamed "colorModel" and its type was changed to ColorModel.

  • Histogram

    The parameter set of the operator was changed to the following:

    Parameters

    Name	Class	Default
    roi	ROI	null (entire image)
    xPeriod	Integer	1 (all pixels across rows)
    yPeriod	Integer	1 (all pixels down columns)
    numBins	int[]	{256}
    lowValue	double[]	{0}
    highValue	double[]	{256.0}

  • Composite, DFT, IDFT, MedianFilter, Shear, Transpose

    The integral constants defined in the OperationDescriptor associated with each of these operations have been changed to be subclasses of the new class javax.media.jai.EnumeratedParameter.

• Deprecations

  This section lists only deprecated interfaces and classes. For more details please refer to the JAI Javadoc.

  • javax.media.jai.CoordinateImage
  • javax.media.jai.ImageSequence
  • javax.media.jai.ImageStack
  • javax.media.jai.RemoteImage
  • javax.media.jai.SequentialImage
  • javax.media.jai.widget package and all classes therein

  CLASS-LEVEL CHANGES

• New Packages

  The following packages have been added to the specification:

  Package	Content
  javax.media.jai.registry	Registry modes and helper classes
  javax.media.jai.remote	JAI network imaging
  javax.media.jai.tilecodec	Tile codecs used in JAI network imaging
  javax.media.jai.util	Public utility classes

• New Interfaces

  The following interfaces have been added to the javax.media.jai package:

  CachedTile
  OperationNode
  OperationRegistrySpi
  ParameterList
  ParameterListDescriptor
  PropertyChangeEmitter
  RegistryElementDescriptor
  RenderableCollectionImageFactory
  TileComputationListener
  WritablePropertySource

• New Classes

  The following classes have been added to the javax.media.jai package:

  AttributedImage
  AttributedImageCollection
  CRIFImpl
  CollectionChangeEvent
  ColorSpaceJAI
  ColormapOpImage
  DeferredData
  DeferredProperty
  EnumeratedParameter
  GeometricOpImage
  IHSColorSpace
  NullCRIF
  OperationNodeSupport
  PackedImageData
  ParameterListDescriptorImpl
  ParameterListImpl
  PixelAccessor
  PropertyChangeEventJAI
  PropertyChangeSupportJAI
  PropertySourceChangeEvent
  PropertySourceImpl
  RegistryMode
  RenderedImageList
  RenderingChangeEvent
  UnpackedImageData
  WritablePropertySourceImpl

Note: These changes are not comprehensive but indicate the major changes which would affect re-tooling an extant product. For complete details please refer to the API specification javadoc which takes precedence in case of discrepancy.

• Histogram

  • Two new convenience constructors were added.
  • Methods were added to retrieve bin counts over ranges.
  • Added methods to extract derived statistics including the mean, standard deviation, entropy, and arbitrary moments including central, absolute, and absolute central moments.
  • Add methods to derive a histogram using a rectangular, weighted rectangular, or Gaussian moving window.
  • Add methods to compute a band-by-band threshold by the iterative selection, maximum entropy, maximum between class to within class variance, minimum error, minimum fuzziness, mode, and P-tile algorithms.

• JAI

  • A number of RenderingHints.Key constant fields were added for ColorModel initialization in OpImage, remote imaging and serialization, TileCache metric, and the TileScheduler.
  • A default tile size to be used by OpImage was defined via an accessor and mutator.
  • A getBuildVersion() method was added.
  • Many of the static create() convenience methods were deprecated.

• ROI

  The getAsImage() method now returns a binarized (bilevel) form of the image used to create the ROI. The binarized image is created using the specified threshold.

• ROIShape

  The getAsImage() method was modified to return a bilevel (binary) image instead of one which contains byte data.

• ParameterBlockJAI

  Support for named sources was added.

• PlanarImage

  • A method getDefaultColorModel() was added.
  • A new constructor was added: PlanarImage(layout,sources,properties).
  • setImageParameters() was replaced with setImageLayout(ImageLayout) which, unlike the method it replaces, verifies that if both a SampleModel and ColorModel are provided they are compatible as follows:
    • The SampleModel satisfies ColorModel.isCompatibleSampleModel(), and
    • If the ColorModel is a ComponentColorModel that:
      • The number of bands of the SampleModel equals the number of components of the ColorModel, and
      • SampleModel.getSampleSize(b) >= ColorModel.getComponentSize(b) for all bands b.
    This verification of SampleModel/ColorModel compatibility is also performed in the PlanarImage constructor which accepts an ImageLayout.
  • getNumBands() was added.
  • getTileIndices(Rectangle) was added to return the indices of all tiles overlapping a given Rectangle.
  • Raster[] getTiles() was added to return all tiles in the image.
  • getSources() was modified to return null if there are no sources instead of returning an empty Vector.

• RenderedOp, RenderableOp, and CollectionOp

  Formerly the ParameterBlock and RenderingHints of the node were saved by reference. They are now cloned. Consequently code such as

  RenderableOp opNode; ParameterBlock pb; Vector sources; opNode.setParameterBlock(pb); pb.setSources(sources);

  
  will no longer work as before. In this case the sources on the node will not be updated. Likewise the following code would not change the sources of the node:

  pb = opNode.getParameterBlock();
  pb.setSources(sources);
  

• RasterAccessor

  • Enhanced support for bilevel data handling.
  • Added methods: isBinary(), copyBinaryDataToRaster(), and getBinaryDataArray().

• TiledImage

  • Added two constructors:
    • TiledImage(RenderedImage,boolean areBuffersShared)
    • TiledImage(RenderedImage,tileWidth,tileHeight)
  • Added two methods to retrieve a sub-image while specifying its ColorModel.

• PlanarImage Hierarchy
  
  Many constructors in the PlanarImage hierarchy were modified. This is likely to be the source of many compilation errors encountered while building a JAI 1.0.2 application against JAI 1.1-beta.
  • OpImage

    • Removed the field "extenders" of type BorderExtender[]. BorderExtenders are not needed by all subclasses and so are pushed down to the top level classes in sub-hierarchies to which they are relevant. Within JAI this includes AreaOpImage and GeometricOpImage.

      Extenders of OpImage which previously utilized BorderExtenders are recommended to either:

      1. Include the BorderExtender in the subclass and override computeTile(), or
      2. Extend AreaOpImage and set the padding values to zero.

    • All previous constructors were deleted and replaced with the single constructor defined in the new version of the class.

  • AreaOpImage

    • Replaced previous constructor with a new definition
    • Added BorderExtender accessor and boolean presence verifier.

  • NullOpImage

    Added a new constructor; deprecated previous one.

  • PointOpImage

    • Replaced previous constructor with a new definition.
    • Modified checking of destination and source image bounds:
      • The intersection of all source bounds must be non-empty.
      • If the destination bounds are specified, the intersection of these bounds and the intersection of all source bounds must also be non-empty.
    • Added isColormapOperation() in support of colormap acceleration.

  • ScaleOpImage

    • Replaced previous constructor with a new definition
    • Deprecate accessor of padding values which are available from the Interpolation object.

  • SourcelessOpImage

    Replaced previous constructor with a new definition

  • UntiledOpImage

    • Added a constructor which permits multiple sources.
    • Changed specification of computeImage().

  • WarpOpImage

    Replaced previous constructor with a new definition

  OPERATOR CHANGES

• New Operators

  The following operators have been added: bandmerge, binarize, dilate, erode, filteredsubsample, maxfilter, minfilter, null, subsamplebinarytogray, unsharpmask.

• Changes to operators

  • As outlined above, the operators Border, ColorConvert, Composite, DFT, IDFT, Histogram, MedianFilter, Shear, and Transpose have been modified such that they are backward incompatible with JAI 1.0.2.

  • The "FileLoad" operator now has a "checkFileLocally" parameter which specifies whether the existence of the file to be loaded should be checked on the local file system.

  • The TIFF operator now has a "page" parameter but this change is backward compatible with JAI 1.0/1.0.2. The "TIFF" operator now also sets a property called "tiff_directory" on the RenderedImage generated.

  CHANGES TO CODEC HELPER CLASSES

• ImageCodec

  Fixed bug wherein createGrayIndexColorModel() was returning a ramp inverted from that which was expected.

• JPEGEncodeParam

  Implement Cloneable interface.

• SimpleRenderedImage

  Fixed bug wherein getProperty() was returning null for an undefined property instead of java.awt.Image.UndefinedProperty.

• SeekableOutputStream

  Added class to support compression in TIFF encoding.

• TIFFDecodeParam

  Added methods getJPEGDecompressYCbCrToRGB(), getIFDOffset(), setIFDOffset(), and setJPEGDecompressYCbCrToRGB().

• TIFFDirectory
  • Added "directory" parameter to the constructor which accepts an IFD offset.
  • Added methods getIFDOffset() and getNextIFDOffset().

• TIFFEncodeParam
  • Added fields COMPRESSION_DEFLATE and COMPRESSION_JPEG_TTN2.
  • Added methods getJPEGCompressRGBToYCbCr(), getJPEGEncodeParam(), getDeflateLevel(), getTileHeight(), getTileWidth(), getExtraImages(), setExtraImages(), setDeflateLevel(), setJPEGCompressRGBToYCbCr(), setJPEGEncodeParam(), setTileSize(), setExtraFields(), getExtraFields().

• TIFFField

  Implement the Comparable interface: add compareTo() method.

  PERFORMANCE CHANGES

• Native Acceleration

  • All Platforms

    • Native acceleration has been added to the "Warp" operation for the cases wherein the warp uses a grid or a polynomial for the geometric mapping and the interpolation object is an instance of InterpolationTable.

    • Native acceleration was expected to have been added for the new "FilteredSubsample" operation but was unavailable at the time of JAI 1.1-beta release. This will be made available for the final release of JAI 1.1.

  • Windows

    As described above, MMX hardware acceleration was added for the following operations:

    • arithmetic operators (add, addconst, and subtract only)
    • logical operators (and, not, or, xor)
    • affine (nearest neighbor, bilinear, bicubic)
    • convolve (3x3 and 5x5; general and separable cases)
    • scale (nearest neighbor, bilinear, bicubic)
    • absolute
    • bandcombine
    • transpose

• Operations on Bilevel (Binary) Data

  Binary images are defined to be those which have a SampleModel which is single-banded, is an instance of MultiPixelPackedSampleModel, and has a pixel bit stride (bits/pixel) of unity (1). Note that the SampleModel may have a transfer type of byte, short, or int and may have a bit offset. The most efficient case will in general be when the transfer type is byte and the bit offset is zero. For non-geometric accelerated operations, more efficiency (in speed and memory usage) should also be obtained by using the same tile size for all source and destination images.

  Some operations can process binary data directly in packed form. These operations are the following:

  • Absolute
  • Add
  • Affine (Nearest Neighbor interpolation only)
  • And
  • Copy
  • Dilate
  • Divide
  • Erode
  • Invert
  • Multiply
  • Not
  • Or
  • Rotate (Nearest Neighbor interpolation only)
  • Shear (Nearest Neighbor interpolation only)
  • Subtract
  • Translate (Nearest Neighbor interpolation only)
  • Xor

  All the above operations are binary accelerated without native code. Additionally the following operations are accelerated for binary data using native code:

  • Binarize
  • Convolve (3x3 kernels only)

• Operations on Colormapped Data

  When the source and destination images of certain operations are colormapped imagery, i.e., both have an IndexColorModel, processing may be accelerated in one of two ways.

  1. Colormap Modification

     In the first case the operation may be implemented by simply modifying the colormap (IndexColorModel) rather than actually processing the data. The operations for which this type of acceleration is implemented are the following:

     • AddConst
     • AndConst
     • DivideByConst
     • DivideIntoConst
     • Exp
     • Invert
     • Log
     • Lookup
     • MultiplyConst
     • Not
     • OrConst
     • Piecewise
     • Rescale
     • SubtractConst
     • SubtractFromConst
     • Threshold
     • XorConst

     All colormap modification processing is performed without native code.

  2. Geometric Processing

     When the interpolation used for geometric processing is nearest neighbor there is no need to expand the index data into RGB before warping the data. This type of processing should be about three times faster than if RGB data of the same dimensions were processed. All geometric operations support this case: Affine, Rotate, Shear, Transpose, Translate, and Warp. (Most, but not all, of these operations were in fact so accelerated in JAI 1.0.2.)

SPECIFICATION CHANGES

• TiledImage

  Deleted instance variable src. The source Vector of the PlanarImage superclass is instead used to manage the single source image, if any.

• Tile Queueing

  Some changes were made to improve the usability of background tile queueing.

  • TileRequest

    A new interface javax.media.jai.TileRequest was added to represent a list of tiles queued for background processing.

  • TileComputationListener

    • The concept of "per tile" as opposed to "block" listeners was removed. Consequently the isPerTileListener() and tilesComputed() methods were removed. All remaining methods are invoked on a per-tile basis only.

    • A method tileCancelled() was added to be invoked on tile cancellation.

    • The parameter lists of all methods were revised to include eventSource and TileRequest[] parameters.

  • TileScheduler

    • The scheduleTiles() method which accepts listeners was modified to accept only a single array of listeners and to return a TileRequest.

    • cancelTiles() was modified to accept a TileRequest parameter instead of a PlanarImage.

  • PlanarImage, OpImage, and RenderedOp

    • queueTiles() was modified to return a TileRequest.

    • cancelTiles() was modified to accept a TileRequest parameter.

• javax.media.jai.util.Range

  Added overriding of the hashCode() per the specification of java.lang.Object.

• Native Acceleration

  • All Platforms

    C acceleration was added to support this operation:

    • "FilteredSubsample" Operation

  • Solaris-only

    VIS acceleration was added to support this operation:

    • "FilteredSubsample" Operation

  • Windows-only

    MMX acceleration for byte and short data was added to support these operations:

    • "AndConst"

    • "BandSelect"

    • "Composite"

    • "Dilate" for 4x4 and 8x8 structuring elements and 1-band images.

    • "Erode" for 4x4 and 8x8 structuring elements and 1-band images.

    • "GradientMagnitude" for generic 3x3 masks.

    • "Max"

    • "MaxFilter" for 3x3 kernels and 1-band images.

    • "MedianFilter" for 3x3 kernels.

    • "Min"

    • "MinFilter" for 3x3 kernels and 1-band images.

    • "OrConst"

    • "Transpose" by 180 degrees.

    • "XorConst"

• Core Bugs
  • AreaOpImage allows its BorderExtender to be null but if the extender is null and data outside the source image are requested an exception will be thrown.

  • When a rendering is created from a RenderableOp, properties (meta-data) of the rendering may be overwritten by properties of the same name which are copied from the RenderableOp.

  • Renderable CollectionOps may emit CollectionChangeEvents; these should be emitted only in rendered mode.

  • Cannot set ColorModel via RenderingHints passed to JAI.create().

  • OpImage.getFormatTags() dies with a NullPointerException when calling getFormatTags() from (subclasses of) SourcelessOpImage.

• Operator Bugs

  • "scale" operation: when scaling a RenderedImage which has a non-zero value returned by getMinX() or getMinY(), a zero-valued row or column may occasionally appear at some border if the interpolation type is nearest neighbor. This fix may cause unexpected behavior in certain applications. In particular, when scaling an image with origin (0, 0), it may no longer be assumed that the origin of the destination image will have origin (0, 0) unless the interpolation type is nearest neighbor or a BorderExtender is provided via the RenderingHints

  • "iip" or "iipresolution" operations: the red and blue (first and third) bands of RGB data may be interchanged under certain circumstances.

  • "errordiffusion" operation: an ArrayIndexOutOfBoundsException exception has been observed when applying this operator to certain sources.

  • "mean" operator gives different results when x/y period != 1 when using mediaLib.

  • MinFilter/SQUARE/5x5 operator with mediaLib generates exception when using multi-band data.

  • "Overlay" fails if attempting to overlay a smaller image on a larger image.

• Remote Imaging Bugs

  • If the "fileload" operation is executed in renderable mode and the image file to be loaded is visible from the client but not from the server executing the operation then an exception will result. A workaround is to ensure that the file to be loaded is visible from both client and server.

• Codec Bugs

  • The TIFF decoder will fail with an exception if any of the fields StripByteCounts, StripOffsets, TileByteCounts, or TileOffsets contains an array of SHORTs rather than the more common array of LONGs. The Strip* fields apply to untiled (stripped) data and the Tile* fields to tiled data.

  • Using floating point TIFF images in JAI which were loaded by the JAI TIFF decoder causes a ClassCastException.

  • TIFF X,Y Resolution fields have hard-coded values in images encoded by JAI.

  • TIFF decoder cannot read tiled bilevel data with G3 or G4 compression.

  • TIFF encoder has incorrect tile/strip offsets for some integer, float images.

  • Bug in FileSeekableStream prevents reading of images > 2GB.

SPECIFICATION CHANGES

• JAI

  • Initial Value of the Default Tile Size

    This value was changed from 1024 to 512. For information on how to retrieve or modify this value see JAI.getDefaultTileSize() and JAI.setDefaultTileSize(), respectively. For information on how it is used refer to the OpImage constructor documentation.

  • Default Size of a RenderableOp Rendering.

    The default rendering of a RenderableOp node is obtained by RenderableOp.createDefaultRendering(). Formerly the default size of this rendering would frequently devolve to an image of height 1. Some changes were made to permit specifying a more reasonable default size. See RenderableOp.createDefaultRendering() for more information.

    • Added public field KEY_DEFAULT_RENDERING_SIZE to be used as a key to set the default size of a rendering created by RenderableOp.createDefaultRendering() via RenderingHints.

    • Added public method setDefaultRenderingSize() to set the global default rendering size.

    • Added public method getDefaultRenderingSize() to retrieve the global default rendering size.

  • Convenience Method Changes

    Some changes were made to the set of convenience create() methods, both static and non-static.

    • Added public RenderableOp createRenderableNS(String,ParameterBlock,RenderingHints) which accepts RenderingHints. These hints are merged with the global hints on the current JAI instance and the result is set on the created node.

    • Added public static RenderableOp createRenderable(String,ParameterBlock,RenderingHints) which accepts RenderingHints. These hints are merged with the global hints on the default JAI instance and the result is set on the created node.

    • Added public Collection createRenderableCollectionNS(String,ParameterBlock,RenderingHints) which accepts RenderingHints. These hints are merged with the global hints on the current JAI instance and the result is set on the created node.

    • Added public static Collection createRenderableCollection(String,ParameterBlock,RenderingHints) which accepts RenderingHints. These hints are merged with the global hints on the default JAI instance and the result is set on the created node.

    • Deprecated method public RenderableOp createRenderableNS(String,ParameterBlock) which is superseded by the version which accepts RenderingHints.

    • Deprecated method public Collection createRenderableCollectionNS(String,ParameterBlock) which is superseded by the version which accepts RenderingHints.

• PlanarImage/OpImage Hierarchy Constructors

  These constructors and the PlanarImage source Vector mutator methods were modified to disallow null sources and to remove the constraint that all sources must be RenderedImages.

• OperationNode and OperationNodeSupport

  Modified this interface and associated utility class to clarify how it is determined that an attribute of a node (ParameterBlock, etc.) has changed when updated via the associated mutator (setParameterBlock(), etc.).

• CollectionOp

  Modified behavior of method createRendering() to merge hints in RenderContext parameter with those set on the node with the argument hints taking precedence.

• RenderableOp

  • Added public constructor RenderableOp(OperationRegistry,String,ParameterBlock,RenderingHints) which accepts RenderingHints which are set on the node.

  • Modified behavior of public method createDefaultRendering() to use default rendering size set in node RenderingHints or on the JAI class in preference to using an identity transform for conversion from renderable to rendered coordinates.

• RenderedOp

  • Added method getCurrentRendering() to retrieve the rendering of the node without forcing the node to be rendered.

  • Added method getNewRendering() to force re-rendering of the node and return the new rendering.

• PerspectiveTransform

  • Deprecated constructors: PerspectiveTransform(float m00,...), PerspectiveTransform(double m00,...), PerspectiveTransform(float[] flatmatrix), PerspectiveTransform(float[][] matrix), PerspectiveTransform(double[] flatmatrix). These constructors had actually been deprecated before but the incorrect tag @Deprecated prevented their being marked as such in the javadoc.

  • Deprecated methods: public void setTransform(float m00,...) and double[] getMatrix(double[] flatmatrix).

  • Added setTransform(double[][] matrix).

• EnumeratedParameter

  Changed specification of String returned by toString().

• Property Environment Behavior

  • OperationRegistry

    Modified specification of the sources parameter of

        public PropertySource getPropertySource(String modeName,
                                                String descriptorName,
    					    Object op,
                                                Vector sources) {}
    

    to read:
    

    sources the PropertySources corresponding to the sources of the object representing the named descriptor in the indicated mode. The supplied Vector may be empty to indicate that there are no sources.

  • OperationNodeSupport

    Revised specification of getPropertySource() to indicate that the global property environment managed by the registry will not be included in the returned PropertySource if the mode in use does not support properties.

• RenderedImageAdapter

  Changed specification of getTiles() to require that the tile index parameters be verified as lying within the wrapped image's tile array before forwarded the call.

• SerializerFactory

  Clarified specification of getSerializers(), getSerializer(), and isSupportedClass() in particular with respect to the handling of Serializers which permit subclasses.

  PERFORMANCE CHANGES

• Native Acceleration

  • Windows Acceleration

    MMX acceleration for byte and short data was added to support these operations:

    • "Clamp"

    • "Extrema"

    • "FilteredSubsample"

    • "GradientMagnitude" optimization for Sobel mask.

    • "Invert"

    • "Lookup"

    • "Mean"

    • "Threshold"

    • "Warp" (for a Warp parameter which is an instance of WarpGrid or WarpPolynomial).

A number of inconsistencies between the specification and its implementation were identified and fixed. As these were mostly issues of the clarity of the API documentation and of the accord between exceptions stated versus those actually thrown they are not listed here in detail.

• Core Bugs

  • PlanarImage.getData(Rectangle) may throw a NullPointerException for bilevel image data when the requested Rectangle intersects the bounds of image tiles which do not intersect the bounds of the image. This problem has been observed when using the "FilteredSubsample" operator but may not be limited to this case.

  • When a RenderedOp node is rendered and subsequently edited and very large (1 Gb) images are in the chain, re-rendering of the chain could be very slow. This was determined to be due to the implementation of the determination of which regions of the chain nodes should be invalidated. The slowest part of the implementation was changed to provide much improved performance.

  • The intersection of certain Rectangles with an ROI in some cases could generate ArrayIndexOutOfBoundsExceptions.

  • Once the ROI threshold is set in the constructor, ROI.setThreshold() has no effect.

  • The OperationNodeSupport constructors were not setting the registry to the JAI default registry when the supplied registry parameter was null.

  • The image adapter classes RenderedImageAdapter, WritableRenderedImageAdapter and RenderableImageAdapter property set did not reflect a change in their source image's properties.

• Codec Bugs

  • The LZW decoder of the TIFF decoder was modified to detect the end of a compressed data strip when the terminating code "257" is missing.