VTK  9.3.1
vtkCellValidator.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
62 #ifndef vtkCellValidator_h
63 #define vtkCellValidator_h
64 
65 #include "vtkDataSetAlgorithm.h"
66 #include "vtkFiltersGeneralModule.h" // For export macro
67 
68 VTK_ABI_NAMESPACE_BEGIN
69 class vtkCell;
70 class vtkGenericCell;
71 class vtkEmptyCell;
72 class vtkVertex;
73 class vtkPolyVertex;
74 class vtkLine;
75 class vtkPolyLine;
76 class vtkTriangle;
77 class vtkTriangleStrip;
78 class vtkPolygon;
79 class vtkPixel;
80 class vtkQuad;
81 class vtkTetra;
82 class vtkVoxel;
83 class vtkHexahedron;
84 class vtkWedge;
85 class vtkPyramid;
86 class vtkPentagonalPrism;
87 class vtkHexagonalPrism;
88 class vtkQuadraticEdge;
90 class vtkQuadraticQuad;
92 class vtkQuadraticTetra;
94 class vtkQuadraticWedge;
96 class vtkBiQuadraticQuad;
104 class vtkCubicLine;
105 class vtkConvexPointSet;
106 class vtkPolyhedron;
107 class vtkLagrangeCurve;
108 class vtkLagrangeTriangle;
110 class vtkLagrangeTetra;
112 class vtkLagrangeWedge;
113 class vtkBezierCurve;
114 class vtkBezierTriangle;
116 class vtkBezierTetra;
117 class vtkBezierHexahedron;
118 class vtkBezierWedge;
119 
120 class VTKFILTERSGENERAL_EXPORT vtkCellValidator : public vtkDataSetAlgorithm
121 {
122 public:
124  void PrintSelf(ostream& os, vtkIndent indent) override;
125 
126  // Description:
127  // Construct to compute the validity of cells.
128  static vtkCellValidator* New();
129 
130  enum State : short
131  {
132  Valid = 0x0,
133  WrongNumberOfPoints = 0x01,
134  IntersectingEdges = 0x02,
135  IntersectingFaces = 0x04,
136  NoncontiguousEdges = 0x08,
137  Nonconvex = 0x10,
138  FacesAreOrientedIncorrectly = 0x20,
139  };
140 
141  friend inline State operator&(State a, State b)
142  {
143  return static_cast<State>(static_cast<short>(a) & static_cast<short>(b));
144  }
145  friend inline State operator|(State a, State b)
146  {
147  return static_cast<State>(static_cast<short>(a) | static_cast<short>(b));
148  }
149  friend inline State& operator&=(State& a, State b) { return a = a & b; }
150 
151  friend inline State& operator|=(State& a, State b) { return a = a | b; }
152 
153  static void PrintState(State state, ostream& os, vtkIndent indent);
154 
155  static State Check(vtkGenericCell*, double tolerance);
156  static State Check(vtkCell*, double tolerance);
157 
158  static State Check(vtkEmptyCell*, double tolerance);
159  static State Check(vtkVertex*, double tolerance);
160  static State Check(vtkPolyVertex*, double tolerance);
161  static State Check(vtkLine*, double tolerance);
162  static State Check(vtkPolyLine*, double tolerance);
163  static State Check(vtkTriangle*, double tolerance);
164  static State Check(vtkTriangleStrip*, double tolerance);
165  static State Check(vtkPolygon*, double tolerance);
166  static State Check(vtkPixel*, double tolerance);
167  static State Check(vtkQuad*, double tolerance);
168  static State Check(vtkTetra*, double tolerance);
169  static State Check(vtkVoxel*, double tolerance);
170  static State Check(vtkHexahedron*, double tolerance);
171  static State Check(vtkWedge*, double tolerance);
172  static State Check(vtkPyramid*, double tolerance);
173  static State Check(vtkPentagonalPrism*, double tolerance);
174  static State Check(vtkHexagonalPrism*, double tolerance);
175  static State Check(vtkQuadraticEdge*, double tolerance);
176  static State Check(vtkQuadraticTriangle*, double tolerance);
177  static State Check(vtkQuadraticQuad*, double tolerance);
178  static State Check(vtkQuadraticPolygon*, double tolerance);
179  static State Check(vtkQuadraticTetra*, double tolerance);
180  static State Check(vtkQuadraticHexahedron*, double tolerance);
181  static State Check(vtkQuadraticWedge*, double tolerance);
182  static State Check(vtkQuadraticPyramid*, double tolerance);
183  static State Check(vtkBiQuadraticQuad*, double tolerance);
184  static State Check(vtkTriQuadraticHexahedron*, double tolerance);
185  static State Check(vtkTriQuadraticPyramid*, double tolerance);
186  static State Check(vtkQuadraticLinearQuad*, double tolerance);
187  static State Check(vtkQuadraticLinearWedge*, double tolerance);
188  static State Check(vtkBiQuadraticQuadraticWedge*, double tolerance);
189  static State Check(vtkBiQuadraticQuadraticHexahedron*, double tolerance);
190  static State Check(vtkBiQuadraticTriangle*, double tolerance);
191  static State Check(vtkCubicLine*, double tolerance);
192  static State Check(vtkConvexPointSet*, double tolerance);
193  static State Check(vtkPolyhedron*, double tolerance);
194  static State Check(vtkLagrangeCurve*, double tolerance);
195  static State Check(vtkLagrangeTriangle*, double tolerance);
196  static State Check(vtkLagrangeQuadrilateral*, double tolerance);
197  static State Check(vtkLagrangeTetra*, double tolerance);
198  static State Check(vtkLagrangeHexahedron*, double tolerance);
199  static State Check(vtkLagrangeWedge*, double tolerance);
200  static State Check(vtkBezierCurve*, double tolerance);
201  static State Check(vtkBezierTriangle*, double tolerance);
202  static State Check(vtkBezierQuadrilateral*, double tolerance);
203  static State Check(vtkBezierTetra*, double tolerance);
204  static State Check(vtkBezierHexahedron*, double tolerance);
205  static State Check(vtkBezierWedge*, double tolerance);
206 
208 
213  vtkSetClampMacro(Tolerance, double, 0.0, VTK_DOUBLE_MAX);
214  vtkGetMacro(Tolerance, double);
216 
217 protected:
219  ~vtkCellValidator() override = default;
220 
221  double Tolerance;
222 
224 
225  static bool NoIntersectingEdges(vtkCell* cell, double tolerance);
226  static bool NoIntersectingFaces(vtkCell* cell, double tolerance);
227  static bool ContiguousEdges(vtkCell* twoDimensionalCell, double tolerance);
228  static bool Convex(vtkCell* cell, double tolerance);
229  static bool FacesAreOrientedCorrectly(vtkCell* threeDimensionalCell, double tolerance);
230 
231 private:
232  vtkCellValidator(const vtkCellValidator&) = delete;
233  void operator=(const vtkCellValidator&) = delete;
234 };
235 
236 VTK_ABI_NAMESPACE_END
237 #endif
cell represents a parabolic, 13-node isoparametric pyramid
#define VTK_DOUBLE_MAX
Definition: vtkType.h:154
friend State operator&(State a, State b)
Store vtkAlgorithm input/output information.
a cell that represents a 3D point
Definition: vtkVertex.h:22
a 3D cell that represents a linear pyramid
Definition: vtkPyramid.h:35
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:26
cell represents a parabolic, 9-node isoparametric quad
friend State operator|(State a, State b)
A 2D cell that represents an arbitrary order Bezier triangle.
a cell that represents a 2D quadrilateral
Definition: vtkQuad.h:27
A 3D cell that represents an arbitrary order Bezier hex.
cell represents a parabolic, 19-node isoparametric pyramid
an empty cell used as a place-holder during processing
Definition: vtkEmptyCell.h:21
cell represents a set of 0D vertices
Definition: vtkPolyVertex.h:24
A 3D cell that represents an arbitrary order Lagrange tetrahedron.
cell represents a parabolic, 18-node isoparametric wedge
provides thread-safe access to cells
cell represents a biquadratic, 24-node isoparametric hexahedron
a 3D cell that represents a prism with hexagonal base
cell represents a cubic , isoparametric 1D line
Definition: vtkCubicLine.h:34
friend State & operator|=(State &a, State b)
friend State & operator&=(State &a, State b)
a cell that represents a triangle strip
a 3D cell that represents a tetrahedron
Definition: vtkTetra.h:33
a 3D cell that represents a convex prism with pentagonal base
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
cell represents a 1D line
Definition: vtkLine.h:22
abstract class to specify cell behavior
Definition: vtkCell.h:49
A 3D cell that represents an arbitrary order Lagrange wedge.
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:30
A 2D cell that represents an arbitrary order Lagrange triangle.
cell represents a parabolic, 8-node isoparametric quad
a simple class to control print indentation
Definition: vtkIndent.h:28
A 3D cell that represents an arbitrary order Bezier tetrahedron.
virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *)
This is called within ProcessRequest when a request asks the algorithm to do its work.
a cell that represents an n-sided polygon
Definition: vtkPolygon.h:31
validates cells in a dataset
cell represents a parabolic, isoparametric triangle
a cell that represents a linear 3D hexahedron
Definition: vtkHexahedron.h:33
cell represents a parabolic, 10-node isoparametric tetrahedron
a 3D cell defined by a set of convex points
A 3D cell that represents an arbitrary order Bezier wedge.
cell represents a parabolic, 27-node isoparametric hexahedron
a cell that represents a parabolic n-sided polygon
cell represents a parabolic, isoparametric edge
a cell that represents a triangle
Definition: vtkTriangle.h:27
cell represents a parabolic, 20-node isoparametric hexahedron
cell represents a parabolic, isoparametric triangle
cell represents a parabolic, 15-node isoparametric wedge
Store zero or more vtkInformation instances.
A 3D cell defined by a set of polygonal faces.
Superclass for algorithms that produce output of the same type as input.
A 3D cell that represents an arbitrary order Lagrange hex.
cell represents a, 12-node isoparametric wedge
static vtkDataSetAlgorithm * New()
cell represents a quadratic-linear, 6-node isoparametric quad
a 3D cell that represents a linear wedge
Definition: vtkWedge.h:35
cell represents a set of 1D lines
Definition: vtkPolyLine.h:29