vtkSlicerFixedPointVolumeRayCastHelper.h File Reference

#include "vtkObject.h"
#include "vtkVolumeRenderingReplacements.h"

Go to the source code of this file.

Classes

class  vtkSlicerFixedPointVolumeRayCastHelper

Defines

#define VTKKWRCHelper_CompositeColorAndCheckEarlyTermination(COLOR, TMP, REMAININGOPACITY)
#define VTKKWRCHelper_ComputeWeights(POS)
#define VTKKWRCHelper_CroppingCheckNN(POS)
#define VTKKWRCHelper_CroppingCheckTrilin(POS)
#define VTKKWRCHelper_GetCellComponentDirectionValues(ABCD, EFGH, CIDX)
#define VTKKWRCHelper_GetCellComponentMagnitudeValues(ABCD, EFGH, CIDX)
#define VTKKWRCHelper_GetCellComponentScalarValues(DATA, CIDX, SCALE, SHIFT)
#define VTKKWRCHelper_GetCellDirectionValues(ABCD, EFGH)
#define VTKKWRCHelper_GetCellMagnitudeValues(ABCD, EFGH)
#define VTKKWRCHelper_GetCellScalarValues(DATA, SCALE, SHIFT)
#define VTKKWRCHelper_GetCellScalarValuesSimple(DATA)
#define VTKKWRCHelper_IncrementAndLoopEnd()
#define VTKKWRCHelper_InitializationAndLoopStartGONN()
#define VTKKWRCHelper_InitializationAndLoopStartGOShadeNN()
#define VTKKWRCHelper_InitializationAndLoopStartGOShadeTrilin()
#define VTKKWRCHelper_InitializationAndLoopStartGOTrilin()
#define VTKKWRCHelper_InitializationAndLoopStartNN()
#define VTKKWRCHelper_InitializationAndLoopStartShadeNN()
#define VTKKWRCHelper_InitializationAndLoopStartShadeTrilin()
#define VTKKWRCHelper_InitializationAndLoopStartTrilin()
#define VTKKWRCHelper_InitializeCompositeGONN()   unsigned char *magPtr = gradientMag[spos[2]] + spos[0]*mInc[0] + spos[1]*mInc[1];
#define VTKKWRCHelper_InitializeCompositeMultiGOTrilin()
#define VTKKWRCHelper_InitializeCompositeMultiNN()
#define VTKKWRCHelper_InitializeCompositeMultiShadeTrilin()
#define VTKKWRCHelper_InitializeCompositeMultiTrilin()
#define VTKKWRCHelper_InitializeCompositeOneGOTrilin()
#define VTKKWRCHelper_InitializeCompositeOneNN()
#define VTKKWRCHelper_InitializeCompositeOneShadeTrilin()
#define VTKKWRCHelper_InitializeCompositeOneTrilin()
#define VTKKWRCHelper_InitializeCompositeShadeNN()   unsigned short *dirPtr = gradientDir[spos[2]] + spos[0]*dInc[0] + spos[1]*dInc[1];
#define VTKKWRCHelper_InitializeMIPMultiNN()
#define VTKKWRCHelper_InitializeMIPMultiTrilin()
#define VTKKWRCHelper_InitializeMIPOneNN()
#define VTKKWRCHelper_InitializeMIPOneTrilin()
#define VTKKWRCHelper_InitializeTrilinVariables()
#define VTKKWRCHelper_InitializeTrilinVariablesGO()
#define VTKKWRCHelper_InitializeTrilinVariablesShade()
#define VTKKWRCHelper_InitializeVariables()
#define VTKKWRCHelper_InitializeVariablesGO()
#define VTKKWRCHelper_InitializeVariablesShade()
#define VTKKWRCHelper_InitializeWeights()
#define VTKKWRCHelper_InnerInitialization()
#define VTKKWRCHelper_InterpolateMagnitude(VAL)
#define VTKKWRCHelper_InterpolateMagnitudeComponent(VAL, CIDX, COMPONENTS)
#define VTKKWRCHelper_InterpolateScalar(VAL)
#define VTKKWRCHelper_InterpolateScalarComponent(VAL, CIDX, COMPONENTS)
#define VTKKWRCHelper_InterpolateShading(DTABLE, STABLE, COLOR)
#define VTKKWRCHelper_InterpolateShadingComponent(DTABLE, STABLE, COLOR, CIDX)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOInterpolateShadeUS(COLORTABLE, SOTABLE, GOTABLE,DTABLE, STABLE,SCALAR, MAG, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOShadeUS(COLORTABLE, SOTABLE, GOTABLE,DTABLE, STABLE,SCALAR, MAG, NORMAL, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOUS(COLORTABLE, SOTABLE,GOTABLE,SCALAR, MAG, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsInterpolateShadeUS(COLORTABLE, SOTABLE,DTABLE, STABLE,SCALAR, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsMax(COLORTABLE, SCALAROPACITYTABLE,IDX, WEIGHTS, CMPS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsShadeUS(COLORTABLE, SOTABLE,DTABLE, STABLE,SCALAR, NORMAL, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupAndCombineIndependentColorsUS(COLORTABLE, SOTABLE,SCALAR, WEIGHTS,COMPONENTS, COLOR)
#define VTKKWRCHelper_LookupColorGOUS(CTABLE, SOTABLE, GOTABLE, IDX, IDX2, COLOR)
#define VTKKWRCHelper_LookupColorMax(COLORTABLE, SCALAROPACITYTABLE, IDX, COLOR)
#define VTKKWRCHelper_LookupColorUS(COLORTABLE, SCALAROPACITYTABLE, IDX, COLOR)
#define VTKKWRCHelper_LookupDependentColorUS(COLORTABLE, SCALAROPACITYTABLE, IDX, CMPS, COLOR)
#define VTKKWRCHelper_LookupShading(DTABLE, STABLE, NORMAL, COLOR)
#define VTKKWRCHelper_MIPSpaceLeapCheck(MAXIDX, MAXIDXDEF)
#define VTKKWRCHelper_MIPSpaceLeapCheckMulti(COMP)   mmvalid[COMP]
#define VTKKWRCHelper_MIPSpaceLeapPopulateMulti(MAXIDX)
#define VTKKWRCHelper_MoveToNextSampleGONN()
#define VTKKWRCHelper_MoveToNextSampleGOShadeNN()
#define VTKKWRCHelper_MoveToNextSampleNN()
#define VTKKWRCHelper_MoveToNextSampleShadeNN()
#define VTKKWRCHelper_OuterInitialization()
#define VTKKWRCHelper_SetPixelColor(IMAGEPTR, COLOR, REMAININGOPACITY)
#define VTKKWRCHelper_SpaceLeapCheck()
#define VTKKWRCHelper_SpaceLeapSetup()
#define VTKKWRCHelper_SpaceLeapSetupMulti()

Define Documentation

#define VTKKWRCHelper_CompositeColorAndCheckEarlyTermination ( COLOR,
TMP,
REMAININGOPACITY   ) 
Value:
COLOR[0] += (TMP[0]*REMAININGOPACITY+0x7fff)>>VTKKW_FP_SHIFT;                                 \
  COLOR[1] += (TMP[1]*REMAININGOPACITY+0x7fff)>>VTKKW_FP_SHIFT;                                 \
  COLOR[2] += (TMP[2]*REMAININGOPACITY+0x7fff)>>VTKKW_FP_SHIFT;                                 \
  REMAININGOPACITY = (REMAININGOPACITY*((~(TMP[3])&VTKKW_FP_MASK))+0x7fff)>>VTKKW_FP_SHIFT;     \
  if ( REMAININGOPACITY < 0xff )                                                                \
    {                                                                                           \
    break;                                                                                      \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin().

#define VTKKWRCHelper_ComputeWeights ( POS   ) 
Value:
w2X = (POS[0]&VTKKW_FP_MASK);                                                         \
  w2Y = (POS[1]&VTKKW_FP_MASK);                                                         \
  w2Z = (POS[2]&VTKKW_FP_MASK);                                                         \
                                                                                        \
  w1X = ((~w2X)&VTKKW_FP_MASK);                                                         \
  w1Y = ((~w2Y)&VTKKW_FP_MASK);                                                         \
  w1Z = ((~w2Z)&VTKKW_FP_MASK);                                                         \
                                                                                        \
  w1Xw1Y = (0x4000+(w1X*w1Y))>>VTKKW_FP_SHIFT;                                          \
  w2Xw1Y = (0x4000+(w2X*w1Y))>>VTKKW_FP_SHIFT;                                          \
  w1Xw2Y = (0x4000+(w1X*w2Y))>>VTKKW_FP_SHIFT;                                          \
  w2Xw2Y = (0x4000+(w2X*w2Y))>>VTKKW_FP_SHIFT;                                          \

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_CroppingCheckNN ( POS   ) 
Value:
if ( cropping )                                       \
    {                                                   \
    if ( mapper->CheckIfCropped( POS ) )                \
      {                                                 \
      continue;                                         \
      }                                                 \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN().

#define VTKKWRCHelper_CroppingCheckTrilin ( POS   ) 
Value:
if ( cropping )                                       \
    {                                                   \
    if ( mapper->CheckIfCropped( POS ) )                \
      {                                                 \
      continue;                                         \
      }                                                 \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_GetCellComponentDirectionValues ( ABCD,
EFGH,
CIDX   ) 
Value:
normalA[CIDX]   = static_cast<unsigned int >(*(ABCD       ));                 \
  normalB[CIDX]   = static_cast<unsigned int >(*(ABCD+dBFinc));                 \
  normalC[CIDX]   = static_cast<unsigned int >(*(ABCD+dCGinc));                 \
  normalD[CIDX]   = static_cast<unsigned int >(*(ABCD+dDHinc));                 \
  normalE[CIDX]   = static_cast<unsigned int >(*(EFGH       ));                 \
  normalF[CIDX]   = static_cast<unsigned int >(*(EFGH+dBFinc));                 \
  normalG[CIDX]   = static_cast<unsigned int >(*(EFGH+dCGinc));                 \
  normalH[CIDX]   = static_cast<unsigned int >(*(EFGH+dDHinc));

Referenced by vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_GetCellComponentMagnitudeValues ( ABCD,
EFGH,
CIDX   ) 
Value:
mA[CIDX] = static_cast<unsigned int >(*(ABCD       ));                       \
  mB[CIDX] = static_cast<unsigned int >(*(ABCD+mBFinc));                       \
  mC[CIDX] = static_cast<unsigned int >(*(ABCD+mCGinc));                       \
  mD[CIDX] = static_cast<unsigned int >(*(ABCD+mDHinc));                       \
  mE[CIDX] = static_cast<unsigned int >(*(EFGH       ));                       \
  mF[CIDX] = static_cast<unsigned int >(*(EFGH+mBFinc));                       \
  mG[CIDX] = static_cast<unsigned int >(*(EFGH+mCGinc));                       \
  mH[CIDX] = static_cast<unsigned int >(*(EFGH+mDHinc))

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_GetCellComponentScalarValues ( DATA,
CIDX,
SCALE,
SHIFT   ) 
Value:
A[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA     ) + SHIFT));             \
  B[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Binc) + SHIFT));             \
  C[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Cinc) + SHIFT));             \
  D[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Dinc) + SHIFT));             \
  E[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Einc) + SHIFT));             \
  F[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Finc) + SHIFT));             \
  G[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Ginc) + SHIFT));             \
  H[CIDX] = static_cast<unsigned int >(SCALE*(*(DATA+Hinc) + SHIFT))

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_GetCellDirectionValues ( ABCD,
EFGH   ) 
Value:
normalA   = static_cast<unsigned int >(*(ABCD       ));       \
  normalB   = static_cast<unsigned int >(*(ABCD+dBFinc));       \
  normalC   = static_cast<unsigned int >(*(ABCD+dCGinc));       \
  normalD   = static_cast<unsigned int >(*(ABCD+dDHinc));       \
  normalE   = static_cast<unsigned int >(*(EFGH       ));       \
  normalF   = static_cast<unsigned int >(*(EFGH+dBFinc));       \
  normalG   = static_cast<unsigned int >(*(EFGH+dCGinc));       \
  normalH   = static_cast<unsigned int >(*(EFGH+dDHinc));

Referenced by vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin().

#define VTKKWRCHelper_GetCellMagnitudeValues ( ABCD,
EFGH   ) 
Value:
mA = static_cast<unsigned int >(*(ABCD      ));                \
  mB = static_cast<unsigned int >(*(ABCD+mBFinc));               \
  mC = static_cast<unsigned int >(*(ABCD+mCGinc));               \
  mD = static_cast<unsigned int >(*(ABCD+mDHinc));               \
  mE = static_cast<unsigned int >(*(EFGH       ));               \
  mF = static_cast<unsigned int >(*(EFGH+mBFinc));               \
  mG = static_cast<unsigned int >(*(EFGH+mCGinc));               \
  mH = static_cast<unsigned int >(*(EFGH+mDHinc))

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin().

#define VTKKWRCHelper_GetCellScalarValues ( DATA,
SCALE,
SHIFT   ) 
Value:
A = static_cast<unsigned int >(SCALE*(*(DATA     ) + SHIFT)); \
  B = static_cast<unsigned int >(SCALE*(*(DATA+Binc) + SHIFT)); \
  C = static_cast<unsigned int >(SCALE*(*(DATA+Cinc) + SHIFT)); \
  D = static_cast<unsigned int >(SCALE*(*(DATA+Dinc) + SHIFT)); \
  E = static_cast<unsigned int >(SCALE*(*(DATA+Einc) + SHIFT)); \
  F = static_cast<unsigned int >(SCALE*(*(DATA+Finc) + SHIFT)); \
  G = static_cast<unsigned int >(SCALE*(*(DATA+Ginc) + SHIFT)); \
  H = static_cast<unsigned int >(SCALE*(*(DATA+Hinc) + SHIFT))

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_GetCellScalarValuesSimple ( DATA   ) 
Value:
A = static_cast<unsigned int >(*(DATA     ));          \
  B = static_cast<unsigned int >(*(DATA+Binc));          \
  C = static_cast<unsigned int >(*(DATA+Cinc));          \
  D = static_cast<unsigned int >(*(DATA+Dinc));          \
  E = static_cast<unsigned int >(*(DATA+Einc));          \
  F = static_cast<unsigned int >(*(DATA+Finc));          \
  G = static_cast<unsigned int >(*(DATA+Ginc));          \
  H = static_cast<unsigned int >(*(DATA+Hinc))

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin().

 
#define VTKKWRCHelper_IncrementAndLoopEnd (  ) 
Value:
imagePtr+=4;                                                              \
      }                                                                         \
    if ( j%32 == 0 && threadID==0 )                                                           \
      {                                                                         \
      float fargs[1];                                                           \
      fargs[0] = static_cast<float>(j)/static_cast<float>(imageInUseSize[1]-1); \
      mapper->InvokeEvent( vtkCommand::ProgressEvent, fargs );                  \
      }                                                                         \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN(), vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageOneNN(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

 
#define VTKKWRCHelper_InitializationAndLoopStartGONN (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartGOShadeNN (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartGOShadeTrilin (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartGOTrilin (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartNN (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartShadeNN (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartShadeTrilin (  ) 
 
#define VTKKWRCHelper_InitializationAndLoopStartTrilin (  ) 
 
#define VTKKWRCHelper_InitializeCompositeGONN (  )     unsigned char *magPtr = gradientMag[spos[2]] + spos[0]*mInc[0] + spos[1]*mInc[1];
 
#define VTKKWRCHelper_InitializeCompositeMultiGOTrilin (  ) 
Value:
unsigned char  *magPtrABCD = 0, *magPtrEFGH = 0;                      \
  unsigned short  mag[4];                                               \
  unsigned int    mA[4],mB[4],mC[4],mD[4],mE[4],mF[4],mG[4],mH[4];

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin().

 
#define VTKKWRCHelper_InitializeCompositeMultiNN (  ) 
Value:
mapper->ShiftVectorDown( pos, spos );                                 \
  T *dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];   \
  unsigned int color[3] = {0,0,0};                                      \
  unsigned int remainingOpacity = 0x7fff;                               \
  unsigned short tmp[4];                                                \
  unsigned short val[4];

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN().

 
#define VTKKWRCHelper_InitializeCompositeMultiShadeTrilin (  ) 
Value:
unsigned short *dirPtrABCD = 0, *dirPtrEFGH = 0;              \
  unsigned int    normalA[4],normalB[4],normalC[4],normalD[4];  \
  unsigned int    normalE[4],normalF[4],normalG[4],normalH[4];

Referenced by vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin().

 
#define VTKKWRCHelper_InitializeCompositeMultiTrilin (  ) 
 
#define VTKKWRCHelper_InitializeCompositeOneGOTrilin (  ) 
 
#define VTKKWRCHelper_InitializeCompositeOneNN (  ) 
 
#define VTKKWRCHelper_InitializeCompositeOneShadeTrilin (  ) 
 
#define VTKKWRCHelper_InitializeCompositeOneTrilin (  ) 
Value:
T *dptr;                                              \
  unsigned int oldSPos[3];                              \
                                                        \
  oldSPos[1] = oldSPos[2] = 0;                          \
  oldSPos[0] = (pos[0] >> VTKKW_FP_SHIFT) + 1;          \
                                                        \
  unsigned int w1X, w1Y, w1Z;                           \
  unsigned int w2X, w2Y, w2Z;                           \
  unsigned int w1Xw1Y, w2Xw1Y, w1Xw2Y, w2Xw2Y;          \
                                                        \
  unsigned short  val;                                  \
  unsigned int    A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0;      \
                                                        \
  unsigned int color[3] = {0,0,0};                      \
  unsigned short remainingOpacity = 0x7fff;             \
  unsigned short tmp[4];

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin().

 
#define VTKKWRCHelper_InitializeCompositeShadeNN (  )     unsigned short *dirPtr = gradientDir[spos[2]] + spos[0]*dInc[0] + spos[1]*dInc[1];
 
#define VTKKWRCHelper_InitializeMIPMultiNN (  ) 
Value:
mapper->ShiftVectorDown( pos, spos );                                 \
  T *dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];   \
  T maxValue[4];                                                        \
  for ( c = 0; c < components; c++ )                                    \
    {                                                                   \
    maxValue[c] = *(dptr+c);                                            \
    }

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN().

 
#define VTKKWRCHelper_InitializeMIPMultiTrilin (  ) 
Value:
T *dptr;                                                      \
  unsigned int oldSPos[3];                                      \
                                                                \
  oldSPos[1] = oldSPos[2] = 0;                                  \
  oldSPos[0] = (pos[0] >> VTKKW_FP_SHIFT) + 1;                  \
                                                                \
  unsigned int w1X, w1Y, w1Z;                                   \
  unsigned int w2X, w2Y, w2Z;                                   \
  unsigned int w1Xw1Y, w2Xw1Y, w1Xw2Y, w2Xw2Y;                  \
                                                                \
  unsigned short  maxValue[4];                                  \
  unsigned short  val[4];                                       \
  unsigned int    A[4],B[4],C[4],D[4],E[4],F[4],G[4],H[4];

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin().

 
#define VTKKWRCHelper_InitializeMIPOneNN (  ) 
Value:
mapper->ShiftVectorDown( pos, spos );                                 \
  T *dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];   \
  T maxValue = *(dptr);

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageOneNN().

 
#define VTKKWRCHelper_InitializeMIPOneTrilin (  ) 
Value:
T *dptr;                                              \
  unsigned int oldSPos[3];                              \
                                                        \
  oldSPos[1] = oldSPos[2] = 0;                          \
  oldSPos[0] = (pos[0] >> VTKKW_FP_SHIFT) + 1;          \
                                                        \
  unsigned int w1X, w1Y, w1Z;                           \
  unsigned int w2X, w2Y, w2Z;                           \
  unsigned int w1Xw1Y, w2Xw1Y, w1Xw2Y, w2Xw2Y;          \
                                                        \
  unsigned short  maxValue=0;                           \
  unsigned short  val;                                  \
  unsigned int    A=0,B=0,C=0,D=0,E=0,F=0,G=0,H=0;

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

 
#define VTKKWRCHelper_InitializeTrilinVariables (  ) 
Value:
unsigned int Binc =                                                components;        \
  unsigned int Cinc =                            dim[0]*components;                     \
  unsigned int Dinc =                            dim[0]*components + components;        \
  unsigned int Einc = dim[0]*dim[1]*components;                                         \
  unsigned int Finc = dim[0]*dim[1]*components                     + components;        \
  unsigned int Ginc = dim[0]*dim[1]*components + dim[0]*components;                     \
  unsigned int Hinc = dim[0]*dim[1]*components + dim[0]*components + components;
 
#define VTKKWRCHelper_InitializeTrilinVariablesGO (  ) 
Value:
int magOffset;                                                \
  if (  vol->GetProperty()->GetIndependentComponents() )        \
    {                                                           \
    magOffset = components;                                     \
    }                                                           \
  else                                                          \
    {                                                           \
    magOffset = 1;                                              \
    }                                                           \
                                                                \
  unsigned int mBFinc =                    magOffset;           \
  unsigned int mCGinc = dim[0]*magOffset;                       \
  unsigned int mDHinc = dim[0]*magOffset + magOffset;
 
#define VTKKWRCHelper_InitializeTrilinVariablesShade (  ) 
Value:
int dirOffset;                                                \
  if (  vol->GetProperty()->GetIndependentComponents() )        \
    {                                                           \
    dirOffset = components;                                     \
    }                                                           \
  else                                                          \
    {                                                           \
    dirOffset = 1;                                              \
    }                                                           \
                                                                \
  unsigned int dBFinc =                    dirOffset;           \
  unsigned int dCGinc = dim[0]*dirOffset;                       \
  unsigned int dDHinc = dim[0]*dirOffset + dirOffset;
 
#define VTKKWRCHelper_InitializeVariables (  ) 
 
#define VTKKWRCHelper_InitializeVariablesGO (  ) 
Value:
unsigned short *gradientOpacityTable[4];                              \
  for ( c = 0; c < 4; c++ )                                             \
    {                                                                   \
    gradientOpacityTable[c] = mapper->GetGradientOpacityTable(c);       \
    }                                                                   \
  unsigned char **gradientMag = mapper->GetGradientMagnitude();         \
                                                                        \
  unsigned int mInc[3];                                                 \
  if ( vol->GetProperty()->GetIndependentComponents() )                 \
    {                                                                   \
    mInc[0] = inc[0];                                                   \
    mInc[1] = inc[1];                                                   \
    mInc[2] = inc[2];                                                   \
    }                                                                   \
  else                                                                  \
    {                                                                   \
    mInc[0] = 1;                                                        \
    mInc[1] = dim[0];                                                   \
    mInc[2] = dim[0]*dim[1];                                            \
    }
 
#define VTKKWRCHelper_InitializeVariablesShade (  ) 
Value:
unsigned short *diffuseShadingTable[4];                               \
  unsigned short *specularShadingTable[4];                              \
  for ( c = 0; c < 4; c++ )                                             \
    {                                                                   \
    diffuseShadingTable[c] = mapper->GetDiffuseShadingTable(c);         \
    specularShadingTable[c] = mapper->GetSpecularShadingTable(c);       \
    }                                                                   \
  unsigned short **gradientDir = mapper->GetGradientNormal();           \
  unsigned int dInc[3];                                                 \
  if ( vol->GetProperty()->GetIndependentComponents() )                 \
    {                                                                   \
    dInc[0] = inc[0];                                                   \
    dInc[1] = inc[1];                                                   \
    dInc[2] = inc[2];                                                   \
    }                                                                   \
  else                                                                  \
    {                                                                   \
    dInc[0] = 1;                                                        \
    dInc[1] = dim[0];                                                   \
    dInc[2] = dim[0]*dim[1];                                            \
    }
 
#define VTKKWRCHelper_InitializeWeights (  ) 
 
#define VTKKWRCHelper_InnerInitialization (  ) 
Value:
unsigned int   numSteps;                              \
  unsigned int   pos[3];                                \
  unsigned int   dir[3];                                \
  mapper->ComputeRayInfo( i, j, pos, dir, &numSteps );  \
  if ( numSteps == 0 )                                  \
    {                                                   \
    *(imagePtr  ) = 0;                                  \
    *(imagePtr+1) = 0;                                  \
    *(imagePtr+2) = 0;                                  \
    *(imagePtr+3) = 0;                                  \
    imagePtr += 4;                                      \
    continue;                                           \
    }                                                   \
  unsigned int   spos[3];                               \
  unsigned int   k;
#define VTKKWRCHelper_InterpolateMagnitude ( VAL   ) 
#define VTKKWRCHelper_InterpolateMagnitudeComponent ( VAL,
CIDX,
COMPONENTS   ) 
Value:
for ( CIDX = 0; CIDX < COMPONENTS; CIDX++ )                                           \
    {                                                                                   \
    VAL[CIDX] =                                                                         \
    (0x7fff + ((mA[CIDX]*((0x4000 + w1Xw1Y*w1Z)>>VTKKW_FP_SHIFT)) +                     \
               (mB[CIDX]*((0x4000 + w2Xw1Y*w1Z)>>VTKKW_FP_SHIFT)) +                     \
               (mC[CIDX]*((0x4000 + w1Xw2Y*w1Z)>>VTKKW_FP_SHIFT)) +                     \
               (mD[CIDX]*((0x4000 + w2Xw2Y*w1Z)>>VTKKW_FP_SHIFT)) +                     \
               (mE[CIDX]*((0x4000 + w1Xw1Y*w2Z)>>VTKKW_FP_SHIFT)) +                     \
               (mF[CIDX]*((0x4000 + w2Xw1Y*w2Z)>>VTKKW_FP_SHIFT)) +                     \
               (mG[CIDX]*((0x4000 + w1Xw2Y*w2Z)>>VTKKW_FP_SHIFT)) +                     \
               (mH[CIDX]*((0x4000 + w2Xw2Y*w2Z)>>VTKKW_FP_SHIFT)))) >> VTKKW_FP_SHIFT;  \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_InterpolateScalar ( VAL   ) 
#define VTKKWRCHelper_InterpolateScalarComponent ( VAL,
CIDX,
COMPONENTS   ) 
Value:
for ( CIDX = 0; CIDX < COMPONENTS; CIDX++ )                                           \
    {                                                                                   \
    VAL[CIDX] =                                                                         \
    (0x7fff + ((A[CIDX]*((0x4000 + w1Xw1Y*w1Z)>>VTKKW_FP_SHIFT)) +                      \
               (B[CIDX]*((0x4000 + w2Xw1Y*w1Z)>>VTKKW_FP_SHIFT)) +                      \
               (C[CIDX]*((0x4000 + w1Xw2Y*w1Z)>>VTKKW_FP_SHIFT)) +                      \
               (D[CIDX]*((0x4000 + w2Xw2Y*w1Z)>>VTKKW_FP_SHIFT)) +                      \
               (E[CIDX]*((0x4000 + w1Xw1Y*w2Z)>>VTKKW_FP_SHIFT)) +                      \
               (F[CIDX]*((0x4000 + w2Xw1Y*w2Z)>>VTKKW_FP_SHIFT)) +                      \
               (G[CIDX]*((0x4000 + w1Xw2Y*w2Z)>>VTKKW_FP_SHIFT)) +                      \
               (H[CIDX]*((0x4000 + w2Xw2Y*w2Z)>>VTKKW_FP_SHIFT)))) >> VTKKW_FP_SHIFT;   \
    }                                                                                   \

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_InterpolateShading ( DTABLE,
STABLE,
COLOR   ) 
#define VTKKWRCHelper_InterpolateShadingComponent ( DTABLE,
STABLE,
COLOR,
CIDX   ) 
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOInterpolateShadeUS ( COLORTABLE,
SOTABLE,
GOTABLE,
DTABLE,
STABLE,
SCALAR,
MAG,
WEIGHTS,
COMPONENTS,
COLOR   ) 
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOShadeUS ( COLORTABLE,
SOTABLE,
GOTABLE,
DTABLE,
STABLE,
SCALAR,
MAG,
NORMAL,
WEIGHTS,
COMPONENTS,
COLOR   ) 
#define VTKKWRCHelper_LookupAndCombineIndependentColorsGOUS ( COLORTABLE,
SOTABLE,
GOTABLE,
SCALAR,
MAG,
WEIGHTS,
COMPONENTS,
COLOR   ) 
Value:
unsigned int _tmp[4] = {0,0,0,0};                                                                                             \
  unsigned short _alpha[4] = {0,0,0,0};                                                                                         \
  unsigned int _totalAlpha = 0;                                                                                                 \
                                                                                                                                \
  {for ( int _idx = 0; _idx < COMPONENTS; _idx++ )                                                                              \
    {                                                                                                                           \
    _alpha[_idx] =  static_cast<unsigned short>(SOTABLE[_idx][SCALAR[_idx]]*WEIGHTS[_idx]);                                     \
    if ( _alpha[_idx] )                                                                                                         \
      {                                                                                                                         \
      _alpha[_idx] = static_cast<unsigned short>((_alpha[_idx]*GOTABLE[_idx][MAG[_idx]] + 0x7fff)>>(VTKKW_FP_SHIFT));           \
      _totalAlpha += _alpha[_idx];                                                                                              \
      }                                                                                                                         \
    }}                                                                                                                          \
                                                                                                                                \
  if ( !_totalAlpha ) {continue;}                                                                                               \
  {for ( int _idx = 0; _idx < COMPONENTS; _idx++ )                                                                              \
    {                                                                                                                           \
    if ( _alpha[_idx] )                                                                                                         \
      {                                                                                                                         \
      _tmp[0] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]  ])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[1] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]+1])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[2] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]+2])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[3] += ((_alpha[_idx]*_alpha[_idx])/_totalAlpha);                                                                     \
      }                                                                                                                         \
    }}                                                                                                                          \
  if ( !_tmp[3] ) {continue;};                                                                                                  \
  COLOR[0] = (_tmp[0]>32767)?(32767):(_tmp[0]);                                                                                 \
  COLOR[1] = (_tmp[1]>32767)?(32767):(_tmp[1]);                                                                                 \
  COLOR[2] = (_tmp[2]>32767)?(32767):(_tmp[2]);                                                                                 \
  COLOR[3] = (_tmp[3]>32767)?(32767):(_tmp[3]);

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), and vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_LookupAndCombineIndependentColorsInterpolateShadeUS ( COLORTABLE,
SOTABLE,
DTABLE,
STABLE,
SCALAR,
WEIGHTS,
COMPONENTS,
COLOR   ) 
#define VTKKWRCHelper_LookupAndCombineIndependentColorsMax ( COLORTABLE,
SCALAROPACITYTABLE,
IDX,
WEIGHTS,
CMPS,
COLOR   ) 
Value:
{                                                                                                                     \
  unsigned int _tmp[4] = {0,0,0,0};                                                                                     \
  for ( int _idx = 0; _idx < CMPS; _idx++ )                                                                             \
    {                                                                                                                   \
    unsigned short _alpha = static_cast<unsigned short>(SCALAROPACITYTABLE[_idx][IDX[_idx]]*WEIGHTS[_idx]);             \
    _tmp[0] += static_cast<unsigned short>(((COLORTABLE[_idx][3*IDX[_idx]  ])*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));      \
    _tmp[1] += static_cast<unsigned short>(((COLORTABLE[_idx][3*IDX[_idx]+1])*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));      \
    _tmp[2] += static_cast<unsigned short>(((COLORTABLE[_idx][3*IDX[_idx]+2])*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));      \
    _tmp[3] += _alpha;                                                                                                  \
    }                                                                                                                   \
  COLOR[0] = (_tmp[0]>32767)?(32767):(_tmp[0]);                                                                         \
  COLOR[1] = (_tmp[1]>32767)?(32767):(_tmp[1]);                                                                         \
  COLOR[2] = (_tmp[2]>32767)?(32767):(_tmp[2]);                                                                         \
  COLOR[3] = (_tmp[3]>32767)?(32767):(_tmp[3]);                                                                         \
  }

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN(), and vtkSlicerFixedPointMIPHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_LookupAndCombineIndependentColorsShadeUS ( COLORTABLE,
SOTABLE,
DTABLE,
STABLE,
SCALAR,
NORMAL,
WEIGHTS,
COMPONENTS,
COLOR   ) 
#define VTKKWRCHelper_LookupAndCombineIndependentColorsUS ( COLORTABLE,
SOTABLE,
SCALAR,
WEIGHTS,
COMPONENTS,
COLOR   ) 
Value:
unsigned int _tmp[4] = {0,0,0,0};                                                                                             \
  unsigned short _alpha[4] = {0,0,0,0};                                                                                         \
  unsigned int _totalAlpha = 0;                                                                                                 \
                                                                                                                                \
  {for ( int _idx = 0; _idx < COMPONENTS; _idx++ )                                                                              \
    {                                                                                                                           \
    _alpha[_idx] = static_cast<unsigned short>(SOTABLE[_idx][SCALAR[_idx]]*WEIGHTS[_idx]);                                      \
    _totalAlpha += _alpha[_idx];                                                                                                \
    }}                                                                                                                          \
                                                                                                                                \
  if ( !_totalAlpha ) {continue;}                                                                                               \
  {for ( int _idx = 0; _idx < COMPONENTS; _idx++ )                                                                              \
    {                                                                                                                           \
    if ( _alpha[_idx] )                                                                                                         \
      {                                                                                                                         \
      _tmp[0] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]  ])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[1] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]+1])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[2] += static_cast<unsigned short>(((COLORTABLE[_idx][3*SCALAR[_idx]+2])*_alpha[_idx] + 0x7fff)>>(VTKKW_FP_SHIFT));   \
      _tmp[3] += ((_alpha[_idx]*_alpha[_idx])/_totalAlpha);                                                                     \
      }                                                                                                                         \
    }}                                                                                                                          \
  if ( !_tmp[3] ) {continue;}                                                                                                   \
  COLOR[0] = (_tmp[0]>32767)?(32767):(_tmp[0]);                                                                                 \
  COLOR[1] = (_tmp[1]>32767)?(32767):(_tmp[1]);                                                                                 \
  COLOR[2] = (_tmp[2]>32767)?(32767):(_tmp[2]);                                                                                 \
  COLOR[3] = (_tmp[3]>32767)?(32767):(_tmp[3]);

Referenced by vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), and vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin().

#define VTKKWRCHelper_LookupColorGOUS ( CTABLE,
SOTABLE,
GOTABLE,
IDX,
IDX2,
COLOR   ) 
Value:
COLOR[3] = (SOTABLE[IDX] * GOTABLE[IDX2] + 0x7fff)>>VTKKW_FP_SHIFT;                   \
  if ( !COLOR[3] ) {continue;}                                                          \
  COLOR[0] = static_cast<unsigned short>                                                \
    ((CTABLE[3*IDX  ]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                            \
  COLOR[1] = static_cast<unsigned short>                                                \
    ((CTABLE[3*IDX+1]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                            \
  COLOR[2] = static_cast<unsigned short>                                                \
    ((CTABLE[3*IDX+2]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN().

#define VTKKWRCHelper_LookupColorMax ( COLORTABLE,
SCALAROPACITYTABLE,
IDX,
COLOR   ) 
Value:
COLOR[3] = SCALAROPACITYTABLE[IDX];                                                 \
  COLOR[0] = static_cast<unsigned short>                                              \
    ((COLORTABLE[3*IDX  ]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                      \
  COLOR[1] = static_cast<unsigned short>                                              \
    ((COLORTABLE[3*IDX+1]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                      \
  COLOR[2] = static_cast<unsigned short>                                              \
    ((COLORTABLE[3*IDX+2]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageOneNN(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_LookupColorUS ( COLORTABLE,
SCALAROPACITYTABLE,
IDX,
COLOR   ) 
Value:
COLOR[3] = SCALAROPACITYTABLE[IDX];                                                   \
  if ( !COLOR[3] ) {continue;}                                                          \
  COLOR[0] = static_cast<unsigned short>                                                \
    ((COLORTABLE[3*IDX  ]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                        \
  COLOR[1] = static_cast<unsigned short>                                                \
    ((COLORTABLE[3*IDX+1]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));                        \
  COLOR[2] = static_cast<unsigned short>                                                \
    ((COLORTABLE[3*IDX+2]*COLOR[3] + 0x7fff)>>(VTKKW_FP_SHIFT));

Referenced by vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_LookupDependentColorUS ( COLORTABLE,
SCALAROPACITYTABLE,
IDX,
CMPS,
COLOR   ) 
Value:
{                                                                                                     \
  unsigned short _alpha;                                                                                \
  switch ( CMPS )                                                                                       \
    {                                                                                                   \
    case 2:                                                                                             \
      _alpha = SCALAROPACITYTABLE[IDX[1]];                                                              \
      COLOR[0] = static_cast<unsigned short>                                                            \
        ((COLORTABLE[3*IDX[0]  ]*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));                                   \
      COLOR[1] = static_cast<unsigned short>                                                            \
        ((COLORTABLE[3*IDX[0]+1]*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));                                   \
      COLOR[2] = static_cast<unsigned short>                                                            \
        ((COLORTABLE[3*IDX[0]+2]*_alpha + 0x7fff)>>(VTKKW_FP_SHIFT));                                   \
      COLOR[3] = _alpha;                                                                                \
      break;                                                                                            \
    case 4:                                                                                             \
      _alpha = SCALAROPACITYTABLE[IDX[3]];                                                              \
      COLOR[0] = static_cast<unsigned short>((IDX[0]*_alpha + 0x7f)>>8 );                               \
      COLOR[1] = static_cast<unsigned short>((IDX[1]*_alpha + 0x7f)>>8 );                               \
      COLOR[2] = static_cast<unsigned short>((IDX[2]*_alpha + 0x7f)>>8 );                               \
      COLOR[3] = _alpha;                                                                                \
      break;                                                                                            \
    }                                                                                                   \
  }

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), and vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin().

#define VTKKWRCHelper_LookupShading ( DTABLE,
STABLE,
NORMAL,
COLOR   ) 
Value:
COLOR[0] = static_cast<unsigned short>((DTABLE[3*NORMAL  ]*COLOR[0]+0x7fff)>>VTKKW_FP_SHIFT); \
  COLOR[1] = static_cast<unsigned short>((DTABLE[3*NORMAL+1]*COLOR[1]+0x7fff)>>VTKKW_FP_SHIFT); \
  COLOR[2] = static_cast<unsigned short>((DTABLE[3*NORMAL+2]*COLOR[2]+0x7fff)>>VTKKW_FP_SHIFT); \
  COLOR[0] += (STABLE[3*NORMAL  ]*COLOR[3] + 0x7fff)>>VTKKW_FP_SHIFT;                           \
  COLOR[1] += (STABLE[3*NORMAL+1]*COLOR[3] + 0x7fff)>>VTKKW_FP_SHIFT;                           \
  COLOR[2] += (STABLE[3*NORMAL+2]*COLOR[3] + 0x7fff)>>VTKKW_FP_SHIFT;

Referenced by vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN().

#define VTKKWRCHelper_MIPSpaceLeapCheck ( MAXIDX,
MAXIDXDEF   ) 
Value:
if ( pos[0] >> VTKKW_FPMM_SHIFT != mmpos[0] ||                        \
       pos[1] >> VTKKW_FPMM_SHIFT != mmpos[1] ||                        \
       pos[2] >> VTKKW_FPMM_SHIFT != mmpos[2] )                         \
    {                                                                   \
    mmpos[0] = pos[0] >> VTKKW_FPMM_SHIFT;                              \
    mmpos[1] = pos[1] >> VTKKW_FPMM_SHIFT;                              \
    mmpos[2] = pos[2] >> VTKKW_FPMM_SHIFT;                              \
    mmvalid = (MAXIDXDEF)?                                              \
     (mapper->CheckMIPMinMaxVolumeFlag( mmpos, 0, MAXIDX )):(1);        \
    }                                                                   \
                                                                        \
  if ( !mmvalid )                                                       \
    {                                                                   \
    continue;                                                           \
    }

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageOneNN(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

#define VTKKWRCHelper_MIPSpaceLeapCheckMulti ( COMP   )     mmvalid[COMP]
#define VTKKWRCHelper_MIPSpaceLeapPopulateMulti ( MAXIDX   ) 
Value:
if ( pos[0] >> VTKKW_FPMM_SHIFT != mmpos[0] ||                                \
       pos[1] >> VTKKW_FPMM_SHIFT != mmpos[1] ||                                \
       pos[2] >> VTKKW_FPMM_SHIFT != mmpos[2] )                                 \
    {                                                                           \
    mmpos[0] = pos[0] >> VTKKW_FPMM_SHIFT;                                      \
    mmpos[1] = pos[1] >> VTKKW_FPMM_SHIFT;                                      \
    mmpos[2] = pos[2] >> VTKKW_FPMM_SHIFT;                                      \
    for ( c = 0; c < components; c++ )                                          \
      {                                                                         \
      mmvalid[c] = mapper->CheckMIPMinMaxVolumeFlag( mmpos, c, MAXIDX[c] );     \
      }                                                                         \
    }

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN().

 
#define VTKKWRCHelper_MoveToNextSampleGONN (  ) 
Value:
if ( k < numSteps-1 )                                                 \
    {                                                                   \
    mapper->FixedPointIncrement( pos, dir );                            \
    mapper->ShiftVectorDown( pos, spos );                               \
    dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];    \
    magPtr = gradientMag[spos[2]] + spos[0]*mInc[0] + spos[1]*mInc[1];  \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), and vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN().

 
#define VTKKWRCHelper_MoveToNextSampleGOShadeNN (  ) 
Value:
if ( k < numSteps-1 )                                                 \
    {                                                                   \
    mapper->FixedPointIncrement( pos, dir );                            \
    mapper->ShiftVectorDown( pos, spos );                               \
    dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];    \
    magPtr = gradientMag[spos[2]] + spos[0]*mInc[0] + spos[1]*mInc[1];  \
    dirPtr = gradientDir[spos[2]] + spos[0]*dInc[0] + spos[1]*dInc[1];  \
    }

Referenced by vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), and vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN().

 
#define VTKKWRCHelper_MoveToNextSampleNN (  ) 
 
#define VTKKWRCHelper_MoveToNextSampleShadeNN (  ) 
Value:
if ( k < numSteps-1 )                                                 \
    {                                                                   \
    mapper->FixedPointIncrement( pos, dir );                            \
    mapper->ShiftVectorDown( pos, spos );                               \
    dptr = data +  spos[0]*inc[0] + spos[1]*inc[1] + spos[2]*inc[2];    \
    dirPtr = gradientDir[spos[2]] + spos[0]*dInc[0] + spos[1]*dInc[1];  \
    }

Referenced by vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN().

 
#define VTKKWRCHelper_OuterInitialization (  ) 
Value:
if ( j%threadCount != threadID )                                    \
      {                                                                 \
      continue;                                                         \
      }                                                                 \
     if ( !threadID )                                                   \
      {                                                                 \
      if ( renWin->CheckAbortStatus() )                                 \
        {                                                               \
        break;                                                          \
        }                                                               \
      }                                                                 \
    else if ( renWin->GetAbortRender() )                                \
      {                                                                 \
      break;                                                            \
      }                                                                 \
    imagePtr = image + 4*(j*imageMemorySize[0] + rowBounds[j*2]);
#define VTKKWRCHelper_SetPixelColor ( IMAGEPTR,
COLOR,
REMAININGOPACITY   ) 
Value:
IMAGEPTR[0] = (COLOR[0]>32767)?(32767):(COLOR[0]);                            \
  IMAGEPTR[1] = (COLOR[1]>32767)?(32767):(COLOR[1]);                            \
  IMAGEPTR[2] = (COLOR[2]>32767)?(32767):(COLOR[2]);                           \
  unsigned int tmpAlpha = (~REMAININGOPACITY)&VTKKW_FP_MASK;                    \
  IMAGEPTR[3] = (tmpAlpha>32767)?(32767):(tmpAlpha);

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageIndependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin().

 
#define VTKKWRCHelper_SpaceLeapCheck (  ) 
Value:
if ( pos[0] >> VTKKW_FPMM_SHIFT != mmpos[0] ||                \
       pos[1] >> VTKKW_FPMM_SHIFT != mmpos[1] ||                \
       pos[2] >> VTKKW_FPMM_SHIFT != mmpos[2] )                 \
    {                                                           \
    mmpos[0] = pos[0] >> VTKKW_FPMM_SHIFT;                      \
    mmpos[1] = pos[1] >> VTKKW_FPMM_SHIFT;                      \
    mmpos[2] = pos[2] >> VTKKW_FPMM_SHIFT;                      \
    mmvalid = mapper->CheckMinMaxVolumeFlag( mmpos, 0 );        \
    }                                                           \
                                                                \
  if ( !mmvalid )                                               \
    {                                                           \
    continue;                                                   \
    }

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), and vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin().

 
#define VTKKWRCHelper_SpaceLeapSetup (  ) 
Value:
unsigned int mmpos[3];                        \
  mmpos[0] = (pos[0] >> VTKKW_FPMM_SHIFT) + 1;  \
  mmpos[1] = 0;                                 \
  mmpos[2] = 0;                                 \
  int mmvalid = 0;

Referenced by vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeGOShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageFourDependentTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneSimpleTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageOneTrilin(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentNN(), vtkSlicerFixedPointCompositeShadeHelperGenerateImageTwoDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageDependentNN(), vtkSlicerFixedPointMIPHelperGenerateImageDependentTrilin(), vtkSlicerFixedPointMIPHelperGenerateImageOneNN(), vtkSlicerFixedPointMIPHelperGenerateImageOneSimpleTrilin(), and vtkSlicerFixedPointMIPHelperGenerateImageOneTrilin().

 
#define VTKKWRCHelper_SpaceLeapSetupMulti (  ) 
Value:
unsigned int mmpos[3];                        \
  mmpos[0] = (pos[0] >> VTKKW_FPMM_SHIFT) + 1;  \
  mmpos[1] = 0;                                 \
  mmpos[2] = 0;                                 \
  int mmvalid[4] = {0,0,0,0};

Referenced by vtkSlicerFixedPointMIPHelperGenerateImageIndependentNN().


Generated on 6 Apr 2011 for Slicer3 by  doxygen 1.6.1