vtkVolumeRayCastSpaceLeapingImageFilter.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 vtkVolumeRayCastSpaceLeapingImageFilter_h
#define vtkVolumeRayCastSpaceLeapingImageFilter_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkThreadedImageAlgorithm.h"
 
class vtkDataArray;
 
class VTKRENDERINGVOLUME_EXPORT vtkVolumeRayCastSpaceLeapingImageFilter
  : public vtkThreadedImageAlgorithm
{
public:
  vtkTypeMacro(vtkVolumeRayCastSpaceLeapingImageFilter, vtkThreadedImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkVolumeRayCastSpaceLeapingImageFilter* New();
 
 
  virtual void SetCurrentScalars(vtkDataArray*);
  vtkGetObjectMacro(CurrentScalars, vtkDataArray);
 
 
  vtkSetMacro(IndependentComponents, int);
  vtkGetMacro(IndependentComponents, int);
 
 
  vtkSetMacro(ComputeGradientOpacity, vtkTypeBool);
  vtkGetMacro(ComputeGradientOpacity, vtkTypeBool);
  vtkBooleanMacro(ComputeGradientOpacity, vtkTypeBool);
 
 
  vtkSetMacro(ComputeMinMax, vtkTypeBool);
  vtkGetMacro(ComputeMinMax, vtkTypeBool);
  vtkBooleanMacro(ComputeMinMax, vtkTypeBool);
 
 
  vtkSetMacro(UpdateGradientOpacityFlags, vtkTypeBool);
  vtkGetMacro(UpdateGradientOpacityFlags, vtkTypeBool);
  vtkBooleanMacro(UpdateGradientOpacityFlags, vtkTypeBool);
 
  vtkMTimeType GetLastMinMaxBuildTime() { return LastMinMaxBuildTime.GetMTime(); }
 
  vtkMTimeType GetLastMinMaxFlagTime() { return LastMinMaxFlagTime.GetMTime(); }
 
 
  vtkSetVector4Macro(TableShift, float);
  vtkGetVector4Macro(TableShift, float);
  vtkSetVector4Macro(TableScale, float);
  vtkGetVector4Macro(TableScale, float);
  vtkSetVector4Macro(TableSize, int);
  vtkGetVector4Macro(TableSize, int);
 
  int GetNumberOfIndependentComponents();
 
  unsigned short* GetMinMaxVolume(int dims[4]);
 
  virtual void SetCache(vtkImageData* imageCache);
 
  static void ComputeInputExtentsForOutput(
    int inExt[6], int inDim[3], int outExt[6], vtkImageData* inData);
 
 
  unsigned short* GetMinNonZeroScalarIndex();
  unsigned char* GetMinNonZeroGradientMagnitudeIndex();
 
 
  void SetGradientMagnitude(unsigned char** gradientMagnitude);
  unsigned char** GetGradientMagnitude();
 
 
  void SetScalarOpacityTable(int c, unsigned short* t);
  void SetGradientOpacityTable(int c, unsigned short* t);
 
  vtkIdType ComputeOffset(const int ext[6], const int wholeExt[6], int nComponents);
 
  // This method helps debug. It writes out a specific component of the
  // computed min-max-volume structure
  // static void WriteMinMaxVolume( int component, unsigned short *minMaxVolume,
  //                           int minMaxVolumeSize[4], const char *filename );
 
protected:
  vtkVolumeRayCastSpaceLeapingImageFilter();
  ~vtkVolumeRayCastSpaceLeapingImageFilter() override;
 
  int IndependentComponents;
  vtkTimeStamp LastMinMaxBuildTime;
  vtkTimeStamp LastMinMaxFlagTime;
  vtkDataArray* CurrentScalars;
  float TableShift[4];
  float TableScale[4];
  int TableSize[4];
  vtkTypeBool ComputeGradientOpacity;
  vtkTypeBool ComputeMinMax;
  vtkTypeBool UpdateGradientOpacityFlags;
  unsigned short* MinNonZeroScalarIndex;
  unsigned char* MinNonZeroGradientMagnitudeIndex;
  unsigned char** GradientMagnitude;
  unsigned short* ScalarOpacityTable[4];
  unsigned short* GradientOpacityTable[4];
  vtkImageData* Cache;
 
  void InternalRequestUpdateExtent(int*, int*);
 
 
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  void ThreadedRequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector, vtkImageData*** inData, vtkImageData** outData,
    int outExt[6], int id) override;
  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  void ComputeFirstNonZeroOpacityIndices();
 
  void FillScalarOpacityFlags(vtkImageData* minMaxVolume, int outExt[6]);
 
  void FillScalarAndGradientOpacityFlags(vtkImageData* minMaxVolume, int outExt[6]);
 
 
  void AllocateOutputData(vtkImageData* out, vtkInformation* outInfo, int* uExtent) override;
  vtkImageData* AllocateOutputData(vtkDataObject* out, vtkInformation* outInfo) override;
 
private:
  vtkVolumeRayCastSpaceLeapingImageFilter(const vtkVolumeRayCastSpaceLeapingImageFilter&) = delete;
  void operator=(const vtkVolumeRayCastSpaceLeapingImageFilter&) = delete;
};
 
#endif