1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkCell3D.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.
=========================================================================*/
/**
* @class vtkCell3D
* @brief abstract class to specify 3D cell interface
*
* vtkCell3D is an abstract class that extends the interfaces for 3D data
* cells, and implements methods needed to satisfy the vtkCell API. The
* 3D cells include hexehedra, tetrahedra, wedge, pyramid, and voxel.
*
* @sa
* vtkTetra vtkHexahedron vtkVoxel vtkWedge vtkPyramid
*/
#ifndef vtkCell3D_h
#define vtkCell3D_h
#include "vtkCell.h"
#include "vtkCommonDataModelModule.h" // For export macro
class vtkOrderedTriangulator;
class vtkTetra;
class vtkCellArray;
class vtkDoubleArray;
class VTKCOMMONDATAMODEL_EXPORT vtkCell3D : public vtkCell
{
public:
vtkTypeMacro(vtkCell3D, vtkCell);
void PrintSelf(ostream& os, vtkIndent indent) override;
/**
* Get the pair of vertices that define an edge. The method returns the
* number of vertices, along with an array of vertices. Note that the
* vertices are 0-offset; that is, they refer to the ids of the cell, not
* the point ids of the mesh that the cell belongs to. The edgeId must
* range between 0<=edgeId<this->GetNumberOfEdges().
*/
virtual void GetEdgePoints(vtkIdType edgeId, const vtkIdType*& pts) = 0;
// @deprecated Replaced by GetEdgePoints(vtkIdType, const vtkIdType*&) as of VTK 9.0
VTK_LEGACY(virtual void GetEdgePoints(int edgeId, int*& pts) = 0;);
/**
* Get the list of vertices that define a face. The list is terminated
* with a negative number. Note that the vertices are 0-offset; that is,
* they refer to the ids of the cell, not the point ids of the mesh that
* the cell belongs to. The faceId must range between
* 0<=faceId<this->GetNumberOfFaces().
*
* @return The number of points in face faceId
*/
virtual vtkIdType GetFacePoints(vtkIdType faceId, const vtkIdType*& pts) = 0;
// @deprecated Replaced by GetFacePoints(vtkIdType, const vtkIdType*&) as of VTK 9.0
VTK_LEGACY(virtual void GetFacePoints(int faceId, int*& pts) = 0;);
/**
* Get the ids of the two adjacent faces to edge of id edgeId.
* The output face ids are sorted from id of lowest rank to highest.
* Note that the faces are 0-offset; that is, they refer to the ids of the cells,
* not the face ids of the mesh that the cell belongs to. The edgeId must range
* between 0<=edgeId<this->GetNumberOfEdges().
*/
virtual void GetEdgeToAdjacentFaces(vtkIdType edgeId, const vtkIdType*& faceIds) = 0;
/**
* Get the ids of the adjacent faces to face of id faceId. The order of
* faces is consistent. They are always ordered in counter clockwise w.r.t.
* normal orientation.
* The first id faces[0] corresponds to the face sharing point of id pts[0]
* where pts is obtained from this->GetFacePoints(faceId, pts), being
* the "most counter clockwise" oriented w.r.t. face faceId.
* Note that the faces are 0-offset; that is, they
* refer to the ids of the cell, not the face ids of the mesh that the cell belongs to.
* The faceId must be between 0<=faceId<this->GetNumberOfFaces();
*
* @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is
* inverted.
* @return The number of adjacent faces to faceId.
*/
virtual vtkIdType GetFaceToAdjacentFaces(vtkIdType faceId, const vtkIdType*& faceIds) = 0;
/**
* Get the ids of the incident edges to point of id pointId. Edges are
* sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell
* at point of id pointId.
* The first edge corresponds to the edge containing point of id pts[0], where
* pts is obtained from this->GetPointToOnRingVertices(pointId, pts).
* Note that the edges are 0-offset; that is, they refer to the ids of the cell,
* not the edge ids of the mesh that the cell belongs to.
* The edgeId must be between 0<=edgeId<this->GetNumberOfEdges();
*
* @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is
* inverted.
* @return The valence of point pointId.
*/
virtual vtkIdType GetPointToIncidentEdges(vtkIdType pointId, const vtkIdType*& edgeIds) = 0;
/**
* Get the ids of the incident faces point of id pointId. Faces are
* sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell
* at point of id pointId.
* The first face corresponds to the face containing edge of id edges[0],
* where edges is obtained from this->GetPointToIncidentEdges(pointId, edges),
* such that face faces[0] is the "most counterclockwise" face incident to
* point pointId containing edges[0].
* Note that the faces are 0-offset; that is, they refer to the ids of the cell,
* not the face ids of the mesh that the cell belongs to.
* The pointId must be between 0<=pointId<this->GetNumberOfPoints().
*
* @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is
* inverted.
* @return The valence of point pointId.
*/
virtual vtkIdType GetPointToIncidentFaces(vtkIdType pointId, const vtkIdType*& faceIds) = 0;
/**
* Get the ids of a one-ring surrounding point of id pointId. Points are
* sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell
* at point of id pointId.
* The first point corresponds to the point contained in edges[0], where
* edges is obtained from this->GetPointToIncidentEdges(pointId, edges).
* Note that the points are 0-offset; that is, they refer to the ids of the cell,
* not the point ids of the mesh that the cell belongs to.
* The pointId must be between 0<pointId<this->GetNumberOfPoints().
* @return The valence of point pointId.
*/
virtual vtkIdType GetPointToOneRingPoints(vtkIdType pointId, const vtkIdType*& pts) = 0;
/**
* Returns true if the normals of the vtkCell3D point inside the cell.
*
* @warning This flag is not precomputed. It is advised for the return result of
* this method to be stored in a local boolean by the user if needed multiple times.
*/
virtual bool IsInsideOut();
/**
* Computes the centroid of the cell.
*/
virtual bool GetCentroid(double centroid[3]) const = 0;
void Contour(double value, vtkDataArray* cellScalars, vtkIncrementalPointLocator* locator,
vtkCellArray* verts, vtkCellArray* lines, vtkCellArray* polys, vtkPointData* inPd,
vtkPointData* outPd, vtkCellData* inCd, vtkIdType cellId, vtkCellData* outCd) override;
/**
* Cut (or clip) the cell based on the input cellScalars and the specified
* value. The output of the clip operation will be one or more cells of the
* same topological dimension as the original cell. The flag insideOut
* controls what part of the cell is considered inside - normally cell
* points whose scalar value is greater than "value" are considered
* inside. If insideOut is on, this is reversed. Also, if the output cell
* data is non-nullptr, the cell data from the clipped cell is passed to the
* generated contouring primitives. (Note: the CopyAllocate() method must
* be invoked on both the output cell and point data. The cellId refers to
* the cell from which the cell data is copied.) (Satisfies vtkCell API.)
*/
void Clip(double value, vtkDataArray* cellScalars, vtkIncrementalPointLocator* locator,
vtkCellArray* connectivity, vtkPointData* inPd, vtkPointData* outPd, vtkCellData* inCd,
vtkIdType cellId, vtkCellData* outCd, int insideOut) override;
/**
* The topological dimension of the cell. (Satisfies vtkCell API.)
*/
int GetCellDimension() override { return 3; }
//@{
/**
* Set the tolerance for merging clip intersection points that are near
* the vertices of cells. This tolerance is used to prevent the generation
* of degenerate tetrahedra during clipping.
*/
vtkSetClampMacro(MergeTolerance, double, 0.0001, 0.25);
vtkGetMacro(MergeTolerance, double);
//@}
protected:
vtkCell3D();
~vtkCell3D() override;
vtkOrderedTriangulator* Triangulator;
double MergeTolerance;
// used to support clipping
vtkTetra* ClipTetra;
vtkDoubleArray* ClipScalars;
private:
vtkCell3D(const vtkCell3D&) = delete;
void operator=(const vtkCell3D&) = delete;
};
#endif
|
