VTK  9.3.0
vtkImageData.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2// SPDX-License-Identifier: BSD-3-Clause
25#ifndef vtkImageData_h
26#define vtkImageData_h
27
28#include "vtkCommonDataModelModule.h" // For export macro
29#include "vtkDataSet.h"
30
31#include "vtkStructuredData.h" // Needed for inline methods
32
33VTK_ABI_NAMESPACE_BEGIN
34class vtkDataArray;
35class vtkLine;
36class vtkMatrix3x3;
37class vtkMatrix4x4;
38class vtkPixel;
39class vtkVertex;
40class vtkVoxel;
41
42class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
43{
44public:
45 static vtkImageData* New();
47
48 vtkTypeMacro(vtkImageData, vtkDataSet);
49 void PrintSelf(ostream& os, vtkIndent indent) override;
50
55 void CopyStructure(vtkDataSet* ds) override;
56
60 int GetDataObjectType() override { return VTK_IMAGE_DATA; }
61
63
72 double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
73 void GetPoint(vtkIdType id, double x[3]) override;
74 vtkCell* GetCell(vtkIdType cellId) override;
75 vtkCell* GetCell(int i, int j, int k) override;
76 void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
77 void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
78 virtual vtkIdType FindPoint(double x, double y, double z)
79 {
80 return this->vtkDataSet::FindPoint(x, y, z);
81 }
82 vtkIdType FindPoint(double x[3]) override;
83 vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
84 double pcoords[3], double* weights) override;
85 vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
86 double tol2, int& subId, double pcoords[3], double* weights) override;
87 vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
88 double pcoords[3], double* weights) override;
89 int GetCellType(vtkIdType cellId) override;
92 void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
93 {
94 int dimensions[3];
95 this->GetDimensions(dimensions);
96 vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
97 }
98 void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
99 {
100 int dimensions[3];
101 this->GetDimensions(dimensions);
102 vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
103 }
104 void ComputeBounds() override;
105 int GetMaxCellSize() override { return 8; } // voxel is the largest
106 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
108
116 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
117
121 void Initialize() override;
122
128 unsigned char IsPointVisible(vtkIdType ptId);
129
135 unsigned char IsCellVisible(vtkIdType cellId);
136
141 bool HasAnyBlankPoints() override;
146 bool HasAnyBlankCells() override;
147
154 void GetCellDims(int cellDims[3]);
155
159 virtual void SetDimensions(int i, int j, int k);
160
164 virtual void SetDimensions(const int dims[3]);
165
172 virtual int* GetDimensions() VTK_SIZEHINT(3);
173
180 virtual void GetDimensions(int dims[3]);
181#if VTK_ID_TYPE_IMPL != VTK_INT
182 virtual void GetDimensions(vtkIdType dims[3]);
183#endif
184
191 virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
192
202 virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
203
210 virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
211
215 virtual int GetDataDimension();
216
220 virtual vtkIdType ComputePointId(int ijk[3])
221 {
222 return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
223 }
224
228 virtual vtkIdType ComputeCellId(int ijk[3])
229 {
230 return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
231 }
232
234
238 int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
239 virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
241
243
254 virtual void SetExtent(int extent[6]);
255 virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
256 vtkGetVector6Macro(Extent, int);
258
260
264 virtual double GetScalarTypeMin(vtkInformation* meta_data);
265 virtual double GetScalarTypeMin();
266 virtual double GetScalarTypeMax(vtkInformation* meta_data);
267 virtual double GetScalarTypeMax();
269
271
274 virtual int GetScalarSize(vtkInformation* meta_data);
275 virtual int GetScalarSize();
277
279
291 virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
292 virtual void GetIncrements(vtkIdType inc[3]);
293 virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
294 virtual void GetIncrements(
295 vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
296 virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
298
300
313 virtual void GetContinuousIncrements(
314 int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
315 virtual void GetContinuousIncrements(
316 vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
318
320
323 virtual void* GetScalarPointerForExtent(int extent[6]);
324 virtual void* GetScalarPointer(int coordinates[3]);
325 virtual void* GetScalarPointer(int x, int y, int z);
326 virtual void* GetScalarPointer();
328
330
333 virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
334 virtual vtkIdType GetScalarIndex(int coordinates[3]);
335 virtual vtkIdType GetScalarIndex(int x, int y, int z);
337
339
342 virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
343 virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
344 virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
345 virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
347
353 virtual void AllocateScalars(int dataType, int numComponents);
354
361 virtual void AllocateScalars(vtkInformation* pipeline_info);
362
364
370 virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
371 virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
372 {
373 int e[6];
374 e[0] = x0;
375 e[1] = x1;
376 e[2] = y0;
377 e[3] = y1;
378 e[4] = z0;
379 e[5] = z1;
380 this->CopyAndCastFrom(inData, e);
381 }
383
389 void Crop(const int* updateExtent) override;
390
399 unsigned long GetActualMemorySize() override;
400
402
406 vtkGetVector3Macro(Spacing, double);
407 virtual void SetSpacing(double i, double j, double k);
408 virtual void SetSpacing(const double ijk[3]);
410
412
420 vtkGetVector3Macro(Origin, double);
421 virtual void SetOrigin(double i, double j, double k);
422 virtual void SetOrigin(const double ijk[3]);
424
426
430 vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
432 virtual void SetDirectionMatrix(const double elements[9]);
433 virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
434 double e12, double e20, double e21, double e22);
436
438
442 vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
444
446
449 virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
450 virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
451 virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
452 virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
453 static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
454 double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
456
458
462 vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
464
466
469 virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
470 virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
472
474 double const origin[3], double const spacing[3], double const direction[9], double result[16]);
475
477
480 virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
482
487 virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
488
489 static void SetScalarType(int, vtkInformation* meta_data);
490 static int GetScalarType(vtkInformation* meta_data);
491 static bool HasScalarType(vtkInformation* meta_data);
493 const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
494
496
500 static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
505
510 void CopyInformationFromPipeline(vtkInformation* information) override;
511
517 void CopyInformationToPipeline(vtkInformation* information) override;
518
524 void PrepareForNewData() override;
525
527
530 void ShallowCopy(vtkDataObject* src) override;
531 void DeepCopy(vtkDataObject* src) override;
533
534 //--------------------------------------------------------------------------
535 // Methods that apply to any array (not just scalars).
536 // I am starting to experiment with generalizing imaging filters
537 // to operate on more than just scalars.
538
540
545 void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
546 void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
548
550
557 vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
559
564 void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
565
572 void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
573
577 int GetExtentType() override { return VTK_3D_EXTENT; }
578
580
586
587protected:
589 ~vtkImageData() override;
590
591 // The extent of what is currently in the structured grid.
592 // Dimensions is just an array to return a value.
593 // Its contents are out of data until GetDimensions is called.
594 int Dimensions[3];
595 vtkIdType Increments[3];
596
597 // Variables used to define dataset physical orientation
598 double Origin[3];
599 double Spacing[3];
603
604 int Extent[6];
605
606 // The first method assumes Active Scalars
607 void ComputeIncrements();
608 // This one is given the number of components of the
609 // scalar field explicitly
610 void ComputeIncrements(int numberOfComponents);
611 void ComputeIncrements(vtkDataArray* scalars);
612
613 // The first method assumes Acitive Scalars
615 // This one is given the number of components of the
616 // scalar field explicitly
617 void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
619
620 // for the index to physical methods
622
623 // Cell utilities
626 bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
627 bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
628 void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
629
631
632 void SetDataDescription(int desc);
633 int GetDataDescription() { return this->DataDescription; }
634
635private:
636 void InternalImageDataCopy(vtkImageData* src);
637
638 friend class vtkUniformGrid;
639
640 // for the GetCell method
641 vtkVertex* Vertex;
642 vtkLine* Line;
643 vtkPixel* Pixel;
644 vtkVoxel* Voxel;
645
646 // for the GetPoint method
647 double Point[3];
648
649 int DataDescription;
650
651 vtkImageData(const vtkImageData&) = delete;
652 void operator=(const vtkImageData&) = delete;
653};
654
655//----------------------------------------------------------------------------
657{
658 this->ComputeIncrements(this->Increments);
659}
660
661//----------------------------------------------------------------------------
662inline void vtkImageData::ComputeIncrements(int numberOfComponents)
663{
664 this->ComputeIncrements(numberOfComponents, this->Increments);
665}
666
667//----------------------------------------------------------------------------
669{
670 this->ComputeIncrements(scalars, this->Increments);
671}
672
673//----------------------------------------------------------------------------
675{
676 this->GetPoint(id, this->Point);
677 return this->Point;
678}
679
680//----------------------------------------------------------------------------
682{
683 const int* extent = this->Extent;
684 vtkIdType dims[3];
685 dims[0] = extent[1] - extent[0] + 1;
686 dims[1] = extent[3] - extent[2] + 1;
687 dims[2] = extent[5] - extent[4] + 1;
688
689 return dims[0] * dims[1] * dims[2];
690}
691
692//----------------------------------------------------------------------------
694{
695 return vtkStructuredData::GetDataDimension(this->DataDescription);
696}
697
698VTK_ABI_NAMESPACE_END
699#endif
abstract class to specify cell behavior
Definition vtkCell.h:50
abstract superclass for arrays of numeric data
general representation of visualization data
abstract class to specify dataset behavior
Definition vtkDataSet.h:53
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:233
provides thread-safe access to cells
list of point or cell ids
Definition vtkIdList.h:23
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()
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.
virtual void SetDirectionMatrix(vtkMatrix3x3 *m)
Set/Get the direction transform of the dataset.
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.
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.
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 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.
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.
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
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.
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:29
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition vtkLine.h:23
represent and manipulate 3x3 transformation matrices
represent and manipulate 4x4 transformation matrices
a cell that represents an orthogonal quadrilateral
Definition vtkPixel.h:27
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, VTK_FUTURE_CONST int dim[3])
Get the cells using a point.
record modification and/or execution time
image data with blanking
a cell that represents a 3D point
Definition vtkVertex.h:23
a cell that represents a 3D orthogonal parallelepiped
Definition vtkVoxel.h:31
#define VTK_3D_EXTENT
int vtkIdType
Definition vtkType.h:315
#define VTK_IMAGE_DATA
Definition vtkType.h:71
#define VTK_SIZEHINT(...)
#define max(a, b)