vtkFixedPointVolumeRayCastMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkFixedPointVolumeRayCastMapper.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkFixedPointVolumeRayCastMapper_h
#define vtkFixedPointVolumeRayCastMapper_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkThreads.h"               // for VTK_THREAD_RETURN_TYPE
#include "vtkVolumeMapper.h"
 
#define VTKKW_FP_SHIFT 15
#define VTKKW_FPMM_SHIFT 17
#define VTKKW_FP_MASK 0x7fff
#define VTKKW_FP_SCALE 32767.0
 
class vtkMatrix4x4;
class vtkMultiThreader;
class vtkPlaneCollection;
class vtkRenderer;
class vtkTimerLog;
class vtkVolume;
class vtkTransform;
class vtkRenderWindow;
class vtkColorTransferFunction;
class vtkPiecewiseFunction;
class vtkFixedPointVolumeRayCastMIPHelper;
class vtkFixedPointVolumeRayCastCompositeHelper;
class vtkFixedPointVolumeRayCastCompositeGOHelper;
class vtkFixedPointVolumeRayCastCompositeGOShadeHelper;
class vtkFixedPointVolumeRayCastCompositeShadeHelper;
class vtkVolumeRayCastSpaceLeapingImageFilter;
class vtkDirectionEncoder;
class vtkEncodedGradientShader;
class vtkFiniteDifferenceGradientEstimator;
class vtkRayCastImageDisplayHelper;
class vtkFixedPointRayCastImage;
class vtkDataArray;
 
// Forward declaration needed for use by friend declaration below.
VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
 
class VTKRENDERINGVOLUME_EXPORT vtkFixedPointVolumeRayCastMapper : public vtkVolumeMapper
{
public:
  static vtkFixedPointVolumeRayCastMapper* New();
  vtkTypeMacro(vtkFixedPointVolumeRayCastMapper, vtkVolumeMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(SampleDistance, float);
  vtkGetMacro(SampleDistance, float);
 
 
  vtkSetMacro(InteractiveSampleDistance, float);
  vtkGetMacro(InteractiveSampleDistance, float);
 
 
  vtkSetClampMacro(ImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(ImageSampleDistance, float);
 
 
  vtkSetClampMacro(MinimumImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(MinimumImageSampleDistance, float);
 
 
  vtkSetClampMacro(MaximumImageSampleDistance, float, 0.1f, 100.0f);
  vtkGetMacro(MaximumImageSampleDistance, float);
 
 
  vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
  vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
  vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
 
 
  vtkSetClampMacro(LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1);
  vtkGetMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
  vtkBooleanMacro(LockSampleDistanceToInputSpacing, vtkTypeBool);
 
 
  void SetNumberOfThreads(int num);
  int GetNumberOfThreads();
 
 
  vtkSetClampMacro(IntermixIntersectingGeometry, vtkTypeBool, 0, 1);
  vtkGetMacro(IntermixIntersectingGeometry, vtkTypeBool);
  vtkBooleanMacro(IntermixIntersectingGeometry, vtkTypeBool);
 
 
  float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren);
  float ComputeRequiredImageSampleDistance(float desiredTime, vtkRenderer* ren, vtkVolume* vol);
 
  void Render(vtkRenderer*, vtkVolume*) override;
 
  unsigned int ToFixedPointPosition(float val);
  void ToFixedPointPosition(float in[3], unsigned int out[3]);
  unsigned int ToFixedPointDirection(float dir);
  void ToFixedPointDirection(float in[3], unsigned int out[3]);
  void FixedPointIncrement(unsigned int position[3], unsigned int increment[3]);
  void GetFloatTripleFromPointer(float v[3], float* ptr);
  void GetUIntTripleFromPointer(unsigned int v[3], unsigned int* ptr);
  void ShiftVectorDown(unsigned int in[3], unsigned int out[3]);
  int CheckMinMaxVolumeFlag(unsigned int pos[3], int c);
  int CheckMIPMinMaxVolumeFlag(unsigned int pos[3], int c, unsigned short maxIdx, int flip);
 
  void LookupColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
    unsigned short index, unsigned char color[4]);
  void LookupDependentColorUC(unsigned short* colorTable, unsigned short* scalarOpacityTable,
    unsigned short index[4], int components, unsigned char color[4]);
  void LookupAndCombineIndependentColorsUC(unsigned short* colorTable[4],
    unsigned short* scalarOpacityTable[4], unsigned short index[4], float weights[4],
    int components, unsigned char color[4]);
  int CheckIfCropped(unsigned int pos[3]);
 
  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);
  vtkGetObjectMacro(MIPHelper, vtkFixedPointVolumeRayCastMIPHelper);
  vtkGetObjectMacro(CompositeHelper, vtkFixedPointVolumeRayCastCompositeHelper);
  vtkGetObjectMacro(CompositeGOHelper, vtkFixedPointVolumeRayCastCompositeGOHelper);
  vtkGetObjectMacro(CompositeGOShadeHelper, vtkFixedPointVolumeRayCastCompositeGOShadeHelper);
  vtkGetObjectMacro(CompositeShadeHelper, vtkFixedPointVolumeRayCastCompositeShadeHelper);
  vtkGetVectorMacro(TableShift, float, 4);
  vtkGetVectorMacro(TableScale, float, 4);
  vtkGetMacro(ShadingRequired, int);
  vtkGetMacro(GradientOpacityRequired, int);
 
  vtkGetObjectMacro(CurrentScalars, vtkDataArray);
  vtkGetObjectMacro(PreviousScalars, vtkDataArray);
 
  int* GetRowBounds() { return this->RowBounds; }
  unsigned short* GetColorTable(int c) { return this->ColorTable[c]; }
  unsigned short* GetScalarOpacityTable(int c) { return this->ScalarOpacityTable[c]; }
  unsigned short* GetGradientOpacityTable(int c) { return this->GradientOpacityTable[c]; }
  vtkVolume* GetVolume() { return this->Volume; }
  unsigned short** GetGradientNormal() { return this->GradientNormal; }
  unsigned char** GetGradientMagnitude() { return this->GradientMagnitude; }
  unsigned short* GetDiffuseShadingTable(int c) { return this->DiffuseShadingTable[c]; }
  unsigned short* GetSpecularShadingTable(int c) { return this->SpecularShadingTable[c]; }
 
  void ComputeRayInfo(
    int x, int y, unsigned int pos[3], unsigned int dir[3], unsigned int* numSteps);
 
  void InitializeRayInfo(vtkVolume* vol);
 
  int ShouldUseNearestNeighborInterpolation(vtkVolume* vol);
 
 
  void SetRayCastImage(vtkFixedPointRayCastImage*);
  vtkGetObjectMacro(RayCastImage, vtkFixedPointRayCastImage);
 
  int PerImageInitialization(vtkRenderer*, vtkVolume*, int, double*, double*, int*);
  void PerVolumeInitialization(vtkRenderer*, vtkVolume*);
  void PerSubVolumeInitialization(vtkRenderer*, vtkVolume*, int);
  void RenderSubVolume();
  void DisplayRenderedImage(vtkRenderer*, vtkVolume*);
  void AbortRender();
 
  void CreateCanonicalView(vtkVolume* volume, vtkImageData* image, int blend_mode,
    double viewDirection[3], double viewUp[3]);
 
  float GetEstimatedRenderTime(vtkRenderer* ren, vtkVolume* vol)
  {
    return this->RetrieveRenderTime(ren, vol);
  }
  float GetEstimatedRenderTime(vtkRenderer* ren) { return this->RetrieveRenderTime(ren); }
 
 
  vtkSetMacro(FinalColorWindow, float);
  vtkGetMacro(FinalColorWindow, float);
  vtkSetMacro(FinalColorLevel, float);
  vtkGetMacro(FinalColorLevel, float);
 
  // Here to be used by the mapper to tell the helper
  // to flip the MIP comparison in order to support
  // minimum intensity blending
  vtkGetMacro(FlipMIPComparison, int);
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
protected:
  vtkFixedPointVolumeRayCastMapper();
  ~vtkFixedPointVolumeRayCastMapper() override;
 
  // The helper class that displays the image
  vtkRayCastImageDisplayHelper* ImageDisplayHelper;
 
  // The distance between sample points along the ray
  float SampleDistance;
  float InteractiveSampleDistance;
 
  // The distance between rays in the image
  float ImageSampleDistance;
  float MinimumImageSampleDistance;
  float MaximumImageSampleDistance;
  vtkTypeBool AutoAdjustSampleDistances;
  vtkTypeBool LockSampleDistanceToInputSpacing;
 
  // Saved values used to restore
  float OldSampleDistance;
  float OldImageSampleDistance;
 
  // Internal method for computing matrices needed during
  // ray casting
  void ComputeMatrices(double inputOrigin[3], double inputSpacing[3], int inputExtent[6],
    vtkRenderer* ren, vtkVolume* vol);
 
  int ComputeRowBounds(vtkRenderer* ren, int imageFlag, int rowBoundsFlag, int inputExtent[6]);
 
  void CaptureZBuffer(vtkRenderer* ren);
 
  friend VTK_THREAD_RETURN_TYPE FixedPointVolumeRayCastMapper_CastRays(void* arg);
  friend VTK_THREAD_RETURN_TYPE vtkFPVRCMSwitchOnDataType(void* arg);
 
  vtkMultiThreader* Threader;
 
  vtkMatrix4x4* PerspectiveMatrix;
  vtkMatrix4x4* ViewToWorldMatrix;
  vtkMatrix4x4* ViewToVoxelsMatrix;
  vtkMatrix4x4* VoxelsToViewMatrix;
  vtkMatrix4x4* WorldToVoxelsMatrix;
  vtkMatrix4x4* VoxelsToWorldMatrix;
 
  vtkMatrix4x4* VolumeMatrix;
 
  vtkTransform* PerspectiveTransform;
  vtkTransform* VoxelsTransform;
  vtkTransform* VoxelsToViewTransform;
 
  // This object encapsulated the image and all related information
  vtkFixedPointRayCastImage* RayCastImage;
 
  int* RowBounds;
  int* OldRowBounds;
 
  float* RenderTimeTable;
  vtkVolume** RenderVolumeTable;
  vtkRenderer** RenderRendererTable;
  int RenderTableSize;
  int RenderTableEntries;
 
  void StoreRenderTime(vtkRenderer* ren, vtkVolume* vol, float t);
  float RetrieveRenderTime(vtkRenderer* ren, vtkVolume* vol);
  float RetrieveRenderTime(vtkRenderer* ren);
 
  vtkTypeBool IntermixIntersectingGeometry;
 
  float MinimumViewDistance;
 
  vtkColorTransferFunction* SavedRGBFunction[4];
  vtkPiecewiseFunction* SavedGrayFunction[4];
  vtkPiecewiseFunction* SavedScalarOpacityFunction[4];
  vtkPiecewiseFunction* SavedGradientOpacityFunction[4];
  int SavedColorChannels[4];
  float SavedScalarOpacityDistance[4];
  int SavedBlendMode;
  vtkImageData* SavedParametersInput;
  vtkTimeStamp SavedParametersMTime;
 
  vtkImageData* SavedGradientsInput;
  vtkTimeStamp SavedGradientsMTime;
 
  float SavedSampleDistance;
 
  unsigned short ColorTable[4][32768 * 3];
  unsigned short ScalarOpacityTable[4][32768];
  unsigned short GradientOpacityTable[4][256];
  int TableSize[4];
  float TableScale[4];
  float TableShift[4];
 
  float GradientMagnitudeScale[4];
  float GradientMagnitudeShift[4];
 
  unsigned short** GradientNormal;
  unsigned char** GradientMagnitude;
  unsigned short* ContiguousGradientNormal;
  unsigned char* ContiguousGradientMagnitude;
 
  int NumberOfGradientSlices;
 
  vtkDirectionEncoder* DirectionEncoder;
 
  vtkEncodedGradientShader* GradientShader;
 
  vtkFiniteDifferenceGradientEstimator* GradientEstimator;
 
  unsigned short DiffuseShadingTable[4][65536 * 3];
  unsigned short SpecularShadingTable[4][65536 * 3];
 
  int ShadingRequired;
  int GradientOpacityRequired;
 
  vtkDataArray* CurrentScalars;
  vtkDataArray* PreviousScalars;
 
  vtkRenderWindow* RenderWindow;
  vtkVolume* Volume;
 
  int ClipRayAgainstVolume(
    double rayStart[3], double rayEnd[3], float rayDirection[3], double bounds[6]);
 
  int UpdateColorTable(vtkVolume* vol);
  int UpdateGradients(vtkVolume* vol);
  int UpdateShadingTable(vtkRenderer* ren, vtkVolume* vol);
  void UpdateCroppingRegions();
 
  void ComputeGradients(vtkVolume* vol);
 
  int ClipRayAgainstClippingPlanes(
    double rayStart[3], double rayEnd[3], int numClippingPlanes, float* clippingPlanes);
 
  unsigned int FixedPointCroppingRegionPlanes[6];
  unsigned int CroppingRegionMask[27];
 
  // Get the ZBuffer value corresponding to location (x,y) where (x,y)
  // are indexing into the ImageInUse image. This must be converted to
  // the zbuffer image coordinates. Nearest neighbor value is returned.
  float GetZBufferValue(int x, int y);
 
  vtkFixedPointVolumeRayCastMIPHelper* MIPHelper;
  vtkFixedPointVolumeRayCastCompositeHelper* CompositeHelper;
  vtkFixedPointVolumeRayCastCompositeGOHelper* CompositeGOHelper;
  vtkFixedPointVolumeRayCastCompositeShadeHelper* CompositeShadeHelper;
  vtkFixedPointVolumeRayCastCompositeGOShadeHelper* CompositeGOShadeHelper;
 
  // Some variables used for ray computation
  float ViewToVoxelsArray[16];
  float WorldToVoxelsArray[16];
  float VoxelsToWorldArray[16];
 
  double CroppingBounds[6];
 
  int NumTransformedClippingPlanes;
  float* TransformedClippingPlanes;
 
  double SavedSpacing[3];
 
  // Min Max structure used to do space leaping
  unsigned short* MinMaxVolume;
  int MinMaxVolumeSize[4];
  vtkImageData* SavedMinMaxInput;
  vtkImageData* MinMaxVolumeCache;
  vtkVolumeRayCastSpaceLeapingImageFilter* SpaceLeapFilter;
 
  void UpdateMinMaxVolume(vtkVolume* vol);
  void FillInMaxGradientMagnitudes(int fullDim[3], int smallDim[3]);
 
  float FinalColorWindow;
  float FinalColorLevel;
 
  int FlipMIPComparison;
 
  void ApplyFinalColorWindowLevel();
 
private:
  vtkFixedPointVolumeRayCastMapper(const vtkFixedPointVolumeRayCastMapper&) = delete;
  void operator=(const vtkFixedPointVolumeRayCastMapper&) = delete;
 
  bool ThreadWarning;
};
 
inline unsigned int vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float val)
{
  return static_cast<unsigned int>(val * VTKKW_FP_SCALE + 0.5);
}
 
inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointPosition(float in[3], unsigned int out[3])
{
  out[0] = static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5);
  out[1] = static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5);
  out[2] = static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5);
}
 
inline unsigned int vtkFixedPointVolumeRayCastMapper::ToFixedPointDirection(float dir)
{
  return ((dir < 0.0) ? (static_cast<unsigned int>(-dir * VTKKW_FP_SCALE + 0.5))
                      : (0x80000000 + static_cast<unsigned int>(dir * VTKKW_FP_SCALE + 0.5)));
}
 
inline void vtkFixedPointVolumeRayCastMapper::ToFixedPointDirection(
  float in[3], unsigned int out[3])
{
  out[0] = ((in[0] < 0.0) ? (static_cast<unsigned int>(-in[0] * VTKKW_FP_SCALE + 0.5))
                          : (0x80000000 + static_cast<unsigned int>(in[0] * VTKKW_FP_SCALE + 0.5)));
  out[1] = ((in[1] < 0.0) ? (static_cast<unsigned int>(-in[1] * VTKKW_FP_SCALE + 0.5))
                          : (0x80000000 + static_cast<unsigned int>(in[1] * VTKKW_FP_SCALE + 0.5)));
  out[2] = ((in[2] < 0.0) ? (static_cast<unsigned int>(-in[2] * VTKKW_FP_SCALE + 0.5))
                          : (0x80000000 + static_cast<unsigned int>(in[2] * VTKKW_FP_SCALE + 0.5)));
}
 
inline void vtkFixedPointVolumeRayCastMapper::FixedPointIncrement(
  unsigned int position[3], unsigned int increment[3])
{
  if (increment[0] & 0x80000000)
  {
    position[0] += (increment[0] & 0x7fffffff);
  }
  else
  {
    position[0] -= increment[0];
  }
  if (increment[1] & 0x80000000)
  {
    position[1] += (increment[1] & 0x7fffffff);
  }
  else
  {
    position[1] -= increment[1];
  }
  if (increment[2] & 0x80000000)
  {
    position[2] += (increment[2] & 0x7fffffff);
  }
  else
  {
    position[2] -= increment[2];
  }
}
 
inline void vtkFixedPointVolumeRayCastMapper::GetFloatTripleFromPointer(float v[3], float* ptr)
{
  v[0] = *(ptr);
  v[1] = *(ptr + 1);
  v[2] = *(ptr + 2);
}
 
inline void vtkFixedPointVolumeRayCastMapper::GetUIntTripleFromPointer(
  unsigned int v[3], unsigned int* ptr)
{
  v[0] = *(ptr);
  v[1] = *(ptr + 1);
  v[2] = *(ptr + 2);
}
 
inline void vtkFixedPointVolumeRayCastMapper::ShiftVectorDown(
  unsigned int in[3], unsigned int out[3])
{
  out[0] = in[0] >> VTKKW_FP_SHIFT;
  out[1] = in[1] >> VTKKW_FP_SHIFT;
  out[2] = in[2] >> VTKKW_FP_SHIFT;
}
 
inline int vtkFixedPointVolumeRayCastMapper::CheckMinMaxVolumeFlag(unsigned int mmpos[3], int c)
{
  vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
      (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
        mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
    static_cast<vtkIdType>(c);
 
  return ((*(this->MinMaxVolume + 3 * offset + 2)) & 0x00ff);
}
 
inline int vtkFixedPointVolumeRayCastMapper::CheckMIPMinMaxVolumeFlag(
  unsigned int mmpos[3], int c, unsigned short maxIdx, int flip)
{
  vtkIdType offset = static_cast<vtkIdType>(this->MinMaxVolumeSize[3]) *
      (mmpos[2] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0] * this->MinMaxVolumeSize[1]) +
        mmpos[1] * static_cast<vtkIdType>(this->MinMaxVolumeSize[0]) + mmpos[0]) +
    static_cast<vtkIdType>(c);
 
  if ((*(this->MinMaxVolume + 3 * offset + 2) & 0x00ff))
  {
    if (flip)
    {
      return (*(this->MinMaxVolume + 3 * offset) < maxIdx);
    }
    else
    {
      return (*(this->MinMaxVolume + 3 * offset + 1) > maxIdx);
    }
  }
  else
  {
    return 0;
  }
}
 
inline void vtkFixedPointVolumeRayCastMapper::LookupColorUC(unsigned short* colorTable,
  unsigned short* scalarOpacityTable, unsigned short index, unsigned char color[4])
{
  unsigned short alpha = scalarOpacityTable[index];
  color[0] = static_cast<unsigned char>(
    (colorTable[3 * index] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
  color[1] = static_cast<unsigned char>(
    (colorTable[3 * index + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
  color[2] = static_cast<unsigned char>(
    (colorTable[3 * index + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
  color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
}
 
inline void vtkFixedPointVolumeRayCastMapper::LookupDependentColorUC(unsigned short* colorTable,
  unsigned short* scalarOpacityTable, unsigned short index[4], int components,
  unsigned char color[4])
{
  unsigned short alpha;
  switch (components)
  {
    case 2:
      alpha = scalarOpacityTable[index[1]];
      color[0] = static_cast<unsigned char>(
        (colorTable[3 * index[0]] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
      color[1] = static_cast<unsigned char>(
        (colorTable[3 * index[0] + 1] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
      color[2] = static_cast<unsigned char>(
        (colorTable[3 * index[0] + 2] * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
      color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
      break;
    case 4:
      alpha = scalarOpacityTable[index[3]];
      color[0] = static_cast<unsigned char>((index[0] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
      color[1] = static_cast<unsigned char>((index[1] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
      color[2] = static_cast<unsigned char>((index[2] * alpha + 0x7fff) >> VTKKW_FP_SHIFT);
      color[3] = static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
      break;
  }
}
 
inline void vtkFixedPointVolumeRayCastMapper::LookupAndCombineIndependentColorsUC(
  unsigned short* colorTable[4], unsigned short* scalarOpacityTable[4], unsigned short index[4],
  float weights[4], int components, unsigned char color[4])
{
  unsigned int tmp[4] = { 0, 0, 0, 0 };
 
  for (int i = 0; i < components; i++)
  {
    unsigned short alpha =
      static_cast<unsigned short>(static_cast<float>(scalarOpacityTable[i][index[i]]) * weights[i]);
    tmp[0] += static_cast<unsigned char>(
      ((colorTable[i][3 * index[i]]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
    tmp[1] += static_cast<unsigned char>(
      ((colorTable[i][3 * index[i] + 1]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
    tmp[2] += static_cast<unsigned char>(
      ((colorTable[i][3 * index[i] + 2]) * alpha + 0x7fff) >> (2 * VTKKW_FP_SHIFT - 8));
    tmp[3] += static_cast<unsigned char>(alpha >> (VTKKW_FP_SHIFT - 8));
  }
 
  color[0] = static_cast<unsigned char>((tmp[0] > 255) ? (255) : (tmp[0]));
  color[1] = static_cast<unsigned char>((tmp[1] > 255) ? (255) : (tmp[1]));
  color[2] = static_cast<unsigned char>((tmp[2] > 255) ? (255) : (tmp[2]));
  color[3] = static_cast<unsigned char>((tmp[3] > 255) ? (255) : (tmp[3]));
}
 
inline int vtkFixedPointVolumeRayCastMapper::CheckIfCropped(unsigned int pos[3])
{
  int idx;
 
  if (pos[2] < this->FixedPointCroppingRegionPlanes[4])
  {
    idx = 0;
  }
  else if (pos[2] > this->FixedPointCroppingRegionPlanes[5])
  {
    idx = 18;
  }
  else
  {
    idx = 9;
  }
 
  if (pos[1] >= this->FixedPointCroppingRegionPlanes[2])
  {
    if (pos[1] > this->FixedPointCroppingRegionPlanes[3])
    {
      idx += 6;
    }
    else
    {
      idx += 3;
    }
  }
 
  if (pos[0] >= this->FixedPointCroppingRegionPlanes[0])
  {
    if (pos[0] > this->FixedPointCroppingRegionPlanes[1])
    {
      idx += 2;
    }
    else
    {
      idx += 1;
    }
  }
 
  return !(static_cast<unsigned int>(this->CroppingRegionFlags) & this->CroppingRegionMask[idx]);
}
 
#endif