vtkQuadricDecimation.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 vtkQuadricDecimation_h
#define vtkQuadricDecimation_h
 
#include "vtkFiltersCoreModule.h" // For export macro
#include "vtkPolyDataAlgorithm.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkEdgeTable;
class vtkIdList;
class vtkPointData;
class vtkPriorityQueue;
class vtkDoubleArray;
 
class VTKFILTERSCORE_EXPORT VTK_MARSHALAUTO vtkQuadricDecimation : public vtkPolyDataAlgorithm
{
public:
  vtkTypeMacro(vtkQuadricDecimation, vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkQuadricDecimation* New();


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


  vtkSetMacro(AttributeErrorMetric, vtkTypeBool);
  vtkGetMacro(AttributeErrorMetric, vtkTypeBool);
  vtkBooleanMacro(AttributeErrorMetric, vtkTypeBool);


  vtkSetMacro(VolumePreservation, vtkTypeBool);
  vtkGetMacro(VolumePreservation, vtkTypeBool);
  vtkBooleanMacro(VolumePreservation, vtkTypeBool);


  vtkSetMacro(MaximumError, double);
  vtkGetMacro(MaximumError, double);


  vtkSetMacro(Regularize, vtkTypeBool);
  vtkGetMacro(Regularize, vtkTypeBool);
  vtkBooleanMacro(Regularize, vtkTypeBool);
  vtkSetMacro(Regularization, double);
  vtkGetMacro(Regularization, double);


  vtkSetMacro(WeighBoundaryConstraintsByLength, vtkTypeBool);
  vtkGetMacro(WeighBoundaryConstraintsByLength, vtkTypeBool);
  vtkBooleanMacro(WeighBoundaryConstraintsByLength, vtkTypeBool);
  vtkSetMacro(BoundaryWeightFactor, double);
  vtkGetMacro(BoundaryWeightFactor, double);


  vtkGetMacro(MapPointData, bool);
  vtkSetMacro(MapPointData, bool);
  vtkBooleanMacro(MapPointData, bool);


  vtkSetMacro(ScalarsAttribute, vtkTypeBool);
  vtkGetMacro(ScalarsAttribute, vtkTypeBool);
  vtkBooleanMacro(ScalarsAttribute, vtkTypeBool);
  vtkSetMacro(VectorsAttribute, vtkTypeBool);
  vtkGetMacro(VectorsAttribute, vtkTypeBool);
  vtkBooleanMacro(VectorsAttribute, vtkTypeBool);
  vtkSetMacro(NormalsAttribute, vtkTypeBool);
  vtkGetMacro(NormalsAttribute, vtkTypeBool);
  vtkBooleanMacro(NormalsAttribute, vtkTypeBool);
  vtkSetMacro(TCoordsAttribute, vtkTypeBool);
  vtkGetMacro(TCoordsAttribute, vtkTypeBool);
  vtkBooleanMacro(TCoordsAttribute, vtkTypeBool);
  vtkSetMacro(TensorsAttribute, vtkTypeBool);
  vtkGetMacro(TensorsAttribute, vtkTypeBool);
  vtkBooleanMacro(TensorsAttribute, vtkTypeBool);


  vtkSetMacro(ScalarsWeight, double);
  vtkSetMacro(VectorsWeight, double);
  vtkSetMacro(NormalsWeight, double);
  vtkSetMacro(TCoordsWeight, double);
  vtkSetMacro(TensorsWeight, double);
  vtkGetMacro(ScalarsWeight, double);
  vtkGetMacro(VectorsWeight, double);
  vtkGetMacro(NormalsWeight, double);
  vtkGetMacro(TCoordsWeight, double);
  vtkGetMacro(TensorsWeight, double);


  vtkGetMacro(ActualReduction, double);
 
protected:
  vtkQuadricDecimation();
  ~vtkQuadricDecimation() override;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  int CollapseEdge(vtkIdType pt0Id, vtkIdType pt1Id);

  void InitializeQuadrics(vtkIdType numPts);

  void AddBoundaryConstraints();

  void ComputeQuadric(vtkIdType pointId);

  void AddQuadric(vtkIdType oldPtId, vtkIdType newPtId);


  double ComputeCost(vtkIdType edgeId, double* x);
  double ComputeCost2(vtkIdType edgeId, double* x);

  void FindAffectedEdges(vtkIdType p1Id, vtkIdType p2Id, vtkIdList* edges);

  vtkIdType GetEdgeCellId(vtkIdType p1Id, vtkIdType p2Id);
 
  int IsGoodPlacement(vtkIdType pt0Id, vtkIdType pt1Id, const double* x);
  int TrianglePlaneCheck(
    const double t0[3], const double t1[3], const double t2[3], const double* x);
  void ComputeNumberOfComponents();
  void UpdateEdgeData(vtkIdType pt0Id, vtkIdType pt1Id);


  void SetPointCoordinates(vtkIdType ptId, const double* x);

  void SetPointActiveAttributes(vtkIdType ptId, const double* x);

  void SetPointAttributeArray(vtkIdType ptId[2], const double* x);
  void GetPointAttributeArray(vtkIdType ptId, double* x);

  void GetAttributeComponents();
 
  double TargetReduction;
  double ActualReduction;
  vtkTypeBool AttributeErrorMetric;
  vtkTypeBool VolumePreservation;
 
  bool MapPointData = false;
 
  vtkTypeBool ScalarsAttribute;
  vtkTypeBool VectorsAttribute;
  vtkTypeBool NormalsAttribute;
  vtkTypeBool TCoordsAttribute;
  vtkTypeBool TensorsAttribute;
 
  double ScalarsWeight;
  double VectorsWeight;
  double NormalsWeight;
  double TCoordsWeight;
  double TensorsWeight;
 
  int NumberOfEdgeCollapses;
  vtkEdgeTable* Edges;
  vtkIdList* EndPoint1List;
  vtkIdList* EndPoint2List;
  vtkPriorityQueue* EdgeCosts;
  vtkDoubleArray* TargetPoints;
  int NumberOfComponents;
  vtkPolyData* Mesh;
 
  struct ErrorQuadric
  {
    double* Quadric;
  };
 
  // One ErrorQuadric per point
  ErrorQuadric* ErrorQuadrics;
 
  // Controlling regularization behavior
  vtkTypeBool Regularize = false;
  double Regularization = 0.05;
 
  // Controlling the boundary weighting behavior
  vtkTypeBool WeighBoundaryConstraintsByLength = false;
  double BoundaryWeightFactor = 1.0;
 
  // Contains 4 doubles per point. Length = nPoints * 4
  double* VolumeConstraints;
  int AttributeComponents[6];
  double AttributeScale[6];
 
  // Temporary variables for performance
  vtkIdList* CollapseCellIds;
  double* TempX;
  double* TempQuad;
  double* TempB;
  double** TempA;
  double* TempData;
 
private:
  vtkQuadricDecimation(const vtkQuadricDecimation&) = delete;
  void operator=(const vtkQuadricDecimation&) = delete;
 
  // Maximum allowed absolute error for stopping criteria.
  double MaximumError = VTK_DOUBLE_MAX;
};
 
VTK_ABI_NAMESPACE_END
#endif