org.modeshape.sequencer.image
Class ImageMetadataSequencer

java.lang.Object
  org.modeshape.jcr.api.sequencer.Sequencer
      org.modeshape.sequencer.image.ImageMetadataSequencer

public class ImageMetadataSequencer
extends Sequencer

A sequencer that processes the binary content of an image file, extracts the metadata for the image, and then writes that image metadata to the repository.

This sequencer produces data that corresponds to the following structure:

• image:metadata node of type image:metadata
  • jcr:mimeType - optional string property for the mime type of the image
  • jcr:encoding - optional string property for the encoding of the image
  • image:formatName - string property for the name of the format
  • image:width - optional integer property for the image's width in pixels
  • image:height - optional integer property for the image's height in pixles
  • image:bitsPerPixel - optional integer property for the number of bits per pixel
  • image:progressive - optional boolean property specifying whether the image is stored in a progressive (i.e., interlaced) form
  • image:numberOfImages - optional integer property for the number of images stored in the file; defaults to 1
  • image:physicalWidthDpi - optional integer property for the physical width of the image in dots per inch
  • image:physicalHeightDpi - optional integer property for the physical height of the image in dots per inch
  • image:physicalWidthInches - optional double property for the physical width of the image in inches
  • image:physicalHeightInches - optional double property for the physical height of the image in inches

This structure could be extended in the future to add EXIF and IPTC metadata as child nodes. For example, EXIF metadata is structured as tags in directories, where the directories form something like namespaces, and which are used by different camera vendors to store custom metadata. This structure could be mapped with each directory (e.g. "EXIF" or "Nikon Makernote" or "IPTC") as the name of a child node, with the EXIF tags values stored as either properties or child nodes.

Nested Class Summary

Nested classes/interfaces inherited from class org.modeshape.jcr.api.sequencer.Sequencer

Sequencer.Context

Constructor Summary

ImageMetadataSequencer()

Method Summary

boolean	execute(Property inputProperty, Node outputNode, Sequencer.Context context) Execute the sequencing operation on the specified property, which has recently been created or changed.
void	initialize(NamespaceRegistry registry, NodeTypeManager nodeTypeManager) Initialize the sequencer.

Methods inherited from class org.modeshape.jcr.api.sequencer.Sequencer

getAcceptedMimeTypes, getLogger, getName, getPathExpressions, getRepositoryName, getUniqueId, hasAcceptedMimeTypes, isAccepted, registerDefaultMimeTypes, registerNamespace, registerNodeTypes, registerNodeTypes, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

ImageMetadataSequencer

public ImageMetadataSequencer()

Method Detail

execute

public boolean execute(Property inputProperty,
                       Node outputNode,
                       Sequencer.Context context)
                throws Exception

Description copied from class: Sequencer

Execute the sequencing operation on the specified property, which has recently been created or changed.

Each sequencer is expected to process the value of the property, extract information from the value, and write a structured representation (in the form of a node or a subgraph of nodes) using the supplied output node. Note that the output node will either be:

1. the selected node, in which case the sequencer was configured to generate the output information directly under the selected input node; or
2. a newly created node in a different location than node being sequenced (in this case, the primary type of the new node will be 'nt:unstructured', but the sequencer can easily change that using Node.setPrimaryType(String))

The implementation is expected to always clean up all resources that it acquired, even in the case of exceptions.

Note: This method must be threadsafe: ModeShape will likely invoke this method concurrently in separate threads, and the method should never modify the state or fields of the Sequencer implementation class. All initialization should be performed in Sequencer.initialize(NamespaceRegistry, NodeTypeManager).

Specified by:

execute in class Sequencer

Parameters:

inputProperty - the property that was changed and that should be used as the input; never null

outputNode - the node that represents the output for the derived information; never null, and will either be new if the output is being placed outside of the selected node, or will not be new when the output is to be placed on the selected input node

context - the context in which this sequencer is executing, and which may contain additional parameters useful when generating the output structure; never null

Returns:

true if the sequencer's output should be saved, or false otherwise

Throws:

Exception - if there was a problem with the sequencer that could not be handled. All exceptions will be logged automatically as errors by ModeShape.

initialize

public void initialize(NamespaceRegistry registry,
                       NodeTypeManager nodeTypeManager)
                throws RepositoryException,
                       IOException

Description copied from class: Sequencer

Initialize the sequencer. This is called automatically by ModeShape once for each Sequencer instance, and should not be called by the sequencer.

By default this method does nothing, so it should be overridden by implementations to do a one-time initialization of any internal components. For example, sequencers can use the supplied registry and nodeTypeManager objects to register custom namesapces and node types required by the generated content.

Overrides:

initialize in class Sequencer

Parameters:

registry - the namespace registry that can be used to register custom namespaces; never null

nodeTypeManager - the node type manager that can be used to register custom node types; never null

Throws:

RepositoryException - if operations on the NamespaceRegistry or NodeTypeManager fail

IOException - if any stream based operations fail (like importing cnd files)