vtkQuadricClustering.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkQuadricClustering_h
#define vtkQuadricClustering_h

#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkFeatureEdges;
class vtkPoints;
class vtkQuadricClusteringCellSet;

class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO 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 ways 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.
  vtkTypeBool 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