vtkDecimatePro.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 vtkDecimatePro_h
#define vtkDecimatePro_h
 
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#include "vtkCell.h" // Needed for VTK_CELL_SIZE
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDoubleArray;
class vtkPriorityQueue;
 
class VTKFILTERSCORE_EXPORT vtkDecimatePro : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkDecimatePro, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkDecimatePro* New();
 
 
  vtkSetClampMacro(TargetReduction, double, 0.0, 1.0);
  vtkGetMacro(TargetReduction, double);
 
 
  vtkSetMacro(PreserveTopology, vtkTypeBool);
  vtkGetMacro(PreserveTopology, vtkTypeBool);
  vtkBooleanMacro(PreserveTopology, vtkTypeBool);
 
 
  vtkSetClampMacro(FeatureAngle, double, 0.0, 180.0);
  vtkGetMacro(FeatureAngle, double);
 
 
  vtkSetMacro(Splitting, vtkTypeBool);
  vtkGetMacro(Splitting, vtkTypeBool);
  vtkBooleanMacro(Splitting, vtkTypeBool);
 
 
  vtkSetClampMacro(SplitAngle, double, 0.0, 180.0);
  vtkGetMacro(SplitAngle, double);
 
 
  vtkSetMacro(PreSplitMesh, vtkTypeBool);
  vtkGetMacro(PreSplitMesh, vtkTypeBool);
  vtkBooleanMacro(PreSplitMesh, vtkTypeBool);
 
 
  vtkSetClampMacro(MaximumError, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(MaximumError, double);
 
 
  vtkSetMacro(AccumulateError, vtkTypeBool);
  vtkGetMacro(AccumulateError, vtkTypeBool);
  vtkBooleanMacro(AccumulateError, vtkTypeBool);
 
 
  vtkSetMacro(ErrorIsAbsolute, int);
  vtkGetMacro(ErrorIsAbsolute, int);
 
 
  vtkSetClampMacro(AbsoluteError, double, 0.0, VTK_DOUBLE_MAX);
  vtkGetMacro(AbsoluteError, double);
 
 
  vtkSetMacro(BoundaryVertexDeletion, vtkTypeBool);
  vtkGetMacro(BoundaryVertexDeletion, vtkTypeBool);
  vtkBooleanMacro(BoundaryVertexDeletion, vtkTypeBool);
 
 
  vtkSetClampMacro(Degree, int, 25, VTK_CELL_SIZE);
  vtkGetMacro(Degree, int);
 
 
  vtkSetClampMacro(InflectionPointRatio, double, 1.001, VTK_DOUBLE_MAX);
  vtkGetMacro(InflectionPointRatio, double);
 
  vtkIdType GetNumberOfInflectionPoints();
 
  void GetInflectionPoints(double* inflectionPoints);
 
  double* GetInflectionPoints();
 
 
  vtkSetMacro(OutputPointsPrecision, int);
  vtkGetMacro(OutputPointsPrecision, int);
 
protected:
  vtkDecimatePro();
  ~vtkDecimatePro() override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  double TargetReduction;
  double FeatureAngle;
  double MaximumError;
  double AbsoluteError;
  int ErrorIsAbsolute;
  vtkTypeBool AccumulateError;
  double SplitAngle;
  vtkTypeBool Splitting;
  vtkTypeBool PreSplitMesh;
  vtkTypeBool BoundaryVertexDeletion;
  vtkTypeBool PreserveTopology;
  int Degree;
  double InflectionPointRatio;
  vtkDoubleArray* InflectionPoints;
  int OutputPointsPrecision;
 
  // to replace a static object
  vtkIdList* Neighbors;
  vtkPriorityQueue* EdgeLengths;
 
  void SplitMesh();
  int EvaluateVertex(vtkIdType ptId, vtkIdType numTris, vtkIdType* tris, vtkIdType fedges[2]);
  vtkIdType FindSplit(
    int type, vtkIdType fedges[2], vtkIdType& pt1, vtkIdType& pt2, vtkIdList* CollapseTris);
  int IsValidSplit(int index);
  void SplitLoop(vtkIdType fedges[2], vtkIdType& n1, vtkIdType* l1, vtkIdType& n2, vtkIdType* l2);
  void SplitVertex(vtkIdType ptId, int type, vtkIdType numTris, vtkIdType* tris, int insert);
  int CollapseEdge(int type, vtkIdType ptId, vtkIdType collapseId, vtkIdType pt1, vtkIdType pt2,
    vtkIdList* CollapseTris);
  void DistributeError(double error);
 
  //
  // Special classes for manipulating data
  //
  // Special structures for building loops
  class LocalVertex
  {
  public:
    vtkIdType id;
    double x[3];
    double FAngle;
  };
  typedef LocalVertex* LocalVertexPtr;
 
  class LocalTri
  {
  public:
    vtkIdType id;
    double area;
    double n[3];
    vtkIdType verts[3];
  };
  typedef LocalTri* LocalTriPtr;
 
  class VertexArray;
  friend class VertexArray;
  class VertexArray
  { //;prevent man page generation
  public:
    VertexArray(const vtkIdType sz)
    {
      this->MaxId = -1;
      this->Array = new LocalVertex[sz];
    }
    ~VertexArray() { delete[] this->Array; }
    vtkIdType GetNumberOfVertices() { return this->MaxId + 1; }
    void InsertNextVertex(LocalVertex& v)
    {
      this->MaxId++;
      this->Array[this->MaxId] = v;
    }
    LocalVertex& GetVertex(vtkIdType i) { return this->Array[i]; }
    void Reset() { this->MaxId = -1; }
 
    LocalVertex* Array; // pointer to data
    vtkIdType MaxId;    // maximum index inserted thus far
  };
 
  class TriArray;
  friend class TriArray;
  class TriArray
  { //;prevent man page generation
  public:
    TriArray(const vtkIdType sz)
    {
      this->MaxId = -1;
      this->Array = new LocalTri[sz];
    }
    ~TriArray() { delete[] this->Array; }
    vtkIdType GetNumberOfTriangles() { return this->MaxId + 1; }
    void InsertNextTriangle(LocalTri& t)
    {
      this->MaxId++;
      this->Array[this->MaxId] = t;
    }
    LocalTri& GetTriangle(vtkIdType i) { return this->Array[i]; }
    void Reset() { this->MaxId = -1; }
 
    LocalTri* Array; // pointer to data
    vtkIdType MaxId; // maximum index inserted thus far
  };
 
private:
  void InitializeQueue(vtkIdType numPts);
  void DeleteQueue();
  void Insert(vtkIdType id, double error = -1.0);
  int Pop(double& error);
  double DeleteId(vtkIdType id);
  void Reset();
 
  vtkPriorityQueue* Queue;
  vtkDoubleArray* VertexError;
 
  VertexArray* V;
  TriArray* T;
 
  // Use to be static variables used by object
  vtkPolyData* Mesh;               // operate on this data structure
  double Pt[3];                    // least squares plane point
  double Normal[3];                // least squares plane normal
  double LoopArea;                 // the total area of all triangles in a loop
  double CosAngle;                 // Cosine of dihedral angle
  double Tolerance;                // Intersection tolerance
  double X[3];                     // coordinates of current point
  int NumCollapses;                // Number of times edge collapses occur
  int NumMerges;                   // Number of times vertex merges occur
  int Split;                       // Controls whether and when vertex splitting occurs
  int VertexDegree;                // Maximum number of triangles that can use a vertex
  vtkIdType NumberOfRemainingTris; // Number of triangles left in the mesh
  double TheSplitAngle;            // Split angle
  int SplitState;                  // State of the splitting process
  double Error;                    // Maximum allowable surface error
 
  vtkDecimatePro(const vtkDecimatePro&) = delete;
  void operator=(const vtkDecimatePro&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif