# 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 .vtkIncrementalPointLocator import vtkIncrementalPointLocator class vtkIncrementalOctreePointLocator(vtkIncrementalPointLocator): """ vtkIncrementalOctreePointLocator - Incremental octree in support of both point location and point insertion. Superclass: vtkIncrementalPointLocator As opposed to the uniform bin-based search structure (adopted in class vtkPointLocator) with a fixed spatial resolution, an octree mechanism employs a hierarchy of tree-like sub-division of the 3D data domain. Thus it enables data-aware multi-resolution and accordingly accelerated point location as well as insertion, particularly when handling a radically imbalanced layout of points as not uncommon in datasets defined on adaptive meshes. Compared to a static point locator supporting pure location functionalities through some search structure established from a fixed set of points, an incremental point locator allows for, in addition, point insertion capabilities, with the search structure maintaining a dynamically increasing number of points. Class vtkIncrementalOctreePointLocator is an octree-based accelerated implementation of the functionalities of the uniform bin-based incremental point locator vtkPointLocator. For point location, an octree is built by accessing a vtkDataSet, specifically a vtkPointSet. For point insertion, an empty octree is inited and then incrementally populated as points are inserted. Three increasingly complex point insertion modes, i.e., direct check-free insertion, zero tolerance insertion, and non-zero tolerance insertion, are supported. In fact, the octree used in the point location mode is actually constructed via direct check-free point insertion. This class also provides a polygonal representation of the octree boundary. @sa vtkAbstractPointLocator, vtkIncrementalPointLocator, vtkPointLocator, vtkMergePoints """ def BuildCubicOctreeOff(self): # real signature unknown; restored from __doc__ """ BuildCubicOctreeOff(self) -> None C++: virtual void BuildCubicOctreeOff() """ pass def BuildCubicOctreeOn(self): # real signature unknown; restored from __doc__ """ BuildCubicOctreeOn(self) -> None C++: virtual void BuildCubicOctreeOn() """ pass def BuildLocator(self): # real signature unknown; restored from __doc__ """ BuildLocator(self) -> None C++: void BuildLocator() override; Load points from a dataset to construct an octree for point location. This function resorts to InitPointInsertion() to fulfill some of the work. This will NOT do anything if UseExistingSearchStructure is on. """ pass def FindClosestInsertedPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestInsertedPoint(self, x:(float, float, float)) -> int C++: vtkIdType FindClosestInsertedPoint(const double x[3]) override; Given a point x assumed to be covered by the octree, return the index of the closest in-octree point regardless of the associated minimum squared distance relative to the squared insertion-tolerance distance. This method is used when performing incremental point insertion. Note -1 indicates that no point is found. InitPointInsertion() should have been called in advance. """ pass def FindClosestNPoints(self, N, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestNPoints(self, N:int, x:(float, float, float), result:vtkIdList) -> None C++: void FindClosestNPoints(int N, const double x[3], vtkIdList *result) override; Find the closest N points to a given point. The returned point ids (via result) are sorted from closest to farthest. BuildLocator() should have been called prior to this function. This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def FindClosestPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestPoint(self, x:(float, float, float)) -> int C++: vtkIdType FindClosestPoint(const double x[3]) override; FindClosestPoint(self, x:float, y:float, z:float) -> int C++: virtual vtkIdType FindClosestPoint(double x, double y, double z) FindClosestPoint(self, x:(float, float, float), miniDist2:[float, ...]) -> int C++: virtual vtkIdType FindClosestPoint(const double x[3], double *miniDist2) FindClosestPoint(self, x:float, y:float, z:float, miniDist2:[float, ...]) -> int C++: virtual vtkIdType FindClosestPoint(double x, double y, double z, double *miniDist2) Given a point x, return the id of the closest point. BuildLocator() should have been called prior to this function. This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def FindClosestPointWithinRadius(self, radius, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestPointWithinRadius(self, radius:float, x:(float, float, float), dist2:float) -> int C++: vtkIdType FindClosestPointWithinRadius(double radius, const double x[3], double &dist2) override; Given a point x and a radius, return the id of the closest point within the radius and the associated minimum squared distance (via dist2, this returned distance is valid only if the point id is not -1). Note that BuildLocator() should have been called prior to this function. This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def FindClosestPointWithinSquaredRadius(self, radius2, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestPointWithinSquaredRadius(self, radius2:float, x:(float, float, float), dist2:float) -> int C++: vtkIdType FindClosestPointWithinSquaredRadius(double radius2, const double x[3], double &dist2) Given a point x and a squared radius radius2, return the id of the closest point within the radius and the associated minimum squared distance (via dist2, note this returned distance is valid only if the point id is not -1). BuildLocator() should have been called prior to this function.This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def FindPointsWithinRadius(self, R, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindPointsWithinRadius(self, R:float, x:(float, float, float), result:vtkIdList) -> None C++: void FindPointsWithinRadius(double R, const double x[3], vtkIdList *result) override; Find all points within a radius R relative to a given point x. The returned point ids (stored in result) are not sorted in any way. BuildLocator() should have been called prior to this function. This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def FindPointsWithinSquaredRadius(self, R2, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindPointsWithinSquaredRadius(self, R2:float, x:(float, float, float), result:vtkIdList) -> None C++: void FindPointsWithinSquaredRadius(double R2, const double x[3], vtkIdList *result) Find all points within a squared radius R2 relative to a given point x. The returned point ids (stored in result) are not sorted in any way. BuildLocator() should have been called prior to this function. This method is thread safe if BuildLocator() is directly or indirectly called from a single thread first. """ pass def ForceBuildLocator(self): # real signature unknown; restored from __doc__ """ ForceBuildLocator(self) -> None C++: void ForceBuildLocator() override; Build the locator from the input dataset (even if UseExistingSearchStructure is on). """ pass def FreeSearchStructure(self): # real signature unknown; restored from __doc__ """ FreeSearchStructure(self) -> None C++: void FreeSearchStructure() override; Delete the octree search structure. """ pass def GenerateRepresentation(self, level, polysData): # real signature unknown; restored from __doc__ """ GenerateRepresentation(self, level:int, polysData:vtkPolyData) -> None C++: void GenerateRepresentation(int level, vtkPolyData *polysData) override; Create a polygonal representation of the octree 'level': for each node on the specified level we generate six faces for the bounding box of the node. We also include a cell attribute that specifies the Index of the node. The second version of this function, generates user defined boundaries provided by 'GetBounds'. This function takes as parameters a user defined opaque 'data', the current node, and a pointer to where to write the 'bounds'. The function returns true if we want to generate the representation for this node, and false otherwise. A user can store data associated with a node using the node index.@see vtkIncrementalOctreeNode::GetIndex """ pass def GetBounds(self, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetBounds(self, bounds:[float, ...]) -> None C++: void GetBounds(double *bounds) override; GetBounds(self) -> Pointer C++: double *GetBounds() override; Get the spatial bounding box of the octree. """ pass def GetBuildCubicOctree(self): # real signature unknown; restored from __doc__ """ GetBuildCubicOctree(self) -> int C++: virtual vtkTypeBool GetBuildCubicOctree() """ return 0 def GetLocatorPoints(self): # real signature unknown; restored from __doc__ """ GetLocatorPoints(self) -> vtkPoints C++: virtual vtkPoints *GetLocatorPoints() Get access to the vtkPoints object in which point coordinates are stored for either point location or point insertion. """ pass def GetMaxPointsPerLeaf(self): # real signature unknown; restored from __doc__ """ GetMaxPointsPerLeaf(self) -> int C++: virtual int GetMaxPointsPerLeaf() """ 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++: int GetNumberOfLevels() Returns the maximum level of the tree. If a tree has one node it returns 1 else it returns the maximum level of its children plus 1. """ return 0 def GetNumberOfNodes(self): # real signature unknown; restored from __doc__ """ GetNumberOfNodes(self) -> int C++: virtual int GetNumberOfNodes() Get number of nodes in the tree. """ return 0 def GetNumberOfPoints(self): # real signature unknown; restored from __doc__ """ GetNumberOfPoints(self) -> int C++: int GetNumberOfPoints() Get the number of points maintained by the octree. """ return 0 def GetRoot(self): # real signature unknown; restored from __doc__ """ GetRoot(self) -> vtkIncrementalOctreeNode C++: vtkIncrementalOctreeNode *GetRoot() """ return vtkIncrementalOctreeNode def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; Delete the octree search structure. """ pass def InitPointInsertion(self, points, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InitPointInsertion(self, points:vtkPoints, bounds:(float, float, float, float, float, float)) -> int C++: int InitPointInsertion(vtkPoints *points, const double bounds[6]) override; InitPointInsertion(self, points:vtkPoints, bounds:(float, float, float, float, float, float), estSize:int) -> int C++: int InitPointInsertion(vtkPoints *points, const double bounds[6], vtkIdType estSize) override; Initialize the point insertion process. points is an object, storing 3D point coordinates, to which incremental point insertion put coordinates. It is created and provided by an external VTK class. Argument bounds represents the spatial bounding box, into which the points fall. In fact, an adjusted version of the bounding box is used to build the octree to make sure no any point (to be inserted) falls outside the octree. This function is not thread safe. """ pass def InsertNextPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertNextPoint(self, x:(float, float, float)) -> int C++: vtkIdType InsertNextPoint(const double x[3]) override; Insert a given point into the octree and return the point index. Note that InitPointInsertion() should have been called prior to this function. In addition, IsInsertedPoint() should have been called in advance to ensure that the given point has not been inserted unless point duplication is allowed (in this case, this function involves a repeated leaf container location). vtkPoints::InsertNextPoint() is invoked. """ pass def InsertPoint(self, ptId, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertPoint(self, ptId:int, x:(float, float, float)) -> None C++: void InsertPoint(vtkIdType ptId, const double x[3]) override; Insert a given point into the octree with a specified point index ptId. InitPointInsertion() should have been called prior to this function. In addition, IsInsertedPoint() should have been called in advance to ensure that the given point has not been inserted unless point duplication is allowed (Note that in this case, this function involves a repeated leaf container location). vtkPoints::InsertPoint() is invoked. """ pass def InsertPointWithoutChecking(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertPointWithoutChecking(self, point:(float, float, float), pntId:int, insert:int) -> None C++: void InsertPointWithoutChecking(const double point[3], vtkIdType &pntId, int insert) "Insert" a point to the octree without any checking. Argument insert means whether vtkPoints::InsertNextPoint() upon 1 is called or the point itself is not inserted to the vtkPoints at all but instead only the point index is inserted to a vtkIdList upon 0. For case 0, the point index needs to be specified via pntId. For case 1, the actual point index is returned via pntId. InitPointInsertion() should have been called. """ pass def InsertUniquePoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertUniquePoint(self, point:(float, float, float), pntId:int) -> int C++: int InsertUniquePoint(const double point[3], vtkIdType &pntId) override; Insert a point to the octree unless there has been a duplicate point. Whether the point is actually inserted (return 1) or not (return 0 upon a rejection by an existing duplicate), the index of the point (either new or the duplicate) is returned via pntId. Note that InitPointInsertion() should have been called prior to this function. vtkPoints::InsertNextPoint() is invoked. This method is not thread safe. """ 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 IsInsertedPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IsInsertedPoint(self, x:(float, float, float)) -> int C++: vtkIdType IsInsertedPoint(const double x[3]) override; IsInsertedPoint(self, x:float, y:float, z:float) -> int C++: vtkIdType IsInsertedPoint(double x, double y, double z) override; Determine whether or not a given point has been inserted into the octree. Return the id of the already inserted point if true, otherwise return -1. InitPointInsertion() should have been called in advance. """ pass 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) -> vtkIncrementalOctreePointLocator C++: vtkIncrementalOctreePointLocator *NewInstance() """ return vtkIncrementalOctreePointLocator def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkIncrementalOctreePointLocator C++: static vtkIncrementalOctreePointLocator *SafeDownCast( vtkObjectBase *o) """ return vtkIncrementalOctreePointLocator def SetBuildCubicOctree(self, _arg): # real signature unknown; restored from __doc__ """ SetBuildCubicOctree(self, _arg:int) -> None C++: virtual void SetBuildCubicOctree(vtkTypeBool _arg) Set/Get whether the search octree is built as a cubic shape or not. """ pass def SetMaxPointsPerLeaf(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxPointsPerLeaf(self, _arg:int) -> None C++: virtual void SetMaxPointsPerLeaf(int _arg) Set/Get the maximum number of points that a leaf node may maintain. Note that the actual number of points maintained by a leaf node might exceed this threshold if there is a large number (equal to or greater than the threshold) of exactly duplicate points (with zero distance) to be inserted (e.g., to construct an octree for subsequent point location) in extreme cases. Respecting this threshold in such scenarios would cause endless node sub-division. Thus this threshold is broken, but only in case of such situations. """ 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__': 'vtkIncrementalOctreePointLocator', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetMaxPointsPerLeaf': , 'GetMaxPointsPerLeaf': , 'SetBuildCubicOctree': , 'GetBuildCubicOctree': , 'BuildCubicOctreeOn': , 'BuildCubicOctreeOff': , 'GetLocatorPoints': , 'Initialize': , 'FreeSearchStructure': , 'GetBounds': , 'GetNumberOfPoints': , 'GetNumberOfNodes': , 'FindClosestInsertedPoint': , 'GenerateRepresentation': , 'BuildLocator': , 'ForceBuildLocator': , 'FindClosestPoint': , 'FindClosestPointWithinRadius': , 'FindClosestPointWithinSquaredRadius': , 'FindPointsWithinRadius': , 'FindPointsWithinSquaredRadius': , 'FindClosestNPoints': , 'InitPointInsertion': , 'IsInsertedPoint': , 'InsertUniquePoint': , 'InsertPoint': , 'InsertNextPoint': , 'InsertPointWithoutChecking': , 'GetRoot': , 'GetNumberOfLevels': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkIncrementalOctreePointLocator - Incremental octree in support\\n of both point location and point insertion.\\n\\nSuperclass: vtkIncrementalPointLocator\\n\\nAs opposed to the uniform bin-based search structure (adopted in\\nclass\\n vtkPointLocator) with a fixed spatial resolution, an octree\\nmechanism\\n employs a hierarchy of tree-like sub-division of the 3D data domain.\\nThus\\n it enables data-aware multi-resolution and accordingly accelerated\\npoint\\n location as well as insertion, particularly when handling a\\nradically\\n imbalanced layout of points as not uncommon in datasets defined on\\n adaptive meshes. Compared to a static point locator supporting pure\\n location functionalities through some search structure established\\nfrom\\n a fixed set of points, an incremental point locator allows for, in\\naddition,\\n point insertion capabilities, with the search structure maintaining\\na\\n dynamically increasing number of points.\\n Class vtkIncrementalOctreePointLocator is an octree-based\\naccelerated\\n implementation of the functionalities of the uniform bin-based\\nincremental\\n point locator vtkPointLocator. For point location, an octree is\\nbuilt by\\n accessing a vtkDataSet, specifically a vtkPointSet. For point\\ninsertion,\\n an empty octree is inited and then incrementally populated as points\\nare\\n inserted. Three increasingly complex point insertion modes, i.e.,\\ndirect\\n check-free insertion, zero tolerance insertion, and non-zero\\ntolerance\\n insertion, are supported. In fact, the octree used in the point\\nlocation\\n mode is actually constructed via direct check-free point insertion.\\nThis\\n class also provides a polygonal representation of the octree\\nboundary.\\n\\n@sa\\n vtkAbstractPointLocator, vtkIncrementalPointLocator,\\nvtkPointLocator,\\n vtkMergePoints\\n\\n'})" __vtkname__ = 'vtkIncrementalOctreePointLocator'