vtkSurfaceNets3D.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 vtkSurfaceNets3D_h
#define vtkSurfaceNets3D_h
 
#include "vtkConstrainedSmoothingFilter.h" // Perform mesh smoothing
#include "vtkContourValues.h"              // Needed for direct access to ContourValues
#include "vtkFiltersCoreModule.h"          // For export macro
#include "vtkPolyData.h"                   // To support data caching
#include "vtkPolyDataAlgorithm.h"
 
#include <vector> // For selected seeds
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkImageData;
 
class VTKFILTERSCORE_EXPORT vtkSurfaceNets3D : public vtkPolyDataAlgorithm
{
public:
 
  static vtkSurfaceNets3D* New();
  vtkTypeMacro(vtkSurfaceNets3D, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMTimeType GetMTime() override;
 
 
  void SetValue(int i, double value) { this->Labels->SetValue(i, value); }
  void SetLabel(int i, double value) { this->Labels->SetValue(i, value); }
 
 
  double GetValue(int i) { return this->Labels->GetValue(i); }
  double GetLabel(int i) { return this->Labels->GetValue(i); }
 
 
  double* GetValues() { return this->Labels->GetValues(); }
  double* GetLabels() { return this->Labels->GetValues(); }
 
 
  void GetValues(double* contourValues) { this->Labels->GetValues(contourValues); }
  void GetLabels(double* contourValues) { this->Labels->GetValues(contourValues); }
 
 
  void SetNumberOfLabels(int number) { this->Labels->SetNumberOfContours(number); }
  void SetNumberOfContours(int number) { this->Labels->SetNumberOfContours(number); }
 
 
  vtkIdType GetNumberOfLabels() { return this->Labels->GetNumberOfContours(); }
  vtkIdType GetNumberOfContours() { return this->Labels->GetNumberOfContours(); }
 
 
  void GenerateLabels(int numLabels, double range[2])
  {
    this->Labels->GenerateValues(numLabels, range);
  }
  void GenerateValues(int numContours, double range[2])
  {
    this->Labels->GenerateValues(numContours, range);
  }
  void GenerateLabels(int numLabels, double rangeStart, double rangeEnd)
  {
    this->Labels->GenerateValues(numLabels, rangeStart, rangeEnd);
  }
  void GenerateValues(int numContours, double rangeStart, double rangeEnd)
  {
    this->Labels->GenerateValues(numContours, rangeStart, rangeEnd);
  }
 
 
  vtkSetMacro(BackgroundLabel, double);
  vtkGetMacro(BackgroundLabel, double);
 
 
  vtkSetMacro(ArrayComponent, int);
  vtkGetMacro(ArrayComponent, int);
 
  enum MeshType
  {
    MESH_TYPE_DEFAULT = 0,
    MESH_TYPE_TRIANGLES,
    MESH_TYPE_QUADS
  };
 
 
  vtkSetClampMacro(OutputMeshType, int, MESH_TYPE_DEFAULT, MESH_TYPE_QUADS);
  vtkGetMacro(OutputMeshType, int);
  void SetOutputMeshTypeToDefault() { this->SetOutputMeshType(MESH_TYPE_DEFAULT); }
  void SetOutputMeshTypeToTriangles() { this->SetOutputMeshType(MESH_TYPE_TRIANGLES); }
  void SetOutputMeshTypeToQuads() { this->SetOutputMeshType(MESH_TYPE_QUADS); }
 
  // The following code is used to control the smoothing process. Internally
  // there is a vtkConstrainedSmoothingFilter that can be directly
  // manipulated.  In addition, methods that delegate to this filter are also
  // provided.
 
 
  vtkSetMacro(Smoothing, bool);
  vtkGetMacro(Smoothing, bool);
  vtkBooleanMacro(Smoothing, bool);
 
 
  void SetNumberOfIterations(int n) { this->Smoother->SetNumberOfIterations(n); }
  int GetNumberOfIterations() { return this->Smoother->GetNumberOfIterations(); }
  void SetRelaxationFactor(double f) { this->Smoother->SetRelaxationFactor(f); }
  double GetRelaxationFactor() { return this->Smoother->GetRelaxationFactor(); }
  void SetConstraintDistance(double d) { this->Smoother->SetConstraintDistance(d); }
  double GetConstraintDistance() { return this->Smoother->GetConstraintDistance(); }
  void SetConstraintBox(double sx, double sy, double sz)
  {
    this->Smoother->SetConstraintBox(sx, sy, sz);
  }
  void SetConstraintBox(double s[3]) { this->Smoother->SetConstraintBox(s); }
  double* GetConstraintBox() VTK_SIZEHINT(3) { return this->Smoother->GetConstraintBox(); }
  void GetConstraintBox(double s[3]) { this->Smoother->GetConstraintBox(s); }
  void SetConstraintStrategyToConstraintDistance()
  {
    this->Smoother->SetConstraintStrategyToConstraintDistance();
  }
  void SetConstraintStrategyToConstraintBox()
  {
    this->Smoother->SetConstraintStrategyToConstraintBox();
  }
  int GetConstraintStrategy() { return this->Smoother->GetConstraintStrategy(); }
 
 
  vtkSetMacro(AutomaticSmoothingConstraints, bool);
  vtkGetMacro(AutomaticSmoothingConstraints, bool);
  vtkBooleanMacro(AutomaticSmoothingConstraints, bool);
  vtkSetClampMacro(ConstraintScale, double, 0, 100);
  vtkGetMacro(ConstraintScale, double);
 
 
  vtkSetMacro(OptimizedSmoothingStencils, bool);
  vtkGetMacro(OptimizedSmoothingStencils, bool);
  vtkBooleanMacro(OptimizedSmoothingStencils, bool);
 
 
  vtkGetSmartPointerMacro(Smoother, vtkConstrainedSmoothingFilter);
 
  // The following code is used to control what is produced for output.
 
  enum OutputType
  {
    OUTPUT_STYLE_DEFAULT = 0,
    OUTPUT_STYLE_BOUNDARY,
    OUTPUT_STYLE_SELECTED
  };
 
 
  vtkSetClampMacro(OutputStyle, int, OUTPUT_STYLE_DEFAULT, OUTPUT_STYLE_SELECTED);
  vtkGetMacro(OutputStyle, int);
  void SetOutputStyleToDefault() { this->SetOutputStyle(OUTPUT_STYLE_DEFAULT); }
  void SetOutputStyleToBoundary() { this->SetOutputStyle(OUTPUT_STYLE_BOUNDARY); }
  void SetOutputStyleToSelected() { this->SetOutputStyle(OUTPUT_STYLE_SELECTED); }
 
 
  void InitializeSelectedLabelsList();
  void AddSelectedLabel(double label);
  void DeleteSelectedLabel(double label);
  vtkIdType GetNumberOfSelectedLabels();
  double GetSelectedLabel(vtkIdType ithLabel);
 
  enum TriangulationType
  {
    TRIANGULATION_GREEDY = 0,
    TRIANGULATION_MIN_EDGE,
    TRIANGULATION_MIN_AREA
  };
 
 
  vtkSetClampMacro(TriangulationStrategy, int, TRIANGULATION_GREEDY, TRIANGULATION_MIN_AREA);
  vtkGetMacro(TriangulationStrategy, int);
  void SetTriangulationStrategyToGreedy() { this->SetTriangulationStrategy(TRIANGULATION_GREEDY); }
  void SetTriangulationStrategyToMinEdge()
  {
    this->SetTriangulationStrategy(TRIANGULATION_MIN_EDGE);
  }
  void SetTriangulationStrategyToMinArea()
  {
    this->SetTriangulationStrategy(TRIANGULATION_MIN_AREA);
  }
 
 
  vtkSetMacro(DataCaching, bool);
  vtkGetMacro(DataCaching, bool);
  vtkBooleanMacro(DataCaching, bool);
 
protected:
  vtkSurfaceNets3D();
  ~vtkSurfaceNets3D() override = default;
 
  // Support visualization pipeline operations.
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  // Support the contouring operation.
  vtkSmartPointer<vtkContourValues> Labels;
  bool ComputeScalars;
  double BackgroundLabel;
  int ArrayComponent;
  int OutputMeshType;
 
  // Support smoothing.
  bool Smoothing;
  bool OptimizedSmoothingStencils;
  vtkSmartPointer<vtkConstrainedSmoothingFilter> Smoother;
  bool AutomaticSmoothingConstraints;
  double ConstraintScale;
 
  // Support data caching of the extracted surface nets. This is used to
  // avoid repeated surface extraction when only smoothing filter
  // parameters are modified.
  bool DataCaching;
  vtkSmartPointer<vtkPolyData> GeometryCache;
  vtkSmartPointer<vtkCellArray> StencilsCache;
  vtkTimeStamp SmoothingTime;
  bool IsCacheEmpty();
  void CacheData(vtkPolyData* pd, vtkCellArray* ca);
 
  // Support output style
  int OutputStyle;
  std::vector<double> SelectedLabels;
  vtkTimeStamp SelectedLabelsTime;
 
  // Support triangulation strategy
  int TriangulationStrategy;
 
private:
  vtkSurfaceNets3D(const vtkSurfaceNets3D&) = delete;
  void operator=(const vtkSurfaceNets3D&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif