vtkGeneralizedSurfaceNets3D.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 vtkGeneralizedSurfaceNets3D_h
#define vtkGeneralizedSurfaceNets3D_h
 
#include "vtkConstrainedSmoothingFilter.h" // Perform surface smoothing
#include "vtkContourValues.h"              // Manage countour values
#include "vtkFiltersMeshingModule.h"       // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkStaticPointLocator.h" // For point locator
#include "vtkWrappingHints.h"      // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKFILTERSMESHING_EXPORT VTK_MARSHALAUTO vtkGeneralizedSurfaceNets3D
  : public vtkPolyDataAlgorithm
{
public:

  static vtkGeneralizedSurfaceNets3D* New();
  vtkTypeMacro(vtkGeneralizedSurfaceNets3D, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //---------------The following are methods used to set/get and generate
  //---------------contour labels. Contour labels are required to be
  //---------------specified by this filter.

  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, int);
  vtkGetMacro(BackgroundLabel, int);
 
  //---------------Done defining label-related methods.

  vtkGetMacro(BoundaryCapping, vtkTypeBool);
  vtkSetMacro(BoundaryCapping, vtkTypeBool);
  vtkBooleanMacro(BoundaryCapping, vtkTypeBool);


  vtkGetMacro(MergePoints, vtkTypeBool);
  vtkSetMacro(MergePoints, vtkTypeBool);
  vtkBooleanMacro(MergePoints, vtkTypeBool);


  vtkSetMacro(Smoothing, vtkTypeBool);
  vtkGetMacro(Smoothing, vtkTypeBool);
  vtkBooleanMacro(Smoothing, vtkTypeBool);


  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(); }


  vtkSetMacro(GenerateSmoothingStencils, vtkTypeBool);
  vtkGetMacro(GenerateSmoothingStencils, vtkTypeBool);
  vtkBooleanMacro(GenerateSmoothingStencils, vtkTypeBool);


  vtkSetVector4Macro(SmoothingConstraints, unsigned char);
  vtkGetVector4Macro(SmoothingConstraints, unsigned char);
  void AllSmoothingConstraintsOn() { this->SetSmoothingConstraints(1, 1, 1, 1); }
  void AllSmoothingConstraintsOff() { this->SetSmoothingConstraints(0, 0, 0, 0); }
  void EdgeSmoothingConstraintOff() { this->SetSmoothingConstraints(1, 0, 1, 1); }


  vtkGetSmartPointerMacro(Smoother, vtkConstrainedSmoothingFilter);

  enum MeshType
  {
    MESH_TYPE_DEFAULT = 0,
    MESH_TYPE_TRIANGLES,
    MESH_TYPE_POLYGONS
  };


  vtkSetClampMacro(OutputMeshType, int, MESH_TYPE_DEFAULT, MESH_TYPE_POLYGONS);
  vtkGetMacro(OutputMeshType, int);
  void SetOutputMeshTypeToDefault() { this->SetOutputMeshType(MESH_TYPE_DEFAULT); }
  void SetOutputMeshTypeToTriangles() { this->SetOutputMeshType(MESH_TYPE_TRIANGLES); }
  void SetOutputMeshTypeToPolygons() { this->SetOutputMeshType(MESH_TYPE_POLYGONS); }


  vtkSetClampMacro(Padding, double, 0.001, 0.25);
  vtkGetMacro(Padding, double);


  vtkStaticPointLocator* GetLocator() { return this->Locator; }


  vtkSetMacro(Validate, vtkTypeBool);
  vtkGetMacro(Validate, vtkTypeBool);
  vtkBooleanMacro(Validate, vtkTypeBool);


  vtkSetClampMacro(PointOfInterest, vtkIdType, -1, VTK_ID_MAX);
  vtkGetMacro(PointOfInterest, vtkIdType);
  vtkSetObjectMacro(PointsOfInterest, vtkIdTypeArray);
  vtkGetObjectMacro(PointsOfInterest, vtkIdTypeArray);
  vtkSetClampMacro(MaximumNumberOfHullClips, vtkIdType, 1, VTK_ID_MAX);
  vtkGetMacro(MaximumNumberOfHullClips, vtkIdType);


  vtkSetClampMacro(PruneTolerance, double, 0.0, 0.5);
  vtkGetMacro(PruneTolerance, double);


  vtkSetClampMacro(BatchSize, unsigned int, 1, VTK_INT_MAX);
  vtkGetMacro(BatchSize, unsigned int);

  int GetNumberOfThreads() { return this->NumberOfThreads; }

  int GetNumberOfPrunes() { return this->NumberOfPrunes; }

  vtkMTimeType GetMTime() override;
 
protected:
  vtkGeneralizedSurfaceNets3D();
  ~vtkGeneralizedSurfaceNets3D() override = default;
 
  // Support the contouring operation by defining labels.
  vtkSmartPointer<vtkContourValues> Labels;
  int BackgroundLabel;
 
  // Algorithm control
  vtkTypeBool BoundaryCapping; // produce boundary surfaces or not
  vtkTypeBool MergePoints;     // merge near coincident points or not
  vtkTypeBool Smoothing;       // enable built-in smoothing process
 
  // Internal classes Related to point location and smoothing control
  vtkSmartPointer<vtkConstrainedSmoothingFilter> Smoother; // built in smoother
  vtkSmartPointer<vtkStaticPointLocator> Locator;          // locator for finding proximal points
 
  // Control the type of output mesh. Triangles by default.
  int OutputMeshType;
 
  // Related to internal Voronoi methods
  double Padding;                        // amount to pad out input points bounding box
  vtkTypeBool Validate;                  // Choose to validate and repair output
  vtkTypeBool GenerateSmoothingStencils; // Produce smoothing stencils
  unsigned char SmoothingConstraints[4]; // Specify which smoothing constraints are active
  vtkIdType PointOfInterest;             // specify a single input point to process
  vtkSmartPointer<vtkIdTypeArray> PointsOfInterest; // list of points of interest
  vtkIdType MaximumNumberOfHullClips;               // limit the number of hull clips
  double PruneTolerance;                            // prune tiny faces
  unsigned int BatchSize;                           // process data in batches of specified size
  int NumberOfThreads; // report on the number of threads used during processing
  int NumberOfPrunes;  // If spoke pruning is enabled, report number of pruning operations
 
  // Satisfy pipeline-related API
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
private:
  vtkGeneralizedSurfaceNets3D(const vtkGeneralizedSurfaceNets3D&) = delete;
  void operator=(const vtkGeneralizedSurfaceNets3D&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif