VTK
vtkImageData.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkImageData.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 =========================================================================*/
31 #ifndef vtkImageData_h
32 #define vtkImageData_h
33 
34 #include "vtkCommonDataModelModule.h" // For export macro
35 #include "vtkDataSet.h"
36 
37 #include "vtkStructuredData.h" // Needed for inline methods
38 
39 class vtkDataArray;
40 class vtkLine;
41 class vtkPixel;
42 class vtkVertex;
43 class vtkVoxel;
44 
45 class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
46 {
47 public:
48  static vtkImageData *New();
49 
50  vtkTypeMacro(vtkImageData,vtkDataSet);
51  void PrintSelf(ostream& os, vtkIndent indent) override;
52 
57  void CopyStructure(vtkDataSet *ds) override;
58 
62  int GetDataObjectType() override {return VTK_IMAGE_DATA;};
63 
65 
69  vtkIdType GetNumberOfPoints() override;
70  double *GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
71  void GetPoint(vtkIdType id, double x[3]) override;
72  vtkCell *GetCell(vtkIdType cellId) override;
73  vtkCell *GetCell(int i, int j, int k) override;
74  void GetCell(vtkIdType cellId, vtkGenericCell *cell) override;
75  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
76  virtual vtkIdType FindPoint(double x, double y, double z)
77  {
78  return this->vtkDataSet::FindPoint(x, y, z);
79  }
80  vtkIdType FindPoint(double x[3]) override;
82  double x[3], vtkCell *cell, vtkIdType cellId, double tol2,
83  int& subId, double pcoords[3], double *weights) override;
85  double x[3], vtkCell *cell, vtkGenericCell *gencell,
86  vtkIdType cellId, double tol2, int& subId,
87  double pcoords[3], double *weights) override;
88  vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId,
89  double tol2, int& subId, double pcoords[3],
90  double *weights) override;
91  int GetCellType(vtkIdType cellId) override;
92  void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
93  {vtkStructuredData::GetCellPoints(cellId,ptIds,this->DataDescription,
94  this->GetDimensions());}
95  void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
96  {vtkStructuredData::GetPointCells(ptId,cellIds,this->GetDimensions());}
97  void ComputeBounds() override;
98  int GetMaxCellSize() override {return 8;}; //voxel is the largest
100 
104  void Initialize() override;
105 
109  virtual void SetDimensions(int i, int j, int k);
110 
114  virtual void SetDimensions(const int dims[3]);
115 
122  virtual int *GetDimensions() VTK_SIZEHINT(3);
123 
130  virtual void GetDimensions(int dims[3]);
131 
138  virtual int ComputeStructuredCoordinates(
139  const double x[3], int ijk[3], double pcoords[3]);
140 
141  static int ComputeStructuredCoordinates( const double x[3], int ijk[3], double pcoords[3],
142  const int* extent,
143  const double* spacing,
144  const double* origin,
145  const double* bounds);
155  virtual void GetVoxelGradient(
156  int i,int j,int k, vtkDataArray *s, vtkDataArray *g);
157 
164  virtual void GetPointGradient(
165  int i, int j, int k, vtkDataArray *s, double g[3]);
166 
170  virtual int GetDataDimension();
171 
175  virtual vtkIdType ComputePointId(int ijk[3]) {
176  return vtkStructuredData::ComputePointIdForExtent(this->Extent,ijk);};
177 
181  virtual vtkIdType ComputeCellId(int ijk[3]) {
182  return vtkStructuredData::ComputeCellIdForExtent(this->Extent,ijk);};
183 
185 
188  virtual void SetAxisUpdateExtent(int axis, int min, int max,
189  const int* updateExtent,
190  int* axisUpdateExtent);
191  virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int* updateExtent);
193 
195 
206  virtual void SetExtent(int extent[6]);
207  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
208  vtkGetVector6Macro(Extent, int);
210 
212 
216  virtual double GetScalarTypeMin(vtkInformation* meta_data);
217  virtual double GetScalarTypeMin();
218  virtual double GetScalarTypeMax(vtkInformation* meta_data);
219  virtual double GetScalarTypeMax();
221 
223 
226  virtual int GetScalarSize(vtkInformation* meta_data);
227  virtual int GetScalarSize();
229 
231 
238  virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
239  virtual void GetIncrements(vtkIdType inc[3]);
240  virtual vtkIdType *GetIncrements(vtkDataArray *scalars) VTK_SIZEHINT(3);
241  virtual void GetIncrements(vtkDataArray *scalars,
242  vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
243  virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
245 
247 
260  virtual void GetContinuousIncrements(
261  int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
262  virtual void GetContinuousIncrements(vtkDataArray *scalars,
263  int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
265 
267 
270  virtual void *GetScalarPointerForExtent(int extent[6]);
271  virtual void *GetScalarPointer(int coordinates[3]);
272  virtual void *GetScalarPointer(int x, int y, int z);
273  virtual void *GetScalarPointer();
275 
277 
280  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
281  virtual void SetScalarComponentFromFloat(
282  int x, int y, int z, int component, float v);
283  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
284  virtual void SetScalarComponentFromDouble(
285  int x, int y, int z, int component, double v);
287 
293  virtual void AllocateScalars(int dataType, int numComponents);
294 
301  virtual void AllocateScalars(vtkInformation* pipeline_info);
302 
304 
310  virtual void CopyAndCastFrom(vtkImageData *inData, int extent[6]);
311  virtual void CopyAndCastFrom(vtkImageData *inData, int x0, int x1,
312  int y0, int y1, int z0, int z1)
313  {int e[6]; e[0]=x0; e[1]=x1; e[2]=y0; e[3]=y1; e[4]=z0; e[5]=z1;
314  this->CopyAndCastFrom(inData, e);}
316 
322  void Crop(const int* updateExtent) override;
323 
332  unsigned long GetActualMemorySize() override;
333 
335 
339  vtkSetVector3Macro(Spacing,double);
340  vtkGetVector3Macro(Spacing,double);
342 
344 
352  vtkSetVector3Macro(Origin,double);
353  vtkGetVector3Macro(Origin,double);
355 
356  static void SetScalarType(int, vtkInformation* meta_data);
357  static int GetScalarType(vtkInformation* meta_data);
358  static bool HasScalarType(vtkInformation* meta_data);
360  const char* GetScalarTypeAsString()
361  { return vtkImageScalarTypeNameMacro ( this->GetScalarType() ); };
362 
364 
368  static void SetNumberOfScalarComponents( int n, vtkInformation* meta_data);
373 
378  void CopyInformationFromPipeline(vtkInformation* information) override;
379 
385  void CopyInformationToPipeline(vtkInformation* information) override;
386 
392  void PrepareForNewData() override;
393 
395 
398  void ShallowCopy(vtkDataObject *src) override;
399  void DeepCopy(vtkDataObject *src) override;
401 
402  //--------------------------------------------------------------------------
403  // Methods that apply to any array (not just scalars).
404  // I am starting to experiment with generalizing imaging filters
405  // to operate on more than just scalars.
406 
408 
414  void *GetArrayPointer(vtkDataArray* array, int coordinates[3]);
416 
421  void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3]);
422 
429  void ComputeInternalExtent(int *intExt, int *tgtExt, int *bnds);
430 
434  int GetExtentType() override { return VTK_3D_EXTENT; };
435 
437 
443 
444 protected:
446  ~vtkImageData() override;
447 
448  // The extent of what is currently in the structured grid.
449  // Dimensions is just an array to return a value.
450  // Its contents are out of data until GetDimensions is called.
451  int Dimensions[3];
452  vtkIdType Increments[3];
453 
454  double Origin[3];
455  double Spacing[3];
456 
457  int Extent[6];
458 
459  // The first method assumes Active Scalars
460  void ComputeIncrements();
461  // This one is given the number of components of the
462  // scalar field explicitly
463  void ComputeIncrements(int numberOfComponents);
464  void ComputeIncrements(vtkDataArray *scalars);
465 
466  // The first method assumes Acitive Scalars
468  // This one is given the number of components of the
469  // scalar field explicitly
470  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
471  void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
473 
475 
476  void SetDataDescription(int desc);
477  int GetDataDescription() { return this->DataDescription; }
478 
479 private:
480  void InternalImageDataCopy(vtkImageData *src);
481 private:
482 
483  friend class vtkUniformGrid;
484 
485  // for the GetCell method
486  vtkVertex *Vertex;
487  vtkLine *Line;
488  vtkPixel *Pixel;
489  vtkVoxel *Voxel;
490 
491  // for the GetPoint method
492  double Point[3];
493 
494  int DataDescription;
495 
496  vtkImageData(const vtkImageData&) = delete;
497  void operator=(const vtkImageData&) = delete;
498 };
499 
500 
501 //----------------------------------------------------------------------------
503 {
504  this->ComputeIncrements(this->Increments);
505 }
506 
507 //----------------------------------------------------------------------------
508 inline void vtkImageData::ComputeIncrements(int numberOfComponents)
509 {
510  this->ComputeIncrements(numberOfComponents, this->Increments);
511 }
512 
513 //----------------------------------------------------------------------------
515 {
516  this->ComputeIncrements(scalars, this->Increments);
517 }
518 
519 //----------------------------------------------------------------------------
521 {
522  this->GetPoint(id, this->Point);
523  return this->Point;
524 }
525 
526 //----------------------------------------------------------------------------
528 {
529  const int *extent = this->Extent;
530  vtkIdType dims[3];
531  dims[0] = extent[1] - extent[0] + 1;
532  dims[1] = extent[3] - extent[2] + 1;
533  dims[2] = extent[5] - extent[4] + 1;
534 
535  return dims[0]*dims[1]*dims[2];
536 }
537 
538 //----------------------------------------------------------------------------
540 {
541  return vtkStructuredData::GetDataDimension(this->DataDescription);
542 }
543 
544 #endif
vtkDataSet::GetNumberOfPoints
virtual vtkIdType GetNumberOfPoints()=0
Determine the number of points composing the dataset.
vtkStructuredData::GetDataDimension
static int GetDataDimension(int dataDescription)
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
vtkImageData::GetCellPoints
void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
Topological inquiry to get points defining cell.
Definition: vtkImageData.h:92
vtkImageData::HasNumberOfScalarComponents
static bool HasNumberOfScalarComponents(vtkInformation *meta_data)
vtkX3D::component
@ component
Definition: vtkX3D.h:175
vtkImageData::GetMaxCellSize
int GetMaxCellSize() override
Convenience method returns largest cell size in dataset.
Definition: vtkImageData.h:98
vtkImageData::SetDimensions
virtual void SetDimensions(int i, int j, int k)
Same as SetExtent(0, i-1, 0, j-1, 0, k-1)
vtkImageData::GetNumberOfScalarComponents
static int GetNumberOfScalarComponents(vtkInformation *meta_data)
vtkImageData::ComputeBounds
void ComputeBounds() override
Compute the data bounding box from data points.
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkImageData::GetActualMemorySize
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
vtkImageData::ExtentComputeTime
vtkTimeStamp ExtentComputeTime
Definition: vtkImageData.h:474
vtkImageData::ComputeInternalExtent
void ComputeInternalExtent(int *intExt, int *tgtExt, int *bnds)
Given how many pixel are required on a side for bounrary conditions (in bnds), the target extent to t...
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:42
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
VTK_IMAGE_DATA
#define VTK_IMAGE_DATA
Definition: vtkType.h:97
vtkImageData::GetScalarSize
virtual int GetScalarSize()
vtkUniformGrid
image data with blanking
Definition: vtkUniformGrid.h:41
vtkImageData::PrepareForNewData
void PrepareForNewData() override
make the output data ready for new data to be inserted.
vtkImageData::GetExtentType
int GetExtentType() override
The extent type is a 3D extent.
Definition: vtkImageData.h:434
vtkImageData::GetCellType
int GetCellType(vtkIdType cellId) override
Get type of cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkImageData::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkImageData::FindCell
vtkIdType FindCell(double x[3], vtkCell *cell, vtkGenericCell *gencell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
This is a version of the above method that can be used with multithreaded applications.
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkImageData::SetExtent
virtual void SetExtent(int extent[6])
Set/Get the extent.
vtkImageData::GetData
static vtkImageData * GetData(vtkInformationVector *v, int i=0)
vtkImageData::CopyInformationFromPipeline
void CopyInformationFromPipeline(vtkInformation *information) override
Override these to handle origin, spacing, scalar type, and scalar number of components.
vtkImageData::SetExtent
virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2)
vtkImageData::GetCell
vtkCell * GetCell(vtkIdType cellId) override
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkImageData::FindCell
vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Locate cell based on global coordinate x and tolerance squared.
vtkVertex
a cell that represents a 3D point
Definition: vtkVertex.h:37
vtkImageData::GetCellBounds
void GetCellBounds(vtkIdType cellId, double bounds[6]) override
Get the bounds of the cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkImageData::GetDimensions
virtual int * GetDimensions()
Get dimensions of this structured points dataset.
vtkLine
cell represents a 1D line
Definition: vtkLine.h:36
vtkImageData::SetAxisUpdateExtent
virtual void SetAxisUpdateExtent(int axis, int min, int max, const int *updateExtent, int *axisUpdateExtent)
Set / Get the extent on just one axis.
vtkImageData::SetScalarType
static void SetScalarType(int, vtkInformation *meta_data)
max
#define max(a, b)
Definition: vtkX3DExporterFIWriterHelper.h:31
vtkImageData::Extent
int Extent[6]
Definition: vtkImageData.h:457
VTK_3D_EXTENT
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:61
vtkImageData::FindAndGetCell
vtkCell * FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Locate the cell that contains a point and return the cell.
vtkImageData::ShallowCopy
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
vtkStructuredData.h
vtkImageData::GetNumberOfScalarComponents
int GetNumberOfScalarComponents()
vtkImageData::SetDataDescription
void SetDataDescription(int desc)
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:42
vtkStructuredData::GetCellPoints
static void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds, int dataDescription, int dim[3])
Get the points defining a cell.
vtkImageData::GetScalarSize
virtual int GetScalarSize(vtkInformation *meta_data)
Get the size of the scalar type in bytes.
vtkImageData::ComputeCellId
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:181
vtkDataSet::FindPoint
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:197
vtkImageData::FindPoint
virtual vtkIdType FindPoint(double x, double y, double z)
Definition: vtkImageData.h:76
vtkCell
abstract class to specify cell behavior
Definition: vtkCell.h:60
vtkImageData::~vtkImageData
~vtkImageData() override
vtkImageData::ComputeIncrements
void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3])
vtkStructuredData::GetPointCells
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, int dim[3])
Get the cells using a point.
vtkImageData::ComputeIncrements
void ComputeIncrements(vtkIdType inc[3])
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:46
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkStructuredData::ComputeCellIdForExtent
static vtkIdType ComputeCellIdForExtent(int extent[6], int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the extent of the structured dataset,...
Definition: vtkStructuredData.h:399
vtkImageData::GetPoint
double * GetPoint(vtkIdType ptId) override
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
Definition: vtkImageData.h:520
vtkImageData::GetIncrements
virtual vtkIdType * GetIncrements()
Different ways to get the increments for moving around the data.
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:37
vtkImageData::GetPointCells
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Topological inquiry to get cells using point.
Definition: vtkImageData.h:95
vtkImageData::GetNumberOfPoints
vtkIdType GetNumberOfPoints() override
Determine the number of points composing the dataset.
Definition: vtkImageData.h:527
vtkImageData::SetDimensions
virtual void SetDimensions(const int dims[3])
Same as SetExtent(0, dims[0]-1, 0, dims[1]-1, 0, dims[2]-1)
vtkImageData::SetNumberOfScalarComponents
static void SetNumberOfScalarComponents(int n, vtkInformation *meta_data)
Set/Get the number of scalar components for points.
vtkImageData::GetScalarType
static int GetScalarType(vtkInformation *meta_data)
vtkImageData::Initialize
void Initialize() override
Restore data object to initial state.
vtkImageData::GetArrayPointerForExtent
void * GetArrayPointerForExtent(vtkDataArray *array, int extent[6])
These are convenience methods for getting a pointer from any filed array.
vtkImageData::CopyStructure
void CopyStructure(vtkDataSet *ds) override
Copy the geometric and topological structure of an input image data object.
vtkDataSet.h
vtkX3D::spacing
@ spacing
Definition: vtkX3D.h:481
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:63
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:87
vtkImageData::DeepCopy
void DeepCopy(vtkDataObject *src) override
vtkImageData::FindPoint
vtkIdType FindPoint(double x[3]) override
vtkX3D::info
@ info
Definition: vtkX3D.h:376
vtkDataSet::GetPoint
virtual double * GetPoint(vtkIdType ptId)=0
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
vtkImageData::GetCell
vtkCell * GetCell(int i, int j, int k) override
vtkImageData::GetCell
void GetCell(vtkIdType cellId, vtkGenericCell *cell) override
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkImageData::ComputeIncrements
void ComputeIncrements(int numberOfComponents, vtkIdType inc[3])
vtkImageData::CopyOriginAndSpacingFromPipeline
void CopyOriginAndSpacingFromPipeline(vtkInformation *info)
vtkPixel
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:41
vtkImageData::GetScalarType
int GetScalarType()
vtkImageData::CopyInformationToPipeline
void CopyInformationToPipeline(vtkInformation *information) override
Copy information from this data object to the pipeline information.
vtkImageData::GetDataDescription
int GetDataDescription()
Definition: vtkImageData.h:477
vtkImageData::GetDataDimension
virtual int GetDataDimension()
Return the dimensionality of the data.
Definition: vtkImageData.h:539
vtkGenericCell
provides thread-safe access to cells
Definition: vtkGenericCell.h:40
vtkImageData::Increments
vtkIdType Increments[3]
Definition: vtkImageData.h:452
vtkImageData::GetArrayPointer
void * GetArrayPointer(vtkDataArray *array, int coordinates[3])
vtkStructuredData::ComputePointIdForExtent
static vtkIdType ComputePointIdForExtent(int extent[6], int ijk[3], int dataDescription=VTK_EMPTY)
Given a location in structured coordinates (i-j-k), and the extent of the structured dataset,...
Definition: vtkStructuredData.h:386
vtkImageData::GetPoint
void GetPoint(vtkIdType id, double x[3]) override
Copy point coordinates into user provided array x[3] for specified point id.
vtkX3D::extent
@ extent
Definition: vtkX3D.h:345
vtkImageData::GetDataObjectType
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkImageData.h:62
vtkImageData::ComputeIncrements
void ComputeIncrements()
Definition: vtkImageData.h:502
vtkImageData::GetData
static vtkImageData * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
vtkImageData::GetScalarTypeMax
virtual double GetScalarTypeMax(vtkInformation *meta_data)
vtkImageData::GetArrayIncrements
void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3])
Since various arrays have different number of components, the will have different increments.
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:65
vtkImageData::GetNumberOfCells
vtkIdType GetNumberOfCells() override
Standard vtkDataSet API methods.
vtkImageData::New
static vtkImageData * New()
vtkImageData::GetScalarTypeAsString
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:360
vtkImageData::GetScalarTypeMin
virtual double GetScalarTypeMin()
vtkImageData::GetScalarTypeMax
virtual double GetScalarTypeMax()
vtkImageData::GetScalarTypeMin
virtual double GetScalarTypeMin(vtkInformation *meta_data)
These returns the minimum and maximum values the ScalarType can hold without overflowing.
vtkImageData::vtkImageData
vtkImageData()
vtkImageData::GetAxisUpdateExtent
virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int *updateExtent)
vtkImageData::Crop
void Crop(const int *updateExtent) override
Reallocates and copies to set the Extent to updateExtent.
vtkImageData::HasScalarType
static bool HasScalarType(vtkInformation *meta_data)
vtkVoxel
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:45