VTK  9.0.20200813
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 =========================================================================*/
25 #ifndef vtkImageData_h
26 #define vtkImageData_h
27 
28 #include "vtkCommonDataModelModule.h" // For export macro
29 #include "vtkDataSet.h"
30 
31 #include "vtkStructuredData.h" // Needed for inline methods
32 
33 class vtkDataArray;
34 class vtkLine;
35 class vtkMatrix3x3;
36 class vtkMatrix4x4;
37 class vtkPixel;
38 class vtkVertex;
39 class vtkVoxel;
40 
41 class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
42 {
43 public:
44  static vtkImageData* New();
45  static vtkImageData* ExtendedNew();
46 
47  vtkTypeMacro(vtkImageData, vtkDataSet);
48  void PrintSelf(ostream& os, vtkIndent indent) override;
49 
54  void CopyStructure(vtkDataSet* ds) override;
55 
59  int GetDataObjectType() override { return VTK_IMAGE_DATA; }
60 
62 
69  vtkIdType GetNumberOfCells() override;
70  vtkIdType GetNumberOfPoints() override;
71  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
72  void GetPoint(vtkIdType id, double x[3]) override;
73  vtkCell* GetCell(vtkIdType cellId) override;
74  vtkCell* GetCell(int i, int j, int k) override;
75  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
76  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
77  virtual vtkIdType FindPoint(double x, double y, double z)
78  {
79  return this->vtkDataSet::FindPoint(x, y, z);
80  }
81  vtkIdType FindPoint(double x[3]) override;
82  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
83  double pcoords[3], double* weights) override;
84  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
85  double tol2, int& subId, double pcoords[3], double* weights) override;
86  vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
87  double pcoords[3], double* weights) override;
88  int GetCellType(vtkIdType cellId) override;
89  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
90  {
91  vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, this->GetDimensions());
92  }
93  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
94  {
95  vtkStructuredData::GetPointCells(ptId, cellIds, this->GetDimensions());
96  }
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 #if VTK_ID_TYPE_IMPL != VTK_INT
132  virtual void GetDimensions(vtkIdType dims[3]);
133 #endif
134 
141  virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
142 
152  virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
153 
160  virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
161 
165  virtual int GetDataDimension();
166 
170  virtual vtkIdType ComputePointId(int ijk[3])
171  {
172  return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
173  }
174 
178  virtual vtkIdType ComputeCellId(int ijk[3])
179  {
180  return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
181  }
182 
184 
187  virtual void SetAxisUpdateExtent(
188  int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
189  virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
191 
193 
204  virtual void SetExtent(int extent[6]);
205  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
206  vtkGetVector6Macro(Extent, int);
208 
210 
214  virtual double GetScalarTypeMin(vtkInformation* meta_data);
215  virtual double GetScalarTypeMin();
216  virtual double GetScalarTypeMax(vtkInformation* meta_data);
217  virtual double GetScalarTypeMax();
219 
221 
224  virtual int GetScalarSize(vtkInformation* meta_data);
225  virtual int GetScalarSize();
227 
229 
235  virtual vtkIdType* GetIncrements() VTK_SIZEHINT(3);
236  virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
237  virtual void GetIncrements(vtkIdType inc[3]);
238  virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
239  virtual void GetIncrements(
240  vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
241  virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
243 
245 
258  virtual void GetContinuousIncrements(
259  int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
260  virtual void GetContinuousIncrements(
261  vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
263 
265 
268  virtual void* GetScalarPointerForExtent(int extent[6]);
269  virtual void* GetScalarPointer(int coordinates[3]);
270  virtual void* GetScalarPointer(int x, int y, int z);
271  virtual void* GetScalarPointer();
273 
275 
278  virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
279  virtual vtkIdType GetScalarIndex(int coordinates[3]);
280  virtual vtkIdType GetScalarIndex(int x, int y, int z);
282 
284 
287  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
288  virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
289  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
290  virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
292 
298  virtual void AllocateScalars(int dataType, int numComponents);
299 
306  virtual void AllocateScalars(vtkInformation* pipeline_info);
307 
309 
315  virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
316  virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
317  {
318  int e[6];
319  e[0] = x0;
320  e[1] = x1;
321  e[2] = y0;
322  e[3] = y1;
323  e[4] = z0;
324  e[5] = z1;
325  this->CopyAndCastFrom(inData, e);
326  }
328 
334  void Crop(const int* updateExtent) override;
335 
344  unsigned long GetActualMemorySize() override;
345 
347 
351  vtkGetVector3Macro(Spacing, double);
352  virtual void SetSpacing(double i, double j, double k);
353  virtual void SetSpacing(const double ijk[3]);
355 
357 
365  vtkGetVector3Macro(Origin, double);
366  virtual void SetOrigin(double i, double j, double k);
367  virtual void SetOrigin(const double ijk[3]);
369 
371 
375  vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
376  virtual void SetDirectionMatrix(vtkMatrix3x3* m);
377  virtual void SetDirectionMatrix(const double elements[9]);
378  virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
379  double e12, double e20, double e21, double e22);
381 
383 
387  vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
389 
391 
394  virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
395  virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
396  virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
397  virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
398  static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
399  double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
401 
403 
407  vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
409 
411 
414  virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
415  virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
417 
418  static void ComputeIndexToPhysicalMatrix(
419  double const origin[3], double const spacing[3], double const direction[9], double result[16]);
420 
422 
425  virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
427 
431  virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
432 
433  static void SetScalarType(int, vtkInformation* meta_data);
434  static int GetScalarType(vtkInformation* meta_data);
435  static bool HasScalarType(vtkInformation* meta_data);
436  int GetScalarType();
437  const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
438 
440 
444  static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
445  static int GetNumberOfScalarComponents(vtkInformation* meta_data);
446  static bool HasNumberOfScalarComponents(vtkInformation* meta_data);
447  int GetNumberOfScalarComponents();
449 
454  void CopyInformationFromPipeline(vtkInformation* information) override;
455 
461  void CopyInformationToPipeline(vtkInformation* information) override;
462 
468  void PrepareForNewData() override;
469 
471 
474  void ShallowCopy(vtkDataObject* src) override;
475  void DeepCopy(vtkDataObject* src) override;
477 
478  //--------------------------------------------------------------------------
479  // Methods that apply to any array (not just scalars).
480  // I am starting to experiment with generalizing imaging filters
481  // to operate on more than just scalars.
482 
484 
489  void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
490  void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
492 
494 
501  vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
503 
508  void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
509 
516  void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
517 
521  int GetExtentType() override { return VTK_3D_EXTENT; }
522 
524 
528  static vtkImageData* GetData(vtkInformationVector* v, int i = 0);
530 
531 protected:
532  vtkImageData();
533  ~vtkImageData() override;
534 
535  // The extent of what is currently in the structured grid.
536  // Dimensions is just an array to return a value.
537  // Its contents are out of data until GetDimensions is called.
538  int Dimensions[3];
539  vtkIdType Increments[3];
540 
541  // Variables used to define dataset physical orientation
542  double Origin[3];
543  double Spacing[3];
547 
548  int Extent[6];
549 
550  // The first method assumes Active Scalars
551  void ComputeIncrements();
552  // This one is given the number of components of the
553  // scalar field explicitly
554  void ComputeIncrements(int numberOfComponents);
555  void ComputeIncrements(vtkDataArray* scalars);
556 
557  // The first method assumes Acitive Scalars
558  void ComputeIncrements(vtkIdType inc[3]);
559  // This one is given the number of components of the
560  // scalar field explicitly
561  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
562  void ComputeIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
563 
564  // for the index to physical methods
565  void ComputeTransforms();
566 
567  // Cell utilities
568  vtkCell* GetCellTemplateForDataDescription();
569  bool GetCellTemplateForDataDescription(vtkGenericCell* cell);
570  bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
571  bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
572  void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
573 
575 
576  void SetDataDescription(int desc);
577  int GetDataDescription() { return this->DataDescription; }
578 
579 private:
580  void InternalImageDataCopy(vtkImageData* src);
581 
582 private:
583  friend class vtkUniformGrid;
584 
585  // for the GetCell method
586  vtkVertex* Vertex;
587  vtkLine* Line;
588  vtkPixel* Pixel;
589  vtkVoxel* Voxel;
590 
591  // for the GetPoint method
592  double Point[3];
593 
594  int DataDescription;
595 
596  vtkImageData(const vtkImageData&) = delete;
597  void operator=(const vtkImageData&) = delete;
598 };
599 
600 //----------------------------------------------------------------------------
602 {
603  this->ComputeIncrements(this->Increments);
604 }
605 
606 //----------------------------------------------------------------------------
607 inline void vtkImageData::ComputeIncrements(int numberOfComponents)
608 {
609  this->ComputeIncrements(numberOfComponents, this->Increments);
610 }
611 
612 //----------------------------------------------------------------------------
614 {
615  this->ComputeIncrements(scalars, this->Increments);
616 }
617 
618 //----------------------------------------------------------------------------
620 {
621  this->GetPoint(id, this->Point);
622  return this->Point;
623 }
624 
625 //----------------------------------------------------------------------------
627 {
628  const int* extent = this->Extent;
629  vtkIdType dims[3];
630  dims[0] = extent[1] - extent[0] + 1;
631  dims[1] = extent[3] - extent[2] + 1;
632  dims[2] = extent[5] - extent[4] + 1;
633 
634  return dims[0] * dims[1] * dims[2];
635 }
636 
637 //----------------------------------------------------------------------------
639 {
640  return vtkStructuredData::GetDataDimension(this->DataDescription);
641 }
642 
643 #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:89
vtkImageData::IndexToPhysicalMatrix
vtkMatrix4x4 * IndexToPhysicalMatrix
Definition: vtkImageData.h:545
vtkX3D::component
Definition: vtkX3D.h:181
vtkImageData::GetMaxCellSize
int GetMaxCellSize() override
Convenience method returns largest cell size in dataset.
Definition: vtkImageData.h:98
vtkIdType
int vtkIdType
Definition: vtkType.h:330
vtkImageData::ExtentComputeTime
vtkTimeStamp ExtentComputeTime
Definition: vtkImageData.h:574
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:170
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:521
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:29
max
#define max(a, b)
Definition: vtkX3DExporterFIWriterHelper.h:31
vtkImageData::Extent
int Extent[6]
Definition: vtkImageData.h:548
VTK_3D_EXTENT
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:56
vtkImageData::PhysicalToIndexMatrix
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:546
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:178
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:77
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:41
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:619
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:93
vtkImageData::GetNumberOfPoints
vtkIdType GetNumberOfPoints() override
Determine the number of points composing the dataset.
Definition: vtkImageData.h:626
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:577
vtkImageData::GetDataDimension
virtual int GetDataDimension()
Return the dimensionality of the data.
Definition: vtkImageData.h:638
vtkGenericCell
provides thread-safe access to cells
Definition: vtkGenericCell.h:36
vtkImageData::Increments
vtkIdType Increments[3]
Definition: vtkImageData.h:539
vtkImageData::DirectionMatrix
vtkMatrix3x3 * DirectionMatrix
Definition: vtkImageData.h:544
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:59
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:601
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:437
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