vtkSPHInterpolator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkSPHInterpolator.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 vtkSPHInterpolator_h
#define vtkSPHInterpolator_h
 
#include "vtkDataSetAlgorithm.h"
#include "vtkFiltersPointsModule.h" // For export macro
#include "vtkStdString.h"           // For vtkStdString ivars
#include <vector>                   //For STL vector
 
class vtkAbstractPointLocator;
class vtkIdList;
class vtkDoubleArray;
class vtkSPHKernel;
class vtkCharArray;
class vtkFloatArray;
 
class VTKFILTERSPOINTS_EXPORT vtkSPHInterpolator : public vtkDataSetAlgorithm
{
public:
 
  static vtkSPHInterpolator* New();
  vtkTypeMacro(vtkSPHInterpolator, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetSourceData(vtkDataObject* source);
  vtkDataObject* GetSource();
 
  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
 
 
  void SetLocator(vtkAbstractPointLocator* locator);
  vtkGetObjectMacro(Locator, vtkAbstractPointLocator);
 
 
  void SetKernel(vtkSPHKernel* kernel);
  vtkGetObjectMacro(Kernel, vtkSPHKernel);
 
 
  vtkSetMacro(CutoffArrayName, vtkStdString);
  vtkGetMacro(CutoffArrayName, vtkStdString);
 
 
  vtkSetMacro(DensityArrayName, vtkStdString);
  vtkGetMacro(DensityArrayName, vtkStdString);
 
 
  vtkSetMacro(MassArrayName, vtkStdString);
  vtkGetMacro(MassArrayName, vtkStdString);
 
 
  void AddExcludedArray(const vtkStdString& excludedArray)
  {
    this->ExcludedArrays.push_back(excludedArray);
    this->Modified();
  }
 
 
  void ClearExcludedArrays()
  {
    this->ExcludedArrays.clear();
    this->Modified();
  }
 
  int GetNumberOfExcludedArrays() { return static_cast<int>(this->ExcludedArrays.size()); }
 
 
  const char* GetExcludedArray(int i)
  {
    if (i < 0 || i >= static_cast<int>(this->ExcludedArrays.size()))
    {
      return nullptr;
    }
    return this->ExcludedArrays[i].c_str();
  }
 
 
  void AddDerivativeArray(const vtkStdString& derivArray)
  {
    this->DerivArrays.push_back(derivArray);
    this->Modified();
  }
 
 
  void ClearDerivativeArrays()
  {
    this->DerivArrays.clear();
    this->Modified();
  }
 
  int GetNumberOfDerivativeArrays() { return static_cast<int>(this->DerivArrays.size()); }
 
 
  const char* GetDerivativeArray(int i)
  {
    if (i < 0 || i >= static_cast<int>(this->DerivArrays.size()))
    {
      return nullptr;
    }
    return this->DerivArrays[i].c_str();
  }
 
  // How to handle NULL/empty points
  enum NullStrategy
  {
    MASK_POINTS = 0,
    NULL_VALUE = 1
  };
 
 
  vtkSetMacro(NullPointsStrategy, int);
  vtkGetMacro(NullPointsStrategy, int);
  void SetNullPointsStrategyToMaskPoints() { this->SetNullPointsStrategy(MASK_POINTS); }
  void SetNullPointsStrategyToNullValue() { this->SetNullPointsStrategy(NULL_VALUE); }
 
 
  vtkSetMacro(ValidPointsMaskArrayName, vtkStdString);
  vtkGetMacro(ValidPointsMaskArrayName, vtkStdString);
 
 
  vtkSetMacro(NullValue, double);
  vtkGetMacro(NullValue, double);
 
 
  vtkSetMacro(ComputeShepardSum, vtkTypeBool);
  vtkBooleanMacro(ComputeShepardSum, vtkTypeBool);
  vtkGetMacro(ComputeShepardSum, vtkTypeBool);
 
 
  vtkSetMacro(ShepardSumArrayName, vtkStdString);
  vtkGetMacro(ShepardSumArrayName, vtkStdString);
 
 
  vtkSetMacro(PromoteOutputArrays, vtkTypeBool);
  vtkBooleanMacro(PromoteOutputArrays, vtkTypeBool);
  vtkGetMacro(PromoteOutputArrays, vtkTypeBool);
 
 
  vtkSetMacro(PassPointArrays, vtkTypeBool);
  vtkBooleanMacro(PassPointArrays, vtkTypeBool);
  vtkGetMacro(PassPointArrays, vtkTypeBool);
 
 
  vtkSetMacro(PassCellArrays, vtkTypeBool);
  vtkBooleanMacro(PassCellArrays, vtkTypeBool);
  vtkGetMacro(PassCellArrays, vtkTypeBool);
 
 
  vtkSetMacro(PassFieldArrays, vtkTypeBool);
  vtkBooleanMacro(PassFieldArrays, vtkTypeBool);
  vtkGetMacro(PassFieldArrays, vtkTypeBool);
 
 
  vtkSetMacro(ShepardNormalization, vtkTypeBool);
  vtkBooleanMacro(ShepardNormalization, vtkTypeBool);
  vtkGetMacro(ShepardNormalization, vtkTypeBool);
 
  vtkMTimeType GetMTime() override;
 
protected:
  vtkSPHInterpolator();
  ~vtkSPHInterpolator() override;
 
  vtkAbstractPointLocator* Locator;
  vtkSPHKernel* Kernel;
 
  vtkStdString CutoffArrayName;
 
  vtkStdString DensityArrayName;
  vtkStdString MassArrayName;
 
  std::vector<vtkStdString> ExcludedArrays;
  std::vector<vtkStdString> DerivArrays;
 
  vtkTypeBool ShepardNormalization;
 
  int NullPointsStrategy;
  double NullValue;
  vtkStdString ValidPointsMaskArrayName;
  vtkCharArray* ValidPointsMask;
 
  vtkTypeBool ComputeShepardSum;
  vtkStdString ShepardSumArrayName;
 
  vtkTypeBool PromoteOutputArrays;
 
  vtkTypeBool PassCellArrays;
  vtkTypeBool PassPointArrays;
  vtkTypeBool PassFieldArrays;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  virtual void Probe(vtkDataSet* input, vtkDataSet* source, vtkDataSet* output);
 
  virtual void PassAttributeData(vtkDataSet* input, vtkDataObject* source, vtkDataSet* output);
 
private:
  vtkSPHInterpolator(const vtkSPHInterpolator&) = delete;
  void operator=(const vtkSPHInterpolator&) = delete;
};
 
#endif