vtkCheckerboardSplatter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCheckerboardSplatter.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 vtkCheckerboardSplatter_h
#define vtkCheckerboardSplatter_h
 
#include "vtkImageAlgorithm.h"
#include "vtkImagingHybridModule.h" // For export macro
 
#define VTK_ACCUMULATION_MODE_MIN 0
#define VTK_ACCUMULATION_MODE_MAX 1
#define VTK_ACCUMULATION_MODE_SUM 2
 
class vtkDoubleArray;
class vtkCompositeDataSet;
 
class VTKIMAGINGHYBRID_EXPORT vtkCheckerboardSplatter : public vtkImageAlgorithm
{
public:
  vtkTypeMacro(vtkCheckerboardSplatter, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkCheckerboardSplatter* New();
 
 
  void SetSampleDimensions(int i, int j, int k);
  void SetSampleDimensions(int dim[3]);
  vtkGetVectorMacro(SampleDimensions, int, 3);
 
 
  vtkSetVector6Macro(ModelBounds, double);
  vtkGetVectorMacro(ModelBounds, double, 6);
 
 
  vtkSetClampMacro(Footprint, int, 0, VTK_INT_MAX);
  vtkGetMacro(Footprint, int);
 
 
  vtkSetClampMacro(Radius, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(Radius, double);
 
 
  vtkSetClampMacro(ScaleFactor, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(ScaleFactor, double);
 
 
  vtkSetMacro(ExponentFactor, double);
  vtkGetMacro(ExponentFactor, double);
 
 
  vtkSetMacro(ScalarWarping, vtkTypeBool);
  vtkGetMacro(ScalarWarping, vtkTypeBool);
  vtkBooleanMacro(ScalarWarping, vtkTypeBool);
 
 
  vtkSetMacro(NormalWarping, vtkTypeBool);
  vtkGetMacro(NormalWarping, vtkTypeBool);
  vtkBooleanMacro(NormalWarping, vtkTypeBool);
 
 
  vtkSetClampMacro(Eccentricity, double, 0.001, VTK_DOUBLE_MAX);
  vtkGetMacro(Eccentricity, double);
 
 
  vtkSetClampMacro(AccumulationMode, int, VTK_ACCUMULATION_MODE_MIN, VTK_ACCUMULATION_MODE_SUM);
  vtkGetMacro(AccumulationMode, int);
  void SetAccumulationModeToMin() { this->SetAccumulationMode(VTK_ACCUMULATION_MODE_MIN); }
  void SetAccumulationModeToMax() { this->SetAccumulationMode(VTK_ACCUMULATION_MODE_MAX); }
  void SetAccumulationModeToSum() { this->SetAccumulationMode(VTK_ACCUMULATION_MODE_SUM); }
  const char* GetAccumulationModeAsString();
 
 
  vtkSetMacro(OutputScalarType, int);
  vtkGetMacro(OutputScalarType, int);
  void SetOutputScalarTypeToDouble() { this->SetOutputScalarType(VTK_DOUBLE); }
  void SetOutputScalarTypeToFloat() { this->SetOutputScalarType(VTK_FLOAT); }
 
 
  vtkSetMacro(Capping, vtkTypeBool);
  vtkGetMacro(Capping, vtkTypeBool);
  vtkBooleanMacro(Capping, vtkTypeBool);
 
 
  vtkSetMacro(CapValue, double);
  vtkGetMacro(CapValue, double);
 
 
  vtkSetMacro(NullValue, double);
  vtkGetMacro(NullValue, double);
 
 
  vtkSetClampMacro(MaximumDimension, int, 0, 255);
  vtkGetMacro(MaximumDimension, int);
 
 
  vtkSetClampMacro(ParallelSplatCrossover, int, 0, 255);
  vtkGetMacro(ParallelSplatCrossover, int);
 
  void ComputeModelBounds(vtkDataSet* input, vtkImageData* output, vtkInformation* outInfo);
 
protected:
  vtkCheckerboardSplatter();
  ~vtkCheckerboardSplatter() override {}
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int OutputScalarType;           // the type of output scalars
  int SampleDimensions[3];        // dimensions of volume to splat into
  double Radius;                  // Radius factor in the Gaussian exponential function
  int Footprint;                  // maximum distance splat propagates (in voxels 0->Dim)
  double ExponentFactor;          // scale exponent of gaussian function
  double ModelBounds[6];          // bounding box of splatting dimensions
  double Origin[3], Spacing[3];   // output geometry
  vtkTypeBool NormalWarping;      // on/off warping of splat via normal
  double Eccentricity;            // elliptic distortion due to normals
  vtkTypeBool ScalarWarping;      // on/off warping of splat via scalar
  double ScaleFactor;             // splat size influenced by scale factor
  vtkTypeBool Capping;            // Cap side of volume to close surfaces
  double CapValue;                // value to use for capping
  int AccumulationMode;           // how to combine scalar values
  double NullValue;               // initial value of voxels
  unsigned char MaximumDimension; // max resolution of checkerboard
  int ParallelSplatCrossover;     // the point at which parallel splatting occurs
 
private:
  vtkCheckerboardSplatter(const vtkCheckerboardSplatter&) = delete;
  void operator=(const vtkCheckerboardSplatter&) = delete;
};
 
#endif