| Package | Description |
|---|---|
| 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 |
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Field and Description |
|---|---|
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 |
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
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) |
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
CoordinateSystem |
FileFlatField.getDomainCoordinateSystem() |
CoordinateSystem |
AreaImageCacheAdapter.getDomainCoordinateSystem() |
CoordinateSystem[] |
FileFlatField.getRangeCoordinateSystem() |
CoordinateSystem[] |
AreaImageCacheAdapter.getRangeCoordinateSystem() |
CoordinateSystem[] |
FileFlatField.getRangeCoordinateSystem(int component) |
CoordinateSystem[] |
AreaImageCacheAdapter.getRangeCoordinateSystem(int component) |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Constructor and Description |
|---|
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
|
| Modifier and Type | Class and Description |
|---|---|
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 ).
|
| Modifier and Type | Method and Description |
|---|---|
CoordinateSystem |
GctpMap.getVisADCoordinateSystem() |
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
CoordinateSystem |
McIDASGridDirectory.getCoordinateSystem()
Get the GRIDCoordinateSystem associated with this grid
|
CoordinateSystem |
AreaAdapter.getCoordinateSystem()
get the CoordinateSystem of the image
|
| Modifier and Type | Method and Description |
|---|---|
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.
|
| Modifier and Type | Class and Description |
|---|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
static CoordinateSystem |
BinaryCoordinateSystem.read(BinaryReader reader) |
static CoordinateSystem[] |
BinaryCoordinateSystem.readList(BinaryReader reader) |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Class and Description |
|---|---|
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 |
| Constructor and Description |
|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Method and Description |
|---|---|
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) |
| Modifier and Type | Class and Description |
|---|---|
class |
AlbersCoordinateSystem |
class |
EASECoordinateSystem |
class |
GRIBCoordinateSystem |
| Modifier and Type | Field and Description |
|---|---|
protected CoordinateSystem |
MetGrid.coordinateSystem |
protected CoordinateSystem |
MetGridDirectory.coordSystem |
| Modifier and Type | Method and Description |
|---|---|
abstract CoordinateSystem |
MetGridDirectory.getCoordinateSystem() |
CoordinateSystem |
MetGrid.getCoordinateSystem()
return the CoordinateSystem for this grid (could also get from
the MetGridDirectory, too)
|
| Modifier and Type | Method and Description |
|---|---|
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
|
| Constructor and Description |
|---|
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.
|
| Modifier and Type | Method and Description |
|---|---|
static RealTupleType |
JPythonMethods.makeType(String[] s,
CoordinateSystem c)
make a MathType with a Coordinate System.
|