VTK  9.0.1
vtkRectilinearGrid.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkRectilinearGrid.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 =========================================================================*/
37 #ifndef vtkRectilinearGrid_h
38 #define vtkRectilinearGrid_h
39 
40 #include "vtkCommonDataModelModule.h" // For export macro
41 #include "vtkDataSet.h"
42 #include "vtkStructuredData.h" // For inline methods
43 
44 class vtkVertex;
45 class vtkLine;
46 class vtkPixel;
47 class vtkVoxel;
48 class vtkDataArray;
49 class vtkPoints;
50 
51 class VTKCOMMONDATAMODEL_EXPORT vtkRectilinearGrid : public vtkDataSet
52 {
53 public:
54  static vtkRectilinearGrid* New();
55 
57  void PrintSelf(ostream& os, vtkIndent indent) override;
58 
62  int GetDataObjectType() override { return VTK_RECTILINEAR_GRID; }
63 
68  void CopyStructure(vtkDataSet* ds) override;
69 
73  void Initialize() override;
74 
76 
79  vtkIdType GetNumberOfCells() override;
80  vtkIdType GetNumberOfPoints() override;
81  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
82  void GetPoint(vtkIdType id, double x[3]) override;
83  vtkCell* GetCell(vtkIdType cellId) override;
84  vtkCell* GetCell(int i, int j, int k) override;
85  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
86  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
87  vtkIdType FindPoint(double x, double y, double z) { return this->vtkDataSet::FindPoint(x, y, z); }
88  vtkIdType FindPoint(double x[3]) override;
89  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
90  double pcoords[3], double* weights) override;
91  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
92  double tol2, int& subId, double pcoords[3], double* weights) override;
93  vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
94  double pcoords[3], double* weights) override;
95  int GetCellType(vtkIdType cellId) override;
96  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
97  {
98  vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, this->Dimensions);
99  }
100  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
101  {
102  vtkStructuredData::GetPointCells(ptId, cellIds, this->Dimensions);
103  }
104  void ComputeBounds() override;
105  int GetMaxCellSize() override { return 8; } // voxel is the largest
106  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
108 
113  void GetPoints(vtkPoints* pnts);
114 
116 
120  void SetDimensions(int i, int j, int k);
121  void SetDimensions(const int dim[3]);
123 
125 
128  vtkGetVectorMacro(Dimensions, int, 3);
130 
134  int GetDataDimension();
135 
142  int ComputeStructuredCoordinates(double x[3], int ijk[3], double pcoords[3]);
143 
147  vtkIdType ComputePointId(int ijk[3]);
148 
152  vtkIdType ComputeCellId(int ijk[3]);
153 
159  void GetPoint(const int i, const int j, const int k, double p[3]);
160 
162 
165  virtual void SetXCoordinates(vtkDataArray*);
166  vtkGetObjectMacro(XCoordinates, vtkDataArray);
168 
170 
173  virtual void SetYCoordinates(vtkDataArray*);
174  vtkGetObjectMacro(YCoordinates, vtkDataArray);
176 
178 
181  virtual void SetZCoordinates(vtkDataArray*);
182  vtkGetObjectMacro(ZCoordinates, vtkDataArray);
184 
186 
191  void SetExtent(int extent[6]);
192  void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
193  vtkGetVector6Macro(Extent, int);
195 
204  unsigned long GetActualMemorySize() override;
205 
207 
210  void ShallowCopy(vtkDataObject* src) override;
211  void DeepCopy(vtkDataObject* src) override;
213 
217  int GetExtentType() override { return VTK_3D_EXTENT; }
218 
224  void Crop(const int* updateExtent) override;
225 
227 
231  static vtkRectilinearGrid* GetData(vtkInformationVector* v, int i = 0);
233 
234 protected:
236  ~vtkRectilinearGrid() override;
237 
238  // for the GetCell method
243 
244  int Dimensions[3];
246 
247  int Extent[6];
248 
252 
253  // Hang on to some space for returning points when GetPoint(id) is called.
254  double PointReturn[3];
255 
256 private:
257  void Cleanup();
258 
259 private:
260  vtkRectilinearGrid(const vtkRectilinearGrid&) = delete;
261  void operator=(const vtkRectilinearGrid&) = delete;
262 };
263 
264 //----------------------------------------------------------------------------
266 {
267  vtkIdType nCells = 1;
268  int i;
269 
270  for (i = 0; i < 3; i++)
271  {
272  if (this->Dimensions[i] <= 0)
273  {
274  return 0;
275  }
276  if (this->Dimensions[i] > 1)
277  {
278  nCells *= (this->Dimensions[i] - 1);
279  }
280  }
281 
282  return nCells;
283 }
284 
285 //----------------------------------------------------------------------------
287 {
288  return static_cast<vtkIdType>(this->Dimensions[0]) * this->Dimensions[1] * this->Dimensions[2];
289 }
290 
291 //----------------------------------------------------------------------------
293 {
295 }
296 
297 //----------------------------------------------------------------------------
299 {
301 }
302 
303 //----------------------------------------------------------------------------
305 {
306  return vtkStructuredData::ComputeCellId(this->Dimensions, ijk);
307 }
308 
309 #endif
int GetDataDimension()
Return the dimensionality of the data.
vtkIdType FindPoint(double x, double y, double z)
Standard vtkDataSet API methods.
int GetDataObjectType() override
Return what type of dataset this is.
a dataset that is topologically regular with variable spacing in the three coordinate directions ...
virtual vtkCell * FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights)
Locate the cell that contains a point and return the cell.
virtual vtkIdType GetNumberOfCells()=0
Determine the number of cells composing the dataset.
vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
int GetMaxCellSize() override
Standard vtkDataSet API methods.
static vtkDataObject * New()
virtual vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights)=0
Locate cell based on global coordinate x and tolerance squared.
#define VTK_RECTILINEAR_GRID
Definition: vtkType.h:88
Store vtkAlgorithm input/output information.
virtual vtkIdType GetNumberOfPoints()=0
Determine the number of points composing the dataset.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
a cell that represents a 3D point
Definition: vtkVertex.h:30
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:56
static int GetDataDimension(int dataDescription)
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:34
virtual void ComputeBounds()
Compute the data bounding box from data points.
int GetExtentType() override
Structured extent.
vtkDataArray * XCoordinates
int vtkIdType
Definition: vtkType.h:338
void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
Standard vtkDataSet API methods.
static vtkDataSet * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
provides thread-safe access to cells
vtkIdType ComputePointId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the point id.
virtual void Crop(const int *updateExtent)
This method crops the data object (if necessary) so that the extent matches the update extent...
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...
cell represents a 1D line
Definition: vtkLine.h:29
abstract class to specify cell behavior
Definition: vtkCell.h:56
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:38
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkIdType GetNumberOfPoints() override
Standard vtkDataSet API methods.
static void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds, int dataDescription, int dim[3])
Get the points defining a cell.
vtkDataArray * ZCoordinates
list of point or cell ids
Definition: vtkIdList.h:30
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
void DeepCopy(vtkDataObject *src) override
Shallow and Deep copy.
virtual void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds)
Topological inquiry to get all cells using list of points exclusive of cell specified (e...
#define VTK_SIZEHINT(...)
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, int dim[3])
Get the cells using a point.
void Initialize() override
Restore data object to initial state.
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Standard vtkDataSet API methods.
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...
vtkDataArray * YCoordinates
vtkIdType GetNumberOfCells() override
Standard vtkDataSet API methods.
virtual void CopyStructure(vtkDataSet *ds)=0
Copy the geometric and topological structure of an object.
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
Store zero or more vtkInformation instances.
virtual double * GetPoint(vtkIdType ptId)=0
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
general representation of visualization data
Definition: vtkDataObject.h:59
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:193
virtual vtkCell * GetCell(vtkIdType cellId)=0
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
represent and manipulate 3D points
Definition: vtkPoints.h:33
virtual void GetCellBounds(vtkIdType cellId, double bounds[6])
Get the bounds of the cell with cellId such that: 0 <= cellId < NumberOfCells.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual int GetCellType(vtkIdType cellId)=0
Get type of cell with cellId such that: 0 <= cellId < NumberOfCells.