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) VTK_OVERRIDE;
52 
57  void CopyStructure(vtkDataSet *ds) VTK_OVERRIDE;
58 
62  int GetDataObjectType() VTK_OVERRIDE {return VTK_IMAGE_DATA;};
63 
65 
68  vtkIdType GetNumberOfCells() VTK_OVERRIDE;
69  vtkIdType GetNumberOfPoints() VTK_OVERRIDE;
70  double *GetPoint(vtkIdType ptId) VTK_OVERRIDE;
71  void GetPoint(vtkIdType id, double x[3]) VTK_OVERRIDE;
72  vtkCell *GetCell(vtkIdType cellId) VTK_OVERRIDE;
73  void GetCell(vtkIdType cellId, vtkGenericCell *cell) VTK_OVERRIDE;
74  void GetCellBounds(vtkIdType cellId, double bounds[6]) VTK_OVERRIDE;
75  virtual vtkIdType FindPoint(double x, double y, double z)
76  {
77  return this->vtkDataSet::FindPoint(x, y, z);
78  }
79  vtkIdType FindPoint(double x[3]) VTK_OVERRIDE;
81  double x[3], vtkCell *cell, vtkIdType cellId, double tol2,
82  int& subId, double pcoords[3], double *weights) VTK_OVERRIDE;
84  double x[3], vtkCell *cell, vtkGenericCell *gencell,
85  vtkIdType cellId, double tol2, int& subId,
86  double pcoords[3], double *weights) VTK_OVERRIDE;
87  vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId,
88  double tol2, int& subId, double pcoords[3],
89  double *weights) VTK_OVERRIDE;
90  int GetCellType(vtkIdType cellId) VTK_OVERRIDE;
91  void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) VTK_OVERRIDE
92  {vtkStructuredData::GetCellPoints(cellId,ptIds,this->DataDescription,
93  this->GetDimensions());}
94  void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) VTK_OVERRIDE
95  {vtkStructuredData::GetPointCells(ptId,cellIds,this->GetDimensions());}
96  void ComputeBounds() VTK_OVERRIDE;
97  int GetMaxCellSize() VTK_OVERRIDE {return 8;}; //voxel is the largest
99 
103  void Initialize() VTK_OVERRIDE;
104 
108  virtual void SetDimensions(int i, int j, int k);
109 
113  virtual void SetDimensions(const int dims[3]);
114 
121  virtual int *GetDimensions();
122 
129  virtual void GetDimensions(int dims[3]);
130 
137  virtual int ComputeStructuredCoordinates(
138  const double x[3], int ijk[3], double pcoords[3]);
139 
140  static int ComputeStructuredCoordinates( const double x[3], int ijk[3], double pcoords[3],
141  const int* extent,
142  const double* spacing,
143  const double* origin,
144  const double* bounds);
154  virtual void GetVoxelGradient(
155  int i,int j,int k, vtkDataArray *s, vtkDataArray *g);
156 
163  virtual void GetPointGradient(
164  int i, int j, int k, vtkDataArray *s, double g[3]);
165 
169  virtual int GetDataDimension();
170 
174  virtual vtkIdType ComputePointId(int ijk[3]) {
175  return vtkStructuredData::ComputePointIdForExtent(this->Extent,ijk);};
176 
180  virtual vtkIdType ComputeCellId(int ijk[3]) {
181  return vtkStructuredData::ComputeCellIdForExtent(this->Extent,ijk);};
182 
184 
187  virtual void SetAxisUpdateExtent(int axis, int min, int max,
188  const int* updateExtent,
189  int* axisUpdateExtent);
190  virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int* updateExtent);
192 
194 
205  virtual void SetExtent(int extent[6]);
206  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
207  vtkGetVector6Macro(Extent, int);
209 
211 
215  virtual double GetScalarTypeMin(vtkInformation* meta_data);
216  virtual double GetScalarTypeMin();
217  virtual double GetScalarTypeMax(vtkInformation* meta_data);
218  virtual double GetScalarTypeMax();
220 
222 
225  virtual int GetScalarSize(vtkInformation* meta_data);
226  virtual int GetScalarSize();
228 
230 
237  virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
238  virtual void GetIncrements(vtkIdType inc[3]);
240  virtual void GetIncrements(vtkDataArray *scalars,
241  vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
242  virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
244 
246 
260  int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
261  virtual void GetContinuousIncrements(vtkDataArray *scalars,
262  int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ);
264 
266 
269  virtual void *GetScalarPointerForExtent(int extent[6]);
270  virtual void *GetScalarPointer(int coordinates[3]);
271  virtual void *GetScalarPointer(int x, int y, int z);
272  virtual void *GetScalarPointer();
274 
276 
279  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
281  int x, int y, int z, int component, float v);
282  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
284  int x, int y, int z, int component, double v);
286 
292  virtual void AllocateScalars(int dataType, int numComponents);
293 
300  virtual void AllocateScalars(vtkInformation* pipeline_info);
301 
303 
309  virtual void CopyAndCastFrom(vtkImageData *inData, int extent[6]);
310  virtual void CopyAndCastFrom(vtkImageData *inData, int x0, int x1,
311  int y0, int y1, int z0, int z1)
312  {int e[6]; e[0]=x0; e[1]=x1; e[2]=y0; e[3]=y1; e[4]=z0; e[5]=z1;
313  this->CopyAndCastFrom(inData, e);}
315 
321  void Crop(const int* updateExtent) VTK_OVERRIDE;
322 
331  unsigned long GetActualMemorySize() VTK_OVERRIDE;
332 
334 
338  vtkSetVector3Macro(Spacing,double);
339  vtkGetVector3Macro(Spacing,double);
341 
343 
351  vtkSetVector3Macro(Origin,double);
352  vtkGetVector3Macro(Origin,double);
354 
355  static void SetScalarType(int, vtkInformation* meta_data);
356  static int GetScalarType(vtkInformation* meta_data);
357  static bool HasScalarType(vtkInformation* meta_data);
358  int GetScalarType();
359  const char* GetScalarTypeAsString()
360  { return vtkImageScalarTypeNameMacro ( this->GetScalarType() ); };
361 
363 
367  static void SetNumberOfScalarComponents( int n, vtkInformation* meta_data);
372 
377  void CopyInformationFromPipeline(vtkInformation* information) VTK_OVERRIDE;
378 
384  void CopyInformationToPipeline(vtkInformation* information) VTK_OVERRIDE;
385 
391  void PrepareForNewData() VTK_OVERRIDE;
392 
394 
397  void ShallowCopy(vtkDataObject *src) VTK_OVERRIDE;
398  void DeepCopy(vtkDataObject *src) VTK_OVERRIDE;
400 
401  //--------------------------------------------------------------------------
402  // Methods that apply to any array (not just scalars).
403  // I am starting to experiment with generalizing imaging fitlers
404  // to operate on more than just scalars.
405 
407 
412  void *GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
413  void *GetArrayPointer(vtkDataArray* array, int coordinates[3]);
415 
420  void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3]);
421 
428  void ComputeInternalExtent(int *intExt, int *tgtExt, int *bnds);
429 
433  int GetExtentType() VTK_OVERRIDE { return VTK_3D_EXTENT; };
434 
436 
442 
443 protected:
445  ~vtkImageData() VTK_OVERRIDE;
446 
447  // The extent of what is currently in the structured grid.
448  // Dimensions is just an array to return a value.
449  // Its contents are out of data until GetDimensions is called.
450  int Dimensions[3];
451  vtkIdType Increments[3];
452 
453  double Origin[3];
454  double Spacing[3];
455 
456  int Extent[6];
457 
458  // The first method assumes Active Scalars
459  void ComputeIncrements();
460  // This one is given the number of components of the
461  // scalar field explicitly
462  void ComputeIncrements(int numberOfComponents);
463  void ComputeIncrements(vtkDataArray *scalars);
464 
465  // The first method assumes Acitive Scalars
466  void ComputeIncrements(vtkIdType inc[3]);
467  // This one is given the number of components of the
468  // scalar field explicitly
469  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
470  void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3]);
471  void CopyOriginAndSpacingFromPipeline(vtkInformation* info);
472 
473  vtkTimeStamp ExtentComputeTime;
474 
475  void SetDataDescription(int desc);
476  int GetDataDescription() { return this->DataDescription; }
477 
478 private:
479  void InternalImageDataCopy(vtkImageData *src);
480 private:
481 
482  friend class vtkUniformGrid;
483 
484  // for the GetCell method
485  vtkVertex *Vertex;
486  vtkLine *Line;
487  vtkPixel *Pixel;
488  vtkVoxel *Voxel;
489 
490  // for the GetPoint method
491  double Point[3];
492 
493  int DataDescription;
494 
495  vtkImageData(const vtkImageData&) VTK_DELETE_FUNCTION;
496  void operator=(const vtkImageData&) VTK_DELETE_FUNCTION;
497 };
498 
499 
500 //----------------------------------------------------------------------------
502 {
503  this->ComputeIncrements(this->Increments);
504 }
505 
506 //----------------------------------------------------------------------------
507 inline void vtkImageData::ComputeIncrements(int numberOfComponents)
508 {
509  this->ComputeIncrements(numberOfComponents, this->Increments);
510 }
511 
512 //----------------------------------------------------------------------------
514 {
515  this->ComputeIncrements(scalars, this->Increments);
516 }
517 
518 //----------------------------------------------------------------------------
520 {
521  this->GetPoint(id, this->Point);
522  return this->Point;
523 }
524 
525 //----------------------------------------------------------------------------
527 {
528  const int *extent = this->Extent;
529  vtkIdType dims[3];
530  dims[0] = extent[1] - extent[0] + 1;
531  dims[1] = extent[3] - extent[2] + 1;
532  dims[2] = extent[5] - extent[4] + 1;
533 
534  return dims[0]*dims[1]*dims[2];
535 }
536 
537 //----------------------------------------------------------------------------
539 {
540  return vtkStructuredData::GetDataDimension(this->DataDescription);
541 }
542 
543 #endif
vtkpiston::DeepCopy
void DeepCopy(vtkPistonReference *self, vtkPistonReference *other)
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:91
vtkImageData::HasNumberOfScalarComponents
static bool HasNumberOfScalarComponents(vtkInformation *meta_data)
vtkImageData::GetScalarPointerForExtent
virtual void * GetScalarPointerForExtent(int extent[6])
Access the native pointer for the scalar data.
vtkX3D::component
@ component
Definition: vtkX3D.h:175
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:287
vtkImageData::GetActualMemorySize
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
vtkImageData::GetScalarPointer
virtual void * GetScalarPointer()
vtkInformationVector
Store zero or more vtkInformation instances.
Definition: vtkInformationVector.h:42
vtkImageData::SetScalarComponentFromFloat
virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v)
vtkTimeStamp
record modification and/or execution time
Definition: vtkTimeStamp.h:36
VTK_IMAGE_DATA
#define VTK_IMAGE_DATA
Definition: vtkType.h:93
vtkImageData::GetScalarSize
virtual int GetScalarSize()
vtkUniformGrid
image data with blanking
Definition: vtkUniformGrid.h:41
vtkImageData::GetScalarComponentAsDouble
virtual double GetScalarComponentAsDouble(int x, int y, int z, int component)
vtkImageData::PrepareForNewData
void PrepareForNewData() override
make the output data ready for new data to be inserted.
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.
vtkImageData::GetIncrements
virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
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::CopyAndCastFrom
virtual void CopyAndCastFrom(vtkImageData *inData, int x0, int x1, int y0, int y1, int z0, int z1)
Definition: vtkImageData.h:310
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
GetPoint
void GetPoint(const int i, const int j, const int k, double pnt[3])
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::CopyAndCastFrom
virtual void CopyAndCastFrom(vtkImageData *inData, int extent[6])
This method is passed a input and output region, and executes the filter algorithm to fill the output...
max
#define max(a, b)
Definition: vtkX3DExporterFIWriterHelper.h:31
vtkImageData::Extent
int Extent[6]
Definition: vtkImageData.h:456
VTK_3D_EXTENT
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:61
vtkImageData::SetScalarComponentFromDouble
virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v)
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::GetIncrements
virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3])
vtkStructuredData.h
vtkImageData::GetNumberOfScalarComponents
int GetNumberOfScalarComponents()
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:180
vtkDataSet::FindPoint
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:192
vtkCell
abstract class to specify cell behavior
Definition: vtkCell.h:60
vtkImageData::~vtkImageData
~vtkImageData() override
vtkImageData::GetContinuousIncrements
virtual void GetContinuousIncrements(int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
Different ways to get the increments for moving around the data.
vtkImageData::GetScalarComponentAsFloat
virtual float GetScalarComponentAsFloat(int x, int y, int z, int component)
For access to data from tcl.
vtkStructuredData::GetPointCells
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, int dim[3])
Get the cells using a point.
vtkImageData::GetIncrements
virtual void GetIncrements(vtkDataArray *scalars, vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
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:397
vtkImageData::GetPoint
double * GetPoint(vtkIdType ptId) override
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
Definition: vtkImageData.h:519
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:94
vtkImageData::GetNumberOfPoints
vtkIdType GetNumberOfPoints() override
Determine the number of points composing the dataset.
Definition: vtkImageData.h:526
vtkImageData::SetNumberOfScalarComponents
static void SetNumberOfScalarComponents(int n, vtkInformation *meta_data)
Set/Get the number of scalar components for points.
vtkImageData::AllocateScalars
virtual void AllocateScalars(int dataType, int numComponents)
Allocate the point scalars for this dataset.
vtkImageData::Initialize
void Initialize() override
Restore data object to initial state.
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::FindPoint
vtkIdType FindPoint(double x[3]) override
vtkX3D::info
@ info
Definition: vtkX3D.h:376
vtkPixel
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:41
vtkImageData::GetIncrements
virtual void GetIncrements(vtkIdType inc[3])
vtkImageData::CopyInformationToPipeline
void CopyInformationToPipeline(vtkInformation *information) override
Copy information from this data object to the pipeline information.
vtkImageData::GetDataDimension
virtual int GetDataDimension()
Return the dimensionality of the data.
Definition: vtkImageData.h:538
vtkGenericCell
provides thread-safe access to cells
Definition: vtkGenericCell.h:40
vtkImageData::Increments
vtkIdType Increments[3]
Definition: vtkImageData.h:451
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:384
vtkX3D::extent
@ extent
Definition: vtkX3D.h:345
vtkImageData::GetDataObjectType
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkImageData.h:62
vtkImageData::AllocateScalars
virtual void AllocateScalars(vtkInformation *pipeline_info)
Allocate the point scalars for this dataset.
vtkImageData::ComputeIncrements
void ComputeIncrements()
Definition: vtkImageData.h:501
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)
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:65
vtkImageData::GetNumberOfCells
vtkIdType GetNumberOfCells() override
Standard vtkDataSet API methods.
vtkImageData::GetScalarPointer
virtual void * GetScalarPointer(int coordinates[3])
vtkImageData::New
static vtkImageData * New()
vtkImageData::GetContinuousIncrements
virtual void GetContinuousIncrements(vtkDataArray *scalars, int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
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::GetScalarPointer
virtual void * GetScalarPointer(int x, int y, int z)
vtkImageData::GetIncrements
virtual vtkIdType * GetIncrements(vtkDataArray *scalars)
vtkVoxel
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:45