vtkAttributeSmoothingFilter.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 vtkAttributeSmoothingFilter_h
#define vtkAttributeSmoothingFilter_h
 
#include "vtkDataSetAlgorithm.h"
#include "vtkFiltersGeometryModule.h" // For export macro
#include "vtkSmartPointer.h"          // For point smoothing mask
#include "vtkUnsignedCharArray.h"     // For point smoothing mask
#include <vector>                     //For std::vector<> - ExcludedArrays
 
VTK_ABI_NAMESPACE_BEGIN
class VTKFILTERSGEOMETRY_EXPORT vtkAttributeSmoothingFilter : public vtkDataSetAlgorithm
{
public:
 
  static vtkAttributeSmoothingFilter* New();
  vtkTypeMacro(vtkAttributeSmoothingFilter, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetClampMacro(NumberOfIterations, int, 0, VTK_INT_MAX);
  vtkGetMacro(NumberOfIterations, int);
 
 
  vtkSetClampMacro(RelaxationFactor, double, 0.0, 1.0);
  vtkGetMacro(RelaxationFactor, double);
 
  enum SmoothingStrategyType
  {
    ALL_POINTS = 0,
    ALL_BUT_BOUNDARY = 1,
    ADJACENT_TO_BOUNDARY = 2,
    SMOOTHING_MASK = 3
  };
 
 
  vtkSetClampMacro(SmoothingStrategy, int, ALL_POINTS, SMOOTHING_MASK);
  vtkGetMacro(SmoothingStrategy, int);
  void SetSmoothingStrategyToAllPoints() { this->SetSmoothingStrategy(ALL_POINTS); }
  void SetSmoothingStrategyToAllButBoundary() { this->SetSmoothingStrategy(ALL_BUT_BOUNDARY); }
  void SetSmoothingStrategyToAdjacentToBoundary()
  {
    this->SetSmoothingStrategy(ADJACENT_TO_BOUNDARY);
  }
  void SetSmoothingStrategyToSmoothingMask() { this->SetSmoothingStrategy(SMOOTHING_MASK); }
 
 
  vtkSetSmartPointerMacro(SmoothingMask, vtkUnsignedCharArray);
  vtkGetSmartPointerMacro(SmoothingMask, vtkUnsignedCharArray);
 
  enum InterpolationWeightsType
  {
    AVERAGE = 0,
    DISTANCE = 1,
    DISTANCE2 = 2
  };
 
 
  vtkSetClampMacro(WeightsType, int, AVERAGE, DISTANCE2);
  vtkGetMacro(WeightsType, int);
  void SetWeightsTypeToAverage() { this->SetWeightsType(AVERAGE); }
  void SetWeightsTypeToDistance() { this->SetWeightsType(DISTANCE); }
  void SetWeightsTypeToDistance2() { this->SetWeightsType(DISTANCE2); }
 
 
  void AddExcludedArray(const std::string& 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();
  }
 
protected:
  vtkAttributeSmoothingFilter();
  ~vtkAttributeSmoothingFilter() override = default;
 
  int NumberOfIterations;
  double RelaxationFactor;
  int SmoothingStrategy;
  vtkSmartPointer<vtkUnsignedCharArray> SmoothingMask;
  int WeightsType;
 
  std::vector<std::string> ExcludedArrays;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
private:
  vtkAttributeSmoothingFilter(const vtkAttributeSmoothingFilter&) = delete;
  void operator=(const vtkAttributeSmoothingFilter&) = delete;
};
VTK_ABI_NAMESPACE_END
 
#endif