v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  Program:   Visualization Toolkit

  Module:    vtkQuadricClustering.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 vtkQuadricClustering_h

#define vtkQuadricClustering_h


#include "vtkFiltersCoreModule.h" // For export macro

#include "vtkPolyDataAlgorithm.h"


class vtkCellArray;

class vtkFeatureEdges;

class vtkPoints;

class vtkQuadricClusteringCellSet;


class VTKFILTERSCORE_EXPORT vtkQuadricClustering : public vtkPolyDataAlgorithm

{

public:


  vtkTypeMacro(vtkQuadricClustering, vtkPolyDataAlgorithm);

  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkQuadricClustering *New();


  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])

    { this->SetNumberOfDivisions(div[0], div[1], div[2]); }

  void SetNumberOfDivisions(int div0, int div1, int div2);

  int *GetNumberOfDivisions();

  void GetNumberOfDivisions(int div[3]);


  vtkSetMacro(AutoAdjustNumberOfDivisions,int);

  vtkGetMacro(AutoAdjustNumberOfDivisions,int);

  vtkBooleanMacro(AutoAdjustNumberOfDivisions,int);


  void SetDivisionOrigin(double x, double y, double z);

  void SetDivisionOrigin(double o[3])

    {this->SetDivisionOrigin(o[0],o[1],o[2]);}

  vtkGetVector3Macro(DivisionOrigin, double);

  void SetDivisionSpacing(double x, double y, double z);

  void SetDivisionSpacing(double s[3])

    {this->SetDivisionSpacing(s[0],s[1],s[2]);}

  vtkGetVector3Macro(DivisionSpacing, double);


  vtkSetMacro(UseInputPoints, int);

  vtkGetMacro(UseInputPoints, int);

  vtkBooleanMacro(UseInputPoints, int);


  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, double, 0.0, 180.0);

  vtkGetMacro(FeaturePointsAngle, double);


  vtkSetMacro(UseInternalTriangles, int);

  vtkGetMacro(UseInternalTriangles, int);

  vtkBooleanMacro(UseInternalTriangles, int);


  void StartAppend(double *bounds);

  void StartAppend(double x0,double x1,double y0,double y1,double z0,double z1)

    {double 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);


  vtkSetMacro(PreventDuplicateCells,int);

  vtkGetMacro(PreventDuplicateCells,int);

  vtkBooleanMacro(PreventDuplicateCells,int);


protected:

  vtkQuadricClustering();

  ~vtkQuadricClustering();


  int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);

  int FillInputPortInformation(int, vtkInformation *);


  vtkIdType HashPoint(double point[3]);


  void ComputeRepresentativePoint(double quadric[9], vtkIdType binId,

                                  double point[3]);


  void AddPolygons(vtkCellArray *polys, vtkPoints *points, int geometryFlag,

                   vtkPolyData *input, vtkPolyData *output);

  void AddStrips(vtkCellArray *strips, vtkPoints *points, int geometryFlag,

                 vtkPolyData *input, vtkPolyData *output);

  void AddTriangle(vtkIdType *binIds, double *pt0, double *pt1, double *pt2,

                   int geometeryFlag, vtkPolyData *input, vtkPolyData *output);


  void AddEdges(vtkCellArray *edges, vtkPoints *points,

                int geometryFlag,

                vtkPolyData *input, vtkPolyData *output);

  void AddEdge(vtkIdType *binIds, double *pt0, double *pt1, int geometeryFlag,

               vtkPolyData *input, vtkPolyData *output);


  void AddVertices(vtkCellArray *verts, vtkPoints *points, int geometryFlag,

                   vtkPolyData *input, vtkPolyData *output);

  void AddVertex(vtkIdType binId, double *pt, int geometryFlag,

                 vtkPolyData *input, vtkPolyData *output);


  void InitializeQuadric(double quadric[9]);


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


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


  void EndAppendUsingPoints(vtkPolyData *input, vtkPolyData *output);

  int UseInputPoints;


  void EndAppendVertexGeometry(vtkPolyData *input, vtkPolyData *output);


  // Unfinished option to handle boundary edges differently.

  void AppendFeatureQuadrics(vtkPolyData *pd, vtkPolyData *output);

  int UseFeatureEdges;

  int UseFeaturePoints;

  int UseInternalTriangles;


  int NumberOfXDivisions;

  int NumberOfYDivisions;

  int NumberOfZDivisions;


  // Set this to eliminate duplicate cells

  int PreventDuplicateCells;

  vtkQuadricClusteringCellSet *CellSet; //PIMPLd stl set for tracking inserted cells

  vtkIdType NumberOfBins;


  // 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;


  double DivisionOrigin[3];

  double DivisionSpacing[3];

  int   AutoAdjustNumberOfDivisions;


  double Bounds[6];

  double XBinSize;

  double YBinSize;

  double ZBinSize;

  double XBinStep;     //replace some divisions with multiplication

  double YBinStep;

  double ZBinStep;

  vtkIdType SliceSize; //eliminate one multiplication


  //BTX

  struct PointQuadric

  {

    PointQuadric():VertexId(-1),Dimension(255) {}


    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;

    double 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;

  double FeaturePointsAngle;


  int CopyCellData;

  int InCellCount;

  int OutCellCount;


private:

  vtkQuadricClustering(const vtkQuadricClustering&);  // Not implemented.

  void operator=(const vtkQuadricClustering&);  // Not implemented.

};


#endif