# 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 .vtkUnstructuredGridBase import vtkUnstructuredGridBase class vtkUnstructuredGrid(vtkUnstructuredGridBase): """ vtkUnstructuredGrid - dataset represents arbitrary combinations of all possible cell types Superclass: vtkUnstructuredGridBase vtkUnstructuredGrid is a data object that is a concrete implementation of vtkDataSet. vtkUnstructuredGrid represents any combinations of any cell types. This includes 0D (e.g., points), 1D (e.g., lines, polylines), 2D (e.g., triangles, polygons), and 3D (e.g., hexahedron, tetrahedron, polyhedron, etc.). vtkUnstructuredGrid provides random access to cells, as well as topological information (such as lists of cells using each point). """ def AddReferenceToCell(self, ptId, cellId): # real signature unknown; restored from __doc__ """ AddReferenceToCell(self, ptId:int, cellId:int) -> None C++: void AddReferenceToCell(vtkIdType ptId, vtkIdType cellId) """ pass def Allocate(self, numCells=1000, extSize=1000): # real signature unknown; restored from __doc__ """ Allocate(self, numCells:int=1000, extSize:int=1000) -> None C++: void Allocate(vtkIdType numCells=1000, int extSize=1000) override; Method allocates initial storage for the cell connectivity. Use this method before the method InsertNextCell(). The array capacity is doubled when the inserting a cell exceeds the current capacity. extSize is no longer used. ote Prefer AllocateExact or AllocateEstimate, which give more control over how allocations are distributed. """ pass def AllocateEstimate(self, numCells, maxCellSize): # real signature unknown; restored from __doc__ """ AllocateEstimate(self, numCells:int, maxCellSize:int) -> bool C++: bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize) Pre-allocate memory in internal data structures. Does not change the number of cells, only the array capacities. Existing data is NOT preserved. @param numCells The number of expected cells in the dataset. @param maxCellSize The number of points per cell to allocate memory for. @return True if allocation succeeds. @sa Squeeze(); """ return False def AllocateExact(self, numCells, connectivitySize): # real signature unknown; restored from __doc__ """ AllocateExact(self, numCells:int, connectivitySize:int) -> bool C++: bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize) Pre-allocate memory in internal data structures. Does not change the number of cells, only the array capacities. Existing data is NOT preserved. @param numCells The number of expected cells in the dataset. @param connectivitySize The total number of pointIds stored for all cells. @return True if allocation succeeds. @sa Squeeze(); """ return False def BuildLinks(self): # real signature unknown; restored from __doc__ """ BuildLinks(self) -> None C++: void BuildLinks() Build topological links from points to lists of cells that use each point. See vtkAbstractCellLinks for more information. """ pass def ConvertFaceStreamPointIds(self, faceStream, idMap, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ConvertFaceStreamPointIds(faceStream:vtkIdList, idMap:[int, ...]) -> None C++: static void ConvertFaceStreamPointIds(vtkIdList *faceStream, vtkIdType *idMap) ConvertFaceStreamPointIds(nfaces:int, faceStream:[int, ...], idMap:[int, ...]) -> None C++: static void ConvertFaceStreamPointIds(vtkIdType nfaces, vtkIdType *faceStream, vtkIdType *idMap) Convert pid in a face stream into idMap[pid]. The face stream is of format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]. The user is responsible to make sure all the Ids in faceStream do not exceed the range of idMap. """ 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 structure of an input point set object. """ pass def DecomposeAPolyhedronCell(self, polyhedronCellArray, nCellpts, nCellfaces, cellArray, faces): # real signature unknown; restored from __doc__ """ DecomposeAPolyhedronCell(polyhedronCellArray:vtkCellArray, nCellpts:int, nCellfaces:int, cellArray:vtkCellArray, faces:vtkIdTypeArray) -> None C++: static void DecomposeAPolyhedronCell( vtkCellArray *polyhedronCellArray, vtkIdType &nCellpts, vtkIdType &nCellfaces, vtkCellArray *cellArray, vtkIdTypeArray *faces) DecomposeAPolyhedronCell(polyhedronCellStream:(int, ...), nCellpts:int, nCellfaces:int, cellArray:vtkCellArray, faces:vtkIdTypeArray) -> None C++: static void DecomposeAPolyhedronCell( const vtkIdType *polyhedronCellStream, vtkIdType &nCellpts, vtkIdType &nCellfaces, vtkCellArray *cellArray, vtkIdTypeArray *faces) DecomposeAPolyhedronCell(nCellFaces:int, inFaceStream:(int, ...), nCellpts:int, cellArray:vtkCellArray, faces:vtkIdTypeArray) -> None C++: static void DecomposeAPolyhedronCell(vtkIdType nCellFaces, const vtkIdType *inFaceStream, vtkIdType &nCellpts, vtkCellArray *cellArray, vtkIdTypeArray *faces) A static method for converting a polyhedron vtkCellArray of format [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...] into three components: (1) an integer indicating the number of faces (2) a standard vtkCellArray storing point ids [nCell0Pts, i, j, k] and (3) an vtkIdTypeArray storing face connectivity in format [nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...] Note: input is assumed to contain only one polyhedron cell. Outputs (2) and (3) will be stacked at the end of the input cellArray and faces. The original data in the input will not be touched. """ pass def DeepCopy(self, src): # real signature unknown; restored from __doc__ """ DeepCopy(self, src:vtkDataObject) -> None C++: void DeepCopy(vtkDataObject *src) override; Shallow and Deep copy. """ pass def ExtendedNew(self): # real signature unknown; restored from __doc__ """ ExtendedNew() -> vtkUnstructuredGrid C++: static vtkUnstructuredGrid *ExtendedNew() """ return vtkUnstructuredGrid 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 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 GetCellLinks(self): # real signature unknown; restored from __doc__ """ GetCellLinks(self) -> vtkAbstractCellLinks C++: vtkAbstractCellLinks *GetCellLinks() Get the cell links. The cell links will be one of nullptr=0; vtkCellLinks=1; vtkStaticCellLinksTemplate=2; vtkStaticCellLinksTemplate=3; vtkStaticCellLinksTemplate=4. (See enum types defined in vtkAbstractCellLinks.) """ return vtkAbstractCellLinks def GetCellLocationsArray(self): # real signature unknown; restored from __doc__ """ GetCellLocationsArray(self) -> vtkIdTypeArray C++: vtkIdTypeArray *GetCellLocationsArray() Get the array of all the starting indices of cell definitions in the cell array. @warning vtkCellArray supports random access now. This array is no longer used. """ 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, npts:int, ptIds:(int, ...), cellIds:vtkIdList) -> None C++: void GetCellNeighbors(vtkIdType cellId, vtkIdType npts, const vtkIdType *ptIds, vtkIdList *cellIds) A topological inquiry to retrieve all of the cells using list of points exclusive of the current cell specified (e.g., cellId). 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, ...)) -> None C++: void GetCellPoints(vtkIdType cellId, vtkIdType &npts, vtkIdType const *&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++: vtkCellArray *GetCells() Return the unstructured grid connectivity array. """ return vtkCellArray 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 the cell with given cellId. """ return 0 def GetCellType(self, cellId): # real signature unknown; restored from __doc__ """ GetCellType(self, cellId:int) -> int C++: int GetCellType(vtkIdType cellId) override; Get the type of the cell with the given cellId. """ return 0 def GetCellTypes(self, types): # real signature unknown; restored from __doc__ """ GetCellTypes(self, types:vtkCellTypes) -> None C++: void GetCellTypes(vtkCellTypes *types) override; Get a list of types of cells in a dataset. The list consists of an array of types (not necessarily in any order), with a single entry per type. For example a dataset with 5 triangles, 3 lines, and 100 hexahedra would result in a list of three entries, corresponding to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. This override implements an optimization that recomputes cell types only when the types of cells may have changed. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetCellTypesArray(self): # real signature unknown; restored from __doc__ """ GetCellTypesArray(self) -> vtkUnsignedCharArray C++: vtkUnsignedCharArray *GetCellTypesArray() Get the array of all cell types in the grid. Each single-component tuple in the array at an index that corresponds to the type of the cell with the same index. To get an array of only the distinct cell types in the dataset, use GetCellTypes(). """ pass def GetData(self, info): # real signature unknown; restored from __doc__ """ GetData(info:vtkInformation) -> vtkUnstructuredGrid C++: static vtkUnstructuredGrid *GetData(vtkInformation *info) GetData(v:vtkInformationVector, i:int=0) -> vtkUnstructuredGrid C++: static vtkUnstructuredGrid *GetData(vtkInformationVector *v, int i=0) Retrieve an instance of this class from an information object. """ return vtkUnstructuredGrid def GetDataObjectType(self): # real signature unknown; restored from __doc__ """ GetDataObjectType(self) -> int C++: int GetDataObjectType() override; Standard vtkDataSet API methods. See vtkDataSet for more information. """ return 0 def GetDistinctCellTypesArray(self): # real signature unknown; restored from __doc__ """ GetDistinctCellTypesArray(self) -> vtkUnsignedCharArray C++: vtkUnsignedCharArray *GetDistinctCellTypesArray() Get a list of types of cells in a dataset. The list consists of an array of types (not necessarily in any order), with a single entry per type. For example a dataset with 5 triangles, 3 lines, and 100 hexahedra would result in a list of three entries, corresponding to the types VTK_TRIANGLE, VTK_LINE, and VTK_HEXAHEDRON. This override implements an optimization that recomputes cell types only when the types of cells may have changed. This method never returns `nullptr`. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED """ pass def GetFaceLocations(self): # real signature unknown; restored from __doc__ """ GetFaceLocations(self) -> vtkIdTypeArray C++: vtkIdTypeArray *GetFaceLocations() """ pass def GetFaces(self, cellId): # real signature unknown; restored from __doc__ """ GetFaces(self, cellId:int) -> Pointer C++: vtkIdType *GetFaces(vtkIdType cellId) GetFaces(self) -> vtkIdTypeArray C++: vtkIdTypeArray *GetFaces() Special support for polyhedron. Return nullptr for all other cell types. """ pass def GetFaceStream(self, cellId, ptIds): # real signature unknown; restored from __doc__ """ GetFaceStream(self, cellId:int, ptIds:vtkIdList) -> None C++: void GetFaceStream(vtkIdType cellId, vtkIdList *ptIds) GetFaceStream(self, cellId:int, nfaces:int, ptIds:(int, ...)) -> None C++: void GetFaceStream(vtkIdType cellId, vtkIdType &nfaces, vtkIdType const *&ptIds) Get the face stream of a polyhedron cell in the following format: (numCellFaces, numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2, id3, ...). If the requested cell is not a polyhedron, then the standard GetCellPoints is called to return a list of unique point ids (id1, id2, id3, ...). """ pass def GetGhostLevel(self): # real signature unknown; restored from __doc__ """ GetGhostLevel(self) -> int C++: virtual int GetGhostLevel() Get the ghost level. """ return 0 def GetIdsOfCellsOfType(self, type, array): # real signature unknown; restored from __doc__ """ GetIdsOfCellsOfType(self, type:int, array:vtkIdTypeArray) -> None C++: void GetIdsOfCellsOfType(int type, vtkIdTypeArray *array) override; Fill vtkIdTypeArray container with list of cell Ids. This method traverses all cells and, for a particular cell type, inserts the cell Id into the container. """ pass 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; Get the size, in number of points, of the largest cell. """ return 0 def GetMeshMTime(self): # real signature unknown; restored from __doc__ """ GetMeshMTime(self) -> int C++: virtual vtkMTimeType GetMeshMTime() Return the mesh (geometry/topology) modification time. This time is different from the usual MTime which also takes into account the modification of data arrays. This function can be used to track the changes on the mesh separately from the data arrays (eg. static mesh over time with transient data). """ 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 GetNumberOfPieces(self): # real signature unknown; restored from __doc__ """ GetNumberOfPieces(self) -> int C++: virtual int GetNumberOfPieces() """ return 0 def GetPiece(self): # real signature unknown; restored from __doc__ """ GetPiece(self) -> int C++: virtual int GetPiece() Set / Get the piece and the number of pieces. Similar to extent in 3D. """ 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; GetPointCells(self, ptId:int, ncells:int, cells:[int, ...]) -> None C++: void GetPointCells(vtkIdType ptId, vtkIdType &ncells, vtkIdType *&cells) 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 Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Reset the grid to an empty state and free any memory. """ pass def InitializeFacesRepresentation(self, numPrevCells): # real signature unknown; restored from __doc__ """ InitializeFacesRepresentation(self, numPrevCells:int) -> int C++: int InitializeFacesRepresentation(vtkIdType numPrevCells) Special function used by vtkUnstructuredGridReader. By default vtkUnstructuredGrid does not contain face information, which is only used by polyhedron cells. If so far no polyhedron cells have been added, Faces and FaceLocations pointers will be nullptr. In this case, need to initialize the arrays and assign values to the previous non-polyhedron cells. """ return 0 def InsertNextLinkedCell(self, type, npts, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertNextLinkedCell(self, type:int, npts:int, pts:(int, ...)) -> int C++: vtkIdType InsertNextLinkedCell(int type, int npts, const vtkIdType pts[]) Use these methods only if the dataset has been specified as Editable. See vtkPointSet 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 IsCellBoundary(self, cellId, npts, ptIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...)) -> bool C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts, const vtkIdType *ptIds) IsCellBoundary(self, cellId:int, npts:int, ptIds:(int, ...), cellIds:vtkIdList) -> bool C++: bool IsCellBoundary(vtkIdType cellId, vtkIdType npts, const vtkIdType *ptIds, vtkIdList *cellIds) A topological inquiry to determine whether a topological entity (e.g., point, edge, or face) defined by the point ids (ptIds of length npts) is a boundary entity of a specified cell (indicated by cellId). A boundary entity is a topological feature used by exactly one cell. This method is related to GetCellNeighbors() except that it simply indicates whether a topological feature is boundary - hence the method is faster. CellIds in the second version are used as a temp buffer to avoid allocation internally, and it's faster. THIS METHOD IS THREAD SAFE IF FIRST CALLED FROM A SINGLE THREAD AND THE DATASET IS NOT MODIFIED. """ pass def IsHomogeneous(self): # real signature unknown; restored from __doc__ """ IsHomogeneous(self) -> int C++: int IsHomogeneous() override; Returns whether cells are all of the same type. """ 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 NewCellIterator(self): # real signature unknown; restored from __doc__ """ NewCellIterator(self) -> vtkCellIterator C++: vtkCellIterator *NewCellIterator() override; Return an iterator that traverses the cells in this data set. """ return vtkCellIterator def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkUnstructuredGrid C++: vtkUnstructuredGrid *NewInstance() """ return vtkUnstructuredGrid def RemoveGhostCells(self): # real signature unknown; restored from __doc__ """ RemoveGhostCells(self) -> None C++: void RemoveGhostCells() This method will remove any cell that is marked as ghost (has the vtkDataSetAttributes::DUPLICATECELL or the vtkDataSetAttributes::HIDDENCELL bit set). """ pass def RemoveReferenceToCell(self, ptId, cellId): # real signature unknown; restored from __doc__ """ RemoveReferenceToCell(self, ptId:int, cellId:int) -> None C++: void RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId) """ pass def Reset(self): # real signature unknown; restored from __doc__ """ Reset(self) -> None C++: void Reset() Standard vtkDataSet methods; see vtkDataSet.h for documentation. """ pass def ResizeCellList(self, ptId, size): # real signature unknown; restored from __doc__ """ ResizeCellList(self, ptId:int, size:int) -> None C++: void ResizeCellList(vtkIdType ptId, int size) """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkUnstructuredGrid C++: static vtkUnstructuredGrid *SafeDownCast(vtkObjectBase *o) """ return vtkUnstructuredGrid def SetCells(self, type, cells): # real signature unknown; restored from __doc__ """ SetCells(self, type:int, cells:vtkCellArray) -> None C++: void SetCells(int type, vtkCellArray *cells) SetCells(self, types:[int, ...], cells:vtkCellArray) -> None C++: void SetCells(int *types, vtkCellArray *cells) SetCells(self, cellTypes:vtkUnsignedCharArray, cells:vtkCellArray) -> None C++: void SetCells(vtkUnsignedCharArray *cellTypes, vtkCellArray *cells) SetCells(self, cellTypes:vtkUnsignedCharArray, cells:vtkCellArray, faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None C++: void SetCells(vtkUnsignedCharArray *cellTypes, vtkCellArray *cells, vtkIdTypeArray *faceLocations, vtkIdTypeArray *faces) SetCells(self, cellTypes:vtkUnsignedCharArray, cellLocations:vtkIdTypeArray, cells:vtkCellArray) -> None C++: void SetCells(vtkUnsignedCharArray *cellTypes, vtkIdTypeArray *cellLocations, vtkCellArray *cells) SetCells(self, cellTypes:vtkUnsignedCharArray, cellLocations:vtkIdTypeArray, cells:vtkCellArray, faceLocations:vtkIdTypeArray, faces:vtkIdTypeArray) -> None C++: void SetCells(vtkUnsignedCharArray *cellTypes, vtkIdTypeArray *cellLocations, vtkCellArray *cells, vtkIdTypeArray *faceLocations, vtkIdTypeArray *faces) Provide cell information to define the dataset. Cells like vtkPolyhedron require points plus a list of faces. To handle vtkPolyhedron, SetCells() support a special input cellConnectivities format (numCellFaces, numFace0Pts, id1, id2, id3, numFace1Pts,id1, id2, id3, ...) The functions use vtkPolyhedron::DecomposeAPolyhedronCell() to convert polyhedron cells into standard format. """ pass def SetLinks(self, _arg): # real signature unknown; restored from __doc__ """ SetLinks(self, _arg:vtkAbstractCellLinks) -> None C++: virtual void SetLinks(vtkAbstractCellLinks *_arg) Set/Get the links that you created possibly without using BuildLinks. """ 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 Squeeze(self): # real signature unknown; restored from __doc__ """ Squeeze(self) -> None C++: void Squeeze() override; Squeeze all arrays in the grid to conserve memory. """ 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__': 'vtkUnstructuredGrid', 'ExtendedNew': , 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetDataObjectType': , 'AllocateEstimate': , 'AllocateExact': , 'Allocate': , 'Reset': , 'CopyStructure': , 'GetNumberOfCells': , 'GetCell': , 'GetCellBounds': , 'GetCellPoints': , 'GetPointCells': , 'NewCellIterator': , 'GetCellType': , 'GetCellSize': , 'GetCellTypes': , 'GetDistinctCellTypesArray': , 'GetCellTypesArray': , 'Squeeze': , 'Initialize': , 'GetMaxCellSize': , 'BuildLinks': , 'SetLinks': , 'GetLinks': , 'GetCellLinks': , 'GetFaceStream': , 'SetCells': , 'GetCells': , 'GetCellNeighbors': , 'IsCellBoundary': , 'InsertNextLinkedCell': , 'RemoveReferenceToCell': , 'AddReferenceToCell': , 'ResizeCellList': , 'GetPiece': , 'GetNumberOfPieces': , 'GetGhostLevel': , 'GetActualMemorySize': , 'ShallowCopy': , 'DeepCopy': , 'GetIdsOfCellsOfType': , 'IsHomogeneous': , 'RemoveGhostCells': , 'GetData': , 'GetFaces': , 'GetFaceLocations': , 'InitializeFacesRepresentation': , 'GetMeshMTime': , 'DecomposeAPolyhedronCell': , 'ConvertFaceStreamPointIds': , 'GetCellLocationsArray': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkUnstructuredGrid - dataset represents arbitrary combinations of\\nall possible cell types\\n\\nSuperclass: vtkUnstructuredGridBase\\n\\nvtkUnstructuredGrid is a data object that is a concrete\\nimplementation of vtkDataSet. vtkUnstructuredGrid represents any\\ncombinations of any cell types. This includes 0D (e.g., points), 1D\\n(e.g., lines, polylines), 2D (e.g., triangles, polygons), and 3D\\n(e.g., hexahedron, tetrahedron, polyhedron, etc.).\\nvtkUnstructuredGrid provides random access to cells, as well as\\ntopological information (such as lists of cells using each point).\\n\\n'})" __vtkname__ = 'vtkUnstructuredGrid'