# 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 .vtkPointSet import vtkPointSet class vtkExplicitStructuredGrid(vtkPointSet): """ vtkExplicitStructuredGrid - structured grid with explicit topology and geometry Superclass: vtkPointSet vtkExplicitStructuredGrid is a data object that is a concrete implementation of vtkDataSet. vtkExplicitStructuredGrid represents a geometric structure that is a topologically regular array of hexahedron. The topology is that of a cube that has been subdivided into a regular array of smaller cubes. Each cell can be addressed with i-j-k indices, however neighbor hexahedrons does not necessarily share a face and hexahedron can be blanked (turned-off). Like unstructured grid, vtkExplicitStructuredGrid has explicit point coordinates and cell to point indexing. Unlike unstructured grid, vtkExplicitStructuredGrid does not keep a cell type list as all visible cells are known to be hexahedra. vtkExplicitStructuredGrid can take advantage of its layout to perform operations based on the i, j, k parameters, similar to structured grid. This makes some operations faster on this class, without losing the flexibility of the cell -> points mapping. The most common use of this class would be in situations where you have all hexahedra but the points used by the cells are not exactly defined by the i, j, k parameters. One example of this is a structured grid with a half voxel shift occurring in the middle of it such as with a geologic fault. The order and number of points is arbitrary. The order and number of cells must match that specified by the dimensions of the grid minus 1, because in vtk structured datasets the dimensions correspond to the points. The cells order increases in i fastest (from 0 <= i <= dims[0] - 2), then j (0 <= j <= dims[1] - 2), then k ( 0 <= k <= dims[2] - 2) where dims[] are the dimensions of the grid in the i-j-k topological directions. The number of cells is (dims[0] - 1) * (dims[1] - 1) * (dims[2] - 1). In order for an ESG to be usable by most other ESG specific filters, it is needed to call the ComputeFacesConnectivityFlagsArray method. It is also recommended to call CheckAndReorderFaces method to fix any faces issues in the dataset. """ def BlankCell(self, cellId): # real signature unknown; restored from __doc__ """ BlankCell(self, cellId:int) -> None C++: void BlankCell(vtkIdType cellId) Methods for supporting blanking of cells. Blanking turns on or off cells in the structured grid. These methods should be called only after the dimensions of the grid are set. """ pass def BuildLinks(self): # real signature unknown; restored from __doc__ """ BuildLinks(self) -> None C++: void BuildLinks() Create/Get upward links from points to cells that use each point. Enables topologically complex queries. """ pass def CheckAndReorderFaces(self): # real signature unknown; restored from __doc__ """ CheckAndReorderFaces(self) -> None C++: void CheckAndReorderFaces() Check faces are numbered correctly regarding ijk numbering If not this will reorganize cell points order so face order is valid. This is made in two pass, first it check that faces are on the correct axis and corrects it Then it check if faces are mirrored and corrects it. Make sure cells and extent have been set before calling this method and recompute face connectivity afterwards. """ pass def ComputeCellId(self, i, j, k, adjustForExtent=True): # real signature unknown; restored from __doc__ """ ComputeCellId(self, i:int, j:int, k:int, adjustForExtent:bool=True) -> int C++: vtkIdType ComputeCellId(int i, int j, int k, bool adjustForExtent=true) Given a location in structured coordinates (i-j-k), return the cell id. If adjustForExtent is true, (i,j,k) is interpreted as a position relative to the beginning of the extent. If adjustForExtent is false, (i,j,k) is interpreted literally and the cell id is returned regardless of the extent beginning. The default adjustForExtent is true. """ return 0 def ComputeCellStructuredCoords(self, cellId, i, j, k, adjustForExtent=True): # real signature unknown; restored from __doc__ """ ComputeCellStructuredCoords(self, cellId:int, i:int, j:int, k:int, adjustForExtent:bool=True) -> None C++: void ComputeCellStructuredCoords(vtkIdType cellId, int &i, int &j, int &k, bool adjustForExtent=true) Given a cellId, get the structured coordinates (i-j-k). If adjustForExtent is true, (i,j,k) is computed as a position relative to the beginning of the extent. If adjustForExtent is false, (i,j,k) is computed regardless of the extent beginning. The default adjustForExtent is true. """ pass def ComputeFacesConnectivityFlagsArray(self): # real signature unknown; restored from __doc__ """ ComputeFacesConnectivityFlagsArray(self) -> None C++: void ComputeFacesConnectivityFlagsArray() Compute the faces connectivity flags array. This method should be called after the construction if the ESG is to be used by other filters. """ 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 poly 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; Crop(self, input:vtkExplicitStructuredGrid, updateExtent:(int, ...), generateOriginalCellIds:bool) -> None C++: virtual void Crop(vtkExplicitStructuredGrid *input, const int *updateExtent, bool generateOriginalCellIds) Reallocates and copies to set the Extent to the 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 GenerateGhostArray(self, zeroExt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int], cellOnly:bool) -> None C++: void GenerateGhostArray(int zeroExt[6], bool cellOnly) override; GenerateGhostArray(self, zeroExt:[int, int, int, int, int, int]) -> None C++: virtual void GenerateGhostArray(int zeroExt[6]) """ pass 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 kilobytes. 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 GetCell(self, cellId): # real signature unknown; restored from __doc__ """ GetCell(self, cellId:int) -> vtkCell C++: vtkCell *GetCell(vtkIdType cellId) override; GetCell(self, cellId:int, cell:vtkGenericCell) -> None C++: void GetCell(vtkIdType cellId, vtkGenericCell *cell) override; GetCell(self, i:int, j:int, k:int) -> vtkCell C++: virtual vtkCell *GetCell(int i, int j, int k) This method always return a `vtkEmptyCell`, as there is no cell in a `vtkPointSet`. """ 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]) Computes the cell dimensions according to internal point dimensions. The total number of cells can be achieved 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, neighbors:[int, int, int, int, int, int], wholeExtent:[int, ...]=...) -> None C++: void GetCellNeighbors(vtkIdType cellId, vtkIdType neighbors[6], int *wholeExtent=nullptr) 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) -> Pointer C++: vtkIdType *GetCellPoints(vtkIdType cellId) GetCellPoints(self, cellId:int, npts:int, pts:[int, ...]) -> None C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts, vtkIdType *&pts) GetCellPoints(self, cellId:int, npts:int, pts:(int, ...), ptIds:vtkIdList) -> None C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts, vtkIdType const *&pts, vtkIdList *ptIds) override; 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 GetCells(self): # real signature unknown; restored from __doc__ """ GetCells(self) -> vtkCellArray C++: virtual vtkCellArray *GetCells() """ return vtkCellArray def GetCellSize(self, cellId): # real signature unknown; restored from __doc__ """ GetCellSize(self, cellId:int) -> int C++: vtkIdType GetCellSize(vtkIdType cellId) override; This method always returns 1, as all cells are point in a pure `vtkPointSet`. """ return 0 def GetCellType(self, cellId): # real signature unknown; restored from __doc__ """ GetCellType(self, cellId:int) -> int C++: int GetCellType(vtkIdType cellId) override; This method always returns `VTK_EMPTY_CELL`, as there is no cell in a `vtkPointSet`. """ return 0 def GetData(self, info): # real signature unknown; restored from __doc__ """ GetData(info:vtkInformation) -> vtkExplicitStructuredGrid C++: static vtkExplicitStructuredGrid *GetData( vtkInformation *info) GetData(v:vtkInformationVector, i:int=0) -> vtkExplicitStructuredGrid C++: static vtkExplicitStructuredGrid *GetData( vtkInformationVector *v, int i=0) Retrieve an instance of this class from an information object. """ return vtkExplicitStructuredGrid def GetDataDimension(self): # real signature unknown; restored from __doc__ """ GetDataDimension(self) -> int C++: 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, dim, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetDimensions(self, dim:[int, int, int]) -> None C++: void GetDimensions(int dim[3]) """ 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 GetFacesConnectivityFlagsArrayName(self): # real signature unknown; restored from __doc__ """ GetFacesConnectivityFlagsArrayName(self) -> str C++: virtual char *GetFacesConnectivityFlagsArrayName() """ return "" def GetLinks(self): # real signature unknown; restored from __doc__ """ GetLinks(self) -> vtkAbstractCellLinks C++: virtual vtkAbstractCellLinks *GetLinks() """ return vtkAbstractCellLinks 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; This method always returns 0, as there are no cells in a `vtkPointSet`. """ 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 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 HasAnyBlankCells(self): # real signature unknown; restored from __doc__ """ HasAnyBlankCells(self) -> bool C++: bool HasAnyBlankCells() override; Returns true if one or more cells are blanked, false otherwise. """ return False def HasAnyGhostCells(self): # real signature unknown; restored from __doc__ """ HasAnyGhostCells(self) -> bool C++: bool HasAnyGhostCells() Returns true if one or more cells are ghost, false otherwise. """ return False def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Standard vtkDataSet API methods. See vtkDataSet for more information. """ 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 IsCellGhost(self, cellId): # real signature unknown; restored from __doc__ """ IsCellGhost(self, cellId:int) -> int C++: unsigned char IsCellGhost(vtkIdType cellId) Return non-zero value if specified cell is a ghost cell. These methods should be called only after the dimensions of the grid are set. """ 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 cell 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) -> vtkExplicitStructuredGrid C++: vtkExplicitStructuredGrid *NewInstance() """ return vtkExplicitStructuredGrid def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkExplicitStructuredGrid C++: static vtkExplicitStructuredGrid *SafeDownCast( vtkObjectBase *o) """ return vtkExplicitStructuredGrid def SetCells(self, cells): # real signature unknown; restored from __doc__ """ SetCells(self, cells:vtkCellArray) -> None C++: void SetCells(vtkCellArray *cells) Set/Get the cell array defining hexahedron. """ pass def SetDimensions(self, i, j, k): # real signature unknown; restored from __doc__ """ SetDimensions(self, i:int, j:int, k:int) -> None C++: void SetDimensions(int i, int j, int k) SetDimensions(self, dim:[int, int, int]) -> None C++: void SetDimensions(int dim[3]) Set/Get the dimensions of this structured dataset in term of number of points along each direction. This is just a convenience method which calls Set/GetExtent internally. """ pass def SetExtent(self, x0, x1, y0, y1, z0, z1): # real signature unknown; restored from __doc__ """ SetExtent(self, x0:int, x1:int, y0:int, y1:int, z0:int, z1:int) -> None C++: void SetExtent(int x0, int x1, int y0, int y1, int z0, int z1) SetExtent(self, extent:[int, int, int, int, int, int]) -> None C++: void SetExtent(int extent[6]) Set/Get the extent of this structured dataset in term of number of points along each direction. Setting the extent will reset the internal CellArray and Links and a correctly sized cell array will be created. The Extent is stored in the order (X, Y, Z). """ pass def SetFacesConnectivityFlagsArrayName(self, _arg): # real signature unknown; restored from __doc__ """ SetFacesConnectivityFlagsArrayName(self, _arg:str) -> None C++: virtual void SetFacesConnectivityFlagsArrayName( const char *_arg) Set/Get the name of the faces connectivity flags array. """ 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 UnBlankCell(self, cellId): # real signature unknown; restored from __doc__ """ UnBlankCell(self, cellId:int) -> None C++: void UnBlankCell(vtkIdType cellId) """ 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__': 'vtkExplicitStructuredGrid', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetDataObjectType': , 'Initialize': , 'GetCell': , 'GetCellBounds': , 'GetCellType': , 'GetCellSize': , 'GetNumberOfCells': , 'GetCellPoints': , 'GetPointCells': , 'GetMaxCellSize': , 'GetCellNeighbors': , 'CopyStructure': , 'ShallowCopy': , 'DeepCopy': , 'GetDataDimension': , 'SetDimensions': , 'GetDimensions': , 'GetCellDims': , 'GetExtentType': , 'SetExtent': , 'GetExtent': , 'SetCells': , 'GetCells': , 'BuildLinks': , 'GetLinks': , 'ComputeCellStructuredCoords': , 'ComputeCellId': , 'ComputeFacesConnectivityFlagsArray': , 'SetFacesConnectivityFlagsArrayName': , 'GetFacesConnectivityFlagsArrayName': , 'BlankCell': , 'UnBlankCell': , 'HasAnyBlankCells': , 'IsCellVisible': , 'IsCellGhost': , 'HasAnyGhostCells': , 'Crop': , 'GetData': , 'GetActualMemorySize': , 'CheckAndReorderFaces': , 'GenerateGhostArray': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkExplicitStructuredGrid - structured grid with explicit topology\\nand geometry\\n\\nSuperclass: vtkPointSet\\n\\nvtkExplicitStructuredGrid is a data object that is a concrete\\nimplementation of vtkDataSet. vtkExplicitStructuredGrid represents a\\ngeometric structure that is a topologically regular array of\\nhexahedron. The topology is that of a cube that has been subdivided\\ninto a regular array of smaller cubes. Each cell can be addressed\\nwith i-j-k indices, however neighbor hexahedrons does not necessarily\\nshare a face and hexahedron can be blanked (turned-off).\\n\\nLike unstructured grid, vtkExplicitStructuredGrid has explicit point\\ncoordinates and cell to point indexing. Unlike unstructured grid,\\nvtkExplicitStructuredGrid does not keep a cell type list as all\\nvisible cells are known to be hexahedra. vtkExplicitStructuredGrid\\ncan take advantage of its layout to perform operations based on the\\ni, j, k parameters, similar to structured grid. This makes some\\noperations faster on this class, without losing the flexibility of\\nthe cell -> points mapping. The most common use of this class would\\nbe in situations where you have all hexahedra but the points used by\\nthe cells are not exactly defined by the i, j, k parameters. One\\nexample of this is a structured grid with a half voxel shift\\noccurring in the middle of it such as with a geologic fault.\\n\\nThe order and number of points is arbitrary. The order and number of\\ncells must match that specified by the dimensions of the grid minus\\n1, because in vtk structured datasets the dimensions correspond to\\nthe points. The cells order increases in i fastest (from 0 <= i <=\\ndims[0] - 2), then j (0 <= j <= dims[1] - 2), then k ( 0 <= k <=\\ndims[2] - 2) where dims[] are the dimensions of the grid in the i-j-k\\ntopological directions. The number of cells is (dims[0] - 1) *\\n(dims[1] - 1) * (dims[2] - 1).\\n\\nIn order for an ESG to be usable by most other ESG specific filters,\\nit is needed to call the ComputeFacesConnectivityFlagsArray method.\\nIt is also recommended to call CheckAndReorderFaces method to fix any\\nfaces issues in the dataset.\\n\\n'})" __vtkname__ = 'vtkExplicitStructuredGrid'