/**
* Sets one of the node's sources to an Object. This is a convenience method that invokes <code>
* setParameterBlock()</code> and so adheres to the same event firing behavior.
*
* @param source the source, as an Object.
* @param index the index of the source.
* @throws IllegalArgumentException if <code>source</code> is <code>null</code>.
*/
public void setSource(Object source, int index) {
if (source == null) throw new IllegalArgumentException(JaiI18N.getString("Generic0"));
ParameterBlock pb = (ParameterBlock) nodeSupport.getParameterBlock().clone();
pb.setSource(source, index);
nodeSupport.setParameterBlock(pb);
}
private Vector getRenderableSources() {
Vector sources = null;
int numSrcs = nodeSupport.getParameterBlock().getNumSources();
if (numSrcs > 0) {
sources = new Vector();
for (int i = 0; i < numSrcs; i++) {
Object o = nodeSupport.getParameterBlock().getSource(i);
if (o instanceof RenderableImage) {
sources.add(o);
}
}
}
return sources;
}
/**
* Returns a default rendering of this <code>RenderableImage</code>. In all cases the area of
* interest will equal the image bounds. Any hints set on the node via <code>setRenderingHints()
* </code> will be used.
*
* <p>The dimensions of the created <code>RenderedImage</code> are determined in the following
* order of precedence:
*
* <ol>
* <li>If a <code>JAI.KEY_DEFAULT_RENDERING_SIZE</code> hint is set on the node it is used
* unless both its dimensions are non-positive.
* <li>The value returned by <code>JAI.getDefaultRenderingSize()</code> is used unless it is
* <code>null</code>.
* <li>An identity transform from renderable to rendered coordinates is applied.
* </ol>
*
* Either dimension of the default rendering size set in the hints or on the default <code>JAI
* </code> instance may be non-positive in which case the other dimension and the renderable
* aspect ratio will be used to compute the rendered image size.
*
* <p>This method does not validate sources and parameters supplied in the <code>ParameterBlock
* </code> supplied at construction against the specification of the operation this node
* represents. It is the caller's responsibility to ensure that the data in the <code>
* ParameterBlock</code> are suitable for this operation. Otherwise, some kind of exception or
* error will occur. Invoking this method will cause any <code>DeferredData</code> parameters to
* be evaluated.
*
* @return The default RenderedImage.
*/
public RenderedImage createDefaultRendering() {
// Get the default dimensions.
Dimension defaultDimension = null;
RenderingHints hints = nodeSupport.getRenderingHints();
if (hints != null && hints.containsKey(JAI.KEY_DEFAULT_RENDERING_SIZE)) {
defaultDimension = (Dimension) hints.get(JAI.KEY_DEFAULT_RENDERING_SIZE);
}
if (defaultDimension == null || (defaultDimension.width <= 0 && defaultDimension.height <= 0)) {
defaultDimension = JAI.getDefaultRenderingSize();
}
// Initialize scale factors to represent the identify transform.
double sx = 1.0;
double sy = 1.0;
// Reset the scale factors if a default dimension is set.
if (defaultDimension != null && (defaultDimension.width > 0 || defaultDimension.height > 0)) {
if (defaultDimension.width > 0 && defaultDimension.height > 0) {
sx = defaultDimension.width / getWidth();
sy = defaultDimension.height / getHeight();
} else if (defaultDimension.width > 0) {
sx = sy = defaultDimension.width / getWidth();
} else { // defaultDimension.height > 0
sx = sy = defaultDimension.height / getHeight();
}
}
// Create the renderable-to-rendered scaling.
AffineTransform transform = AffineTransform.getScaleInstance(sx, sy);
// Return the rendering applying the computed transform.
return createRendering(new RenderContext(transform));
}
/** Creates a <code>PropertySource</code> if none exists. */
private synchronized void createPropertySource() {
if (thePropertySource == null) {
// Create a <code>PropertySource</code> encapsulating the
// property environment of the node.
thePropertySource = nodeSupport.getPropertySource(this, null);
// Add the <code>PropertySource</code> to the helper object.
properties.addProperties(thePropertySource);
}
}
/**
* Removes all the node's sources. This is a convenience method that invokes <code>
* setParameterBlock()</code> and so adheres to the same event firing behavior.
*
* @since JAI 1.1
*/
public void removeSources() {
ParameterBlock pb = (ParameterBlock) nodeSupport.getParameterBlock().clone();
pb.removeSources();
nodeSupport.setParameterBlock(pb);
}
/**
* Returns one of the node's sources as an Object.
*
* @param index the index of the source.
*/
public Object getSource(int index) {
Vector sources = nodeSupport.getParameterBlock().getSources();
return sources.elementAt(index);
}
/**
* Sets the <code>OperationRegistry</code> that is used by this node. If the specified registry is
* <code>null</code>, the default registry is used.
*
* <p>If the supplied registry does not equal the current registry, a <code>PropertyChangeEventJAI
* </code> named "OperationRegistry" will be fired
*/
public synchronized void setRegistry(OperationRegistry registry) {
nodeSupport.setRegistry(registry);
}
/**
* Forces a property to be copied from the specified source node. By default, a property is copied
* from the first source node that emits it. The result of specifying an invalid source is
* undefined.
*
* @param propertyName the name of the property to be copied.
* @param sourceIndex the index of the from which to copy the property.
* @throws IllegalArgumentException if <code>propertyName</code> is <code>null</code>.
* @since JAI 1.1
*/
public synchronized void copyPropertyFromSource(String propertyName, int sourceIndex) {
nodeSupport.copyPropertyFromSource(propertyName, sourceIndex);
}
/**
* Removes a named property from the property environment of this node. Unless the property is
* stored locally either due to having been set explicitly via <code>setProperty()</code> or to
* having been cached for property synchronization purposes, subsequent calls to <code>
* getProperty(name)</code> will return <code>java.awt.Image.UndefinedProperty</code>, and <code>
* name</code> will not appear on the list of properties emitted by <code>getPropertyNames()
* </code>. To delete the property from the local property set of the node, <code>removeProperty()
* </code> should be used.
*
* @param name a String naming the property to be suppressed.
* @throws <code>IllegalArgumentException</code> if <code>name</code> is <code>null</code>.
*/
public void suppressProperty(String name) {
nodeSupport.suppressProperty(name);
}
/** Returns a clone of the <code>ParameterBlock</code> of this node. */
public ParameterBlock getParameterBlock() {
return (ParameterBlock) nodeSupport.getParameterBlock().clone();
}
/**
* Returns the <code>OperationRegistry</code> that is used by this node. If the registry had not
* been set, the default registry is returned.
*/
public synchronized OperationRegistry getRegistry() {
return nodeSupport.getRegistry();
}
/**
* Returns one of the node's parameters, as a short.
*
* @param index the index of the parameter.
*/
public short getShortParameter(int index) {
return nodeSupport.getParameterBlock().getShortParameter(index);
}
/**
* Returns one of the node's parameters, as a long.
*
* @param index the index of the parameter.
*/
public long getLongParameter(int index) {
return nodeSupport.getParameterBlock().getLongParameter(index);
}
/** Returns the name of the operation this node represents as a <code>String</code>. */
public String getOperationName() {
return nodeSupport.getOperationName();
}
/** Gets the minimum Y coordinate of the rendering-independent image data. */
public float getMinY() {
findCRIF();
ParameterBlock paramBlock = ImageUtil.evaluateParameters(nodeSupport.getParameterBlock());
Rectangle2D boundingBox = crif.getBounds2D(paramBlock);
return (float) boundingBox.getY();
}
/**
* Sets the common <code>RenderingHints</code> of this node. The supplied parameter is cloned if
* non-<code>null</code>.
*
* <p>If the supplied <code>RenderingHints</code> does not equal the current <code>RenderingHints
* </code>, a <code>PropertyChangeEventJAI</code> named "RenderingHints" will be fired.
*
* @param hints The new <code>RenderingHints</code> to be set; it may be <code>null</code>.
* @since JAI 1.1
*/
public synchronized void setRenderingHints(RenderingHints hints) {
if (hints != null) {
hints = (RenderingHints) hints.clone();
}
nodeSupport.setRenderingHints(hints);
}
/**
* Returns a clone of the common <code>RenderingHints</code> of this node or <code>null</code>.
*
* @since JAI 1.1
*/
public RenderingHints getRenderingHints() {
RenderingHints hints = nodeSupport.getRenderingHints();
return hints == null ? null : (RenderingHints) hints.clone();
}
/**
* Sets the <code>ParameterBlock</code> of this node. If the specified new <code>ParameterBlock
* </code> is <code>null</code>, it is assumed that this node has no input sources and parameters.
* The supplied parameter is cloned.
*
* <p>This method does not validate the content of the supplied <code>ParameterBlock</code>. The
* caller should ensure that the sources and parameters in the <code>ParameterBlock</code> are
* suitable for the operation this node represents; otherwise some form of error or exception may
* occur at the time of rendering.
*
* <p>If the supplied <code>ParameterBlock</code> does not equal the current <code>ParameterBlock
* </code>, a <code>PropertyChangeEventJAI</code> named "ParameterBlock", "Sources", or
* "Parameters" will be fired.
*
* <p>The <code>ParameterBlock</code> may include <code>DeferredData</code> parameters. These will
* not be evaluated until their values are actually required, i.e., when a rendering of the node
* is requested or the renderable dimensions are queried.
*
* @param pb The new <code>ParameterBlock</code> to be set; it may be <code>null</code>.
*/
public synchronized void setParameterBlock(ParameterBlock pb) {
nodeSupport.setParameterBlock(pb == null ? new ParameterBlock() : (ParameterBlock) pb.clone());
}
/**
* Returns one of the node's parameters, as a byte.
*
* @param index the index of the parameter.
*/
public byte getByteParameter(int index) {
return nodeSupport.getParameterBlock().getByteParameter(index);
}
/**
* Returns one of the node's parameters, as a double.
*
* @param index the index of the parameter.
*/
public double getDoubleParameter(int index) {
return nodeSupport.getParameterBlock().getDoubleParameter(index);
}
/**
* Returns one of the node's parameters, as a char.
*
* @param index the index of the parameter.
*/
public char getCharParameter(int index) {
return nodeSupport.getParameterBlock().getCharParameter(index);
}
/**
* Sets the name of the operation this node represents. The parameter is saved by reference.
*
* <p>If the supplied name does not equal the current operation name, a <code>
* PropertyChangeEventJAI</code> named "OperationName" will be fired.
*
* @param opName The new operation name to be set.
* @throws IllegalArgumentException if <code>opName</code> is <code>null</code>.
*/
public synchronized void setOperationName(String opName) {
nodeSupport.setOperationName(opName);
}
/**
* Returns one of the node's parameters, as an int.
*
* @param index the index of the parameter.
*/
public int getIntParameter(int index) {
return nodeSupport.getParameterBlock().getIntParameter(index);
}
/**
* Gets a RenderedImage that represents a rendering of this image using a given RenderContext.
* This is the most general way to obtain a rendering of a RenderableImage.
*
* <p>This method does not validate sources and parameters supplied in the <code>ParameterBlock
* </code> supplied at construction against the specification of the operation this node
* represents. It is the caller's responsibility to ensure that the data in the <code>
* ParameterBlock</code> are suitable for this operation. Otherwise, some kind of exception or
* error will occur. Invoking this method will cause any <code>DeferredData</code> parameters to
* be evaluated.
*
* <p>The <code>RenderContext</code> may contain a <code>Shape</code> that represents the
* area-of-interest (aoi). If the aoi is specifed, it is still legal to return an image that's
* larger than this aoi. Therefore, by default, the aoi, if specified, is ignored at the
* rendering.
*
* <p>Any hints in the <code>RenderContext</code> will be merged with any set on the node via
* <code>setRenderingHints()</code> with the hints in the <code>RenderContext</code> taking
* precedence.
*
* @param renderContext the RenderContext to use to produce the rendering.
* @return a RenderedImage containing the rendered data.
*/
public RenderedImage createRendering(RenderContext renderContext) {
findCRIF();
// Clone the original ParameterBlock; if the ParameterBlock
// contains RenderableImage sources, they will be replaced by
// RenderedImages.
ParameterBlock nodePB = nodeSupport.getParameterBlock();
Vector nodeParams = ImageUtil.evaluateParameters(nodePB.getParameters());
ParameterBlock renderedPB =
new ParameterBlock((Vector) nodePB.getSources().clone(), nodeParams);
Vector sources = getRenderableSources();
try {
// This assumes that if there is no renderable source, that there
// is a rendered source in the ParameterBlock.
// If there are any hints set on the node, create a new
// RenderContext which merges them with those in the RenderContext
// passed in with the passed in hints taking precedence.
RenderContext rcIn = renderContext;
RenderingHints nodeHints = nodeSupport.getRenderingHints();
if (nodeHints != null) {
RenderingHints hints = renderContext.getRenderingHints();
RenderingHints mergedHints = JAI.mergeRenderingHints(nodeHints, hints);
if (mergedHints != hints) {
rcIn =
new RenderContext(
renderContext.getTransform(), renderContext.getAreaOfInterest(), mergedHints);
}
}
if (sources != null) {
Vector renderedSources = new Vector();
for (int i = 0; i < sources.size(); i++) {
RenderContext rcOut = crif.mapRenderContext(i, rcIn, renderedPB, this);
RenderableImage src = (RenderableImage) sources.elementAt(i);
RenderedImage renderedImage = src.createRendering(rcOut);
if (renderedImage == null) {
return null;
}
// Add this rendered image to the ParameterBlock's
// list of RenderedImages.
renderedSources.addElement(renderedImage);
}
if (renderedSources.size() > 0) {
renderedPB.setSources(renderedSources);
}
}
RenderedImage rendering = crif.create(rcIn, renderedPB);
// Replace with the actual rendering if a RenderedOp.
if (rendering instanceof RenderedOp) {
rendering = ((RenderedOp) rendering).getRendering();
}
// Copy properties to the rendered node.
if (rendering != null && rendering instanceof WritablePropertySource) {
String[] propertyNames = getPropertyNames();
if (propertyNames != null) {
WritablePropertySource wps = (WritablePropertySource) rendering;
// Save the names of rendered properties.
HashSet wpsNameSet = null;
String[] wpsNames = wps.getPropertyNames();
if (wpsNames != null) {
wpsNameSet = new HashSet();
for (int j = 0; j < wpsNames.length; j++) {
wpsNameSet.add(new CaselessStringKey(wpsNames[j]));
}
}
// Copy any properties not already defined by the rendering.
for (int j = 0; j < propertyNames.length; j++) {
String name = propertyNames[j];
if (wpsNameSet == null || !wpsNameSet.contains(new CaselessStringKey(name))) {
Object value = getProperty(name);
if (value != null && value != java.awt.Image.UndefinedProperty) {
wps.setProperty(name, value);
}
}
}
}
}
return rendering;
} catch (ArrayIndexOutOfBoundsException e) {
// This should never happen
return null;
}
}
/**
* Returns one of the node's parameters, as a float.
*
* @param index the index of the parameter.
*/
public float getFloatParameter(int index) {
return nodeSupport.getParameterBlock().getFloatParameter(index);
}
/**
* Adds a PropertyGenerator to the node. The property values emitted by this property generator
* override any previous definitions.
*
* @param pg a PropertyGenerator to be added to this node's property environment.
*/
public void addPropertyGenerator(PropertyGenerator pg) {
nodeSupport.addPropertyGenerator(pg);
}
/**
* Returns one of the node's parameters, as an Object.
*
* @param index the index of the parameter.
*/
public Object getObjectParameter(int index) {
return nodeSupport.getParameterBlock().getObjectParameter(index);
}
/**
* Sets one of the node's parameters to an Object. This is a convenience method that invokes
* <code>setParameterBlock()</code> and so adheres to the same event firing behavior.
*
* <p>The <code>Object</code> may be a <code>DeferredData</code> instance. It will not be
* evaluated until its value is actually required, i.e., when a rendering of the node is requested
* or the renderable dimensions are queried.
*
* @param param the parameter, as an Object.
* @param index the index of the parameter.
*/
public void setParameter(Object param, int index) {
ParameterBlock pb = (ParameterBlock) nodeSupport.getParameterBlock().clone();
pb.set(param, index);
nodeSupport.setParameterBlock(pb);
}
