## visad
Class Irregular2DSet

    java.lang.Object
      visad.ThingImpl
          visad.DataImpl
              visad.Set
                  visad.SimpleSet
                      visad.SampledSet
                          visad.IrregularSet
                              visad.Irregular2DSet

All Implemented Interfaces:
  Cloneable, Data, SampledSetIface, Serializable, SetIface, SimpleSetIface, Thing

public class Irregular2DSet
extends IrregularSet

`IrregularSet` for a finite number of samples of R.

NOTE: There is no `Irregular2DSet` with a manifold dimension equal to one. Use `Gridded2DSet` with a manifold dimension equal to one instead.

When you call an `Irregular2DSet` constructor without a `Delaunay` argument, the constructor uses the `Delaunay#factory()` method to implictly compute a Delaunay triangulation. 3000 points is the current break-point from Watson's algorithm to Clarkson's algorithm. So, currently, at 3001 points you start using Clarkson's algorithm, which rounds coordinates to integers. If your values are small enough that integer rounding will merge some of them to the same value (and hence create colinear or colocated points), there will be trouble. One approach is to scale your coordinates up so integer rounding does not merge values. Another is to ensure that you use Watson's algorithm by using `new DelaunayWatson(samples)` as the `Delaunay` argument of the `Irregular2DSet` constructor.

See Also:
  Serialized Form

Nested Class Summary

Nested classes inherited from class visad.DataImpl
`DataImpl.Syncher`

Nested classes inherited from class visad.ThingImpl
`ThingImpl.RemotePair`

Field Summary

Fields inherited from class visad.IrregularSet
`Delan, newToOld, oldToNew`

Fields inherited from class visad.SampledSet
`Hi, Low, Samples`

Fields inherited from class visad.SimpleSet
`ManifoldDimension`

Fields inherited from class visad.Set
`DomainCoordinateSystem, DomainDimension, hashCode, hashCodeSet, Length, SetErrors, SetUnits`

Fields inherited from class visad.DataImpl
`Type`

Fields inherited from interface visad.Data

`ABS, ACOS, ACOS_DEGREES, ADD, ASIN, ASIN_DEGREES, ATAN, ATAN_DEGREES, ATAN2, ATAN2_DEGREES, CEIL, COS, COS_DEGREES, DEGREES_TO_RADIANS, DEPENDENT, DIVIDE, EXP, FLOOR, INDEPENDENT, INV_ATAN2, INV_ATAN2_DEGREES, INV_DIVIDE, INV_POW, INV_REMAINDER, INV_SUBTRACT, LOG, MAX, MIN, MULTIPLY, NEAREST_NEIGHBOR, NEGATE, NO_ERRORS, NOP, POW, RADIANS_TO_DEGREES, REMAINDER, RINT, ROUND, SIN, SIN_DEGREES, SQRT, SUBTRACT, TAN, TAN_DEGREES, WEIGHTED_AVERAGE`

Constructor Summary
`Irregular2DSet(MathType type, float[][] samples)` a 2-D irregular set with null errors, CoordinateSystem and Units are defaults from type; topology is computed by the constructor

`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)` shortcut 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)` 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)`

Method Summary
`Object` `cloneButType(MathType type)` Clones this set -- changing the MathType.
`float[][]` `indexToValue(int[] index)` convert an array of 1-D indices to an array of values in R^DomainDimension
`static void` `main(String[] argv)` Simple DataImpl test, invoked as 'java visad.DataImpl'.
`Set` `makeSpatial(SetType type, float[][] samples)`
`int[]` `valueToIndex(float[][] value)` convert an array of values in R^DomainDimension to an array of 1-D indices
`void` `valueToInterp(float[][] value, int[][] indices, float[][] weights)` for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if no interpolation is possible
`int[]` `valueToTri(float[][] value)` valueToTri returns an array of containing triangles given an array of points in R^DomainDimension

Methods inherited from class visad.IrregularSet
`clone, equals, getNeighbors, longString`

Methods inherited from class visad.SampledSet
`computeRanges, computeRanges, cram_missing, cram_samples, getHi, getLow, getNeighbors, getSamples, getSamples, init_samples, init_samples, isMissing, make1DGeometry, make3DGeometry, makePointGeometry, setGeometryArray, setGeometryArray`

Methods inherited from class visad.SimpleSet
`getManifoldDimension, setAnimationSampling`

Methods inherited from class visad.Set

`__getitem__, __len__, addEqualsCache, addNotEqualsCache, adjustType, copyDoubles, copyFloats, doubleToFloat, doubleToIndex, equalUnitAndCS, floatToDouble, getCoordinateSystem, getDimension, getDimension, getDoubles, getDoubles, getLength, getNeighbors, getSetErrors, getSetUnits, getWedge, indexToDouble, longString, make2DGeometry, makeIsoLines, makeIsoSurface, merge1DSets, testEqualsCache, testNotEqualsCache, unary, unitAndCSHashCode`

Methods inherited from class visad.DataImpl

`__add__, __add__, __div__, __div__, __mod__, __mod__, __mul__, __mul__, __neg__, __pow__, __pow__, __radd__, __rdiv__, __rmod__, __rmul__, __rpow__, __rsub__, __sub__, __sub__, abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, adjustSamplingError, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, computeReferenceRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, invertOp, local, log, log, max, max, min, min, multiply, multiply, negate, negate, notifyReferences, pow, pow, remainder, remainder, rint, rint, round, round, setParent, sin, sin, sinDegrees, sinDegrees, sqrt, sqrt, subtract, subtract, tan, tan, tanDegrees, tanDegrees, toString, unary`

Methods inherited from class visad.ThingImpl
`adaptedAddReference, adaptedRemoveReference, addReference, removeReference`

Methods inherited from class java.lang.Object
`finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface visad.SetIface
`doubleToIndex, equalUnitAndCS, getCoordinateSystem, getDimension, getDoubles, getDoubles, getLength, getManifoldDimension, getNeighbors, getSetErrors, getSetUnits, getWedge, indexToDouble, make2DGeometry, makeIsoLines, makeIsoSurface, merge1DSets`

Methods inherited from interface visad.Data

`abs, abs, acos, acos, acosDegrees, acosDegrees, add, add, adjustSamplingError, asin, asin, asinDegrees, asinDegrees, atan, atan, atan2, atan2, atan2Degrees, atan2Degrees, atanDegrees, atanDegrees, binary, binary, ceil, ceil, changeMathType, computeRanges, computeRanges, cos, cos, cosDegrees, cosDegrees, dataClone, divide, divide, exp, exp, floor, floor, getType, local, log, log, longString, max, max, min, min, multiply, multiply, negate, negate, pow, pow, remainder, remainder, rint, rint, round, round, sin, sin, sinDegrees, sinDegrees, sqrt, sqrt, subtract, subtract, tan, tan, tanDegrees, tanDegrees, unary, unary`

Methods inherited from interface visad.Thing
`addReference, removeReference`

Constructor Detail

### Irregular2DSet

    public Irregular2DSet(MathType type,
                          float[][] samples)
                   throws VisADException

  a 2-D irregular set with null errors, CoordinateSystem and Units are defaults from type; topology is computed by the constructor

### Irregular2DSet

    public Irregular2DSet(MathType type,
                          float[][] samples,
                          CoordinateSystem coord_sys,
                          Unit[] units,
                          ErrorEstimate[] errors,
                          Delaunay delan)
                   throws VisADException

  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

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

### Irregular2DSet

    public Irregular2DSet(MathType type,
                          float[][] samples,
                          int[] new2old,
                          int[] old2new)
                   throws VisADException

  shortcut constructor for constructing Irregular2DSet using sort from existing Irregular1DSet

### Irregular2DSet

    public Irregular2DSet(MathType type,
                          float[][] samples,
                          int[] new2old,
                          int[] old2new,
                          CoordinateSystem coord_sys,
                          Unit[] units,
                          ErrorEstimate[] errors)
                   throws VisADException

  complete constructor for constructing Irregular2DSet using sort from existing Irregular1DSet

### Irregular2DSet

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

Method Detail

### makeSpatial

    public Set makeSpatial(SetType type,
                           float[][] samples)
                    throws VisADException

  Specified by:
    `makeSpatial` in interface `SetIface`
  Overrides:
    `makeSpatial` in class `Set`
  Throws:
    `VisADException`

### indexToValue

    public float[][] indexToValue(int[] index)
                           throws VisADException

  convert an array of 1-D indices to an array of values in R^DomainDimension

  Specified by:
    `indexToValue` in interface `SetIface`
  Overrides:
    `indexToValue` in class `IrregularSet`
  Throws:
    `VisADException`

### valueToTri

    public int[] valueToTri(float[][] value)
                     throws VisADException

  valueToTri returns an array of containing triangles given an array of points in R^DomainDimension

  Throws:
    `VisADException`

### valueToIndex

    public int[] valueToIndex(float[][] value)
                       throws VisADException

  convert an array of values in R^DomainDimension to an array of 1-D indices

  Specified by:
    `valueToIndex` in interface `SetIface`
  Overrides:
    `valueToIndex` in class `IrregularSet`
  Throws:
    `VisADException`

### valueToInterp

    public void valueToInterp(float[][] value,
                              int[][] indices,
                              float[][] weights)
                       throws VisADException

  for each of an array of values in R^DomainDimension, compute an array of 1-D indices and an array of weights, to be used for interpolation; indices[i] and weights[i] are null if no interpolation is possible

  Specified by:
    `valueToInterp` in interface `SimpleSetIface`
  Overrides:
    `valueToInterp` in class `IrregularSet`
  Throws:
    `VisADException`

### cloneButType

    public Object cloneButType(MathType type)
                        throws VisADException

  Description copied from interface: `SetIface`
  Clones this set -- changing the MathType.

  Specified by:
    `cloneButType` in interface `SetIface`
  Overrides:
    `cloneButType` in class `IrregularSet`
  Throws:
    `VisADException`

### main

    public static void main(String[] argv)
                     throws VisADException

  Description copied from class: `DataImpl`
  Simple DataImpl test, invoked as 'java visad.DataImpl'.

  Throws:
    `VisADException`