VTK  9.2.5
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 =========================================================================*/
146 #ifndef vtkImageData_h
147 #define vtkImageData_h
148 
149 #include "vtkCommonDataModelModule.h" // For export macro
150 #include "vtkDataSet.h"
151 
152 #include "vtkStructuredData.h" // Needed for inline methods
153 
154 class vtkDataArray;
155 class vtkLine;
156 class vtkMatrix3x3;
157 class vtkMatrix4x4;
158 class vtkPixel;
159 class vtkVertex;
160 class vtkVoxel;
161 
162 class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
163 {
164 public:
165  static vtkImageData* New();
167 
168  vtkTypeMacro(vtkImageData, vtkDataSet);
169  void PrintSelf(ostream& os, vtkIndent indent) override;
170 
175  void CopyStructure(vtkDataSet* ds) override;
176 
180  int GetDataObjectType() override { return VTK_IMAGE_DATA; }
181 
183 
191  vtkIdType GetNumberOfPoints() override;
192  double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
193  void GetPoint(vtkIdType id, double x[3]) override;
194  vtkCell* GetCell(vtkIdType cellId) override;
195  vtkCell* GetCell(int i, int j, int k) override;
196  void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
197  void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
198  virtual vtkIdType FindPoint(double x, double y, double z)
199  {
200  return this->vtkDataSet::FindPoint(x, y, z);
201  }
202  vtkIdType FindPoint(double x[3]) override;
203  vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
204  double pcoords[3], double* weights) override;
205  vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
206  double tol2, int& subId, double pcoords[3], double* weights) override;
207  vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
208  double pcoords[3], double* weights) override;
209  int GetCellType(vtkIdType cellId) override;
210  vtkIdType GetCellSize(vtkIdType cellId) override;
212  void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
213  {
214  int dimensions[3];
215  this->GetDimensions(dimensions);
216  vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
217  }
218  void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
219  {
220  int dimensions[3];
221  this->GetDimensions(dimensions);
222  vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
223  }
224  void ComputeBounds() override;
225  int GetMaxCellSize() override { return 8; } // voxel is the largest
226  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
228 
236  void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
237 
241  void Initialize() override;
242 
248  unsigned char IsPointVisible(vtkIdType ptId);
249 
255  unsigned char IsCellVisible(vtkIdType cellId);
256 
261  bool HasAnyBlankPoints() override;
266  bool HasAnyBlankCells() override;
267 
274  void GetCellDims(int cellDims[3]);
275 
279  virtual void SetDimensions(int i, int j, int k);
280 
284  virtual void SetDimensions(const int dims[3]);
285 
292  virtual int* GetDimensions() VTK_SIZEHINT(3);
293 
300  virtual void GetDimensions(int dims[3]);
301 #if VTK_ID_TYPE_IMPL != VTK_INT
302  virtual void GetDimensions(vtkIdType dims[3]);
303 #endif
304 
311  virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
312 
322  virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
323 
330  virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
331 
335  virtual int GetDataDimension();
336 
340  virtual vtkIdType ComputePointId(int ijk[3])
341  {
342  return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
343  }
344 
348  virtual vtkIdType ComputeCellId(int ijk[3])
349  {
350  return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
351  }
352 
354 
357  virtual void SetAxisUpdateExtent(
358  int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
359  virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
361 
363 
374  virtual void SetExtent(int extent[6]);
375  virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
376  vtkGetVector6Macro(Extent, int);
378 
380 
384  virtual double GetScalarTypeMin(vtkInformation* meta_data);
385  virtual double GetScalarTypeMin();
386  virtual double GetScalarTypeMax(vtkInformation* meta_data);
387  virtual double GetScalarTypeMax();
389 
391 
394  virtual int GetScalarSize(vtkInformation* meta_data);
395  virtual int GetScalarSize();
397 
399 
411  virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
412  virtual void GetIncrements(vtkIdType inc[3]);
413  virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
414  virtual void GetIncrements(
415  vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
416  virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
418 
420 
433  virtual void GetContinuousIncrements(
434  int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
435  virtual void GetContinuousIncrements(
436  vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
438 
440 
443  virtual void* GetScalarPointerForExtent(int extent[6]);
444  virtual void* GetScalarPointer(int coordinates[3]);
445  virtual void* GetScalarPointer(int x, int y, int z);
446  virtual void* GetScalarPointer();
448 
450 
453  virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
454  virtual vtkIdType GetScalarIndex(int coordinates[3]);
455  virtual vtkIdType GetScalarIndex(int x, int y, int z);
457 
459 
462  virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
463  virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
464  virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
465  virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
467 
473  virtual void AllocateScalars(int dataType, int numComponents);
474 
481  virtual void AllocateScalars(vtkInformation* pipeline_info);
482 
484 
490  virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
491  virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
492  {
493  int e[6];
494  e[0] = x0;
495  e[1] = x1;
496  e[2] = y0;
497  e[3] = y1;
498  e[4] = z0;
499  e[5] = z1;
500  this->CopyAndCastFrom(inData, e);
501  }
503 
509  void Crop(const int* updateExtent) override;
510 
519  unsigned long GetActualMemorySize() override;
520 
522 
526  vtkGetVector3Macro(Spacing, double);
527  virtual void SetSpacing(double i, double j, double k);
528  virtual void SetSpacing(const double ijk[3]);
530 
532 
540  vtkGetVector3Macro(Origin, double);
541  virtual void SetOrigin(double i, double j, double k);
542  virtual void SetOrigin(const double ijk[3]);
544 
546 
550  vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
552  virtual void SetDirectionMatrix(const double elements[9]);
553  virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
554  double e12, double e20, double e21, double e22);
556 
558 
562  vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
564 
566 
569  virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
570  virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
571  virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
572  virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
573  static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
574  double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
576 
578 
582  vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
584 
586 
589  virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
590  virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
592 
594  double const origin[3], double const spacing[3], double const direction[9], double result[16]);
595 
597 
600  virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
602 
607  virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
608 
609  static void SetScalarType(int, vtkInformation* meta_data);
610  static int GetScalarType(vtkInformation* meta_data);
611  static bool HasScalarType(vtkInformation* meta_data);
613  const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
614 
616 
620  static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
625 
630  void CopyInformationFromPipeline(vtkInformation* information) override;
631 
637  void CopyInformationToPipeline(vtkInformation* information) override;
638 
644  void PrepareForNewData() override;
645 
647 
650  void ShallowCopy(vtkDataObject* src) override;
651  void DeepCopy(vtkDataObject* src) override;
653 
654  //--------------------------------------------------------------------------
655  // Methods that apply to any array (not just scalars).
656  // I am starting to experiment with generalizing imaging filters
657  // to operate on more than just scalars.
658 
660 
666  void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
668 
670 
677  vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
679 
684  void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
685 
692  void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
693 
697  int GetExtentType() override { return VTK_3D_EXTENT; }
698 
700 
704  static vtkImageData* GetData(vtkInformationVector* v, int i = 0);
706 
707 protected:
709  ~vtkImageData() override;
710 
711  // The extent of what is currently in the structured grid.
712  // Dimensions is just an array to return a value.
713  // Its contents are out of data until GetDimensions is called.
714  int Dimensions[3];
715  vtkIdType Increments[3];
716 
717  // Variables used to define dataset physical orientation
718  double Origin[3];
719  double Spacing[3];
723 
724  int Extent[6];
725 
726  // The first method assumes Active Scalars
727  void ComputeIncrements();
728  // This one is given the number of components of the
729  // scalar field explicitly
730  void ComputeIncrements(int numberOfComponents);
731  void ComputeIncrements(vtkDataArray* scalars);
732 
733  // The first method assumes Acitive Scalars
735  // This one is given the number of components of the
736  // scalar field explicitly
737  void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
738  void ComputeIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
739 
740  // for the index to physical methods
742 
743  // Cell utilities
746  bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
747  bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
748  void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
749 
751 
752  void SetDataDescription(int desc);
753  int GetDataDescription() { return this->DataDescription; }
754 
755 private:
756  void InternalImageDataCopy(vtkImageData* src);
757 
758 private:
759  friend class vtkUniformGrid;
760 
761  // for the GetCell method
762  vtkVertex* Vertex;
763  vtkLine* Line;
764  vtkPixel* Pixel;
765  vtkVoxel* Voxel;
766 
767  // for the GetPoint method
768  double Point[3];
769 
770  int DataDescription;
771 
772  vtkImageData(const vtkImageData&) = delete;
773  void operator=(const vtkImageData&) = delete;
774 };
775 
776 //----------------------------------------------------------------------------
778 {
779  this->ComputeIncrements(this->Increments);
780 }
781 
782 //----------------------------------------------------------------------------
783 inline void vtkImageData::ComputeIncrements(int numberOfComponents)
784 {
785  this->ComputeIncrements(numberOfComponents, this->Increments);
786 }
787 
788 //----------------------------------------------------------------------------
790 {
791  this->ComputeIncrements(scalars, this->Increments);
792 }
793 
794 //----------------------------------------------------------------------------
796 {
797  this->GetPoint(id, this->Point);
798  return this->Point;
799 }
800 
801 //----------------------------------------------------------------------------
803 {
804  const int* extent = this->Extent;
805  vtkIdType dims[3];
806  dims[0] = extent[1] - extent[0] + 1;
807  dims[1] = extent[3] - extent[2] + 1;
808  dims[2] = extent[5] - extent[4] + 1;
809 
810  return dims[0] * dims[1] * dims[2];
811 }
812 
813 //----------------------------------------------------------------------------
815 {
816  return vtkStructuredData::GetDataDimension(this->DataDescription);
817 }
818 
819 #endif
abstract class to specify cell behavior
Definition: vtkCell.h:150
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:165
general representation of visualization data
abstract class to specify dataset behavior
Definition: vtkDataSet.h:172
virtual vtkIdType GetNumberOfPoints()=0
Determine the number of points composing the dataset.
virtual void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)=0
Topological inquiry to get points defining cell.
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:341
virtual double * GetPoint(vtkIdType ptId)=0
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:143
topologically and geometrically regular array of data
Definition: vtkImageData.h:163
void Crop(const int *updateExtent) override
Reallocates and copies to set the Extent to updateExtent.
virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3])
Convert coordinates from physical space (xyz) to index space (ijk).
bool GetCellTemplateForDataDescription(vtkGenericCell *cell)
virtual int GetDataDimension()
Return the dimensionality of the data.
Definition: vtkImageData.h:814
vtkIdType FindCell(double x[3], vtkCell *cell, vtkGenericCell *gencell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Standard vtkDataSet API methods.
void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3])
Since various arrays have different number of components, the will have different increments.
virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3])
Convert coordinates from index space (ijk) to physical space (xyz).
void CopyInformationToPipeline(vtkInformation *information) override
Copy information from this data object to the pipeline information.
vtkCell * GetCellTemplateForDataDescription()
bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3])
vtkIdType GetCellSize(vtkIdType cellId) override
Standard vtkDataSet API methods.
vtkCell * FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Standard vtkDataSet API methods.
virtual vtkIdType * GetIncrements()
Different ways to get the increments for moving around the data.
bool HasAnyBlankCells() override
Returns 1 if there is any visibility constraint on the cells, 0 otherwise.
virtual vtkIdType ComputePointId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the point id.
Definition: vtkImageData.h:340
void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds) override
Standard vtkDataSet API methods.
virtual void SetDirectionMatrix(vtkMatrix3x3 *m)
Set/Get the direction transform of the dataset.
vtkMatrix4x4 * IndexToPhysicalMatrix
Definition: vtkImageData.h:721
static vtkImageData * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
void ComputeInternalExtent(int *intExt, int *tgtExt, int *bnds)
Given how many pixel are required on a side for boundary conditions (in bnds), the target extent to t...
virtual void SetDimensions(int i, int j, int k)
Same as SetExtent(0, i-1, 0, j-1, 0, k-1)
virtual double GetScalarTypeMin()
These returns the minimum and maximum values the ScalarType can hold without overflowing.
virtual void SetDirectionMatrix(const double elements[9])
Set/Get the direction transform of the dataset.
void ComputeIncrements()
Definition: vtkImageData.h:777
virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3])
Convert coordinates from index space (ijk) to physical space (xyz).
static int GetScalarType(vtkInformation *meta_data)
void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds, int *seedLoc)
Get cell neighbors around cell located at seedloc, except cell of id cellId.
vtkCell * GetCell(vtkIdType cellId) override
Standard vtkDataSet API methods.
void AddPointsToCellTemplate(vtkCell *cell, int ijkMin[3], int ijkMax[3])
void ComputeBounds() override
Standard vtkDataSet API methods.
double * GetPoint(vtkIdType ptId) override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:795
static vtkImageData * New()
bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3])
virtual double GetScalarTypeMin(vtkInformation *meta_data)
These returns the minimum and maximum values the ScalarType can hold without overflowing.
static vtkImageData * ExtendedNew()
void GetCellBounds(vtkIdType cellId, double bounds[6]) override
Standard vtkDataSet API methods.
virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3])
Convert normal from physical space (xyz) to index space (ijk).
void SetDataDescription(int desc)
void GetPoint(vtkIdType id, double x[3]) override
Standard vtkDataSet API methods.
void GetCellDims(int cellDims[3])
Given the node dimensions of this grid instance, this method computes the node dimensions.
vtkTimeStamp ExtentComputeTime
Definition: vtkImageData.h:750
int GetDataDescription()
Definition: vtkImageData.h:753
virtual int GetScalarSize(vtkInformation *meta_data)
Get the size of the scalar type in bytes.
virtual void SetExtent(int extent[6])
Set/Get the extent.
virtual int * GetDimensions()
Get dimensions of this structured points dataset.
static int GetNumberOfScalarComponents(vtkInformation *meta_data)
Set/Get the number of scalar components for points.
virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4])
Convert a plane from physical to a continuous index.
void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:212
virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray *s, vtkDataArray *g)
Given structured coordinates (i,j,k) for a voxel cell, compute the eight gradient values for the voxe...
virtual double GetScalarTypeMax(vtkInformation *meta_data)
These returns the minimum and maximum values the ScalarType can hold without overflowing.
vtkIdType GetTupleIndex(vtkDataArray *array, int coordinates[3])
Given a data array and a coordinate, return the index of the tuple in the array corresponding to that...
void ComputeIncrements(int numberOfComponents, vtkIdType inc[3])
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:613
int GetNumberOfScalarComponents()
Set/Get the number of scalar components for points.
vtkIdType GetNumberOfPoints() override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:802
vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Standard vtkDataSet API methods.
vtkCell * GetCell(int i, int j, int k) override
Standard vtkDataSet API methods.
void ComputeIncrements(vtkDataArray *scalars, vtkIdType inc[3])
virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int *updateExtent)
Set / Get the extent on just one axis.
int GetExtentType() override
The extent type is a 3D extent.
Definition: vtkImageData.h:697
virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3])
Convenience function computes the structured coordinates for a point x[3].
virtual void SetSpacing(double i, double j, double k)
Set the spacing (width,height,length) of the cubical cells that compose the data set.
static void SetNumberOfScalarComponents(int n, vtkInformation *meta_data)
Set/Get the number of scalar components for points.
virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22)
Set/Get the direction transform of the dataset.
vtkIdType Increments[3]
Definition: vtkImageData.h:715
int GetCellType(vtkIdType cellId) override
Standard vtkDataSet API methods.
virtual void SetSpacing(const double ijk[3])
Set the spacing (width,height,length) of the cubical cells that compose the data set.
static void SetScalarType(int, vtkInformation *meta_data)
vtkIdType GetNumberOfCells() override
Standard vtkDataSet API methods.
virtual void SetOrigin(const double ijk[3])
Set/Get the origin of the dataset.
void DeepCopy(vtkDataObject *src) override
Shallow and Deep copy.
virtual int GetScalarSize()
Get the size of the scalar type in bytes.
int GetScalarType()
virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3])
Convert coordinates from physical space (xyz) to index space (ijk).
int GetDataObjectType() override
Return what type of dataset this is.
Definition: vtkImageData.h:180
void CopyInformationFromPipeline(vtkInformation *information) override
Override these to handle origin, spacing, scalar type, and scalar number of components.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double const origin[3], double const spacing[3], double const direction[9], double xyz[3])
Convert coordinates from index space (ijk) to physical space (xyz).
void ComputeIncrements(vtkIdType inc[3])
void ComputeTransforms()
vtkMatrix3x3 * DirectionMatrix
Definition: vtkImageData.h:720
vtkIdType FindPoint(double x[3]) override
Standard vtkDataSet API methods.
unsigned long GetActualMemorySize() override
Return the actual size of the data in kibibytes (1024 bytes).
void GetCell(vtkIdType cellId, vtkGenericCell *cell) override
Standard vtkDataSet API methods.
void Initialize() override
Restore data object to initial state.
static vtkImageData * GetData(vtkInformationVector *v, int i=0)
Retrieve an instance of this class from an information object.
static void ComputeIndexToPhysicalMatrix(double const origin[3], double const spacing[3], double const direction[9], double result[16])
virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3])
Convert coordinates from index space (ijk) to physical space (xyz).
virtual void SetOrigin(double i, double j, double k)
Set/Get the origin of the dataset.
virtual double GetScalarTypeMax()
These returns the minimum and maximum values the ScalarType can hold without overflowing.
virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3])
Convert coordinates from index space (ijk) to physical space (xyz).
int GetMaxCellSize() override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:225
unsigned char IsPointVisible(vtkIdType ptId)
Return non-zero value if specified point is visible.
void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:218
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
virtual void SetAxisUpdateExtent(int axis, int min, int max, const int *updateExtent, int *axisUpdateExtent)
Set / Get the extent on just one axis.
static bool HasNumberOfScalarComponents(vtkInformation *meta_data)
Set/Get the number of scalar components for points.
static bool HasScalarType(vtkInformation *meta_data)
void * GetArrayPointerForExtent(vtkDataArray *array, int extent[6])
These are convenience methods for getting a pointer from any filed array.
virtual void GetPointGradient(int i, int j, int k, vtkDataArray *s, double g[3])
Given structured coordinates (i,j,k) for a point in a structured point dataset, compute the gradient ...
~vtkImageData() override
unsigned char IsCellVisible(vtkIdType cellId)
Return non-zero value if specified point is visible.
void PrepareForNewData() override
make the output data ready for new data to be inserted.
virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2)
Set/Get the extent.
void CopyStructure(vtkDataSet *ds) override
Copy the geometric and topological structure of an input image data object.
bool HasAnyBlankPoints() override
Returns 1 if there is any visibility constraint on the points, 0 otherwise.
virtual void SetDimensions(const int dims[3])
Same as SetExtent(0, dims[0]-1, 0, dims[1]-1, 0, dims[2]-1)
virtual vtkIdType FindPoint(double x, double y, double z)
Standard vtkDataSet API methods.
Definition: vtkImageData.h:198
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:722
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:348
void * GetArrayPointer(vtkDataArray *array, int coordinates[3])
These are convenience methods for getting a pointer from any filed array.
a simple class to control print indentation
Definition: vtkIndent.h:119
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition: vtkLine.h:143
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:66
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:151
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:77
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,...
static void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds, int dataDescription, int dim[3])
Get the points defining a cell.
static int GetDataDimension(int dataDescription)
Return the topological dimension of the data (e.g., 0, 1, 2, or 3D).
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,...
static void GetPointCells(vtkIdType ptId, vtkIdList *cellIds, int dim[3])
Get the cells using a point.
record modification and/or execution time
Definition: vtkTimeStamp.h:55
image data with blanking
a cell that represents a 3D point
Definition: vtkVertex.h:103
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:91
@ component
Definition: vtkX3D.h:181
@ info
Definition: vtkX3D.h:382
@ direction
Definition: vtkX3D.h:266
@ extent
Definition: vtkX3D.h:351
@ spacing
Definition: vtkX3D.h:487
#define VTK_3D_EXTENT
int vtkIdType
Definition: vtkType.h:332
#define VTK_IMAGE_DATA
Definition: vtkType.h:83
#define VTK_SIZEHINT(...)
#define max(a, b)