---

Graphics/vtkQuadricClustering.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkQuadricClustering.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 __vtkQuadricClustering_h
#define __vtkQuadricClustering_h

#include "vtkPolyDataToPolyDataFilter.h"

class vtkCellArray;
class vtkFeatureEdges;
class vtkPoints;

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


  vtkSetMacro(UseFeatureEdges, int);
  vtkGetMacro(UseFeatureEdges, int);
  vtkBooleanMacro(UseFeatureEdges, int);
  vtkFeatureEdges *GetFeatureEdges() {return this->FeatureEdges;}


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


  vtkSetClampMacro(FeaturePointsAngle, float, 0.0, 180.0);
  vtkGetMacro(FeaturePointsAngle, float);
  

  void SetNumberOfXDivisions(int num);
  void SetNumberOfYDivisions(int num);
  void SetNumberOfZDivisions(int num);
  vtkGetMacro(NumberOfXDivisions, int);
  vtkGetMacro(NumberOfYDivisions, int);
  vtkGetMacro(NumberOfZDivisions, int);
  void SetNumberOfDivisions(int div[3]);
  int *GetNumberOfDivisions();
  void GetNumberOfDivisions(int div[3]);


  void SetDivisionOrigin(float x, float y, float z);
  void SetDivisionOrigin(float o[3]) {this->SetDivisionOrigin(o[0],o[1],o[2]);}
  vtkGetVector3Macro(DivisionOrigin, float);
  void SetDivisionSpacing(float x, float y, float z);
  void SetDivisionSpacing(float s[3]) {this->SetDivisionSpacing(s[0],s[1],s[2]);}
  vtkGetVector3Macro(DivisionSpacing, float);


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


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


  void StartAppend(float *bounds);
  void StartAppend(float x0,float x1,float y0,float y1,float z0,float z1)
    {float b[6]; b[0]=x0; b[1]=x1; b[2]=y0; b[3]=y1; b[4]=z0; b[5]=z1; 
    this->StartAppend(b);}  
  void Append(vtkPolyData *piece);
  void EndAppend();


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

protected:
  vtkQuadricClustering();
  ~vtkQuadricClustering();

  void Execute();
    
  vtkIdType HashPoint(float point[3]);
  

  void ComputeRepresentativePoint(float quadric[9], vtkIdType binId,
                                  float point[3]);


  void AddTriangles(vtkCellArray *tris, vtkPoints *points,
                    int geometryFlag);
  void AddPolygons(vtkCellArray *polys, vtkPoints *points,
                   int geometryFlag);
  void AddTriangle(vtkIdType *binIds, float *pt0, float *pt1, float *pt2,
                   int geometeryFlag);


  void AddEdges(vtkCellArray *edges, vtkPoints *points,
                int geometryFlag);
  void AddEdge(vtkIdType *binIds, float *pt0, float *pt1, int geometeryFlag);


  void AddVertices(vtkCellArray *verts, vtkPoints *points, int geometryFlag);
  void AddVertex(vtkIdType binId, float *pt, int geometryFlag);

  void InitializeQuadric(float quadric[9]);
  
  void AddQuadric(vtkIdType binId, float quadric[9]);

  void FindFeaturePoints(vtkCellArray *edges, vtkPoints *edgePts, float angle);
  

  void EndAppendUsingPoints(vtkPolyData *input);
  int UseInputPoints;

  void EndAppendVertexGeometry(vtkPolyData *input);

  // Unfinished option to handle boundary edges differently.
  void AppendFeatureQuadrics(vtkPolyData *pd);
  int UseFeatureEdges;
  int UseFeaturePoints;
  int UseInternalTriangles;

  int NumberOfXDivisions;
  int NumberOfYDivisions;
  int NumberOfZDivisions;

  // Used internally.
  // can be smaller than user values when input numb er of points is small.
  int NumberOfDivisions[3];

  // Since there are two was of specifing the grid, we have this flag
  // to indicate which the user has set.  When this flag is on, 
  // the bin sizes are computed from the DivisionOrigin and DivisionSpacing. 
  int ComputeNumberOfDivisions;

  float DivisionOrigin[3];
  float DivisionSpacing[3];

  float Bounds[6];
  float XBinSize;
  float YBinSize;
  float ZBinSize;

  //BTX
  class PointQuadric 
  {
  public:
    vtkIdType VertexId;
    // Dimension is supposed to be a flag representing the dimension of the cells
    // contributing to the quadric. 
    // Lines: 1, Triangles: 2 (and points 0 in the future?)
    unsigned char Dimension;
    float Quadric[9];
  };
  //ETX
  PointQuadric* QuadricArray;

  vtkIdType NumberOfBinsUsed;

  // Have to make these instance variables if we are going to allow
  // the algorithm to be driven by the Append methods.
  vtkCellArray *OutputTriangleArray;
  vtkCellArray *OutputLines;

  vtkFeatureEdges *FeatureEdges;
  vtkPoints *FeaturePoints;
  float FeaturePointsAngle;

  int CopyCellData;
  int InCellCount;
  int OutCellCount;
private:
  vtkQuadricClustering(const vtkQuadricClustering&);  // Not implemented.
  void operator=(const vtkQuadricClustering&);  // Not implemented.
};

#endif

Generated on Fri Mar 7 15:40:12 2003 for VTK by Doxygen 1.2.18