VTK  9.0.20210118
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 vtkMatrix3x3;
42 class vtkMatrix4x4;
43 class vtkPixel;
44 class vtkVertex;
45 class vtkVoxel;
46 
47 class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
48 {
49 public:
50  static vtkImageData* New();
51  static vtkImageData* ExtendedNew();
52 
53  vtkTypeMacro(vtkImageData, vtkDataSet);
54  void PrintSelf(ostream& os, vtkIndent indent) override;
55 
60  void CopyStructure(vtkDataSet* ds) override;
61 
65  int GetDataObjectType() override { return VTK_IMAGE_DATA; }
66 
68 
75  vtkIdType GetNumberOfCells() override;
76  vtkIdType GetNumberOfPoints() override;
77  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
78  void GetPoint(vtkIdType id, double x[3]) override;
79  vtkCell* GetCell(vtkIdType cellId) override;
80  vtkCell* GetCell(int i, int j, int k) override;
81  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
82  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
83  virtual vtkIdType FindPoint(double x, double y, double z)
84  {
85  return this->vtkDataSet::FindPoint(x, y, z);
86  }
87  vtkIdType FindPoint(double x[3]) override;
88  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
89  double pcoords[3], double* weights) override;
90  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
91  double tol2, int& subId, double pcoords[3], double* weights) override;
92  vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
93  double pcoords[3], double* weights) override;
94  int GetCellType(vtkIdType cellId) override;
95  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
96  {
97  vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, this->GetDimensions());
98  }
99  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
100  {
101  vtkStructuredData::GetPointCells(ptId, cellIds, this->GetDimensions());
102  }
103  void ComputeBounds() override;
104  int GetMaxCellSize() override { return 8; } // voxel is the largest
106 
110  void Initialize() override;
111 
115  virtual void SetDimensions(int i, int j, int k);
116 
120  virtual void SetDimensions(const int dims[3]);
121 
128  virtual int* GetDimensions() VTK_SIZEHINT(3);
129 
136  virtual void GetDimensions(int dims[3]);
137 #if VTK_ID_TYPE_IMPL != VTK_INT
138  virtual void GetDimensions(vtkIdType dims[3]);
139 #endif
140 
147  virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
148 
158  virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
159 
166  virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
167 
171  virtual int GetDataDimension();
172 
176  virtual vtkIdType ComputePointId(int ijk[3])
177  {
178  return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
179  }
180 
184  virtual vtkIdType ComputeCellId(int ijk[3])
185  {
186  return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
187  }
188 
190 
193  virtual void SetAxisUpdateExtent(
194  int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
195  virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
197 
199 
210  virtual void SetExtent(int extent[6]);
211  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
212  vtkGetVector6Macro(Extent, int);
214 
216 
220  virtual double GetScalarTypeMin(vtkInformation* meta_data);
221  virtual double GetScalarTypeMin();
222  virtual double GetScalarTypeMax(vtkInformation* meta_data);
223  virtual double GetScalarTypeMax();
225 
227 
230  virtual int GetScalarSize(vtkInformation* meta_data);
231  virtual int GetScalarSize();
233 
235 
241  virtual vtkIdType* GetIncrements() VTK_SIZEHINT(3);
242  virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
243  virtual void GetIncrements(vtkIdType inc[3]);
244  virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
245  virtual void GetIncrements(
246  vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
247  virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
249 
251 
264  virtual void GetContinuousIncrements(
265  int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
266  virtual void GetContinuousIncrements(
267  vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
269 
271 
274  virtual void* GetScalarPointerForExtent(int extent[6]);
275  virtual void* GetScalarPointer(int coordinates[3]);
276  virtual void* GetScalarPointer(int x, int y, int z);
277  virtual void* GetScalarPointer();
279 
281 
284  virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
285  virtual vtkIdType GetScalarIndex(int coordinates[3]);
286  virtual vtkIdType GetScalarIndex(int x, int y, int z);
288 
290 
293  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
294  virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
295  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
296  virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
298 
304  virtual void AllocateScalars(int dataType, int numComponents);
305 
312  virtual void AllocateScalars(vtkInformation* pipeline_info);
313 
315 
321  virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
322  virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
323  {
324  int e[6];
325  e[0] = x0;
326  e[1] = x1;
327  e[2] = y0;
328  e[3] = y1;
329  e[4] = z0;
330  e[5] = z1;
331  this->CopyAndCastFrom(inData, e);
332  }
334 
340  void Crop(const int* updateExtent) override;
341 
350  unsigned long GetActualMemorySize() override;
351 
353 
357  vtkGetVector3Macro(Spacing, double);
358  virtual void SetSpacing(double i, double j, double k);
359  virtual void SetSpacing(const double ijk[3]);
361 
363 
371  vtkGetVector3Macro(Origin, double);
372  virtual void SetOrigin(double i, double j, double k);
373  virtual void SetOrigin(const double ijk[3]);
375 
377 
381  vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
382  virtual void SetDirectionMatrix(vtkMatrix3x3* m);
383  virtual void SetDirectionMatrix(const double elements[9]);
384  virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
385  double e12, double e20, double e21, double e22);
387 
389 
393  vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
395 
397 
400  virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
401  virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
402  virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
403  virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
404  static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
405  double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
407 
409 
413  vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
415 
417 
420  virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
421  virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
423 
424  static void ComputeIndexToPhysicalMatrix(
425  double const origin[3], double const spacing[3], double const direction[9], double result[16]);
426 
428 
431  virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
433 
438  virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
439 
440  static void SetScalarType(int, vtkInformation* meta_data);
441  static int GetScalarType(vtkInformation* meta_data);
442  static bool HasScalarType(vtkInformation* meta_data);
443  int GetScalarType();
444  const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
445 
447 
451  static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
452  static int GetNumberOfScalarComponents(vtkInformation* meta_data);
453  static bool HasNumberOfScalarComponents(vtkInformation* meta_data);
454  int GetNumberOfScalarComponents();
456 
461  void CopyInformationFromPipeline(vtkInformation* information) override;
462 
468  void CopyInformationToPipeline(vtkInformation* information) override;
469 
475  void PrepareForNewData() override;
476 
478 
481  void ShallowCopy(vtkDataObject* src) override;
482  void DeepCopy(vtkDataObject* src) override;
484 
485  //--------------------------------------------------------------------------
486  // Methods that apply to any array (not just scalars).
487  // I am starting to experiment with generalizing imaging filters
488  // to operate on more than just scalars.
489 
491 
496  void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
497  void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
499 
501 
508  vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
510 
515  void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
516 
523  void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
524 
528  int GetExtentType() override { return VTK_3D_EXTENT; }
529 
531 
535  static vtkImageData* GetData(vtkInformationVector* v, int i = 0);
537 
538 protected:
539  vtkImageData();
540  ~vtkImageData() override;
541 
542  // The extent of what is currently in the structured grid.
543  // Dimensions is just an array to return a value.
544  // Its contents are out of data until GetDimensions is called.
545  int Dimensions[3];
546  vtkIdType Increments[3];
547 
548  // Variables used to define dataset physical orientation
549  double Origin[3];
550  double Spacing[3];
554 
555  int Extent[6];
556 
557  // The first method assumes Active Scalars
558  void ComputeIncrements();
559  // This one is given the number of components of the
560  // scalar field explicitly
561  void ComputeIncrements(int numberOfComponents);
562  void ComputeIncrements(vtkDataArray* scalars);
563 
564  // The first method assumes Acitive Scalars
565  void ComputeIncrements(vtkIdType inc[3]);
566  // This one is given the number of components of the
567  // scalar field explicitly
568  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
569  void ComputeIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
570 
571  // for the index to physical methods
572  void ComputeTransforms();
573 
574  // Cell utilities
575  vtkCell* GetCellTemplateForDataDescription();
576  bool GetCellTemplateForDataDescription(vtkGenericCell* cell);
577  bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
578  bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
579  void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
580 
582 
583  void SetDataDescription(int desc);
584  int GetDataDescription() { return this->DataDescription; }
585 
586 private:
587  void InternalImageDataCopy(vtkImageData* src);
588 
589 private:
590  friend class vtkUniformGrid;
591 
592  // for the GetCell method
593  vtkVertex* Vertex;
594  vtkLine* Line;
595  vtkPixel* Pixel;
596  vtkVoxel* Voxel;
597 
598  // for the GetPoint method
599  double Point[3];
600 
601  int DataDescription;
602 
603  vtkImageData(const vtkImageData&) = delete;
604  void operator=(const vtkImageData&) = delete;
605 };
606 
607 //----------------------------------------------------------------------------
609 {
610  this->ComputeIncrements(this->Increments);
611 }
612 
613 //----------------------------------------------------------------------------
614 inline void vtkImageData::ComputeIncrements(int numberOfComponents)
615 {
616  this->ComputeIncrements(numberOfComponents, this->Increments);
617 }
618 
619 //----------------------------------------------------------------------------
621 {
622  this->ComputeIncrements(scalars, this->Increments);
623 }
624 
625 //----------------------------------------------------------------------------
627 {
628  this->GetPoint(id, this->Point);
629  return this->Point;
630 }
631 
632 //----------------------------------------------------------------------------
634 {
635  const int* extent = this->Extent;
636  vtkIdType dims[3];
637  dims[0] = extent[1] - extent[0] + 1;
638  dims[1] = extent[3] - extent[2] + 1;
639  dims[2] = extent[5] - extent[4] + 1;
640 
641  return dims[0] * dims[1] * dims[2];
642 }
643 
644 //----------------------------------------------------------------------------
646 {
647  return vtkStructuredData::GetDataDimension(this->DataDescription);
648 }
649 
650 #endif
vtkDataSet::GetNumberOfPoints
virtual vtkIdType GetNumberOfPoints()=0
Determine the number of points composing the dataset.
vtkDataSet::GetActualMemorySize
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
vtkStructuredData::GetDataDimension
static int GetDataDimension(int dataDescription)
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
vtkDataSet::ShallowCopy
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
vtkImageData::GetCellPoints
void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
Topological inquiry to get points defining cell.
Definition: vtkImageData.h:95
vtkImageData::IndexToPhysicalMatrix
vtkMatrix4x4 * IndexToPhysicalMatrix
Definition: vtkImageData.h:552
vtkX3D::component
Definition: vtkX3D.h:181
vtkImageData::GetMaxCellSize
int GetMaxCellSize() override
Convenience method returns largest cell size in dataset.
Definition: vtkImageData.h:104
vtkIdType
int vtkIdType
Definition: vtkType.h:330
vtkImageData::ExtentComputeTime
vtkTimeStamp ExtentComputeTime
Definition: vtkImageData.h:581
vtkX3D::direction
Definition: vtkX3D.h:266
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:35
vtkImageData::ComputePointId
virtual vtkIdType ComputePointId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the point id.
Definition: vtkImageData.h:176
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:32
VTK_IMAGE_DATA
#define VTK_IMAGE_DATA
Definition: vtkType.h:83
vtkUniformGrid
image data with blanking
Definition: vtkUniformGrid.h:34
vtkDataSet::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkImageData::GetExtentType
int GetExtentType() override
The extent type is a 3D extent.
Definition: vtkImageData.h:528
vtkDataObject::CopyInformationFromPipeline
virtual void CopyInformationFromPipeline(vtkInformation *vtkNotUsed(info))
Copy from the pipeline information to the data object's own information.
Definition: vtkDataObject.h:146
vtkDataSet::GetData
static vtkDataSet * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkVertex
a cell that represents a 3D point
Definition: vtkVertex.h:30
vtkMatrix3x3
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:33
vtkDataSet::FindCell
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.
vtkLine
cell represents a 1D line
Definition: vtkLine.h:30
max
#define max(a, b)
Definition: vtkX3DExporterFIWriterHelper.h:31
vtkImageData::Extent
int Extent[6]
Definition: vtkImageData.h:555
VTK_3D_EXTENT
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:56
vtkImageData::PhysicalToIndexMatrix
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:553
vtkDataSet::ComputeBounds
virtual void ComputeBounds()
Compute the data bounding box from data points.
vtkStructuredData.h
VTK_SIZEHINT
#define VTK_SIZEHINT(...)
Definition: vtkWrappingHints.h:45
vtkStructuredData::GetCellPoints
static void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds, int dataDescription, int dim[3])
Get the points defining a cell.
vtkImageData::ComputeCellId
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:184
vtkDataSet::FindPoint
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:201
vtkImageData::FindPoint
virtual vtkIdType FindPoint(double x, double y, double z)
Definition: vtkImageData.h:83
vtkCell
abstract class to specify cell behavior
Definition: vtkCell.h:57
vtkStructuredData::GetPointCells
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, int dim[3])
Get the cells using a point.
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:47
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkMatrix4x4
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:35
vtkImageData::GetPoint
double * GetPoint(vtkIdType ptId) override
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
Definition: vtkImageData.h:626
vtkDataObject::PrepareForNewData
virtual void PrepareForNewData()
make the output data ready for new data to be inserted.
Definition: vtkDataObject.h:217
vtkDataSet::Initialize
void Initialize() override
Restore data object to initial state.
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:30
vtkImageData::GetPointCells
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Topological inquiry to get cells using point.
Definition: vtkImageData.h:99
vtkImageData::GetNumberOfPoints
vtkIdType GetNumberOfPoints() override
Determine the number of points composing the dataset.
Definition: vtkImageData.h:633
vtkDataObject::Crop
virtual void Crop(const int *updateExtent)
This method crops the data object (if necessary) so that the extent matches the update extent.
vtkDataObject::CopyInformationToPipeline
virtual void CopyInformationToPipeline(vtkInformation *vtkNotUsed(info))
Copy information from this data object to the pipeline information.
Definition: vtkDataObject.h:153
vtkDataSet.h
vtkX3D::spacing
Definition: vtkX3D.h:487
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
vtkInformation
Store vtkAlgorithm input/output information.
Definition: vtkInformation.h:73
vtkX3D::info
Definition: vtkX3D.h:382
vtkDataSet::GetPoint
virtual double * GetPoint(vtkIdType ptId)=0
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
vtkPixel
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:34
vtkDataSet::CopyStructure
virtual void CopyStructure(vtkDataSet *ds)=0
Copy the geometric and topological structure of an object.
vtkImageData::GetDataDescription
int GetDataDescription()
Definition: vtkImageData.h:584
vtkImageData::GetDataDimension
virtual int GetDataDimension()
Return the dimensionality of the data.
Definition: vtkImageData.h:645
vtkGenericCell
provides thread-safe access to cells
Definition: vtkGenericCell.h:36
vtkImageData::Increments
vtkIdType Increments[3]
Definition: vtkImageData.h:546
vtkImageData::DirectionMatrix
vtkMatrix3x3 * DirectionMatrix
Definition: vtkImageData.h:551
vtkX3D::extent
Definition: vtkX3D.h:351
vtkDataSet::GetNumberOfCells
virtual vtkIdType GetNumberOfCells()=0
Determine the number of cells composing the dataset.
vtkImageData::GetDataObjectType
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkImageData.h:65
vtkStructuredData::ComputeCellIdForExtent
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,...
Definition: vtkStructuredData.h:381
vtkImageData::ComputeIncrements
void ComputeIncrements()
Definition: vtkImageData.h:608
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:59
vtkDataSet::GetCellType
virtual int GetCellType(vtkIdType cellId)=0
Get type of cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkDataSet::GetCellBounds
virtual void GetCellBounds(vtkIdType cellId, double bounds[6])
Get the bounds of the cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkImageData::GetScalarTypeAsString
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:444
vtkDataSet::FindAndGetCell
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.
vtkStructuredData::ComputePointIdForExtent
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,...
Definition: vtkStructuredData.h:368
vtkDataSet::DeepCopy
void DeepCopy(vtkDataObject *src) override
vtkImageData::vtkImageData
vtkImageData()
vtkDataObject::New
static vtkDataObject * New()
vtkDataSet::GetCell
virtual vtkCell * GetCell(vtkIdType cellId)=0
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkVoxel
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:38