# 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 class vtkCellArrayIterator(__vtkmodules_vtkCommonCore.vtkObject): """ vtkCellArrayIterator - Encapsulate traversal logic for vtkCellArray. Superclass: vtkObject This is iterator for thread-safe traversal of a vtkCellArray. It provides random access and forward iteration. Typical usage for forward iteration looks like: ``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator()); for (iter->GoToFirstCell(); !iter->IsDoneWithTraversal(); iter->GoToNextCell()) { // do work with iter iter->GetCurrentCell(numCellPts, cellPts); } ``` Typical usage for random access looks like: ``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator()); iter->GetCellAtId(cellId, numCellPts, cellPts); ``` Here cellId is the id of the ith cell in the vtkCellArray;numCellPts is the number of points defining the cell represented as vtkIdType; and cellPts is a pointer to the point ids defined as vtkIdType const*&. Internally the iterator may copy data from the vtkCellArray, or reference the internal vtkCellArray storage. This depends on the relationship of vtkIdType to the type and structure of internal storage. If the type of storage is the same as vtkIdType, and the storage is a single-component AOS array (i.e., a 1D array), then shared access to the vtkCellArray storage is provided. Otherwise, the data from storage is copied into an internal iterator buffer. (Of course copying is slower and can result in 3-4x reduction in traversal performance. On the other hand, the vtkCellArray can use the appropriate storage to save memory, perform zero-copy, and/or efficiently represent the cell connectivity information.) Note that referencing internal vtkCellArray storage has implications on the validity of the iterator. If the underlying vtkCellArray storage changes while iterating, and the iterator is referencing this storage, unpredictable and catastrophic results are likely - hence do not modify the vtkCellArray while iterating. @sa vtkCellArray """ def GetCellArray(self): # real signature unknown; restored from __doc__ """ GetCellArray(self) -> vtkCellArray C++: vtkCellArray *GetCellArray() Return the vtkCellArray object over which iteration is occurring. """ return vtkCellArray def GetCellAtId(self, cellId, numCellPts, cellPts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCellAtId(self, cellId:int, numCellPts:int, cellPts:(int, ...)) -> None C++: void GetCellAtId(vtkIdType cellId, vtkIdType &numCellPts, vtkIdType const *&cellPts) GetCellAtId(self, cellId:int, cellIds:vtkIdList) -> None C++: void GetCellAtId(vtkIdType cellId, vtkIdList *cellIds) GetCellAtId(self, cellId:int) -> vtkIdList C++: vtkIdList *GetCellAtId(vtkIdType cellId) Initialize the iterator to a specific cell and return the cell. Note that methods passing vtkIdLists always copy data from the vtkCellArray storage buffer into the vtkIdList. Otherwise, a fastpath returning (numCellPts,cellPts) which may return a pointer to internal vtkCellArray storage is possible, if vtkIdType is the same as the vtkCellArray buffer (which is typical). """ pass def GetCurrentCell(self, cellSize, cellPoints, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCurrentCell(self, cellSize:int, cellPoints:(int, ...)) -> None C++: void GetCurrentCell(vtkIdType &cellSize, vtkIdType const *&cellPoints) GetCurrentCell(self, ids:vtkIdList) -> None C++: void GetCurrentCell(vtkIdList *ids) GetCurrentCell(self) -> vtkIdList C++: vtkIdList *GetCurrentCell() Returns the definition of the current cell during forward traversal. Note that methods passing vtkIdLists always copy data from the vtkCellArray storage buffer into the vtkIdList. Otherwise, a fastpath returning (numCellPts,cellPts) - which may return a pointer to internal vtkCellArray storage - is possible, if vtkIdType is the same as the vtkCellArray storage (which is typical). """ pass def GetCurrentCellId(self): # real signature unknown; restored from __doc__ """ GetCurrentCellId(self) -> int C++: vtkIdType GetCurrentCellId() Returns the id of the current cell during forward iteration. """ 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 GoToCell(self, cellId): # real signature unknown; restored from __doc__ """ GoToCell(self, cellId:int) -> None C++: void GoToCell(vtkIdType cellId) Initialize the iterator to a specific cell. This will revalidate the iterator if the underlying vtkCellArray has been modified. This method can always be used to set the starting location for forward iteration, and it is also used to support random access. """ pass def GoToFirstCell(self): # real signature unknown; restored from __doc__ """ GoToFirstCell(self) -> None C++: void GoToFirstCell() The following are methods supporting forward iteration. Initialize the iterator for forward iteration. This will revalidate the iterator if the underlying vtkCellArray has been modified. """ pass def GoToNextCell(self): # real signature unknown; restored from __doc__ """ GoToNextCell(self) -> None C++: void GoToNextCell() Advance the forward iterator to the next cell. """ 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 IsDoneWithTraversal(self): # real signature unknown; restored from __doc__ """ IsDoneWithTraversal(self) -> bool C++: bool IsDoneWithTraversal() Returns true if the iterator has completed the traversal. """ return False 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) -> vtkCellArrayIterator C++: vtkCellArrayIterator *NewInstance() """ return vtkCellArrayIterator def ReplaceCurrentCell(self, p_list): # real signature unknown; restored from __doc__ """ ReplaceCurrentCell(self, list:vtkIdList) -> None C++: void ReplaceCurrentCell(vtkIdList *list) ReplaceCurrentCell(self, npts:int, pts:(int, ...)) -> None C++: void ReplaceCurrentCell(vtkIdType npts, const vtkIdType *pts) Specialized methods for performing operations on the vtkCellArray. Replace the current cell with the ids in `list`. Note that this method CANNOT change the number of points in the cell, it can only redefine the ids (e.g. `list` must contain the same number of entries as the current cell's points). """ pass def ReverseCurrentCell(self): # real signature unknown; restored from __doc__ """ ReverseCurrentCell(self) -> None C++: void ReverseCurrentCell() Reverses the order of the point ids in the current cell. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCellArrayIterator C++: static vtkCellArrayIterator *SafeDownCast(vtkObjectBase *o) """ return vtkCellArrayIterator 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__': 'vtkCellArrayIterator', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetCellArray': , 'GoToCell': , 'GetCellAtId': , 'GoToFirstCell': , 'GoToNextCell': , 'IsDoneWithTraversal': , 'GetCurrentCellId': , 'GetCurrentCell': , 'ReplaceCurrentCell': , 'ReverseCurrentCell': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCellArrayIterator - Encapsulate traversal logic for vtkCellArray.\\n\\nSuperclass: vtkObject\\n\\nThis is iterator for thread-safe traversal of a vtkCellArray. It\\nprovides random access and forward iteration. Typical usage for\\nforward iteration looks like:\\n\\n``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator()); for\\n(iter->GoToFirstCell(); !iter->IsDoneWithTraversal();\\niter->GoToNextCell()) {\\n // do work with iter\\n iter->GetCurrentCell(numCellPts, cellPts); } ```\\n\\nTypical usage for random access looks like:\\n\\n``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator());\\niter->GetCellAtId(cellId, numCellPts, cellPts); ```\\n\\nHere cellId is the id of the ith cell in the vtkCellArray;numCellPts\\nis the number of points defining the cell represented as vtkIdType;\\nand cellPts is a pointer to the point ids defined as vtkIdType\\nconst*&.\\n\\nInternally the iterator may copy data from the vtkCellArray, or\\nreference the internal vtkCellArray storage. This depends on the\\nrelationship of vtkIdType to the type and structure of internal\\nstorage. If the type of storage is the same as vtkIdType, and the\\nstorage is a single-component AOS array (i.e., a 1D array), then\\nshared access to the vtkCellArray storage is provided. Otherwise, the\\ndata from storage is copied into an internal iterator buffer. (Of\\ncourse copying is slower and can result in 3-4x reduction in\\ntraversal performance. On the other hand, the vtkCellArray can use\\nthe appropriate storage to save memory, perform zero-copy, and/or\\nefficiently represent the cell connectivity information.) Note that\\nreferencing internal vtkCellArray storage has implications on the\\nvalidity of the iterator. If the underlying vtkCellArray storage\\nchanges while iterating, and the iterator is referencing this\\nstorage, unpredictable and catastrophic results are likely - hence do\\nnot modify the vtkCellArray while iterating.\\n\\n@sa\\nvtkCellArray\\n\\n'})" __vtkname__ = 'vtkCellArrayIterator'