VTK  9.3.20240328
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
59 #ifndef vtkStructuredData_h
60 #define vtkStructuredData_h
61 
62 #include "vtkCommonDataModelModule.h" // For export macro
63 #include "vtkObject.h"
64 #include "vtkSmartPointer.h" // For vtkSmartPointer
65 
66 VTK_ABI_NAMESPACE_BEGIN
67 class vtkDataArray;
68 class vtkIdList;
69 class vtkPoints;
72 
73 template <typename T>
74 class vtkImplicitArray;
75 template <typename Type>
77 template <typename Type>
79 
80 #define VTK_UNCHANGED 0
81 #define VTK_SINGLE_POINT 1
82 #define VTK_X_LINE 2
83 #define VTK_Y_LINE 3
84 #define VTK_Z_LINE 4
85 #define VTK_XY_PLANE 5
86 #define VTK_YZ_PLANE 6
87 #define VTK_XZ_PLANE 7
88 #define VTK_XYZ_GRID 8
89 #define VTK_EMPTY 9
90 
91 class VTKCOMMONDATAMODEL_EXPORT vtkStructuredData : public vtkObject
92 {
93 public:
94  vtkTypeMacro(vtkStructuredData, vtkObject);
95  void PrintSelf(ostream& os, vtkIndent indent) override;
96 
98 
105  static int SetDimensions(VTK_FUTURE_CONST int inDim[3], int dim[3]);
106  static int SetExtent(VTK_FUTURE_CONST int inExt[6], int ext[6]);
108 
110 
114  static int GetDataDescription(int dims[3]);
115  static int GetDataDescriptionFromExtent(int ext[6]);
117 
119 
122  static int GetDataDimension(int dataDescription);
123  static int GetDataDimension(int ext[6]);
125 
131  static vtkIdType GetNumberOfPoints(const int ext[6], int dataDescription = VTK_EMPTY);
132 
138  static vtkIdType GetNumberOfCells(const int ext[6], int dataDescription = VTK_EMPTY);
139 
145  static void GetCellExtentFromPointExtent(
146  const int pntExtent[6], int cellExtent[6], int dataDescription = VTK_EMPTY);
147 
152  static void GetDimensionsFromExtent(
153  const int ext[6], int dims[3], int dataDescription = VTK_EMPTY);
154 
158  static bool IsPointVisible(vtkIdType cellId, vtkUnsignedCharArray* ghosts);
159 
163  static bool IsCellVisible(vtkIdType cellId, VTK_FUTURE_CONST int dimensions[3],
164  int dataDescription, vtkUnsignedCharArray* cellGhostArray,
165  vtkUnsignedCharArray* pointGhostArray = nullptr);
166 
173  static void GetCellDimensionsFromExtent(
174  const int ext[6], int celldims[3], int dataDescription = VTK_EMPTY);
175 
181  static void GetCellDimensionsFromPointDimensions(const int pntdims[3], int cellDims[3]);
182 
189  static void GetLocalStructuredCoordinates(
190  const int ijk[3], const int ext[6], int lijk[3], int dataDescription = VTK_EMPTY);
191 
197  static void GetGlobalStructuredCoordinates(
198  const int lijk[3], const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
199 
203  static void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds, int dataDescription, int dim[3]);
204 
208  static void GetPointCells(vtkIdType ptId, vtkIdList* cellIds, VTK_FUTURE_CONST int dim[3]);
209 
214  static void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3]);
215  static void GetCellNeighbors(
216  vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3], int seedLoc[3]);
217 
223  static vtkIdType ComputePointIdForExtent(
224  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
225 
231  static vtkIdType ComputeCellIdForExtent(
232  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
233 
240  static vtkIdType ComputePointId(
241  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
242 
249  static vtkIdType ComputeCellId(
250  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
251 
258  static void ComputeCellStructuredCoordsForExtent(
259  vtkIdType cellIdx, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
260 
266  static void ComputeCellStructuredCoords(
267  vtkIdType cellId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
268 
273  static void ComputeCellStructuredMinMaxCoords(vtkIdType cellId, const int dim[3], int ijkMin[3],
274  int ijkMax[3], int dataDescription = VTK_EMPTY);
275 
281  static void ComputePointStructuredCoordsForExtent(
282  vtkIdType ptId, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
283 
289  static void ComputePointStructuredCoords(
290  vtkIdType ptId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
291 
296  int extent[6], bool usePixelVoxelOrientation);
297 
303  vtkDataArray* zCoords, int extent[6], double dirMatrix[9]);
304 
309  int extent[6], bool usePixelVoxelOrientation);
310 
311 protected:
312  vtkStructuredData() = default;
313  ~vtkStructuredData() override = default;
314 
322  static vtkIdType GetLinearIndex(const int i, const int j, const int k, const int N1, const int N2)
323  {
324  return ((static_cast<vtkIdType>(k) * N2 + j) * N1 + i);
325  }
326 
328 
335  const vtkIdType idx, const int N1, const int N2, int& i, int& j, int& k)
336  {
337  vtkIdType N12 = N1 * N2;
338  k = static_cast<int>(idx / N12);
339  j = static_cast<int>((idx - k * N12) / N1);
340  i = static_cast<int>(idx - k * N12 - j * N1);
341  }
343 
344  // Want to avoid importing <algorithm> in the header...
345  template <typename T>
346  static T Max(const T& a, const T& b)
347  {
348  return (a > b) ? a : b;
349  }
350 
351 private:
352  vtkStructuredData(const vtkStructuredData&) = delete;
353  void operator=(const vtkStructuredData&) = delete;
354 };
355 
356 //------------------------------------------------------------------------------
357 inline void vtkStructuredData::GetCellDimensionsFromExtent(const int ext[6], int celldims[3], int)
358 {
359  celldims[0] = vtkStructuredData::Max(ext[1] - ext[0], 0);
360  celldims[1] = vtkStructuredData::Max(ext[3] - ext[2], 0);
361  celldims[2] = vtkStructuredData::Max(ext[5] - ext[4], 0);
362 }
363 
364 //------------------------------------------------------------------------------
365 inline vtkIdType vtkStructuredData::ComputePointId(const int dims[3], const int ijk[3], int)
366 {
367  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2], dims[0], dims[1]);
368 }
369 
370 //------------------------------------------------------------------------------
371 inline vtkIdType vtkStructuredData::ComputeCellId(const int dims[3], const int ijk[3], int)
372 {
373  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2],
374  vtkStructuredData::Max(dims[0] - 1, 1), vtkStructuredData::Max(dims[1] - 1, 1));
375 }
376 
377 //------------------------------------------------------------------------------
378 inline vtkIdType vtkStructuredData::GetNumberOfPoints(const int ext[6], int)
379 {
380  return static_cast<vtkIdType>(ext[1] - ext[0] + 1) * static_cast<vtkIdType>(ext[3] - ext[2] + 1) *
381  static_cast<vtkIdType>(ext[5] - ext[4] + 1);
382 }
383 
384 //------------------------------------------------------------------------------
385 inline vtkIdType vtkStructuredData::GetNumberOfCells(const int ext[6], int)
386 {
387  int dims[3];
389 
390  // if any of the dimensions is 0, then there are no cells
391  const int cellDims[3] = { dims[0] != 0 ? std::max(dims[0] - 1, 1) : 0,
392  dims[1] != 0 ? std::max(dims[1] - 1, 1) : 0, dims[2] != 0 ? std::max(dims[2] - 1, 1) : 0 };
393 
394  // Note, when we compute the result below, we statically cast to vtkIdType to
395  // ensure the compiler will generate a 32x32=64 instruction.
396  return static_cast<vtkIdType>(cellDims[0]) * static_cast<vtkIdType>(cellDims[1]) *
397  static_cast<vtkIdType>(cellDims[2]);
398 }
399 
400 //------------------------------------------------------------------------------
402  const int nodeExtent[6], int cellExtent[6], int)
403 {
404  cellExtent[0] = nodeExtent[0];
405  cellExtent[2] = nodeExtent[2];
406  cellExtent[4] = nodeExtent[4];
407 
408  cellExtent[1] = vtkStructuredData::Max(nodeExtent[0], nodeExtent[1] - 1);
409  cellExtent[3] = vtkStructuredData::Max(nodeExtent[2], nodeExtent[3] - 1);
410  cellExtent[5] = vtkStructuredData::Max(nodeExtent[4], nodeExtent[5] - 1);
411 }
412 
413 //------------------------------------------------------------------------------
414 inline void vtkStructuredData::GetDimensionsFromExtent(const int ext[6], int dims[3], int)
415 {
416  dims[0] = ext[1] - ext[0] + 1;
417  dims[1] = ext[3] - ext[2] + 1;
418  dims[2] = ext[5] - ext[4] + 1;
419 }
420 
421 //------------------------------------------------------------------------------
423  const int nodeDims[3], int cellDims[3])
424 {
425  cellDims[0] = vtkStructuredData::Max(nodeDims[0] - 1, 0);
426  cellDims[1] = vtkStructuredData::Max(nodeDims[1] - 1, 0);
427  cellDims[2] = vtkStructuredData::Max(nodeDims[2] - 1, 0);
428 }
429 
430 //------------------------------------------------------------------------------
432  const int ijk[3], const int ext[6], int lijk[3], int)
433 {
434  lijk[0] = ijk[0] - ext[0];
435  lijk[1] = ijk[1] - ext[2];
436  lijk[2] = ijk[2] - ext[4];
437 }
438 
439 //------------------------------------------------------------------------------
441  const int lijk[3], const int ext[6], int ijk[3], int)
442 {
443  ijk[0] = ext[0] + lijk[0];
444  ijk[1] = ext[2] + lijk[1];
445  ijk[2] = ext[4] + lijk[2];
446 }
447 
448 //------------------------------------------------------------------------------
450  const int extent[6], const int ijk[3], int)
451 {
452  int dims[3];
454 
455  int lijk[3];
457 
458  return vtkStructuredData::ComputePointId(dims, lijk);
459 }
460 
461 //------------------------------------------------------------------------------
463  const int extent[6], const int ijk[3], int)
464 {
465  int nodeDims[3];
467 
468  int lijk[3];
470 
471  return vtkStructuredData::ComputeCellId(nodeDims, lijk);
472 }
473 
474 //------------------------------------------------------------------------------
476  vtkIdType cellId, const int dims[3], int ijk[3], int)
477 {
479  cellId, dims[0] - 1, dims[1] - 1, ijk[0], ijk[1], ijk[2]);
480 }
481 
482 //------------------------------------------------------------------------------
484  vtkIdType cellIdx, const int ext[6], int ijk[3], int)
485 {
486  int nodeDims[3];
488 
489  int lijk[3];
490  vtkStructuredData::ComputeCellStructuredCoords(cellIdx, nodeDims, lijk);
491 
493 }
494 
495 //------------------------------------------------------------------------------
497  vtkIdType ptId, const int dim[3], int ijk[3], int)
498 {
499  vtkStructuredData::GetStructuredCoordinates(ptId, dim[0], dim[1], ijk[0], ijk[1], ijk[2]);
500 }
501 
502 //------------------------------------------------------------------------------
504  vtkIdType ptId, const int ext[6], int ijk[3], int)
505 {
506  int nodeDims[3];
508 
509  int lijk[3];
511 
513 }
514 
515 VTK_ABI_NAMESPACE_END
516 #endif
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:154
list of point or cell ids
Definition: vtkIdList.h:132
A read only array class that wraps an implicit function from integers to any value type supported by ...
a simple class to control print indentation
Definition: vtkIndent.h:108
abstract base class for most VTK objects
Definition: vtkObject.h:161
represent and manipulate 3D points
Definition: vtkPoints.h:138
implicit object to represent cell connectivity
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 vtkSmartPointer< vtkStructuredCellArray > GetCellArray(int extent[6], bool usePixelVoxelOrientation)
Get the implicit cell array for structured data.
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 void ComputeCellStructuredMinMaxCoords(vtkIdType cellId, const int dim[3], int ijkMin[3], int ijkMax[3], int dataDescription=VTK_EMPTY)
Given a cellId and grid dimensions 'dim', get the min and max structured coordinates (i-j-k).
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 VTK_WRAPEXCLUDE vtkSmartPointer< vtkConstantArray< int > > GetCellTypesArray(int extent[6], bool usePixelVoxelOrientation)
Get the implicit cell array types for structured data.
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 vtkSmartPointer< vtkPoints > GetPoints(vtkDataArray *xCoords, vtkDataArray *yCoords, vtkDataArray *zCoords, int extent[6], double dirMatrix[9])
Given 3 arrays describing the xCoords, yCoords, and zCoords, the extent, and the direction matrix,...
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
A utility structure serving as a backend for constant implicit arrays.
#define VTK_EMPTY
int vtkIdType
Definition: vtkType.h:315
#define VTK_WRAPEXCLUDE
#define max(a, b)