# 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 vtkStaticPointLocator(vtkAbstractPointLocator): """ vtkStaticPointLocator - quickly locate points in 3-space Superclass: vtkAbstractPointLocator vtkStaticPointLocator is a spatial search object to quickly locate points in 3D. vtkStaticPointLocator works by dividing a specified region of space into a regular array of cuboid buckets, and then keeping a list of points that lie in each bucket. Typical operation involves giving a position in 3D and finding the closest point; or finding the N closest points. vtkStaticPointLocator is an accelerated version of vtkPointLocator. It is threaded (via vtkSMPTools), and supports one-time static construction (i.e., incremental point insertion is not supported). If you need to incrementally insert points, use the vtkPointLocator or its kin to do so. @warning This class is templated. It may run slower than serial execution if the code is not optimized during compilation. Build in Release or ReleaseWithDebugInfo. @warning Make sure that you review the documentation for the superclasses vtkAbstactPointLocator and vtkLocator. In particular the Automatic data member can be used to automatically determine divisions based on the average number of points per bucket. @warning Other types of spatial locators have been developed such as octrees and kd-trees. These are often more efficient for the operations described here. @warning Frequently vtkStaticPointLocator is used in lieu of vtkPointLocator. They are very similar in terms of algorithmic approach, however vtkStaticCellLocator is threaded and is typically much faster for a large number of points (on the order of 3-5x faster). For small numbers of points, vtkPointLocator is just as fast as vtkStaticPointLocator. @sa vtkPointLocator vtkCellLocator vtkLocator vtkAbstractPointLocator """ def BuildLocator(self): # real signature unknown; restored from __doc__ """ BuildLocator(self) -> None C++: void BuildLocator() override; BuildLocator(self, inBounds:(float, ...)) -> None C++: void BuildLocator(const double *inBounds) Build the locator from the input dataset. This will NOT do anything if UseExistingSearchStructure is on. """ 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; FindClosestNPoints(self, N:int, x:float, y:float, z:float, result:vtkIdList) -> None C++: void FindClosestNPoints(int N, double x, double y, double z, vtkIdList *result) Find the closest N points to a position. This returns the closest N points to a position. A faster method could be created that returned N close points to a position, but necessarily the exact N closest. The returned points are sorted from closest to farthest. These methods are 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++: vtkIdType FindClosestPoint(double x, double y, double z) Given a position x, return the id of the point closest to it, or (-1) if no point found. An alternative method (defined in the superclass) requires separate x-y-z values. These methods are 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; FindClosestPointWithinRadius(self, radius:float, x:(float, float, float), inputDataLength:float, dist2:float) -> int C++: virtual vtkIdType FindClosestPointWithinRadius(double radius, const double x[3], double inputDataLength, double &dist2) Given a position x and a radius r, return the id of the point closest to the point in that radius, or (-1) if nothing found. These methods are thread safe if BuildLocator() is directly or indirectly called from a single thread first. dist2 returns the squared distance to the point. Note that if multiple points are located the same distance away, the actual point returned is a function in which order the points are processed (i.e., indeterminate). """ 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; FindPointsWithinRadius(self, R:float, x:float, y:float, z:float, result:vtkIdList) -> None C++: void FindPointsWithinRadius(double R, double x, double y, double z, vtkIdList *result) Find all points within a specified radius R of position x. The result is not sorted in any specific manner. These methods are 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). This function is not pure virtual to maintain backwards compatibility. """ pass def FreeSearchStructure(self): # real signature unknown; restored from __doc__ """ FreeSearchStructure(self) -> None C++: void FreeSearchStructure() override; Free the memory required for the spatial data structure. """ pass def GenerateRepresentation(self, level, pd): # real signature unknown; restored from __doc__ """ GenerateRepresentation(self, level:int, pd:vtkPolyData) -> None C++: void GenerateRepresentation(int level, vtkPolyData *pd) override; Populate a polydata with the faces of the bins that potentially contain cells. Note that the level parameter has no effect on this method as there is no hierarchy built (i.e., uniform binning). Typically this is used for debugging. """ pass def GetBounds(self): # real signature unknown; restored from __doc__ """ GetBounds(self) -> Pointer C++: virtual double *GetBounds() GetBounds(self, __a:[float, ...]) -> None C++: virtual void GetBounds(double *) Provide an accessor to the bounds. Valid after the locator is built. """ pass def GetBucketIds(self, bNum, bList): # real signature unknown; restored from __doc__ """ GetBucketIds(self, bNum:int, bList:vtkIdList) -> None C++: void GetBucketIds(vtkIdType bNum, vtkIdList *bList) Given a bucket number bNum between 0 <= bNum < this->GetNumberOfBuckets(), return a list of point ids contained within the bucket. The user must provide an instance of vtkIdList to contain the result. """ pass def GetDivisions(self): # real signature unknown; restored from __doc__ """ GetDivisions(self) -> (int, int, int) C++: virtual int *GetDivisions() """ pass def GetLargeIds(self): # real signature unknown; restored from __doc__ """ GetLargeIds(self) -> bool C++: bool GetLargeIds() Inform the user as to whether large ids are being used. This flag only has meaning after the locator has been built. Large ids are used when the number of binned points, or the number of bins, is >= the maximum number of buckets (specified by the user). Note that LargeIds are only available on 64-bit architectures. """ return False def GetMaxNumberOfBuckets(self): # real signature unknown; restored from __doc__ """ GetMaxNumberOfBuckets(self) -> int C++: virtual vtkIdType GetMaxNumberOfBuckets() """ return 0 def GetMaxNumberOfBucketsMaxValue(self): # real signature unknown; restored from __doc__ """ GetMaxNumberOfBucketsMaxValue(self) -> int C++: virtual vtkIdType GetMaxNumberOfBucketsMaxValue() """ return 0 def GetMaxNumberOfBucketsMinValue(self): # real signature unknown; restored from __doc__ """ GetMaxNumberOfBucketsMinValue(self) -> int C++: virtual vtkIdType GetMaxNumberOfBucketsMinValue() """ 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 GetNumberOfPointsInBucket(self, bNum): # real signature unknown; restored from __doc__ """ GetNumberOfPointsInBucket(self, bNum:int) -> int C++: vtkIdType GetNumberOfPointsInBucket(vtkIdType bNum) Given a bucket number bNum between 0 <= bNum < this->GetNumberOfBuckets(), return the number of points found in the bucket. """ return 0 def GetNumberOfPointsPerBucket(self): # real signature unknown; restored from __doc__ """ GetNumberOfPointsPerBucket(self) -> int C++: virtual int GetNumberOfPointsPerBucket() """ return 0 def GetNumberOfPointsPerBucketMaxValue(self): # real signature unknown; restored from __doc__ """ GetNumberOfPointsPerBucketMaxValue(self) -> int C++: virtual int GetNumberOfPointsPerBucketMaxValue() """ return 0 def GetNumberOfPointsPerBucketMinValue(self): # real signature unknown; restored from __doc__ """ GetNumberOfPointsPerBucketMinValue(self) -> int C++: virtual int GetNumberOfPointsPerBucketMinValue() """ return 0 def GetSpacing(self): # real signature unknown; restored from __doc__ """ GetSpacing(self) -> Pointer C++: virtual double *GetSpacing() GetSpacing(self, spacing:[float, float, float]) -> None C++: virtual void GetSpacing(double spacing[3]) Provide an accessor to the bucket spacing. Valid after the locator is built. """ pass def GetTraversalOrder(self): # real signature unknown; restored from __doc__ """ GetTraversalOrder(self) -> int C++: virtual int GetTraversalOrder() """ return 0 def GetTraversalOrderMaxValue(self): # real signature unknown; restored from __doc__ """ GetTraversalOrderMaxValue(self) -> int C++: virtual int GetTraversalOrderMaxValue() """ return 0 def GetTraversalOrderMinValue(self): # real signature unknown; restored from __doc__ """ GetTraversalOrderMinValue(self) -> int C++: virtual int GetTraversalOrderMinValue() """ return 0 def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; See vtkLocator and vtkAbstractPointLocator interface documentation. These methods are not thread safe. """ pass def IntersectWithLine(self, a0, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectWithLine(self, a0:[float, float, float], a1:[float, float, float], tol:float, t:float, lineX:[float, float, float], ptX:[float, float, float], ptId:int) -> int C++: int IntersectWithLine(double a0[3], double a1[3], double tol, double &t, double lineX[3], double ptX[3], vtkIdType &ptId) Intersect the points contained in the locator with the line defined by (a0,a1). Return the point within the tolerance tol that is closest to a0 (tol measured in the world coordinate system). If an intersection occurs (i.e., the method returns nonzero), then the parametric location along the line t, the closest position along the line lineX, and the coordinates of the picked ptId is returned in ptX. (This method is thread safe after the locator is built.) """ 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 MergePoints(self, tol, mergeMap, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MergePoints(self, tol:float, mergeMap:[int, ...]) -> None C++: void MergePoints(double tol, vtkIdType *mergeMap) Merge points in the locator given a tolerance. Return a merge map which maps all points to the points to which they were merged. Note the number of points in the merge map is the number of points the locator was built with. The user is expected to pass in an allocated mergeMap. Note that when tol!=0, the traversal order of threading can be specified using the SetTraversalOrder() method. The traversal order is needed to generate deterministic output (i.e., output independent of thread execution order). """ pass def MergePointsWithData(self, data, mergeMap, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ MergePointsWithData(self, data:vtkDataArray, mergeMap:[int, ...]) -> None C++: void MergePointsWithData(vtkDataArray *data, vtkIdType *mergeMap) Merge points and associated data in the locator. Return a merge map which maps all points to the points to which they were merged. Note the number of points in the merge map is the number of points the locator was built with. Merging occurs when both the points and the associated point data (represented by the data array) are equal. The user is expected to pass in an allocated mergeMap, and the size of the data array should be number of points in the locator. The data array may have an arbitrary number of components. """ pass def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkStaticPointLocator C++: vtkStaticPointLocator *NewInstance() """ return vtkStaticPointLocator def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkStaticPointLocator C++: static vtkStaticPointLocator *SafeDownCast(vtkObjectBase *o) """ return vtkStaticPointLocator def SetDivisions(self, _arg1, _arg2, _arg3): # real signature unknown; restored from __doc__ """ SetDivisions(self, _arg1:int, _arg2:int, _arg3:int) -> None C++: virtual void SetDivisions(int _arg1, int _arg2, int _arg3) SetDivisions(self, _arg:(int, int, int)) -> None C++: virtual void SetDivisions(const int _arg[3]) Set the number of divisions in x-y-z directions. If the Automatic data member is enabled, the Divisions are set according to the NumberOfPointsPerBucket and MaxNumberOfBuckets data members. The number of divisions must be >= 1 in each direction. """ pass def SetMaxNumberOfBuckets(self, _arg): # real signature unknown; restored from __doc__ """ SetMaxNumberOfBuckets(self, _arg:int) -> None C++: virtual void SetMaxNumberOfBuckets(vtkIdType _arg) Set the maximum number of buckets in the locator. By default the value is set to VTK_INT_MAX. Note that there are significant performance implications at work here. If the number of buckets is set very large (meaning > VTK_INT_MAX) then internal sorting may be performed using 64-bit integers (which is much slower than using a 32-bit int). Of course, memory requirements may dramatically increase as well. It is recommended that the default value be used; but for extremely large data it may be desired to create a locator with an exceptionally large number of buckets. Note also that during initialization of the locator if the MaxNumberOfBuckets threshold is exceeded, the Divisions are scaled down in such a way as not to exceed the MaxNumberOfBuckets proportionally to the size of the bounding box in the x-y-z directions. """ pass def SetNumberOfPointsPerBucket(self, _arg): # real signature unknown; restored from __doc__ """ SetNumberOfPointsPerBucket(self, _arg:int) -> None C++: virtual void SetNumberOfPointsPerBucket(int _arg) Specify the average number of points in each bucket. This data member is used in conjunction with the Automatic data member (if enabled) to determine the number of locator x-y-z divisions. """ pass def SetTraversalOrder(self, _arg): # real signature unknown; restored from __doc__ """ SetTraversalOrder(self, _arg:int) -> None C++: virtual void SetTraversalOrder(int _arg) Specify the manner in which points are processed when a non-zero merge tolerance is specified. By default, BIN_ORDER is used (i.e., threaded using bin checkerboard traversal) versus POINT_ORDER, which is a serial traversal. """ pass def SetTraversalOrderToBinOrder(self): # real signature unknown; restored from __doc__ """ SetTraversalOrderToBinOrder(self) -> None C++: void SetTraversalOrderToBinOrder() """ pass def SetTraversalOrderToPointOrder(self): # real signature unknown; restored from __doc__ """ SetTraversalOrderToPointOrder(self) -> None C++: void SetTraversalOrderToPointOrder() """ 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.""" BIN_ORDER = 1 POINT_ORDER = 0 TraversalOrderType = None # (!) real value is "" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkStaticPointLocator', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetNumberOfPointsPerBucket': , 'GetNumberOfPointsPerBucketMinValue': , 'GetNumberOfPointsPerBucketMaxValue': , 'GetNumberOfPointsPerBucket': , 'SetDivisions': , 'GetDivisions': , 'FindClosestPoint': , 'FindClosestPointWithinRadius': , 'FindClosestNPoints': , 'FindPointsWithinRadius': , 'IntersectWithLine': , 'MergePoints': , 'MergePointsWithData': , 'Initialize': , 'FreeSearchStructure': , 'BuildLocator': , 'ForceBuildLocator': , 'GenerateRepresentation': , 'GetNumberOfPointsInBucket': , 'GetBucketIds': , 'SetMaxNumberOfBuckets': , 'GetMaxNumberOfBucketsMinValue': , 'GetMaxNumberOfBucketsMaxValue': , 'GetMaxNumberOfBuckets': , 'GetLargeIds': , 'GetSpacing': , 'SetTraversalOrder': , 'GetTraversalOrderMinValue': , 'GetTraversalOrderMaxValue': , 'GetTraversalOrder': , 'SetTraversalOrderToPointOrder': , 'SetTraversalOrderToBinOrder': , 'GetBounds': , 'TraversalOrderType': , 'POINT_ORDER': 0, 'BIN_ORDER': 1, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkStaticPointLocator - quickly locate points in 3-space\\n\\nSuperclass: vtkAbstractPointLocator\\n\\nvtkStaticPointLocator is a spatial search object to quickly locate\\npoints in 3D. vtkStaticPointLocator works by dividing a specified\\nregion of space into a regular array of cuboid buckets, and then\\nkeeping a list of points that lie in each bucket. Typical operation\\ninvolves giving a position in 3D and finding the closest point; or\\nfinding the N closest points.\\n\\nvtkStaticPointLocator is an accelerated version of vtkPointLocator.\\nIt is threaded (via vtkSMPTools), and supports one-time static\\nconstruction (i.e., incremental point insertion is not supported). If\\nyou need to incrementally insert points, use the vtkPointLocator or\\nits kin to do so.\\n\\n@warning\\nThis class is templated. It may run slower than serial execution if\\nthe code is not optimized during compilation. Build in Release or\\nReleaseWithDebugInfo.\\n\\n@warning\\nMake sure that you review the documentation for the superclasses\\nvtkAbstactPointLocator and vtkLocator. In particular the Automatic\\ndata member can be used to automatically determine divisions based on\\nthe average number of points per bucket.\\n\\n@warning\\nOther types of spatial locators have been developed such as octrees\\nand kd-trees. These are often more efficient for the operations\\ndescribed here.\\n\\n@warning\\nFrequently vtkStaticPointLocator is used in lieu of vtkPointLocator.\\nThey are very similar in terms of algorithmic approach, however\\nvtkStaticCellLocator is threaded and is typically much faster for a\\nlarge number of points (on the order of 3-5x faster). For small\\nnumbers of points, vtkPointLocator is just as fast as\\nvtkStaticPointLocator.\\n\\n@sa\\nvtkPointLocator vtkCellLocator vtkLocator vtkAbstractPointLocator\\n\\n'})" __vtkname__ = 'vtkStaticPointLocator'