Examples of com.lightcrafts.mediax.jai.RenderedOp

com.lightcrafts.mediax.jai.RenderedOp
A node in a rendered imaging chain. A RenderedOp stores an operation name, a ParameterBlock containing sources and parameters, and a RenderingHints containing hints which may be used in rendering the node. A set of nodes may be joined together via the source Vectors within their respective ParameterBlocks to form a directed acyclic graph (DAG). The topology, i.e., connectivity, of the graph may be altered by changing the node's sources. The operation name, parameters, and rendering hints may also be changed.
Such chains are useful for example as arguments to a RemoteImage; they convey the structure of an imaging chain in a compact representation and at a suitably high level of abstraction to allow the server some leeway in materializing the results. They are also useful in that a chain may be manipulated dynamically and rendered multiple times. Thus for example the same chain of operations may be applied to different images or the parameters of certain operations in a chain may be modified interactively.
A RenderedOp may be constructed directly as, for example,
```
  ParameterBlock pb = (new ParameterBlock()).add("SomeFile.tif"); RenderedOp node = new RenderedOp("fileload", pb, null);  
```
or via the create or createNS() methods defined in the JAI class. The difference between direct construction of a node and creation via a convenience method is that in the latter case:
1. It is verified that the operation supports the rendered mode.
2. Using the validateArguments() method of the associated OperationDescriptor, the arguments (sources and parameters) are validated as being compatible with the specified operation.
3. Global RenderingHints maintained by the JAI instance are merged with the local RenderingHints with the local hints taking precedence.
4. If the operation is defined to be "immediate" (the isImmediate() method of the corresponding OperationDescriptor returns true) then the node is rendered.
When a chain of nodes is rendered by any means a "parallel" chain of RenderedImages is created. Each node in the chain of RenderedOps corresponds to a node in the chain of RenderedImages. RenderedImage methods invoked on the RenderedOp are in general forwarded to the associated RenderedImage which is referred to as the rendering of the node.
The translation between RenderedOp chains and RenderedImage (usually OpImage) chains makes use of two levels of indirection provided by the OperationRegistry and RenderedImageFactory (RIF) facilities. First, the local OperationRegistry is used to map the operation name into a RIF. This RIF then constructs a RenderedImage (usually an OpImage) which does the actual image data processing. The local OperationRegistry is used in order to take advantage of the best possible implementation of the operation, e.g., RIFs that provide acceleration for certain cases or RIFs that are known to a server without having to burden the client.
A node may be rendered explicitly by invoking the method getRendering() which also returns the rendering of the node. A node may be rendered implicitly by invoking any method defined in the RenderedImage interface. A node may also be rendered implicitly by invoking any method the execution of which
- requires some dimensional quantity of the image such as its bounds or tile layout;
- retrieves image data by any means;
The current rendering may be obtained without forcing the rendering of an unrendered node via the method getCurrentRendering(). A node may also be re-rendered via getNewRendering() which regenerates the rendering from the existing set of sources, parameters, and hints.
A rendering of a node may also be obtained by means of the createInstance() method. This method returns a PlanarImage rendering without marking the node as having been rendered. If the node is not marked as rendered then it will not fire RenderingChangeEvents as described below.
RenderedOp nodes may participate in Java Bean-style events. The PropertyChangeEmitter methods may be used to register and unregister PropertyChangeListeners. RenderedOps are also PropertyChangeListeners so that they may be registered as listeners of other PropertyChangeEmitters or the equivalent. Each RenderedOp also automatically receives any RenderingChangeEvents emitted by any of its sources which are also RenderedOps or any CollectionChangeEvents from any CollectionOp sources.
Certain PropertyChangeEvents may be emitted by the RenderedOp. These include the PropertyChangeEventJAIs and PropertySourceChangeEvents required by virtue of implementing the OperationNode interface. Additionally a RenderingChangeEvent may be emitted if the node has already been rendered and both of the following conditions are satisfied:
1. A. any of the critical attributes is changed (edited), i.e., the operation name, operation registry, node sources, parameters, or rendering hints; or
  B. the node receives a RenderingChangeEvent from one of its RenderedOp sources or a CollectionChangeEvent from one of its CollectionOp sources.
2. the old and new renderings differ over some non-empty region.
When a rendered RenderedOp node receives a RenderingChangeEvent from a RenderedOp source, then if the rendering is an OpImage, the region of the current rendering which may be retained will be determined by using mapSourceRect() to forward map the bounds of the invalid region. A similar procedure is used for "InvalidRegion" events emitted by source RenderedImages such as TiledImages. If a critical attribute of the node is edited, then the getInvalidRegion() method of the corresponding OperationDescriptor will be used to determine the invalid region. If the complement of the invalid region contains any tiles of the current rendering and the rendering is an OpImage, a new rendering of the node will be generated and the identified tiles will be retained from the old rendering insofar as possible. This might involve for example adding tiles to a TileCache under the ownership of the new rendering. A RenderingChangeEvent will then be fired to all PropertyChangeListeners of the node, and to any sinks that are PropertyChangeListeners. The newRendering parameter of the event constructor (which may be retrieved via the getNewValue() method of the event) will be set to either the new rendering of the node or to null if it was not possible to retain any tiles of the previous rendering.
RenderedOp nodes are WritablePropertySources and so manage a name-value database of image meta-data also known as image properties. Properties may be set on and requested from a node. The value of a property not explicitly set on the node (via setProperty()) is obtained from the property environment of the node. When a property is derived from the property environment it is cached locally to ensure synchronization, i.e., that properties do not change spontaneously if for example the same property is modified upstream.
The property environment of a RenderedOp is initially derived from that of the corresponding OperationDescriptor as maintained by the OperationRegistry. It may be modified locally by adding PropertyGenerators, directives to copy certain properties from specific sources, or requests to suppress certain properties. These modifications per se cannot be undone directly but may be eliminated as a side effect of other changes to the node as described below.
The RenderedOp itself synthesizes several property values, which may neither be set nor removed. These are: image_width, image_height, image_min_x_coord, image_min_y_coord, tile_cache and tile_cache_key. These properties are referred to as synthetic properties. The property tile_cache_key has a value of type {@link TileCache} which indicates where the tilesof the rendering are cached, if anywhere. The value of the property tile_cache_key is a {@link RenderedImage} by which thecached tiles are referenced in the indicated cache. If the rendering is of type {@link OpImage} or{@link com.lightcrafts.mediax.jai.remote.PlanarImageServerProxy} then the value oftile_cache_key will be set to the rendering itself and the value of tile_cache to the value returned by invoking getTileCache() on the rendering. Otherwise these properties will be set to the same values as the properties of the same names set on the rendering. It is legal for these properties to have the value java.awt.Image.UndefinedProperty.
When a property value is requested an attempt will be made to derive it from the several entities in the following order of precedence:
1. synthetic properties;
2. local properties;
3. the rendering of the node;
4. any registered PropertyGenerators, or
  a source specified via a copy-from-source directive;
5. the first node source which defines the property.
Local properties are those which have been cached locally either by virtue of direct invocation of setProperty() or due to caching of a property derived from the property environment. Note that the properties of a node are not copied to its rendering.
All dynamically computed properties of a RenderedOp which have been cached locally, i.e., those cached properties which were not set by an explicit call to setProperty(), will be cleared when any of the critical attributes of the node is edited. By implication these properties will also be cleared when a RenderingChangeEvent is received from any node source. The property environment or the cached properties may also be cleared by invoking resetProperties().
As mentioned, a RenderedOp chain created on a client may be passed to a server via a RemoteImage. Whether the node has been previously rendered is irrelevant to its ability to be serialized. Any RenderedImage sources which are not Serializable will be wrapped in SerializableRenderedImages for serialization. The tile transmission parameters will be determined from the RenderingHints of the node. All other non-serializable objects will attempt to be serialized using SerializerFactory. If no Serializer is available for a particular object, a java.io.NotSerializableException may result. Image properties (meta-data) are serialized insofar as they are serializable: non-serializable components are simply eliminated from the local cache of properties and from the property environment.
Note that RenderedOp nodes used to instantiate operations which have a corresponding OperationDescriptor the isImmediate() method of which returns true are rendered upon deserialization.
RenderedOp represents a single PlanarImage as a node in a RenderedImage operation chain. Its companion classes, RenderableOp and CollectionOp, represent nodes in operation chains of RenderableImages and CollectionImages, respectively. @see CollectionOp @see JAI @see OperationDescriptor @see OperationRegistry @see OpImage @see RenderableOp @see RenderingChangeEvent @see com.lightcrafts.mediax.jai.remote.SerializableRenderedImage @see com.lightcrafts.mediax.jai.remote.Serializer @see com.lightcrafts.mediax.jai.remote.SerializerFactory @see java.awt.RenderingHints @see java.awt.image.renderable.ParameterBlock @see java.awt.image.renderable.RenderedImageFactory

                              Object opNode) {
        validate(name, opNode);


        if(opNode instanceof RenderedOp &&
           name.equalsIgnoreCase("roi")) {
            RenderedOp op = (RenderedOp)opNode;


            ParameterBlock pb = op.getParameterBlock();


            // Retrieve the rendered source image and its ROI.
            RenderedImage src = pb.getRenderedSource(0);


            Object property = src.getProperty("ROI");
            if (property == null ||
                property.equals(java.awt.Image.UndefinedProperty) ||
                !(property instanceof ROI)) {
                return java.awt.Image.UndefinedProperty;
            }
            ROI srcROI = (ROI)property;


            // Determine the effective source bounds.
            Rectangle srcBounds = new Rectangle(src.getMinX(),
            src.getMinY(),
            src.getWidth(),
            src.getHeight());


            // If necessary, clip the ROI to the effective source bounds.
            if(!srcBounds.contains(srcROI.getBounds())) {
                srcROI = srcROI.intersect(new ROIShape(srcBounds));
            }


            // Retrieve the scale factors and translation values.
            float sx = pb.getFloatParameter(0);
            float sy = pb.getFloatParameter(1);


            // Create an equivalent transform.
            AffineTransform transform =
                new AffineTransform(sx, 0.0, 0.0, sy, 0.0, 0.0);


            // Create the scaled ROI.
            ROI dstROI = srcROI.transform(transform);


            // Retrieve the destination bounds.
            Rectangle dstBounds = op.getBounds();


            // If necessary, clip the warped ROI to the destination bounds.
            if(!dstBounds.contains(dstROI.getBounds())) {
                dstROI = dstROI.intersect(new ROIShape(dstBounds));
            }

View Full Code Here


            Object source = getNodeSource(i);
            Object ai = null;
      if (source instanceof RenderedOp) {


                RenderedOp src = (RenderedOp)source;
    ai = isNodeRendered ?
                    src.getRendering() :
                    src.createInstance();


            } else if ((source instanceof RenderedImage) ||
                       (source instanceof Collection)) {


                ai = source;

View Full Code Here

            throw new IllegalArgumentException(formatter.format(msgArg0));
        }


  // Find the id that refers to the corresponding RenderedOp on the
  // server
  RenderedOp op = (RenderedOp)node;
  Object rendering = op.getRendering();
  Long id = null;
  if (rendering instanceof RMIServerProxy) {
      id = ((RMIServerProxy)rendering).getRMIID();
  } else {
      throw new RuntimeException(

View Full Code Here

                // Construct a Collection of the RenderedOp nodes that
                // will be retained in the new CollectionImage.
                ArrayList commonNodes = new ArrayList(commonSources.size());
                it = oldRendering.iterator();
                while(it.hasNext()) {
                    RenderedOp node = (RenderedOp)it.next();
                    PlanarImage source = (PlanarImage)node.getSourceImage(0);
                    if(commonSources.contains(source)) {
                        commonNodes.add(node);
                    }
                }


                // Create a new CollectionImage.
                updatedCollection =
                    new AddConstToCollectionOpImage(newSource, newHints,
                                                    constants);


                // Remove from the new CollectionImage all nodes that
                // are common with the old CollectionImage.
                ArrayList newNodes = new ArrayList(oldRendering.size() -
                                                   commonSources.size());
                it = updatedCollection.iterator();
                while(it.hasNext()) {
                    RenderedOp node = (RenderedOp)it.next();
                    PlanarImage source = (PlanarImage)node.getSourceImage(0);
                    if(commonSources.contains(source)) {
                        it.remove();
                    }
                }

View Full Code Here


        // Derive the image if necessary.
        if(mres == null) {
            // Retrieve the source and parameters.
            RenderedImage source = paramBlock.getRenderedSource(0);
            RenderedOp downSampler =
                (RenderedOp)paramBlock.getObjectParameter(0);
            int maxLowResDim = paramBlock.getIntParameter(1);
            float minX = paramBlock.getFloatParameter(2);
            float minY = paramBlock.getFloatParameter(3);
            float height = paramBlock.getFloatParameter(4);

View Full Code Here

                              Object opNode) {
        validate(name, opNode);


        if(opNode instanceof RenderedOp &&
           name.equalsIgnoreCase("roi")) {
            RenderedOp op = (RenderedOp)opNode;


      ParameterBlock pb = op.getParameterBlock();


      // Retrieve the rendered source image and its ROI.
      RenderedImage src = pb.getRenderedSource(0);
      Object property = src.getProperty("ROI");
      if (property == null ||
    property.equals(java.awt.Image.UndefinedProperty) ||
    !(property instanceof ROI)) {
    return null;
      }
      ROI srcROI = (ROI)property;


      // Determine the effective source bounds.
      Rectangle srcBounds = null;
      PlanarImage dst = op.getRendering();
      if(dst instanceof WarpOpImage && !((OpImage)dst).hasExtender(0)) {
    WarpOpImage warpIm = (WarpOpImage)dst;
    srcBounds =
        new Rectangle(src.getMinX() + warpIm.getLeftPadding(),
          src.getMinY() + warpIm.getTopPadding(),
          src.getWidth() - warpIm.getWidth() + 1,
          src.getHeight() - warpIm.getHeight() + 1);
      } else {
    srcBounds = new Rectangle(src.getMinX(),
            src.getMinY(),
            src.getWidth(),
            src.getHeight());
      }


      // If necessary, clip the ROI to the effective source bounds.
      if(!srcBounds.contains(srcROI.getBounds())) {
    srcROI = srcROI.intersect(new ROIShape(srcBounds));
      }


      // Retrieve the scale factors
      float sx = 1.0F/pb.getIntParameter(1);
      float sy = 1.0F/pb.getIntParameter(2);


      // Create an equivalent transform.
      AffineTransform transform =
    new AffineTransform(sx, 0.0, 0.0, sy, 0, 0);


      // Create the scaled ROI.
      ROI dstROI = srcROI.transform(transform);


      // Retrieve the destination bounds.
      Rectangle dstBounds = op.getBounds();


      // If necessary, clip the warped ROI to the destination bounds.
      if(!dstBounds.contains(dstROI.getBounds())) {
    dstROI = dstROI.intersect(new ROIShape(dstBounds));
      }

View Full Code Here

                              Object opNode) {
        validate(name, opNode);


        if(opNode instanceof RenderedOp &&
           name.equalsIgnoreCase("roi")) {
            RenderedOp op = (RenderedOp)opNode;


            ParameterBlock pb = op.getParameterBlock();


            // Retrieve the rendered source image and its ROI.
            RenderedImage src = (RenderedImage)pb.getRenderedSource(0);
            Object property = src.getProperty("ROI");
            if (property == null ||
                property.equals(java.awt.Image.UndefinedProperty) ||
                !(property instanceof ROI)) {
                return java.awt.Image.UndefinedProperty;
            }


            // Return undefined also if source ROI is empty.
            ROI srcROI = (ROI)property;
            if (srcROI.getBounds().isEmpty()) {
                return java.awt.Image.UndefinedProperty;
            }


            // Retrieve the Interpolation object.
            Interpolation interp = (Interpolation)pb.getObjectParameter(1);


            // Determine the effective source bounds.
            Rectangle srcBounds = null;
            PlanarImage dst = op.getRendering();
            if (dst instanceof GeometricOpImage &&
                ((GeometricOpImage)dst).getBorderExtender() == null) {
                srcBounds =
                    new Rectangle(src.getMinX() + interp.getLeftPadding(),
                                  src.getMinY() + interp.getTopPadding(),
                                  src.getWidth() - interp.getWidth() + 1,
                                  src.getHeight() - interp.getHeight() + 1);
            } else {
                srcBounds = new Rectangle(src.getMinX(),
            src.getMinY(),
            src.getWidth(),
            src.getHeight());
            }


            // If necessary, clip the ROI to the effective source bounds.
            if(!srcBounds.contains(srcROI.getBounds())) {
                srcROI = srcROI.intersect(new ROIShape(srcBounds));
            }


            // Set the nearest neighbor interpolation object.
            Interpolation interpNN = interp instanceof InterpolationNearest ?
                interp :
                Interpolation.getInstance(Interpolation.INTERP_NEAREST);


            // Retrieve the Warp object.
            Warp warp = (Warp)pb.getObjectParameter(0);


            // Create the warped ROI.
            ROI dstROI = new ROI(JAI.create("warp", srcROI.getAsImage(),
                                            warp, interpNN));


            // Retrieve the destination bounds.
            Rectangle dstBounds = op.getBounds();


            // If necessary, clip the warped ROI to the destination bounds.
            if(!dstBounds.contains(dstROI.getBounds())) {
                dstROI = dstROI.intersect(new ROIShape(dstBounds));
            }

View Full Code Here

0 1 2 3

TOP

Related Classes of com.lightcrafts.mediax.jai.RenderedOp

com.lightcrafts.app.batch.BatchImageComponent

com.lightcrafts.media.jai.opimage.AddConstToCollectionCIF

com.lightcrafts.media.jai.opimage.RenderableCRIF

com.lightcrafts.media.jai.rmi.JAIRMIImageServer

com.lightcrafts.media.jai.rmi.JAIRMIUtil

com.lightcrafts.media.jai.rmi.RMIServerProxy

com.lightcrafts.media.jai.util.AreaOpPropertyGenerator

com.lightcrafts.mediax.jai.CRIFImpl

com.lightcrafts.mediax.jai.operator.AffinePropertyGenerator

com.lightcrafts.mediax.jai.operator.DFTPropertyGenerator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.