ContextualRenderedImageFactory provides an interface for the
functionality that may differ between instances of
RenderableImageOp.  Thus different operations on RenderableImages
may be performed by a single class such as RenderedImageOp through
the use of multiple instances of ContextualRenderedImageFactory.
The name ContextualRenderedImageFactory is commonly shortened to
"CRIF."

 All operations that are to be used in a rendering-independent
chain must implement ContextualRenderedImageFactory.

 Classes that implement this interface must provide a
constructor with no arguments.

A ParameterBlock encapsulates all the information about sources and
parameters (Objects) required by a RenderableImageOp, or other
classes that process images.

 Although it is possible to place arbitrary objects in the
source Vector, users of this class may impose semantic constraints
such as requiring all sources to be RenderedImages or
RenderableImage.  ParameterBlock itself is merely a container and
performs no checking on source or parameter types.

 All parameters in a ParameterBlock are objects; convenience
add and set methods are available that take arguments of base type and
construct the appropriate subclass of Number (such as
Integer or Float).  Corresponding get methods perform a
downward cast and have return values of base type; an exception
will be thrown if the stored values do not have the correct type.
There is no way to distinguish between the results of
"short s; add(s)" and "add(new Short(s))".

 Note that the get and set methods operate on references.
Therefore, one must be careful not to share references between
ParameterBlocks when this is inappropriate.  For example, to create
a new ParameterBlock that is equal to an old one except for an
added source, one might be tempted to write:



ParameterBlock addSource(ParameterBlock pb, RenderableImage im) {
    ParameterBlock pb1 = new ParameterBlock(pb.getSources());
    pb1.addSource(im);
    return pb1;
}

 This code will have the side effect of altering the original
ParameterBlock, since the getSources operation returned a reference
to its source Vector.  Both pb and pb1 share their source Vector,
and a change in either is visible to both.

 A correct way to write the addSource function is to clone
the source Vector:



ParameterBlock addSource (ParameterBlock pb, RenderableImage im) {
    ParameterBlock pb1 = new ParameterBlock(pb.getSources().clone());
    pb1.addSource(im);
    return pb1;
}

 The clone method of ParameterBlock has been defined to
perform a clone of both the source and parameter Vectors for
this reason.  A standard, shallow clone is available as
shallowClone.

 The addSource, setSource, add, and set methods are
defined to return 'this' after adding their argument.  This allows
use of syntax like:



ParameterBlock pb = new ParameterBlock();
op = new RenderableImageOp("operation", pb.add(arg1).add(arg2));

A RenderableImage is a common interface for rendering-independent
images (a notion which subsumes resolution independence).  That is,
images which are described and have operations applied to them
independent of any specific rendering of the image.  For example, a
RenderableImage can be rotated and cropped in
resolution-independent terms.  Then, it can be rendered for various
specific contexts, such as a draft preview, a high-quality screen
display, or a printer, each in an optimal fashion.

 A RenderedImage is returned from a RenderableImage via the
createRendering() method, which takes a RenderContext.  The
RenderContext specifies how the RenderedImage should be
constructed.  Note that it is not possible to extract pixels
directly from a RenderableImage.

 The createDefaultRendering() and createScaledRendering() methods are
convenience methods that construct an appropriate RenderContext
internally.  All of the rendering methods may return a reference to a
previously produced rendering.

This class handles the renderable aspects of an operation with help
from its associated instance of a ContextualRenderedImageFactory.

An adapter class that implements ImageProducer to allow the
asynchronous production of a RenderableImage.  The size of the
ImageConsumer is determined by the scale factor of the usr2dev
transform in the RenderContext.  If the RenderContext is null, the
default rendering of the RenderableImage is used.  This class
implements an asynchronous production that produces the image in
one thread at one resolution.  This class may be subclassed to
implement versions that will render the image using several
threads.  These threads could render either the same image at
progressively better quality, or different sections of the image at
a single resolution.

A RenderContext encapsulates the information needed to produce a
specific rendering from a RenderableImage.  It contains the area to
be rendered specified in rendering-independent terms, the
resolution at which the rendering is to be performed, and hints
used to control the rendering process.

 Users create RenderContexts and pass them to the
RenderableImage via the createRendering method.  Most of the methods of
RenderContexts are not meant to be used directly by applications,
but by the RenderableImage and operator classes to which it is
passed.

 The AffineTransform parameter passed into and out of this class
are cloned.  The RenderingHints and Shape parameters are not
necessarily cloneable and are therefore only reference copied.
Altering RenderingHints or Shape instances that are in use by
instances of RenderContext may have undesired side effects.

The RenderedImageFactory interface (often abbreviated RIF) is
intended to be implemented by classes that wish to act as factories
to produce different renderings, for example by executing a series
of BufferedImageOps on a set of sources, depending on a specific
set of parameters, properties, and rendering hints.