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
206
207
208
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkHexahedron.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 vtkHexahedron
* @brief a cell that represents a linear 3D hexahedron
*
* vtkHexahedron is a concrete implementation of vtkCell to represent a
* linear, 3D rectangular hexahedron (e.g., "brick" topology). vtkHexahedron
* uses the standard isoparametric shape functions for a linear
* hexahedron. The hexahedron is defined by the eight points (0-7) where
* (0,1,2,3) is the base of the hexahedron which, using the right hand rule,
* forms a quadrilaterial whose normal points in the direction of the
* opposite face (4,5,6,7).
*
* @sa
* vtkConvexPointSet vtkPyramid vtkTetra vtkVoxel vtkWedge
*/
#ifndef vtkHexahedron_h
#define vtkHexahedron_h
#include "vtkCell3D.h"
#include "vtkCommonDataModelModule.h" // For export macro
class vtkLine;
class vtkQuad;
class vtkIncrementalPointLocator;
class VTKCOMMONDATAMODEL_EXPORT vtkHexahedron : public vtkCell3D
{
public:
static vtkHexahedron* New();
vtkTypeMacro(vtkHexahedron, vtkCell3D);
void PrintSelf(ostream& os, vtkIndent indent) override;
//@{
/**
* See vtkCell3D API for description of these methods.
*/
void GetEdgePoints(vtkIdType edgeId, const vtkIdType*& pts) override;
// @deprecated Replaced by GetEdgePoints(vtkIdType, const vtkIdType*&) as of VTK 9.0
VTK_LEGACY(virtual void GetEdgePoints(int edgeId, int*& pts) override);
vtkIdType GetFacePoints(vtkIdType faceId, const vtkIdType*& pts) override;
// @deprecated Replaced by GetFacePoints(vtkIdType, const vtkIdType*&) as of VTK 9.0
VTK_LEGACY(virtual void GetFacePoints(int faceId, int*& pts) override);
void GetEdgeToAdjacentFaces(vtkIdType edgeId, const vtkIdType*& pts) override;
vtkIdType GetFaceToAdjacentFaces(vtkIdType faceId, const vtkIdType*& faceIds) override;
vtkIdType GetPointToIncidentEdges(vtkIdType pointId, const vtkIdType*& edgeIds) override;
vtkIdType GetPointToIncidentFaces(vtkIdType pointId, const vtkIdType*& faceIds) override;
vtkIdType GetPointToOneRingPoints(vtkIdType pointId, const vtkIdType*& pts) override;
bool GetCentroid(double centroid[3]) const override;
bool IsInsideOut() override;
//@}
/**
* static constexpr handle on the number of points.
*/
static constexpr vtkIdType NumberOfPoints = 8;
/**
* static contexpr handle on the number of faces.
*/
static constexpr vtkIdType NumberOfEdges = 12;
/**
* static contexpr handle on the number of edges.
*/
static constexpr vtkIdType NumberOfFaces = 6;
/**
* static contexpr handle on the maximum face size. It can also be used
* to know the number of faces adjacent to one face.
*/
static constexpr vtkIdType MaximumFaceSize = 4;
/**
* static constexpr handle on the maximum valence of this cell.
* The valence of a vertex is the number of incident edges (or equivalently faces)
* to this vertex. It is also equal to the size of a one ring neighborhood of a vertex.
*/
static constexpr vtkIdType MaximumValence = 3;
//@{
/**
* See the vtkCell API for descriptions of these methods.
*/
int GetCellType() override { return VTK_HEXAHEDRON; }
int GetNumberOfEdges() override { return 12; }
int GetNumberOfFaces() override { return 6; }
vtkCell* GetEdge(int edgeId) override;
vtkCell* GetFace(int faceId) override;
int CellBoundary(int subId, const double pcoords[3], vtkIdList* pts) override;
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;
//@}
int EvaluatePosition(const double x[3], double closestPoint[3], int& subId, double pcoords[3],
double& dist2, double weights[]) override;
void EvaluateLocation(int& subId, const double pcoords[3], double x[3], double* weights) override;
int IntersectWithLine(const double p1[3], const double p2[3], double tol, double& t, double x[3],
double pcoords[3], int& subId) override;
int Triangulate(int index, vtkIdList* ptIds, vtkPoints* pts) override;
void Derivatives(
int subId, const double pcoords[3], const double* values, int dim, double* derivs) override;
double* GetParametricCoords() override;
/**
* Return the case table for table-based isocontouring (aka marching cubes
* style implementations). A linear 3D cell with N vertices will have 2**N
* cases. The returned case array lists three edges in order to produce one
* output triangle which may be repeated to generate multiple triangles. The
* list of cases terminates with a -1 entry.
*/
static int* GetTriangleCases(int caseId);
static void InterpolationFunctions(const double pcoords[3], double weights[8]);
static void InterpolationDerivs(const double pcoords[3], double derivs[24]);
//@{
/**
* Compute the interpolation functions/derivatives
* (aka shape functions/derivatives)
*/
void InterpolateFunctions(const double pcoords[3], double weights[8]) override
{
vtkHexahedron::InterpolationFunctions(pcoords, weights);
}
void InterpolateDerivs(const double pcoords[3], double derivs[24]) override
{
vtkHexahedron::InterpolationDerivs(pcoords, derivs);
}
//@}
//@{
/**
* Return the ids of the vertices defining edge/face (`edgeId`/`faceId').
* Ids are related to the cell, not to the dataset.
*
* @note The return type changed. It used to be int*, it is now const vtkIdType*.
* This is so ids are unified between vtkCell and vtkPoints, and so vtkCell ids
* can be used as inputs in algorithms such as vtkPolygon::ComputeNormal.
*/
static const vtkIdType* GetEdgeArray(vtkIdType edgeId) VTK_SIZEHINT(2);
static const vtkIdType* GetFaceArray(vtkIdType faceId) VTK_SIZEHINT(4);
//@}
/**
* Static method version of GetEdgeToAdjacentFaces.
*/
static const vtkIdType* GetEdgeToAdjacentFacesArray(vtkIdType edgeId) VTK_SIZEHINT(2);
/**
* Static method version of GetFaceToAdjacentFaces.
*/
static const vtkIdType* GetFaceToAdjacentFacesArray(vtkIdType faceId) VTK_SIZEHINT(4);
/**
* Static method version of GetPointToIncidentEdgesArray.
*/
static const vtkIdType* GetPointToIncidentEdgesArray(vtkIdType pointId) VTK_SIZEHINT(3);
/**
* Static method version of GetPointToIncidentFacesArray.
*/
static const vtkIdType* GetPointToIncidentFacesArray(vtkIdType pointId) VTK_SIZEHINT(3);
/**
* Static method version of GetPointToOneRingPoints.
*/
static const vtkIdType* GetPointToOneRingPointsArray(vtkIdType pointId) VTK_SIZEHINT(3);
/**
* Static method version of GetCentroid.
*/
static bool ComputeCentroid(vtkPoints* points, const vtkIdType* pointIds, double centroid[3]);
/**
* Given parametric coordinates compute inverse Jacobian transformation
* matrix. Returns 9 elements of 3x3 inverse Jacobian plus interpolation
* function derivatives.
*/
void JacobianInverse(const double pcoords[3], double** inverse, double derivs[24]);
protected:
vtkHexahedron();
~vtkHexahedron() override;
vtkLine* Line;
vtkQuad* Quad;
private:
vtkHexahedron(const vtkHexahedron&) = delete;
void operator=(const vtkHexahedron&) = delete;
};
#endif
|
