vodmlid 
feature type 
description 

vodml:model 
The transform model defines objects which can be used to construct expressions representing the relation between two coordinate
systems. These may be used to transform coordinates and other objects defined in one coordinate system into corresponding
objects in another coordinate system. There are two primary components to the model, the "Mapping", and the "TransformSet".
The "Mapping" object defines how to transform a set of "input" scalar values into a corresponding set of "output" scalar values.
The Mapping supports transforms in either direction via "operations" which we refer to as the forward and inverse operations.
The forward operation transforms the mapping inputs into mapping outputs. The inverse operation transforms the mapping outputs
into mapping inputs.
The "TransformSet" object gives physical context to the "Mapping" by relating a parent coordinate system to a target coordinate
system via a Mapping. The TransformSet model structure allows for the association of groups of interrelated coordinate systems.
Since a mapping expression can involve multiple steps between end points, we separate these features, such that the Mapping
provides the path, and the TransformSet associates a Mapping with its source and target coordinate systems.

BiDirectionalMap 
objectType 
The BiDirectionalMap supports cases where one wants to explicitely define independent transforms for the forward and inverse
operations. This may be because a mapping does not have a natural inverse, or dictated by the requirements of the application.
The associated mappings do not have to be of the same type. The forward operation of the BiDirectionalMap is supported by
the forward operation of the forwardMap, and the inverse operation of the BiDirectionalMap by the inverse operation of the
inverseMap. If the 'invert' flag is True, this is reversed so that the forward operation of the BiDirectionalMap is supported
by the inverse operation of the inverseMap, and the inverse operation of the BiDirectionalMap by the forward operation of
the forwardMap.

BiDirectionalMap.forwardMap 
reference 
The Mapping that defines the foward operation of the BiDirectionalMap. The forward operation of the target Mapping is used
as the foward operation of the BiDirectionalMap. If the forward operation of the target Mapping is undefined, then the forward
operation of the BiDirectionalMap is also undefined. The inverse operation of the target Mapping is never used and need not
be defined.

BiDirectionalMap.inverseMap 
reference 
The Mapping that defines the inverse operation of the BiDirectionalMap. The inverse operation of the target Mapping is used
as the inverse operation of the BiDirectionalMap. If the inverse operation of the target Mapping is undefined, then the inverse
operation of the BiDirectionalMap is also undefined. The forward operation of the target Mapping is never used and may be
undefined.

ComposeMap 
objectType 
Combines the component mappings in series. This allows the building of multistage transforms such as a Matrix operation followed
by a WCS Projection. When the invert flag is 'True', the forward operation of the ComposeMap is defined by the inverse of
the content, iterating the component list in reverse order, executing the inverse operation of each component.

CompoundMap 
objectType 
Abstract class to facilitate the combination of Mappings in various ways. Since they are themselves mappings, they can be
used as a components in other compound mappings to create arbitrarily complex transform expressions.

CompoundMap.cptMap 
composition 
List of component mappings. Joins multiple mappings together to form a single unit. The interpretation of the list set depends
on the particular subclass of CompoundMap.

ConcatenateMap 
objectType 
Combines the component mappings in parallel. This enables the building of a mapping which covers the full dimension space
of the input. Axes are distributed to the component mappings in order. For example, to perform a shift on a 2dimensional
coordinate (x,y), one would join two Shift maps giving the offset in x and y respectively.
When the 'invert' flag is True, the forward operation of the ConcatenateMap is defined by applying the inverse operations
of the component mappings.

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 a 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.

MapRef 
objectType 
An entry in the CompountMap component mapping list. Holds a reference to the component mapping. 
MapRef.ref 
reference 
Reference to the component Mapping. 
Mapping 
objectType 
The "Mapping" object defines how to transform a set of "input" scalar values into a corresponding set of "output" scalar values.
The Mapping supports transforms in either direction via "operations" which we refer to here as the forward and inverse operations.
The forward operation transforms the mapping inputs into mapping outputs. The inverse operation transforms the mapping outputs
into mapping inputs.
There is possibility here for confusion regarding the meaning of the words "input" and "output". A clear distinction should
be drawn between the inputs and outputs of a mapping and those of an operation. The inputs and outputs of a mapping are the
same as the inputs and outputs of the mapping's forward operation, but are the reverse of the inputs and outputs of the mapping's
inverse operation. Thus, the inputs of the inverse operation are the outputs of the mapping, etc.
Note, a mapping may in principle be inverted, but an operation cannot be inverted. Inverting a mapping means reversing the
roles performed by its two operation  the original inverse operation is used as the new forward operation, and viceversa.
We could support both forward and inverse operations by defining entirely separate expressions to describe the two transformations.
However, that 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 leverages this compact approach, defining mappings with sufficient information to support both forward and inverse
operations. Many mappings, such as shift, and rotation, have a natural inverse, and both operations can be supported by
a single set of parameters. Others, like polynomial, do not have a natural inverse, so one of the two operations may be undefined.
The BiDirectionalMap may be used to explicitely assign a different mapping for each direction.
In this model, we describe three flavors of mappings which allow specifications from very simple relations to arbitrarily
complex relations built from a set of component mappings:
* Atomic Mappings which perform a single arithmatic operation
* BiDirectional Mapping with explicit specification of the mapping in the forward and inverse direction
* Compound Mappings which are used to control the workflow and build arbitrarily complex operations

Mapping.invert 
attribute 
Boolean flag indicates that the Mapping content defines its inverse operation rather than its forward operation and so the
Mapping should be inverted before being used. In other words, the forward operation of the Mapping should be implemented using
the inverse operation implied by the Mapping's contents, and vice versa.
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.

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 description 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 from the "Native Spherical" coordinate system to the "Celestial" coordinate system. 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 from the intermediate "Projection Plane" to the "Native Spherical" coordinate system. 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. 
TransNode 
objectType 
TransNode is a container object relating a parent coordinate system and a target coordinate system (that of the node) with
the mapping relation between them. The associated Mapping MUST be constructed such that the mapping inputs correspond to
the parent coordinate system and the mapping outputs to the target coordinate system.
If either the parent node or mapping is NULL, the other MUST also be NULL. This forms a 'root' node, containing only the
target coordinate system, and serves as an origination node in the TransformSet.
If the target is NULL, the parent and mapping MUST NOT be NULL, additionally such a node MUST NOT be the end point of a node
sequence (ie: must be the 'parent' of another node). This type of node can be useful for cases where the mapping defines
the transform to an unspecified intermediate coordinate system, and enables a more efficient and compact structure for the
TransformSet by forming a node at this intermediate coordinate system which can serve as the parent for multiple subsequent
nodes.

TransNode.mapping 
reference 
This is a reference to the mapping relating the parent coordinate system to the target system. Will be NULL for 'root' nodes. 
TransNode.parent 
reference 
This identifies the source coordinate system node. The associated mapping describes the transformation from this parent system
to the target system of this node. Will be NULL for 'root' nodes.

TransNode.target 
reference 
This identifies the target coordinate system node. It is the represenitive coordinate system for this node. The associated
mapping describes the transformation from the parent system of this node to this target system. The coordinate systems themselves
are described in the IVOA "Astronomical Coordinates and Coordinate Systems" model.

TransformSet 
objectType 
TransformSet supports the relation of coordinate systems via Mappings. The design is such that it supports the relation of
collections of related coordinates systems by the various mappings between them.
A single TransformSet can relate a tree of spatial coordinate systems, individual TransNodes can be used as the parent for
multiple branches. For example:
* pixel  chip  tiled detector  detector  tangent plane
* chip  chip physical
* detector  mirror spherical
* tangent plane  celestial
Each transition is encapsulated by a TransNode instance linking the parent coordinate system to the target coordinate system
(that of the TransNode) with a Mapping (from the parent to target systems).
A simple transform from system A to system B requires two TransNodes, one describing system A (with no Mapping), and another
describing system B with the Mapping from A to B.

TransformSet.node 
composition 
A node in the transform set, relating a parent and target coordinate system with the corresponding mapping specification. 
Unit 
objectType 
A 1Dimensional operation which makes no change to the inputs. ( X' = X )
