# 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 .vtkDirectedGraph import vtkDirectedGraph class vtkMutableDirectedGraph(vtkDirectedGraph): """ vtkMutableDirectedGraph - An editable directed graph. Superclass: vtkDirectedGraph vtkMutableDirectedGraph is a directed graph which has additional methods for adding edges and vertices. AddChild() is a convenience method for constructing trees. ShallowCopy(), DeepCopy(), CheckedShallowCopy() and CheckedDeepCopy() will succeed for instances of vtkDirectedGraph, vtkMutableDirectedGraph and vtkTree. @sa vtkDirectedGraph vtkGraph vtkTree """ def AddChild(self, parent, propertyArr): # real signature unknown; restored from __doc__ """ AddChild(self, parent:int, propertyArr:vtkVariantArray) -> int C++: vtkIdType AddChild(vtkIdType parent, vtkVariantArray *propertyArr) AddChild(self, parent:int) -> int C++: vtkIdType AddChild(vtkIdType parent) Convenience method for creating trees. Returns the newly created vertex id. Shortcut forvtkIdType v = g->AddVertex(); g->AddEdge(parent, v); If non-null, propertyArr provides edge properties for the newly-created edge. The values in propertyArr must match up with the arrays in the edge data returned by GetEdgeData(). """ return 0 def AddEdge(self, u, v): # real signature unknown; restored from __doc__ """ AddEdge(self, u:int, v:int) -> vtkEdgeType C++: vtkEdgeType AddEdge(vtkIdType u, vtkIdType v) AddEdge(self, u:int, v:int, propertyArr:vtkVariantArray) -> vtkEdgeType C++: vtkEdgeType AddEdge(vtkIdType u, vtkIdType v, vtkVariantArray *propertyArr) AddEdge(self, u:vtkVariant, v:int, propertyArr:vtkVariantArray=...) -> vtkEdgeType C++: vtkEdgeType AddEdge(const vtkVariant &u, vtkIdType v, vtkVariantArray *propertyArr=nullptr) AddEdge(self, u:int, v:vtkVariant, propertyArr:vtkVariantArray=...) -> vtkEdgeType C++: vtkEdgeType AddEdge(vtkIdType u, const vtkVariant &v, vtkVariantArray *propertyArr=nullptr) AddEdge(self, u:vtkVariant, v:vtkVariant, propertyArr:vtkVariantArray=...) -> vtkEdgeType C++: vtkEdgeType AddEdge(const vtkVariant &u, const vtkVariant &v, vtkVariantArray *propertyArr=nullptr) Adds a directed edge from u to v, where u and v are vertex indices, and returns a vtkEdgeType structure describing that edge. * vtkEdgeType contains fields for Source vertex index, * Target vertex index, and edge index Id. """ return vtkEdgeType def AddGraphEdge(self, u, v): # real signature unknown; restored from __doc__ """ AddGraphEdge(self, u:int, v:int) -> vtkGraphEdge C++: vtkGraphEdge *AddGraphEdge(vtkIdType u, vtkIdType v) Variant of AddEdge() that returns a heavyweight vtkGraphEdge object. The graph owns the reference of the edge and will replace its contents on the next call to AddGraphEdge(). * ote This is a less efficient method for use with wrappers. * In C++ you should use the faster AddEdge(). """ return vtkGraphEdge def AddVertex(self): # real signature unknown; restored from __doc__ """ AddVertex(self) -> int C++: vtkIdType AddVertex() AddVertex(self, propertyArr:vtkVariantArray) -> int C++: vtkIdType AddVertex(vtkVariantArray *propertyArr) AddVertex(self, pedigreeId:vtkVariant) -> int C++: vtkIdType AddVertex(const vtkVariant &pedigreeId) Adds a vertex to the graph and returns the index of the new vertex. * ote In a distributed graph (i.e. a graph whose DistributedHelper * is non-null), this routine cannot be used to add a vertex * if the vertices in the graph have pedigree IDs, because this routine * will always add the vertex locally, which may conflict with the * proper location of the vertex based on the distribution of the * pedigree IDs. """ 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 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 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 LazyAddEdge(self, u, v, propertyArr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ LazyAddEdge(self, u:int, v:int, propertyArr:vtkVariantArray=...) -> None C++: void LazyAddEdge(vtkIdType u, vtkIdType v, vtkVariantArray *propertyArr=nullptr) LazyAddEdge(self, u:vtkVariant, v:int, propertyArr:vtkVariantArray=...) -> None C++: void LazyAddEdge(const vtkVariant &u, vtkIdType v, vtkVariantArray *propertyArr=nullptr) LazyAddEdge(self, u:int, v:vtkVariant, propertyArr:vtkVariantArray=...) -> None C++: void LazyAddEdge(vtkIdType u, const vtkVariant &v, vtkVariantArray *propertyArr=nullptr) LazyAddEdge(self, u:vtkVariant, v:vtkVariant, propertyArr:vtkVariantArray=...) -> None C++: void LazyAddEdge(const vtkVariant &u, const vtkVariant &v, vtkVariantArray *propertyArr=nullptr) Adds a directed edge from u to v, where u and v are vertex indices. * The number and order of values in the optional parameter * propertyArr must match up with the arrays in the edge data * retrieved by GetEdgeData(). * This method is lazily evaluated for distributed graphs (i.e. graphs * whose DistributedHelper is non-null) the next time Synchronize is * called on the helper. """ pass def LazyAddVertex(self): # real signature unknown; restored from __doc__ """ LazyAddVertex(self) -> None C++: void LazyAddVertex() LazyAddVertex(self, propertyArr:vtkVariantArray) -> None C++: void LazyAddVertex(vtkVariantArray *propertyArr) LazyAddVertex(self, pedigreeId:vtkVariant) -> None C++: void LazyAddVertex(const vtkVariant &pedigreeId) Adds a vertex to the graph. * This method is lazily evaluated for distributed graphs (i.e. graphs * whose DistributedHelper is non-null) the next time Synchronize is * called on the helper. """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkMutableDirectedGraph C++: vtkMutableDirectedGraph *NewInstance() """ return vtkMutableDirectedGraph def RemoveEdge(self, e): # real signature unknown; restored from __doc__ """ RemoveEdge(self, e:int) -> None C++: void RemoveEdge(vtkIdType e) Removes the edge from the graph. Note: This invalidates the last edge index, which is reassigned to e. """ pass def RemoveEdges(self, arr): # real signature unknown; restored from __doc__ """ RemoveEdges(self, arr:vtkIdTypeArray) -> None C++: void RemoveEdges(vtkIdTypeArray *arr) Removes a collection of edges from the graph. """ pass def RemoveVertex(self, v): # real signature unknown; restored from __doc__ """ RemoveVertex(self, v:int) -> None C++: void RemoveVertex(vtkIdType v) Removes the vertex from the graph along with any connected edges. Note: This invalidates the last vertex index, which is reassigned to v. """ pass def RemoveVertices(self, arr): # real signature unknown; restored from __doc__ """ RemoveVertices(self, arr:vtkIdTypeArray) -> None C++: void RemoveVertices(vtkIdTypeArray *arr) Removes a collection of vertices from the graph along with any connected edges. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkMutableDirectedGraph C++: static vtkMutableDirectedGraph *SafeDownCast( vtkObjectBase *o) """ return vtkMutableDirectedGraph def SetNumberOfVertices(self, numVerts): # real signature unknown; restored from __doc__ """ SetNumberOfVertices(self, numVerts:int) -> int C++: virtual vtkIdType SetNumberOfVertices(vtkIdType numVerts) Allocates space for the specified number of vertices in the graph's internal data structures. * This has no effect on the number of vertex coordinate tuples or * vertex attribute tuples allocated; you are responsible for * guaranteeing these match. * Also, this call is not implemented for distributed-memory graphs since * the semantics are unclear; calling this function on a graph with a * non-nullptr DistributedGraphHelper will generate an error message and * no allocation will be performed. """ return 0 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__': 'vtkMutableDirectedGraph', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetNumberOfVertices': , 'AddVertex': , 'AddEdge': , 'LazyAddVertex': , 'LazyAddEdge': , 'AddGraphEdge': , 'AddChild': , 'RemoveVertex': , 'RemoveEdge': , 'RemoveVertices': , 'RemoveEdges': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkMutableDirectedGraph - An editable directed graph.\\n\\nSuperclass: vtkDirectedGraph\\n\\nvtkMutableDirectedGraph is a directed graph which has additional\\nmethods for adding edges and vertices. AddChild() is a convenience\\nmethod for constructing trees. ShallowCopy(), DeepCopy(),\\nCheckedShallowCopy() and CheckedDeepCopy() will succeed for instances\\nof vtkDirectedGraph, vtkMutableDirectedGraph and vtkTree.\\n\\n@sa\\nvtkDirectedGraph vtkGraph vtkTree\\n\\n'})" __vtkname__ = 'vtkMutableDirectedGraph'