java.lang.Object
- gov.nih.mipav.view.renderer.J3D.volumeview.Renderer
- - gov.nih.mipav.view.renderer.J3D.volumeview.ShearWarpRenderer

Direct Known Subclasses:

ShearWarpColor, ShearWarpIntensity
```
public abstract class ShearWarpRenderer
extends Renderer
```
The base class renderer to support shear-warp rendering. See the document ShearWarpRendering.pdf for a detailed description of the renderer architecture.

Field Summary

Fields
Modifier and Type	Field	Description
`protected short[][][][]`	`m_aaaasEncode`	encoding of voxels based on transparent runs.
`protected short[][][]`	`m_aaasVolumeEncode`	DOCUMENT ME!
`protected float[][]`	`m_aafBox`	DOCUMENT ME!
`protected float[][]`	`m_aafM`	DOCUMENT ME!
`protected int[][]`	`m_aaiIndex`	permutations that just store voxel indices.
`protected short[][]`	`m_aasSliceEncode`	DOCUMENT ME!
`protected float[]`	`m_afA`	DOCUMENT ME!
`protected float[]`	`m_afB`	DOCUMENT ME!
`protected float[]`	`m_afOffset`	for resampling a slice.
`protected float[]`	`m_afShear`	for resampling a slice.
`protected int[]`	`m_aiBound`	Parallel viewing model.
`protected int[]`	`m_aiClipMax`	for clipping.
`protected int[]`	`m_aiClipMin`	for clipping.
`protected int[]`	`m_aiCurrentI`	DOCUMENT ME!
`protected int[]`	`m_aiInterC`	intermediate image indicating that the number of times each pixels is processed.
`protected int[]`	`m_aiSliceBound`	DOCUMENT ME!
`protected int[]`	`m_aiSliceMax`	DOCUMENT ME!
`protected int[]`	`m_aiSliceMin`	DOCUMENT ME!
`protected short[]`	`m_asSkip`	support for skipping opaque intermediate pixels.
`protected boolean`	`m_bDoEncodeSkip`	flag set by derived class that uses encoding and skipping.
`protected float`	`m_fInv255`	DOCUMENT ME!
`protected int`	`m_iI0`	Temporary quantities used in the inner loop of resampleSingle().
`protected int`	`m_iInterBound`	intermediate 2D image supporting quantities.
`protected int`	`m_iInterBoundM1`	intermediate 2D image supporting quantities.
`protected int`	`m_iInterIndex`	Temporary quantities used in the inner loop of resampleSingle().
`protected int`	`m_iInterOffset`	DOCUMENT ME!
`protected int`	`m_iInterQuantity`	intermediate 2D image supporting quantities.
`protected int`	`m_iPermute`	the current permutation of the voxel indices (0, 1, or 2).
`protected int`	`m_iPixel`	Temporary quantities used in the inner loop of resampleSingle().
`protected int`	`m_iQuantity`	Parallel viewing model.
`protected int`	`m_iSIndex`	Temporary quantities used in the inner loop of resampleSingle().
`protected int`	`m_iSlice`	DOCUMENT ME!
`protected int`	`m_iSliceQuantity`	DOCUMENT ME!
`protected javax.vecmath.Point3f`	`m_kP00`	To avoid memory reallocations.
`protected javax.vecmath.Point3f`	`m_kP01`	DOCUMENT ME!
`protected javax.vecmath.Point3f`	`m_kP10`	DOCUMENT ME!
`protected javax.vecmath.Point3f`	`m_kP11`	DOCUMENT ME!
`protected javax.vecmath.Point3f`	`m_kPosition`	DOCUMENT ME!

Fields inherited from class gov.nih.mipav.view.renderer.J3D.volumeview.Renderer
m_aiRImage, m_akAxis, m_akNormal, m_bParallel, m_bReloadInput, m_fAngle, m_fExtreme, m_fFMult, m_fGamma, m_fNear, m_fRScaleX, m_fRScaleY, m_fXTrn, m_fYTrn, m_fZoom, m_iMaxBound, m_iMinBound, m_iRBound, m_iXBound, m_iXBoundM1, m_iXBoundM2, m_iXYProduct, m_iXYZProduct, m_iYBound, m_iYBoundM1, m_iYBoundM2, m_iZBound, m_iZBoundM1, m_iZBoundM2, m_kBackgroundColor, m_kEyeModel, m_kEyeWorld, m_kImage, m_kLightSet, m_kMaterial, m_kRotate

Constructor Summary

Constructors
Constructor Description

ShearWarpRenderer(ModelImage kImage, int iRBound, int[] aiRImage)
Create a renderer.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`beforeResampleAll(int k0, int k1, int k2)`	This is a callback to be executed before resampleAll is executed.
`protected void`	`beforeResampleSingle()`	This is a callback to be executed before resampleSingle is executed.
`void`	`composite(int iDS)`	The top level rendering call.
`protected void`	`computeEncode(int k0, int k1, int k2, byte[] acChannel)`	Calculate the encoding table for the specified permutation.
`protected void`	`computePositions(int i0, int i1, int i2)`	Compute the vertex positions for the four voxels in the current slice to be bilinearly interpolated.
`void`	`disposeLocal()`	Disposes of image memory and associated objects.
`protected void`	`finalize()`	Calls disposeLocal of this class to ensure this class nulls the references to global class variables so that memory will be recovered.
`protected static byte`	`fromFloat(float fValue)`	Convert a 32-bit float to a 'byte' that represents an unsigned 8-bit integer (uint8).
`protected static byte`	`fromInt(int iValue)`	Convert a 32-bit integer (int32) to a 'byte' that represents an unsigned 8-bit integer (uint8).
`javax.vecmath.Vector3f`	`getAxis(int i)`	Read the current axis at index i.
`void`	`getAxis(int i, javax.vecmath.Vector3f kAxis)`	Read the current axis at index i.
`protected void`	`initializeEncodeSkip(byte[] acChannel)`	Calculate the encoding of the specified channel.
`protected abstract void`	`mapIntermediateToFinal()`	Map the intermediate images to the final color image.
`protected void`	`resampleAll(int iDS)`	Resample all the slices for the current permuted volume data.
`protected void`	`resampleSingle()`	Resample a single slice of the permuted volume data.
`void`	`rotateBy(javax.vecmath.AxisAngle4f kAxisAngle)`	Rotate the oriented bounding box of the 3D image about the specified axis with the specified angle.
`void`	`rotateFrameBy(javax.media.j3d.Transform3D transform)`	Rotate the oriented bounding box of the 3D image about the specified axis with the specified angle.
`void`	`setAxis(int i, javax.vecmath.Vector3f kAxis)`	Change an axis of the oriented bounding box of the 3D image.
`void`	`setParallel(boolean bParallel)`	Change the camera model.
`void`	`setXBoundNeg(float value)`	Setup the X Negative clipping plane position.
`void`	`setXBoundPos(float value)`	Setup the X positive clipping plane position.
`void`	`setYBoundNeg(float value)`	Setup the Y Negative clipping plane position.
`void`	`setYBoundPos(float value)`	Setup the Y positive clipping plane position.
`void`	`setZBoundNeg(float value)`	Setup the Z negative clipping plane position.
`void`	`setZBoundPos(float value)`	Setup the Z positive clipping plane position.
`protected boolean`	`skipToNonopaque(int i1, short[] asIndex)`	An array is maintained that keeps track of opaque intermediate pixels during the resampling phase.
`protected static float`	`toFloat(byte cValue)`	Convert a 'byte' that represents an unsigned 8-bit integer (uint8) to a 32-bit float.
`protected static int`	`toInt(byte cValue)`	Convert a 'byte' that represents an unsigned 8-bit integer (uint8) to a signed 32-bit integer (int32).
`protected void`	`updateSkip()`	After the compositing step in resampleSingle, the intensity (for gray scale) or alpha value (for color) might become its maximum value.

Methods inherited from class gov.nih.mipav.view.renderer.J3D.volumeview.Renderer
computeIntegralNormalizationFactor, convertWorldToModel, getAngle, getBackgroundColor, getExtreme, getEyeDist, getEyePoint, getGamma, getMaxBound, getMinBound, getNear, getParallel, getXBound, getXTranslate, getYBound, getYTranslate, getZBound, getZoom, hasInputData, hasNormals, orthonormalize, reloadInputData, reloadInputData, setAngle, setBackgroundColor, setExtreme, setEyeDist, setGamma, setLighting, setMaterialShininess, setNear, setNearAndAngle, setNormals, setXTranslate, setYTranslate, setZoom, traceInit, usesNormals

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

- Field Detail
  - m_aaaasEncode
```
protected short[][][][] m_aaaasEncode
```
    encoding of voxels based on transparent runs.
  - m_aaasVolumeEncode
```
protected short[][][] m_aaasVolumeEncode
```
    DOCUMENT ME!
  - m_aafBox
```
protected float[][] m_aafBox
```
    DOCUMENT ME!
  - m_aafM
```
protected float[][] m_aafM
```
    DOCUMENT ME!
  - m_aaiIndex
```
protected int[][] m_aaiIndex
```
    permutations that just store voxel indices.
  - m_aasSliceEncode
```
protected short[][] m_aasSliceEncode
```
    DOCUMENT ME!
  - m_afA
```
protected float[] m_afA
```
    DOCUMENT ME!
  - m_afB
```
protected float[] m_afB
```
    DOCUMENT ME!
  - m_afShear
```
protected float[] m_afShear
```
    for resampling a slice.
  - m_afOffset
```
protected float[] m_afOffset
```
    for resampling a slice.
  - m_aiBound
```
protected int[] m_aiBound
```
    Parallel viewing model. Camera direction is always (0,0,1). The volume image and bounding box axes, center at origin, columns are direction, up, right. The matrix m_aafM[][] is for inverse warping.
  - m_iQuantity
```
protected int m_iQuantity
```
    Parallel viewing model. Camera direction is always (0,0,1). The volume image and bounding box axes, center at origin, columns are direction, up, right. The matrix m_aafM[][] is for inverse warping.
  - m_aiClipMin
```
protected int[] m_aiClipMin
```
    for clipping.
  - m_aiClipMax
```
protected int[] m_aiClipMax
```
    for clipping.
  - m_aiCurrentI
```
protected int[] m_aiCurrentI
```
    DOCUMENT ME!
  - m_aiInterC
```
protected int[] m_aiInterC
```
    intermediate image indicating that the number of times each pixels is processed.
  - m_aiSliceBound
```
protected int[] m_aiSliceBound
```
    DOCUMENT ME!
  - m_aiSliceMin
```
protected int[] m_aiSliceMin
```
    DOCUMENT ME!
  - m_aiSliceMax
```
protected int[] m_aiSliceMax
```
    DOCUMENT ME!
  - m_asSkip
```
protected short[] m_asSkip
```
    support for skipping opaque intermediate pixels.
  - m_bDoEncodeSkip
```
protected boolean m_bDoEncodeSkip
```
    flag set by derived class that uses encoding and skipping.
  - m_fInv255
```
protected float m_fInv255
```
    DOCUMENT ME!
  - m_iI0
```
protected int m_iI0
```
    Temporary quantities used in the inner loop of resampleSingle(). These exist since Java does not allow you to pass references to variables to allow more than one to change on return from a function call.
  - m_iSIndex
```
protected int m_iSIndex
```
    Temporary quantities used in the inner loop of resampleSingle(). These exist since Java does not allow you to pass references to variables to allow more than one to change on return from a function call.
  - m_iInterIndex
```
protected int m_iInterIndex
```
    Temporary quantities used in the inner loop of resampleSingle(). These exist since Java does not allow you to pass references to variables to allow more than one to change on return from a function call.
  - m_iPixel
```
protected int m_iPixel
```
    Temporary quantities used in the inner loop of resampleSingle(). These exist since Java does not allow you to pass references to variables to allow more than one to change on return from a function call.
  - m_iInterBound
```
protected int m_iInterBound
```
    intermediate 2D image supporting quantities.
  - m_iInterBoundM1
```
protected int m_iInterBoundM1
```
    intermediate 2D image supporting quantities.
  - m_iInterQuantity
```
protected int m_iInterQuantity
```
    intermediate 2D image supporting quantities.
  - m_iInterOffset
```
protected int m_iInterOffset
```
    DOCUMENT ME!
  - m_iPermute
```
protected int m_iPermute
```
    the current permutation of the voxel indices (0, 1, or 2).
  - m_iSliceQuantity
```
protected int m_iSliceQuantity
```
    DOCUMENT ME!
  - m_iSlice
```
protected int m_iSlice
```
    DOCUMENT ME!
  - m_kP00
```
protected javax.vecmath.Point3f m_kP00
```
    To avoid memory reallocations. These are used in the bilinearly interpolation of a 2x2 block of voxels in the current slice. The Pij are vertex positions. The MatColorij are the material colors of the voxels. The Cij are the final dynamically lit colors of the voxels.
  - m_kP01
```
protected javax.vecmath.Point3f m_kP01
```
    DOCUMENT ME!
  - m_kP10
```
protected javax.vecmath.Point3f m_kP10
```
    DOCUMENT ME!
  - m_kP11
```
protected javax.vecmath.Point3f m_kP11
```
    DOCUMENT ME!
  - m_kPosition
```
protected javax.vecmath.Point3f m_kPosition
```
    DOCUMENT ME!
- Constructor Detail
  - ShearWarpRenderer
```
public ShearWarpRenderer(ModelImage kImage,
                         int iRBound,
                         int[] aiRImage)
```
    Create a renderer.
    
    Parameters:
    
    kImage - the 3D image
    
    iRBound - the dimension of the square 2D renderer image
    
    aiRImage - The rendered image data stored in row-major order. Each integer pixel represents an RGB color in the format B | (G .
- Method Detail
  - composite
```
public void composite(int iDS)
```
    The top level rendering call. This function calls beforeResampleAll, resampleAll, and mapIntermediateToFinal, all virtual functions that are implemented in derived classes.
    
    Parameters:
    
    iDS - The number of slices to increment during the resampling phase. The value should be one or larger. If one, all slices of the volume data are resampled. If two, only every other slice is resampled. An input larger than one is used to allow fast rendering during rotation of the volume data. Once the rotation terminates, a composite with input of one should be called.
  - disposeLocal
```
public void disposeLocal()
```
    Disposes of image memory and associated objects.
    
    Overrides:
    
    disposeLocal in class Renderer
  - getAxis
```
public javax.vecmath.Vector3f getAxis(int i)
```
    Read the current axis at index i.
    
    Specified by:
    
    getAxis in class Renderer
    
    Parameters:
    
    i - the axis index (0, 1, or 2)
    
    Returns:
    
    the current axis vector at index i
  - getAxis
```
public void getAxis(int i,
                    javax.vecmath.Vector3f kAxis)
```
    Read the current axis at index i.
    
    Parameters:
    
    i - the axis index (0, 1, or 2)
    
    kAxis - the new axis vector at index i
  - rotateBy
```
public void rotateBy(javax.vecmath.AxisAngle4f kAxisAngle)
```
    Rotate the oriented bounding box of the 3D image about the specified axis with the specified angle.
    
    Specified by:
    
    rotateBy in class Renderer
    
    Parameters:
    
    kAxisAngle - the axis and angle formulation for the rotation
  - rotateFrameBy
```
public void rotateFrameBy(javax.media.j3d.Transform3D transform)
```
    Rotate the oriented bounding box of the 3D image about the specified axis with the specified angle.
    
    Specified by:
    
    rotateFrameBy in class Renderer
    
    Parameters:
    
    transform - The transform and its matrix by which to rotate the image.
  - setAxis
```
public void setAxis(int i,
                    javax.vecmath.Vector3f kAxis)
```
    Change an axis of the oriented bounding box of the 3D image.
    
    Parameters:
    
    i - the axis index (0, 1, or 2)
    
    kAxis - the new axis vector at index i
  - setParallel
```
public void setParallel(boolean bParallel)
```
    Change the camera model.
    
    Overrides:
    
    setParallel in class Renderer
    
    Parameters:
    
    bParallel - true for a parallel camera, false for a perspective camera
  - setXBoundNeg
```
public void setXBoundNeg(float value)
```
    Setup the X Negative clipping plane position.
    
    Specified by:
    
    setXBoundNeg in class Renderer
    
    Parameters:
    
    value - position of the X negative clip slider.
  - setXBoundPos
```
public void setXBoundPos(float value)
```
    Setup the X positive clipping plane position.
    
    Specified by:
    
    setXBoundPos in class Renderer
    
    Parameters:
    
    value - position of the X positive clip slider.
  - setYBoundNeg
```
public void setYBoundNeg(float value)
```
    Setup the Y Negative clipping plane position.
    
    Specified by:
    
    setYBoundNeg in class Renderer
    
    Parameters:
    
    value - position of the Y negative clip slider.
  - setYBoundPos
```
public void setYBoundPos(float value)
```
    Setup the Y positive clipping plane position.
    
    Specified by:
    
    setYBoundPos in class Renderer
    
    Parameters:
    
    value - positin of the Y positve clip slider.
  - setZBoundNeg
```
public void setZBoundNeg(float value)
```
    Setup the Z negative clipping plane position.
    
    Specified by:
    
    setZBoundNeg in class Renderer
    
    Parameters:
    
    value - position of the Z negative clip slider.
  - setZBoundPos
```
public void setZBoundPos(float value)
```
    Setup the Z positive clipping plane position.
    
    Specified by:
    
    setZBoundPos in class Renderer
    
    Parameters:
    
    value - position of the Z positive clip slider.
  - mapIntermediateToFinal
```
protected abstract void mapIntermediateToFinal()
```
    Map the intermediate images to the final color image. This is a stub for derived classes. This function must be implemented in at least one class in a derivation chain in order for that class to be considered non-abstract.
  - fromFloat
```
protected static final byte fromFloat(float fValue)
```
    Convert a 32-bit float to a 'byte' that represents an unsigned 8-bit integer (uint8). This is provided to allow 'byte' to represent a color in [0,255], the latter range not supported by Java since it has no unsigned integer types.
    
    Parameters:
    
    fValue - a float value in [0.0f,256.0f)
    
    Returns:
    
    the corresponding uint8 value
  - fromInt
```
protected static final byte fromInt(int iValue)
```
    Convert a 32-bit integer (int32) to a 'byte' that represents an unsigned 8-bit integer (uint8). This is provided to allow 'byte' to represent a color in [0,255], the latter range not supported by Java since it has no unsigned integer types.
    
    Parameters:
    
    iValue - an int32 value
    
    Returns:
    
    the corresponding uint8 value
  - toFloat
```
protected static final float toFloat(byte cValue)
```
    Convert a 'byte' that represents an unsigned 8-bit integer (uint8) to a 32-bit float. This is provided to allow 'byte' to represent a color in [0,255], the latter range not supported by Java since it has no unsigned integer types.
    
    Parameters:
    
    cValue - a uint8 value
    
    Returns:
    
    the corresponding float value in [0.0f,255.0f]
  - toInt
```
protected static final int toInt(byte cValue)
```
    Convert a 'byte' that represents an unsigned 8-bit integer (uint8) to a signed 32-bit integer (int32). This is provided to allow 'byte' to represent a color in [0,255], the latter range not supported by Java since it has no unsigned integer types.
    
    Parameters:
    
    cValue - a uint8 value
    
    Returns:
    
    the corresponding int32 value
  - beforeResampleAll
```
protected void beforeResampleAll(int k0,
                                 int k1,
                                 int k2)
```
    This is a callback to be executed before resampleAll is executed. The idea is to initialize the necessary parameters needed for the shear warp resampling of the volume data. The actual shear parameters are computed based on the orientation of the bounding box of the volume data. The permuted slice bounds, index set, and encoding table are selected based on the input permutation. The skip array is initialized to zero since before rendering, all intermediate pixels are transparent. Derived classes may provide additional initializations as needed.
    Each one of the indices is a permutation; either one of (0,1,2), (1,2,0), (2,0,1).
    
    Parameters:
    
    k0 - Index to m_aiBound, a value of 0, 1 or 2.
    
    k1 - Index to m_aiBound, a value of 0, 1 or 2.
    
    k2 - Index to m_aiBound, a value of 0, 1 or 2.
  - beforeResampleSingle
```
protected void beforeResampleSingle()
```
    This is a callback to be executed before resampleSingle is executed. The bilinear interpolation coefficients are computed here and vary with the single, active slice. The offset into the intermediate image is also computed since this also varies with the active slice. If encoding of transparent data has occurred in the renderer constructor, then the current slice of the encoding table is initialized for use by resampleSingle.
  - computeEncode
```
protected void computeEncode(int k0,
                             int k1,
                             int k2,
                             byte[] acChannel)
```
    Calculate the encoding table for the specified permutation. See the comments for initializeEncodeSkip. Because bilinear interpolation is used, 2x2 blocks of voxels in the current slice must be analyzed for transparency. The 2x2 block is tagged as non-transparent if and only if at least one of the voxels is non-transparent.
    Each one of the indices is a permutation; either one of (0,1,2), (1,2,0), (2,0,1).
    
    Parameters:
    
    k0 - Index to m_aiBound, a value of 0, 1 or 2.
    
    k1 - Index to m_aiBound, a value of 0, 1 or 2.
    
    k2 - Index to m_aiBound, a value of 0, 1 or 2.
    
    acChannel - The blue channel for intensity renderers or the alpha channel for color renderers.
  - computePositions
```
protected final void computePositions(int i0,
                                      int i1,
                                      int i2)
```
    Compute the vertex positions for the four voxels in the current slice to be bilinearly interpolated.
    
    Parameters:
    
    i0 - the current permuted indices of the upper left voxel in the 2x2 block of voxels in the slice
    
    i1 - DOCUMENT ME!
    
    i2 - DOCUMENT ME!
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Calls disposeLocal of this class to ensure this class nulls the references to global class variables so that memory will be recovered.
    
    Overrides:
    
    finalize in class Renderer
    
    Throws:
    
    java.lang.Throwable - DOCUMENT ME!
  - initializeEncodeSkip
```
protected void initializeEncodeSkip(byte[] acChannel)
```
    Calculate the encoding of the specified channel. The tables calculated by this function is used to skip transparent voxels during the resampling phase. This leads to a significant performance improvement for data sets that have a relatively large number of transparent voxels. Each table corresponds to one of the three permutations of the image indices. The active permutation is determined by the composite function based on the orientation of the bounding box of the volume data.
    
    Parameters:
    
    acChannel - the blue channel for intensity renderers or the alpha channel for color renderers
  - resampleAll
```
protected void resampleAll(int iDS)
```
    Resample all the slices for the current permuted volume data. This is a stub for derived classes. This function must be implemented by at least one class in a derivation chain in order for that class to be considered non-abstract.
    
    Parameters:
    
    iDS - The number of slices to increment during the resampling phase. The value should be one or larger. If one, all slices of the volume data are resampled. If two, only every other slice is resampled. An input larger than one is used to allow fast rendering during rotation of the volume data. Once the rotation terminates, a composite with input of one should be called.
  - resampleSingle
```
protected void resampleSingle()
```
    Resample a single slice of the permuted volume data. This is a stub for derived classes. This function must be implemented in at least one class in a derivation chain in order for that class to be considered non-abstract.
  - skipToNonopaque
```
protected boolean skipToNonopaque(int i1,
                                  short[] asIndex)
```
    An array is maintained that keeps track of opaque intermediate pixels during the resampling phase. Whenever pixels become opaque, they can be skipped if revisited later in the resampling. As runs of pixels become opaque on a scan line, skipping the run can greatly increase the speed of rendering. This function is called in resampleSingle by all the renderer classes taking advantage of opacity skipping.
    
    Parameters:
    
    i1 - the current slice index of the current permuted index set
    
    asIndex - the skip array for the current scan line of the slice
    
    Returns:
    
    The return value is 'true' if and only if there is another nonopaque pixel to be processed. If 'true', then m_iI0, m_iInterIndex, and m_iPixel contain values that are needed for later calculations in resampleSingle. The variable m_iInterIndex stores the offset into the intermediate and skip arrays for the current nonopaque pixel. The variable m_iPixel stores the offset into the volume data for the current nonopaque voxel. The variable m_iI0 is one of the indices for the volume data and is only needed in the MjLightingRenderer class for computing the voxel position from the permuted indices.
  - updateSkip
```
protected void updateSkip()
```
    After the compositing step in resampleSingle, the intensity (for gray scale) or alpha value (for color) might become its maximum value. In this case, the intermediate pixel is opaque. The skip array must be updated so that this pixel is skipped if revisited later.

Class ShearWarpRenderer

Field Summary

Fields inherited from class gov.nih.mipav.view.renderer.J3D.volumeview.Renderer

Constructor Summary

Method Summary

Methods inherited from class gov.nih.mipav.view.renderer.J3D.volumeview.Renderer

Methods inherited from class java.lang.Object

Field Detail

m_aaaasEncode

m_aaasVolumeEncode

m_aafBox

m_aafM

m_aaiIndex

m_aasSliceEncode

m_afA

m_afB

m_afShear

m_afOffset

m_aiBound

m_iQuantity

m_aiClipMin

m_aiClipMax

m_aiCurrentI

m_aiInterC

m_aiSliceBound

m_aiSliceMin

m_aiSliceMax

m_asSkip

m_bDoEncodeSkip

m_fInv255

m_iI0

m_iSIndex

m_iInterIndex

m_iPixel

m_iInterBound

m_iInterBoundM1

m_iInterQuantity

m_iInterOffset

m_iPermute

m_iSliceQuantity

m_iSlice

m_kP00

m_kP01

m_kP10

m_kP11

m_kPosition

Constructor Detail

ShearWarpRenderer

Method Detail

composite

disposeLocal

getAxis

getAxis

rotateBy

rotateFrameBy

setAxis

setParallel

setXBoundNeg

setXBoundPos

setYBoundNeg

setYBoundPos

setZBoundNeg

setZBoundPos

mapIntermediateToFinal

fromFloat

fromInt

toFloat

toInt

beforeResampleAll

beforeResampleSingle

computeEncode

computePositions

finalize

initializeEncodeSkip

resampleAll

resampleSingle

skipToNonopaque

updateSkip