Limn programs


There are two steps to creating and interacting with a Limn animation. First the Limn class is used in the first step to create an animation sequenence and save it either as a quicktime movie or as a series of JPEG images. Then the View class can then be used to view the animation and even interact with the animation.

The Limn program creates an animation creation cycle as descirbed in the design page. Basically, it creates the Tour engine, rendering and recording type objects that are specified in its properties file and starts animation cycle that they from. The properties file is used to specifiy animation creation and appearance attributes.

The View program will display an animation and allow the user to control the playback. Additionally with animations based on the scatterplot view type, users can interact with the display. By brushing on areas plot, data points will be selected and the viewer will draw graphics around each point to highlight it. Because the highlight graphics are drawn on top of the scaterplot image performance will begin to lag if larger subsets of the data are selected. This rendering technique will avoid problems with over plotting of graphics as the highlights are always rendered on top of the data points.

Limn Prototype Design

Design of this limn prototype has revolved around keeping the overall structure simple and distilling out key functionality into distinct parts of the system. Java Interfaces have been defined for each of these parts and in themselves provide a high level overview of the system. Java Interfaces provide a way of reducing class dependencies within a system. By allowing objects to interact with one another through interface greatly increases the modularity of the system. Providing these interfaces also allows for greater specialization in the development of the system. Researchers and students that are mainly interested in the development of methods for a certain aspect of the animation production process will not need to keep in mind all the complications of other areas of the design.

Unlike Orca where the speed of the animations crucial to the real time viewing, Limn will allow each rendering to complete and for the recorder to process the rendered image in full before continuing on to the next frame. With real time rendering a few dropped frames may be acceptable to maintain performance, while with out the restriction of time, the importance should be more heavily on completeness and quality of image.

The main dependencies between objects to maintain the integrity of this process form a triangle of objects where for each frame rendered control is passed along between them. Here Interfaces are used to discuss each aspect of the system.
coreLimnEngine will manage the creation and interpolation between tour projection basis. It will notify the LimnRender component when a new projection has been created and is ready for rendering.

LimnRender is the core rendering object. While other objects may augment the graphic with navigation tools or indices, the basic structure and type of the graphic will be defined here. Once rendering is complete the recorder object is notified to save the image.

LimnRecorder receives notification from the LimnRender component to begin processing the next frame. Once finished processing it notifies the LimnEngine that the cycle has completed.

In addition to these three main production objects, there are a handful of object types needed to create the projection basis and manage the data. The main data objects are defined by the following interfaces.
LimnBasisFactory will be responsible for building appropriate projections. In some instances these will need to be generated in batches before the animation process begins to find the best combinations of projections for the tour. in others it might make more sense to build them as needed. The factory is only responsible for producing the main key frames of the projection, the LimnEngine is responsible for iterating between them.

LimnBasis is a small wrapper class that contains the active projection. It is little more than a convenience as it provides methods for performing the projections across rows of data. This object is accessed by both the LimnEngine which writes new projections into it and LimnRender which reads the projection information out of it.

LimnData provides some basic data access and selection features. A LimnData object may contain an entire data set or may only cache sections of data as needed.

Of these six interfaces, LimnBasisFactory and LimnRender cover the areas that seem most interesting to explore. Most likely they will be the interfaces that get the most attention.

There are a few lesser interfaces that will allow objects to augment a rendering, though they are probably not worth discussing at this point. The following classes implement the interfaces mentioned above:

LimnEngine TourEngine - basic basis interpolation and control fo
LimnRender RecordCanvas - Abstract class that provides the core functionality for providing the images to the recorder.
ScatterPlotRender - extends RecordCanvas and is a very simple 2d scatterplot canvas.
LimnRecorder QuicktimeRecorder - Provides methods for creating quicktime movies out of the animations.
JPEGImageSaver - saves images as JPEG images to be compiled by some external MPEG building utility.
LimnBasisFactory GTBasisFactory - produces random seeded basis.
PPHolesFactory - computes the ppholes index for each projection. This information can then be rendered within the animation, and can be used to set a rejection value for new projections.
LittleTourFactory - produces projections of all of the standard two dimensional scatterplots to tour between them.
FileBasisFactory - reads in bases values from a file (most of the other factories include methods for recording bases to a file).
LimnBasis SimpleBasis - contains active random basis and performs projection calculations against rows of data.
LimnData RAFData - will cache only sections of a data file when data from that section is needed.
SimpleData - copies all the data into memory.

JavaDoc and more on the specifics of implementing essential limn objects will be posted as available.