VTK  9.2.6
vtkStructuredData.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkStructuredData.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
61 #ifndef vtkStructuredData_h
62 #define vtkStructuredData_h
63 
64 #include "vtkCommonDataModelModule.h" // For export macro
65 #include "vtkObject.h"
66 
67 class vtkIdList;
69 
70 #define VTK_UNCHANGED 0
71 #define VTK_SINGLE_POINT 1
72 #define VTK_X_LINE 2
73 #define VTK_Y_LINE 3
74 #define VTK_Z_LINE 4
75 #define VTK_XY_PLANE 5
76 #define VTK_YZ_PLANE 6
77 #define VTK_XZ_PLANE 7
78 #define VTK_XYZ_GRID 8
79 #define VTK_EMPTY 9
80 
81 class VTKCOMMONDATAMODEL_EXPORT vtkStructuredData : public vtkObject
82 {
83 public:
84  vtkTypeMacro(vtkStructuredData, vtkObject);
85  void PrintSelf(ostream& os, vtkIndent indent) override;
86 
88 
95  static int SetDimensions(int inDim[3], int dim[3]);
96  static int SetExtent(int inExt[6], int ext[6]);
98 
100 
104  static int GetDataDescription(int dims[3]);
105  static int GetDataDescriptionFromExtent(int ext[6]);
107 
109 
112  static int GetDataDimension(int dataDescription);
113  static int GetDataDimension(int ext[6]);
115 
121  static vtkIdType GetNumberOfPoints(const int ext[6], int dataDescription = VTK_EMPTY);
122 
128  static vtkIdType GetNumberOfCells(const int ext[6], int dataDescription = VTK_EMPTY);
129 
135  static void GetCellExtentFromPointExtent(
136  const int pntExtent[6], int cellExtent[6], int dataDescription = VTK_EMPTY);
137 
142  static void GetDimensionsFromExtent(
143  const int ext[6], int dims[3], int dataDescription = VTK_EMPTY);
144 
148  static bool IsPointVisible(vtkIdType cellId, vtkUnsignedCharArray* ghosts);
149 
153  static bool IsCellVisible(vtkIdType cellId, int dimensions[3], int dataDescription,
154  vtkUnsignedCharArray* cellGhostArray, vtkUnsignedCharArray* pointGhostArray = nullptr);
155 
162  static void GetCellDimensionsFromExtent(
163  const int ext[6], int celldims[3], int dataDescription = VTK_EMPTY);
164 
170  static void GetCellDimensionsFromPointDimensions(const int pntdims[3], int cellDims[3]);
171 
178  static void GetLocalStructuredCoordinates(
179  const int ijk[3], const int ext[6], int lijk[3], int dataDescription = VTK_EMPTY);
180 
186  static void GetGlobalStructuredCoordinates(
187  const int lijk[3], const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
188 
192  static void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds, int dataDescription, int dim[3]);
193 
197  static void GetPointCells(vtkIdType ptId, vtkIdList* cellIds, int dim[3]);
198 
203  static void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3]);
204  static void GetCellNeighbors(
205  vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int dim[3], int seedLoc[3]);
206 
212  static vtkIdType ComputePointIdForExtent(
213  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
214 
220  static vtkIdType ComputeCellIdForExtent(
221  const int extent[6], const int ijk[3], int dataDescription = VTK_EMPTY);
222 
229  static vtkIdType ComputePointId(
230  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
231 
238  static vtkIdType ComputeCellId(
239  const int dim[3], const int ijk[3], int dataDescription = VTK_EMPTY);
240 
247  static void ComputeCellStructuredCoordsForExtent(
248  const vtkIdType cellIdx, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
249 
255  static void ComputeCellStructuredCoords(
256  const vtkIdType cellId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
257 
263  static void ComputePointStructuredCoordsForExtent(
264  const vtkIdType ptId, const int ext[6], int ijk[3], int dataDescription = VTK_EMPTY);
265 
271  static void ComputePointStructuredCoords(
272  const vtkIdType ptId, const int dim[3], int ijk[3], int dataDescription = VTK_EMPTY);
273 
274 protected:
275  vtkStructuredData() = default;
276  ~vtkStructuredData() override = default;
277 
285  static vtkIdType GetLinearIndex(const int i, const int j, const int k, const int N1, const int N2)
286  {
287  return ((static_cast<vtkIdType>(k) * N2 + j) * N1 + i);
288  }
289 
291 
298  const vtkIdType idx, const int N1, const int N2, int& i, int& j, int& k)
299  {
300  vtkIdType N12 = N1 * N2;
301  k = static_cast<int>(idx / N12);
302  j = static_cast<int>((idx - k * N12) / N1);
303  i = static_cast<int>(idx - k * N12 - j * N1);
304  }
306 
307  // Want to avoid importing <algorithm> in the header...
308  template <typename T>
309  static T Max(const T& a, const T& b)
310  {
311  return (a > b) ? a : b;
312  }
313 
314 private:
315  vtkStructuredData(const vtkStructuredData&) = delete;
316  void operator=(const vtkStructuredData&) = delete;
317 };
318 
319 //------------------------------------------------------------------------------
320 inline void vtkStructuredData::GetCellDimensionsFromExtent(const int ext[6], int celldims[3], int)
321 {
322  celldims[0] = vtkStructuredData::Max(ext[1] - ext[0], 0);
323  celldims[1] = vtkStructuredData::Max(ext[3] - ext[2], 0);
324  celldims[2] = vtkStructuredData::Max(ext[5] - ext[4], 0);
325 }
326 
327 //------------------------------------------------------------------------------
328 inline vtkIdType vtkStructuredData::ComputePointId(const int dims[3], const int ijk[3], int)
329 {
330  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2], dims[0], dims[1]);
331 }
332 
333 //------------------------------------------------------------------------------
334 inline vtkIdType vtkStructuredData::ComputeCellId(const int dims[3], const int ijk[3], int)
335 {
336  return vtkStructuredData::GetLinearIndex(ijk[0], ijk[1], ijk[2],
337  vtkStructuredData::Max(dims[0] - 1, 1), vtkStructuredData::Max(dims[1] - 1, 1));
338 }
339 
340 //------------------------------------------------------------------------------
341 inline vtkIdType vtkStructuredData::GetNumberOfPoints(const int ext[6], int)
342 {
343  return static_cast<vtkIdType>(ext[1] - ext[0] + 1) * static_cast<vtkIdType>(ext[3] - ext[2] + 1) *
344  static_cast<vtkIdType>(ext[5] - ext[4] + 1);
345 }
346 
347 //------------------------------------------------------------------------------
348 inline vtkIdType vtkStructuredData::GetNumberOfCells(const int ext[6], int)
349 {
350  int cellDims[3];
352 
353  // Replace 0's with 1's so we can just multiply them regardless of cell type.
354  cellDims[0] = vtkStructuredData::Max(cellDims[0], 1);
355  cellDims[1] = vtkStructuredData::Max(cellDims[1], 1);
356  cellDims[2] = vtkStructuredData::Max(cellDims[2], 1);
357 
358  // Note, when we compute the result below, we statically cast to vtkIdType to
359  // ensure the compiler will generate a 32x32=64 instruction.
360  return static_cast<vtkIdType>(cellDims[0]) * static_cast<vtkIdType>(cellDims[1]) *
361  static_cast<vtkIdType>(cellDims[2]);
362 }
363 
364 //------------------------------------------------------------------------------
366  const int nodeExtent[6], int cellExtent[6], int)
367 {
368  cellExtent[0] = nodeExtent[0];
369  cellExtent[2] = nodeExtent[2];
370  cellExtent[4] = nodeExtent[4];
371 
372  cellExtent[1] = vtkStructuredData::Max(nodeExtent[0], nodeExtent[1] - 1);
373  cellExtent[3] = vtkStructuredData::Max(nodeExtent[2], nodeExtent[3] - 1);
374  cellExtent[5] = vtkStructuredData::Max(nodeExtent[4], nodeExtent[5] - 1);
375 }
376 
377 //------------------------------------------------------------------------------
378 inline void vtkStructuredData::GetDimensionsFromExtent(const int ext[6], int dims[3], int)
379 {
380  dims[0] = ext[1] - ext[0] + 1;
381  dims[1] = ext[3] - ext[2] + 1;
382  dims[2] = ext[5] - ext[4] + 1;
383 }
384 
385 //------------------------------------------------------------------------------
387  const int nodeDims[3], int cellDims[3])
388 {
389  cellDims[0] = vtkStructuredData::Max(nodeDims[0] - 1, 0);
390  cellDims[1] = vtkStructuredData::Max(nodeDims[1] - 1, 0);
391  cellDims[2] = vtkStructuredData::Max(nodeDims[2] - 1, 0);
392 }
393 
394 //------------------------------------------------------------------------------
396  const int ijk[3], const int ext[6], int lijk[3], int)
397 {
398  lijk[0] = ijk[0] - ext[0];
399  lijk[1] = ijk[1] - ext[2];
400  lijk[2] = ijk[2] - ext[4];
401 }
402 
403 //------------------------------------------------------------------------------
405  const int lijk[3], const int ext[6], int ijk[3], int)
406 {
407  ijk[0] = ext[0] + lijk[0];
408  ijk[1] = ext[2] + lijk[1];
409  ijk[2] = ext[4] + lijk[2];
410 }
411 
412 //------------------------------------------------------------------------------
414  const int extent[6], const int ijk[3], int)
415 {
416  int dims[3];
418 
419  int lijk[3];
421 
422  return vtkStructuredData::ComputePointId(dims, lijk);
423 }
424 
425 //------------------------------------------------------------------------------
427  const int extent[6], const int ijk[3], int)
428 {
429  int nodeDims[3];
431 
432  int lijk[3];
434 
435  return vtkStructuredData::ComputeCellId(nodeDims, lijk);
436 }
437 
438 //------------------------------------------------------------------------------
440  const vtkIdType cellId, const int dims[3], int ijk[3], int)
441 {
443  cellId, dims[0] - 1, dims[1] - 1, ijk[0], ijk[1], ijk[2]);
444 }
445 
446 //------------------------------------------------------------------------------
448  const vtkIdType cellIdx, const int ext[6], int ijk[3], int)
449 {
450  int nodeDims[3];
452 
453  int lijk[3];
454  vtkStructuredData::ComputeCellStructuredCoords(cellIdx, nodeDims, lijk);
455 
457 }
458 
459 //------------------------------------------------------------------------------
461  const vtkIdType ptId, const int dim[3], int ijk[3], int)
462 {
463  vtkStructuredData::GetStructuredCoordinates(ptId, dim[0], dim[1], ijk[0], ijk[1], ijk[2]);
464 }
465 
466 //------------------------------------------------------------------------------
468  const vtkIdType ptId, const int ext[6], int ijk[3], int)
469 {
470  int nodeDims[3];
472 
473  int lijk[3];
475 
477 }
478 
479 #endif
list of point or cell ids
Definition: vtkIdList.h:143
a simple class to control print indentation
Definition: vtkIndent.h:119
abstract base class for most VTK objects
Definition: vtkObject.h:82
Singleton class for topologically regular data.
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 int SetDimensions(int inDim[3], int dim[3])
Specify the dimensions of a regular, rectangular dataset.
static void ComputeCellStructuredCoords(const 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 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 SetExtent(int inExt[6], int ext[6])
Specify the dimensions of a regular, rectangular 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 void ComputeCellStructuredCoordsForExtent(const 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).
static void ComputePointStructuredCoordsForExtent(const 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).
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static bool IsCellVisible(vtkIdType cellId, int dimensions[3], int dataDescription, vtkUnsignedCharArray *cellGhostArray, vtkUnsignedCharArray *pointGhostArray=nullptr)
Return non-zero value if specified cell is visible.
~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 void ComputePointStructuredCoords(const 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 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 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 void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, 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:351
#define VTK_EMPTY
int vtkIdType
Definition: vtkType.h:332