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=========================================================================*/
140#ifndef vtkImageData_h
141#define vtkImageData_h
142
143#include "vtkCommonDataModelModule.h" // For export macro
144#include "vtkDataSet.h"
145
146#include "vtkStructuredData.h" // Needed for inline methods
147
148class vtkDataArray;
149class vtkLine;
150class vtkMatrix3x3;
151class vtkMatrix4x4;
152class vtkPixel;
153class vtkVertex;
154class vtkVoxel;
155
156class VTKCOMMONDATAMODEL_EXPORT vtkImageData : public vtkDataSet
157{
158public:
159 static vtkImageData* New();
161
162 vtkTypeMacro(vtkImageData, vtkDataSet);
163 void PrintSelf(ostream& os, vtkIndent indent) override;
164
169 void CopyStructure(vtkDataSet* ds) override;
170
174 int GetDataObjectType() override { return VTK_IMAGE_DATA; }
175
177
185 vtkIdType GetNumberOfPoints() override;
186 double* GetPoint(vtkIdType ptId) VTK_SIZEHINT(3) override;
187 void GetPoint(vtkIdType id, double x[3]) override;
188 vtkCell* GetCell(vtkIdType cellId) override;
189 vtkCell* GetCell(int i, int j, int k) override;
190 void GetCell(vtkIdType cellId, vtkGenericCell* cell) override;
191 void GetCellBounds(vtkIdType cellId, double bounds[6]) override;
192 virtual vtkIdType FindPoint(double x, double y, double z)
193 {
194 return this->vtkDataSet::FindPoint(x, y, z);
195 }
196 vtkIdType FindPoint(double x[3]) override;
197 vtkIdType FindCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
198 double pcoords[3], double* weights) override;
199 vtkIdType FindCell(double x[3], vtkCell* cell, vtkGenericCell* gencell, vtkIdType cellId,
200 double tol2, int& subId, double pcoords[3], double* weights) override;
201 vtkCell* FindAndGetCell(double x[3], vtkCell* cell, vtkIdType cellId, double tol2, int& subId,
202 double pcoords[3], double* weights) override;
203 int GetCellType(vtkIdType cellId) override;
204 void GetCellPoints(vtkIdType cellId, vtkIdList* ptIds) override
205 {
206 int dimensions[3];
207 this->GetDimensions(dimensions);
208 vtkStructuredData::GetCellPoints(cellId, ptIds, this->DataDescription, dimensions);
209 }
210 void GetPointCells(vtkIdType ptId, vtkIdList* cellIds) override
211 {
212 int dimensions[3];
213 this->GetDimensions(dimensions);
214 vtkStructuredData::GetPointCells(ptId, cellIds, dimensions);
215 }
216 void ComputeBounds() override;
217 int GetMaxCellSize() override { return 8; } // voxel is the largest
218 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds) override;
220
228 void GetCellNeighbors(vtkIdType cellId, vtkIdList* ptIds, vtkIdList* cellIds, int* seedLoc);
229
233 void Initialize() override;
234
240 unsigned char IsPointVisible(vtkIdType ptId);
241
247 unsigned char IsCellVisible(vtkIdType cellId);
248
253 bool HasAnyBlankPoints() override;
258 bool HasAnyBlankCells() override;
259
266 void GetCellDims(int cellDims[3]);
267
271 virtual void SetDimensions(int i, int j, int k);
272
276 virtual void SetDimensions(const int dims[3]);
277
284 virtual int* GetDimensions() VTK_SIZEHINT(3);
285
292 virtual void GetDimensions(int dims[3]);
293#if VTK_ID_TYPE_IMPL != VTK_INT
294 virtual void GetDimensions(vtkIdType dims[3]);
295#endif
296
303 virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]);
304
314 virtual void GetVoxelGradient(int i, int j, int k, vtkDataArray* s, vtkDataArray* g);
315
322 virtual void GetPointGradient(int i, int j, int k, vtkDataArray* s, double g[3]);
323
327 virtual int GetDataDimension();
328
332 virtual vtkIdType ComputePointId(int ijk[3])
333 {
334 return vtkStructuredData::ComputePointIdForExtent(this->Extent, ijk);
335 }
336
340 virtual vtkIdType ComputeCellId(int ijk[3])
341 {
342 return vtkStructuredData::ComputeCellIdForExtent(this->Extent, ijk);
343 }
344
346
350 int axis, int min, int max, const int* updateExtent, int* axisUpdateExtent);
351 virtual void GetAxisUpdateExtent(int axis, int& min, int& max, const int* updateExtent);
353
355
366 virtual void SetExtent(int extent[6]);
367 virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2);
368 vtkGetVector6Macro(Extent, int);
370
372
376 virtual double GetScalarTypeMin(vtkInformation* meta_data);
377 virtual double GetScalarTypeMin();
378 virtual double GetScalarTypeMax(vtkInformation* meta_data);
379 virtual double GetScalarTypeMax();
381
383
386 virtual int GetScalarSize(vtkInformation* meta_data);
387 virtual int GetScalarSize();
389
391
398 virtual void GetIncrements(vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
399 virtual void GetIncrements(vtkIdType inc[3]);
400 virtual vtkIdType* GetIncrements(vtkDataArray* scalars) VTK_SIZEHINT(3);
401 virtual void GetIncrements(
402 vtkDataArray* scalars, vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
403 virtual void GetIncrements(vtkDataArray* scalars, vtkIdType inc[3]);
405
407
420 virtual void GetContinuousIncrements(
421 int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
422 virtual void GetContinuousIncrements(
423 vtkDataArray* scalars, int extent[6], vtkIdType& incX, vtkIdType& incY, vtkIdType& incZ);
425
427
430 virtual void* GetScalarPointerForExtent(int extent[6]);
431 virtual void* GetScalarPointer(int coordinates[3]);
432 virtual void* GetScalarPointer(int x, int y, int z);
433 virtual void* GetScalarPointer();
435
437
440 virtual vtkIdType GetScalarIndexForExtent(int extent[6]);
441 virtual vtkIdType GetScalarIndex(int coordinates[3]);
442 virtual vtkIdType GetScalarIndex(int x, int y, int z);
444
446
449 virtual float GetScalarComponentAsFloat(int x, int y, int z, int component);
450 virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v);
451 virtual double GetScalarComponentAsDouble(int x, int y, int z, int component);
452 virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v);
454
460 virtual void AllocateScalars(int dataType, int numComponents);
461
468 virtual void AllocateScalars(vtkInformation* pipeline_info);
469
471
477 virtual void CopyAndCastFrom(vtkImageData* inData, int extent[6]);
478 virtual void CopyAndCastFrom(vtkImageData* inData, int x0, int x1, int y0, int y1, int z0, int z1)
479 {
480 int e[6];
481 e[0] = x0;
482 e[1] = x1;
483 e[2] = y0;
484 e[3] = y1;
485 e[4] = z0;
486 e[5] = z1;
487 this->CopyAndCastFrom(inData, e);
488 }
490
496 void Crop(const int* updateExtent) override;
497
506 unsigned long GetActualMemorySize() override;
507
509
513 vtkGetVector3Macro(Spacing, double);
514 virtual void SetSpacing(double i, double j, double k);
515 virtual void SetSpacing(const double ijk[3]);
517
519
527 vtkGetVector3Macro(Origin, double);
528 virtual void SetOrigin(double i, double j, double k);
529 virtual void SetOrigin(const double ijk[3]);
531
533
537 vtkGetObjectMacro(DirectionMatrix, vtkMatrix3x3);
539 virtual void SetDirectionMatrix(const double elements[9]);
540 virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11,
541 double e12, double e20, double e21, double e22);
543
545
549 vtkGetObjectMacro(IndexToPhysicalMatrix, vtkMatrix4x4);
551
553
556 virtual void TransformContinuousIndexToPhysicalPoint(double i, double j, double k, double xyz[3]);
557 virtual void TransformContinuousIndexToPhysicalPoint(const double ijk[3], double xyz[3]);
558 virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]);
559 virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]);
560 static void TransformContinuousIndexToPhysicalPoint(double i, double j, double k,
561 double const origin[3], double const spacing[3], double const direction[9], double xyz[3]);
563
565
569 vtkGetObjectMacro(PhysicalToIndexMatrix, vtkMatrix4x4);
571
573
576 virtual void TransformPhysicalPointToContinuousIndex(double x, double y, double z, double ijk[3]);
577 virtual void TransformPhysicalPointToContinuousIndex(const double xyz[3], double ijk[3]);
579
581 double const origin[3], double const spacing[3], double const direction[9], double result[16]);
582
584
587 virtual void TransformPhysicalNormalToContinuousIndex(const double xyz[3], double ijk[3]);
589
594 virtual void TransformPhysicalPlaneToContinuousIndex(double const pplane[4], double iplane[4]);
595
596 static void SetScalarType(int, vtkInformation* meta_data);
597 static int GetScalarType(vtkInformation* meta_data);
598 static bool HasScalarType(vtkInformation* meta_data);
600 const char* GetScalarTypeAsString() { return vtkImageScalarTypeNameMacro(this->GetScalarType()); }
601
603
607 static void SetNumberOfScalarComponents(int n, vtkInformation* meta_data);
612
617 void CopyInformationFromPipeline(vtkInformation* information) override;
618
624 void CopyInformationToPipeline(vtkInformation* information) override;
625
631 void PrepareForNewData() override;
632
634
637 void ShallowCopy(vtkDataObject* src) override;
638 void DeepCopy(vtkDataObject* src) override;
640
641 //--------------------------------------------------------------------------
642 // Methods that apply to any array (not just scalars).
643 // I am starting to experiment with generalizing imaging filters
644 // to operate on more than just scalars.
645
647
652 void* GetArrayPointerForExtent(vtkDataArray* array, int extent[6]);
653 void* GetArrayPointer(vtkDataArray* array, int coordinates[3]);
655
657
664 vtkIdType GetTupleIndex(vtkDataArray* array, int coordinates[3]);
666
671 void GetArrayIncrements(vtkDataArray* array, vtkIdType increments[3]);
672
679 void ComputeInternalExtent(int* intExt, int* tgtExt, int* bnds);
680
684 int GetExtentType() override { return VTK_3D_EXTENT; }
685
687
693
694protected:
696 ~vtkImageData() override;
697
698 // The extent of what is currently in the structured grid.
699 // Dimensions is just an array to return a value.
700 // Its contents are out of data until GetDimensions is called.
701 int Dimensions[3];
702 vtkIdType Increments[3];
703
704 // Variables used to define dataset physical orientation
705 double Origin[3];
706 double Spacing[3];
710
711 int Extent[6];
712
713 // The first method assumes Active Scalars
714 void ComputeIncrements();
715 // This one is given the number of components of the
716 // scalar field explicitly
717 void ComputeIncrements(int numberOfComponents);
718 void ComputeIncrements(vtkDataArray* scalars);
719
720 // The first method assumes Acitive Scalars
722 // This one is given the number of components of the
723 // scalar field explicitly
724 void ComputeIncrements(int numberOfComponents, vtkIdType inc[3]);
726
727 // for the index to physical methods
729
730 // Cell utilities
733 bool GetIJKMinForCellId(vtkIdType cellId, int ijkMin[3]);
734 bool GetIJKMaxForIJKMin(int ijkMin[3], int ijkMax[3]);
735 void AddPointsToCellTemplate(vtkCell* cell, int ijkMin[3], int ijkMax[3]);
736
738
739 void SetDataDescription(int desc);
740 int GetDataDescription() { return this->DataDescription; }
741
742private:
743 void InternalImageDataCopy(vtkImageData* src);
744
745private:
746 friend class vtkUniformGrid;
747
748 // for the GetCell method
749 vtkVertex* Vertex;
750 vtkLine* Line;
751 vtkPixel* Pixel;
752 vtkVoxel* Voxel;
753
754 // for the GetPoint method
755 double Point[3];
756
757 int DataDescription;
758
759 vtkImageData(const vtkImageData&) = delete;
760 void operator=(const vtkImageData&) = delete;
761};
762
763//----------------------------------------------------------------------------
765{
766 this->ComputeIncrements(this->Increments);
767}
768
769//----------------------------------------------------------------------------
770inline void vtkImageData::ComputeIncrements(int numberOfComponents)
771{
772 this->ComputeIncrements(numberOfComponents, this->Increments);
773}
774
775//----------------------------------------------------------------------------
777{
778 this->ComputeIncrements(scalars, this->Increments);
779}
780
781//----------------------------------------------------------------------------
783{
784 this->GetPoint(id, this->Point);
785 return this->Point;
786}
787
788//----------------------------------------------------------------------------
790{
791 const int* extent = this->Extent;
792 vtkIdType dims[3];
793 dims[0] = extent[1] - extent[0] + 1;
794 dims[1] = extent[3] - extent[2] + 1;
795 dims[2] = extent[5] - extent[4] + 1;
796
797 return dims[0] * dims[1] * dims[2];
798}
799
800//----------------------------------------------------------------------------
802{
803 return vtkStructuredData::GetDataDimension(this->DataDescription);
804}
805
806#endif
abstract class to specify cell behavior
Definition: vtkCell.h:147
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:159
general representation of visualization data
abstract class to specify dataset behavior
Definition: vtkDataSet.h:166
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:310
provides thread-safe access to cells
list of point or cell ids
Definition: vtkIdList.h:140
topologically and geometrically regular array of data
Definition: vtkImageData.h:157
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:801
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:332
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:708
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:764
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:782
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:737
int GetDataDescription()
Definition: vtkImageData.h:740
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:204
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:789
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:684
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:702
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:174
const char * GetScalarTypeAsString()
Definition: vtkImageData.h:600
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:707
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:217
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:210
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:192
vtkMatrix4x4 * PhysicalToIndexMatrix
Definition: vtkImageData.h:709
virtual vtkIdType ComputeCellId(int ijk[3])
Given a location in structured coordinates (i-j-k), return the cell id.
Definition: vtkImageData.h:340
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:113
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
cell represents a 1D line
Definition: vtkLine.h:140
represent and manipulate 3x3 transformation matrices
Definition: vtkMatrix3x3.h:63
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:145
a cell that represents an orthogonal quadrilateral
Definition: vtkPixel.h:74
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:52
image data with blanking
a cell that represents a 3D point
Definition: vtkVertex.h:100
a cell that represents a 3D orthogonal parallelepiped
Definition: vtkVoxel.h:88
#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)