# 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 vtkSimple3DCirclesStrategy(vtkGraphLayoutStrategy): """ vtkSimple3DCirclesStrategy - places vertices on circles in 3D Superclass: vtkGraphLayoutStrategy Places vertices on circles depending on the graph vertices hierarchy level. The source graph could be vtkDirectedAcyclicGraph or vtkDirectedGraph if MarkedStartPoints array was added. The algorithm collects the standalone points, too and take them to a separated circle. If method is FixedRadiusMethod, the radius of the circles will be equal. If method is FixedDistanceMethod, the distance between the points on circles will be equal. In first step initial points are searched. A point is initial, if its in degree equal zero and out degree is greater than zero (or marked by MarkedStartVertices and out degree is greater than zero). Independent vertices (in and out degree equal zero) are collected separatelly. In second step the hierarchical level is generated for every vertex. In third step the hierarchical order is generated. If a vertex has no hierarchical level and it is not independent, the graph has loop so the algorithm exit with error message. Finally the vertices positions are calculated by the hierarchical order and by the vertices hierarchy levels. @par Thanks: Ferenc Nasztanovics, naszta aszta.hu, Budapest University of Technology and Economics, Department of Structural Mechanics @par References: in 3D rotation was used: http://en.citizendium.org/wiki/Rotation_matrix """ def AutoHeightOff(self): # real signature unknown; restored from __doc__ """ AutoHeightOff(self) -> None C++: virtual void AutoHeightOff() """ pass def AutoHeightOn(self): # real signature unknown; restored from __doc__ """ AutoHeightOn(self) -> None C++: virtual void AutoHeightOn() """ pass def ForceToUseUniversalStartPointsFinderOff(self): # real signature unknown; restored from __doc__ """ ForceToUseUniversalStartPointsFinderOff(self) -> None C++: virtual void ForceToUseUniversalStartPointsFinderOff() """ pass def ForceToUseUniversalStartPointsFinderOn(self): # real signature unknown; restored from __doc__ """ ForceToUseUniversalStartPointsFinderOn(self) -> None C++: virtual void ForceToUseUniversalStartPointsFinderOn() """ pass def GetAutoHeight(self): # real signature unknown; restored from __doc__ """ GetAutoHeight(self) -> int C++: virtual vtkTypeBool GetAutoHeight() """ return 0 def GetDirection(self): # real signature unknown; restored from __doc__ """ GetDirection(self) -> (float, float, float) C++: virtual double *GetDirection() """ pass def GetForceToUseUniversalStartPointsFinder(self): # real signature unknown; restored from __doc__ """ GetForceToUseUniversalStartPointsFinder(self) -> int C++: virtual vtkTypeBool GetForceToUseUniversalStartPointsFinder() """ return 0 def GetHeight(self): # real signature unknown; restored from __doc__ """ GetHeight(self) -> float C++: virtual double GetHeight() """ return 0.0 def GetHierarchicalLayers(self): # real signature unknown; restored from __doc__ """ GetHierarchicalLayers(self) -> vtkIntArray C++: virtual vtkIntArray *GetHierarchicalLayers() """ pass def GetHierarchicalOrder(self): # real signature unknown; restored from __doc__ """ GetHierarchicalOrder(self) -> vtkIdTypeArray C++: virtual vtkIdTypeArray *GetHierarchicalOrder() """ pass def GetMarkedStartVertices(self): # real signature unknown; restored from __doc__ """ GetMarkedStartVertices(self) -> vtkAbstractArray C++: virtual vtkAbstractArray *GetMarkedStartVertices() """ pass def GetMarkedValue(self): # real signature unknown; restored from __doc__ """ GetMarkedValue(self) -> vtkVariant C++: virtual vtkVariant GetMarkedValue(void) """ pass def GetMethod(self): # real signature unknown; restored from __doc__ """ GetMethod(self) -> int C++: virtual int GetMethod() """ return 0 def GetMinimumDegree(self): # real signature unknown; restored from __doc__ """ GetMinimumDegree(self) -> float C++: virtual double GetMinimumDegree(void) """ return 0.0 def GetMinimumRadian(self): # real signature unknown; restored from __doc__ """ GetMinimumRadian(self) -> float C++: virtual double GetMinimumRadian() """ return 0.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 GetOrigin(self): # real signature unknown; restored from __doc__ """ GetOrigin(self) -> (float, float, float) C++: virtual double *GetOrigin() """ pass def GetRadius(self): # real signature unknown; restored from __doc__ """ GetRadius(self) -> float C++: virtual double GetRadius() """ return 0.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(void) override; Standard layout method """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkSimple3DCirclesStrategy C++: vtkSimple3DCirclesStrategy *NewInstance() """ return vtkSimple3DCirclesStrategy def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSimple3DCirclesStrategy C++: static vtkSimple3DCirclesStrategy *SafeDownCast( vtkObjectBase *o) """ return vtkSimple3DCirclesStrategy def SetAutoHeight(self, _arg): # real signature unknown; restored from __doc__ """ SetAutoHeight(self, _arg:int) -> None C++: virtual void SetAutoHeight(vtkTypeBool _arg) Set or get auto height (Default: false). If AutoHeight is true, (r(i+1) - r(i-1))/Height will be smaller than tan(MinimumRadian). If you want equal distances and parallel circles, you should turn off AutoHeight. """ pass def SetDirection(self, dx, dy, dz): # real signature unknown; restored from __doc__ """ SetDirection(self, dx:float, dy:float, dz:float) -> None C++: virtual void SetDirection(double dx, double dy, double dz) SetDirection(self, d:[float, float, float]) -> None C++: virtual void SetDirection(double d[3]) Set or get the normal vector of the circles plain. The height is growing in this direction. The direction must not be zero vector. The default vector is (0.0,0.0,1.0) """ pass def SetForceToUseUniversalStartPointsFinder(self, _arg): # real signature unknown; restored from __doc__ """ SetForceToUseUniversalStartPointsFinder(self, _arg:int) -> None C++: virtual void SetForceToUseUniversalStartPointsFinder( vtkTypeBool _arg) Set or get ForceToUseUniversalStartPointsFinder. If ForceToUseUniversalStartPointsFinder is true, MarkedStartVertices won't be used. In this case the input graph must be vtkDirectedAcyclicGraph (Default: false). """ pass def SetGraph(self, graph): # real signature unknown; restored from __doc__ """ SetGraph(self, graph:vtkGraph) -> None C++: void SetGraph(vtkGraph *graph) override; Set graph (warning: HierarchicalOrder and HierarchicalLayers will set to zero. These reference counts will be decreased!) """ pass def SetHeight(self, _arg): # real signature unknown; restored from __doc__ """ SetHeight(self, _arg:float) -> None C++: virtual void SetHeight(double _arg) Set or get the vertical (local z) distance between the circles. If AutoHeight is on, this is the minimal height between the circle layers """ pass def SetHierarchicalLayers(self, _arg): # real signature unknown; restored from __doc__ """ SetHierarchicalLayers(self, _arg:vtkIntArray) -> None C++: virtual void SetHierarchicalLayers(vtkIntArray *_arg) Set or get hierarchical layers id by vertices (An usual vertex's layer id is greater or equal to zero. If a vertex is standalone, its layer id is -2.) If no HierarchicalLayers array is defined, vtkSimple3DCirclesStrategy will generate it automatically (default). """ pass def SetHierarchicalOrder(self, _arg): # real signature unknown; restored from __doc__ """ SetHierarchicalOrder(self, _arg:vtkIdTypeArray) -> None C++: virtual void SetHierarchicalOrder(vtkIdTypeArray *_arg) Set or get hierarchical ordering of vertices (The array starts from the first vertex's id. All id must be greater or equal to zero!) If no HierarchicalOrder is defined, vtkSimple3DCirclesStrategy will generate it automatically (default). """ pass def SetMarkedStartVertices(self, _arg): # real signature unknown; restored from __doc__ """ SetMarkedStartVertices(self, _arg:vtkAbstractArray) -> None C++: virtual void SetMarkedStartVertices(vtkAbstractArray *_arg) Set or get initial vertices. If MarkedStartVertices is added, loop is accepted in the graph. (If all of the loop start vertices are marked in MarkedStartVertices array.) MarkedStartVertices size must be equal with the number of the vertices in the graph. Start vertices must be marked by MarkedValue. (E.g.: if MarkedValue=3 and MarkedStartPoints is { 0, 3, 5, 3 }, the start points ids will be {1,3}.) ) """ pass def SetMarkedValue(self, _arg): # real signature unknown; restored from __doc__ """ SetMarkedValue(self, _arg:vtkVariant) -> None C++: virtual void SetMarkedValue(vtkVariant _arg) Set or get MarkedValue. See: MarkedStartVertices. """ pass def SetMethod(self, _arg): # real signature unknown; restored from __doc__ """ SetMethod(self, _arg:int) -> None C++: virtual void SetMethod(int _arg) Set or get circle generating method (FixedRadiusMethod/FixedDistanceMethod). Default is FixedRadiusMethod. """ pass def SetMinimumDegree(self, degree): # real signature unknown; restored from __doc__ """ SetMinimumDegree(self, degree:float) -> None C++: virtual void SetMinimumDegree(double degree) Set or get minimum degree (used by auto height). There is no separated minimum degree, so minimum radian will be changed. """ pass def SetMinimumRadian(self, _arg): # real signature unknown; restored from __doc__ """ SetMinimumRadian(self, _arg:float) -> None C++: virtual void SetMinimumRadian(double _arg) Set or get minimum radian (used by auto height). """ pass def SetOrigin(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetOrigin(self, _arg1:float, _arg2:float, _arg3:float) -> None C++: virtual void SetOrigin(double _arg1, double _arg2, double _arg3) SetOrigin(self, _arg:(float, float, float)) -> None C++: virtual void SetOrigin(const double _arg[3]) Set or get the origin of the geometry. This is the center of the first circle. SetOrigin(x,y,z) """ pass def SetRadius(self, _arg): # real signature unknown; restored from __doc__ """ SetRadius(self, _arg:float) -> None C++: virtual void SetRadius(double _arg) If Method is FixedRadiusMethod: Set or get the radius of the circles. If Method is FixedDistanceMethod: Set or get the distance of the points in the circle. """ 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.""" FixedDistanceMethod = 1 FixedRadiusMethod = 0 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkSimple3DCirclesStrategy', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetMethod': , 'GetMethod': , 'SetRadius': , 'GetRadius': , 'SetHeight': , 'GetHeight': , 'SetOrigin': , 'GetOrigin': , 'SetDirection': , 'GetDirection': , 'SetMarkedStartVertices': , 'GetMarkedStartVertices': , 'SetMarkedValue': , 'GetMarkedValue': , 'SetForceToUseUniversalStartPointsFinder': , 'GetForceToUseUniversalStartPointsFinder': , 'ForceToUseUniversalStartPointsFinderOn': , 'ForceToUseUniversalStartPointsFinderOff': , 'SetAutoHeight': , 'GetAutoHeight': , 'AutoHeightOn': , 'AutoHeightOff': , 'SetMinimumRadian': , 'GetMinimumRadian': , 'SetMinimumDegree': , 'GetMinimumDegree': , 'SetHierarchicalLayers': , 'GetHierarchicalLayers': , 'SetHierarchicalOrder': , 'GetHierarchicalOrder': , 'Layout': , 'SetGraph': , 'FixedRadiusMethod': 0, 'FixedDistanceMethod': 1, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkSimple3DCirclesStrategy - places vertices on circles in 3D\\n\\nSuperclass: vtkGraphLayoutStrategy\\n\\nPlaces vertices on circles depending on the graph vertices hierarchy\\nlevel. The source graph could be vtkDirectedAcyclicGraph or\\nvtkDirectedGraph if MarkedStartPoints array was added. The algorithm\\ncollects the standalone points, too and take them to a separated\\ncircle. If method is FixedRadiusMethod, the radius of the circles\\nwill be equal. If method is FixedDistanceMethod, the distance between\\nthe points on circles will be equal.\\n\\nIn first step initial points are searched. A point is initial, if its\\nin degree equal zero and out degree is greater than zero (or marked\\nby MarkedStartVertices and out degree is greater than zero).\\nIndependent vertices (in and out degree equal zero) are collected\\nseparatelly. In second step the hierarchical level is generated for\\nevery vertex. In third step the hierarchical order is generated. If a\\nvertex has no hierarchical level and it is not independent, the graph\\nhas loop so the algorithm exit with error message. Finally the\\nvertices positions are calculated by the hierarchical order and by\\nthe vertices hierarchy levels.\\n\\n@par Thanks: Ferenc Nasztanovics, naszta\\n\\naszta.hu, Budapest University of Technology and Economics, Department\\nof Structural Mechanics\\n\\n@par References: in 3D rotation was used:\\nhttp://en.citizendium.org/wiki/Rotation_matrix\\n\\n'})" __vtkname__ = 'vtkSimple3DCirclesStrategy'