# encoding: utf-8 # module vtkmodules.vtkInfovisLayout # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkInfovisLayout.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel from .vtkGraphLayoutStrategy import vtkGraphLayoutStrategy class vtkSpanTreeLayoutStrategy(vtkGraphLayoutStrategy): """ vtkSpanTreeLayoutStrategy - vtkSpanTreeLayout is a strategy for drawing directed graphs that works by first extracting a spanning tree (more accurately, a spanning forest), and using this both to position graph vertices and to plan the placement of non Superclass: vtkGraphLayoutStrategy -tree edges. The latter are drawn with the aid of edge points to produce a tidy drawing. The approach is best suited to "quasi-trees", graphs where the number of edges is of the same order as the number of nodes; it is less well suited to denser graphs. The boolean flag DepthFirstSpanningTree determines whether a depth-first or breadth-first strategy is used to construct the underlying forest, and the choice of strategy affects the output layout significantly. Informal experiments suggest that the breadth-first strategy is better for denser graphs. Different layouts could also be produced by plugging in alternative tree layout strategies. To work with the method of routing non-tree edges, any strategy should draw a tree so that levels are equally spaced along the z-axis, precluding for example the use of a radial or balloon layout. vtkSpanTreeLayout is based on an approach to 3D graph layout first developed as part of the "tulip" tool by Dr. David Auber at LaBRI, U.Bordeaux: see www.tulip-software.org This implementation departs from the original version in that: (a) it is reconstructed to use Titan/VTK data structures; (b) it uses a faster method for dealing with non-tree edges, requiring at most two edge points per edge (c) allows for plugging in different tree layout methods (d) allows selection of two different strategies for building the underlying layout tree, which can yield significantly different results depending on the data. @par Thanks: Thanks to David Duke from the University of Leeds for providing this implementation. """ def DepthFirstSpanningTreeOff(self): # real signature unknown; restored from __doc__ """ DepthFirstSpanningTreeOff(self) -> None C++: virtual void DepthFirstSpanningTreeOff() """ pass def DepthFirstSpanningTreeOn(self): # real signature unknown; restored from __doc__ """ DepthFirstSpanningTreeOn(self) -> None C++: virtual void DepthFirstSpanningTreeOn() """ pass def GetDepthFirstSpanningTree(self): # real signature unknown; restored from __doc__ """ GetDepthFirstSpanningTree(self) -> bool C++: virtual bool GetDepthFirstSpanningTree() """ return False 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 Layout(self): # real signature unknown; restored from __doc__ """ Layout(self) -> None C++: void Layout() override; Perform the layout. """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSpanTreeLayoutStrategy C++: vtkSpanTreeLayoutStrategy *NewInstance() """ return vtkSpanTreeLayoutStrategy def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSpanTreeLayoutStrategy C++: static vtkSpanTreeLayoutStrategy *SafeDownCast( vtkObjectBase *o) """ return vtkSpanTreeLayoutStrategy def SetDepthFirstSpanningTree(self, _arg): # real signature unknown; restored from __doc__ """ SetDepthFirstSpanningTree(self, _arg:bool) -> None C++: virtual void SetDepthFirstSpanningTree(bool _arg) If set, base the layout on a depth-first spanning tree, rather than the default breadth-first spanning tree. Switching between DFT and BFT may significantly change the layout, and choice must be made on a per-graph basis. Default value is off. """ 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__\': \'vtkSpanTreeLayoutStrategy\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetDepthFirstSpanningTree\': , \'GetDepthFirstSpanningTree\': , \'DepthFirstSpanningTreeOn\': , \'DepthFirstSpanningTreeOff\': , \'Layout\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkSpanTreeLayoutStrategy - vtkSpanTreeLayout is a strategy for\\ndrawing directed graphs that works by first extracting a spanning\\ntree (more accurately, a spanning forest), and using this both to\\nposition graph vertices and to plan the placement of non\\n\\nSuperclass: vtkGraphLayoutStrategy\\n\\n-tree edges. The latter are drawn with the aid of edge points to\\n produce a tidy drawing.\\n\\nThe approach is best suited to "quasi-trees", graphs where the number\\nof edges is of the same order as the number of nodes; it is less well\\nsuited to denser graphs. The boolean flag DepthFirstSpanningTree\\ndetermines whether a depth-first or breadth-first strategy is used to\\nconstruct the underlying forest, and the choice of strategy affects\\nthe output layout significantly. Informal experiments suggest that\\nthe breadth-first strategy is better for denser graphs.\\n\\nDifferent layouts could also be produced by plugging in alternative\\ntree layout strategies. To work with the method of routing non-tree\\nedges, any strategy should draw a tree so that levels are equally\\nspaced along the z-axis, precluding for example the use of a radial\\nor balloon layout.\\n\\nvtkSpanTreeLayout is based on an approach to 3D graph layout first\\ndeveloped as part of the "tulip" tool by Dr. David Auber at LaBRI,\\nU.Bordeaux: see www.tulip-software.org\\n\\nThis implementation departs from the original version in that: (a) it\\nis reconstructed to use Titan/VTK data structures; (b) it uses a\\nfaster method for dealing with non-tree edges,\\n requiring at most two edge points per edge (c) allows for\\nplugging in different tree layout methods (d) allows selection of two\\ndifferent strategies for building\\n the underlying layout tree, which can yield significantly\\n different results depending on the data.\\n\\n@par Thanks: Thanks to David Duke from the University of Leeds for\\nproviding this implementation.\\n\\n\'})' __vtkname__ = 'vtkSpanTreeLayoutStrategy'