VTK  9.1.0
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
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;
95 void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
96 {
97 int dimensions[3];
98 this->GetDimensions(dimensions);
99 vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
100 }
101 void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
102 {
103 int dimensions[3];
104 this->GetDimensions(dimensions);
105 vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
106 }
107 void ComputeBounds() override;
108 int GetMaxCellSize() override { return 8; } // voxel is the largest
109 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
111
119 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
120
124 void Initialize() override;
125
131 unsigned char IsPointVisible(vtkIdType ptId);
132
138 unsigned char IsCellVisible(vtkIdType cellId);
139
144 bool HasAnyBlankPoints() override;
149 bool HasAnyBlankCells() override;
150
157 void GetCellDims(int cellDims[3]);
158
162 virtual void SetDimensions(int i, int j, int k);
163
167 virtual void SetDimensions(const int dims[3]);
168
175 virtual int* GetDimensions() VTK_SIZEHINT(3);
176
183 virtual void GetDimensions(int dims[3]);
184#if VTK_ID_TYPE_IMPL != VTK_INT
185 virtual void GetDimensions(vtkIdType dims[3]);
186#endif
187
194 virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
195
205 virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
206
213 virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
214
218 virtual int GetDataDimension();
219
223 virtual vtkIdType ComputePointId(int ijk[3])
224 {
225 return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
226 }
227
231 virtual vtkIdType ComputeCellId(int ijk[3])
232 {
233 return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
234 }
235
237
241 int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
242 virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
244
246
257 virtual void SetExtent(int extent[6]);
258 virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
259 vtkGetVector6Macro(Extent, int);
261
263
267 virtual double GetScalarTypeMin(vtkInformation* meta_data);
268 virtual double GetScalarTypeMin();
269 virtual double GetScalarTypeMax(vtkInformation* meta_data);
270 virtual double GetScalarTypeMax();
272
274
277 virtual int GetScalarSize(vtkInformation* meta_data);
278 virtual int GetScalarSize();
280
282
289 virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
290 virtual void GetIncrements(vtkIdType inc[3]);
291 virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
292 virtual void GetIncrements(
293 vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
294 virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
296
298
311 virtual void GetContinuousIncrements(
312 int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
313 virtual void GetContinuousIncrements(
314 vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
316
318
321 virtual void* GetScalarPointerForExtent(int extent[6]);
322 virtual void* GetScalarPointer(int coordinates[3]);
323 virtual void* GetScalarPointer(int x, int y, int z);
324 virtual void* GetScalarPointer();
326
328
331 virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
332 virtual vtkIdType GetScalarIndex(int coordinates[3]);
333 virtual vtkIdType GetScalarIndex(int x, int y, int z);
335
337
340 virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
341 virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
342 virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
343 virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
345
351 virtual void AllocateScalars(int dataType, int numComponents);
352
359 virtual void AllocateScalars(vtkInformation* pipeline_info);
360
362
368 virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
369 virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
370 {
371 int e[6];
372 e[0] = x0;
373 e[1] = x1;
374 e[2] = y0;
375 e[3] = y1;
376 e[4] = z0;
377 e[5] = z1;
378 this->CopyAndCastFrom(inData, e);
379 }
381
387 void Crop(const int* updateExtent) override;
388
397 unsigned long GetActualMemorySize() override;
398
400
404 vtkGetVector3Macro(Spacing, double);
405 virtual void SetSpacing(double i, double j, double k);
406 virtual void SetSpacing(const double ijk[3]);
408
410
418 vtkGetVector3Macro(Origin, double);
419 virtual void SetOrigin(double i, double j, double k);
420 virtual void SetOrigin(const double ijk[3]);
422
424
428 vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
430 virtual void SetDirectionMatrix(const double elements[9]);
431 virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
432 double e12, double e20, double e21, double e22);
434
436
440 vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
442
444
447 virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
448 virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
449 virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
450 virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
451 static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
452 double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
454
456
460 vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
462
464
467 virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
468 virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
470
472 double const origin[3], double const spacing[3], double const direction[9], double result[16]);
473
475
478 virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
480
485 virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
486
487 static void SetScalarType(int, vtkInformation* meta_data);
488 static int GetScalarType(vtkInformation* meta_data);
489 static bool HasScalarType(vtkInformation* meta_data);
491 const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
492
494
498 static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
503
508 void CopyInformationFromPipeline(vtkInformation* information) override;
509
515 void CopyInformationToPipeline(vtkInformation* information) override;
516
522 void PrepareForNewData() override;
523
525
528 void ShallowCopy(vtkDataObject* src) override;
529 void DeepCopy(vtkDataObject* src) override;
531
532 //--------------------------------------------------------------------------
533 // Methods that apply to any array (not just scalars).
534 // I am starting to experiment with generalizing imaging filters
535 // to operate on more than just scalars.
536
538
543 void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
544 void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
546
548
555 vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
557
562 void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
563
570 void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
571
575 int GetExtentType() override { return VTK_3D_EXTENT; }
576
578
584
585protected:
587 ~vtkImageData() override;
588
589 // The extent of what is currently in the structured grid.
590 // Dimensions is just an array to return a value.
591 // Its contents are out of data until GetDimensions is called.
592 int Dimensions[3];
593 vtkIdType Increments[3];
594
595 // Variables used to define dataset physical orientation
596 double Origin[3];
597 double Spacing[3];
601
602 int Extent[6];
603
604 // The first method assumes Active Scalars
605 void ComputeIncrements();
606 // This one is given the number of components of the
607 // scalar field explicitly
608 void ComputeIncrements(int numberOfComponents);
609 void ComputeIncrements(vtkDataArray* scalars);
610
611 // The first method assumes Acitive Scalars
613 // This one is given the number of components of the
614 // scalar field explicitly
615 void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
617
618 // for the index to physical methods
620
621 // Cell utilities
624 bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
625 bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
626 void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
627
629
630 void SetDataDescription(int desc);
631 int GetDataDescription() { return this->DataDescription; }
632
633private:
634 void InternalImageDataCopy(vtkImageData* src);
635
636private:
637 friend class vtkUniformGrid;
638
639 // for the GetCell method
640 vtkVertex* Vertex;
641 vtkLine* Line;
642 vtkPixel* Pixel;
643 vtkVoxel* Voxel;
644
645 // for the GetPoint method
646 double Point[3];
647
648 int DataDescription;
649
650 vtkImageData(const vtkImageData&) = delete;
651 void operator=(const vtkImageData&) = delete;
652};
653
654//----------------------------------------------------------------------------
656{
657 this->ComputeIncrements(this->Increments);
658}
659
660//----------------------------------------------------------------------------
661inline void vtkImageData::ComputeIncrements(int numberOfComponents)
662{
663 this->ComputeIncrements(numberOfComponents, this->Increments);
664}
665
666//----------------------------------------------------------------------------
668{
669 this->ComputeIncrements(scalars, this->Increments);
670}
671
672//----------------------------------------------------------------------------
674{
675 this->GetPoint(id, this->Point);
676 return this->Point;
677}
678
679//----------------------------------------------------------------------------
681{
682 const int* extent = this->Extent;
683 vtkIdType dims[3];
684 dims[0] = extent[1] - extent[0] + 1;
685 dims[1] = extent[3] - extent[2] + 1;
686 dims[2] = extent[5] - extent[4] + 1;
687
688 return dims[0] * dims[1] * dims[2];
689}
690
691//----------------------------------------------------------------------------
693{
694 return vtkStructuredData::GetDataDimension(this->DataDescription);
695}
696
697#endif
abstract class to specify cell behavior
Definition: vtkCell.h:58
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
general representation of visualization data
Definition: vtkDataObject.h:60
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
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.
vtkIdType FindPoint(double x, double y, double z)
Locate the closest point to the global coordinate x.
Definition: vtkDataSet.h:201
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:31
topologically and geometrically regular array of data
Definition: vtkImageData.h:48
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:692
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])
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:223
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:599
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 bounrary 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:655
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:673
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:628
int GetDataDescription()
Definition: vtkImageData.h:631
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:95
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:680
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:575
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:593
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:65
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:491
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:598
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:108
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:101
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:83
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:600
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:231
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
Definition: vtkMatrix3x3.h:34
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:36
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
Definition: vtkTimeStamp.h:33
image data with blanking
a cell that represents a 3D point
Definition: vtkVertex.h:31
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:39
#define VTK_3D_EXTENT
Definition: vtkDataObject.h:56
int vtkIdType
Definition: vtkType.h:332
#define VTK_IMAGE_DATA
Definition: vtkType.h:83
#define VTK_SIZEHINT(...)
#define max(a, b)