Patented/vtkDecimate.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkDecimate.h,v $

  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.


     THIS CLASS IS PATENTED UNDER UNITED STATES PATENT NUMBER 5,559,388
     "Method for Reducting the Complexity of a Polygonal Mesh".
     Application of this software for commercial purposes requires 
     a license grant from GE. Contact:

         Carl B. Horton
         Sr. Counsel, Intellectual Property
         3000 N. Grandview Blvd., W-710
         Waukesha, WI  53188
         Phone:  (262) 513-4022
         E-Mail: Carl.Horton@med.ge.com

     for more information.

=========================================================================*/
#ifndef __vtkDecimate_h
#define __vtkDecimate_h

#include "vtkPolyDataToPolyDataFilter.h"

#include "vtkCell.h" // Needed for VTK_CELL_SIZE

#define VTK_NUMBER_STATISTICS 12

class vtkIdList;

class VTK_PATENTED_EXPORT vtkDecimate : public vtkPolyDataToPolyDataFilter
{
public:
  static vtkDecimate *New();
  vtkTypeRevisionMacro(vtkDecimate,vtkPolyDataToPolyDataFilter);
  void PrintSelf(ostream& os, vtkIndent indent);


  vtkSetClampMacro(InitialError,double,0.0,1.0);
  vtkGetMacro(InitialError,double);


  vtkSetClampMacro(ErrorIncrement,double,0.0,1.0);
  vtkGetMacro(ErrorIncrement,double);


  vtkSetClampMacro(MaximumError,double,0.0,1.0);
  vtkGetMacro(MaximumError,double);


  vtkSetClampMacro(TargetReduction,double,0.0,1.0);
  vtkGetMacro(TargetReduction,double);


  vtkSetClampMacro(MaximumIterations,int,0,VTK_LARGE_INTEGER);
  vtkGetMacro(MaximumIterations,int);


  vtkSetClampMacro(MaximumSubIterations,int,1,VTK_LARGE_INTEGER);
  vtkGetMacro(MaximumSubIterations,int);
  

  vtkSetClampMacro(InitialFeatureAngle,double,0.0,180.0);
  vtkGetMacro(InitialFeatureAngle,double);


  vtkSetClampMacro(FeatureAngleIncrement,double,0.0,180.0);
  vtkGetMacro(FeatureAngleIncrement,double);


  vtkSetClampMacro(MaximumFeatureAngle,double,0.0,180.0);
  vtkGetMacro(MaximumFeatureAngle,double);


  vtkSetMacro(GenerateErrorScalars,int);
  vtkGetMacro(GenerateErrorScalars,int);
  vtkBooleanMacro(GenerateErrorScalars,int);


  vtkSetMacro(PreserveEdges,int);
  vtkGetMacro(PreserveEdges,int);
  vtkBooleanMacro(PreserveEdges,int);


  vtkSetMacro(BoundaryVertexDeletion,int);
  vtkGetMacro(BoundaryVertexDeletion,int);
  vtkBooleanMacro(BoundaryVertexDeletion,int);


  vtkSetClampMacro(AspectRatio,double,1.0,1000.0);
  vtkGetMacro(AspectRatio,double);


  vtkSetMacro(PreserveTopology,int);
  vtkGetMacro(PreserveTopology,int);
  vtkBooleanMacro(PreserveTopology,int);


  vtkSetClampMacro(Degree,int,25,VTK_CELL_SIZE);
  vtkGetMacro(Degree,int);
  

  vtkSetClampMacro(MaximumNumberOfSquawks,int,0,VTK_LARGE_INTEGER);
  vtkGetMacro(MaximumNumberOfSquawks,int);
  
protected:

  //
  // Special classes for manipulating data
  //
  //BTX - begin tcl exclude
  //
  // Special structures for building loops
  class LocalVertex
  {
  public:
    vtkIdType     id;
    double   x[3];
    double   FAngle;
    int     deRefs; //monitor memory requirements; new only when necessary
    int     newRefs;
  };
  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() {if (this->Array) {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() {if (this->Array) {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
  //

  vtkDecimate();
  ~vtkDecimate();

  void Execute();

  double InitialFeatureAngle; // dihedral angle constraint
  double FeatureAngleIncrement;
  double MaximumFeatureAngle;
  int PreserveEdges; // do/don't worry about feature edges
  int BoundaryVertexDeletion;  
  double InitialError; // decimation error in fraction of bounding box
  double ErrorIncrement; // each iteration will bump error this amount
  double MaximumError; // maximum error
  double TargetReduction; //target reduction of mesh (fraction)
  int MaximumIterations; // maximum number of passes over data
  int MaximumSubIterations; // maximum non-incrementing passes
  double AspectRatio; // control triangle shape during triangulation
  int Degree; // maximum number of triangles incident on vertex
  int Stats[VTK_NUMBER_STATISTICS]; // keep track of interesting statistics
  int GenerateErrorScalars; // turn on/off vertex error scalar generation
  int MaximumNumberOfSquawks; //control number of error messages
  int PreserveTopology; //control whether mesh topology is preserved
  vtkIdList *Neighbors; // to replace static
  VertexArray *V; //to replace static
  TriArray *T; //to replace static
  
  void CreateOutput(vtkIdType numPts, vtkIdType numTris,
                    vtkIdType numEliminated, vtkPointData *pd,
                    vtkPoints *inPts);
  int BuildLoop(vtkIdType ptId, unsigned short int nTris, vtkIdType* tris);
  void EvaluateLoop(int& vtype, vtkIdType& numFEdges,
                    LocalVertexPtr fedges[]);
  int CanSplitLoop(LocalVertexPtr fedges[2], vtkIdType numVerts, 
                   LocalVertexPtr verts[], vtkIdType& n1,
                   LocalVertexPtr l1[], vtkIdType& n2,
                   LocalVertexPtr l2[], double& ar);
  void SplitLoop(LocalVertexPtr fedges[2], vtkIdType numVerts, 
                 LocalVertexPtr *verts, vtkIdType& n1,
                 LocalVertexPtr *l1, vtkIdType& n2, LocalVertexPtr *l2);
  void Triangulate(vtkIdType numVerts, LocalVertexPtr verts[]);
  int CheckError();
private:
  vtkDecimate(const vtkDecimate&);  // Not implemented.
  void operator=(const vtkDecimate&);  // Not implemented.
};

#endif

Generated on Tue May 23 11:05:23 2006 for VTK by Doxygen 1.3.5