vtkGaussianSplatter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkGaussianSplatter_h
#define vtkGaussianSplatter_h
 
#include "vtkImageAlgorithm.h"
#include "vtkImagingHybridModule.h" // For export macro
 
#include <cmath> // for std::exp
 
#define VTK_ACCUMULATION_MODE_MIN 0
#define VTK_ACCUMULATION_MODE_MAX 1
#define VTK_ACCUMULATION_MODE_SUM 2
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDoubleArray;
class vtkCompositeDataSet;
class vtkGaussianSplatterAlgorithm;
 
class VTKIMAGINGHYBRID_EXPORT vtkGaussianSplatter : public vtkImageAlgorithm
{
public:
  vtkTypeMacro(vtkGaussianSplatter, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkGaussianSplatter* 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(Radius, double, 0.0, 1.0);
  vtkGetMacro(Radius, double);
 
 
  vtkSetClampMacro(ScaleFactor, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(ScaleFactor, double);
 
 
  vtkSetMacro(ExponentFactor, double);
  vtkGetMacro(ExponentFactor, double);
 
 
  vtkSetMacro(NormalWarping, vtkTypeBool);
  vtkGetMacro(NormalWarping, vtkTypeBool);
  vtkBooleanMacro(NormalWarping, vtkTypeBool);
 
 
  vtkSetClampMacro(Eccentricity, double, 0.001, VTK_DOUBLE_MAX);
  vtkGetMacro(Eccentricity, double);
 
 
  vtkSetMacro(ScalarWarping, vtkTypeBool);
  vtkGetMacro(ScalarWarping, vtkTypeBool);
  vtkBooleanMacro(ScalarWarping, vtkTypeBool);
 
 
  vtkSetMacro(Capping, vtkTypeBool);
  vtkGetMacro(Capping, vtkTypeBool);
  vtkBooleanMacro(Capping, vtkTypeBool);
 
 
  vtkSetMacro(CapValue, double);
  vtkGetMacro(CapValue, 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(NullValue, double);
  vtkGetMacro(NullValue, double);
 
 
  void ComputeModelBounds(vtkDataSet* input, vtkImageData* output, vtkInformation* outInfo);
  void ComputeModelBounds(
    vtkCompositeDataSet* input, vtkImageData* output, vtkInformation* outInfo);
 
 
  friend class vtkGaussianSplatterAlgorithm;
  double SamplePoint(double x[3]) // for compilers who can't handle this
  {
    return (this->*Sample)(x);
  }
  void SetScalar(vtkIdType idx, double dist2, double* sPtr)
  {
    double v = (this->*SampleFactor)(this->S) *
      std::exp(static_cast<double>(this->ExponentFactor * (dist2) / (this->Radius2)));
 
    if (!this->Visited[idx])
    {
      this->Visited[idx] = 1;
      *sPtr = v;
    }
    else
    {
      switch (this->AccumulationMode)
      {
        case VTK_ACCUMULATION_MODE_MIN:
          if (*sPtr > v)
          {
            *sPtr = v;
          }
          break;
        case VTK_ACCUMULATION_MODE_MAX:
          if (*sPtr < v)
          {
            *sPtr = v;
          }
          break;
        case VTK_ACCUMULATION_MODE_SUM:
          *sPtr += v;
          break;
      }
    } // not first visit
  }
 
protected:
  vtkGaussianSplatter();
  ~vtkGaussianSplatter() override = default;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  void Cap(vtkDoubleArray* s);
 
  int SampleDimensions[3];   // dimensions of volume to splat into
  double Radius;             // maximum distance splat propagates (as fraction 0->1)
  double ExponentFactor;     // scale exponent of gaussian function
  double ModelBounds[6];     // bounding box of splatting dimensions
  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 Gaussian(double x[3]);
  double EccentricGaussian(double x[3]);
  double ScalarSampling(double s) { return this->ScaleFactor * s; }
  double PositionSampling(double) { return this->ScaleFactor; }
 
private:
  double Radius2;
  double (vtkGaussianSplatter::*Sample)(double x[3]);
  double (vtkGaussianSplatter::*SampleFactor)(double s);
  char* Visited;
  double Eccentricity2;
  double* P;
  double* N;
  double S;
  double Origin[3];
  double Spacing[3];
  double SplatDistance[3];
  double NullValue;
 
  vtkGaussianSplatter(const vtkGaussianSplatter&) = delete;
  void operator=(const vtkGaussianSplatter&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif