vtkMeshQuality.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2003-2008 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
#ifndef vtkMeshQuality_h
#define vtkMeshQuality_h
 
#include "vtkDataSetAlgorithm.h"
#include "vtkDeprecation.h"          // For VTK_DEPRECATED_IN_9_2_0
#include "vtkFiltersVerdictModule.h" // For export macro
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCell;
class vtkDataArray;
class vtkDoubleArray;
class vtkMeshQualityFunctor;
 
class VTKFILTERSVERDICT_EXPORT vtkMeshQuality : public vtkDataSetAlgorithm
{
private:
  friend class vtkMeshQualityFunctor;
 
public:
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkTypeMacro(vtkMeshQuality, vtkDataSetAlgorithm);
  static vtkMeshQuality* New();
 
 
  vtkSetMacro(SaveCellQuality, vtkTypeBool);
  vtkGetMacro(SaveCellQuality, vtkTypeBool);
  vtkBooleanMacro(SaveCellQuality, vtkTypeBool);
 
 
  vtkSetMacro(LinearApproximation, bool);
  vtkGetMacro(LinearApproximation, bool);
  vtkBooleanMacro(LinearApproximation, bool);
 
  enum class QualityMeasureTypes
  {
    AREA = 28,
    ASPECT_FROBENIUS = 3,
    ASPECT_GAMMA = 27,
    ASPECT_RATIO = 1,
    COLLAPSE_RATIO = 7,
    CONDITION = 9,
    DIAGONAL = 21,
    DIMENSION = 22,
    DISTORTION = 15,
    EDGE_RATIO = 0,
    EQUIANGLE_SKEW = 29,
    EQUIVOLUME_SKEW = 30,
    JACOBIAN = 25,
    MAX_ANGLE = 8,
    MAX_ASPECT_FROBENIUS = 5,
    MAX_EDGE_RATIO = 16,
    MAX_STRETCH = 31,
    MEAN_ASPECT_FROBENIUS = 32,
    MEAN_RATIO = 33,
    MED_ASPECT_FROBENIUS = 4,
    MIN_ANGLE = 6,
    NODAL_JACOBIAN_RATIO = 34,
    NORMALIZED_INRADIUS = 35,
    ODDY = 23,
    RADIUS_RATIO = 2,
    RELATIVE_SIZE_SQUARED = 12,
    SCALED_JACOBIAN = 10,
    SHAPE = 13,
    SHAPE_AND_SIZE = 14,
    SHEAR = 11,
    SHEAR_AND_SIZE = 24,
    SKEW = 17,
    SQUISH_INDEX = 36,
    STRETCH = 20,
    TAPER = 18,
    VOLUME = 19,
    WARPAGE = 26,
    TOTAL_QUALITY_MEASURE_TYPES = 37,
    NONE = TOTAL_QUALITY_MEASURE_TYPES
  };
 
  static const char* QualityMeasureNames[];
 
 
  vtkSetEnumMacro(TriangleQualityMeasure, QualityMeasureTypes);
  virtual void SetTriangleQualityMeasure(int measure)
  {
    this->SetTriangleQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(TriangleQualityMeasure, QualityMeasureTypes);
  void SetTriangleQualityMeasureToArea()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::AREA);
  }
  void SetTriangleQualityMeasureToEdgeRatio()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::EDGE_RATIO);
  }
  void SetTriangleQualityMeasureToAspectRatio()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::ASPECT_RATIO);
  }
  void SetTriangleQualityMeasureToRadiusRatio()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::RADIUS_RATIO);
  }
  void SetTriangleQualityMeasureToAspectFrobenius()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::ASPECT_FROBENIUS);
  }
  void SetTriangleQualityMeasureToMinAngle()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::MIN_ANGLE);
  }
  void SetTriangleQualityMeasureToMaxAngle()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::MAX_ANGLE);
  }
  void SetTriangleQualityMeasureToCondition()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::CONDITION);
  }
  void SetTriangleQualityMeasureToScaledJacobian()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetTriangleQualityMeasureToRelativeSizeSquared()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::RELATIVE_SIZE_SQUARED);
  }
  void SetTriangleQualityMeasureToShape()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::SHAPE);
  }
  void SetTriangleQualityMeasureToShapeAndSize()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::SHAPE_AND_SIZE);
  }
  void SetTriangleQualityMeasureToDistortion()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::DISTORTION);
  }
  void SetTriangleQualityMeasureToEquiangleSkew()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
  void SetTriangleQualityMeasureToNormalizedInradius()
  {
    this->SetTriangleQualityMeasure(QualityMeasureTypes::NORMALIZED_INRADIUS);
  }
 
 
  vtkSetEnumMacro(QuadQualityMeasure, QualityMeasureTypes);
  virtual void SetQuadQualityMeasure(int measure)
  {
    this->SetQuadQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(QuadQualityMeasure, QualityMeasureTypes);
  void SetQuadQualityMeasureToEdgeRatio()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::EDGE_RATIO);
  }
  void SetQuadQualityMeasureToAspectRatio()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::ASPECT_RATIO);
  }
  void SetQuadQualityMeasureToRadiusRatio()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::RADIUS_RATIO);
  }
  void SetQuadQualityMeasureToMedAspectFrobenius()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::MED_ASPECT_FROBENIUS);
  }
  void SetQuadQualityMeasureToMaxAspectFrobenius()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::MAX_ASPECT_FROBENIUS);
  }
  void SetQuadQualityMeasureToMaxEdgeRatio()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::MAX_EDGE_RATIO);
  }
  void SetQuadQualityMeasureToSkew() { this->SetQuadQualityMeasure(QualityMeasureTypes::SKEW); }
  void SetQuadQualityMeasureToTaper() { this->SetQuadQualityMeasure(QualityMeasureTypes::TAPER); }
  void SetQuadQualityMeasureToWarpage()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::WARPAGE);
  }
  void SetQuadQualityMeasureToArea() { this->SetQuadQualityMeasure(QualityMeasureTypes::AREA); }
  void SetQuadQualityMeasureToStretch()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::STRETCH);
  }
  void SetQuadQualityMeasureToMinAngle()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::MIN_ANGLE);
  }
  void SetQuadQualityMeasureToMaxAngle()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::MAX_ANGLE);
  }
  void SetQuadQualityMeasureToOddy() { this->SetQuadQualityMeasure(QualityMeasureTypes::ODDY); }
  void SetQuadQualityMeasureToCondition()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::CONDITION);
  }
  void SetQuadQualityMeasureToJacobian()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::JACOBIAN);
  }
  void SetQuadQualityMeasureToScaledJacobian()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetQuadQualityMeasureToShear() { this->SetQuadQualityMeasure(QualityMeasureTypes::SHEAR); }
  void SetQuadQualityMeasureToShape() { this->SetQuadQualityMeasure(QualityMeasureTypes::SHAPE); }
  void SetQuadQualityMeasureToRelativeSizeSquared()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::RELATIVE_SIZE_SQUARED);
  }
  void SetQuadQualityMeasureToShapeAndSize()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::SHAPE_AND_SIZE);
  }
  void SetQuadQualityMeasureToShearAndSize()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::SHEAR_AND_SIZE);
  }
  void SetQuadQualityMeasureToDistortion()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::DISTORTION);
  }
  void SetQuadQualityMeasureToEquiangleSkew()
  {
    this->SetQuadQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
 
 
  vtkSetEnumMacro(TetQualityMeasure, QualityMeasureTypes);
  virtual void SetTetQualityMeasure(int measure)
  {
    this->SetTetQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(TetQualityMeasure, QualityMeasureTypes);
  void SetTetQualityMeasureToEdgeRatio()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::EDGE_RATIO);
  }
  void SetTetQualityMeasureToAspectRatio()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::ASPECT_RATIO);
  }
  void SetTetQualityMeasureToRadiusRatio()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::RADIUS_RATIO);
  }
  void SetTetQualityMeasureToAspectFrobenius()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::ASPECT_FROBENIUS);
  }
  void SetTetQualityMeasureToMinAngle()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::MIN_ANGLE);
  }
  void SetTetQualityMeasureToCollapseRatio()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::COLLAPSE_RATIO);
  }
  void SetTetQualityMeasureToAspectGamma()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::ASPECT_GAMMA);
  }
  void SetTetQualityMeasureToVolume() { this->SetTetQualityMeasure(QualityMeasureTypes::VOLUME); }
  void SetTetQualityMeasureToCondition()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::CONDITION);
  }
  void SetTetQualityMeasureToJacobian()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::JACOBIAN);
  }
  void SetTetQualityMeasureToScaledJacobian()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetTetQualityMeasureToShape() { this->SetTetQualityMeasure(QualityMeasureTypes::SHAPE); }
  void SetTetQualityMeasureToRelativeSizeSquared()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::RELATIVE_SIZE_SQUARED);
  }
  void SetTetQualityMeasureToShapeAndSize()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::SHAPE_AND_SIZE);
  }
  void SetTetQualityMeasureToDistortion()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::DISTORTION);
  }
  void SetTetQualityMeasureToEquiangleSkew()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
  void SetTetQualityMeasureToEquivolumeSkew()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::EQUIVOLUME_SKEW);
  }
  void SetTetQualityMeasureToMeanRatio()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::MEAN_RATIO);
  }
  void SetTetQualityMeasureToNormalizedInradius()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::NORMALIZED_INRADIUS);
  }
  void SetTetQualityMeasureToSquishIndex()
  {
    this->SetTetQualityMeasure(QualityMeasureTypes::SQUISH_INDEX);
  }
 
 
  vtkSetEnumMacro(PyramidQualityMeasure, QualityMeasureTypes);
  virtual void SetPyramidQualityMeasure(int measure)
  {
    this->SetPyramidQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(PyramidQualityMeasure, QualityMeasureTypes);
  void SetPyramidQualityMeasureToEquiangleSkew()
  {
    this->SetPyramidQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
  void SetPyramidQualityMeasureToJacobian()
  {
    this->SetPyramidQualityMeasure(QualityMeasureTypes::JACOBIAN);
  }
  void SetPyramidQualityMeasureToScaledJacobian()
  {
    this->SetPyramidQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetPyramidQualityMeasureToShape()
  {
    this->SetPyramidQualityMeasure(QualityMeasureTypes::SHAPE);
  }
  void SetPyramidQualityMeasureToVolume()
  {
    this->SetPyramidQualityMeasure(QualityMeasureTypes::VOLUME);
  }
 
 
  vtkSetEnumMacro(WedgeQualityMeasure, QualityMeasureTypes);
  virtual void SetWedgeQualityMeasure(int measure)
  {
    this->SetWedgeQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(WedgeQualityMeasure, QualityMeasureTypes);
  void SetWedgeQualityMeasureToCondition()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::CONDITION);
  }
  void SetWedgeQualityMeasureToDistortion()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::DISTORTION);
  }
  void SetWedgeQualityMeasureToEdgeRatio()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::EDGE_RATIO);
  }
  void SetWedgeQualityMeasureToEquiangleSkew()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
  void SetWedgeQualityMeasureToJacobian()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::JACOBIAN);
  }
  void SetWedgeQualityMeasureToMaxAspectFrobenius()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::MAX_ASPECT_FROBENIUS);
  }
  void SetWedgeQualityMeasureToMaxStretch()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::MAX_STRETCH);
  }
  void SetWedgeQualityMeasureToMeanAspectFrobenius()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::MEAN_ASPECT_FROBENIUS);
  }
  void SetWedgeQualityMeasureToScaledJacobian()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetWedgeQualityMeasureToShape() { this->SetWedgeQualityMeasure(QualityMeasureTypes::SHAPE); }
  void SetWedgeQualityMeasureToVolume()
  {
    this->SetWedgeQualityMeasure(QualityMeasureTypes::VOLUME);
  }
 
 
  vtkSetEnumMacro(HexQualityMeasure, QualityMeasureTypes);
  virtual void SetHexQualityMeasure(int measure)
  {
    this->SetHexQualityMeasure(static_cast<QualityMeasureTypes>(measure));
  }
  vtkGetEnumMacro(HexQualityMeasure, QualityMeasureTypes);
  void SetHexQualityMeasureToEdgeRatio()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::EDGE_RATIO);
  }
  void SetHexQualityMeasureToMedAspectFrobenius()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::MED_ASPECT_FROBENIUS);
  }
  void SetHexQualityMeasureToMaxAspectFrobenius()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::MAX_ASPECT_FROBENIUS);
  }
  void SetHexQualityMeasureToMaxEdgeRatio()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::MAX_EDGE_RATIO);
  }
  void SetHexQualityMeasureToSkew() { this->SetHexQualityMeasure(QualityMeasureTypes::SKEW); }
  void SetHexQualityMeasureToTaper() { this->SetHexQualityMeasure(QualityMeasureTypes::TAPER); }
  void SetHexQualityMeasureToVolume() { this->SetHexQualityMeasure(QualityMeasureTypes::VOLUME); }
  void SetHexQualityMeasureToStretch() { this->SetHexQualityMeasure(QualityMeasureTypes::STRETCH); }
  void SetHexQualityMeasureToDiagonal()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::DIAGONAL);
  }
  void SetHexQualityMeasureToDimension()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::DIMENSION);
  }
  void SetHexQualityMeasureToOddy() { this->SetHexQualityMeasure(QualityMeasureTypes::ODDY); }
  void SetHexQualityMeasureToCondition()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::CONDITION);
  }
  void SetHexQualityMeasureToJacobian()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::JACOBIAN);
  }
  void SetHexQualityMeasureToScaledJacobian()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::SCALED_JACOBIAN);
  }
  void SetHexQualityMeasureToShear() { this->SetHexQualityMeasure(QualityMeasureTypes::SHEAR); }
  void SetHexQualityMeasureToShape() { this->SetHexQualityMeasure(QualityMeasureTypes::SHAPE); }
  void SetHexQualityMeasureToRelativeSizeSquared()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::RELATIVE_SIZE_SQUARED);
  }
  void SetHexQualityMeasureToShapeAndSize()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::SHAPE_AND_SIZE);
  }
  void SetHexQualityMeasureToShearAndSize()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::SHEAR_AND_SIZE);
  }
  void SetHexQualityMeasureToDistortion()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::DISTORTION);
  }
  void SetHexQualityMeasureToEquiangleSkew()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::EQUIANGLE_SKEW);
  }
  void SetHexQualityMeasureToNodalJacobianRatio()
  {
    this->SetHexQualityMeasure(QualityMeasureTypes::NODAL_JACOBIAN_RATIO);
  }
 
  static double TriangleArea(vtkCell* cell);
 
  static double TriangleEdgeRatio(vtkCell* cell);
 
  static double TriangleAspectRatio(vtkCell* cell);
 
  static double TriangleRadiusRatio(vtkCell* cell);
 
  static double TriangleAspectFrobenius(vtkCell* cell);
 
  static double TriangleMinAngle(vtkCell* cell);
 
  static double TriangleMaxAngle(vtkCell* cell);
 
  static double TriangleCondition(vtkCell* cell);
 
  static double TriangleScaledJacobian(vtkCell* cell);
 
  static double TriangleRelativeSizeSquared(vtkCell* cell);
 
  static double TriangleShape(vtkCell* cell);
 
  static double TriangleShapeAndSize(vtkCell* cell);
 
  static double TriangleDistortion(vtkCell* cell);
 
  static double TriangleEquiangleSkew(vtkCell* cell);
 
  static double TriangleNormalizedInradius(vtkCell* cell);
 
  static double QuadEdgeRatio(vtkCell* cell);
 
  static double QuadAspectRatio(vtkCell* cell);
 
  static double QuadRadiusRatio(vtkCell* cell);
 
  static double QuadMedAspectFrobenius(vtkCell* cell);
 
  static double QuadMaxAspectFrobenius(vtkCell* cell);
 
  static double QuadMinAngle(vtkCell* cell);
 
  static double QuadMaxEdgeRatio(vtkCell* cell);
 
  static double QuadSkew(vtkCell* cell);
 
  static double QuadTaper(vtkCell* cell);
 
  static double QuadWarpage(vtkCell* cell);
 
  static double QuadArea(vtkCell* cell);
 
  static double QuadStretch(vtkCell* cell);
 
  static double QuadMaxAngle(vtkCell* cell);
 
  static double QuadOddy(vtkCell* cell);
 
  static double QuadCondition(vtkCell* cell);
 
  static double QuadJacobian(vtkCell* cell);
 
  static double QuadScaledJacobian(vtkCell* cell);
 
  static double QuadShear(vtkCell* cell);
 
  static double QuadShape(vtkCell* cell);
 
  static double QuadRelativeSizeSquared(vtkCell* cell);
 
  static double QuadShapeAndSize(vtkCell* cell);
 
  static double QuadShearAndSize(vtkCell* cell);
 
  static double QuadDistortion(vtkCell* cell);
 
  static double QuadEquiangleSkew(vtkCell* cell);
 
  static double TetEdgeRatio(vtkCell* cell);
 
  static double TetAspectRatio(vtkCell* cell);
 
  static double TetRadiusRatio(vtkCell* cell);
 
  static double TetAspectFrobenius(vtkCell* cell);
 
  static double TetMinAngle(vtkCell* cell);
 
  static double TetCollapseRatio(vtkCell* cell);
 
  static double TetAspectGamma(vtkCell* cell);
 
  static double TetVolume(vtkCell* cell);
 
  static double TetCondition(vtkCell* cell);
 
  static double TetJacobian(vtkCell* cell);
 
  static double TetScaledJacobian(vtkCell* cell);
 
  static double TetShape(vtkCell* cell);
 
  static double TetRelativeSizeSquared(vtkCell* cell);
 
  static double TetShapeAndSize(vtkCell* cell);
 
  static double TetDistortion(vtkCell* cell);
 
  static double TetEquiangleSkew(vtkCell* cell);
 
  static double TetEquivolumeSkew(vtkCell* cell);
 
  static double TetMeanRatio(vtkCell* cell);
 
  static double TetNormalizedInradius(vtkCell* cell);
 
  static double TetSquishIndex(vtkCell* cell);
 
  static double PyramidEquiangleSkew(vtkCell* cell);
 
  static double PyramidJacobian(vtkCell* cell);
 
  static double PyramidScaledJacobian(vtkCell* cell);
 
  static double PyramidShape(vtkCell* cell);
 
  static double PyramidVolume(vtkCell* cell);
 
  static double WedgeCondition(vtkCell* cell);
 
  static double WedgeDistortion(vtkCell* cell);
 
  static double WedgeEdgeRatio(vtkCell* cell);
 
  static double WedgeEquiangleSkew(vtkCell* cell);
 
  static double WedgeJacobian(vtkCell* cell);
 
  static double WedgeMaxAspectFrobenius(vtkCell* cell);
 
  static double WedgeMaxStretch(vtkCell* cell);
 
  static double WedgeMeanAspectFrobenius(vtkCell* cell);
 
  static double WedgeScaledJacobian(vtkCell* cell);
 
  static double WedgeShape(vtkCell* cell);
 
  static double WedgeVolume(vtkCell* cell);
 
  static double HexEdgeRatio(vtkCell* cell);
 
  static double HexMedAspectFrobenius(vtkCell* cell);
 
  static double HexMaxAspectFrobenius(vtkCell* cell);
 
  static double HexMaxEdgeRatio(vtkCell* cell);
 
  static double HexSkew(vtkCell* cell);
 
  static double HexTaper(vtkCell* cell);
 
  static double HexVolume(vtkCell* cell);
 
  static double HexStretch(vtkCell* cell);
 
  static double HexDiagonal(vtkCell* cell);
 
  static double HexDimension(vtkCell* cell);
 
  static double HexOddy(vtkCell* cell);
 
  static double HexCondition(vtkCell* cell);
 
  static double HexJacobian(vtkCell* cell);
 
  static double HexScaledJacobian(vtkCell* cell);
 
  static double HexShear(vtkCell* cell);
 
  static double HexShape(vtkCell* cell);
 
  static double HexRelativeSizeSquared(vtkCell* cell);
 
  static double HexShapeAndSize(vtkCell* cell);
 
  static double HexShearAndSize(vtkCell* cell);
 
  static double HexDistortion(vtkCell* cell);
 
  static double HexEquiangleSkew(vtkCell* cell);
 
  static double HexNodalJacobianRatio(vtkCell* cell);
 
  virtual void SetRatio(vtkTypeBool r) { this->SetSaveCellQuality(r); }
  vtkTypeBool GetRatio() { return this->GetSaveCellQuality(); }
  vtkBooleanMacro(Ratio, vtkTypeBool);
 
 
  VTK_DEPRECATED_IN_9_2_0("Part of deprecating compatibility mode for this filter")
  virtual void SetVolume(vtkTypeBool cv)
  {
    if (!((cv != 0) ^ (this->Volume != 0)))
    {
      return;
    }
    this->Modified();
    this->Volume = cv;
    if (this->Volume)
    {
      this->CompatibilityMode = 1;
    }
  }
  VTK_DEPRECATED_IN_9_2_0("Part of deprecating compatibility mode for this filter")
  vtkTypeBool GetVolume() { return this->Volume; }
  VTK_DEPRECATED_IN_9_2_0("Part of deprecating compatibility mode for this filter")
  void VolumeOn()
  {
    if (!this->Volume)
    {
      this->Volume = 1;
      this->Modified();
    }
  }
  VTK_DEPRECATED_IN_9_2_0("Part of deprecating compatibility mode for this filter")
  void VolumeOff()
  {
    if (this->Volume)
    {
      this->Volume = 0;
      this->Modified();
    }
  }
 
 
  VTK_DEPRECATED_IN_9_2_0("Deprecating compatibility mode for this filter")
  virtual void SetCompatibilityMode(vtkTypeBool cm)
  {
    if (!((cm != 0) ^ (this->CompatibilityMode != 0)))
    {
      return;
    }
    this->CompatibilityMode = cm;
    this->Modified();
    if (this->CompatibilityMode)
    {
      this->Volume = 1;
      this->TetQualityMeasure = QualityMeasureTypes::RADIUS_RATIO;
    }
  }
  VTK_DEPRECATED_IN_9_2_0("Deprecating compatibility mode for this filter")
  vtkGetMacro(CompatibilityMode, vtkTypeBool);
  VTK_DEPRECATED_IN_9_2_0("Deprecating compatibility mode for this filter")
  void CompatibilityModeOn()
  {
    if (!this->CompatibilityMode)
    {
      this->CompatibilityMode = 1;
      this->Modified();
    }
  }
  VTK_DEPRECATED_IN_9_2_0("Part of deprecating compatibility mode for this filter")
  void CompatibilityModeOff()
  {
    if (this->CompatibilityMode)
    {
      this->CompatibilityMode = 0;
      this->Modified();
    }
  }
 
protected:
  vtkMeshQuality();
  ~vtkMeshQuality() override = default;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  vtkTypeBool SaveCellQuality;
  QualityMeasureTypes TriangleQualityMeasure;
  QualityMeasureTypes QuadQualityMeasure;
  QualityMeasureTypes TetQualityMeasure;
  QualityMeasureTypes PyramidQualityMeasure;
  QualityMeasureTypes WedgeQualityMeasure;
  QualityMeasureTypes HexQualityMeasure;
  bool LinearApproximation;
 
  using CellQualityType = double (*)(vtkCell*);
  CellQualityType GetTriangleQualityMeasureFunction();
  CellQualityType GetQuadQualityMeasureFunction();
  CellQualityType GetTetQualityMeasureFunction();
  CellQualityType GetPyramidQualityMeasureFunction();
  CellQualityType GetWedgeQualityMeasureFunction();
  CellQualityType GetHexQualityMeasureFunction();
 
  // VTK_DEPRECATED_IN_9_2_0 Those 2 attributes need to be removed, and instance in the code as
  // well.
  vtkTypeBool CompatibilityMode;
  vtkTypeBool Volume;
 
  // Variables used to store the average size (2D: area / 3D: volume)
  static double TriangleAverageSize;
  static double QuadAverageSize;
  static double TetAverageSize;
  static double PyramidAverageSize;
  static double WedgeAverageSize;
  static double HexAverageSize;
 
private:
  vtkMeshQuality(const vtkMeshQuality&) = delete;
  void operator=(const vtkMeshQuality&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkMeshQuality_h