Uses of Class
visad.CoordinateSystem

Packages that use CoordinateSystem

visad	The core VisAD package, providing support for VisAD's Data & MathType hierarchy, as well as for VisAD Displays and remote collaboration.
visad.bom
visad.cluster
visad.data	Provides for importing data to and exporting data from VisAD.
visad.data.hdfeos	Provides for importing an HDF-EOS dataset into VisAD.
visad.data.hrit
visad.data.mcidas	Provides for importing McIDAS AREA files and McIDAS base map (OUTL) files into VisAD.
visad.data.vis5d	Provides for importing a Vis5D dataset into VisAD.
visad.data.visad	Provides for importing and exporting serialized Java object files into and out of VisAD.
visad.data.visad.object
visad.georef	Provides classes for geo-referencing.
visad.java2d	Provides support for two-dimensional VisAD Displays using Java2D.
visad.java3d	Provides support for two- and three-dimensional VisAD Displays using Java3D.
visad.jmet
visad.math
visad.matrix
visad.python

Uses of CoordinateSystem in visad

Subclasses of CoordinateSystem in visad

class	CachingCoordinateSystem A wrapper class for CoordinateSystems that will cache the last values input and output values of the toReference and fromReference methods.
class	CartesianProductCoordinateSystem A class for creating a new CoordinateSystem that is the product of two or more CoordinateSystems.
class	CMYCoordinateSystem CMYCoordinateSystem is the VisAD CoordinateSystem class for (Cyan, Magenta, Yellow) with Reference (Red, Green, Blue).
class	CylindricalCoordinateSystem CylindricalCoordinateSystem is the VisAD CoordinateSystem class for (CylRadius, CylAzimuth, CylZAxis) with a Cartesian Reference, (XAxis, YAxis, ZAxis) and with CylAzimuth in degrees.
class	EmpiricalCoordinateSystem Provides support for empirically-defined CoordinateSystem-s.
class	FlowSphericalCoordinateSystem FlowSphericalCoordinateSystem is the VisAD CoordinateSystem class for (Elevation, Azimuth, Radial) with a Cartesian Reference, with Elevation and Azimuth in degrees and Radial in meters per second.
class	GridCoordinateSystem GridCoordinateSystem is the VisAD CoordinateSystem class for grids defined by GriddedSets.
class	HSVCoordinateSystem HSVCoordinateSystem is the VisAD CoordinateSystem class for (Hue, Saturation, Value) with Reference (Red, Green, Blue).
class	IdentityCoordinateSystem A CoordinateSystem that will return the input values when toReference() and fromReference() are called.
class	InverseCoordinateSystem InverseCoordinateSystem is the VisAD CoordinateSystem class for inverting other CoordinateSystems.
class	LogCoordinateSystem A CoordinateSystem to transform between values and their logarithms.
class	PolarCoordinateSystem PolarCoordinateSystem is the VisAD CoordinateSystem class for (Longitude, Radius) with a Cartesian Reference, and with Longitude in degrees.
class	SphericalCoordinateSystem SphericalCoordinateSystem is the VisAD CoordinateSystem class for (Latitude, Longitude, Radius) with a Cartesian Reference, and with Latitude and Longitude in degrees.

Fields in visad declared as CoordinateSystem

static CoordinateSystem	Display.DisplayCMYCoordSys CoordinateSystem for DisplayCMYTuple, with reference DisplayRGBTuple
static CoordinateSystem	Display.DisplayCylindricalCoordSys CoordinateSystem for DisplaySpatialCylindricalTuple, with reference DisplaySpatialCartesianTuple
static CoordinateSystem	Display.DisplayFlow1SphericalCoordSys CoordinateSystem for DisplayFlow1SphericalTuple, with reference DisplayFlow1Tuple
static CoordinateSystem	Display.DisplayFlow2SphericalCoordSys CoordinateSystem for DisplayFlow2SphericalTuple, with reference DisplayFlow2Tuple
static CoordinateSystem	Display.DisplayHSVCoordSys CoordinateSystem for DisplayHSVTuple, with reference DisplayRGBTuple
static CoordinateSystem	Display.DisplaySphericalCoordSys CoordinateSystem for DisplaySpatialSphericalTuple, with reference DisplaySpatialCartesianTuple
protected CoordinateSystem	FlatField.RangeCoordinateSystem
protected CoordinateSystem[]	FlatField.RangeCoordinateSystems

Methods in visad that return CoordinateSystem

CoordinateSystem	CachingCoordinateSystem.getCachedCoordinateSystem() Access to the "cached" CS
CoordinateSystem	SetIface.getCoordinateSystem() Returns the coordinate system transformation of the set.
CoordinateSystem	Set.getCoordinateSystem() Gets the coordinate system of this domain set (DomainCoordinateSystem).
CoordinateSystem	RealTupleType.getCoordinateSystem() get default CoordinateSystem
CoordinateSystem	RealTupleIface.getCoordinateSystem() Returns the coordinate system transformation.
CoordinateSystem	RealTuple.getCoordinateSystem() get CoordinateSystem
CoordinateSystem	CartesianProductCoordinateSystem.getCoordinateSystem(int index) Get a particular CoordinateSystem
CoordinateSystem[]	CartesianProductCoordinateSystem.getCoordinateSystems() Get the arrays of CoordinateSystems being used in this product
CoordinateSystem	DataRenderer.getDisplayCoordinateSystem()
CoordinateSystem	RemoteFunctionImpl.getDomainCoordinateSystem()
CoordinateSystem	RemoteFieldImpl.getDomainCoordinateSystem()
CoordinateSystem	FunctionImpl.getDomainCoordinateSystem() Get the CoordinateSystem associated with the domain RealTuple
CoordinateSystem	Function.getDomainCoordinateSystem() Get the CoordinateSystem associated with the domain RealTuple
CoordinateSystem	FieldImpl.getDomainCoordinateSystem()
CoordinateSystem	InverseLinearScaledCS.getInvertedCoordinateSystem() The CoordinateSystem being inverted
CoordinateSystem[]	RemoteFieldImpl.getRangeCoordinateSystem()
CoordinateSystem[]	FlatField.getRangeCoordinateSystem() Returns the range CoordinateSystem assuming that the range type is a RealTupleType (and throws a TypeException if its not).
CoordinateSystem[]	FieldImpl.getRangeCoordinateSystem() Get range CoordinateSystem for 'RealTuple' range; second index enumerates samples.
CoordinateSystem[]	Field.getRangeCoordinateSystem() get range CoordinateSystem for 'RealTuple' range; index may enumerate samples, if they differ
CoordinateSystem[]	RemoteFieldImpl.getRangeCoordinateSystem(int i)
CoordinateSystem[]	FlatField.getRangeCoordinateSystem(int i) Returns the CoordinateSystem of a component of the range.
CoordinateSystem[]	FieldImpl.getRangeCoordinateSystem(int component) get range CoordinateSystem for 'RealTuple' components; second index enumerates samples
CoordinateSystem[]	Field.getRangeCoordinateSystem(int component) get range CoordinateSystem for 'RealTuple' components; index may enumerate samples, if they differ

Methods in visad with parameters of type CoordinateSystem

static boolean	CoordinateSystem.canConvert(RealTupleType out, CoordinateSystem coord_out, RealTupleType in, CoordinateSystem coord_in) Check to see if a conversion can be done between values of one RealTupleType and another given the CoordinateSystems supplied.
static Gridded1DDoubleSet	Gridded1DDoubleSet.create(MathType type, double[] samples, CoordinateSystem coordSys, Unit unit, ErrorEstimate error) Returns an instance of this class.
static LinearSet	LinearNDSet.create(MathType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
static GriddedSet	GriddedSet.create(MathType type, float[][] samples, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors) General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.).
static GriddedSet	GriddedSet.create(MathType type, float[][] samples, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy) General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.).
static GriddedSet	GriddedSet.create(MathType type, float[][] samples, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test) General Factory method for creating the proper gridded set (Gridded1DSet, Gridded2DSet, etc.).
static Gridded1DSet	Gridded1DSet.create(MathType type, float[] samples, CoordinateSystem coordSys, Unit unit, ErrorEstimate error) Returns an instance of this class.
static GriddedSet	IntegerNDSet.create(MathType type, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors) General factory method for creating the proper integer set (Integer1DSet, Integer2DSet, etc.).
Field	FieldImpl.domainMultiply(CoordinateSystem resultCS) Combine domains of two outermost nested Fields into a single domain and Field.
Field	FieldImpl.domainMultiply(int collapse_depth, CoordinateSystem resultCS) Combine domains of collapse_depth if possible.
boolean	ShadowType.makeContour(int valueArrayLength, int[] valueToScalar, float[][] display_values, int[] inherited_values, Vector MapVector, int[] valueToMap, int domain_length, boolean[][] range_select, int spatialManifoldDimension, Set spatial_set, byte[][] color_values, boolean indexed, Object group, GraphicsModeControl mode, boolean[] swap, float constant_alpha, float[] constant_color, ShadowType shadow_api, ShadowRealTupleType Domain, ShadowRealType[] DomainReferenceComponents, Set domain_set, Unit[] domain_units, CoordinateSystem dataCoordinateSystem)
VisADGeometryArray	Gridded3DSet.makeIsoSurfaceMissingSpatial(float isolevel, float[] fieldValues, byte[][] color_values, boolean indexed, ShadowRealTupleType Domain, ShadowRealTupleType domain_reference, Unit[] domain_units, CoordinateSystem dataCoordinateSystem, CoordinateSystem coord_sys, ShadowRealType[] DomainReferenceComponents, DisplayTupleType spatial_tuple, float[][] spatial_offset_values)
void	DataRenderer.setEarthSpatialData(ShadowRealTupleType s_d_i, ShadowRealTupleType s_d_o, RealTupleType d_o, Unit[] d_u_o, RealTupleType d_i, CoordinateSystem[] d_c_i, Unit[] d_u_i) save information about relation between earth and display spatial coordinates, IF the arguments do define the relation
void	DataRenderer.setEarthSpatialDisplay(CoordinateSystem coord, DisplayTupleType t, DisplayImpl display, int[] indices, float[] default_values, double[] r) save information from ShadowType.assembleSpatial() about relation between earth and display spatial coordinates
static double[][]	CoordinateSystem.transformCoordinates(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, double[][] value) Transforms double-valued coordinates between two RealTupleTypes.
static double[][]	CoordinateSystem.transformCoordinates(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, double[][] value, boolean copy) Transforms double-valued coordinates between two RealTupleTypes.
static float[][]	CoordinateSystem.transformCoordinates(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, float[][] value) Transforms float-valued coordinates between two RealTupleTypes.
static float[][]	CoordinateSystem.transformCoordinates(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, float[][] value, boolean copy) Transforms float-valued coordinates between two RealTupleTypes.
static double[][]	CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, double[][] value) Transforms double-valued coordinates between two RealTupleTypes.
static float[][]	CoordinateSystem.transformCoordinatesFreeUnits(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, ErrorEstimate[] errors_in, float[][] value) Transforms float-valued coordinates between two RealTupleTypes.
RealTuple	RealVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, double[][] inloc, double[][] outloc, RealTuple tuple) transform a single vector in a RealTuple, based on a coordinate transform of the field domain.
abstract double[][]	RealVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, double[][] inloc, double[][] outloc, double[][] value) transform an array of vector values from a field, based on a coordinate transform of the field domain.
double[][]	GridVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, double[][] inloc, double[][] outloc, double[][] value) transform an array of vector values from a field, based on a coordinate transform of the field domain.
double[][]	EarthVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, double[][] inloc, double[][] outloc, double[][] value) transform an array of vector values from a field, based on a coordinate transform of the field domain.
float[][]	RealVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, float[][] inloc, float[][] outloc, float[][] value)
float[][]	GridVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, float[][] inloc, float[][] outloc, float[][] value) transform an array of vector values from a field, based on a coordinate transform of the field domain.
float[][]	EarthVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, ErrorEstimate[] errors_in, ErrorEstimate[] errors_out, float[][] inloc, float[][] outloc, float[][] value) transform an array of vector values from a field, based on a coordinate transform of the field domain.
RealTuple	RealVectorType.transformVectors(RealTupleType out, CoordinateSystem coord_out, Unit[] units_out, ErrorEstimate[] loc_errors_out, RealTupleType in, CoordinateSystem coord_in, Unit[] units_in, CoordinateSystem coord_vector, float[][] inloc, float[][] outloc, RealTuple tuple)

Constructors in visad with parameters of type CoordinateSystem

CachingCoordinateSystem(CoordinateSystem cs)
Construct a new CachingCoordinateSystem that wraps around the input.

CartesianProductCoordinateSystem(CoordinateSystem[] csArray)
Construct a CartesianProductCoordinateSystem from an array of CoordinateSystems.

CartesianProductCoordinateSystem(CoordinateSystem a, CoordinateSystem b)
Construct a CartesianProductCoordinateSystem from two other CoordinateSystems.

CoordinateSystemException(CoordinateSystem cs1, CoordinateSystem cs2)
construct a CoordinateSystemException for unequal CoordinateSystems

DisplayTupleType(DisplayRealType[] types, CoordinateSystem coord_sys)
construct a DisplayTupleType

DoubleSet(MathType type, CoordinateSystem coord_sys, Unit[] units)
construct a DoubleSet with null CoordinateSystem and Units

EarthVectorType(RealType[] types, CoordinateSystem coord_sys)

FlatField(FunctionType type, Set domain_set, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Constructs a FlatField from a function type, a sampling set of the domain, coordinate systems for the range components, sampling sets for the range components, and units for the range components.

FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components.

FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, coordinate systems for the range components, sampling sets for the range components, and units for the range components.

FlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, Set[] range_sets, Unit[] units)
Constructs a FlatField from a function type, a sampling set of the domain, a coordinate system for the range, sampling sets for the range components, and units for the range components.

FloatSet(MathType type, CoordinateSystem coord_sys, Unit[] units)
the set of values representable by N floats; type must be a RealType, a RealTupleType or a SetType; coordinate_system and units must be compatible with defaults for type, or may be null; a FloatSet may not be used as a Field domain

Gridded1DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

Gridded1DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized double[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null

Gridded1DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

Gridded1DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)
a 1-D sorted sequence with no regular interval. samples array is organized float[1][number_of_samples] where lengthX = number_of_samples. samples must be sorted (either increasing or decreasing). coordinate_system and units must be compatible with defaults for type, or may be null. errors may be null

Gridded1DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Constructs a 1-D sorted sequence with no regular interval.

Gridded1DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)
Constructs a 1-D sorted sequence with no regular interval.

Gridded2DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized double[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded2DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized double[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded2DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test)

Gridded2DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded2DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set with manifold dimension = 1; samples array is organized float[2][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded2DSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 2-D set whose topology is a lengthX x lengthY grid; samples array is organized float[2][number_of_samples] where lengthX * lengthY = number_of_samples; samples must form a non-degenerate 2-D grid (no bow-tie-shaped grid boxes); the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded2DSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded2DSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test)

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized double[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized double[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized double[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DDoubleSet(MathType type, double[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test)

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DDoubleSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 1; samples array is organized float[3][number_of_samples] where lengthX = number_of_samples; no geometric constraint on samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DSet(MathType type, float[][] samples, int lengthX, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set with manifold dimension = 2; samples array is organized float[3][number_of_samples] where lengthX * lengthY = number_of_samples; no geometric constraint on samples; the X component increases fastest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DSet(MathType type, float[][] samples, int lengthX, int lengthY, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 3-D set whose topology is a lengthX x lengthY x lengthZ grid; samples array is organized float[3][number_of_samples] where lengthX * lengthY * lengthZ = number_of_samples; samples must form a non-degenerate 3-D grid (no bow-tie-shaped grid cubes); the X component increases fastest and the Z component slowest in the second index of samples; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Gridded3DSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Gridded3DSet(MathType type, float[][] samples, int lengthX, int lengthY, int lengthZ, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy, boolean test)

GriddedSet(MathType type, float[][] samples, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct a GriddedSet with samples and non-default CoordinateSystem

GriddedSet(MathType type, float[][] samples, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

GridVectorType(RealType[] types, CoordinateSystem coord_sys)

ImageFlatField(FunctionType type, Set domain_set, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)

ImageFlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)

ImageFlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)

ImageFlatField(FunctionType type, Set domain_set, CoordinateSystem range_coord_sys, Set[] range_sets, Unit[] units)

Integer1DSet(MathType type, int length, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct a 1-dimensional set with values {0, 1, ..., length-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Integer2DSet(MathType type, Integer1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

Integer2DSet(MathType type, int length1, int length2, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct a 2-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Integer3DSet(MathType type, Integer1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

Integer3DSet(MathType type, int length1, int length2, int length3, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct a 3-dimensional set with values {0, 1, ..., length1-1} x {0, 1, ..., length2-1} x {0, 1, ..., length3-1}; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

IntegerNDSet(MathType type, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

IntegerNDSet(MathType type, Integer1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct an N-dimensional set with values in the cross product of {0, 1, ..., lengths[i]-1} for i=0, ..., lengths[lengths.length-1]; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

InverseCoordinateSystem(RealTupleType reference, CoordinateSystem inv)
construct a CoordinateSystem that whose transforms invert the transforms of inverse (i.e., toReference and fromReference are switched); for example, this could be used to define Cartesian coordinates releative to a refernce in spherical coordinates

Irregular1DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
a 1-D irregular set; samples array is organized float[1][number_of_samples]; samples need not be sorted - the constructor sorts samples to define a 1-D "triangulation"; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Irregular1DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Irregular2DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan)
a 2-D irregular set; samples array is organized float[2][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which must have manifold dimension 2), else the constructor computes a topology with manifold dimension 2; note that Gridded2DSet can be used for an irregular set with domain dimension 2 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Irregular2DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan, boolean copy)

Irregular2DSet(MathType type, float[][] samples, int[] new2old, int[] old2new, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
complete constructor for constructing Irregular2DSet using sort from existing Irregular1DSet

Irregular2DSet(MathType type, float[][] samples, int[] new2old, int[] old2new, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Irregular3DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan)
a 3-D irregular set; samples array is organized float[3][number_of_samples]; no geometric constraint on samples; if delan is non-null it defines the topology of samples (which may have manifold dimension 2 or 3), else the constructor computes a topology with manifold dimension 3; note that Gridded3DSet can be used for an irregular set with domain dimension 3 and manifold dimension 1; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

Irregular3DSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan, boolean copy)

Irregular3DSet(MathType type, float[][] samples, int[] new2old, int[] old2new, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct Irregular3DSet using sort from existing Irregular1DSet

Irregular3DSet(MathType type, float[][] samples, int[] new2old, int[] old2new, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

IrregularSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
construct an IrregularSet with non-default CoordinateSystem

IrregularSet(MathType type, float[][] samples, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan)
construct an IrregularSet with non-default CoordinateSystem and non-default Delaunay

IrregularSet(MathType type, float[][] samples, int manifold_dimension, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan)
construct an IrregularSet with ManifoldDimension !

IrregularSet(MathType type, float[][] samples, int manifold_dimension, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, Delaunay delan, boolean copy)

Linear1DSet(MathType type, double first, double last, int length, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 1-D arithmetic progression with the specified type, coord_sys, units and errors.

Linear1DSet(MathType type, double first, double last, int length, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 1-D arithmetic progression with the specified type, coord_sys, units and errors.

Linear2DSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys, units and errors.

Linear2DSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 2-D cross product of arithmetic progressions with the specified type, coord_sys, units and errors.

Linear2DSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 2-D cross product of sets, with the specified type, coord_sys, units and errors.

Linear2DSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 2-D cross product of sets, with the specified type, coord_sys, units and errors.

Linear3DSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, double first3, double last3, int length3, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys, units and errors.

Linear3DSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, double first3, double last3, int length3, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 3-D cross product of arithmetic progressions with the specified type, coord_sys, units and errors.

Linear3DSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 3-D cross product of sets, with the specified type, coord_sys, units and errors.

Linear3DSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 3-D cross product of sets, with the specified type, coord_sys, units and errors.

LinearLatLonSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and units.

LinearLatLonSet(MathType type, double first1, double last1, int length1, double first2, double last2, int length2, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and units.

LinearLatLonSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and units.

LinearLatLonSet(MathType type, Linear1DSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct a 2-D cross product of arithmetic progressions whose east and west edges may be joined (for interpolation purposes), with specified errors, coord_sys and units.

LinearNDSet(MathType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null.

LinearNDSet(MathType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct an N-dimensional set as the product of N arithmetic progressions (lengths[i] samples between firsts[i] and lasts[i]), coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null.

LinearNDSet(MathType type, Linear1DSet[] l, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

LinearNDSet(MathType type, Linear1DSet[] l, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean cache)
Construct an N-dimensional set as the product of N Linear1DSets; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

List1DDoubleSet(double[] d, MathType type, CoordinateSystem coord_sys, Unit[] units)
Constructs with a non-default CoordinateSystem.

List1DSet(float[] d, MathType type, CoordinateSystem coord_sys, Unit[] units)
Constructs with a non-default CoordinateSystem.

ProductSet(MathType type, SampledSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
create the product of the sets array; coordinate_system and units must be compatible with defaults for type, or may be null; errors may be null

RealTuple(RealTupleType type, Real[] reals, CoordinateSystem coord_sys)
construct a RealTuple according to an array of Real objects; coordinate_system may be null; otherwise coordinate_system.getReference() must equal type.getCoordinateSystem.getReference()

RealTuple(RealTupleType type, Real[] reals, CoordinateSystem coord_sys, Unit[] units, boolean checkUnits)
Construct a RealTuple according to an array of Real objects; coordinate_system may be null; otherwise coordinate_system.getReference() must equal type.getCoordinateSystem.getReference()

RealTupleType(RealType[] types, CoordinateSystem coord_sys, Set set)
array of component types; default CoordinateSystem for values of this type (including Function domains) and may be null; default Set used when this type is a FunctionType domain and may be null

RealTupleType(RealType a, CoordinateSystem coord_sys, Set set)
construct a RealTupleType with one component

RealTupleType(RealType a, RealType b, CoordinateSystem coord_sys, Set set)
construct a RealTupleType with two components

RealTupleType(RealType a, RealType b, RealType c, CoordinateSystem coord_sys, Set set)
construct a RealTupleType with three components

RealTupleType(RealType a, RealType b, RealType c, RealType d, CoordinateSystem coord_sys, Set set)
construct a RealTupleType with four components

RealVectorType(RealType[] types, CoordinateSystem coord_sys)

SampledSet(MathType type, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

SampledSet(MathType type, int manifold_dimension, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

Set(MathType type, CoordinateSystem coord_sys)
Constructs a Set object with a non-default CoordinateSystem.

Set(MathType type, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Constructs a Set object with a non-default CoordinateSystem, non-default Unit-s, and non-default errors.

SimpleSet(MathType type, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

SimpleSet(MathType type, int manifold_dimension, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)

SingletonSet(RealTuple d, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors)
Construct a SingletonSet with the single sample given by a RealTuple, and a non-default CoordinateSystem, Units and ErrorEstimates.

SingletonSet(RealTupleType type, double[] values, CoordinateSystem coordSys, Unit[] units, ErrorEstimate[] errors)
Constructs from a type, numeric values, units, coordinate system, and error estimates.

UnionSet(MathType type, SampledSet[] sets, CoordinateSystem coord_sys, Unit[] units, ErrorEstimate[] errors, boolean copy)

Uses of CoordinateSystem in visad.bom

Subclasses of CoordinateSystem in visad.bom

class	Radar2DCoordinateSystem Radar2DCoordinateSystem is the VisAD CoordinateSystem class for radar (range, azimuth) with an Earth (Latitude, Longitude) Reference, and with azimuth in degrees and range in meters.
class	Radar3DCoordinateSystem Radar3DCoordinateSystem is the VisAD CoordinateSystem class for radar (range, azimuth, elevation_angle) with an Earth (Latitude, Longitude, Altitude) Reference, and with azimuth and elevation angle in degrees, and range in meters.
class	WindPolarCoordinateSystem WindPolarCoordinateSystem is the VisAD CoordinateSystem class for (Longitude, Radius) with a Cartesian Reference, and with Longitude in degrees.

Methods in visad.bom that return CoordinateSystem

CoordinateSystem	RubberBandLineRendererJ3D.getDisplayCoordinateSystem()
CoordinateSystem	RubberBandBoxRendererJ3D.getDisplayCoordinateSystem()
CoordinateSystem	PointManipulationRendererJ3D.getDisplayCoordinateSystem()
CoordinateSystem	PickManipulationRendererJ3D.getDisplayCoordinateSystem() Get the CoordinateSystem for the display side.
CoordinateSystem	PickManipulationRendererJ2D.getDisplayCoordinateSystem() Get the CoordinateSystem for the display side.

Methods in visad.bom with parameters of type CoordinateSystem

void	ShadowImageFunctionTypeJ3D.buildCurvedTexture(Object group, Set domain_set, Unit[] dataUnits, Unit[] domain_units, float[] default_values, ShadowRealType[] DomainComponents, int valueArrayLength, int[] inherited_values, int[] valueToScalar, GraphicsModeControl mode, float constant_alpha, float[] value_array, float[] constant_color, byte[][] color_bytes, DisplayImpl display, int curved_size, ShadowRealTupleType Domain, CoordinateSystem dataCoordinateSystem, DataRenderer renderer, ShadowFunctionOrSetType adaptedShadowType, int[] start, int lenX, int lenY, float[][] samples, int bigX, int bigY)
void	ShadowImageByRefFunctionTypeJ3D.buildCurvedTexture(Object group, Set domain_set, Unit[] dataUnits, Unit[] domain_units, float[] default_values, ShadowRealType[] DomainComponents, int valueArrayLength, int[] inherited_values, int[] valueToScalar, GraphicsModeControl mode, float constant_alpha, float[] value_array, float[] constant_color, DisplayImpl display, int curved_size, ShadowRealTupleType Domain, CoordinateSystem dataCoordinateSystem, DataRenderer renderer, ShadowFunctionOrSetType adaptedShadowType, int[] start, int lenX, int lenY, int bigX, int bigY, VisADImageTile tile)
void	SceneGraphRenderer.plot(Graphics2D graphics, DisplayImpl display, CoordinateSystem cs, int width, int height) Implements the Plottable interface.
int	SceneGraphRenderer.print(Graphics graphics, PageFormat pageFormat, int pageIndex, DisplayImpl display, CoordinateSystem cs) Print the display

Uses of CoordinateSystem in visad.cluster

Methods in visad.cluster that return CoordinateSystem

CoordinateSystem	RemoteNodePartitionedFieldImpl.getDomainCoordinateSystem()
CoordinateSystem	RemoteNodeFieldImpl.getDomainCoordinateSystem()
CoordinateSystem	RemoteClientPartitionedFieldImpl.getDomainCoordinateSystem()
CoordinateSystem	RemoteClientFieldImpl.getDomainCoordinateSystem()
CoordinateSystem[]	RemoteNodePartitionedFieldImpl.getRangeCoordinateSystem()
CoordinateSystem[]	RemoteNodeFieldImpl.getRangeCoordinateSystem()
CoordinateSystem[]	RemoteClientPartitionedFieldImpl.getRangeCoordinateSystem()
CoordinateSystem[]	RemoteClientFieldImpl.getRangeCoordinateSystem()
CoordinateSystem[]	RemoteNodePartitionedFieldImpl.getRangeCoordinateSystem(int i)
CoordinateSystem[]	RemoteNodeFieldImpl.getRangeCoordinateSystem(int i)
CoordinateSystem[]	RemoteClientPartitionedFieldImpl.getRangeCoordinateSystem(int i)
CoordinateSystem[]	RemoteClientFieldImpl.getRangeCoordinateSystem(int i)

Uses of CoordinateSystem in visad.data

Methods in visad.data that return CoordinateSystem

CoordinateSystem	FileFlatField.getDomainCoordinateSystem()
CoordinateSystem	AreaImageCacheAdapter.getDomainCoordinateSystem()
CoordinateSystem[]	FileFlatField.getRangeCoordinateSystem()
CoordinateSystem[]	AreaImageCacheAdapter.getRangeCoordinateSystem()
CoordinateSystem[]	FileFlatField.getRangeCoordinateSystem(int component)
CoordinateSystem[]	AreaImageCacheAdapter.getRangeCoordinateSystem(int component)

Methods in visad.data with parameters of type CoordinateSystem

CachedFlatField	CachedFlatField.cloneMe(boolean copy, FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSysArray, Set[] rangeSets, Unit[] units) Clone this object
CachedFlatField	CachedFlatField.cloneMe(boolean copy, FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSysArray, Set[] rangeSets, Unit[] units) Clone this object
void	EmptyDataProcessor.processDoubleSet(SetType type, CoordinateSystem cs, Unit[] units, DoubleSet set, Object token)
void	DataProcessor.processDoubleSet(SetType type, CoordinateSystem cs, Unit[] units, DoubleSet set, Object token)
abstract void	BaseDataProcessor.processDoubleSet(SetType type, CoordinateSystem cs, Unit[] units, DoubleSet set, Object token)
void	EmptyDataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	EmptyDataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	DataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	DataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
abstract void	BaseDataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
abstract void	BaseDataProcessor.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	EmptyDataProcessor.processFloatSet(SetType type, CoordinateSystem cs, Unit[] units, FloatSet set, Object token)
void	DataProcessor.processFloatSet(SetType type, CoordinateSystem cs, Unit[] units, FloatSet set, Object token)
abstract void	BaseDataProcessor.processFloatSet(SetType type, CoordinateSystem cs, Unit[] units, FloatSet set, Object token)
void	EmptyDataProcessor.processGridded1DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DDoubleSet set, Object token)
void	DataProcessor.processGridded1DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DDoubleSet set, Object token)
abstract void	BaseDataProcessor.processGridded1DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DDoubleSet set, Object token)
void	EmptyDataProcessor.processGridded1DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DSet set, Object token)
void	DataProcessor.processGridded1DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DSet set, Object token)
abstract void	BaseDataProcessor.processGridded1DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DSet set, Object token)
void	EmptyDataProcessor.processGridded2DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DDoubleSet set, Object token)
void	DataProcessor.processGridded2DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DDoubleSet set, Object token)
abstract void	BaseDataProcessor.processGridded2DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DDoubleSet set, Object token)
void	EmptyDataProcessor.processGridded2DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DSet set, Object token)
void	DataProcessor.processGridded2DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DSet set, Object token)
abstract void	BaseDataProcessor.processGridded2DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DSet set, Object token)
void	EmptyDataProcessor.processGridded3DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DDoubleSet set, Object token)
void	DataProcessor.processGridded3DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DDoubleSet set, Object token)
abstract void	BaseDataProcessor.processGridded3DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DDoubleSet set, Object token)
void	EmptyDataProcessor.processGridded3DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DSet set, Object token)
void	DataProcessor.processGridded3DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DSet set, Object token)
abstract void	BaseDataProcessor.processGridded3DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DSet set, Object token)
void	EmptyDataProcessor.processGriddedSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Object token)
void	DataProcessor.processGriddedSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Object token)
abstract void	BaseDataProcessor.processGriddedSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Object token)
void	EmptyDataProcessor.processInteger1DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer1DSet set, Object token)
void	DataProcessor.processInteger1DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer1DSet set, Object token)
abstract void	BaseDataProcessor.processInteger1DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer1DSet set, Object token)
void	EmptyDataProcessor.processInteger2DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer2DSet set, Object token)
void	DataProcessor.processInteger2DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer2DSet set, Object token)
abstract void	BaseDataProcessor.processInteger2DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer2DSet set, Object token)
void	EmptyDataProcessor.processInteger3DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer3DSet set, Object token)
void	DataProcessor.processInteger3DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer3DSet set, Object token)
abstract void	BaseDataProcessor.processInteger3DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer3DSet set, Object token)
void	EmptyDataProcessor.processIntegerNDSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IntegerNDSet set, Object token)
void	DataProcessor.processIntegerNDSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IntegerNDSet set, Object token)
abstract void	BaseDataProcessor.processIntegerNDSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IntegerNDSet set, Object token)
void	EmptyDataProcessor.processIrregular1DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Irregular1DSet set, Object token)
void	DataProcessor.processIrregular1DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Irregular1DSet set, Object token)
abstract void	BaseDataProcessor.processIrregular1DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Irregular1DSet set, Object token)
void	EmptyDataProcessor.processIrregular2DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular2DSet set, Object token)
void	DataProcessor.processIrregular2DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular2DSet set, Object token)
abstract void	BaseDataProcessor.processIrregular2DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular2DSet set, Object token)
void	EmptyDataProcessor.processIrregular3DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular3DSet set, Object token)
void	DataProcessor.processIrregular3DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular3DSet set, Object token)
abstract void	BaseDataProcessor.processIrregular3DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular3DSet set, Object token)
void	EmptyDataProcessor.processIrregularSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Object token)
void	DataProcessor.processIrregularSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Object token)
abstract void	BaseDataProcessor.processIrregularSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Object token)
void	EmptyDataProcessor.processLinear1DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear1DSet set, Object token)
void	DataProcessor.processLinear1DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear1DSet set, Object token)
abstract void	BaseDataProcessor.processLinear1DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear1DSet set, Object token)
void	EmptyDataProcessor.processLinear2DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear2DSet set, Object token)
void	DataProcessor.processLinear2DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear2DSet set, Object token)
abstract void	BaseDataProcessor.processLinear2DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear2DSet set, Object token)
void	EmptyDataProcessor.processLinear3DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear3DSet set, Object token)
void	DataProcessor.processLinear3DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear3DSet set, Object token)
abstract void	BaseDataProcessor.processLinear3DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear3DSet set, Object token)
void	EmptyDataProcessor.processLinearLatLonSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearLatLonSet set, Object token)
void	DataProcessor.processLinearLatLonSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearLatLonSet set, Object token)
abstract void	BaseDataProcessor.processLinearLatLonSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearLatLonSet set, Object token)
void	EmptyDataProcessor.processLinearNDSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearNDSet set, Object token)
void	DataProcessor.processLinearNDSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearNDSet set, Object token)
abstract void	BaseDataProcessor.processLinearNDSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearNDSet set, Object token)
void	EmptyDataProcessor.processList1DSet(SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
void	DataProcessor.processList1DSet(SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
abstract void	BaseDataProcessor.processList1DSet(SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
void	EmptyDataProcessor.processProductSet(SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
void	DataProcessor.processProductSet(SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
abstract void	BaseDataProcessor.processProductSet(SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
void	EmptyDataProcessor.processRealTuple(RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
void	DataProcessor.processRealTuple(RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
abstract void	BaseDataProcessor.processRealTuple(RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
void	EmptyDataProcessor.processSampledSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SampledSet set, Object token)
void	DataProcessor.processSampledSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SampledSet set, Object token)
abstract void	BaseDataProcessor.processSampledSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SampledSet set, Object token)
void	EmptyDataProcessor.processSimpleSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SimpleSet set, Object token)
void	DataProcessor.processSimpleSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SimpleSet set, Object token)
abstract void	BaseDataProcessor.processSimpleSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SimpleSet set, Object token)
void	EmptyDataProcessor.processSingletonSet(RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)
void	DataProcessor.processSingletonSet(RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)
abstract void	BaseDataProcessor.processSingletonSet(RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)

Constructors in visad.data with parameters of type CoordinateSystem

CachedFlatField(CachedFlatField that, boolean copy, FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSysArray, Set[] rangeSets, Unit[] units)
Copy constructor

CachedFlatField(CachedFlatField that, boolean copy, FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSysArray, Set[] rangeSets, Unit[] units)
Copy constructor

CachedFlatField(FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSyses, Set[] rangeSets, Unit[] units, float[][] floats)
Create a new CachedFlatField

CachedFlatField(FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, CoordinateSystem[] rangeCoordSyses, Set[] rangeSets, Unit[] units, float[][] floats)
Create a new CachedFlatField

CachedFlatField(FunctionType type, Set domainSet, CoordinateSystem rangeCoordSys, Set[] rangeSets, Unit[] units, float[][] floats)
Create a new CachedFlatField

Uses of CoordinateSystem in visad.data.hdfeos

Subclasses of CoordinateSystem in visad.data.hdfeos

class	LambertAzimuthalEqualArea LambertAzimuthalEqualArea is the VisAD class for coordinate systems for ( X_map, Y_map ).
class	LambertConformalConic LambertConformalConic is the VisAD class for coordinate systems for ( X_map, Y_map ).
class	PolarStereographic PolarStereographic is the VisAD class for coordinate systems for ( X_map, Y_map ).

Methods in visad.data.hdfeos that return CoordinateSystem

CoordinateSystem

GctpMap.getVisADCoordinateSystem()

Uses of CoordinateSystem in visad.data.hrit

Subclasses of CoordinateSystem in visad.data.hrit

class

HRITCoordinateSystem HRITCoordinateSystem is a VisAD CoordinateSystem class used by HRITAdapter for conversions to/from (Latitude, Longitude) and Cartesian (element,line), and with Latitude and Longitude in degrees.

Uses of CoordinateSystem in visad.data.mcidas

Subclasses of CoordinateSystem in visad.data.mcidas

class	AREACoordinateSystem AREACoordinateSystem is the VisAD CoordinateSystem class for conversions to/from (Latitude, Longitude) and Cartesian (element,line), and with Latitude and Longitude in degrees.
class	GRIDCoordinateSystem GRIDCoordinateSystem is the VisAD CoordinateSystem class for conversions to/from (Latitude, Longitude) and Cartesian (col,row), and with Latitude and Longitude in degrees.

Methods in visad.data.mcidas that return CoordinateSystem

CoordinateSystem	McIDASGridDirectory.getCoordinateSystem() Get the GRIDCoordinateSystem associated with this grid
CoordinateSystem	AreaAdapter.getCoordinateSystem() get the CoordinateSystem of the image

Methods in visad.data.mcidas with parameters of type CoordinateSystem

void	BaseMapAdapter.setCoordinateSystem(CoordinateSystem cs, int numEles, int numLines, RealTupleType domain) Define a CoordinateSystem whose fromReference() will be used to transform points from latitude/longitude into element,line.

Uses of CoordinateSystem in visad.data.vis5d

Subclasses of CoordinateSystem in visad.data.vis5d

class	Vis5DCoordinateSystem Vis5DCoordinateSystem is the VisAD class for coordinate systems for ( row, col ).
static class	Vis5DVerticalSystem.Vis5DVerticalCoordinateSystem Vis5DVerticalCoordinateSystem is the VisAD class for coordinate systems for transforming pressure in millibars to Altitude in m.

Uses of CoordinateSystem in visad.data.visad

Methods in visad.data.visad with parameters of type CoordinateSystem

void	BinaryWriter.processDoubleSet(SetType type, CoordinateSystem cs, Unit[] units, DoubleSet set, Object token)
void	BinarySizer.processDoubleSet(SetType type, CoordinateSystem cs, Unit[] units, DoubleSet set, Object token)
void	BinaryWriter.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	BinaryWriter.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	BinarySizer.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	BinarySizer.processFlatField(FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
void	BinaryWriter.processFloatSet(SetType type, CoordinateSystem cs, Unit[] units, FloatSet set, Object token)
void	BinarySizer.processFloatSet(SetType type, CoordinateSystem cs, Unit[] units, FloatSet set, Object token)
void	BinaryWriter.processGridded1DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DDoubleSet set, Object token)
void	BinarySizer.processGridded1DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DDoubleSet set, Object token)
void	BinaryWriter.processGridded1DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DSet set, Object token)
void	BinarySizer.processGridded1DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded1DSet set, Object token)
void	BinaryWriter.processGridded2DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DDoubleSet set, Object token)
void	BinarySizer.processGridded2DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DDoubleSet set, Object token)
void	BinaryWriter.processGridded2DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DSet set, Object token)
void	BinarySizer.processGridded2DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded2DSet set, Object token)
void	BinaryWriter.processGridded3DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DDoubleSet set, Object token)
void	BinarySizer.processGridded3DDoubleSet(SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DDoubleSet set, Object token)
void	BinaryWriter.processGridded3DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DSet set, Object token)
void	BinarySizer.processGridded3DSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Gridded3DSet set, Object token)
void	BinaryWriter.processGriddedSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Object token)
void	BinarySizer.processGriddedSet(SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Object token)
void	BinaryWriter.processInteger1DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer1DSet set, Object token)
void	BinarySizer.processInteger1DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer1DSet set, Object token)
void	BinaryWriter.processInteger2DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer2DSet set, Object token)
void	BinarySizer.processInteger2DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer2DSet set, Object token)
void	BinaryWriter.processInteger3DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer3DSet set, Object token)
void	BinarySizer.processInteger3DSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Integer3DSet set, Object token)
void	BinaryWriter.processIntegerNDSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IntegerNDSet set, Object token)
void	BinarySizer.processIntegerNDSet(SetType type, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IntegerNDSet set, Object token)
void	BinaryWriter.processIrregular1DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Irregular1DSet set, Object token)
void	BinarySizer.processIrregular1DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Irregular1DSet set, Object token)
void	BinaryWriter.processIrregular2DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular2DSet set, Object token)
void	BinarySizer.processIrregular2DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular2DSet set, Object token)
void	BinaryWriter.processIrregular3DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular3DSet set, Object token)
void	BinarySizer.processIrregular3DSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, Irregular3DSet set, Object token)
void	BinaryWriter.processIrregularSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Object token)
void	BinarySizer.processIrregularSet(SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Object token)
void	BinaryWriter.processLinear1DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear1DSet set, Object token)
void	BinarySizer.processLinear1DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear1DSet set, Object token)
void	BinaryWriter.processLinear2DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear2DSet set, Object token)
void	BinarySizer.processLinear2DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear2DSet set, Object token)
void	BinaryWriter.processLinear3DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear3DSet set, Object token)
void	BinarySizer.processLinear3DSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Linear3DSet set, Object token)
void	BinaryWriter.processLinearLatLonSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearLatLonSet set, Object token)
void	BinarySizer.processLinearLatLonSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearLatLonSet set, Object token)
void	BinaryWriter.processLinearNDSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearNDSet set, Object token)
void	BinarySizer.processLinearNDSet(SetType type, double[] firsts, double[] lasts, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, LinearNDSet set, Object token)
void	BinaryWriter.processList1DSet(SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
void	BinarySizer.processList1DSet(SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
void	BinaryWriter.processProductSet(SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
void	BinarySizer.processProductSet(SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
void	BinaryWriter.processRealTuple(RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
void	BinarySizer.processRealTuple(RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
void	BinaryWriter.processSampledSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SampledSet set, Object token)
void	BinarySizer.processSampledSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SampledSet set, Object token)
void	BinaryWriter.processSimpleSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SimpleSet set, Object token)
void	BinarySizer.processSimpleSet(SetType st, int manifold_dimension, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SimpleSet set, Object token)
void	BinaryWriter.processSingletonSet(RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)
void	BinarySizer.processSingletonSet(RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)

Uses of CoordinateSystem in visad.data.visad.object

Methods in visad.data.visad.object that return CoordinateSystem

static CoordinateSystem	BinaryCoordinateSystem.read(BinaryReader reader)
static CoordinateSystem[]	BinaryCoordinateSystem.readList(BinaryReader reader)

Methods in visad.data.visad.object with parameters of type CoordinateSystem

static int	BinaryLinearSet.computeBytes(boolean matchedTypes, double[] firsts, double[] lasts, int[] lengths, Linear1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryIntegerSet.computeBytes(boolean matchedTypes, int[] lengths, Integer1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryCoordinateSystem.computeBytes(CoordinateSystem cSys)
static int	BinaryCoordinateSystem.computeBytes(CoordinateSystem[] array)
static int	BinarySimpleSet.computeBytes(CoordinateSystem cs, Unit[] units)
static int	BinaryGriddedDoubleSet.computeBytes(double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryIrregularSet.computeBytes(float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay)
static int	BinaryGriddedSet.computeBytes(float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryList1DSet.computeBytes(float[] list, CoordinateSystem cs, Unit[] units)
static int	BinaryRealTuple.computeBytes(Real[] components, CoordinateSystem cs, boolean trivialTuple)
static int	BinarySingletonSet.computeBytes(RealTupleType sampleType, Real[] sampleReals, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryProductSet.computeBytes(SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors)
static int	BinaryFlatField.computeBytes(Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld)
static int	BinaryFlatField.computeBytes(Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld)
static int[]	BinaryCoordinateSystem.lookupList(BinaryObjectCache cache, CoordinateSystem[] cSys)
static int	BinaryCoordinateSystem.write(BinaryWriter writer, CoordinateSystem cSys, Object token)
static void	BinaryFlatField.write(BinaryWriter writer, FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
static void	BinaryFlatField.write(BinaryWriter writer, FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
static void	BinarySingletonSet.write(BinaryWriter writer, RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)
static void	BinaryRealTuple.write(BinaryWriter writer, RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
static void	BinarySimpleSet.write(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, SimpleSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryGriddedDoubleSet.write(BinaryWriter writer, SetType type, double[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryLinearSet.write(BinaryWriter writer, SetType type, double[] firsts, double[] lasts, int[] lengths, Linear1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryIrregularSet.write(BinaryWriter writer, SetType type, float[][] samples, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, Delaunay delaunay, IrregularSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryGriddedSet.write(BinaryWriter writer, SetType type, float[][] samples, int[] lengths, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryList1DSet.write(BinaryWriter writer, SetType type, float[] list, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
static void	BinaryIntegerSet.write(BinaryWriter writer, SetType type, int[] lengths, Integer1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, byte dataType, Object token)
static void	BinaryProductSet.write(BinaryWriter writer, SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
static void	BinaryFlatField.writeDependentData(BinaryWriter writer, FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
static void	BinaryFlatField.writeDependentData(BinaryWriter writer, FunctionType type, Set domainSet, CoordinateSystem cs, CoordinateSystem[] rangeCS, Set[] rangeSets, Unit[] units, FlatField fld, Object token)
static void	BinarySingletonSet.writeDependentData(BinaryWriter writer, RealTuple sample, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, SingletonSet set, Object token)
static void	BinaryRealTuple.writeDependentData(BinaryWriter writer, RealTupleType type, Real[] components, CoordinateSystem cs, RealTuple rt, Object token)
static void	BinaryGriddedSet.writeDependentData(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, Object token)
static void	BinaryGriddedDoubleSet.writeDependentData(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, Object token)
static void	BinaryIrregularSet.writeDependentData(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, IrregularSet set, Class canonicalClass, Object token)
static void	BinaryList1DSet.writeDependentData(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, List1DSet set, Object token)
static void	BinarySimpleSet.writeDependentData(BinaryWriter writer, SetType type, CoordinateSystem cs, Unit[] units, SimpleSet set, Class canonicalClass, Object token)
static void	BinaryIntegerSet.writeDependentData(BinaryWriter writer, SetType type, Integer1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, Object token)
static void	BinaryLinearSet.writeDependentData(BinaryWriter writer, SetType type, Linear1DSet[] comps, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, GriddedSet set, Class canonicalClass, Object token)
static void	BinaryProductSet.writeDependentData(BinaryWriter writer, SetType type, SampledSet[] sets, CoordinateSystem cs, Unit[] units, ErrorEstimate[] errors, ProductSet set, Object token)
static int[]	BinaryCoordinateSystem.writeList(BinaryWriter writer, CoordinateSystem[] cSys, Object token)

Uses of CoordinateSystem in visad.georef

Subclasses of CoordinateSystem in visad.georef

class	LongitudeLatitudeInterpCS For 2D arrays of earth observations when the navigation is not provided analytically, but a set of navigated points is given to interpolate.
class	MapProjection Abstract class for coordinate systems that support (lat,lon) <-> (x,y) with a reference coordinate system of (lat, lon) or (lon, lat).
class	NavigatedCoordinateSystem Abstract class for CoordinateSystems that have RealType.Latitude and RealType.Longitude in their reference RealTupleType.
class	TrivialMapProjection A trivial implementation for a MapProjection which provides an identity coordinate system with a default bounding box.
class	TrivialNavigation

Constructors in visad.georef with parameters of type CoordinateSystem

UTMCoordinate(Real east, Real north, Real alt, Real zone, Real hemi, CoordinateSystem cs)
Construct a UTMCoordinate from Reals representing the easting and northing, the zone and the hemisphere.

Uses of CoordinateSystem in visad.java2d

Methods in visad.java2d with parameters of type CoordinateSystem

boolean

ShadowTypeJ2D.makeContour(int valueArrayLength, int[] valueToScalar, float[][] display_values, int[] inherited_values, Vector MapVector, int[] valueToMap, int domain_length, boolean[][] range_select, int spatialManifoldDimension, Set spatial_set, byte[][] color_values, boolean indexed, Object group, GraphicsModeControl mode, boolean[] swap, float constant_alpha, float[] constant_color, ShadowType shadow_api, ShadowRealTupleType Domain, ShadowRealType[] DomainReferenceComponents, Set domain_set, Unit[] domain_units, CoordinateSystem dataCoordinateSystem)

Uses of CoordinateSystem in visad.java3d

Methods in visad.java3d with parameters of type CoordinateSystem

boolean

ShadowTypeJ3D.makeContour(int valueArrayLength, int[] valueToScalar, float[][] display_values, int[] inherited_values, Vector MapVector, int[] valueToMap, int domain_length, boolean[][] range_select, int spatialManifoldDimension, Set spatial_set, byte[][] color_values, boolean indexed, Object group, GraphicsModeControl mode, boolean[] swap, float constant_alpha, float[] constant_color, ShadowType shadow_api, ShadowRealTupleType Domain, ShadowRealType[] DomainReferenceComponents, Set domain_set, Unit[] domain_units, CoordinateSystem dataCoordinateSystem)

Uses of CoordinateSystem in visad.jmet

Subclasses of CoordinateSystem in visad.jmet

class	AlbersCoordinateSystem
class	EASECoordinateSystem
class	GRIBCoordinateSystem

Fields in visad.jmet declared as CoordinateSystem

protected CoordinateSystem	MetGrid.coordinateSystem
protected CoordinateSystem	MetGridDirectory.coordSystem

Methods in visad.jmet that return CoordinateSystem

abstract CoordinateSystem	MetGridDirectory.getCoordinateSystem()
CoordinateSystem	MetGrid.getCoordinateSystem() return the CoordinateSystem for this grid (could also get from the MetGridDirectory, too)

Uses of CoordinateSystem in visad.math

Methods in visad.math with parameters of type CoordinateSystem

static FlatField

FFT.fourierTransform(Field field, boolean forward, FunctionType ftype, GriddedSet domain_set, CoordinateSystem range_coord_sys, Set[] range_sets, Unit[] units) return Fourier Transform of field, use FFT if domain dimension(s) are powers of 2

Uses of CoordinateSystem in visad.matrix

Constructors in visad.matrix with parameters of type CoordinateSystem

JamaMatrix(Object matrix, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, coordinate systems, range sets and units.

JamaMatrix(Object matrix, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, coordinate systems, range sets and units.

JamaMatrix(Object matrix, FunctionType type, Gridded2DSet domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, MathType, domain set, coordinate systems, range sets and units.

JamaMatrix(Object matrix, FunctionType type, Gridded2DSet domain_set, CoordinateSystem range_coord_sys, CoordinateSystem[] range_coord_syses, Set[] range_sets, Unit[] units)
Construct a new JamaMatrix from the specified JAMA Matrix, MathType, domain set, coordinate systems, range sets and units.

Uses of CoordinateSystem in visad.python

Methods in visad.python with parameters of type CoordinateSystem

static RealTupleType

JPythonMethods.makeType(String[] s, CoordinateSystem c) make a MathType with a Coordinate System.