# 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 .vtkAbstractPointLocator import vtkAbstractPointLocator class vtkIncrementalPointLocator(vtkAbstractPointLocator): """ vtkIncrementalPointLocator - Abstract class in support of both point location and point insertion. Superclass: vtkAbstractPointLocator Compared to a static point locator for 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. There are two incremental point locators, i.e., vtkPointLocator and vtkIncrementalOctreePointLocator. As opposed to the uniform bin-based search structure (adopted in vtkPointLocator) with a fixed spatial resolution, an octree mechanism (employed in vtkIncrementalOctreePointlocator) resorts to 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 point insertion, particularly when handling a radically imbalanced layout of points as not uncommon in datasets defined on adaptive meshes. In other words, vtkIncrementalOctreePointLocator is an octree-based accelerated implementation of all functionalities of vtkPointLocator. @sa vtkLocator, vtkIncrementalOctreePointLocator, vtkPointLocator, vtkMergePoints vtkStaticPointLocator """ def FindClosestInsertedPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestInsertedPoint(self, x:(float, float, float)) -> int C++: virtual vtkIdType FindClosestInsertedPoint(const double x[3]) Given a point x assumed to be covered by the search structure, return the index of the closest point (already inserted to the search structure) 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 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 InitPointInsertion(self, newPts, bounds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InitPointInsertion(self, newPts:vtkPoints, bounds:(float, float, float, float, float, float)) -> int C++: virtual int InitPointInsertion(vtkPoints *newPts, const double bounds[6]) InitPointInsertion(self, newPts:vtkPoints, bounds:(float, float, float, float, float, float), estSize:int) -> int C++: virtual int InitPointInsertion(vtkPoints *newPts, const double bounds[6], vtkIdType estSize) Initialize the point insertion process. newPts is an object, storing 3D point coordinates, to which incremental point insertion puts coordinates. It is created and provided by an external VTK class. Argument bounds represents the spatial bounding box, into which the points fall. """ pass def InsertNextPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertNextPoint(self, x:(float, float, float)) -> int C++: virtual vtkIdType InsertNextPoint(const double x[3]) Insert a given point and return the point index. InitPointInsertion() should have been called prior to this function. Also, IsInsertedPoint() should have been called in advance to ensure that the given point has not been inserted unless point duplication is allowed. """ 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++: virtual void InsertPoint(vtkIdType ptId, const double x[3]) Insert a given point with a specified point index ptId. InitPointInsertion() should have been called prior to this function. Also, IsInsertedPoint() should have been called in advance to ensure that the given point has not been inserted unless point duplication is allowed. """ pass def InsertUniquePoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsertUniquePoint(self, x:(float, float, float), ptId:int) -> int C++: virtual int InsertUniquePoint(const double x[3], vtkIdType &ptId) Insert a point unless there has been a duplicate in the search structure. Return 0 if the point was already in the list, otherwise return 1. If the point was not in the list, it will be ADDED. In either case, the id of the point (newly inserted or not) is returned in the ptId argument. 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, y, z): # real signature unknown; restored from __doc__ """ IsInsertedPoint(self, x:float, y:float, z:float) -> int C++: virtual vtkIdType IsInsertedPoint(double x, double y, double z) IsInsertedPoint(self, x:(float, float, float)) -> int C++: virtual vtkIdType IsInsertedPoint(const double x[3]) Determine whether or not a given point has been inserted. Return the id of the already inserted point if true, else return -1. InitPointInsertion() should have been called in advance. """ 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) -> vtkIncrementalPointLocator C++: vtkIncrementalPointLocator *NewInstance() """ return vtkIncrementalPointLocator def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkIncrementalPointLocator C++: static vtkIncrementalPointLocator *SafeDownCast( vtkObjectBase *o) """ return vtkIncrementalPointLocator 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__': 'vtkIncrementalPointLocator', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'FindClosestInsertedPoint': , 'InitPointInsertion': , 'IsInsertedPoint': , 'InsertUniquePoint': , 'InsertPoint': , 'InsertNextPoint': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkIncrementalPointLocator - Abstract class in support of both\\n point location and point insertion.\\n\\nSuperclass: vtkAbstractPointLocator\\n\\nCompared to a static point locator for pure location functionalities\\n through some search structure established from a fixed set of\\npoints,\\n an incremental point locator allows for, in addition, point\\ninsertion\\n capabilities, with the search structure maintaining a dynamically\\n increasing number of points. There are two incremental point\\nlocators,\\n i.e., vtkPointLocator and vtkIncrementalOctreePointLocator. As\\nopposed\\n to the uniform bin-based search structure (adopted in\\nvtkPointLocator)\\n with a fixed spatial resolution, an octree mechanism (employed in\\n vtkIncrementalOctreePointlocator) resorts to a hierarchy of\\ntree-like\\n sub-division of the 3D data domain. Thus it enables data-aware\\nmulti-\\n resolution and accordingly accelerated point location as well as\\npoint\\n insertion, particularly when handling a radically imbalanced layout\\nof\\n points as not uncommon in datasets defined on adaptive meshes. In\\nother\\n words, vtkIncrementalOctreePointLocator is an octree-based\\naccelerated\\n implementation of all functionalities of vtkPointLocator.\\n\\n@sa\\n vtkLocator, vtkIncrementalOctreePointLocator, vtkPointLocator,\\n vtkMergePoints vtkStaticPointLocator\\n\\n'})" __vtkname__ = 'vtkIncrementalPointLocator'