vtkQuadricClustering.h

Go to the documentation of this file.

/*=========================================================================
 
  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"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkFeatureEdges;
class vtkPoints;
class vtkQuadricClusteringCellSet;
 
class VTKFILTERSCORE_EXPORT vtkQuadricClustering : public vtkPolyDataAlgorithm
{
public:
 
  static vtkQuadricClustering* New();
  vtkTypeMacro(vtkQuadricClustering, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  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() VTK_SIZEHINT(3);
  void GetNumberOfDivisions(int div[3]);
 
 
  vtkSetMacro(AutoAdjustNumberOfDivisions, vtkTypeBool);
  vtkGetMacro(AutoAdjustNumberOfDivisions, vtkTypeBool);
  vtkBooleanMacro(AutoAdjustNumberOfDivisions, vtkTypeBool);
 
 
  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, vtkTypeBool);
  vtkGetMacro(UseInputPoints, vtkTypeBool);
  vtkBooleanMacro(UseInputPoints, vtkTypeBool);
 
 
  vtkSetMacro(UseFeatureEdges, vtkTypeBool);
  vtkGetMacro(UseFeatureEdges, vtkTypeBool);
  vtkBooleanMacro(UseFeatureEdges, vtkTypeBool);
  vtkFeatureEdges* GetFeatureEdges() { return this->FeatureEdges; }
 
 
  vtkSetMacro(UseFeaturePoints, vtkTypeBool);
  vtkGetMacro(UseFeaturePoints, vtkTypeBool);
  vtkBooleanMacro(UseFeaturePoints, vtkTypeBool);
 
 
  vtkSetClampMacro(FeaturePointsAngle, double, 0.0, 180.0);
  vtkGetMacro(FeaturePointsAngle, double);
 
 
  vtkSetMacro(UseInternalTriangles, vtkTypeBool);
  vtkGetMacro(UseInternalTriangles, vtkTypeBool);
  vtkBooleanMacro(UseInternalTriangles, vtkTypeBool);
 
 
  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, vtkTypeBool);
  vtkGetMacro(CopyCellData, vtkTypeBool);
  vtkBooleanMacro(CopyCellData, vtkTypeBool);
 
 
  vtkSetMacro(PreventDuplicateCells, vtkTypeBool);
  vtkGetMacro(PreventDuplicateCells, vtkTypeBool);
  vtkBooleanMacro(PreventDuplicateCells, vtkTypeBool);
 
protected:
  vtkQuadricClustering();
  ~vtkQuadricClustering() override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int FillInputPortInformation(int, vtkInformation*) override;
 
  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);
  vtkTypeBool UseInputPoints;
 
  void EndAppendVertexGeometry(vtkPolyData* input, vtkPolyData* output);
 
  // Unfinished option to handle boundary edges differently.
  void AppendFeatureQuadrics(vtkPolyData* pd, vtkPolyData* output);
  vtkTypeBool UseFeatureEdges;
  vtkTypeBool UseFeaturePoints;
  vtkTypeBool UseInternalTriangles;
 
  int NumberOfXDivisions;
  int NumberOfYDivisions;
  int NumberOfZDivisions;
 
  // Set this to eliminate duplicate cells
  vtkTypeBool 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 specifying 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];
  vtkTypeBool 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
 
  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];
  };
 
  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;
 
  vtkTypeBool CopyCellData;
  int InCellCount;
  int OutCellCount;
 
private:
  vtkQuadricClustering(const vtkQuadricClustering&) = delete;
  void operator=(const vtkQuadricClustering&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif