# encoding: utf-8 # module vtkmodules.vtkCommonExecutionModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonExecutionModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore class vtkSphereTree(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSphereTree - class to build and traverse sphere trees Superclass: vtkObject vtkSphereTree is a helper class used to build and traverse sphere trees. Various types of trees can be constructed for different VTK dataset types, as well well as different approaches to organize the tree into hierarchies. Typically building a complete sphere tree consists of two parts: 1) creating spheres for each cell in the dataset, then 2) creating an organizing hierarchy. The structure of the hierarchy varies depending on the topological characteristics of the dataset. Once the tree is constructed, various geometric operations are available for quickly selecting cells based on sphere tree operations; for example, process all cells intersecting a plane (i.e., use the sphere tree to identify candidate cells for plane intersection). This class does not necessarily create optimal sphere trees because some of its requirements (fast build time, provide simple reference code, a single bounding sphere per cell, etc.) precludes optimal performance. It is also oriented to computing on cells versus the classic problem of collision detection for polygonal models. For more information you want to read Gareth Bradshaw's PhD thesis "Bounding Volume Hierarchies for Level-of-Detail Collision Handling" which does a nice job of laying out the challenges and important algorithms relative to sphere trees and BVH (bounding volume hierarchies). @sa vtkSphereTreeFilter vtkPlaneCutter """ def Build(self): # real signature unknown; restored from __doc__ """ Build(self) -> None C++: void Build() Build(self, input:vtkDataSet) -> None C++: void Build(vtkDataSet *input) Build the sphere tree (if necessary) from the data set specified. The build time is recorded so the sphere tree will only build if something has changed. An alternative method is available to both set the dataset and then build the sphere tree. """ pass def BuildHierarchyOff(self): # real signature unknown; restored from __doc__ """ BuildHierarchyOff(self) -> None C++: virtual void BuildHierarchyOff() """ pass def BuildHierarchyOn(self): # real signature unknown; restored from __doc__ """ BuildHierarchyOn(self) -> None C++: virtual void BuildHierarchyOn() """ pass def GetBuildHierarchy(self): # real signature unknown; restored from __doc__ """ GetBuildHierarchy(self) -> bool C++: virtual bool GetBuildHierarchy() """ return False def GetCellSpheres(self): # real signature unknown; restored from __doc__ """ GetCellSpheres(self) -> Pointer C++: const double *GetCellSpheres() Special methods to retrieve the sphere tree data. This is generally used for debugging or with filters like vtkSphereTreeFilter. Both methods return an array of double* where four doubles represent a sphere (center + radius). In the first method a sphere per cell is returned. In the second method the user must also specify a level in the sphere tree (used to retrieve the hierarchy of the tree). Note that null pointers can be returned if the request is not consistent with the state of the sphere tree. """ pass def GetDataSet(self): # real signature unknown; restored from __doc__ """ GetDataSet(self) -> vtkDataSet C++: virtual vtkDataSet *GetDataSet() """ pass def GetMaxLevel(self): # real signature unknown; restored from __doc__ """ GetMaxLevel(self) -> int C++: virtual int GetMaxLevel() """ return 0 def GetMaxLevelMaxValue(self): # real signature unknown; restored from __doc__ """ GetMaxLevelMaxValue(self) -> int C++: virtual int GetMaxLevelMaxValue() """ return 0 def GetMaxLevelMinValue(self): # real signature unknown; restored from __doc__ """ GetMaxLevelMinValue(self) -> int C++: virtual int GetMaxLevelMinValue() """ 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 GetNumberOfLevels(self): # real signature unknown; restored from __doc__ """ GetNumberOfLevels(self) -> int C++: virtual int GetNumberOfLevels() Get the current depth of the sphere tree. This value may change each time the sphere tree is built and the branching factor (i.e., resolution) changes. Note that after building the sphere tree there are [0,this->NumberOfLevels) defined levels. """ return 0 def GetResolution(self): # real signature unknown; restored from __doc__ """ GetResolution(self) -> int C++: virtual int GetResolution() """ return 0 def GetResolutionMaxValue(self): # real signature unknown; restored from __doc__ """ GetResolutionMaxValue(self) -> int C++: virtual int GetResolutionMaxValue() """ return 0 def GetResolutionMinValue(self): # real signature unknown; restored from __doc__ """ GetResolutionMinValue(self) -> int C++: virtual int GetResolutionMinValue() """ return 0 def GetTreeSpheres(self, level, numSpheres): # real signature unknown; restored from __doc__ """ GetTreeSpheres(self, level:int, numSpheres:int) -> Pointer C++: const double *GetTreeSpheres(int level, vtkIdType &numSpheres) """ 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 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) -> vtkSphereTree C++: vtkSphereTree *NewInstance() """ return vtkSphereTree def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSphereTree C++: static vtkSphereTree *SafeDownCast(vtkObjectBase *o) """ return vtkSphereTree def SelectLine(self, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SelectLine(self, origin:[float, float, float], ray:[float, float, float], numSelected:int) -> Pointer C++: const unsigned char *SelectLine(double origin[3], double ray[3], vtkIdType &numSelected) SelectLine(self, origin:[float, float, float], ray:[float, float, float], cellIds:vtkIdList) -> None C++: void SelectLine(double origin[3], double ray[3], vtkIdList *cellIds) """ pass def SelectPlane(self, origin, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SelectPlane(self, origin:[float, float, float], normal:[float, float, float], numSelected:int) -> Pointer C++: const unsigned char *SelectPlane(double origin[3], double normal[3], vtkIdType &numSelected) SelectPlane(self, origin:[float, float, float], normal:[float, float, float], cellIds:vtkIdList) -> None C++: void SelectPlane(double origin[3], double normal[3], vtkIdList *cellIds) """ pass def SelectPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SelectPoint(self, point:[float, float, float], numSelected:int) -> Pointer C++: const unsigned char *SelectPoint(double point[3], vtkIdType &numSelected) SelectPoint(self, point:[float, float, float], cellIds:vtkIdList) -> None C++: void SelectPoint(double point[3], vtkIdList *cellIds) Methods for cell selection based on a geometric query. Internally different methods are used depending on the dataset type. The array returned is set to non-zero for each cell that intersects the geometric entity. SelectPoint marks all cells with a non-zero value that may contain a point. SelectLine marks all cells that may intersect an infinite line. SelectPlane marks all cells that may intersect with an infinite plane. """ pass def SetBuildHierarchy(self, _arg): # real signature unknown; restored from __doc__ """ SetBuildHierarchy(self, _arg:bool) -> None C++: virtual void SetBuildHierarchy(bool _arg) Control whether the tree hierarchy is built. If not, then just cell spheres are created (one for each cell). """ pass def SetDataSet(self, __a): # real signature unknown; restored from __doc__ """ SetDataSet(self, __a:vtkDataSet) -> None C++: virtual void SetDataSet(vtkDataSet *) Specify the dataset from which to build the sphere tree. """ pass def SetMaxLevel(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxLevel(self, _arg:int) -> None C++: virtual void SetMaxLevel(int _arg) Specify the maximum number of levels for the tree. By default, the number of levels is set to ten. If the number of levels is set to one or less, then no hierarchy is built (i.e., just the spheres for each cell are created). Note that the actual level of the tree may be less than this value depending on the number of cells and Resolution factor. """ pass def SetResolution(self, _arg): # real signature unknown; restored from __doc__ """ SetResolution(self, _arg:int) -> None C++: virtual void SetResolution(int _arg) Sphere tree creation requires gathering spheres into groups. The Resolution variable is a rough guide to the size of each group (the size different meanings depending on the type of data (structured versus unstructured). For example, in 3D structured data, blocks of resolution Resolution^3 are created. By default the Resolution is three. """ 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__\': \'vtkSphereTree\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetDataSet\': , \'GetDataSet\': , \'Build\': , \'SetBuildHierarchy\': , \'GetBuildHierarchy\': , \'BuildHierarchyOn\': , \'BuildHierarchyOff\': , \'SelectPoint\': , \'SelectLine\': , \'SelectPlane\': , \'SetResolution\': , \'GetResolutionMinValue\': , \'GetResolutionMaxValue\': , \'GetResolution\': , \'SetMaxLevel\': , \'GetMaxLevelMinValue\': , \'GetMaxLevelMaxValue\': , \'GetMaxLevel\': , \'GetNumberOfLevels\': , \'GetCellSpheres\': , \'GetTreeSpheres\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkSphereTree - class to build and traverse sphere trees\\n\\nSuperclass: vtkObject\\n\\nvtkSphereTree is a helper class used to build and traverse sphere\\ntrees. Various types of trees can be constructed for different VTK\\ndataset types, as well well as different approaches to organize the\\ntree into hierarchies.\\n\\nTypically building a complete sphere tree consists of two parts: 1)\\ncreating spheres for each cell in the dataset, then 2) creating an\\norganizing hierarchy. The structure of the hierarchy varies depending\\non the topological characteristics of the dataset.\\n\\nOnce the tree is constructed, various geometric operations are\\navailable for quickly selecting cells based on sphere tree\\noperations; for example, process all cells intersecting a plane\\n(i.e., use the sphere tree to identify candidate cells for plane\\nintersection).\\n\\nThis class does not necessarily create optimal sphere trees because\\nsome of its requirements (fast build time, provide simple reference\\ncode, a single bounding sphere per cell, etc.) precludes optimal\\nperformance. It is also oriented to computing on cells versus the\\nclassic problem of collision detection for polygonal models. For more\\ninformation you want to read Gareth Bradshaw\\\'s PhD thesis "Bounding\\nVolume Hierarchies for Level-of-Detail Collision Handling" which does\\na nice job of laying out the challenges and important algorithms\\nrelative to sphere trees and BVH (bounding volume hierarchies).\\n\\n@sa\\nvtkSphereTreeFilter vtkPlaneCutter\\n\\n\'})' __vtkname__ = 'vtkSphereTree'