VTK  9.3.0
vtkStructuredData.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
29 #ifndef vtkStructuredData_h
30 #define vtkStructuredData_h
31 
32 #include "vtkCommonDataModelModule.h" // For export macro
33 #include "vtkObject.h"
34 
35 VTK_ABI_NAMESPACE_BEGIN
36 class vtkIdList;
38 
39 #define VTK_UNCHANGED 0
40 #define VTK_SINGLE_POINT 1
41 #define VTK_X_LINE 2
42 #define VTK_Y_LINE 3
43 #define VTK_Z_LINE 4
44 #define VTK_XY_PLANE 5
45 #define VTK_YZ_PLANE 6
46 #define VTK_XZ_PLANE 7
47 #define VTK_XYZ_GRID 8
48 #define VTK_EMPTY 9
49 
50 class VTKCOMMONDATAMODEL_EXPORT vtkStructuredData : public vtkObject
51 {
52 public:
53  vtkTypeMacro(vtkStructuredData, vtkObject);
54  void PrintSelf(ostream& os, vtkIndent indent) override;
55 
57 
64  static int SetDimensions(VTK_FUTURE_CONST int inDim[3], int dim[3]);
65  static int SetExtent(VTK_FUTURE_CONST int inExt[6], int ext[6]);
67 
69 
73  static int GetDataDescription(int dims[3]);
74  static int GetDataDescriptionFromExtent(int ext[6]);
76 
78 
81  static int GetDataDimension(int dataDescription);
82  static int GetDataDimension(int ext[6]);
84 
90  static vtkIdType GetNumberOfPoints(const int ext[6], int dataDescription = VTK_EMPTY);
91 
97  static vtkIdType GetNumberOfCells(const int ext[6], int dataDescription = VTK_EMPTY);
98 
104  static void GetCellExtentFromPointExtent(
105  const int pntExtent[6], int cellExtent[6], int dataDescription = VTK_EMPTY);
106 
111  static void GetDimensionsFromExtent(
112  const int ext[6], int dims[3], int dataDescription = VTK_EMPTY);
113 
117  static bool IsPointVisible(vtkIdType cellId, vtkUnsignedCharArray* ghosts);
118 
122  static bool IsCellVisible(vtkIdType cellId, VTK_FUTURE_CONST int dimensions[3],
123  int dataDescription, vtkUnsignedCharArray* cellGhostArray,
124  vtkUnsignedCharArray* pointGhostArray = nullptr);
125 
132  static void GetCellDimensionsFromExtent(
133  const int ext[6], int celldims[3], int dataDescription = VTK_EMPTY);
134 
140  static void GetCellDimensionsFromPointDimensions(const int pntdims[3], int cellDims[3]);
141 
148  static void GetLocalStructuredCoordinates(
149  const int ijk[3], const int ext[6], int lijk[3], int dataDescription = VTK_EMPTY);
150 
156  static void GetGlobalStructuredCoordinates(
157  const int lijk[3], const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
158 
162  static void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds, int dataDescription, int dim[3]);
163 
167  static void GetPointCells(vtkIdType ptId, vtkIdList* cellIds, VTK_FUTURE_CONST int dim[3]);
168 
173  static void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3]);
174  static void GetCellNeighbors(
175  vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3], int seedLoc[3]);
176 
182  static vtkIdType ComputePointIdForExtent(
183  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
184 
190  static vtkIdType ComputeCellIdForExtent(
191  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
192 
199  static vtkIdType ComputePointId(
200  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
201 
208  static vtkIdType ComputeCellId(
209  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
210 
217  static void ComputeCellStructuredCoordsForExtent(
218  vtkIdType cellIdx, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
219 
225  static void ComputeCellStructuredCoords(
226  vtkIdType cellId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
227 
233  static void ComputePointStructuredCoordsForExtent(
234  vtkIdType ptId, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
235 
241  static void ComputePointStructuredCoords(
242  vtkIdType ptId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
243 
244 protected:
245  vtkStructuredData() = default;
246  ~vtkStructuredData() override = default;
247 
255  static vtkIdType GetLinearIndex(const int i, const int j, const int k, const int N1, const int N2)
256  {
257  return ((static_cast<vtkIdType>(k) * N2 + j) * N1 + i);
258  }
259 
261 
268  const vtkIdType idx, const int N1, const int N2, int& i, int& j, int& k)
269  {
270  vtkIdType N12 = N1 * N2;
271  k = static_cast<int>(idx / N12);
272  j = static_cast<int>((idx - k * N12) / N1);
273  i = static_cast<int>(idx - k * N12 - j * N1);
274  }
276 
277  // Want to avoid importing <algorithm> in the header...
278  template <typename T>
279  static T Max(const T& a, const T& b)
280  {
281  return (a > b) ? a : b;
282  }
283 
284 private:
285  vtkStructuredData(const vtkStructuredData&) = delete;
286  void operator=(const vtkStructuredData&) = delete;
287 };
288 
289 //------------------------------------------------------------------------------
290 inline void vtkStructuredData::GetCellDimensionsFromExtent(const int ext[6], int celldims[3], int)
291 {
292  celldims[0] = vtkStructuredData::Max(ext[1] - ext[0], 0);
293  celldims[1] = vtkStructuredData::Max(ext[3] - ext[2], 0);
294  celldims[2] = vtkStructuredData::Max(ext[5] - ext[4], 0);
295 }
296 
297 //------------------------------------------------------------------------------
298 inline vtkIdType vtkStructuredData::ComputePointId(const int dims[3], const int ijk[3], int)
299 {
300  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2], dims[0], dims[1]);
301 }
302 
303 //------------------------------------------------------------------------------
304 inline vtkIdType vtkStructuredData::ComputeCellId(const int dims[3], const int ijk[3], int)
305 {
306  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2],
307  vtkStructuredData::Max(dims[0] - 1, 1), vtkStructuredData::Max(dims[1] - 1, 1));
308 }
309 
310 //------------------------------------------------------------------------------
311 inline vtkIdType vtkStructuredData::GetNumberOfPoints(const int ext[6], int)
312 {
313  return static_cast<vtkIdType>(ext[1] - ext[0] + 1) * static_cast<vtkIdType>(ext[3] - ext[2] + 1) *
314  static_cast<vtkIdType>(ext[5] - ext[4] + 1);
315 }
316 
317 //------------------------------------------------------------------------------
318 inline vtkIdType vtkStructuredData::GetNumberOfCells(const int ext[6], int)
319 {
320  int cellDims[3];
322 
323  // Replace 0's with 1's so we can just multiply them regardless of cell type.
324  cellDims[0] = vtkStructuredData::Max(cellDims[0], 1);
325  cellDims[1] = vtkStructuredData::Max(cellDims[1], 1);
326  cellDims[2] = vtkStructuredData::Max(cellDims[2], 1);
327 
328  // Note, when we compute the result below, we statically cast to vtkIdType to
329  // ensure the compiler will generate a 32x32=64 instruction.
330  return static_cast<vtkIdType>(cellDims[0]) * static_cast<vtkIdType>(cellDims[1]) *
331  static_cast<vtkIdType>(cellDims[2]);
332 }
333 
334 //------------------------------------------------------------------------------
336  const int nodeExtent[6], int cellExtent[6], int)
337 {
338  cellExtent[0] = nodeExtent[0];
339  cellExtent[2] = nodeExtent[2];
340  cellExtent[4] = nodeExtent[4];
341 
342  cellExtent[1] = vtkStructuredData::Max(nodeExtent[0], nodeExtent[1] - 1);
343  cellExtent[3] = vtkStructuredData::Max(nodeExtent[2], nodeExtent[3] - 1);
344  cellExtent[5] = vtkStructuredData::Max(nodeExtent[4], nodeExtent[5] - 1);
345 }
346 
347 //------------------------------------------------------------------------------
348 inline void vtkStructuredData::GetDimensionsFromExtent(const int ext[6], int dims[3], int)
349 {
350  dims[0] = ext[1] - ext[0] + 1;
351  dims[1] = ext[3] - ext[2] + 1;
352  dims[2] = ext[5] - ext[4] + 1;
353 }
354 
355 //------------------------------------------------------------------------------
357  const int nodeDims[3], int cellDims[3])
358 {
359  cellDims[0] = vtkStructuredData::Max(nodeDims[0] - 1, 0);
360  cellDims[1] = vtkStructuredData::Max(nodeDims[1] - 1, 0);
361  cellDims[2] = vtkStructuredData::Max(nodeDims[2] - 1, 0);
362 }
363 
364 //------------------------------------------------------------------------------
366  const int ijk[3], const int ext[6], int lijk[3], int)
367 {
368  lijk[0] = ijk[0] - ext[0];
369  lijk[1] = ijk[1] - ext[2];
370  lijk[2] = ijk[2] - ext[4];
371 }
372 
373 //------------------------------------------------------------------------------
375  const int lijk[3], const int ext[6], int ijk[3], int)
376 {
377  ijk[0] = ext[0] + lijk[0];
378  ijk[1] = ext[2] + lijk[1];
379  ijk[2] = ext[4] + lijk[2];
380 }
381 
382 //------------------------------------------------------------------------------
384  const int extent[6], const int ijk[3], int)
385 {
386  int dims[3];
388 
389  int lijk[3];
391 
392  return vtkStructuredData::ComputePointId(dims, lijk);
393 }
394 
395 //------------------------------------------------------------------------------
397  const int extent[6], const int ijk[3], int)
398 {
399  int nodeDims[3];
401 
402  int lijk[3];
404 
405  return vtkStructuredData::ComputeCellId(nodeDims, lijk);
406 }
407 
408 //------------------------------------------------------------------------------
410  vtkIdType cellId, const int dims[3], int ijk[3], int)
411 {
413  cellId, dims[0] - 1, dims[1] - 1, ijk[0], ijk[1], ijk[2]);
414 }
415 
416 //------------------------------------------------------------------------------
418  vtkIdType cellIdx, const int ext[6], int ijk[3], int)
419 {
420  int nodeDims[3];
422 
423  int lijk[3];
424  vtkStructuredData::ComputeCellStructuredCoords(cellIdx, nodeDims, lijk);
425 
427 }
428 
429 //------------------------------------------------------------------------------
431  vtkIdType ptId, const int dim[3], int ijk[3], int)
432 {
433  vtkStructuredData::GetStructuredCoordinates(ptId, dim[0], dim[1], ijk[0], ijk[1], ijk[2]);
434 }
435 
436 //------------------------------------------------------------------------------
438  vtkIdType ptId, const int ext[6], int ijk[3], int)
439 {
440  int nodeDims[3];
442 
443  int lijk[3];
445 
447 }
448 
449 VTK_ABI_NAMESPACE_END
450 #endif
list of point or cell ids
Definition: vtkIdList.h:32
a simple class to control print indentation
Definition: vtkIndent.h:38
abstract base class for most VTK objects
Definition: vtkObject.h:61
Singleton class for topologically regular data.
static void ComputePointStructuredCoordsForExtent(vtkIdType ptId, const int ext[6], int ijk[3], int dataDescription=VTK_EMPTY)
Given a pointId and the grid extent ext, get the structured coordinates (i-j-k).
static void GetCellDimensionsFromExtent(const int ext[6], int celldims[3], int dataDescription=VTK_EMPTY)
Returns the cell dimensions, i.e., the number of cells along the i,j,k for the grid with the given gr...
static int GetDataDescription(int dims[3])
Returns the data description given the dimensions (eg.
static int GetDataDimension(int ext[6])
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
static void GetStructuredCoordinates(const vtkIdType idx, const int N1, const int N2, int &i, int &j, int &k)
Returns the structured coordinates (i,j,k) for the given linear index of a grid with N1 and N2 dimens...
static vtkIdType ComputePointIdForExtent(const int extent[6], const int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the extent of the structured dataset,...
static int GetDataDescriptionFromExtent(int ext[6])
Returns the data description given the dimensions (eg.
static void GetLocalStructuredCoordinates(const int ijk[3], const int ext[6], int lijk[3], int dataDescription=VTK_EMPTY)
Given the global structured coordinates for a point or cell, ijk, w.r.t.
static void GetDimensionsFromExtent(const int ext[6], int dims[3], int dataDescription=VTK_EMPTY)
Computes the structured grid dimensions based on the given extent.
static void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds, int dim[3], int seedLoc[3])
static void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds, int dataDescription, int dim[3])
Get the points defining a cell.
static bool IsPointVisible(vtkIdType cellId, vtkUnsignedCharArray *ghosts)
Return non-zero value if specified point is visible.
static void GetCellExtentFromPointExtent(const int pntExtent[6], int cellExtent[6], int dataDescription=VTK_EMPTY)
Given the point extent of a grid, this method computes the corresponding cell extent for the grid.
static vtkIdType GetNumberOfCells(const int ext[6], int dataDescription=VTK_EMPTY)
Given the grid extent, this method returns the total number of cells within the extent.
vtkStructuredData()=default
static int SetExtent(VTK_FUTURE_CONST int inExt[6], int ext[6])
Specify the dimensions of a regular, rectangular dataset.
static void ComputeCellStructuredCoords(vtkIdType cellId, const int dim[3], int ijk[3], int dataDescription=VTK_EMPTY)
Given a cellId and grid dimensions 'dim', get the structured coordinates (i-j-k).
static void ComputeCellStructuredCoordsForExtent(vtkIdType cellIdx, const int ext[6], int ijk[3], int dataDescription=VTK_EMPTY)
Given the global grid extent and the linear index of a cell within the grid extent,...
static int GetDataDimension(int dataDescription)
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
~vtkStructuredData() override=default
static void GetCellDimensionsFromPointDimensions(const int pntdims[3], int cellDims[3])
Given the dimensions of the grid, in pntdims, this method returns the corresponding cell dimensions f...
static void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds, int dim[3])
Get the cells using the points ptIds, exclusive of the cell cellId.
static int SetDimensions(VTK_FUTURE_CONST int inDim[3], int dim[3])
Specify the dimensions of a regular, rectangular dataset.
static vtkIdType ComputeCellIdForExtent(const int extent[6], const int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the extent of the structured dataset,...
static vtkIdType GetLinearIndex(const int i, const int j, const int k, const int N1, const int N2)
Computes the linear index for the given i-j-k structured of a grid with of N1 and N2 dimensions along...
static void ComputePointStructuredCoords(vtkIdType ptId, const int dim[3], int ijk[3], int dataDescription=VTK_EMPTY)
Given a pointId and grid dimensions 'dim', get the structured coordinates (i-j-k).
static vtkIdType ComputePointId(const int dim[3], const int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the dimensions of the structured dataset,...
static bool IsCellVisible(vtkIdType cellId, VTK_FUTURE_CONST int dimensions[3], int dataDescription, vtkUnsignedCharArray *cellGhostArray, vtkUnsignedCharArray *pointGhostArray=nullptr)
Return non-zero value if specified cell is visible.
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, VTK_FUTURE_CONST int dim[3])
Get the cells using a point.
static void GetGlobalStructuredCoordinates(const int lijk[3], const int ext[6], int ijk[3], int dataDescription=VTK_EMPTY)
Given local structured coordinates, and the corresponding global sub-grid extent, this method compute...
static T Max(const T &a, const T &b)
static vtkIdType GetNumberOfPoints(const int ext[6], int dataDescription=VTK_EMPTY)
Given the grid extent, this method returns the total number of points within the extent.
static vtkIdType ComputeCellId(const int dim[3], const int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the dimensions of the structured dataset,...
dynamic, self-adjusting array of unsigned char
@ extent
Definition: vtkX3D.h:345
#define VTK_EMPTY
int vtkIdType
Definition: vtkType.h:315