vtkDecimatePro.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkDecimatePro.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 vtkDecimatePro_h
#define vtkDecimatePro_h
 
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
 
#include "vtkCell.h" // Needed for VTK_CELL_SIZE
 
class vtkDoubleArray;
class vtkPriorityQueue;
 
class VTKFILTERSCORE_EXPORT vtkDecimatePro : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkDecimatePro,vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkDecimatePro *New();
 
 
  vtkSetClampMacro(TargetReduction,double,0.0,1.0);
  vtkGetMacro(TargetReduction,double);
 
 
  vtkSetMacro(PreserveTopology,int);
  vtkGetMacro(PreserveTopology,int);
  vtkBooleanMacro(PreserveTopology,int);
 
 
  vtkSetClampMacro(FeatureAngle,double,0.0,180.0);
  vtkGetMacro(FeatureAngle,double);
 
 
  vtkSetMacro(Splitting,int);
  vtkGetMacro(Splitting,int);
  vtkBooleanMacro(Splitting,int);
 
 
  vtkSetClampMacro(SplitAngle,double,0.0,180.0);
  vtkGetMacro(SplitAngle,double);
 
 
  vtkSetMacro(PreSplitMesh,int);
  vtkGetMacro(PreSplitMesh,int);
  vtkBooleanMacro(PreSplitMesh,int);
 
 
  vtkSetClampMacro(MaximumError,double,0.0,VTK_DOUBLE_MAX);
  vtkGetMacro(MaximumError,double);
 
 
  vtkSetMacro(AccumulateError,int);
  vtkGetMacro(AccumulateError,int);
  vtkBooleanMacro(AccumulateError,int);
 
 
  vtkSetMacro(ErrorIsAbsolute,int);
  vtkGetMacro(ErrorIsAbsolute,int);
 
 
  vtkSetClampMacro(AbsoluteError,double,0.0,VTK_DOUBLE_MAX);
  vtkGetMacro(AbsoluteError,double);
 
 
  vtkSetMacro(BoundaryVertexDeletion,int);
  vtkGetMacro(BoundaryVertexDeletion,int);
  vtkBooleanMacro(BoundaryVertexDeletion,int);
 
 
  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();
 
  int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
 
  double TargetReduction;
  double FeatureAngle;
  double MaximumError;
  double AbsoluteError;
  int ErrorIsAbsolute;
  int AccumulateError;
  double SplitAngle;
  int Splitting;
  int PreSplitMesh;
  int BoundaryVertexDeletion;
  int PreserveTopology;
  int Degree;
  double InflectionPointRatio;
  vtkDoubleArray *InflectionPoints;
  int OutputPointsPrecision;
 
  // to replace a static object
  vtkIdList *Neighbors;
  vtkPriorityQueue *EdgeLengths;
 
  void SplitMesh();
  int EvaluateVertex(vtkIdType ptId, unsigned short int 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, unsigned short int 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
  //
  //BTX - begin tcl exclude
  //
  // 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
  };
  //ETX - end tcl exclude
  //
 
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
 
private:
  vtkDecimatePro(const vtkDecimatePro&);  // Not implemented.
  void operator=(const vtkDecimatePro&);  // Not implemented.
};
 
#endif