# 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 vtkCellArray(__vtkmodules_vtkCommonCore.vtkObject): """ vtkCellArray - object to represent cell connectivity Superclass: vtkObject vtkCellArray stores dataset topologies as an explicit connectivity table listing the point ids that make up each cell. Internally, the connectivity table is represented as two arrays: Offsets and Connectivity. Offsets is an array of [numCells+1] values indicating the index in the Connectivity array where each cell's points start. The last value is always the length of the Connectivity array. The Connectivity array stores the lists of point ids for each cell. Thus, for a dataset consisting of 2 triangles, a quad, and a line, the internal arrays will appear as follows: ``` Topology: --------- Cell 0: Triangle | point ids: {0, 1, 2} Cell 1: Triangle | point ids: {5, 7, 2} Cell 2: Quad | point ids: {3, 4, 6, 7} Cell 4: Line | point ids: {5, 8} vtkCellArray (current): ----------------------- Offsets: {0, 3, 6, 10, 12} Connectivity: {0, 1, 2, 5, 7, 2, 3, 4, 6, 7, 5, 8} ``` While this class provides traversal methods (the legacy InitTraversal(), GetNextCell() methods, and the newer method GetCellAtId()) these are in general not thread-safe. Whenever possible it is preferable to use a local thread-safe, vtkCellArrayIterator object, which can be obtained via: ``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator()); for (iter->GoToFirstCell(); !iter->IsDoneWithTraversal(); iter->GoToNextCell()) { // do work with iter } ``` (Note however that depending on the type and structure of internal storage, a cell array iterator may be significantly slower than direct traversal over the cell array due to extra data copying. Factors of 3-4X are not uncommon. See vtkCellArrayIterator for more information. Also note that an iterator may become invalid if the internal vtkCellArray storage is modified.) Other methods are also available for allocation and memory-related management; insertion of new cells into the vtkCellArray; and limited editing operations such as replacing one cell with a new cell of the same size. The internal arrays may store either 32- or 64-bit values, though most of the API will prefer to use vtkIdType to refer to items in these arrays. This enables significant memory savings when vtkIdType is 64-bit, but 32 bits are sufficient to store all of the values in the connectivity table. Using 64-bit storage with a 32-bit vtkIdType is permitted, but values too large to fit in a 32-bit signed integer will be truncated when accessed through the API. (The particular internal storage type has implications on performance depending on vtkIdType. If the internal storage is equivalent to vtkIdType, then methods that return pointers to arrays of point ids can share the internal storage; otherwise a copy of internal memory must be performed.) Methods for managing the storage type are: - `bool IsStorage64Bit()` - `bool IsStorageShareable() // Can pointers to internal storage be shared` - `void Use32BitStorage()` - `void Use64BitStorage()` - `void UseDefaultStorage() // Depends on vtkIdType` - `bool CanConvertTo32BitStorage()` - `bool CanConvertTo64BitStorage()` - `bool CanConvertToDefaultStorage() // Depends on vtkIdType` - `bool ConvertTo32BitStorage()` - `bool ConvertTo64BitStorage()` - `bool ConvertToDefaultStorage() // Depends on vtkIdType` - `bool ConvertToSmallestStorage() // Depends on current values in arrays` Note that some legacy methods are still available that reflect the previous storage format of this data, which embedded the cell sizes into the Connectivity array: ``` vtkCellArray (legacy): ---------------------- Connectivity: {3, 0, 1, 2, 3, 5, 7, 2, 4, 3, 4, 6, 7, 2, 5, 8} |--Cell 0--||--Cell 1--||----Cell 2---||--C3-| ``` The methods require an external lookup table to allow random access, which was historically stored in the vtkCellTypes object. The following methods in vtkCellArray still support this style of indexing for compatibility purposes, but these are slow as they must perform some complex computations to convert the old "location" into the new "offset" and should be avoided. These methods (and their modern equivalents) are: - GetCell (Prefer GetCellAtId) - GetInsertLocation (Prefer GetNumberOfCells) - GetTraversalLocation (Prefer GetTraversalCellId, or better, NewIterator) - SetTraversalLocation (Prefer SetTraversalLocation, or better, NewIterator) - ReverseCell (Prefer ReverseCellAtId) - ReplaceCell (Prefer ReplaceCellAtId) - SetCells (Use ImportLegacyFormat, or SetData) - GetData (Use ExportLegacyFormat, or Get[Offsets|Connectivity]Array[|32|64]) Some other legacy methods were completely removed, such as GetPointer() / WritePointer(), since they are cannot be effectively emulated under the current design. If external code needs to support both the old and new version of the vtkCellArray API, the VTK_CELL_ARRAY_V2 preprocessor definition may be used to detect which API is being compiled against. @sa vtkCellTypes vtkCellLinks """ def Allocate(self, sz, ext=1000): # real signature unknown; restored from __doc__ """ Allocate(self, sz:int, ext:int=1000) -> int C++: vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext=1000) Allocate memory. This currently allocates both the offsets and connectivity arrays to sz. ote It is preferable to use AllocateEstimate(numCells, maxCellSize) or AllocateExact(numCells, connectivitySize) instead. """ return 0 def AllocateCopy(self, other): # real signature unknown; restored from __doc__ """ AllocateCopy(self, other:vtkCellArray) -> bool C++: bool AllocateCopy(vtkCellArray *other) Pre-allocate memory in internal data structures to match the used size of the input vtkCellArray. Does not change the number of cells, only the array capacities. Existing data is NOT preserved. @param other The vtkCellArray to use as a reference. @return True if allocation succeeds. @sa Squeeze AllocateEstimate AllocateExact """ return False 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 AllocateExact AllocateCopy """ 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 AllocateEstimate AllocateCopy """ return False def Append(self, src, pointOffset=0): # real signature unknown; restored from __doc__ """ Append(self, src:vtkCellArray, pointOffset:int=0) -> None C++: void Append(vtkCellArray *src, vtkIdType pointOffset=0) Append cells from src into this. Point ids are offset by pointOffset. """ pass def AppendLegacyFormat(self, data, ptOffset=0): # real signature unknown; restored from __doc__ """ AppendLegacyFormat(self, data:vtkIdTypeArray, ptOffset:int=0) -> None C++: void AppendLegacyFormat(vtkIdTypeArray *data, vtkIdType ptOffset=0) AppendLegacyFormat(self, data:(int, ...), len:int, ptOffset:int=0) -> None C++: void AppendLegacyFormat(const vtkIdType *data, vtkIdType len, vtkIdType ptOffset=0) """ pass def CanConvertTo32BitStorage(self): # real signature unknown; restored from __doc__ """ CanConvertTo32BitStorage(self) -> bool C++: bool CanConvertTo32BitStorage() """ return False def CanConvertTo64BitStorage(self): # real signature unknown; restored from __doc__ """ CanConvertTo64BitStorage(self) -> bool C++: bool CanConvertTo64BitStorage() """ return False def CanConvertToDefaultStorage(self): # real signature unknown; restored from __doc__ """ CanConvertToDefaultStorage(self) -> bool C++: bool CanConvertToDefaultStorage() """ return False def ConvertTo32BitStorage(self): # real signature unknown; restored from __doc__ """ ConvertTo32BitStorage(self) -> bool C++: bool ConvertTo32BitStorage() """ return False def ConvertTo64BitStorage(self): # real signature unknown; restored from __doc__ """ ConvertTo64BitStorage(self) -> bool C++: bool ConvertTo64BitStorage() """ return False def ConvertToDefaultStorage(self): # real signature unknown; restored from __doc__ """ ConvertToDefaultStorage(self) -> bool C++: bool ConvertToDefaultStorage() """ return False def ConvertToSmallestStorage(self): # real signature unknown; restored from __doc__ """ ConvertToSmallestStorage(self) -> bool C++: bool ConvertToSmallestStorage() """ return False def DeepCopy(self, ca): # real signature unknown; restored from __doc__ """ DeepCopy(self, ca:vtkCellArray) -> None C++: void DeepCopy(vtkCellArray *ca) Perform a deep copy (no reference counting) of the given cell array. """ pass def EstimateSize(self, numCells, maxPtsPerCell): # real signature unknown; restored from __doc__ """ EstimateSize(self, numCells:int, maxPtsPerCell:int) -> int C++: vtkIdType EstimateSize(vtkIdType numCells, int maxPtsPerCell) Utility routines help manage memory of cell array. EstimateSize() returns a value used to initialize and allocate memory for array based on number of cells and maximum number of points making up cell. If every cell is the same size (in terms of number of points), then the memory estimate is guaranteed exact. (If not exact, use Squeeze() to reclaim any extra memory.) ote This method was often misused (e.g. called alone and then discarding the result). Use AllocateEstimate directly instead. """ return 0 def ExportLegacyFormat(self, data): # real signature unknown; restored from __doc__ """ ExportLegacyFormat(self, data:vtkIdTypeArray) -> None C++: void ExportLegacyFormat(vtkIdTypeArray *data) Fill data with the old-style vtkCellArray data layout, e.g. ``` { n0, p0_0, p0_1, ..., p0_n, n1, p1_0, p1_1, ..., p1_n, ... } ``` where `n0` is the number of points in cell 0, and `pX_Y` is the Y'th point in cell X. """ pass def GetActualMemorySize(self): # real signature unknown; restored from __doc__ """ GetActualMemorySize(self) -> int C++: unsigned long GetActualMemorySize() Return the memory in kibibytes (1024 bytes) consumed by this cell array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated. """ return 0 def GetCell(self, loc, npts, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCell(self, loc:int, npts:int, pts:(int, ...)) -> None C++: void GetCell(vtkIdType loc, vtkIdType &npts, const vtkIdType *&pts) GetCell(self, loc:int, pts:vtkIdList) -> None C++: void GetCell(vtkIdType loc, vtkIdList *pts) Internal method used to retrieve a cell given a legacy offset location. @warning Subsequent calls to this method may invalidate previous call results. ote The location-based API is now a super-slow compatibility layer. Prefer GetCellAtId. """ pass def GetCellAtId(self, cellId, cellSize, cellPoints, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...)) -> None C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints) GetCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...), ptIds:vtkIdList) -> None C++: void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints, vtkIdList *ptIds) GetCellAtId(self, cellId:int, pts:vtkIdList) -> None C++: void GetCellAtId(vtkIdType cellId, vtkIdList *pts) Return the point ids for the cell at cellId. @warning Subsequent calls to this method may invalidate previous call results if the internal storage type is not the same as vtkIdType and cannot be shared through the cellPoints pointer. In other words, the method may not be thread safe. Check if shareable (using IsStorageShareable()), or use a vtkCellArrayIterator to guarantee thread safety. """ pass def GetCellSize(self, cellId): # real signature unknown; restored from __doc__ """ GetCellSize(self, cellId:int) -> int C++: vtkIdType GetCellSize(const vtkIdType cellId) Return the size of the cell at cellId. """ return 0 def GetConnectivityArray(self): # real signature unknown; restored from __doc__ """ GetConnectivityArray(self) -> vtkDataArray C++: vtkDataArray *GetConnectivityArray() """ pass def GetConnectivityArray32(self): # real signature unknown; restored from __doc__ """ GetConnectivityArray32(self) -> vtkTypeInt32Array C++: ArrayType32 *GetConnectivityArray32() """ pass def GetConnectivityArray64(self): # real signature unknown; restored from __doc__ """ GetConnectivityArray64(self) -> vtkTypeInt64Array C++: ArrayType64 *GetConnectivityArray64() """ pass def GetData(self): # real signature unknown; restored from __doc__ """ GetData(self) -> vtkIdTypeArray C++: vtkIdTypeArray *GetData() Return the underlying data as a data array. @warning The returned array is not the actual internal representation used by vtkCellArray. Modifications to the returned array will not change the vtkCellArray's topology. ote Use ExportLegacyFormat, or GetOffsetsArray/GetConnectivityArray instead. """ pass def GetInsertLocation(self, npts): # real signature unknown; restored from __doc__ """ GetInsertLocation(self, npts:int) -> int C++: vtkIdType GetInsertLocation(int npts) Computes the current legacy insertion location within the internal array. Used in conjunction with GetCell(int loc,...). ote The location-based API is now a super-slow compatibility layer. """ return 0 def GetMaxCellSize(self): # real signature unknown; restored from __doc__ """ GetMaxCellSize(self) -> int C++: int GetMaxCellSize() Returns the size of the largest cell. The size is the number of points defining the cell. """ return 0 def GetNextCell(self, npts, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetNextCell(self, npts:int, pts:(int, ...)) -> int C++: int GetNextCell(vtkIdType &npts, vtkIdType const *&pts) GetNextCell(self, pts:vtkIdList) -> int C++: int GetNextCell(vtkIdList *pts) @warning This method is not thread-safe. Consider using the NewIterator() iterator instead. GetNextCell() gets the next cell in the list. If end of list is encountered, 0 is returned. A value of 1 is returned whenever npts and pts have been updated without error. Do not modify the returned pts pointer, as it may point to shared memory. ote This method is not thread-safe and has tricky syntax to use correctly. Prefer the use of vtkCellArrayIterator (see NewIterator()). """ pass def GetNumberOfCells(self): # real signature unknown; restored from __doc__ """ GetNumberOfCells(self) -> int C++: vtkIdType GetNumberOfCells() Get the number of cells in the array. """ return 0 def GetNumberOfConnectivityEntries(self): # real signature unknown; restored from __doc__ """ GetNumberOfConnectivityEntries(self) -> int C++: vtkIdType GetNumberOfConnectivityEntries() Return the size of the array that would be returned from ExportLegacyFormat(). ote Method incompatible with current internal storage. """ return 0 def GetNumberOfConnectivityIds(self): # real signature unknown; restored from __doc__ """ GetNumberOfConnectivityIds(self) -> int C++: vtkIdType GetNumberOfConnectivityIds() Get the size of the connectivity array that stores the point ids. ote Do not confuse this with the deprecated GetNumberOfConnectivityEntries(), which refers to the legacy memory layout. """ 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 GetNumberOfOffsets(self): # real signature unknown; restored from __doc__ """ GetNumberOfOffsets(self) -> int C++: vtkIdType GetNumberOfOffsets() Get the number of elements in the offsets array. This will be the number of cells + 1. """ return 0 def GetOffset(self, cellId): # real signature unknown; restored from __doc__ """ GetOffset(self, cellId:int) -> int C++: vtkIdType GetOffset(vtkIdType cellId) Get the offset (into the connectivity) for a specified cell id. """ return 0 def GetOffsetsArray(self): # real signature unknown; restored from __doc__ """ GetOffsetsArray(self) -> vtkDataArray C++: vtkDataArray *GetOffsetsArray() """ pass def GetOffsetsArray32(self): # real signature unknown; restored from __doc__ """ GetOffsetsArray32(self) -> vtkTypeInt32Array C++: ArrayType32 *GetOffsetsArray32() """ pass def GetOffsetsArray64(self): # real signature unknown; restored from __doc__ """ GetOffsetsArray64(self) -> vtkTypeInt64Array C++: ArrayType64 *GetOffsetsArray64() """ pass def GetSize(self): # real signature unknown; restored from __doc__ """ GetSize(self) -> int C++: vtkIdType GetSize() Get the size of the allocated connectivity array. @warning This returns the allocated capacity of the internal arrays as a number of elements, NOT the number of elements in use. ote Method incompatible with current internal storage. """ return 0 def GetTraversalCellId(self): # real signature unknown; restored from __doc__ """ GetTraversalCellId(self) -> int C++: vtkIdType GetTraversalCellId() """ return 0 def GetTraversalLocation(self): # real signature unknown; restored from __doc__ """ GetTraversalLocation(self) -> int C++: vtkIdType GetTraversalLocation() GetTraversalLocation(self, npts:int) -> int C++: vtkIdType GetTraversalLocation(vtkIdType npts) """ return 0 def ImportLegacyFormat(self, data): # real signature unknown; restored from __doc__ """ ImportLegacyFormat(self, data:vtkIdTypeArray) -> None C++: void ImportLegacyFormat(vtkIdTypeArray *data) ImportLegacyFormat(self, data:(int, ...), len:int) -> None C++: void ImportLegacyFormat(const vtkIdType *data, vtkIdType len) """ pass def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() Free any memory and reset to an empty state. """ pass def InitTraversal(self): # real signature unknown; restored from __doc__ """ InitTraversal(self) -> None C++: void InitTraversal() @warning This method is not thread-safe. Consider using the NewIterator() iterator instead. InitTraversal() initializes the traversal of the list of cells. ote This method is not thread-safe and has tricky syntax to use correctly. Prefer the use of vtkCellArrayIterator (see NewIterator()). """ pass def InsertCellPoint(self, id): # real signature unknown; restored from __doc__ """ InsertCellPoint(self, id:int) -> None C++: void InsertCellPoint(vtkIdType id) Used in conjunction with InsertNextCell(npts) to add another point to the list of cells. """ pass def InsertNextCell(self, cell): # real signature unknown; restored from __doc__ """ InsertNextCell(self, cell:vtkCell) -> int C++: vtkIdType InsertNextCell(vtkCell *cell) InsertNextCell(self, npts:int, pts:(int, ...)) -> int C++: vtkIdType InsertNextCell(vtkIdType npts, const vtkIdType *pts) InsertNextCell(self, pts:vtkIdList) -> int C++: vtkIdType InsertNextCell(vtkIdList *pts) InsertNextCell(self, npts:int) -> int C++: vtkIdType InsertNextCell(int npts) Insert a cell object. Return the cell id of the cell. """ return 0 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 IsHomogeneous(self): # real signature unknown; restored from __doc__ """ IsHomogeneous(self) -> int C++: vtkIdType IsHomogeneous() Check if all cells have the same number of vertices. The return value is coded as: * -1 = heterogeneous * 0 = Cell array empty * n (positive integer) = homogeneous array of cell size n """ return 0 def IsStorage64Bit(self): # real signature unknown; restored from __doc__ """ IsStorage64Bit(self) -> bool C++: bool IsStorage64Bit() @return True if the internal storage is using 64 bit arrays. If false, the storage is using 32 bit arrays. """ return False def IsStorageShareable(self): # real signature unknown; restored from __doc__ """ IsStorageShareable(self) -> bool C++: bool IsStorageShareable() @return True if the internal storage can be shared as a pointer to vtkIdType, i.e., the type and organization of internal storage is such that copying of data can be avoided, and instead a pointer to vtkIdType can be used. """ 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 IsValid(self): # real signature unknown; restored from __doc__ """ IsValid(self) -> bool C++: bool IsValid() Check that internal storage is consistent and in a valid state. Specifically, this function returns true if and only if: - The offset and connectivity arrays have exactly one component. - The offset array has at least one value and starts at 0. - The offset array values never decrease. - The connectivity array has as many entries as the last value in the offset array. """ return False def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkCellArray C++: vtkCellArray *NewInstance() """ return vtkCellArray def NewIterator(self): # real signature unknown; restored from __doc__ """ NewIterator(self) -> vtkCellArrayIterator C++: vtkCellArrayIterator *NewIterator() NewIterator returns a new instance of vtkCellArrayIterator that is initialized to point at the first cell's data. The caller is responsible for Delete()'ing the object. """ return vtkCellArrayIterator def ReplaceCell(self, loc, npts, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ ReplaceCell(self, loc:int, npts:int, pts:(int, ...)) -> None C++: void ReplaceCell(vtkIdType loc, int npts, const vtkIdType pts[]) Replace the point ids of the cell at the legacy location with a different list of point ids. Calling this method does not mark the vtkCellArray as modified. This is the responsibility of the caller and may be done after multiple calls to ReplaceCell. This call does not support changing the number of points in the cell -- the caller must ensure that the target cell has npts points. ote The location-based API is now a super-slow compatibility layer. Prefer ReplaceCellAtId. """ pass def ReplaceCellAtId(self, cellId, p_list): # real signature unknown; restored from __doc__ """ ReplaceCellAtId(self, cellId:int, list:vtkIdList) -> None C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdList *list) ReplaceCellAtId(self, cellId:int, cellSize:int, cellPoints:(int, ...)) -> None C++: void ReplaceCellAtId(vtkIdType cellId, vtkIdType cellSize, const vtkIdType *cellPoints) """ pass def Reset(self): # real signature unknown; restored from __doc__ """ Reset(self) -> None C++: void Reset() Reuse list. Reset to initial state without freeing memory. """ pass def ResizeExact(self, numCells, connectivitySize): # real signature unknown; restored from __doc__ """ ResizeExact(self, numCells:int, connectivitySize:int) -> bool C++: bool ResizeExact(vtkIdType numCells, vtkIdType connectivitySize) ResizeExact() resizes the internal structures to hold numCells total cell offsets and connectivitySize total pointIds. Old data is preserved, and newly-available memory is not initialized. @warning For advanced use only. You probably want an Allocate method. @return True if allocation succeeds. """ return False def ReverseCell(self, loc): # real signature unknown; restored from __doc__ """ ReverseCell(self, loc:int) -> None C++: void ReverseCell(vtkIdType loc) Special method inverts ordering of cell at the specified legacy location. Must be called carefully or the cell topology may be corrupted. ote The location-based API is now a super-slow compatibility layer. Prefer ReverseCellAtId; """ pass def ReverseCellAtId(self, cellId): # real signature unknown; restored from __doc__ """ ReverseCellAtId(self, cellId:int) -> None C++: void ReverseCellAtId(vtkIdType cellId) Reverses the order of the point ids for the specified cell. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCellArray C++: static vtkCellArray *SafeDownCast(vtkObjectBase *o) """ return vtkCellArray def SetCells(self, ncells, cells): # real signature unknown; restored from __doc__ """ SetCells(self, ncells:int, cells:vtkIdTypeArray) -> None C++: void SetCells(vtkIdType ncells, vtkIdTypeArray *cells) Define multiple cells by providing a connectivity list. The list is in the form (npts,p0,p1,...p(npts-1), repeated for each cell). Be careful using this method because it discards the old cells, and anything referring these cells becomes invalid (for example, if BuildCells() has been called see vtkPolyData). The traversal location is reset to the beginning of the list; the insertion location is set to the end of the list. @warning The vtkCellArray will not hold a reference to `cells`. This function merely calls ImportLegacyFormat. ote Use ImportLegacyFormat or SetData instead. """ pass def SetData(self, offsets, connectivity): # real signature unknown; restored from __doc__ """ SetData(self, offsets:vtkDataArray, connectivity:vtkDataArray) -> bool C++: bool SetData(vtkDataArray *offsets, vtkDataArray *connectivity) SetData(self, cellSize:int, connectivity:vtkDataArray) -> bool C++: bool SetData(vtkIdType cellSize, vtkDataArray *connectivity) Sets the internal arrays to the supplied offsets and connectivity arrays. This is a convenience method, and may fail if the following conditions are not met: - Both arrays must be of the same type. - The array type must be one of the types in InputArrayList. If invalid arrays are passed in, an error is logged and the function will return false. """ return False def SetNumberOfCells(self, __a): # real signature unknown; restored from __doc__ """ SetNumberOfCells(self, __a:int) -> None C++: virtual void SetNumberOfCells(vtkIdType) Set the number of cells in the array. DO NOT do any kind of allocation, advanced use only. ote This call has no effect. """ pass def SetTraversalCellId(self, cellId): # real signature unknown; restored from __doc__ """ SetTraversalCellId(self, cellId:int) -> None C++: void SetTraversalCellId(vtkIdType cellId) """ pass def SetTraversalLocation(self, loc): # real signature unknown; restored from __doc__ """ SetTraversalLocation(self, loc:int) -> None C++: void SetTraversalLocation(vtkIdType loc) """ pass def ShallowCopy(self, ca): # real signature unknown; restored from __doc__ """ ShallowCopy(self, ca:vtkCellArray) -> None C++: void ShallowCopy(vtkCellArray *ca) Shallow copy ca into this cell array. """ pass def Squeeze(self): # real signature unknown; restored from __doc__ """ Squeeze(self) -> None C++: void Squeeze() Reclaim any extra memory while preserving data. @sa ConvertToSmallestStorage """ pass def UpdateCellCount(self, npts): # real signature unknown; restored from __doc__ """ UpdateCellCount(self, npts:int) -> None C++: void UpdateCellCount(int npts) Used in conjunction with InsertNextCell(int npts) and InsertCellPoint() to update the number of points defining the cell. """ pass def Use32BitStorage(self): # real signature unknown; restored from __doc__ """ Use32BitStorage(self) -> None C++: void Use32BitStorage() """ pass def Use64BitStorage(self): # real signature unknown; restored from __doc__ """ Use64BitStorage(self) -> None C++: void Use64BitStorage() """ pass def UseDefaultStorage(self): # real signature unknown; restored from __doc__ """ UseDefaultStorage(self) -> None C++: void UseDefaultStorage() """ 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, current): # real signature unknown; restored from __doc__ 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__\': \'vtkCellArray\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Allocate\': , \'AllocateEstimate\': , \'AllocateExact\': , \'AllocateCopy\': , \'ResizeExact\': , \'Initialize\': , \'Reset\': , \'Squeeze\': , \'IsValid\': , \'GetNumberOfCells\': , \'GetNumberOfOffsets\': , \'GetOffset\': , \'GetNumberOfConnectivityIds\': , \'NewIterator\': , \'SetData\': , \'IsStorage64Bit\': , \'IsStorageShareable\': , \'Use32BitStorage\': , \'Use64BitStorage\': , \'UseDefaultStorage\': , \'CanConvertTo32BitStorage\': , \'CanConvertTo64BitStorage\': , \'CanConvertToDefaultStorage\': , \'ConvertTo32BitStorage\': , \'ConvertTo64BitStorage\': , \'ConvertToDefaultStorage\': , \'ConvertToSmallestStorage\': , \'GetOffsetsArray\': , \'GetOffsetsArray32\': , \'GetOffsetsArray64\': , \'GetConnectivityArray\': , \'GetConnectivityArray32\': , \'GetConnectivityArray64\': , \'IsHomogeneous\': , \'InitTraversal\': , \'GetNextCell\': , \'GetCellAtId\': , \'GetCellSize\': , \'InsertNextCell\': , \'InsertCellPoint\': , \'UpdateCellCount\': , \'GetTraversalCellId\': , \'SetTraversalCellId\': , \'ReverseCellAtId\': , \'ReplaceCellAtId\': , \'GetMaxCellSize\': , \'DeepCopy\': , \'ShallowCopy\': , \'Append\': , \'ExportLegacyFormat\': , \'ImportLegacyFormat\': , \'AppendLegacyFormat\': , \'GetActualMemorySize\': , \'SetNumberOfCells\': , \'EstimateSize\': , \'GetSize\': , \'GetNumberOfConnectivityEntries\': , \'GetCell\': , \'GetInsertLocation\': , \'GetTraversalLocation\': , \'SetTraversalLocation\': , \'ReverseCell\': , \'ReplaceCell\': , \'SetCells\': , \'GetData\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkCellArray - object to represent cell connectivity\\n\\nSuperclass: vtkObject\\n\\nvtkCellArray stores dataset topologies as an explicit connectivity\\ntable listing the point ids that make up each cell.\\n\\nInternally, the connectivity table is represented as two arrays:\\nOffsets and Connectivity.\\n\\nOffsets is an array of [numCells+1] values indicating the index in\\nthe Connectivity array where each cell\\\'s points start. The last value\\nis always the length of the Connectivity array.\\n\\nThe Connectivity array stores the lists of point ids for each cell.\\n\\nThus, for a dataset consisting of 2 triangles, a quad, and a line,\\nthe internal arrays will appear as follows:\\n\\n``` Topology:\\n--------- Cell 0: Triangle | point ids: {0, 1, 2} Cell 1: Triangle |\\n point ids: {5, 7, 2} Cell 2: Quad | point ids: {3, 4, 6, 7}\\n Cell 4: Line | point ids: {5, 8}\\n\\nvtkCellArray (current):\\n----------------------- Offsets: {0, 3, 6, 10, 12} Connectivity:\\n{0, 1, 2, 5, 7, 2, 3, 4, 6, 7, 5, 8} ```\\n\\nWhile this class provides traversal methods (the legacy\\nInitTraversal(), GetNextCell() methods, and the newer method\\nGetCellAtId()) these are in general not thread-safe. Whenever\\npossible it is preferable to use a local thread-safe,\\nvtkCellArrayIterator object, which can be obtained via:\\n\\n``` auto iter = vtk::TakeSmartPointer(cellArray->NewIterator()); for\\n(iter->GoToFirstCell(); !iter->IsDoneWithTraversal();\\niter->GoToNextCell()) {\\n // do work with iter } ``` (Note however that depending on the type\\nand structure of internal storage, a cell array iterator may be\\nsignificantly slower than direct traversal over the cell array due to\\nextra data copying. Factors of 3-4X are not uncommon. See\\nvtkCellArrayIterator for more information. Also note that an iterator\\nmay become invalid if the internal vtkCellArray storage is modified.)\\n\\nOther methods are also available for allocation and memory-related\\nmanagement; insertion of new cells into the vtkCellArray; and limited\\nediting operations such as replacing one cell with a new cell of the\\nsame size.\\n\\nThe internal arrays may store either 32- or 64-bit values, though\\nmost of the API will prefer to use vtkIdType to refer to items in\\nthese arrays. This enables significant memory savings when vtkIdType\\nis 64-bit, but 32 bits are sufficient to store all of the values in\\nthe connectivity table. Using 64-bit storage with a 32-bit vtkIdType\\nis permitted, but values too large to fit in a 32-bit signed integer\\nwill be truncated when accessed through the API. (The particular\\ninternal storage type has implications on performance depending on\\nvtkIdType. If the internal storage is equivalent to vtkIdType, then\\nmethods that return pointers to arrays of point ids can share the\\ninternal storage; otherwise a copy of internal memory must be\\nperformed.)\\n\\nMethods for managing the storage type are:\\n\\n- `bool IsStorage64Bit()`\\n- `bool IsStorageShareable() // Can pointers to internal storage be\\n shared`\\n- `void Use32BitStorage()`\\n- `void Use64BitStorage()`\\n- `void UseDefaultStorage() // Depends on vtkIdType`\\n- `bool CanConvertTo32BitStorage()`\\n- `bool CanConvertTo64BitStorage()`\\n- `bool CanConvertToDefaultStorage() // Depends on vtkIdType`\\n- `bool ConvertTo32BitStorage()`\\n- `bool ConvertTo64BitStorage()`\\n- `bool ConvertToDefaultStorage() // Depends on vtkIdType`\\n- `bool ConvertToSmallestStorage() // Depends on current values in\\n arrays`\\n\\nNote that some legacy methods are still available that reflect the\\nprevious storage format of this data, which embedded the cell sizes\\ninto the Connectivity array:\\n\\n``` vtkCellArray (legacy):\\n---------------------- Connectivity: {3, 0, 1, 2, 3, 5, 7, 2, 4, 3,\\n 4, 6, 7, 2, 5, 8} |--Cell 0--||--Cell 1--||----Cell 2---||--C3-|\\n ```\\n\\nThe methods require an external lookup table to allow random access,\\nwhich was historically stored in the vtkCellTypes object. The\\nfollowing methods in vtkCellArray still support this style of\\nindexing for compatibility purposes, but these are slow as they must\\nperform some complex computations to convert the old "location" into\\nthe new "offset" and should be avoided. These methods (and their\\nmodern equivalents) are:\\n\\n- GetCell (Prefer GetCellAtId)\\n- GetInsertLocation (Prefer GetNumberOfCells)\\n- GetTraversalLocation (Prefer GetTraversalCellId, or better,\\n NewIterator)\\n- SetTraversalLocation (Prefer SetTraversalLocation, or better,\\n NewIterator)\\n- ReverseCell (Prefer ReverseCellAtId)\\n- ReplaceCell (Prefer ReplaceCellAtId)\\n- SetCells (Use ImportLegacyFormat, or SetData)\\n- GetData (Use ExportLegacyFormat, or\\n Get[Offsets|Connectivity]Array[|32|64])\\n\\nSome other legacy methods were completely removed, such as\\nGetPointer() / WritePointer(), since they are cannot be effectively\\nemulated under the current design. If external code needs to support\\nboth the old and new version of the vtkCellArray API, the\\nVTK_CELL_ARRAY_V2 preprocessor definition may be used to detect which\\nAPI is being compiled against.\\n\\n@sa vtkCellTypes vtkCellLinks\\n\\n\'})' __vtkname__ = 'vtkCellArray'