VTK  9.2.6
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=========================================================================*/
30
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
39class vtkDataArray;
40class vtkLine;
41class vtkMatrix3x3;
42class vtkMatrix4x4;
43class vtkPixel;
44class vtkVertex;
45class vtkVoxel;
46
47class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
48{
49public:
50 static vtkImageData* New();
52
53 vtkTypeMacro(vtkImageData, vtkDataSet);
54 void PrintSelf(ostream& os, vtkIndent indent) override;
55
60 void CopyStructure(vtkDataSet* ds) override;
61
65 int GetDataObjectType() override { return VTK_IMAGE_DATA; }
66
68
77 double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
78 void GetPoint(vtkIdType id, double x[3]) override;
79 vtkCell* GetCell(vtkIdType cellId) override;
80 vtkCell* GetCell(int i, int j, int k) override;
81 void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
82 void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
83 virtual vtkIdType FindPoint(double x, double y, double z)
84 {
85 return this->vtkDataSet::FindPoint(x, y, z);
86 }
87 vtkIdType FindPoint(double x[3]) override;
88 vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
89 double pcoords[3], double* weights) override;
90 vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
91 double tol2, int& subId, double pcoords[3], double* weights) override;
92 vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
93 double pcoords[3], double* weights) override;
94 int GetCellType(vtkIdType cellId) override;
97 void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
98 {
99 int dimensions[3];
100 this->GetDimensions(dimensions);
101 vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
102 }
103 void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
104 {
105 int dimensions[3];
106 this->GetDimensions(dimensions);
107 vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
108 }
109 void ComputeBounds() override;
110 int GetMaxCellSize() override { return 8; } // voxel is the largest
111 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
113
121 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
122
126 void Initialize() override;
127
133 unsigned char IsPointVisible(vtkIdType ptId);
134
140 unsigned char IsCellVisible(vtkIdType cellId);
141
146 bool HasAnyBlankPoints() override;
151 bool HasAnyBlankCells() override;
152
159 void GetCellDims(int cellDims[3]);
160
164 virtual void SetDimensions(int i, int j, int k);
165
169 virtual void SetDimensions(const int dims[3]);
170
177 virtual int* GetDimensions() VTK_SIZEHINT(3);
178
185 virtual void GetDimensions(int dims[3]);
186#if VTK_ID_TYPE_IMPL != VTK_INT
187 virtual void GetDimensions(vtkIdType dims[3]);
188#endif
189
196 virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
197
207 virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
208
215 virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
216
220 virtual int GetDataDimension();
221
225 virtual vtkIdType ComputePointId(int ijk[3])
226 {
228 }
229
233 virtual vtkIdType ComputeCellId(int ijk[3])
234 {
236 }
237
239
243 int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
244 virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
246
248
259 virtual void SetExtent(int extent[6]);
260 virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
261 vtkGetVector6Macro(Extent, int);
263
265
269 virtual double GetScalarTypeMin(vtkInformation* meta_data);
270 virtual double GetScalarTypeMin();
271 virtual double GetScalarTypeMax(vtkInformation* meta_data);
272 virtual double GetScalarTypeMax();
274
276
279 virtual int GetScalarSize(vtkInformation* meta_data);
280 virtual int GetScalarSize();
282
284
296 virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
297 virtual void GetIncrements(vtkIdType inc[3]);
299 virtual void GetIncrements(
300 vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
301 virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
303
305
319 int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
321 vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
323
325
328 virtual void* GetScalarPointerForExtent(int extent[6]);
329 virtual void* GetScalarPointer(int coordinates[3]);
330 virtual void* GetScalarPointer(int x, int y, int z);
331 virtual void* GetScalarPointer();
333
335
338 virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
339 virtual vtkIdType GetScalarIndex(int coordinates[3]);
340 virtual vtkIdType GetScalarIndex(int x, int y, int z);
342
344
347 virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
348 virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
349 virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
350 virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
352
358 virtual void AllocateScalars(int dataType, int numComponents);
359
366 virtual void AllocateScalars(vtkInformation* pipeline_info);
367
369
375 virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
376 virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
377 {
378 int e[6];
379 e[0] = x0;
380 e[1] = x1;
381 e[2] = y0;
382 e[3] = y1;
383 e[4] = z0;
384 e[5] = z1;
385 this->CopyAndCastFrom(inData, e);
386 }
387
388
394 void Crop(const int* updateExtent) override;
395
404 unsigned long GetActualMemorySize() override;
405
407
411 vtkGetVector3Macro(Spacing, double);
412 virtual void SetSpacing(double i, double j, double k);
413 virtual void SetSpacing(const double ijk[3]);
415
417
425 vtkGetVector3Macro(Origin, double);
426 virtual void SetOrigin(double i, double j, double k);
427 virtual void SetOrigin(const double ijk[3]);
429
431
435 vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
437 virtual void SetDirectionMatrix(const double elements[9]);
438 virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
439 double e12, double e20, double e21, double e22);
441
443
449
451
454 virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
455 virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
456 virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
457 virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
458 static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
459 double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
461
463
469
471
474 virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
475 virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
477
479 double const origin[3], double const spacing[3], double const direction[9], double result[16]);
480
482
485 virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
487
492 virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
493
494 static void SetScalarType(int, vtkInformation* meta_data);
495 static int GetScalarType(vtkInformation* meta_data);
496 static bool HasScalarType(vtkInformation* meta_data);
498 const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
499
501
505 static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
510
515 void CopyInformationFromPipeline(vtkInformation* information) override;
516
522 void CopyInformationToPipeline(vtkInformation* information) override;
523
529 void PrepareForNewData() override;
530
532
535 void ShallowCopy(vtkDataObject* src) override;
536 void DeepCopy(vtkDataObject* src) override;
538
539 //--------------------------------------------------------------------------
540 // Methods that apply to any array (not just scalars).
541 // I am starting to experiment with generalizing imaging filters
542 // to operate on more than just scalars.
543
545
550 void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
551 void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
553
555
562 vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
564
569 void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
570
577 void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
578
582 int GetExtentType() override { return VTK_3D_EXTENT; }
583
585
591
592protected:
594 ~vtkImageData() override;
595
596 // The extent of what is currently in the structured grid.
597 // Dimensions is just an array to return a value.
598 // Its contents are out of data until GetDimensions is called.
601
602 // Variables used to define dataset physical orientation
603 double Origin[3];
604 double Spacing[3];
608
609 int Extent[6];
610
611 // The first method assumes Active Scalars
612 void ComputeIncrements();
613 // This one is given the number of components of the
614 // scalar field explicitly
615 void ComputeIncrements(int numberOfComponents);
616 void ComputeIncrements(vtkDataArray* scalars);
617
618 // The first method assumes Acitive Scalars
620 // This one is given the number of components of the
621 // scalar field explicitly
622 void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
624
625 // for the index to physical methods
627
628 // Cell utilities
631 bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
632 bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
633 void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
634
636
637 void SetDataDescription(int desc);
638 int GetDataDescription() { return this->DataDescription; }
639
640private:
641 void InternalImageDataCopy(vtkImageData* src);
642
643private:
644 friend class vtkUniformGrid;
645
646 // for the GetCell method
647 vtkVertex* Vertex;
648 vtkLine* Line;
649 vtkPixel* Pixel;
650 vtkVoxel* Voxel;
651
652 // for the GetPoint method
653 double Point[3];
654
655 int DataDescription;
656
657 vtkImageData(const vtkImageData&) = delete;
658 void operator=(const vtkImageData&) = delete;
659};
660
661//----------------------------------------------------------------------------
663{
664 this->ComputeIncrements(this->Increments);
665}
666
667//----------------------------------------------------------------------------
668inline void vtkImageData::ComputeIncrements(int numberOfComponents)
669{
670 this->ComputeIncrements(numberOfComponents, this->Increments);
671}
672
673//----------------------------------------------------------------------------
675{
676 this->ComputeIncrements(scalars, this->Increments);
677}
678
679//----------------------------------------------------------------------------
681{
682 this->GetPoint(id, this->Point);
683 return this->Point;
684}
685
686//----------------------------------------------------------------------------
688{
689 const int* extent = this->Extent;
690 vtkIdType dims[3];
691 dims[0] = extent[1] - extent[0] + 1;
692 dims[1] = extent[3] - extent[2] + 1;
693 dims[2] = extent[5] - extent[4] + 1;
694
695 return dims[0] * dims[1] * dims[2];
696}
697
698//----------------------------------------------------------------------------
700{
701 return vtkStructuredData::GetDataDimension(this->DataDescription);
702}
703
704#endif
abstract class to specify cell behavior
Definition vtkCell.h:58
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:226
provides thread-safe access to cells
list of point or cell ids
Definition vtkIdList.h:31
topologically and geometrically regular array of data
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.
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()
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...
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.
void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds) override
Standard vtkDataSet API methods.
friend class vtkUniformGrid
virtual void SetDirectionMatrix(vtkMatrix3x3 *m)
Set/Get the direction transform of the dataset.
virtual float GetScalarComponentAsFloat(int x, int y, int z, int component)
For access to data from wrappers.
vtkMatrix4x4 * IndexToPhysicalMatrix
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()
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.
void * GetArrayPointerForExtent(vtkDataArray *array, int extent[6])
These are convenience methods for getting a pointer from any filed array.
int Dimensions[3]
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
int GetDataDescription()
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.
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.
virtual vtkIdType GetScalarIndex(int coordinates[3])
Access the index for the scalar data.
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.
virtual void AllocateScalars(int dataType, int numComponents)
Allocate the point scalars for this dataset.
virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v)
For access to data from wrappers.
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]
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.
virtual void GetContinuousIncrements(int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ)
Different ways to get the increments for moving around the data.
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.
const char * GetScalarTypeAsString()
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.
virtual double GetScalarComponentAsDouble(int x, int y, int z, int component)
For access to data from wrappers.
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).
virtual vtkIdType GetScalarIndexForExtent(int extent[6])
Access the index for the scalar data.
void ComputeIncrements(vtkIdType inc[3])
double Spacing[3]
void ComputeTransforms()
vtkMatrix3x3 * DirectionMatrix
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.
double Origin[3]
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 SetScalarComponentFromDouble(int x, int y, int z, int component, double v)
For access to data from wrappers.
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 void * GetScalarPointer(int coordinates[3])
Access the native pointer for the scalar data.
virtual double GetScalarTypeMax()
These returns the minimum and maximum values the ScalarType can hold without overflowing.
virtual void * GetScalarPointerForExtent(int extent[6])
Access the native pointer for the scalar data.
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.
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.
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.
vtkMatrix4x4 * PhysicalToIndexMatrix
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
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:34
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition vtkLine.h:31
represent and manipulate 3x3 transformation matrices
represent and manipulate 4x4 transformation matrices
a cell that represents an orthogonal quadrilateral
Definition vtkPixel.h:35
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
a cell that represents a 3D point
Definition vtkVertex.h:31
a cell that represents a 3D orthogonal parallelepiped
Definition vtkVoxel.h:39
#define vtkDataArray
#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)