# encoding: utf-8 # module vtkmodules.vtkCommonDataModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms from .vtkDataSet import vtkDataSet class vtkImageData(vtkDataSet): """ vtkImageData - topologically and geometrically regular array of data Superclass: vtkDataSet vtkImageData is a data object that is a concrete implementation of vtkDataSet. vtkImageData represents a geometric structure that is a topological and geometrical regular array of points. Examples include volumes (voxel data) and pixmaps. This representation supports images up to three dimensions. The image may also be oriented (see the DirectionMatrices and related transformation methods). Note however, that not all filters support oriented images. @sa vtkImageTransform """ def AllocateScalars(self, dataType, numComponents): # real signature unknown; restored from __doc__ """ AllocateScalars(self, dataType:int, numComponents:int) -> None C++: virtual void AllocateScalars(int dataType, int numComponents) AllocateScalars(self, pipeline_info:vtkInformation) -> None C++: virtual void AllocateScalars(vtkInformation *pipeline_info) Allocate the point scalars for this dataset. The data type determines the type of the array (VTK_FLOAT, VTK_INT etc.) where as numComponents determines its number of components. """ pass def ComputeBounds(self): # real signature unknown; restored from __doc__ """ ComputeBounds(self) -> None C++: void ComputeBounds() override; Compute the data bounding box from data points. THIS METHOD IS NOT THREAD SAFE. """ pass def ComputeCellId(self, ijk, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeCellId(self, ijk:[int, int, int]) -> int C++: virtual vtkIdType ComputeCellId(int ijk[3]) Given a location in structured coordinates (i-j-k), return the cell id. """ pass def ComputeIndexToPhysicalMatrix(self, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeIndexToPhysicalMatrix(origin:(float, float, float), spacing:(float, float, float), direction:(float, float, float, float, float, float, float, float, float), result:[float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float]) -> None C++: static void ComputeIndexToPhysicalMatrix( double const origin[3], double const spacing[3], double const direction[9], double result[16]) """ pass def ComputeInternalExtent(self, intExt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeInternalExtent(self, intExt:[int, ...], tgtExt:[int, ...], bnds:[int, ...]) -> None C++: 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 traverse, compute the internal extent (the extent for this ImageData that does not suffer from any boundary conditions) and place it in intExt """ pass def ComputePointId(self, ijk, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputePointId(self, ijk:[int, int, int]) -> int C++: virtual vtkIdType ComputePointId(int ijk[3]) Given a location in structured coordinates (i-j-k), return the point id. """ pass def ComputeStructuredCoordinates(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ComputeStructuredCoordinates(self, x:(float, float, float), ijk:[int, int, int], pcoords:[float, float, float]) -> int C++: virtual int ComputeStructuredCoordinates(const double x[3], int ijk[3], double pcoords[3]) Convenience function computes the structured coordinates for a point x[3]. The voxel is specified by the array ijk[3], and the parametric coordinates in the cell are specified with pcoords[3]. The function returns a 0 if the point x is outside of the volume, and a 1 if inside the volume. """ pass def CopyAndCastFrom(self, inData, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CopyAndCastFrom(self, inData:vtkImageData, extent:[int, int, int, int, int, int]) -> None C++: virtual void CopyAndCastFrom(vtkImageData *inData, int extent[6]) CopyAndCastFrom(self, inData:vtkImageData, x0:int, x1:int, y0:int, y1:int, z0:int, z1:int) -> None C++: virtual void CopyAndCastFrom(vtkImageData *inData, int x0, int x1, int y0, int y1, int z0, int z1) This method is passed a input and output region, and executes the filter algorithm to fill the output from the input. It just executes a switch statement to call the correct function for the regions data types. """ pass def CopyInformationFromPipeline(self, information): # real signature unknown; restored from __doc__ """ CopyInformationFromPipeline(self, information:vtkInformation) -> None C++: void CopyInformationFromPipeline(vtkInformation *information) override; Override these to handle origin, spacing, scalar type, and scalar number of components. See vtkDataObject for details. """ pass def CopyInformationToPipeline(self, information): # real signature unknown; restored from __doc__ """ CopyInformationToPipeline(self, information:vtkInformation) -> None C++: void CopyInformationToPipeline(vtkInformation *information) override; Copy information from this data object to the pipeline information. This is used by the vtkTrivialProducer that is created when someone calls SetInputData() to connect the image to a pipeline. """ pass def CopyStructure(self, ds): # real signature unknown; restored from __doc__ """ CopyStructure(self, ds:vtkDataSet) -> None C++: void CopyStructure(vtkDataSet *ds) override; Copy the geometric and topological structure of an input image data object. """ pass def Crop(self, updateExtent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Crop(self, updateExtent:(int, ...)) -> None C++: void Crop(const int *updateExtent) override; Reallocates and copies to set the Extent to updateExtent. This is used internally when the exact extent is requested, and the source generated more than the update extent. """ pass def DeepCopy(self, src): # real signature unknown; restored from __doc__ """ DeepCopy(self, src:vtkDataObject) -> None C++: void DeepCopy(vtkDataObject *src) override; """ pass def ExtendedNew(self): # real signature unknown; restored from __doc__ """ ExtendedNew() -> vtkImageData C++: static vtkImageData *ExtendedNew() """ return vtkImageData def FindAndGetCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindAndGetCell(self, x:[float, float, float], cell:vtkCell, cellId:int, tol2:float, subId:int, pcoords:[float, float, float], weights:[float, ...]) -> vtkCell C++: vtkCell *FindAndGetCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override; Locate the cell that contains a point and return the cell. Also returns the subcell id, parametric coordinates and weights for subsequent interpolation. This method combines the derived class methods int FindCell and vtkCell *GetCell. Derived classes may provide a more efficient implementation. See for example vtkStructuredPoints. THIS METHOD IS NOT THREAD SAFE. """ pass def FindCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCell(self, x:[float, float, float], cell:vtkCell, cellId:int, tol2:float, subId:int, pcoords:[float, float, float], weights:[float, ...]) -> int C++: vtkIdType FindCell(double x[3], vtkCell *cell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override; FindCell(self, x:[float, float, float], cell:vtkCell, gencell:vtkGenericCell, cellId:int, tol2:float, subId:int, pcoords:[float, float, float], weights:[float, ...]) -> int C++: vtkIdType FindCell(double x[3], vtkCell *cell, vtkGenericCell *gencell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) override; Locate cell based on global coordinate x and tolerance squared. If cell and cellId is non-nullptr, then search starts from this cell and looks at immediate neighbors. Returns cellId >= 0 if inside, < 0 otherwise. The parametric coordinates are provided in pcoords[3]. The interpolation weights are returned in weights[]. (The number of weights is equal to the number of points in the found cell). Tolerance is used to control how close the point is to be considered "in" the cell. THIS METHOD IS NOT THREAD SAFE. """ pass def FindPoint(self, x, y, z): # real signature unknown; restored from __doc__ """ FindPoint(self, x:float, y:float, z:float) -> int C++: virtual vtkIdType FindPoint(double x, double y, double z) FindPoint(self, x:[float, float, float]) -> int C++: vtkIdType FindPoint(double x[3]) override; Locate the closest point to the global coordinate x. Return the point id. If point id < 0; then no point found. (This may arise when point is outside of dataset.) THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ return 0 def GetActualMemorySize(self): # real signature unknown; restored from __doc__ """ GetActualMemorySize(self) -> int C++: unsigned long GetActualMemorySize() override; Return the actual size of the data in kibibytes (1024 bytes). This number is valid only after the pipeline has updated. The memory size returned is guaranteed to be greater than or equal to the memory required to represent the data (e.g., extra space in arrays, etc. are not included in the return value). THIS METHOD IS THREAD SAFE. """ return 0 def GetArrayIncrements(self, array, increments, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetArrayIncrements(self, array:vtkDataArray, increments:[int, int, int]) -> None C++: void GetArrayIncrements(vtkDataArray *array, vtkIdType increments[3]) Since various arrays have different number of components, the will have different increments. """ pass def GetArrayPointer(self, array, coordinates, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetArrayPointer(self, array:vtkDataArray, coordinates:[int, int, int]) -> Pointer C++: void *GetArrayPointer(vtkDataArray *array, int coordinates[3]) """ pass def GetArrayPointerForExtent(self, array, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetArrayPointerForExtent(self, array:vtkDataArray, extent:[int, int, int, int, int, int]) -> Pointer C++: void *GetArrayPointerForExtent(vtkDataArray *array, int extent[6]) These are convenience methods for getting a pointer from any filed array. It is a start at expanding image filters to process any array (not just scalars). """ pass def GetAxisUpdateExtent(self, axis, min, max, updateExtent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetAxisUpdateExtent(self, axis:int, min:int, max:int, updateExtent:(int, ...)) -> None C++: virtual void GetAxisUpdateExtent(int axis, int &min, int &max, const int *updateExtent) """ pass def GetCell(self, cellId): # real signature unknown; restored from __doc__ """ GetCell(self, cellId:int) -> vtkCell C++: vtkCell *GetCell(vtkIdType cellId) override; GetCell(self, i:int, j:int, k:int) -> vtkCell C++: vtkCell *GetCell(int i, int j, int k) override; GetCell(self, cellId:int, cell:vtkGenericCell) -> None C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell) override; Get cell with cellId such that: 0 <= cellId < NumberOfCells. The returned vtkCell is an object owned by this instance, hence the return value must not be deleted by the caller. @warning Repeat calls to this function for different face ids will change the data stored in the internal member object whose pointer is returned by this function. @warning THIS METHOD IS NOT THREAD SAFE. For a thread-safe version, please use void GetCell(vtkIdType cellId, vtkGenericCell* cell). """ return vtkCell def GetCellBounds(self, cellId, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCellBounds(self, cellId:int, bounds:[float, float, float, float, float, float]) -> None C++: void GetCellBounds(vtkIdType cellId, double bounds[6]) override; Get the bounds of the cell with cellId such that: 0 <= cellId < NumberOfCells. A subclass may be able to determine the bounds of cell without using an expensive GetCell() method. A default implementation is provided that actually uses a GetCell() call. This is to ensure the method is available to all datasets. Subclasses should override this method to provide an efficient implementation. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetCellDims(self, cellDims, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCellDims(self, cellDims:[int, int, int]) -> None C++: void GetCellDims(int cellDims[3]) Given the node dimensions of this grid instance, this method computes the node dimensions. The value in each dimension can will have a lowest value of "1" such that computing the total number of cells can be achieved by simply by cellDims[0]*cellDims[1]*cellDims[2]. """ pass def GetCellNeighbors(self, cellId, ptIds, cellIds): # real signature unknown; restored from __doc__ """ GetCellNeighbors(self, cellId:int, ptIds:vtkIdList, cellIds:vtkIdList) -> None C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds) override; GetCellNeighbors(self, cellId:int, ptIds:vtkIdList, cellIds:vtkIdList, seedLoc:[int, ...]) -> None C++: void GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds, vtkIdList *cellIds, int *seedLoc) Topological inquiry to get all cells using list of points exclusive of cell specified (e.g., cellId). Note that the list consists of only cells that use ALL the points provided. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetCellPoints(self, cellId, ptIds): # real signature unknown; restored from __doc__ """ GetCellPoints(self, cellId:int, ptIds:vtkIdList) -> None C++: void GetCellPoints(vtkIdType cellId, vtkIdList *ptIds) override; GetCellPoints(self, cellId:int, npts:int, pts:(int, ...), ptIds:vtkIdList) -> None C++: virtual void GetCellPoints(vtkIdType cellId, vtkIdType &npts, vtkIdType const *&pts, vtkIdList *ptIds) Topological inquiry to get points defining cell. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetCellSize(self, cellId): # real signature unknown; restored from __doc__ """ GetCellSize(self, cellId:int) -> int C++: vtkIdType GetCellSize(vtkIdType cellId) override; Get the size of cell with cellId such that: 0 <= cellId < NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED @warning This method MUST be overridden for performance reasons. Default implementation is very unefficient. """ return 0 def GetCellType(self, cellId): # real signature unknown; restored from __doc__ """ GetCellType(self, cellId:int) -> int C++: int GetCellType(vtkIdType cellId) override; Get type of cell with cellId such that: 0 <= cellId < NumberOfCells. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ return 0 def GetContinuousIncrements(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetContinuousIncrements(self, extent:[int, int, int, int, int, int], incX:int, incY:int, incZ:int) -> None C++: virtual void GetContinuousIncrements(int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ) GetContinuousIncrements(self, scalars:vtkDataArray, extent:[int, int, int, int, int, int], incX:int, incY:int, incZ:int) -> None C++: virtual void GetContinuousIncrements(vtkDataArray *scalars, int extent[6], vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ) Different ways to get the increments for moving around the data. incX is always returned with 0. incY is returned with the increment needed to move from the end of one X scanline of data to the start of the next line. incZ is filled in with the increment needed to move from the end of one image to the start of the next. The proper way to use these values is to for a loop over Z, Y, X, C, incrementing the pointer by 1 after each component. When the end of the component is reached, the pointer is set to the beginning of the next pixel, thus incX is properly set to 0. The first form of GetContinuousIncrements uses the active scalar field while the second form allows the scalar array to be passed in. """ pass def GetData(self, info): # real signature unknown; restored from __doc__ """ GetData(info:vtkInformation) -> vtkImageData C++: static vtkImageData *GetData(vtkInformation *info) GetData(v:vtkInformationVector, i:int=0) -> vtkImageData C++: static vtkImageData *GetData(vtkInformationVector *v, int i=0) Retrieve an instance of this class from an information object. """ return vtkImageData def GetDataDimension(self): # real signature unknown; restored from __doc__ """ GetDataDimension(self) -> int C++: virtual int GetDataDimension() Return the dimensionality of the data. """ return 0 def GetDataObjectType(self): # real signature unknown; restored from __doc__ """ GetDataObjectType(self) -> int C++: int GetDataObjectType() override; Return what type of dataset this is. """ return 0 def GetDimensions(self): # real signature unknown; restored from __doc__ """ GetDimensions(self) -> (int, int, int) C++: virtual int *GetDimensions() GetDimensions(self, dims:[int, int, int]) -> None C++: virtual void GetDimensions(int dims[3]) GetDimensions(self, dims:[int, int, int]) -> None C++: virtual void GetDimensions(vtkIdType dims[3]) Get dimensions of this structured points dataset. It is the number of points on each axis. Dimensions are computed from Extents during this call. \warning Non thread-safe, use second signature if you want it to be. """ pass def GetDirectionMatrix(self): # real signature unknown; restored from __doc__ """ GetDirectionMatrix(self) -> vtkMatrix3x3 C++: virtual vtkMatrix3x3 *GetDirectionMatrix() Set/Get the direction transform of the dataset. The direction matrix is a 3x3 transformation matrix supporting scaling and rotation. """ pass def GetExtent(self): # real signature unknown; restored from __doc__ """ GetExtent(self) -> (int, int, int, int, int, int) C++: virtual int *GetExtent() """ pass def GetExtentType(self): # real signature unknown; restored from __doc__ """ GetExtentType(self) -> int C++: int GetExtentType() override; The extent type is a 3D extent """ return 0 def GetIncrements(self): # real signature unknown; restored from __doc__ """ GetIncrements(self) -> (int, int, int) C++: virtual vtkIdType *GetIncrements() GetIncrements(self, incX:int, incY:int, incZ:int) -> None C++: virtual void GetIncrements(vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ) GetIncrements(self, inc:[int, int, int]) -> None C++: virtual void GetIncrements(vtkIdType inc[3]) GetIncrements(self, scalars:vtkDataArray) -> (int, int, int) C++: virtual vtkIdType *GetIncrements(vtkDataArray *scalars) GetIncrements(self, scalars:vtkDataArray, incX:int, incY:int, incZ:int) -> None C++: virtual void GetIncrements(vtkDataArray *scalars, vtkIdType &incX, vtkIdType &incY, vtkIdType &incZ) GetIncrements(self, scalars:vtkDataArray, inc:[int, int, int]) -> None C++: virtual void GetIncrements(vtkDataArray *scalars, vtkIdType inc[3]) Different ways to get the increments for moving around the data. GetIncrements() calls ComputeIncrements() to ensure the increments are up to date. The first three methods compute the increments based on the active scalar field while the next three, the scalar field is passed in. Note that all methods which do not have the increments passed in are not thread-safe. When working on a given `vtkImageData` instance on multiple threads, each thread should use the `inc*` overloads to compute the increments to avoid racing with other threads. """ pass def GetIndexToPhysicalMatrix(self): # real signature unknown; restored from __doc__ """ GetIndexToPhysicalMatrix(self) -> vtkMatrix4x4 C++: virtual vtkMatrix4x4 *GetIndexToPhysicalMatrix() Get the transformation matrix from the index space to the physical space coordinate system of the dataset. The transform is a 4 by 4 matrix. """ pass def GetMaxCellSize(self): # real signature unknown; restored from __doc__ """ GetMaxCellSize(self) -> int C++: int GetMaxCellSize() override; Convenience method returns largest cell size in dataset. This is generally used to allocate memory for supporting data structures. THIS METHOD IS THREAD SAFE """ return 0 def GetNumberOfCells(self): # real signature unknown; restored from __doc__ """ GetNumberOfCells(self) -> int C++: vtkIdType GetNumberOfCells() override; Standard vtkDataSet API methods. See vtkDataSet for more information. \warning If GetCell(int,int,int) gets overridden in a subclass, it is necessary to override GetCell(vtkIdType) in that class as well since vtkImageData::GetCell(vtkIdType) will always call vkImageData::GetCell(int,int,int) """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfPoints(self): # real signature unknown; restored from __doc__ """ GetNumberOfPoints(self) -> int C++: vtkIdType GetNumberOfPoints() override; Determine the number of points composing the dataset. THIS METHOD IS THREAD SAFE """ return 0 def GetNumberOfScalarComponents(self, meta_data): # real signature unknown; restored from __doc__ """ GetNumberOfScalarComponents(meta_data:vtkInformation) -> int C++: static int GetNumberOfScalarComponents( vtkInformation *meta_data) GetNumberOfScalarComponents(self) -> int C++: int GetNumberOfScalarComponents() """ return 0 def GetOrigin(self): # real signature unknown; restored from __doc__ """ GetOrigin(self) -> (float, float, float) C++: virtual double *GetOrigin() Set/Get the origin of the dataset. The origin is the position in world coordinates of the point of extent (0,0,0). This point does not have to be part of the dataset, in other words, the dataset extent does not have to start at (0,0,0) and the origin can be outside of the dataset bounding box. The origin plus spacing determine the position in space of the points. """ pass def GetPhysicalToIndexMatrix(self): # real signature unknown; restored from __doc__ """ GetPhysicalToIndexMatrix(self) -> vtkMatrix4x4 C++: virtual vtkMatrix4x4 *GetPhysicalToIndexMatrix() Get the transformation matrix from the physical space to the index space coordinate system of the dataset. The transform is a 4 by 4 matrix. """ pass def GetPoint(self, ptId): # real signature unknown; restored from __doc__ """ GetPoint(self, ptId:int) -> (float, float, float) C++: double *GetPoint(vtkIdType ptId) override; GetPoint(self, id:int, x:[float, float, float]) -> None C++: void GetPoint(vtkIdType id, double x[3]) override; Get point coordinates with ptId such that: 0 <= ptId < NumberOfPoints. THIS METHOD IS NOT THREAD SAFE. """ pass def GetPointCells(self, ptId, cellIds): # real signature unknown; restored from __doc__ """ GetPointCells(self, ptId:int, cellIds:vtkIdList) -> None C++: void GetPointCells(vtkIdType ptId, vtkIdList *cellIds) override; Topological inquiry to get cells using point. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetPointGradient(self, i, j, k, s, g, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointGradient(self, i:int, j:int, k:int, s:vtkDataArray, g:[float, float, float]) -> None C++: 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 vector from the scalar data at that point. The scalars s are the scalars from which the gradient is to be computed. This method will treat structured point datasets of any dimension. """ pass def GetScalarComponentAsDouble(self, x, y, z, component): # real signature unknown; restored from __doc__ """ GetScalarComponentAsDouble(self, x:int, y:int, z:int, component:int) -> float C++: virtual double GetScalarComponentAsDouble(int x, int y, int z, int component) """ return 0.0 def GetScalarComponentAsFloat(self, x, y, z, component): # real signature unknown; restored from __doc__ """ GetScalarComponentAsFloat(self, x:int, y:int, z:int, component:int) -> float C++: virtual float GetScalarComponentAsFloat(int x, int y, int z, int component) For access to data from wrappers """ return 0.0 def GetScalarIndex(self, coordinates, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScalarIndex(self, coordinates:[int, int, int]) -> int C++: virtual vtkIdType GetScalarIndex(int coordinates[3]) GetScalarIndex(self, x:int, y:int, z:int) -> int C++: virtual vtkIdType GetScalarIndex(int x, int y, int z) """ pass def GetScalarIndexForExtent(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScalarIndexForExtent(self, extent:[int, int, int, int, int, int]) -> int C++: virtual vtkIdType GetScalarIndexForExtent(int extent[6]) Access the index for the scalar data """ pass def GetScalarPointer(self, coordinates, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScalarPointer(self, coordinates:[int, int, int]) -> Pointer C++: virtual void *GetScalarPointer(int coordinates[3]) GetScalarPointer(self, x:int, y:int, z:int) -> Pointer C++: virtual void *GetScalarPointer(int x, int y, int z) GetScalarPointer(self) -> Pointer C++: virtual void *GetScalarPointer() """ pass def GetScalarPointerForExtent(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScalarPointerForExtent(self, extent:[int, int, int, int, int, int]) -> Pointer C++: virtual void *GetScalarPointerForExtent(int extent[6]) Access the native pointer for the scalar data """ pass def GetScalarSize(self, meta_data): # real signature unknown; restored from __doc__ """ GetScalarSize(self, meta_data:vtkInformation) -> int C++: virtual int GetScalarSize(vtkInformation *meta_data) GetScalarSize(self) -> int C++: virtual int GetScalarSize() Get the size of the scalar type in bytes. """ return 0 def GetScalarType(self, meta_data): # real signature unknown; restored from __doc__ """ GetScalarType(meta_data:vtkInformation) -> int C++: static int GetScalarType(vtkInformation *meta_data) GetScalarType(self) -> int C++: int GetScalarType() """ return 0 def GetScalarTypeAsString(self): # real signature unknown; restored from __doc__ """ GetScalarTypeAsString(self) -> str C++: const char *GetScalarTypeAsString() """ return "" def GetScalarTypeMax(self, meta_data): # real signature unknown; restored from __doc__ """ GetScalarTypeMax(self, meta_data:vtkInformation) -> float C++: virtual double GetScalarTypeMax(vtkInformation *meta_data) GetScalarTypeMax(self) -> float C++: virtual double GetScalarTypeMax() """ return 0.0 def GetScalarTypeMin(self, meta_data): # real signature unknown; restored from __doc__ """ GetScalarTypeMin(self, meta_data:vtkInformation) -> float C++: virtual double GetScalarTypeMin(vtkInformation *meta_data) GetScalarTypeMin(self) -> float C++: virtual double GetScalarTypeMin() These returns the minimum and maximum values the ScalarType can hold without overflowing. """ return 0.0 def GetSpacing(self): # real signature unknown; restored from __doc__ """ GetSpacing(self) -> (float, float, float) C++: virtual double *GetSpacing() Set the spacing (width,height,length) of the cubical cells that compose the data set. """ pass def GetTupleIndex(self, array, coordinates, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetTupleIndex(self, array:vtkDataArray, coordinates:[int, int, int]) -> int C++: 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 coordinate. This method is analogous to GetArrayPointer(), but it conforms to the API of vtkGenericDataArray. """ pass def GetVoxelGradient(self, i, j, k, s, g): # real signature unknown; restored from __doc__ """ GetVoxelGradient(self, i:int, j:int, k:int, s:vtkDataArray, g:vtkDataArray) -> None C++: 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 voxel corners. The order in which the gradient vectors are arranged corresponds to the ordering of the voxel points. Gradient vector is computed by central differences (except on edges of volume where forward difference is used). The scalars s are the scalars from which the gradient is to be computed. This method will treat only 3D structured point datasets (i.e., volumes). """ pass def HasAnyBlankCells(self): # real signature unknown; restored from __doc__ """ HasAnyBlankCells(self) -> bool C++: bool HasAnyBlankCells() override; Returns 1 if there is any visibility constraint on the cells, 0 otherwise. """ return False def HasAnyBlankPoints(self): # real signature unknown; restored from __doc__ """ HasAnyBlankPoints(self) -> bool C++: bool HasAnyBlankPoints() override; Returns 1 if there is any visibility constraint on the points, 0 otherwise. """ return False def HasNumberOfScalarComponents(self, meta_data): # real signature unknown; restored from __doc__ """ HasNumberOfScalarComponents(meta_data:vtkInformation) -> bool C++: static bool HasNumberOfScalarComponents( vtkInformation *meta_data) """ return False def HasScalarType(self, meta_data): # real signature unknown; restored from __doc__ """ HasScalarType(meta_data:vtkInformation) -> bool C++: static bool HasScalarType(vtkInformation *meta_data) """ return False def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Restore data object to initial state. """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsCellVisible(self, cellId): # real signature unknown; restored from __doc__ """ IsCellVisible(self, cellId:int) -> int C++: unsigned char IsCellVisible(vtkIdType cellId) Return non-zero value if specified point is visible. These methods should be called only after the dimensions of the grid are set. """ return 0 def IsPointVisible(self, ptId): # real signature unknown; restored from __doc__ """ IsPointVisible(self, ptId:int) -> int C++: unsigned char IsPointVisible(vtkIdType ptId) Return non-zero value if specified point is visible. These methods should be called only after the dimensions of the grid are set. """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkImageData C++: vtkImageData *NewInstance() """ return vtkImageData def PrepareForNewData(self): # real signature unknown; restored from __doc__ """ PrepareForNewData(self) -> None C++: void PrepareForNewData() override; make the output data ready for new data to be inserted. For most objects we just call Initialize. But for image data we leave the old data in case the memory can be reused. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkImageData C++: static vtkImageData *SafeDownCast(vtkObjectBase *o) """ return vtkImageData def SetAxisUpdateExtent(self, axis, min, max, updateExtent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetAxisUpdateExtent(self, axis:int, min:int, max:int, updateExtent:(int, ...), axisUpdateExtent:[int, ...]) -> None C++: virtual void SetAxisUpdateExtent(int axis, int min, int max, const int *updateExtent, int *axisUpdateExtent) Set / Get the extent on just one axis """ pass def SetDimensions(self, i, j, k): # real signature unknown; restored from __doc__ """ SetDimensions(self, i:int, j:int, k:int) -> None C++: virtual void SetDimensions(int i, int j, int k) SetDimensions(self, dims:(int, int, int)) -> None C++: virtual void SetDimensions(const int dims[3]) Same as SetExtent(0, i-1, 0, j-1, 0, k-1) """ pass def SetDirectionMatrix(self, m): # real signature unknown; restored from __doc__ """ SetDirectionMatrix(self, m:vtkMatrix3x3) -> None C++: virtual void SetDirectionMatrix(vtkMatrix3x3 *m) SetDirectionMatrix(self, elements:(float, float, float, float, float, float, float, float, float)) -> None C++: virtual void SetDirectionMatrix(const double elements[9]) SetDirectionMatrix(self, e00:float, e01:float, e02:float, e10:float, e11:float, e12:float, e20:float, e21:float, e22:float) -> None C++: virtual void SetDirectionMatrix(double e00, double e01, double e02, double e10, double e11, double e12, double e20, double e21, double e22) """ pass def SetExtent(self, extent, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetExtent(self, extent:[int, int, int, int, int, int]) -> None C++: virtual void SetExtent(int extent[6]) SetExtent(self, x1:int, x2:int, y1:int, y2:int, z1:int, z2:int) -> None C++: virtual void SetExtent(int x1, int x2, int y1, int y2, int z1, int z2) Set/Get the extent. On each axis, the extent is defined by the index of the first point and the index of the last point. The extent should be set before the "Scalars" are set or allocated. The Extent is stored in the order (X, Y, Z). The dataset extent does not have to start at (0,0,0). (0,0,0) is just the extent of the origin. The first point (the one with Id=0) is at extent (Extent[0],Extent[2],Extent[4]). As for any dataset, a data array on point data starts at Id=0. """ pass def SetNumberOfScalarComponents(self, n, meta_data): # real signature unknown; restored from __doc__ """ SetNumberOfScalarComponents(n:int, meta_data:vtkInformation) -> None C++: static void SetNumberOfScalarComponents(int n, vtkInformation *meta_data) Set/Get the number of scalar components for points. As with the SetScalarType method this is setting pipeline info. """ pass def SetOrigin(self, i, j, k): # real signature unknown; restored from __doc__ """ SetOrigin(self, i:float, j:float, k:float) -> None C++: virtual void SetOrigin(double i, double j, double k) SetOrigin(self, ijk:(float, float, float)) -> None C++: virtual void SetOrigin(const double ijk[3]) """ pass def SetScalarComponentFromDouble(self, x, y, z, component, v): # real signature unknown; restored from __doc__ """ SetScalarComponentFromDouble(self, x:int, y:int, z:int, component:int, v:float) -> None C++: virtual void SetScalarComponentFromDouble(int x, int y, int z, int component, double v) """ pass def SetScalarComponentFromFloat(self, x, y, z, component, v): # real signature unknown; restored from __doc__ """ SetScalarComponentFromFloat(self, x:int, y:int, z:int, component:int, v:float) -> None C++: virtual void SetScalarComponentFromFloat(int x, int y, int z, int component, float v) """ pass def SetScalarType(self, __a, meta_data): # real signature unknown; restored from __doc__ """ SetScalarType(__a:int, meta_data:vtkInformation) -> None C++: static void SetScalarType(int, vtkInformation *meta_data) """ pass def SetSpacing(self, i, j, k): # real signature unknown; restored from __doc__ """ SetSpacing(self, i:float, j:float, k:float) -> None C++: virtual void SetSpacing(double i, double j, double k) SetSpacing(self, ijk:(float, float, float)) -> None C++: virtual void SetSpacing(const double ijk[3]) """ pass def ShallowCopy(self, src): # real signature unknown; restored from __doc__ """ ShallowCopy(self, src:vtkDataObject) -> None C++: void ShallowCopy(vtkDataObject *src) override; Shallow and Deep copy. """ pass def TransformContinuousIndexToPhysicalPoint(self, i, j, k, xyz, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformContinuousIndexToPhysicalPoint(self, i:float, j:float, k:float, xyz:[float, float, float]) -> None C++: virtual void TransformContinuousIndexToPhysicalPoint( double i, double j, double k, double xyz[3]) TransformContinuousIndexToPhysicalPoint(self, ijk:(float, float, float), xyz:[float, float, float]) -> None C++: virtual void TransformContinuousIndexToPhysicalPoint( const double ijk[3], double xyz[3]) TransformContinuousIndexToPhysicalPoint(i:float, j:float, k:float, origin:(float, float, float), spacing:(float, float, float), direction:(float, float, float, float, float, float, float, float, float), xyz:[float, float, float]) -> None C++: 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). """ pass def TransformIndexToPhysicalPoint(self, i, j, k, xyz, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformIndexToPhysicalPoint(self, i:int, j:int, k:int, xyz:[float, float, float]) -> None C++: virtual void TransformIndexToPhysicalPoint(int i, int j, int k, double xyz[3]) TransformIndexToPhysicalPoint(self, ijk:(int, int, int), xyz:[float, float, float]) -> None C++: virtual void TransformIndexToPhysicalPoint(const int ijk[3], double xyz[3]) """ pass def TransformPhysicalNormalToContinuousIndex(self, xyz, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformPhysicalNormalToContinuousIndex(self, xyz:(float, float, float), ijk:[float, float, float]) -> None C++: virtual void TransformPhysicalNormalToContinuousIndex( const double xyz[3], double ijk[3]) Convert normal from physical space (xyz) to index space (ijk). """ pass def TransformPhysicalPlaneToContinuousIndex(self, pplane, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformPhysicalPlaneToContinuousIndex(self, pplane:(float, float, float, float), iplane:[float, float, float, float]) -> None C++: virtual void TransformPhysicalPlaneToContinuousIndex( double const pplane[4], double iplane[4]) Convert a plane from physical to a continuous index. The plane is represented as n(x-xo)=0; or using a four component normal: pplane=( nx,ny,nz,-(n(x0)) ). """ pass def TransformPhysicalPointToContinuousIndex(self, x, y, z, ijk, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ TransformPhysicalPointToContinuousIndex(self, x:float, y:float, z:float, ijk:[float, float, float]) -> None C++: virtual void TransformPhysicalPointToContinuousIndex( double x, double y, double z, double ijk[3]) TransformPhysicalPointToContinuousIndex(self, xyz:(float, float, float), ijk:[float, float, float]) -> None C++: virtual void TransformPhysicalPointToContinuousIndex( const double xyz[3], double ijk[3]) Convert coordinates from physical space (xyz) to index space (ijk). """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkImageData', 'ExtendedNew': , 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'CopyStructure': , 'GetDataObjectType': , 'GetNumberOfCells': , 'GetNumberOfPoints': , 'GetPoint': , 'GetCell': , 'GetCellBounds': , 'FindPoint': , 'FindCell': , 'FindAndGetCell': , 'GetCellType': , 'GetCellSize': , 'GetCellPoints': , 'GetPointCells': , 'ComputeBounds': , 'GetMaxCellSize': , 'GetCellNeighbors': , 'Initialize': , 'IsPointVisible': , 'IsCellVisible': , 'HasAnyBlankPoints': , 'HasAnyBlankCells': , 'GetCellDims': , 'SetDimensions': , 'GetDimensions': , 'ComputeStructuredCoordinates': , 'GetVoxelGradient': , 'GetPointGradient': , 'GetDataDimension': , 'ComputePointId': , 'ComputeCellId': , 'SetAxisUpdateExtent': , 'GetAxisUpdateExtent': , 'SetExtent': , 'GetExtent': , 'GetScalarTypeMin': , 'GetScalarTypeMax': , 'GetScalarSize': , 'GetIncrements': , 'GetContinuousIncrements': , 'GetScalarPointerForExtent': , 'GetScalarPointer': , 'GetScalarIndexForExtent': , 'GetScalarIndex': , 'GetScalarComponentAsFloat': , 'SetScalarComponentFromFloat': , 'GetScalarComponentAsDouble': , 'SetScalarComponentFromDouble': , 'AllocateScalars': , 'CopyAndCastFrom': , 'Crop': , 'GetActualMemorySize': , 'GetSpacing': , 'SetSpacing': , 'GetOrigin': , 'SetOrigin': , 'GetDirectionMatrix': , 'SetDirectionMatrix': , 'GetIndexToPhysicalMatrix': , 'TransformContinuousIndexToPhysicalPoint': , 'TransformIndexToPhysicalPoint': , 'GetPhysicalToIndexMatrix': , 'TransformPhysicalPointToContinuousIndex': , 'ComputeIndexToPhysicalMatrix': , 'TransformPhysicalNormalToContinuousIndex': , 'TransformPhysicalPlaneToContinuousIndex': , 'SetScalarType': , 'GetScalarType': , 'HasScalarType': , 'GetScalarTypeAsString': , 'SetNumberOfScalarComponents': , 'GetNumberOfScalarComponents': , 'HasNumberOfScalarComponents': , 'CopyInformationFromPipeline': , 'CopyInformationToPipeline': , 'PrepareForNewData': , 'ShallowCopy': , 'DeepCopy': , 'GetArrayPointerForExtent': , 'GetArrayPointer': , 'GetTupleIndex': , 'GetArrayIncrements': , 'ComputeInternalExtent': , 'GetExtentType': , 'GetData': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkImageData - topologically and geometrically regular array of data\\n\\nSuperclass: vtkDataSet\\n\\nvtkImageData is a data object that is a concrete implementation of\\nvtkDataSet. vtkImageData represents a geometric structure that is a\\ntopological and geometrical regular array of points. Examples include\\nvolumes (voxel data) and pixmaps. This representation supports images\\nup to three dimensions. The image may also be oriented (see the\\nDirectionMatrices and related transformation methods). Note however,\\nthat not all filters support oriented images.\\n\\n@sa\\nvtkImageTransform\\n\\n'})" __vtkname__ = 'vtkImageData'