vodmlid 
feature type 
description 

vodml:model 
The transform model defines a set of operations which can be used to construct expressions mapping coordinates and other objects
defined in one coordinate space to a different coordinate space.
For many applications, this mapping should work in either direction. One option would be to define entirely separate mapping
sequences to describe these two transformations. However, this approach is bulky and requires more maintanence as any change
to one object would require equivalent changes be made to the other. Since many operations have a natural inverse, a safer,
more compact and flexible approach is to use a single object to describe both transformations. With this approach, a change
to the one transform automatically applies to both directions.
This model defines operations with sufficient information to define both forward and inverse transformations wherever possible.
For cases where a natural inverse cannot be defined, we provide a means of explicitly assigning separate operation specifications
for the forward and inverse directions.
In this model, we describe two flavors of operations:
* Arithmatic operations performing a particular action
* Workflow operations to build and link complex operations
 combine operations in parallel or series
 combine operations for explicit forward and inverse flow
 manage axis sets between steps

EulerAngle 
objectType 
Angular rotation about a particular axis of a 3dimensional cartesian coordinate space. 
EulerAngle.angle 
attribute 
Angle of rotation, in degrees. Angle sign follows the righthand rule, where positive values indicate clockwise rotation
(looking in +axis direction), negative values for counterclockwise.

EulerAngle.rotationAxis 
attribute 
Identifies the axis of rotation. MUST be 'x', 'y', or 'z'. 
EulerRotation 
objectType 
Defines a rotation operation in a 3dimensional cartesian coordinate space, defined as a series of rotations about the native
axes (x,y,z).

EulerRotation.eulerAngle 
composition 
Rotation angle about specified axis. 
InterpolationMethod 
enumeration 
Enumeration of interpolation methods to control the interpretation of data between known points in operations such as Lookup. 
InterpolationMethod.Linear 
literal 
Assume a linear progression between points. 
InterpolationMethod.Nearest 
literal 
Nearest neighbor is selected 
InterpolationMethod.None 
literal 
No interpolation method specified, interpretation between points is undefined. 
InterpolationMethod.Spline 
literal 
Perform a spline interpolation through the points. 2dimensional only. 
Lookup 
objectType 
Defines a lookup table operation. The Lookup is comprised of a series of value pairs (LookupEntry). All members of the series
MUST be of the same type.
Handling Enumerated data:
A common usage of a Lookup operation is to map image pixel index to an enumeration, such as a Polarization state. This can
be handled by two means:
1) Define a numeric equivalent for each enumeration literal, and use NumericEntry types. Casting to the corresponding literal
occurs outside of the operation.
2) Your local model can define a LookupEntry extension which maps the native value directly the target EnumerationLiteral.
The details of either approach for particular enumerations is considered outside the scope of this document.

Lookup.bounds_error 
attribute 
Flag to specify behaviour outside the lookup table data bounds. True indicates an error condition, False indicates that the
associated "fill" entry should be returned. If no "fill" entry is provided, the value should be extrapolated.

Lookup.entry 
composition 
Set of lookup table entries forming a discrete mapping from the native space to the target space. 
Lookup.interpolation 
attribute 
Specifies the form of interpolation, if any, prescribed to be performed. 
LookupEntry 
objectType 
This is an abstract head of lookup table entry objects. Each entry provides a discrete translation of a 'native' value to
the corresponding 'target' value.

LookupEntry.fill 
attribute 
When TRUE, the entry provides values to be used outside the Lookup table data domain. MUST only appear first or last in the
sequence. If missing, it is considered to be FALSE.

Matrix 
objectType 
An M x N matrix operation. Each cell of the matrix is provided by a MatrixElement object. Missing elements should be considered
to equal 0.

Matrix.M 
attribute 
Number of rows in the matrix. 
Matrix.N 
attribute 
Number of columns in the matrix. 
Matrix.element 
composition 
Collection of MatrixElements which define each cell of the matrix. The total number of elements MUST NOT exceed M*N, any
missing elements result in a cell with value=0.0.

MatrixElement 
objectType 
The value of cell m,n in an M x N matrix. 
MatrixElement.m 
attribute 
Matrix cell row number. 
MatrixElement.n 
attribute 
Matrix cell column number. 
MatrixElement.value 
attribute 
Matrix cell value. 
NumericEntry 
objectType 
A 1Dimensional discrete mapping of numeric values. 
NumericEntry.nativeValue 
attribute 
The native, or reference, value of the lookup entry. 
NumericEntry.targetValue 
attribute 
The target, or resulting, value of the lookup entry. 
NumericEntry2D 
objectType 
A 2Dimensional discrete mapping of numeric values. 
NumericEntry2D.nativeValue 
attribute 
The native, or reference, value of the lookup entry. 
NumericEntry2D.targetValue 
attribute 
The target, or resulting, value of the lookup entry. 
Permute 
objectType 
Permute the order and possibly number of dimensions between operations. This operation facilitates the workflow through the
operation sequence. It is comprised of an ordered axismap list defining the output axis sequence in terms of the source (input)
axes. It supports the reorder, duplication, and dropping of dimensions.
Reorder Example: We have a 3dimensional coordinate (x,y,z) and wish to perform a 2dimensional transform on the (x,z) plane.
Define a Permute operation to reorder the axes from (x,y,z) to (y,x,z) using an axismap list specifying the new axis order,
[2,1,3]. The results feed into the next step ( 1D + 2D operations ).
Duplicate Example: We have 2dimensional coordinate (x,y) feeding two Polynomial2D operations to form (x',y'). Define a Permute
operation with axismap list specifying sourceAxis set [1,2,1,2]. The result feeds into the next step ( Polynomial2D + Polynomial2D
operations).
Drop Example: We have a 5dimensional input feeding into a 3x3 Matrix operation. Define a Permute operation selecting the
relevant axis set [1,3,5], the remaining axes, [2,4], are dropped.
Add Example: We have a 2dimensional operation feeding into axes [1,3] of a 3dimensional operation. Define a Permute operation
with numSourceAxes=2; and sourceAxis set [1,0,2] where output axis 2 also specifies the fixed seed value.

Permute.axismap 
composition 
Ordered list defining the number and order of the resulting axis set. Each entry provides the source (input) dimension for
that output dimension.

Permute.numSourceAxes 
attribute 
The number of input axes. Used to verify dimensional coverage in forward and inverse directions. For example, numSourceAxes=4
with axismap=[1,3] indicates that axes [2,4] have been dropped.

PermuteAxis 
objectType 
Entry for the Permute operation, this object defines the mapping of input dimension to output dimension. The output dimension
is determined from its order in the axismap list.

PermuteAxis.seedValue 
attribute 
Value to assign for the new dimensional axis. 
PermuteAxis.sourceAxis 
attribute 
Source (input) dimension number, 1 based. 
PolyCoeff1D 
objectType 
A term of the polynomial expression. This object provides the coefficient (c) and power (p) of the term, forming the expression
c*X**p.

PolyCoeff1D.coeff 
attribute 
Multiplicitive coefficient of the term. 
PolyCoeff1D.power 
attribute 
The power to raise the value for this term. 
PolyCoeff2D 
objectType 
A term of the polynomial expression. This object provides the coefficient (c) and power (p) of the term, forming the expression
c*X**p[0]*Y**p[1].

PolyCoeff2D.coeff 
attribute 
Multiplicitive coefficient of the term. 
PolyCoeff2D.power 
attribute 
The power to raise the values for this term in each dimension. 
Polynomial 
objectType 
Abstract head of a family of Polynomial distortion operations. 
Polynomial.order 
attribute 
The order, or degree, of the polynomial expression. 
Polynomial1D 
objectType 
A 1Dimensional Polynomial transform represented by the expression: X' = SUM( Ci*X**i), i=0..order. Each term is provided
by a PolyCoeff1D object. Missing terms are considered to have a coefficient of 0.0.

Polynomial1D.term 
composition 
A term in the polynomial expression. 
Polynomial2D 
objectType 
A 2Dimensional Polynomial transform represented by the expression: X' = SUMi,j( Cij*X**i*Y**j), i+j<=order. Each term
is provided by a PolyCoeff2D object. Missing terms are considered to have a coefficient of 0.0.

Polynomial2D.term 
composition 
A term in the polynomial expression. 
Projection 
objectType 
Abstract head of World Coordinate System (WCS) projection operations. We do not attempt to define the operations here, but
instead, provide extensions which support the transforms described in the FITS WCS papers II and III.

Projection.param 
composition 
Set of 0 or more parameters providing supplemental metadata required to execute a particular projection algorithm. The number
and meaning of the parameters depends on the algorithm. They are typically in the from of keyword/value pairs, so we provide
a simple ProjectionParam element to accommodate these. The detailed content specification is left to the WCS paper.

ProjectionParam 
objectType 
Simple parameter specification for WCS Projections. The parameter is modeled as a simple name/value pair. The details of
expectations for the various projection algorithms is left to the WCS paper describing the algorithm.

ProjectionParam.name 
attribute 
The parameter name as described in the WCS papers for each operation type. 
ProjectionParam.value 
attribute 
The value for the parameter. 
Rotate2D 
objectType 
A 2Dimensional rotation operation. 
Rotate2D.angle 
attribute 
Rotation angle, in degrees, from the positive direction of axis 1 toward the positive direction of axis 2. 
Scale 
objectType 
A 1Dimensional operator for simple scaling. ( X' = factor*X ) 
Scale.factor 
attribute 
The scale factor. 
Shift 
objectType 
A 1Dimensional operation defining a simple offset. ( X' = X + offset ) 
Shift.offset 
attribute 
The amount of offset to apply. 
SkyProjRotate 
objectType 
This class extends SkyProjection to include the Spherical Rotation component of the FITS WCS paper II. This operation describes
the mapping between the "Native Spherical" and "Celestial" coordinate systems. The reference values are provided at the appropriate
attribute, while all other parameters (e.g. LONPOLE, LATPOLE) are to be provided through the ProjectionParam list according
to the descriptions given in the FITS WCS paper.

SkyProjRotate.referenceValue 
attribute 
The target reference values in each dimension. Equivalent to 'crval' in FITS WCS representations. 
SkyProjection 
objectType 
This class corresponds to the Spherical Projection component of the FITS WCS paper II. As in the paper, this operation describes
the mapping between the intermediate "Projection Plane" and the "Native Spherical" coordinate systems. This model supports
all defined projection types, where the appropriate code is specified in the algorithm attribute. All projection parameters
are to be provided through the ProjectionParam list according to the descriptions given in the FITS WCS paper.

SkyProjection.algorithm 
attribute 
The projection algorithm to apply. The value MUST be taken from the enumeration of standard sky projection algorithms. Extracted
from 'ctype' in the FITS WCS representations.

SkyProjectionType 
enumeration 
Enumeration of nonlinear celestial projection algorithm codes as listed in Table 13 of the FITS WCS paper II. 
SkyProjectionType.AIR 
literal 
Airy 
SkyProjectionType.AIT 
literal 
HammerAitoff 
SkyProjectionType.ARC 
literal 
Zenithal equidistant 
SkyProjectionType.AZP 
literal 
Zenithal perspective 
SkyProjectionType.BON 
literal 
Bonne equalarea 
SkyProjectionType.CAR 
literal 
Plate carree 
SkyProjectionType.CEA 
literal 
Cylindrical equalarea 
SkyProjectionType.COD 
literal 
Conic equidistant 
SkyProjectionType.COE 
literal 
Conic equalarea 
SkyProjectionType.COO 
literal 
Conic orthomorphic 
SkyProjectionType.COP 
literal 
Conic perspective 
SkyProjectionType.CSC 
literal 
COBE Quadrilateralized spherical cube 
SkyProjectionType.CYP 
literal 
Cylindrical perspective 
SkyProjectionType.MER 
literal 
Mercator 
SkyProjectionType.MOL 
literal 
Mollweide 
SkyProjectionType.PAR 
literal 
Parabolic 
SkyProjectionType.PCO 
literal 
Polyconic 
SkyProjectionType.QSC 
literal 
Quadrilateralized spherical cube 
SkyProjectionType.SFL 
literal 
SansonFlamsteed 
SkyProjectionType.SIN 
literal 
Slant orthographic (Sine projection) 
SkyProjectionType.STG 
literal 
Stereographic 
SkyProjectionType.SZP 
literal 
Slant zenithal perspective 
SkyProjectionType.TAN 
literal 
Gnomonic (Tangent plane projection) 
SkyProjectionType.TSC 
literal 
Tangential spherical cube 
SkyProjectionType.ZEA 
literal 
Zenithal equalarea 
SkyProjectionType.ZPN 
literal 
Zenithal polynomial 
SpectralCoordType 
enumeration 
Enumeration of spectral coordinate types as listed in Table 1 of the FITS WCS paper III. 
SpectralCoordType.AWAV 
literal 
Air wavelength 
SpectralCoordType.BETA 
literal 
Beta factor (v/c) 
SpectralCoordType.ENER 
literal 
Energy 
SpectralCoordType.FREQ 
literal 
Frequency 
SpectralCoordType.VELO 
literal 
Apparent radial velocity 
SpectralCoordType.VOPT 
literal 
Optical velocity 
SpectralCoordType.VRAD 
literal 
Radio velocity 
SpectralCoordType.WAVE 
literal 
Vacuum wavelength 
SpectralCoordType.WAVN 
literal 
Wavenumber 
SpectralCoordType.ZOPT 
literal 
Redshift 
SpectralProjection 
objectType 
This class represents a nonlinear onedimensional spectral transform as detailed in the FITS WCS paper III. 
SpectralProjection.algorithm 
attribute 
The projection algorithm to apply. The value MUST be taken from the enumeration of nonlinear spectral projection algorithms.
Extracted from 'ctype' in FITS WCS representations.

SpectralProjection.coordType 
attribute 
The resulting spectral coordinate type code. Values MUST be taken from the enumerated list of spectral coordinate types.
Extracted from 'ctype' in FITS WCS representations.

SpectralProjection.referenceValue 
attribute 
The target reference value for the axis. Equivalent to 'crval' in FITS WCS representations. 
SpectralProjectionType 
enumeration 
Enumeration of nonlinear spectral projection algorithm codes as listed in Table 2 of the FITS WCS paper III.
NOTE: We exclude the TAB code from this list, that type is handled by the Lookup operation in this model.

SpectralProjectionType.A2F 
literal 
Air wavelength  Frequency 
SpectralProjectionType.A2V 
literal 
Air wavelength  Apparent radial velocity 
SpectralProjectionType.A2W 
literal 
Air wavelength  Wavelength 
SpectralProjectionType.F2A 
literal 
Frequency  Air wavelength 
SpectralProjectionType.F2V 
literal 
Frequency  Apparent radial velocity 
SpectralProjectionType.F2W 
literal 
Frequency  Wavelength 
SpectralProjectionType.GRA 
literal 
Grism in air 
SpectralProjectionType.GRI 
literal 
Grism 
SpectralProjectionType.LOG 
literal 
Logarithm 
SpectralProjectionType.V2A 
literal 
Apparent radial velocity  Air wavelength 
SpectralProjectionType.V2F 
literal 
Apparent radial velocity  Frequency 
SpectralProjectionType.V2W 
literal 
Apparent radial velocity  Wavelength 
SpectralProjectionType.W2A 
literal 
Wavelength  Air wavelength 
SpectralProjectionType.W2F 
literal 
Wavelength  Frequency 
SpectralProjectionType.W2V 
literal 
Wavelength  Apparent radial velocity 
StringEntry 
objectType 
A 1Dimensional discrete mapping of an integer counter to a corresponding string form. Since the result is nonnumeric, a
Lookup operation with StringEntrys can only be used at the end of a Transform sequence.

StringEntry.nativeValue 
attribute 
The native, or reference, value of the lookup entry. 
StringEntry.targetValue 
attribute 
The target, or resulting, value of the lookup entry. 
TAtomic 
objectType 
Single stage bidirectional mapping. 
TAtomic.forward 
composition 
The forward transform operation specification. 
TAtomic.inverse 
composition 
The inverse transform operation specification. 
TCompose 
objectType 
A complex operation which executes the component maps in sequence.
This allows the building of multistage transforms such as a Matrix operation followed by a WCS Projection.

TCompound 
objectType 
Abstract class to facilitate the combination of Mappings in various ways.

TCompound.map 
composition 
Components of the complex operation. Depending on how the operations are combined, the interpretation of the components will
change.

TConcatenate 
objectType 
Combines operations in parallel. This class enables the building of an operation which covers the full dimension space of
the input. Axes are distributed to the component operations in order. For example, to perform a shift on a 2dimensional
coordinate (x,y), one would join two Shift operations giving the offset in x and y respectively. Since this class is an
operation itself, it can be used as a component in other complex operations.

TForward 
objectType 
Defines the forward transform operation of the mapping. 
TFunction 
objectType 
Transform Function (TFunction) defines a mathematical operation to be performed on its inputs.

TInverse 
objectType 
Defines the inverse transform operation of the mapping. 
TMapping 
objectType 
Bidirectional mapping, contains the forward and inverse transform operation specifications. Many operations, such as a shift,
rotation, and many matrix operations, have a natural inverse. For these cases, it is not necessary to define and propogate
both the forward and inverse operations since the inverse can be easily derived from the forward. In other cases, an explicit
inverse specification may be needed.
This class serves as the building block, from which arbitrarily complex operations can be built.

TMapping.invert 
attribute 
Boolean flag indicating that the inverse operation should be applied. If missing, it is assumed to be "False".
For many operations, the inverse transformation can be directly derived from the forward transform. For instance, the inverse
of a transform that simply adds a constant to each input is a transform of the same type, with a negated constant. However,
there are potentially operations for which this cannot be done. For instance, a transform that maps 3D Cartesian coodinates
to spherical coordinates cannot be rewritten to represent its inverse. This flag indicates that it should be used in its
inverse sense.
In addition, the invert flag allows a complex compound transformation to be be inverted simply by toggling its invert flag.
Without such a flag each component would need to be rewritten to represent its inverse (if possible), and the order of serial
transformations would need to be reversed  a much more complex and error prone process.

TOperation 
objectType 
Unidirectional transform operation, executes the contained function. 
TOperation.operation 
composition 
Transform operation specification. 
Unit 
objectType 
A 1Dimensional operation which makes no change to the inputs. ( X' = X ) 