## visad
Class ShadowType

    java.lang.Object
      visad.ShadowType

All Implemented Interfaces:
  Serializable

Direct Known Subclasses:
  ShadowFunctionOrSetType, ShadowScalarType, ShadowTupleType, ShadowTypeJ2D, ShadowTypeJ3D

public abstract class ShadowType
extends Object
implements Serializable

The ShadowType hierarchy shadows the MathType hierarchy, within a DataDisplayLink.

See Also:
  Serialized Form

Field Summary
`(package private) boolean` `adjustProjectionSeam`
`(package private) boolean` `anyContour` flags for any IsoContour or Flow at terminal nodes
`(package private) boolean` `anyFlow`
`(package private) boolean` `anyShape`
`(package private) boolean` `anyText`
`(package private) float` `arrowScale1`
`(package private) float` `arrowScale2`
`(package private) ContourControl` `c_cntrl`
`(package private) int[]` `cnt` makeContour, manifoldDimension == 2
`(package private) float` `cntrWeight1`
`(package private) float` `cntrWeight2`
`(package private) int[]` `componentIndex`
`(package private) ShadowRealTupleType[]` `componentWithRef`
`(package private) boolean` `curvedTexture`
`(package private) static int` `D0` possible values for Dtype
`(package private) static int` `D1`
`(package private) static int` `D2`
`(package private) static int` `D3`
`(package private) static int` `D4`
`(package private) static int` `Dbad`
`(package private) DisplayImpl` `display`
`(package private) int[]` `DisplayIndices` count of occurences of DisplayRealType-s ShadowScalarType: set for mappings to DisplayRealType-s ShadowTupleType (incl ShadowRealTupleType): set to sum for ShadowScalarType & ShadowRealTupleType components ShadowRealTupleType: add contribution from Reference
`(package private) int` `Dtype` Dtype and Rtype used only with ShadowSetType and Flat ShadowFunctionType
`(package private) boolean` `isLinearContour3D`
`(package private) boolean` `isTerminal` information calculated by checkIndices & testIndices
`(package private) boolean` `isTexture3D`
`(package private) boolean` `isTextureMap`
`static int` `LEGAL`
`(package private) int` `LevelOfDifficulty`
`(package private) DataDisplayLink` `Link`
`(package private) boolean` `MappedDisplayScalar` MappedDisplayScalar is true if any RealType component is mapped to any DisplayRealType-s, including via a RealTupleType.Reference
`static float` `METERS_PER_DEGREE`
`(package private) boolean` `MultipleDisplayScalar` MultipleDisplayScalar is true if any RealType component is mapped to multiple DisplayRealType-s, or if any RealTupleType component and its Reference are both mapped
`(package private) boolean` `MultipleSpatialDisplayScalar` MultipleSpatialDisplayScalar is true if any RealType component is mapped to multiple spatial DisplayRealType-s
`(package private) int` `n_pass1`
`(package private) int` `n_pass2`
`static int` `NESTED`
`static int` `NOTHING_MAPPED` possible values for LevelOfDifficulty
`(package private) ProjectionControl` `p_cntrl`
`(package private) float` `packingFactor1`
`(package private) float` `packingFactor2`
`(package private) static int` `R0` possible values for Rtype
`(package private) static int` `R1`
`(package private) static int` `R2`
`(package private) static int` `R3`
`(package private) static int` `R4`
`(package private) static int` `Rbad`
`(package private) float` `reduction1`
`(package private) float` `reduction2`
`(package private) int[]` `refToComponent` used by getComponents to record RealTupleTypes with coordinate transforms
`(package private) int` `Rtype`
`static int` `SIMPLE_ANIMATE_FIELD`
`static int` `SIMPLE_FIELD`
`static int` `SIMPLE_TUPLE`
`(package private) int` `spatialDimension` number of spatial DisplayRealType components at terminal nodes
`(package private) DisplayTupleType` `spatialTuple` spatial DisplayTupleType at terminal nodes
`(package private) float` `stepFactor1`
`(package private) float` `stepFactor2`
`(package private) boolean` `streamline1` streamline flags
`(package private) boolean` `streamline2`
`(package private) float` `streamlineDensity1`
`(package private) float` `streamlineDensity2`
`(package private) MathType` `Type` basic information about this ShadowType
`(package private) int[]` `ValueIndices` ValueIndices is like DisplayIndices, but distinguishes different ScalarMap-s of non-Single DisplayRealTypes

Constructor Summary
`ShadowType(MathType type, DataDisplayLink link, ShadowType parent)`

Method Summary
`(package private) static int[]` `addIndices(int[] indices, int[] indices2)` add arrays of indices (for each RealType or each DisplayRealType)
`void` `addLabelsToGroup(Object group, VisADGeometryArray[][] arrays, GraphicsModeControl mode, ContourControl control, ProjectionControl p_cntrl, int[] cnt, float constant_alpha, float[] contstant_color, float[][][] f_array)`
`void` `addSwitch(Object group, Object swit, Control control, Set domain_set, DataRenderer renderer)`
`boolean` `addTextToGroup(Object group, VisADGeometryArray array, GraphicsModeControl mode, float constant_alpha, float[] constant_color)`
`void` `addToGroup(Object group, Object branch)`
`boolean` `addToGroup(Object group, VisADGeometryArray array, GraphicsModeControl mode, float constant_alpha, float[] constant_color)`
`void` `addToSwitch(Object swit, Object branch)`
`static float[][]` `adjustFlowToEarth(int which, float[][] flow_values, float[][] spatial_values, float flowScale, DataRenderer renderer)`
`void` `adjustZ(float[] coordinates)`
`boolean` `allowConstantColorSurfaces()`
`boolean` `allowCurvedTexture()`
`boolean` `allowLinearContour()`
`(package private) boolean` `anyRange(int[] display_indices)` test for any SelectRange in display_indices
`byte[][]` `assembleColor(float[][] display_values, int valueArrayLength, int[] valueToScalar, DisplayImpl display, float[] default_values, boolean[][] range_select, boolean[] single_missing, ShadowType shadow_api)` composite and transform color and Alpha DisplayRealType values from display_values, and return as (Red, Green, Blue, Alpha)
`void` `assembleFlow(float[][] flow1_values, float[][] flow2_values, float[] flowScale, float[][] display_values, int valueArrayLength, int[] valueToScalar, DisplayImpl display, float[] default_values, boolean[][] range_select, DataRenderer renderer, ShadowType shadow_api)` assemble Flow components; Flow components are 'single', so no compositing is required
`boolean[][]` `assembleSelect(float[][] display_values, int domain_length, int valueArrayLength, int[] valueToScalar, DisplayImpl display, ShadowType shadow_api)` return a composite of SelectRange DisplayRealType values from display_values, as 0.0 for select and Double.Nan for no select (these values can be added to other DisplayRealType values)

`VisADGeometryArray[]`

`assembleShape(float[][] display_values, int valueArrayLength, int[] valueToMap, Vector MapVector, int[] valueToScalar, DisplayImpl display, float[] default_values, int[] inherited_values, float[][] spatial_values, byte[][] color_values, boolean[][] range_select, int index, ShadowType shadow_api)`
collect and transform Shape DisplayRealType values from display_values; offset by spatial_values, colored by color_values and selected by range_select

`Set`

`assembleSpatial(float[][] spatial_values, float[][] display_values, int valueArrayLength, int[] valueToScalar, DisplayImpl display, float[] default_values, int[] inherited_values, Set domain_set, boolean allSpatial, boolean set_for_shape, int[] spatialDimensions, boolean[][] range_select, float[][] flow1_values, float[][] flow2_values, float[] flowScale, boolean[] swap, DataRenderer renderer, ShadowType shadow_api)`
collect and transform spatial DisplayRealType values from display_values; add spatial offset DisplayRealType values; adjust flow1_values and flow2_values for any coordinate transform; if needed, return a spatial Set from spatial_values, with the same topology as domain_set (or an appropriate Irregular topology); domain_set = null and allSpatial = false if not called from ShadowFunctionType

`static float` `byteToFloat(byte b)`
`(package private) boolean` `checkAdjustProjectionSeam()`
`(package private) int` `checkAnimationOrValue(int[] display_indices)` test for any Animation or Value in display_indices
`(package private) boolean` `checkAny(int[] display_indices)` test for any non-zero display_indices
`(package private) boolean` `checkColor(int[] display_indices)` test for display_indices in (Color, Unmapped)
`(package private) boolean` `checkColorAlphaRange(int[] display_indices)` test for display_indices in (Color, Alpha, Range, Unmapped)
`(package private) boolean` `checkColorOrAlpha(int[] display_indices)` test for display_indices in (Color, Alpha, Unmapped)
`(package private) boolean` `checkColorRange(int[] display_indices)` test for display_indices in (Color, Range, Unmapped)
`(package private) boolean` `checkContour(int[] display_indices)` test for any IsoContour in display_indices
`(package private) boolean` `checkContourColorAlphaRange(int[] display_indices)` test for display_indices in (IsoContour, Color, Alpha, Range, Unmapped)
`(package private) boolean` `checkFlow(int[] display_indices)` test for any Flow in display_indices

`int`

`checkIndices(int[] indices, int[] display_indices, int[] value_indices, boolean[] isTransform, int levelOfDifficulty)`
scans ShadowType tree to determine display feasibility and precompute useful information for Data transform; indices & display_indices are counts (at leaves) of numbers of occurrences of RealTypes and DisplayRealTypes; isTransform flags for (Animation, Range, Value) re-transform; levelOfDifficulty passed down and up call chain

`(package private) boolean` `checkNested(int[] display_indices)` test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Animation, Range, Value, Flow, Text, Unmapped)
`(package private) boolean` `checkR1D3(int[] display_indices)` test for display_indices in (Color, Alpha, Range, Flow, Shape, ShapeScale, Text, Unmapped)
`(package private) boolean` `checkR2D2(int[] display_indices)` test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Range, Flow, Shape, ShapeScale, Text, Unmapped)
`(package private) boolean` `checkR3(int[] display_indices)` test for display_indices in (IsoContour, Color, Alpha, Flow, Text, Range, Unmapped)
`(package private) boolean` `checkR4(int[] display_indices)` test for display_indices in (Spatial, SpatialOffset, IsoContour, Color, Alpha, Flow, Text, Range, Unmapped)
`(package private) boolean` `checkShape(int[] display_indices)` test for any Shape in display_indices
`(package private) boolean` `checkSpatialColorAlphaRange(int[] display_indices)` test for display_indices in (Spatial, Color, Alpha, Range, Unmapped)
`(package private) boolean` `checkSpatialOffsetColorAlphaRange(int[] display_indices)` test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Range, Unmapped)
`(package private) boolean` `checkSpatialRange(int[] display_indices)` test for display_indices in (Spatial, Range, Unmapped)
`(package private) boolean` `checkText(int[] display_indices)` test for any Text in display_indices
`(package private) static void` `colorComposite(float[][] rgba_values, float[] rgba_value_counts, float[][] tuple_values)` composite tuple_values into rgba_values and rgba_value_counts, for index = 0, 1, 2
`(package private) static void` `colorSum(int nindex, float[][] tuple_values, float[] tuple_value_counts, float[] tuple_singles, float[] tuple_single_counts, DisplayImpl display, DisplayTupleType tuple, float[] default_values)`
`(package private) static int[]` `copyIndices(int[] indices)` copy an array of indices (for each RealType or each DisplayRealType)
`(package private) static void` `equalizeAndDefault(float[][] tuple_values, DisplayImpl display, DisplayTupleType tuple, float[] default_values)` equalize lengths and fill with default values
`static byte` `floatToByte(float f)`
`ShadowType` `getAdaptedShadowType()`
`boolean` `getAdjustProjectionSeam()`
`boolean` `getAnyContour()`
`boolean` `getAnyFlow()`
`boolean` `getAnyShape()`
`boolean` `getAnyText()`
`int[]` `getComponentIndex()`
`ShadowRealType[]` `getComponents(ShadowType type, boolean doRef)`
`ShadowRealTupleType[]` `getComponentWithRef()`
`boolean` `getCurvedTexture()`
`Data` `getData()`
`static int` `getDefaultColorIndex(DisplayImpl display, int index)`
`DisplayImpl` `getDisplay()`
`int[]` `getDisplayIndices()`
`boolean` `getIsLinearContour3D()`
`boolean` `getIsTerminal()`
`boolean` `getIsTexture3D()`
`boolean` `getIsTextureMap()`
`int` `getLevelOfDifficulty()`
`DataDisplayLink` `getLink()`
`boolean` `getMappedDisplayScalar()`
`boolean` `getMultipleDisplayScalar()`
`boolean` `getMultipleSpatialDisplayScalar()`
`String` `getParentText()`
`TextControl` `getParentTextControl()`
`int[]` `getRefToComponent()`
`Vector` `getTextMaps(int i, int[] textIndices)`
`MathType` `getType()`
`int[]` `getValueIndices()`
`Object` `makeBranch()`

`boolean`

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

`VisADGeometryArray[]` `makeFlow(int which, float[][] flow_values, float flowScale, float[][] spatial_values, byte[][] color_values, boolean[][] range_select)` which = 0 for Flow1 and which = 1 for Flow2
`static VisADGeometryArray` `makePointGeometry(float[][] spatial_values, byte[][] color_values)`
`static VisADGeometryArray` `makePointGeometry(float[][] spatial_values, byte[][] color_values, boolean compress)`
`Set` `makeSpatialSet(Set domain_set, SetType type, float[][] spatial_values)`
`VisADGeometryArray[]` `makeStreamline(int which, float[][] flow_values, float flowScale, float[][] spatial_values, Set spatial_set, int spatialManifoldDimension, byte[][] color_values, boolean[][] range_select, int valueArrayLength, int[] valueToMap, Vector MapVector)`
`Object` `makeSwitch()`
`VisADGeometryArray` `makeText(String[] text_values, TextControl text_control, float[][] spatial_values, byte[][] color_values, boolean[][] range_select)`
`static void` `mapValues(float[][] display_values, double[][] values, ShadowRealType[] reals)` map values to display_values according to ScalarMap-s in reals
`static void` `mapValues(float[][] display_values, float[][] values, ShadowRealType[] reals)` map values into display_values according to ScalarMap-s in reals
`static void` `mapValues(float[][] display_values, float[][] values, ShadowRealType[] reals, boolean copy)` Map values into display_values according to ScalarMap-s in reals
`(package private) void` `markTransform(boolean[] isTransform)` mark Control-s as needing re-Transform; default for ShadowTextType and ShadowMissingType
`boolean` `recurseComponent(int i, Object group, Data data, float[] value_array, float[] default_values, DataRenderer renderer)`
`boolean` `recurseRange(Object group, Data data, float[] value_array, float[] default_values, DataRenderer renderer)`
`(package private) static void` `rotateVectors(double[] base, double[] up, double rotationDegrees)` abcd - 2 February 2001 Rotate the base and up vectors Rotation is in degrees clockwise from positive X axis
`float[]` `setTex3DCoords(int length, int axis, float ratiow, float ratioh, float ratiod)`
`void` `setTexCoords(float[] texCoords, float ratiow, float ratioh)`
`float[]` `setTexStackCoords(int length, int axis, float ratiow, float ratioh, float ratiod)`
`void` `setText(String text, TextControl control)`
`(package private) static void` `singleComposite(int index, float[][] rgba_values, float[] rgba_value_counts, float[] values)` composite values into rgba_values[index] and rgba_value_counts[index]

`boolean`

`terminalTupleOrScalar(Object group, float[][] display_values, String text_value, TextControl text_control, int valueArrayLength, int[] valueToScalar, float[] default_values, int[] inherited_values, DataRenderer renderer, ShadowType shadow_api)`
transform data into a (Java3D or Java2D) scene graph; add generated scene graph components as children of group; group is Group (Java3D) or VisADGroup (Java2D); value_array are inherited valueArray values; default_values are defaults for each display.DisplayRealTypeVector; return true if need post-process

`(package private) int` `testIndices(int[] indices, int[] display_indices, int levelOfDifficulty)` applied at terminal nodes
`(package private) boolean` `testTransform()` return true if DisplayIndices include multiple Animation, SelectValue and SelectRange
`void` `texture3DToGroup(Object group, VisADGeometryArray arrayX, VisADGeometryArray arrayY, VisADGeometryArray arrayZ, VisADGeometryArray arrayXrev, VisADGeometryArray arrayYrev, VisADGeometryArray arrayZrev, BufferedImage[] images, GraphicsModeControl mode, float constant_alpha, float[] constant_color, int texture_width, int texture_height, int texture_depth, DataRenderer renderer)`
`int` `textureDepth(int data_depth)`
`int` `textureHeight(int data_height)`

`void`

`textureStackToGroup(Object group, VisADGeometryArray arrayX, VisADGeometryArray arrayY, VisADGeometryArray arrayZ, VisADGeometryArray arrayXrev, VisADGeometryArray arrayYrev, VisADGeometryArray arrayZrev, BufferedImage[] imagesX, BufferedImage[] imagesY, BufferedImage[] imagesZ, GraphicsModeControl mode, float constant_alpha, float[] constant_color, int texture_width, int texture_height, int texture_depth, DataRenderer renderer)`

`void` `textureToGroup(Object group, VisADGeometryArray array, BufferedImage image, GraphicsModeControl mode, float constant_alpha, float[] constant_color, int texture_width, int texture_height)`
`int` `textureWidth(int data_width)`
`String` `toString()`
`boolean` `wantIndexed()`
`(package private) static int[]` `zeroIndices(int length)` create a zero'd array of indices (for each RealType or each DisplayRealType)

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

Field Detail

### NOTHING_MAPPED

    public static final int NOTHING_MAPPED

  possible values for LevelOfDifficulty

  See Also:
    Constant Field Values

### SIMPLE_TUPLE

    public static final int SIMPLE_TUPLE

See Also:
  Constant Field Values

### SIMPLE_ANIMATE_FIELD

    public static final int SIMPLE_ANIMATE_FIELD

See Also:
  Constant Field Values

### SIMPLE_FIELD

    public static final int SIMPLE_FIELD

See Also:
  Constant Field Values

### NESTED

    public static final int NESTED

See Also:
  Constant Field Values

### LEGAL

    public static final int LEGAL

See Also:
  Constant Field Values

### Type

    MathType Type

  basic information about this ShadowType

### Link

    transient DataDisplayLink Link

### display

    transient DisplayImpl display

### DisplayIndices

    int[] DisplayIndices

  count of occurences of DisplayRealType-s ShadowScalarType: set for mappings to DisplayRealType-s ShadowTupleType (incl ShadowRealTupleType): set to sum for ShadowScalarType & ShadowRealTupleType components ShadowRealTupleType: add contribution from Reference

### ValueIndices

    int[] ValueIndices

  ValueIndices is like DisplayIndices, but distinguishes different ScalarMap-s of non-Single DisplayRealTypes

### MultipleSpatialDisplayScalar

    boolean MultipleSpatialDisplayScalar

  MultipleSpatialDisplayScalar is true if any RealType component is mapped to multiple spatial DisplayRealType-s

### MultipleDisplayScalar

    boolean MultipleDisplayScalar

  MultipleDisplayScalar is true if any RealType component is mapped to multiple DisplayRealType-s, or if any RealTupleType component and its Reference are both mapped

### MappedDisplayScalar

    boolean MappedDisplayScalar

  MappedDisplayScalar is true if any RealType component is mapped to any DisplayRealType-s, including via a RealTupleType.Reference

### isTerminal

    boolean isTerminal

  information calculated by checkIndices & testIndices

### LevelOfDifficulty

    int LevelOfDifficulty

### isTextureMap

    boolean isTextureMap

### curvedTexture

    boolean curvedTexture

### isTexture3D

    boolean isTexture3D

### isLinearContour3D

    boolean isLinearContour3D

### adjustProjectionSeam

    boolean adjustProjectionSeam

### Dtype

    int Dtype

  Dtype and Rtype used only with ShadowSetType and Flat ShadowFunctionType

### Rtype

    int Rtype

### D0

    static final int D0

  possible values for Dtype

  See Also:
    Constant Field Values

### D1

    static final int D1

See Also:
  Constant Field Values

### D2

    static final int D2

See Also:
  Constant Field Values

### D3

    static final int D3

See Also:
  Constant Field Values

### D4

    static final int D4

See Also:
  Constant Field Values

### Dbad

    static final int Dbad

See Also:
  Constant Field Values

### R0

    static final int R0

  possible values for Rtype

  See Also:
    Constant Field Values

### R1

    static final int R1

See Also:
  Constant Field Values

### R2

    static final int R2

See Also:
  Constant Field Values

### R3

    static final int R3

See Also:
  Constant Field Values

### R4

    static final int R4

See Also:
  Constant Field Values

### Rbad

    static final int Rbad

See Also:
  Constant Field Values

### spatialTuple

    DisplayTupleType spatialTuple

  spatial DisplayTupleType at terminal nodes

### spatialDimension

    int spatialDimension

  number of spatial DisplayRealType components at terminal nodes

### anyContour

    boolean anyContour

  flags for any IsoContour or Flow at terminal nodes

### anyFlow

    boolean anyFlow

### anyShape

    boolean anyShape

### anyText

    boolean anyText

### streamline1

    boolean streamline1

  streamline flags

### streamline2

    boolean streamline2

### streamlineDensity1

    float streamlineDensity1

### streamlineDensity2

    float streamlineDensity2

### arrowScale1

    float arrowScale1

### arrowScale2

    float arrowScale2

### stepFactor1

    float stepFactor1

### stepFactor2

    float stepFactor2

### packingFactor1

    float packingFactor1

### packingFactor2

    float packingFactor2

### cntrWeight1

    float cntrWeight1

### cntrWeight2

    float cntrWeight2

### n_pass1

    int n_pass1

### n_pass2

    int n_pass2

### reduction1

    float reduction1

### reduction2

    float reduction2

### cnt

    int[] cnt

  makeContour, manifoldDimension == 2

### p_cntrl

    ProjectionControl p_cntrl

### c_cntrl

    ContourControl c_cntrl

### refToComponent

    int[] refToComponent

  used by getComponents to record RealTupleTypes with coordinate transforms

### componentWithRef

    ShadowRealTupleType[] componentWithRef

### componentIndex

    int[] componentIndex

### METERS_PER_DEGREE

    public static final float METERS_PER_DEGREE

See Also:
  Constant Field Values

Constructor Detail

### ShadowType

    public ShadowType(MathType type,
                      DataDisplayLink link,
                      ShadowType parent)
               throws VisADException,
                      RemoteException

Method Detail

### getLink

    public DataDisplayLink getLink()

### getLevelOfDifficulty

    public int getLevelOfDifficulty()

### getIsTerminal

    public boolean getIsTerminal()

### getIsTextureMap

    public boolean getIsTextureMap()

### getCurvedTexture

    public boolean getCurvedTexture()

### getIsTexture3D

    public boolean getIsTexture3D()

### getIsLinearContour3D

    public boolean getIsLinearContour3D()

### getRefToComponent

    public int[] getRefToComponent()

### getComponentWithRef

    public ShadowRealTupleType[] getComponentWithRef()

### getComponentIndex

    public int[] getComponentIndex()

### getAdjustProjectionSeam

    public boolean getAdjustProjectionSeam()

### getComponents

    public ShadowRealType[] getComponents(ShadowType type,
                                          boolean doRef)
                                   throws VisADException

  Throws:
    `VisADException`

### getData

    public Data getData()

### getAdaptedShadowType

    public ShadowType getAdaptedShadowType()

### zeroIndices

    static int[] zeroIndices(int length)

  create a zero'd array of indices (for each RealType or each DisplayRealType)

### copyIndices

    static int[] copyIndices(int[] indices)

  copy an array of indices (for each RealType or each DisplayRealType)

### addIndices

    static int[] addIndices(int[] indices,
                            int[] indices2)
                     throws VisADException

  add arrays of indices (for each RealType or each DisplayRealType)

  Throws:
    `VisADException`

### getAnyContour

    public boolean getAnyContour()

### getAnyFlow

    public boolean getAnyFlow()

### getAnyShape

    public boolean getAnyShape()

### getAnyText

    public boolean getAnyText()

### checkNested

    boolean checkNested(int[] display_indices)
                  throws RemoteException

  test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Animation, Range, Value, Flow, Text, Unmapped)

  Throws:
    `RemoteException`

### checkR4

    boolean checkR4(int[] display_indices)
              throws RemoteException

  test for display_indices in (Spatial, SpatialOffset, IsoContour, Color, Alpha, Flow, Text, Range, Unmapped)

  Throws:
    `RemoteException`

### checkR3

    boolean checkR3(int[] display_indices)
              throws RemoteException

  test for display_indices in (IsoContour, Color, Alpha, Flow, Text, Range, Unmapped)

  Throws:
    `RemoteException`

### checkR1D3

    boolean checkR1D3(int[] display_indices)
                throws RemoteException

  test for display_indices in (Color, Alpha, Range, Flow, Shape, ShapeScale, Text, Unmapped)

  Throws:
    `RemoteException`

### checkColorRange

    boolean checkColorRange(int[] display_indices)
                      throws RemoteException

  test for display_indices in (Color, Range, Unmapped)

  Throws:
    `RemoteException`

### checkColorAlphaRange

    boolean checkColorAlphaRange(int[] display_indices)
                           throws RemoteException

  test for display_indices in (Color, Alpha, Range, Unmapped)

  Throws:
    `RemoteException`

### checkContourColorAlphaRange

    boolean checkContourColorAlphaRange(int[] display_indices)
                                  throws RemoteException

  test for display_indices in (IsoContour, Color, Alpha, Range, Unmapped)

  Throws:
    `RemoteException`

### checkR2D2

    boolean checkR2D2(int[] display_indices)
                throws RemoteException

  test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Range, Flow, Shape, ShapeScale, Text, Unmapped)

  Throws:
    `RemoteException`

### checkSpatialOffsetColorAlphaRange

    boolean checkSpatialOffsetColorAlphaRange(int[] display_indices)
                                        throws RemoteException

  test for display_indices in (Spatial, SpatialOffset, Color, Alpha, Range, Unmapped)

  Throws:
    `RemoteException`

### checkSpatialColorAlphaRange

    boolean checkSpatialColorAlphaRange(int[] display_indices)
                                  throws RemoteException

  test for display_indices in (Spatial, Color, Alpha, Range, Unmapped)

  Throws:
    `RemoteException`

### checkSpatialRange

    boolean checkSpatialRange(int[] display_indices)
                        throws RemoteException

  test for display_indices in (Spatial, Range, Unmapped)

  Throws:
    `RemoteException`

### checkAnimationOrValue

    int checkAnimationOrValue(int[] display_indices)
                        throws RemoteException

  test for any Animation or Value in display_indices

  Throws:
    `RemoteException`

### anyRange

    boolean anyRange(int[] display_indices)
               throws RemoteException

  test for any SelectRange in display_indices

  Throws:
    `RemoteException`

### checkContour

    boolean checkContour(int[] display_indices)
                   throws RemoteException

  test for any IsoContour in display_indices

  Throws:
    `RemoteException`

### checkFlow

    boolean checkFlow(int[] display_indices)
                throws RemoteException

  test for any Flow in display_indices

  Throws:
    `RemoteException`

### checkShape

    boolean checkShape(int[] display_indices)
                 throws RemoteException

  test for any Shape in display_indices

  Throws:
    `RemoteException`

### checkText

    boolean checkText(int[] display_indices)
                throws RemoteException

  test for any Text in display_indices

  Throws:
    `RemoteException`

### checkAdjustProjectionSeam

    boolean checkAdjustProjectionSeam()
                                throws RemoteException

  Throws:
    `RemoteException`

### checkColor

    boolean checkColor(int[] display_indices)
                 throws RemoteException

  test for display_indices in (Color, Unmapped)

  Throws:
    `RemoteException`

### checkColorOrAlpha

    boolean checkColorOrAlpha(int[] display_indices)
                        throws RemoteException

  test for display_indices in (Color, Alpha, Unmapped)

  Throws:
    `RemoteException`

### checkAny

    boolean checkAny(int[] display_indices)
               throws RemoteException

  test for any non-zero display_indices

  Throws:
    `RemoteException`

### testIndices

    int testIndices(int[] indices,
                    int[] display_indices,
                    int levelOfDifficulty)
              throws VisADException,
                     RemoteException

  applied at terminal nodes

  Throws:
    `VisADException`
    `RemoteException`

### checkIndices

    public int checkIndices(int[] indices,
                            int[] display_indices,
                            int[] value_indices,
                            boolean[] isTransform,
                            int levelOfDifficulty)
                     throws VisADException,
                            RemoteException

  scans ShadowType tree to determine display feasibility and precompute useful information for Data transform; indices & display_indices are counts (at leaves) of numbers of occurrences of RealTypes and DisplayRealTypes; isTransform flags for (Animation, Range, Value) re-transform; levelOfDifficulty passed down and up call chain

  Throws:
    `VisADException`
    `RemoteException`

### getDisplay

    public DisplayImpl getDisplay()

### getType

    public MathType getType()

### getMultipleDisplayScalar

    public boolean getMultipleDisplayScalar()

### getMultipleSpatialDisplayScalar

    public boolean getMultipleSpatialDisplayScalar()

### getMappedDisplayScalar

    public boolean getMappedDisplayScalar()

### getDisplayIndices

    public int[] getDisplayIndices()

### getValueIndices

    public int[] getValueIndices()

### testTransform

    boolean testTransform()

  return true if DisplayIndices include multiple Animation, SelectValue and SelectRange

### markTransform

    void markTransform(boolean[] isTransform)

  mark Control-s as needing re-Transform; default for ShadowTextType and ShadowMissingType

### mapValues

    public static void mapValues(float[][] display_values,
                                 double[][] values,
                                 ShadowRealType[] reals)
                          throws VisADException

  map values to display_values according to ScalarMap-s in reals

  Throws:
    `VisADException`

### mapValues

    public static void mapValues(float[][] display_values,
                                 float[][] values,
                                 ShadowRealType[] reals)
                          throws VisADException

  map values into display_values according to ScalarMap-s in reals

  Throws:
    `VisADException`

### mapValues

    public static void mapValues(float[][] display_values,
                                 float[][] values,
                                 ShadowRealType[] reals,
                                 boolean copy)
                          throws VisADException

  Map values into display_values according to ScalarMap-s in reals

  Parameters:
    `display_values` - return display values
    `values` - data values
    `reals` - the ShadowRealTypes corresponding to the Scalar in maps
    `copy` - if false, scale values in place if reals[index] has only one mapping. Use true if values represent a getSamples(false) or getFloats(false)
  Throws:
    `VisADException`

### makePointGeometry

    public static VisADGeometryArray makePointGeometry(float[][] spatial_values,
                                                       byte[][] color_values)
                                                throws VisADException

  Throws:
    `VisADException`

### makePointGeometry

    public static VisADGeometryArray makePointGeometry(float[][] spatial_values,
                                                       byte[][] color_values,
                                                       boolean compress)
                                                throws VisADException

  Throws:
    `VisADException`

### assembleShape

    public VisADGeometryArray[] assembleShape(float[][] display_values,
                                              int valueArrayLength,
                                              int[] valueToMap,
                                              Vector MapVector,
                                              int[] valueToScalar,
                                              DisplayImpl display,
                                              float[] default_values,
                                              int[] inherited_values,
                                              float[][] spatial_values,
                                              byte[][] color_values,
                                              boolean[][] range_select,
                                              int index,
                                              ShadowType shadow_api)
                                       throws VisADException,
                                              RemoteException

  collect and transform Shape DisplayRealType values from display_values; offset by spatial_values, colored by color_values and selected by range_select

  Throws:
    `VisADException`
    `RemoteException`

### assembleSpatial

    public Set assembleSpatial(float[][] spatial_values,
                               float[][] display_values,
                               int valueArrayLength,
                               int[] valueToScalar,
                               DisplayImpl display,
                               float[] default_values,
                               int[] inherited_values,
                               Set domain_set,
                               boolean allSpatial,
                               boolean set_for_shape,
                               int[] spatialDimensions,
                               boolean[][] range_select,
                               float[][] flow1_values,
                               float[][] flow2_values,
                               float[] flowScale,
                               boolean[] swap,
                               DataRenderer renderer,
                               ShadowType shadow_api)
                        throws VisADException,
                               RemoteException

  collect and transform spatial DisplayRealType values from display_values; add spatial offset DisplayRealType values; adjust flow1_values and flow2_values for any coordinate transform; if needed, return a spatial Set from spatial_values, with the same topology as domain_set (or an appropriate Irregular topology); domain_set = null and allSpatial = false if not called from ShadowFunctionType

  Throws:
    `VisADException`
    `RemoteException`

### makeSpatialSet

    public Set makeSpatialSet(Set domain_set,
                              SetType type,
                              float[][] spatial_values)
                       throws VisADException

  Throws:
    `VisADException`

### assembleFlow

    public void assembleFlow(float[][] flow1_values,
                             float[][] flow2_values,
                             float[] flowScale,
                             float[][] display_values,
                             int valueArrayLength,
                             int[] valueToScalar,
                             DisplayImpl display,
                             float[] default_values,
                             boolean[][] range_select,
                             DataRenderer renderer,
                             ShadowType shadow_api)
                      throws VisADException,
                             RemoteException

  assemble Flow components; Flow components are 'single', so no compositing is required

  Throws:
    `VisADException`
    `RemoteException`

### adjustFlowToEarth

    public static float[][] adjustFlowToEarth(int which,
                                              float[][] flow_values,
                                              float[][] spatial_values,
                                              float flowScale,
                                              DataRenderer renderer)
                                       throws VisADException

  Throws:
    `VisADException`

### makeStreamline

    public VisADGeometryArray[] makeStreamline(int which,
                                               float[][] flow_values,
                                               float flowScale,
                                               float[][] spatial_values,
                                               Set spatial_set,
                                               int spatialManifoldDimension,
                                               byte[][] color_values,
                                               boolean[][] range_select,
                                               int valueArrayLength,
                                               int[] valueToMap,
                                               Vector MapVector)
                                        throws VisADException

  Throws:
    `VisADException`

### makeFlow

    public VisADGeometryArray[] makeFlow(int which,
                                         float[][] flow_values,
                                         float flowScale,
                                         float[][] spatial_values,
                                         byte[][] color_values,
                                         boolean[][] range_select)
                                  throws VisADException

  which = 0 for Flow1 and which = 1 for Flow2

  Throws:
    `VisADException`

### rotateVectors

    static void rotateVectors(double[] base,
                              double[] up,
                              double rotationDegrees)

  abcd - 2 February 2001 Rotate the base and up vectors Rotation is in degrees clockwise from positive X axis

### makeText

    public VisADGeometryArray makeText(String[] text_values,
                                       TextControl text_control,
                                       float[][] spatial_values,
                                       byte[][] color_values,
                                       boolean[][] range_select)
                                throws VisADException

  Throws:
    `VisADException`

### assembleColor

    public byte[][] assembleColor(float[][] display_values,
                                  int valueArrayLength,
                                  int[] valueToScalar,
                                  DisplayImpl display,
                                  float[] default_values,
                                  boolean[][] range_select,
                                  boolean[] single_missing,
                                  ShadowType shadow_api)
                           throws VisADException,
                                  RemoteException

  composite and transform color and Alpha DisplayRealType values from display_values, and return as (Red, Green, Blue, Alpha)

  Throws:
    `VisADException`
    `RemoteException`

### byteToFloat

    public static final float byteToFloat(byte b)

### floatToByte

    public static final byte floatToByte(float f)

### colorSum

    static void colorSum(int nindex,
                         float[][] tuple_values,
                         float[] tuple_value_counts,
                         float[] tuple_singles,
                         float[] tuple_single_counts,
                         DisplayImpl display,
                         DisplayTupleType tuple,
                         float[] default_values)
                  throws VisADException

  Throws:
    `VisADException`

### getDefaultColorIndex

    public static int getDefaultColorIndex(DisplayImpl display,
                                           int index)

### equalizeAndDefault

    static void equalizeAndDefault(float[][] tuple_values,
                                   DisplayImpl display,
                                   DisplayTupleType tuple,
                                   float[] default_values)
                            throws VisADException

  equalize lengths and fill with default values

  Throws:
    `VisADException`

### colorComposite

    static void colorComposite(float[][] rgba_values,
                               float[] rgba_value_counts,
                               float[][] tuple_values)
                        throws VisADException

  composite tuple_values into rgba_values and rgba_value_counts, for index = 0, 1, 2

  Throws:
    `VisADException`

### singleComposite

    static void singleComposite(int index,
                                float[][] rgba_values,
                                float[] rgba_value_counts,
                                float[] values)
                         throws VisADException

  composite values into rgba_values[index] and rgba_value_counts[index]

  Throws:
    `VisADException`

### assembleSelect

    public boolean[][] assembleSelect(float[][] display_values,
                                      int domain_length,
                                      int valueArrayLength,
                                      int[] valueToScalar,
                                      DisplayImpl display,
                                      ShadowType shadow_api)
                               throws VisADException

  return a composite of SelectRange DisplayRealType values from display_values, as 0.0 for select and Double.Nan for no select (these values can be added to other DisplayRealType values)

  Throws:
    `VisADException`

### terminalTupleOrScalar

    public boolean terminalTupleOrScalar(Object group,
                                         float[][] display_values,
                                         String text_value,
                                         TextControl text_control,
                                         int valueArrayLength,
                                         int[] valueToScalar,
                                         float[] default_values,
                                         int[] inherited_values,
                                         DataRenderer renderer,
                                         ShadowType shadow_api)
                                  throws VisADException,
                                         RemoteException

  transform data into a (Java3D or Java2D) scene graph; add generated scene graph components as children of group; group is Group (Java3D) or VisADGroup (Java2D); value_array are inherited valueArray values; default_values are defaults for each display.DisplayRealTypeVector; return true if need post-process

  Throws:
    `VisADException`
    `RemoteException`

### makeContour

    public boolean 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)
                        throws VisADException

  Throws:
    `VisADException`

### textureWidth

    public int textureWidth(int data_width)

### textureHeight

    public int textureHeight(int data_height)

### textureDepth

    public int textureDepth(int data_depth)

### adjustZ

    public void adjustZ(float[] coordinates)

### setTexCoords

    public void setTexCoords(float[] texCoords,
                             float ratiow,
                             float ratioh)

### setTex3DCoords

    public float[] setTex3DCoords(int length,
                                  int axis,
                                  float ratiow,
                                  float ratioh,
                                  float ratiod)

### setTexStackCoords

    public float[] setTexStackCoords(int length,
                                     int axis,
                                     float ratiow,
                                     float ratioh,
                                     float ratiod)

### getTextMaps

    public Vector getTextMaps(int i,
                              int[] textIndices)

### addToGroup

    public boolean addToGroup(Object group,
                              VisADGeometryArray array,
                              GraphicsModeControl mode,
                              float constant_alpha,
                              float[] constant_color)
                       throws VisADException

  Throws:
    `VisADException`

### addLabelsToGroup

    public void addLabelsToGroup(Object group,
                                 VisADGeometryArray[][] arrays,
                                 GraphicsModeControl mode,
                                 ContourControl control,
                                 ProjectionControl p_cntrl,
                                 int[] cnt,
                                 float constant_alpha,
                                 float[] contstant_color,
                                 float[][][] f_array)
                          throws VisADException

  Throws:
    `VisADException`

### addTextToGroup

    public boolean addTextToGroup(Object group,
                                  VisADGeometryArray array,
                                  GraphicsModeControl mode,
                                  float constant_alpha,
                                  float[] constant_color)
                           throws VisADException

  Throws:
    `VisADException`

### textureToGroup

    public void textureToGroup(Object group,
                               VisADGeometryArray array,
                               BufferedImage image,
                               GraphicsModeControl mode,
                               float constant_alpha,
                               float[] constant_color,
                               int texture_width,
                               int texture_height)
                        throws VisADException

  Throws:
    `VisADException`

### texture3DToGroup

    public void texture3DToGroup(Object group,
                                 VisADGeometryArray arrayX,
                                 VisADGeometryArray arrayY,
                                 VisADGeometryArray arrayZ,
                                 VisADGeometryArray arrayXrev,
                                 VisADGeometryArray arrayYrev,
                                 VisADGeometryArray arrayZrev,
                                 BufferedImage[] images,
                                 GraphicsModeControl mode,
                                 float constant_alpha,
                                 float[] constant_color,
                                 int texture_width,
                                 int texture_height,
                                 int texture_depth,
                                 DataRenderer renderer)
                          throws VisADException

  Throws:
    `VisADException`

### textureStackToGroup

    public void textureStackToGroup(Object group,
                                    VisADGeometryArray arrayX,
                                    VisADGeometryArray arrayY,
                                    VisADGeometryArray arrayZ,
                                    VisADGeometryArray arrayXrev,
                                    VisADGeometryArray arrayYrev,
                                    VisADGeometryArray arrayZrev,
                                    BufferedImage[] imagesX,
                                    BufferedImage[] imagesY,
                                    BufferedImage[] imagesZ,
                                    GraphicsModeControl mode,
                                    float constant_alpha,
                                    float[] constant_color,
                                    int texture_width,
                                    int texture_height,
                                    int texture_depth,
                                    DataRenderer renderer)
                             throws VisADException

  Throws:
    `VisADException`

### makeSwitch

    public Object makeSwitch()

### makeBranch

    public Object makeBranch()

### addToGroup

    public void addToGroup(Object group,
                           Object branch)
                    throws VisADException

  Throws:
    `VisADException`

### addToSwitch

    public void addToSwitch(Object swit,
                            Object branch)
                     throws VisADException

  Throws:
    `VisADException`

### addSwitch

    public void addSwitch(Object group,
                          Object swit,
                          Control control,
                          Set domain_set,
                          DataRenderer renderer)
                   throws VisADException

  Throws:
    `VisADException`

### recurseRange

    public boolean recurseRange(Object group,
                                Data data,
                                float[] value_array,
                                float[] default_values,
                                DataRenderer renderer)
                         throws VisADException,
                                RemoteException

  Throws:
    `VisADException`
    `RemoteException`

### recurseComponent

    public boolean recurseComponent(int i,
                                    Object group,
                                    Data data,
                                    float[] value_array,
                                    float[] default_values,
                                    DataRenderer renderer)
                             throws VisADException,
                                    RemoteException

  Throws:
    `VisADException`
    `RemoteException`

### wantIndexed

    public boolean wantIndexed()

### getParentTextControl

    public TextControl getParentTextControl()

### getParentText

    public String getParentText()

### setText

    public void setText(String text,
                        TextControl control)

### allowCurvedTexture

    public boolean allowCurvedTexture()

### allowConstantColorSurfaces

    public boolean allowConstantColorSurfaces()

### allowLinearContour

    public boolean allowLinearContour()

### toString

    public String toString()