*/ public abstract class DataType extends Object public abstract boolean equals(DataType type) public abstract boolean equalsExceptName(DataType type) public abstract Data newData() abstract ShadowType buildShadowType(DataDisplayLink link, ShadowType parent) abstract public String toString() /** ScalarType is the superclass of the VisAD hierarchy of scalar data types.
*/ public abstract class ScalarType extends DataType String Name; public ScalarType(String name) public String getName() /** RealType is the VisAD scalar data type for real number variables.
*/ public class RealType extends ScalarType String Units; Set DefaultSet; public RealType(String name) public void setUnits(String units) public String getUnits() public void setDefaultSet(Set sampling) system instances: XAxis, YAxis, ZAxis Latitude, Longitude, Radius Time Generic /** TextType is the VisAD scalar data type for text string variables.
*/ public class TextType extends ScalarType public TextType(String name) system instances: Generic /** TupleType is the general VisAD data type for vectors.
*/ public class TupleType extends DataType DataType[] comonents; public TupleType(DataType[] types) public int getDimension() public DataType getComponent(int i) public boolean setComponent(int i, DataType component) /** RealTupleType is the VisAD data type for tuples in R^n, for n>0.
*/ public class RealTupleType extends TupleType // Dimensions must match CoordinateSystem DefaultCoordinateSystem; Set DefaultSet; public RealTupleType(RealType[] types) public RealTupleType(RealType[] types, CoordinateSystem coord_sys) public void setDefaultSet(Set sampling) public Set getDefaultSet() system instances: SpatialCartesian2DTuple, SpatialLatLonTuple SpatialCartesian3DTuple, SpatialSphericalTuple Time1DTuple /** RealVectorType is the VisAD data type for vector field tuple in R^n, for n>0.
*/ public abstract class RealVectorType extends RealTupleType public RealVectorType(RealType[] types) public RealVectorType(RealType[] types, CoordinateSystem coord_sys) /** transform an array of vector values from a field, based on a coordinate transform of the field domain. This may use the Jacobean of the coordinate transform, but may be more complex. For example, vectors in m/s would not transform for a simple rescaling transform. Or the transform may be to a moving coordinate system. out, coord_out, in, coord_in are the arguments to the corresponding call to transformCoordinates; locs are the output values from the corresponding call to transformCoordinates; coord_vector is the CoordinateSystem associated with this RealVectorType; value are the vector values (already resampled at loc) */ public abstract double[][] transformVectors( RealTupleType out, CoordinateSystem coord_out, RealTupleType in, CoordinateSystem coord_in, CoordinateSystem coord_vector, double[][] loc, double[][] value) public RealTuple transformVectors( RealTupleType out, CoordinateSystem coord_out, RealTupleType in, CoordinateSystem coord_in, CoordinateSystem coord_vector, double[][] loc, RealTuple tuple) /** SetType is the VisAD data type for subsets of R^n for n>0.
*/ public class SetType extends DataType RealTupleType Domain; public SetType(DataType type) /** FunctionType is the VisAD data type for functions.
A Function domain type may be either a RealType (for a function with domain = R) or a RealTupleType (for a function with domain = R^n for n > 0).
*/ public class FunctionType extends DataType RealTupleType Domain; DataType Range; public FunctionType(DataType domain, DataType range) public RealTupleType getDomain() public DataType getRange() system instances: REAL_1TO1_FUNCTION, REAL_1TO3_FUNCTION ------------- Data classes: ------------- Data objects are various forms of approximations to real numbers, text strings, vectors, sets and functions. Any data object may take the value 'missing', and any sub-object of a data object may take the value 'missing'. All data objects have a DataType, which is a mathematical type rather than a synonym for class. All of the Java arithmetical operations are defined for data objects, to the extent that they make sense for the types involved. /** Data is the abstract superclass of the VisAD data hierarchy.
*/ public abstract class Data extends Object implements Cloneable DataType Type; long Tick; public Data(DataType type) public DataType getType() public long getTick() public long incTick() public abstract boolean isMissing() public Data binary(Data data, int op) public Data add(Data data) add, subtract, multiply, divide, pow, max, min, atan2, atan2Degrees, remainder public Data unary(int op) public Data abs() abs, acos, acosDegrees, asin, asinDegrees, atan, atanDegrees, ceil, cos, cosDegrees, exp, floor, log, rint, round, sin, sinDegrees, sqrt, tan, tanDegrees, negate public static int invertOp(int op) public abstract Object clone() public static Data add(Data a, Data b) etc public String toString() /** Scalar is the superclass of the VisAD hierarchy of scalar data.
*/ public abstract class Scalar extends Data public Scalar(ScalarType type) /** Real is the class of VisAD scalar data for real numbers internally, these are double precision floating point values.
NOTE that Double.NaN is used to indicate missing values - Double.NaN does have appropriate arithmetic semantics.
*/ public class Real extends Scalar double Value; public Real(RealType type) public Real(RealType type, double value) public Real(double value) public void setValue(double value) public double getValue() /** Text is the class of VisAD scalar data for text strings.
The null pointer is used to indicate missing.
*/ public class Text extends Scalar String Value; public Text(TextType type) public Text(TextType type, String value) public Text(String value) public void setValue(String value) public String getValue() // binary add is string concatenate /** Tuple is the general VisAD data class for vectors.
*/ public class Tuple extends Data Data[] tupleComponents; public Tuple(TupleType type) public Tuple(Data[] datums) public int getDimension() public Data getComponent(int i) public Data getComponent(DataType type) public void setComponent(int i, Data component) public void setComponent(DataType type, Data component) /** RealTuple is the VisAD data class for vectors in R^n for n>0.
*/ public class RealTuple extends Tuple // Dimensions must match // if non-null must have same Reference as // Type.DefaultCoordinateSystem CoordinateSystem TupleCoordinateSystem; public RealTuple(RealTupleType type) public RealTuple(RealTupleType type, double[] values) public RealTuple(Real[] reals) public void setCoordinateSystem(CoordinateSystem coord_sys) /** Function is the abstract superclass for approximate implmentations of mathematical function.
*/ public abstract class Function extends Data public Function(FunctionType type) public abstract Data evaluate(RealTuple domain) public int getDomainDimension() /** Field is the general VisAD class for finite samplings of functions from R^n to a range type, where n>0.
*/ public class Field extends Function // Dimensions must match // if non-null must have same Reference as // Type.Domain.DefaultCoordinateSystem CoordinateSystem DomainCoordinateSystem; // the sampling of the function domain // if DomainSet is UnionSet, Field value is mean of // non-missing values from Set components Set DomainSet; Data[] Range; // the array of function values public Field(FunctionType type) public void setDomainCoordinateSystem(CoordinateSystem coord_sys) public void setDomainSet(Set set) public void setSamples(Data[] range, boolean copy) public Data evaluate(RealTuple domain) public Data getSample(int index) public void setSample(Data domain, Data range) public void setSample(int index, Data range) public int getLength() /** resample range values of this to domain samples in set, either by nearest neighbor or mulit-linear interpolation may return this (i.e., not a copy) */ public Field resample(Set set, CoordinateSystem coord_sys) public static void setMode(int mode) // SAMPLE or INTERPOLATE public static int getMode() /**
Here's how to use domainEnumeration:
for (Enumeration e = field.domainEnumeration() ; e.hasMoreElements(); ) {
Data domain_sample = e.nextElement();
Data range = field.evaluate(domain_sample);
}
*/
public Enumeration domainEnumeration()
/**
FlatField is the VisAD class for finite samplings of functions whose
range type and range coordinate systems are simple enough to allow
efficient representation.A FlatField range type may be either a RealType (for a function with range = R), a RealTupleType (for a function with range = R^n for n > 0) of a Tuple whose components are RealType's and RealTupleType's.
CoordinateSystem's of values cannot vary between domain samples.
*/ public class FlatField extends Field // if non-null must have same Reference as // Type.Range.DefaultCoordinateSystem CoordinateSystem RangeCoordinateSystem; // for Real or RealTuple Range CoordinateSystem[] RangeCoordinateSystems; // for Tuple Range not // Real or RealTuple int TupleDimension; Set RangeSet; int RangeMode; // DOUBLE, FLOAT, INT, SHORT or BYTE public FlatField(FunctionType type) public void setRangeCoordinateSystem(CoordinateSystem coord_sys) public void setRangeCoordinateSystem(int i, CoordinateSystem coord_sys) public void setRangeSet(Set set) public void setSamples(double[][] range) /** convert this FlatField to a (non-Flat) Field */ public Field convertToField() public int getRangeDimension() /** Set is the abstract superclass of the VisAD hierarchy of sets.
Sets are subsets of R^n for n>0.
*/ public abstract class Set extends Data int DomainDimension; // this is a subset of R^DomainDimension int Length; // number of samples CoordinateSystem DomainCoordinateSystem; public Set(DataType type) public void setDomainCoordinateSystem(CoordinateSystem coord_sys) public int getDimension() public int getLength() /** convert an array of 1-D indices to an array of values in R^DomainDimension */ public abstract double[][] indexToValue(int[] index) /** convert an array of values in R^DomainDimension to an array of 1-D indices */ public abstract int[] valueToIndex(double[][] value) public boolean isIntegerSet() public boolean isLinearSet() public abstract boolean equals(Set set) /** SimpleSet is the abstract superclass of GriddedSets, PolyCells and MultiCells.
*/ public abstract class SimpleSet extends Set int ManifoldDimension; // dimension of subspace that set is embedded in public SimpleSet(DataType type, int manifold_dimension) public SimpleSet(DataType type) public int getManifoldDimension() /** for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if i-th value is outside grid (i.e., if no interpolation is possible) */ public abstract void valueToInterp(double[][] value, int[][] indices, double weights[][]); /** DoubleSet represents the finite (but large) set of samples of R^dimension made by vectors of IEEE double precision floating point numbers.
DoubleSet cannot be used for the domain sampling of a Field.
*/ public class DoubleSet extends SimpleSet public DoubleSet(DataType type) // the indexToValue, valueToIndex & valueToInterp methods // throw SetException's /** FloatSet represents the finite (but large) set of samples of R^dimension made by vectors of IEEE single precision floating point numbers.
FloatSet cannot be used for the domain sampling of a Field.
*/ public class FloatSet extends SimpleSet public FloatSet(DataType type) // the indexToValue, valueToIndex & valueToInterp methods // throw SetException's /** GriddedSet is implemented by those Set sub-classes whose samples lie on a rectangular grid topology (but note the geometry need not be rectangular). It is a M-dimensional array of points in R^N where ManifoldDimension = M <= N = DomainDimension.
The order of the samples is the rasterization of the orders of the 1D components, with the first component increasing fastest. For example, here is the order of 30 product samples when the first component is has 6 samples and the second component has 5 samples (note index is 0-based):
second (Y) component
first 0 6 12 18 24
1 7 13 19 25
(X) 2 8 14 20 26
3 9 15 21 27
component 4 10 16 22 28
5 11 17 23 29
Grid coordinates are zero-based and in the range -0.5 to length-0.5
i.e., there are "length" intervals of length 1.0,
the first centered on 0.0 and the last centered on length-1.0
points outside this range are indicated by the grid coordinate
Double.NaN.*/ public class GriddedSet extends SimpleSet double[][] Samples; // double[DomainDimension][Length], grid int[] Lengths; // double[ManifoldDimension], factors of Length double Low[], Hi[]; // double[DomainDimension], bounds of Samples public GriddedSet(DataType type, int[] lengths) public GriddedSet(DataType type, double[][] samples, int[] lengths) /** transform an array of non-integer grid coordinates to an array of values in R^DomainDimension */ public double[][] gridToValue(double[][] grid) /** transform an array of values in R^DomainDimension to an array of non-integer grid coordinates */ public double[][] valueToGrid(double[][] value) GriddedSet sub-class hierarchy: LinearSet IntegerSet Gridded1DSet Linear1DSet Integer1DSet Gridded2DSet Linear2DSet Integer2DSet LinearLatLonSet Gridded3DSet Linear3DSet Integer3DSet IrregularSet extends SimpleSet just a list of points in R^DomainDimension the class constructor computes a Delaunay Triangulation for the list of points PolyCell extends SimpleSet list of RealTuples P1, P2, ..., PK in R^DomainDimension where each Pi, ..., P(i+ManifoldDimension) is interpreted as a Cell a missing RealTuple is interpreted as a break in the chain MultiCell extends SimpleSet list of RealTuples P1, P2, ..., PK in R^DomainDimension each has a list of pointers to Polyhedra list of Polyhedra (degree ManifoldDimension+1) each has a list of pointers to ManifoldDimension+1 RealTuples ProductSet extends SimpleSet SimpleSet[] FactorSets; int[] PermutationSet; // int[DomainDimension], select FactorSet int[] PermutationIndex; // int[DomainDimension], index into FactorSet // useful for spatial Display Field samplings // ConstantMap-s generate FactorSets with one sample UnionSet extends Set finite union of SimpleSets (MultiCells, PolyCells and GriddedSets) must all have same Domain ------------------- Performance issues: ------------------- This design avoids invoking methods once per datum through the use of FlatField's. These are logically Field's of Tuple's of RealType's and RealTupleType's. Internally FlatField's are stored as arrays of numerical values, rather than the arrays of data objects stored in Field's. Many of the methods in the FlatField class and in other classes (e.g., CoordinateTransform, Set, RealVectorType) process data in the form double[Dimension][Length] where Length is the number of samples in a Field and Dimension is the number of numerical elements in the Field range values. Note that the order of the Length and Dimension indices are reversed as array indices. This allows efficient processing of long columns of Field value components. For example, if Latitude is one component of Field values, then any computation involving Latitude can be applied in a tight loop to all Latitude's in the Field. FlatField's support range types more general than RealTuple's. To understand the motive, consider a set of observations that include Latitude, Longitude, Altitude, Pressure, Temperature, etc. We can organize these as a Field whose range values have the Tuple type: (Latitude, Longitude, Altitude, Pressure, Temperature, ...) However, in order to declare that (Latitude, Longitude, Altitude) is a coordinate system with coordinate transform functions to other spatial coordinate systems, we need to organize: (Latitude, Longitude, Altitude) as a RealTupleType. Hence the range type of the Field of observations must be: ((Latitude, Longitude, Altitude), Pressure, Temperature, ...) which is not a RealTupleType (since one of its components is a RealTupleType). In order to process such data efficiently, FlatField's must support range types that are Tuple's of RealType's and RealTupleType's. --------------------------- Other data-related classes: --------------------------- /** DateTime is a class of objects for holding date and time information.
*/ public class DateTime extends Object // seconds since midnight 1 January 0001 // double is 1 sign, 11 exp, 52 mant -> 4 x 10^15; 2000 yrs -> 6 x 10^10 secs double SecondsSinceMidnight01Jan0001; public DateTime(Real real) public DateTime(int year, int day, double seconds) public static Real fromYearDaySeconds(int year, int day, double seconds) public Real getReal() public boolean isMissing() public String toString() public String dateString() public String timeString() /** CoordinateSystem is the VisAD class for cordinate systems for vectors in R^n for n>0.
*/ public abstract class CoordinateSystem extends Object RealTupleType Reference; // e.g., (Latitude, Longitude, Radius) int DomainDimension; public CoordinateSystem(RealTupleType reference) /** from this CoordinateSystem to Reference */ public abstract double[][] toReference(double[][] value) /** from Reference to this CoordinateSystem */ public abstract double[][] fromReference(double[][] value) /** transform coordinates between two RealTupleType's; in and coord_in are the type and CoordinateSystem associated with value; out and coord_out are the target type and CoordinateSystem; value is the array of values to transform */ public static double[][] transformCoordinates( RealTupleType out, CoordinateSystem coord_out, RealTupleType in, CoordinateSystem coord_in, double[][] value) internal sub-classes: SphericalCoordinateSystem, HSVCoordinateSystem, CMYCoordinateSystem ---------------- Display classes: ---------------- The display architecture is based on three goals: 1. Display data according to a set of mappings from RealType's (e.g., Latitude, Time, Pressure) to DisplayRealType's (e.g., xAxis, RGB, Animation). 2. Allow user extensions, to define new DisplayRealType's, new DisplayRealTuple's (and hence new display CoordinateSsystem's), and new display transformation and rendering algorithms. 3. Support direct manipulation, where users modify data objects by manipulating their graphical depictions. /** DisplayRealType is the class for display real scalar types. A fixed set is defined by the system, users may add others. */ public class DisplayRealType extends RealType double DefaultValue; DisplayTupleType tuple; // tuple to which DisplayRealType belongs, or null int tupleIndex; // index within tuple boolean Single; // true if only one instance allowed in complex display type Control control; // prototype of appropriate Control subclass, or null boolean System; // true is this is an intrinsic (created by the system) public DisplayRealType(String name, Control cont, boolean single, double def) /** DisplayTupleType is the class for tuples of DisplayRealType's.
*/ public class DisplayTupleType extends RealTupleType public DisplayTupleType(DisplayRealType[] types) public DisplayTupleType(DisplayRealType[] types, CoordinateSystem coord_sys) /** mapping from RealType to DisplayRealType; A set of these define how data are dislayed */ public class ScalarMap extends Object RealType Scalar; DisplayRealType DisplayScalar; Control control; // control associated with DisplayScalar, or null Display display; // unique Display this ScalarMap is part of Function function; // 1-D mapping from Scalar values to DisplayScalar values // if null then use identity mapping public ScalarMap(RealType scalar, DisplayRealType display_scalar) public ScalarMap(RealType scalar, DisplayRealType display_scalar, Function func) /** create controls for DisplayScalar */ void setControls() public String toString() /** mapping from constant to DisplayRealType */ public class ConstantMap extends ScalarMap // no Scalar, control or function for ConstantMap double Constant; public ConstantMap(double constant, DisplayRealType display_scalar) public ConstantMap(Real constant, DisplayRealType display_scalar) /** Control is the VisAD superclass for controls for display scalars.
*/ public abstract class Control extends Object implements Cloneable public Control() public Control copy(Display display, ScalarMap map) public abstract Object clone() Control sub-classes: AnimationControl (single per Display) boolean Animate; double RangeLow, RangeHi, Step, Current; FlowControl (two per Display) boolean HorizontalVectorSlice, VerticalVectorSlice; boolean HorizontalStreamSlice, VerticalStreamSlice; boolean[] TrajectorySet; double HorizontalVectorSliceHeight, HorizontalStreamSliceHeight; // etc ColorControl (multiple per Display) Function table; public void setTable(Function func) ContourControl (multiple per Display) boolean HorizontalContourSlice, VerticalContourSlice, ContourSuface; double SurfaceValue; double HorizontalSliceLow, HorizontalSliceHi, HorizontalSliceStep; double VerticalSliceLow, VerticalSliceHi, VerticalSliceStep; RangeControl (multiple per Display) double RangeLow, RangeHi; ValueControl (multiple per Display) double Value; ProjectionControl (single per Display) double[] Matrix; /** The ShadowType hierarchy shadows the DataType hierarchy, within a DataDisplayLink.
*/ public abstract class ShadowType extends Object DataType Type; // DataType being shadowed DataDisplayLink Link; Display display; ShadowType Parent; int[] DisplayIndices; // count of occurences of DisplayRealType-s // set in ShadowRealType & ShadowRealTupleType // set in ShadowTupleType (!ShadowRealTupleType) to sum // for ShadowRealType & ShadowRealTupleType components double[] DefaultValues; // default values for DisplayIndices, from ConstantMap // or DisplayRealType.DefaultValue boolean isTerminal; // a single data object may transform into multiple // display objects, this flag marks the occurence // of a distinct display object int LevelOfDifficulty; // MultipleDisplayScalar is true if any DisplayRealType component is mapped // to multiple DisplayRealType-s, or if any DisplayRealTupleType component // and its Reference are both mapped boolean MultipleDisplayScalar; boolean isDirectRender; boolean isDirectManipulation; ShadowType sub-class hierarchy: ShadowRealType ShadowTextType ShadowTupleType ShadowRealTupleType ShadowSetType ShadowFunctionType /** Action is the superclass of objects that act on data.
*/ public abstract class Action extends Object implements Runnable Thread actionThread; Vector LinkVector; // vector of DataActionLink's public Action() public abstract void run() public void addData(Data data) public void deleteData(Data data) public DataActionLink findData(Data data) public abstract DataActionLink newLink(Data data) class DataActionLink extends Object Data data; Action action; long Tick; // value of data.getTick() last time action was applied to data DataActionLink(Data d, Action a) /** Display is the VisAD class for displays. It is runnable.
*/ public class Display extends Action Vector MapVector; Vector ConstantMapVector; Vector valueControls; Vector rangeControls; Vector contourControls; Vector colorControls; AnimationControl animationControl; FlowControl flowControl; FlowControl flow2Control; ProjectionControl projectionControl; public Display () public void addMap(ScalarMap map) public void clearMaps() public String toString() DisplayRealType system instances: XAxis, YAxis, ZAxis Latitude, Longitude, Radius List Red, Green, Blue Hue, Saturation, Value Cyan, Magenta, Yellow RGB, HSV, CMY // possibly replace with a component of a // 'variable' color coord sys? Alpha Animation SelectValue, SelectRange IsoContour FlowX, FlowY, FlowZ FlowX2, FlowY2, FlowZ2 Shape XAxisOffset, YAxisOffset, ZAxisOffset DisplayTupleType system instances: DisplaySpatialCartesianTuple, DisplaySpatialSphericalTuple DisplayRGBTuple, DisplayHSVCoordSys, DisplayCMYCoordSys DisplayFlowTuple, DisplayFlow2Tuple DisplaySpatialOffsetTuple class DataDisplayLink extends DataActionLink ShadowType shadow; RealTuple DefaultRGB; void setDefaultColor(double[] default_color) ------------------ Display procedure: ------------------ transform data according to ScalarMap's the ShadowType hierarchy is used for analyzing display transformations of data types transformed data have type: Fields: SelectorType, TemporalType -> Field: XYZ -> RGBA Field: XY -> ZRGBA Field: XZ -> YRGBA Field: YZ -> XRGBA Field: X -> YZRGBA Field: Y -> XZRGBA Field: Z -> XYRGBA Field: List -> XYZRGBA render transformed data under some data transformations, users may modify data by interacting with renderings of data display type transformation checks for implicit coordinate transforms mapping may be: RealType -> DisplayRealType RealTupleType -> DefaultCoordinateSystem.Reference -> DisplayRealType's for some DisplayRealType's, the further mapping applies: DisplayRealType -> DefaultCoordinateSystem.Reference note, CoordinateSystem-s in DisplayTupleType-s cannot be data-dependent