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=========================================================================*/
37#ifndef vtkImageData_h
38#define vtkImageData_h
39
40#include "vtkCommonDataModelModule.h" // For export macro
41#include "vtkDataSet.h"
42
43#include "vtkStructuredData.h" // Needed for inline methods
44
45class vtkDataArray;
46class vtkLine;
47class vtkMatrix3x3;
48class vtkMatrix4x4;
49class vtkPixel;
50class vtkVertex;
51class vtkVoxel;
52
53class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
54{
55public:
56 static vtkImageData* New();
58
59 vtkTypeMacro(vtkImageData, vtkDataSet);
60 void PrintSelf(ostream& os, vtkIndent indent) override;
61
66 void CopyStructure(vtkDataSet* ds) override;
67
71 int GetDataObjectType() override { return VTK_IMAGE_DATA; }
72
74
83 double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
84 void GetPoint(vtkIdType id, double x[3]) override;
85 vtkCell* GetCell(vtkIdType cellId) override;
86 vtkCell* GetCell(int i, int j, int k) override;
87 void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
88 void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
89 virtual vtkIdType FindPoint(double x, double y, double z)
90 {
91 return this->vtkDataSet::FindPoint(x, y, z);
92 }
93 vtkIdType FindPoint(double x[3]) override;
94 vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
95 double pcoords[3], double* weights) override;
96 vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
97 double tol2, int& subId, double pcoords[3], double* weights) override;
98 vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
99 double pcoords[3], double* weights) override;
100 int GetCellType(vtkIdType cellId) override;
103 void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
104 {
105 int dimensions[3];
106 this->GetDimensions(dimensions);
107 vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
108 }
109 void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
110 {
111 int dimensions[3];
112 this->GetDimensions(dimensions);
113 vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
114 }
115 void ComputeBounds() override;
116 int GetMaxCellSize() override { return 8; } // voxel is the largest
117 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
119
127 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
128
132 void Initialize() override;
133
139 unsigned char IsPointVisible(vtkIdType ptId);
140
146 unsigned char IsCellVisible(vtkIdType cellId);
147
152 bool HasAnyBlankPoints() override;
157 bool HasAnyBlankCells() override;
158
165 void GetCellDims(int cellDims[3]);
166
170 virtual void SetDimensions(int i, int j, int k);
171
175 virtual void SetDimensions(const int dims[3]);
176
183 virtual int* GetDimensions() VTK_SIZEHINT(3);
184
191 virtual void GetDimensions(int dims[3]);
192#if VTK_ID_TYPE_IMPL != VTK_INT
193 virtual void GetDimensions(vtkIdType dims[3]);
194#endif
195
202 virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
203
213 virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
214
221 virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
222
226 virtual int GetDataDimension();
227
231 virtual vtkIdType ComputePointId(int ijk[3])
232 {
233 return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
234 }
235
239 virtual vtkIdType ComputeCellId(int ijk[3])
240 {
241 return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
242 }
243
245
249 int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
250 virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
252
254
265 virtual void SetExtent(int extent[6]);
266 virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
267 vtkGetVector6Macro(Extent, int);
269
271
275 virtual double GetScalarTypeMin(vtkInformation* meta_data);
276 virtual double GetScalarTypeMin();
277 virtual double GetScalarTypeMax(vtkInformation* meta_data);
278 virtual double GetScalarTypeMax();
280
282
285 virtual int GetScalarSize(vtkInformation* meta_data);
286 virtual int GetScalarSize();
288
290
302 virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
303 virtual void GetIncrements(vtkIdType inc[3]);
304 virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
305 virtual void GetIncrements(
306 vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
307 virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
309
311
324 virtual void GetContinuousIncrements(
325 int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
326 virtual void GetContinuousIncrements(
327 vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
329
331
334 virtual void* GetScalarPointerForExtent(int extent[6]);
335 virtual void* GetScalarPointer(int coordinates[3]);
336 virtual void* GetScalarPointer(int x, int y, int z);
337 virtual void* GetScalarPointer();
339
341
344 virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
345 virtual vtkIdType GetScalarIndex(int coordinates[3]);
346 virtual vtkIdType GetScalarIndex(int x, int y, int z);
348
350
353 virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
354 virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
355 virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
356 virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
358
364 virtual void AllocateScalars(int dataType, int numComponents);
365
372 virtual void AllocateScalars(vtkInformation* pipeline_info);
373
375
381 virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
382 virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
383 {
384 int e[6];
385 e[0] = x0;
386 e[1] = x1;
387 e[2] = y0;
388 e[3] = y1;
389 e[4] = z0;
390 e[5] = z1;
391 this->CopyAndCastFrom(inData, e);
392 }
394
400 void Crop(const int* updateExtent) override;
401
410 unsigned long GetActualMemorySize() override;
411
413
417 vtkGetVector3Macro(Spacing, double);
418 virtual void SetSpacing(double i, double j, double k);
419 virtual void SetSpacing(const double ijk[3]);
421
423
431 vtkGetVector3Macro(Origin, double);
432 virtual void SetOrigin(double i, double j, double k);
433 virtual void SetOrigin(const double ijk[3]);
435
437
441 vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
443 virtual void SetDirectionMatrix(const double elements[9]);
444 virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
445 double e12, double e20, double e21, double e22);
447
449
453 vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
455
457
460 virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
461 virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
462 virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
463 virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
464 static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
465 double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
467
469
473 vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
475
477
480 virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
481 virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
483
485 double const origin[3], double const spacing[3], double const direction[9], double result[16]);
486
488
491 virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
493
498 virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
499
500 static void SetScalarType(int, vtkInformation* meta_data);
501 static int GetScalarType(vtkInformation* meta_data);
502 static bool HasScalarType(vtkInformation* meta_data);
504 const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
505
507
511 static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
516
521 void CopyInformationFromPipeline(vtkInformation* information) override;
522
528 void CopyInformationToPipeline(vtkInformation* information) override;
529
535 void PrepareForNewData() override;
536
538
541 void ShallowCopy(vtkDataObject* src) override;
542 void DeepCopy(vtkDataObject* src) override;
544
545 //--------------------------------------------------------------------------
546 // Methods that apply to any array (not just scalars).
547 // I am starting to experiment with generalizing imaging filters
548 // to operate on more than just scalars.
549
551
556 void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
557 void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
559
561
568 vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
570
575 void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
576
583 void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
584
588 int GetExtentType() override { return VTK_3D_EXTENT; }
589
591
597
598protected:
600 ~vtkImageData() override;
601
602 // The extent of what is currently in the structured grid.
603 // Dimensions is just an array to return a value.
604 // Its contents are out of data until GetDimensions is called.
605 int Dimensions[3];
606 vtkIdType Increments[3];
607
608 // Variables used to define dataset physical orientation
609 double Origin[3];
610 double Spacing[3];
614
615 int Extent[6];
616
617 // The first method assumes Active Scalars
618 void ComputeIncrements();
619 // This one is given the number of components of the
620 // scalar field explicitly
621 void ComputeIncrements(int numberOfComponents);
622 void ComputeIncrements(vtkDataArray* scalars);
623
624 // The first method assumes Acitive Scalars
626 // This one is given the number of components of the
627 // scalar field explicitly
628 void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
630
631 // for the index to physical methods
633
634 // Cell utilities
637 bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
638 bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
639 void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
640
642
643 void SetDataDescription(int desc);
644 int GetDataDescription() { return this->DataDescription; }
645
646private:
647 void InternalImageDataCopy(vtkImageData* src);
648
649private:
650 friend class vtkUniformGrid;
651
652 // for the GetCell method
653 vtkVertex* Vertex;
654 vtkLine* Line;
655 vtkPixel* Pixel;
656 vtkVoxel* Voxel;
657
658 // for the GetPoint method
659 double Point[3];
660
661 int DataDescription;
662
663 vtkImageData(const vtkImageData&) = delete;
664 void operator=(const vtkImageData&) = delete;
665};
666
667//----------------------------------------------------------------------------
669{
670 this->ComputeIncrements(this->Increments);
671}
672
673//----------------------------------------------------------------------------
674inline void vtkImageData::ComputeIncrements(int numberOfComponents)
675{
676 this->ComputeIncrements(numberOfComponents, this->Increments);
677}
678
679//----------------------------------------------------------------------------
681{
682 this->ComputeIncrements(scalars, this->Increments);
683}
684
685//----------------------------------------------------------------------------
687{
688 this->GetPoint(id, this->Point);
689 return this->Point;
690}
691
692//----------------------------------------------------------------------------
694{
695 const int* extent = this->Extent;
696 vtkIdType dims[3];
697 dims[0] = extent[1] - extent[0] + 1;
698 dims[1] = extent[3] - extent[2] + 1;
699 dims[2] = extent[5] - extent[4] + 1;
700
701 return dims[0] * dims[1] * dims[2];
702}
703
704//----------------------------------------------------------------------------
706{
707 return vtkStructuredData::GetDataDimension(this->DataDescription);
708}
709
710#endif
abstract class to specify cell behavior
Definition: vtkCell.h:61
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:56
general representation of visualization data
Definition: vtkDataObject.h:66
abstract class to specify dataset behavior
Definition: vtkDataSet.h:63
virtual vtkIdType GetNumberOfPoints()=0
Determine the number of points composing the dataset.
virtual double * GetPoint(vtkIdType ptId)=0
Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints.
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:232
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:34
topologically and geometrically regular array of data
Definition: vtkImageData.h:54
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:705
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.
virtual vtkIdType * GetIncrements()
Different ways to get the increments for moving around the data.
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.
bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3])
vtkIdType GetCellSize(vtkIdType cellId) override
Standard vtkDataSet API methods.
vtkCell * GetCellTemplateForDataDescription()
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:231
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:612
virtual int * GetDimensions()
Get dimensions of this structured points dataset.
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:668
vtkCell * FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override
Standard vtkDataSet API methods.
static vtkImageData * GetData(vtkInformationVector *v, int i=0)
Retrieve an instance of this class from an information object.
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.
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:686
void * GetArrayPointerForExtent(vtkDataArray *array, int extent[6])
These are convenience methods for getting a pointer from any filed array.
vtkCell * GetCell(vtkIdType cellId) override
Standard vtkDataSet API methods.
bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3])
static vtkImageData * ExtendedNew()
virtual double GetScalarTypeMin(vtkInformation *meta_data)
These returns the minimum and maximum values the ScalarType can hold without overflowing.
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:641
int GetDataDescription()
Definition: vtkImageData.h:644
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.
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:103
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.
static vtkImageData * New()
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])
int GetNumberOfScalarComponents()
Set/Get the number of scalar components for points.
vtkIdType GetNumberOfPoints() override
Standard vtkDataSet API methods.
Definition: vtkImageData.h:693
vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) 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.
void * GetArrayPointer(vtkDataArray *array, int coordinates[3])
These are convenience methods for getting a pointer from any filed array.
int GetExtentType() override
The extent type is a 3D extent.
Definition: vtkImageData.h:588
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:606
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:71
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:504
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:611
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 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:116
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:109
void ShallowCopy(vtkDataObject *src) override
Shallow and Deep copy.
vtkCell * GetCell(int i, int j, int k) override
Standard vtkDataSet API methods.
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)
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:89
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:613
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:239
static vtkImageData * GetData(vtkInformation *info)
Retrieve an instance of this class from an information object.
a simple class to control print indentation
Definition: vtkIndent.h:40
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition: vtkLine.h:34
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:37
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:42
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:38
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:36
image data with blanking
a cell that represents a 3D point
Definition: vtkVertex.h:34
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:42
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:62
int vtkIdType
Definition: vtkType.h:332
#define VTK_IMAGE_DATA
Definition: vtkType.h:83
#define VTK_SIZEHINT(...)
#define max(a, b)