# 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 .vtkAbstractCellLocator import vtkAbstractCellLocator class vtkStaticCellLocator(vtkAbstractCellLocator): """ vtkStaticCellLocator - perform fast cell location operations Superclass: vtkAbstractCellLocator vtkStaticCellLocator is a type of vtkAbstractCellLocator that accelerates certain operations when performing spatial operations on cells. These operations include finding a point that contains a cell, and intersecting cells with a line. vtkStaticCellLocator is an accelerated version of vtkCellLocator. It is threaded (via vtkSMPTools), and supports one-time static construction (i.e., incremental cell insertion is not supported). @warning vtkStaticCellLocator utilizes the following parent class parameters: - Automatic (default true) - NumberOfCellsPerNode (default 10) - UseExistingSearchStructure (default false) vtkStaticCellLocator does NOT utilize the following parameters: - CacheCellBounds (always cached) - Tolerance - Level - MaxLevel - RetainCellLists @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. @sa vtkAbstractCellLocator vtkCellLocator vtkCellTreeLocator vtkModifiedBSPTree vtkOBBTree """ def BuildLocator(self): # real signature unknown; restored from __doc__ """ BuildLocator(self) -> None C++: void BuildLocator() override; Build the locator from the input dataset. This will NOT do anything if UseExistingSearchStructure is on. """ pass def FindCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCell(self, x:[float, float, float], tol2:float, GenCell:vtkGenericCell, subId:int, pcoords:[float, float, float], weights:[float, ...]) -> int C++: vtkIdType FindCell(double x[3], double tol2, vtkGenericCell *GenCell, int &subId, double pcoords[3], double *weights) override; FindCell(self, x:[float, float, float]) -> int C++: virtual vtkIdType FindCell(double x[3]) FindCell(self, x:[float, float, float], tol2:float, GenCell:vtkGenericCell, pcoords:[float, float, float], weights:[float, ...]) -> int C++: virtual vtkIdType FindCell(double x[3], double tol2, vtkGenericCell *GenCell, double pcoords[3], double *weights) Find the cell containing a given point. returns -1 if no cell found the cell parameters are copied into the supplied variables, a cell must be provided to store the information. For other FindCell signatures, see vtkAbstractCellLocator. """ pass def FindCellsAlongLine(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCellsAlongLine(self, p1:(float, float, float), p2:(float, float, float), tolerance:float, cellsIds:vtkIdList) -> None C++: void FindCellsAlongLine(const double p1[3], const double p2[3], double tolerance, vtkIdList *cellsIds) override; Take the passed line segment and intersect it with the data set. For each intersection with the bounds of a cell, the cellIds have the relevant information added. If cellIds is nullptr pointer, then no information is generated for that list. Reimplemented from vtkAbstractCellLocator to showcase that it's a supported function. """ pass def FindCellsAlongPlane(self, o, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCellsAlongPlane(self, o:(float, float, float), n:(float, float, float), tolerance:float, cells:vtkIdList) -> None C++: void FindCellsAlongPlane(const double o[3], const double n[3], double tolerance, vtkIdList *cells) override; Take the passed line segment and intersect it with the data set. For each intersection with the bounds of a cell, the cellIds have the relevant information added sort by t. If cellIds is nullptr pointer, then no information is generated for that list. """ pass def FindCellsWithinBounds(self, bbox, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCellsWithinBounds(self, bbox:[float, ...], cells:vtkIdList) -> None C++: void FindCellsWithinBounds(double *bbox, vtkIdList *cells) override; Return a list of unique cell ids inside of a given bounding box. The user must provide the vtkIdList to populate. """ pass def FindClosestPoint(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestPoint(self, x:(float, float, float), closestPoint:[float, float, float], cell:vtkGenericCell, cellId:int, subId:int, dist2:float) -> None C++: void FindClosestPoint(const double x[3], double closestPoint[3], vtkGenericCell *cell, vtkIdType &cellId, int &subId, double &dist2) override; FindClosestPoint(self, x:(float, float, float), closestPoint:[float, float, float], cellId:int, subId:int, dist2:float) -> None C++: virtual void FindClosestPoint(const double x[3], double closestPoint[3], vtkIdType &cellId, int &subId, double &dist2) Return the closest point and the cell which is closest to the point x. The closest point is somewhere on a cell, it need not be one of the vertices of the cell. Reimplemented from vtkAbstractCellLocator to showcase that it's a supported function. For other FindClosestPoint signatures, see vtkAbstractCellLocator. """ pass def FindClosestPointWithinRadius(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindClosestPointWithinRadius(self, x:[float, float, float], radius:float, closestPoint:[float, float, float], cell:vtkGenericCell, cellId:int, subId:int, dist2:float, inside:int) -> int C++: vtkIdType FindClosestPointWithinRadius(double x[3], double radius, double closestPoint[3], vtkGenericCell *cell, vtkIdType &cellId, int &subId, double &dist2, int &inside) override; FindClosestPointWithinRadius(self, x:[float, float, float], radius:float, closestPoint:[float, float, float], cellId:int, subId:int, dist2:float) -> int C++: virtual vtkIdType FindClosestPointWithinRadius(double x[3], double radius, double closestPoint[3], vtkIdType &cellId, int &subId, double &dist2) FindClosestPointWithinRadius(self, x:[float, float, float], radius:float, closestPoint:[float, float, float], cell:vtkGenericCell, cellId:int, subId:int, dist2:float) -> int C++: virtual vtkIdType FindClosestPointWithinRadius(double x[3], double radius, double closestPoint[3], vtkGenericCell *cell, vtkIdType &cellId, int &subId, double &dist2) Return the closest point within a specified radius and the cell which is closest to the point x. The closest point is somewhere on a cell, it need not be one of the vertices of the cell. This method returns 1 if a point is found within the specified radius. If there are no cells within the specified radius, the method returns 0 and the values of closestPoint, cellId, subId, and dist2 are undefined. If a closest point is found, inside returns the return value of the EvaluatePosition call to the closest cell; inside(=1) or outside(=0). """ 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; Satisfy vtkLocator abstract interface. """ 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 GetUseDiagonalLengthTolerance(self): # real signature unknown; restored from __doc__ """ GetUseDiagonalLengthTolerance(self) -> bool C++: virtual bool GetUseDiagonalLengthTolerance() """ return False def InsideCellBounds(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsideCellBounds(self, x:[float, float, float], cellId:int) -> bool C++: bool InsideCellBounds(double x[3], vtkIdType cellId) override; Quickly test if a point is inside the bounds of a particular cell. This function should be used ONLY after the locator is built. """ 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, x:[float, float, float], pcoords:[float, float, float], subId:int, cellId:int, cell:vtkGenericCell) -> int C++: int IntersectWithLine(const double a0[3], const double a1[3], double tol, double &t, double x[3], double pcoords[3], int &subId, vtkIdType &cellId, vtkGenericCell *cell) override; IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), tol:float, points:vtkPoints, cellIds:vtkIdList, cell:vtkGenericCell) -> int C++: int IntersectWithLine(const double p1[3], const double p2[3], const double tol, vtkPoints *points, vtkIdList *cellIds, vtkGenericCell *cell) override; IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), tol:float, t:float, x:[float, float, float], pcoords:[float, float, float], subId:int) -> int C++: virtual int IntersectWithLine(const double p1[3], const double p2[3], double tol, double &t, double x[3], double pcoords[3], int &subId) IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), tol:float, t:float, x:[float, float, float], pcoords:[float, float, float], subId:int, cellId:int) -> int C++: virtual int IntersectWithLine(const double p1[3], const double p2[3], double tol, double &t, double x[3], double pcoords[3], int &subId, vtkIdType &cellId) IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), points:vtkPoints, cellIds:vtkIdList) -> int C++: virtual int IntersectWithLine(const double p1[3], const double p2[3], vtkPoints *points, vtkIdList *cellIds) IntersectWithLine(self, p1:(float, float, float), p2:(float, float, float), tol:float, points:vtkPoints, cellIds:vtkIdList) -> int C++: virtual int IntersectWithLine(const double p1[3], const double p2[3], const double tol, vtkPoints *points, vtkIdList *cellIds) Return intersection point (if any) AND the ... [Truncated] """ 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) -> vtkStaticCellLocator C++: vtkStaticCellLocator *NewInstance() """ return vtkStaticCellLocator def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkStaticCellLocator C++: static vtkStaticCellLocator *SafeDownCast(vtkObjectBase *o) """ return vtkStaticCellLocator 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 NumberOfCellsPerNode 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 SetUseDiagonalLengthTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetUseDiagonalLengthTolerance(self, _arg:bool) -> None C++: virtual void SetUseDiagonalLengthTolerance(bool _arg) These methods are deprecated. This flag was used in internally in conjunction with Tolerance, which has been removed because nobody was using it, and it would lead to really slow performance if the dataset was small bounds-wise. Tolerance was originally introduced to solve IntersectionWithLine issues the existed before. These issues have been resolved by using double tolerance internally. When set to true, the CellBinner will multiply the locator tolerance by the diagonal length of the dataset to compute its own tolerance. When not, it uses the locator tolerance directly. Default is false. """ pass def ShallowCopy(self, locator): # real signature unknown; restored from __doc__ """ ShallowCopy(self, locator:vtkAbstractCellLocator) -> None C++: void ShallowCopy(vtkAbstractCellLocator *locator) override; Shallow copy of a vtkStaticCellLocator. """ pass def UseDiagonalLengthToleranceOff(self): # real signature unknown; restored from __doc__ """ UseDiagonalLengthToleranceOff(self) -> None C++: virtual void UseDiagonalLengthToleranceOff() """ pass def UseDiagonalLengthToleranceOn(self): # real signature unknown; restored from __doc__ """ UseDiagonalLengthToleranceOn(self) -> None C++: virtual void UseDiagonalLengthToleranceOn() """ 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__': 'vtkStaticCellLocator', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetDivisions': , 'GetDivisions': , 'SetMaxNumberOfBuckets': , 'GetMaxNumberOfBucketsMinValue': , 'GetMaxNumberOfBucketsMaxValue': , 'GetMaxNumberOfBuckets': , 'GetLargeIds': , 'SetUseDiagonalLengthTolerance': , 'GetUseDiagonalLengthTolerance': , 'UseDiagonalLengthToleranceOn': , 'UseDiagonalLengthToleranceOff': , 'IntersectWithLine': , 'FindClosestPoint': , 'FindClosestPointWithinRadius': , 'FindCellsWithinBounds': , 'FindCellsAlongLine': , 'FindCellsAlongPlane': , 'FindCell': , 'InsideCellBounds': , 'GenerateRepresentation': , 'FreeSearchStructure': , 'BuildLocator': , 'ForceBuildLocator': , 'ShallowCopy': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkStaticCellLocator - perform fast cell location operations\\n\\nSuperclass: vtkAbstractCellLocator\\n\\nvtkStaticCellLocator is a type of vtkAbstractCellLocator that\\naccelerates certain operations when performing spatial operations on\\ncells. These operations include finding a point that contains a cell,\\nand intersecting cells with a line.\\n\\nvtkStaticCellLocator is an accelerated version of vtkCellLocator. It\\nis threaded (via vtkSMPTools), and supports one-time static\\nconstruction (i.e., incremental cell insertion is not supported).\\n\\n@warning\\nvtkStaticCellLocator utilizes the following parent class parameters:\\n- Automatic (default true)\\n- NumberOfCellsPerNode (default 10)\\n- UseExistingSearchStructure (default false)\\n\\nvtkStaticCellLocator does NOT utilize the following parameters:\\n- CacheCellBounds (always cached)\\n- Tolerance\\n- Level\\n- MaxLevel\\n- RetainCellLists\\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@sa\\nvtkAbstractCellLocator vtkCellLocator vtkCellTreeLocator\\nvtkModifiedBSPTree vtkOBBTree\\n\\n'})" __vtkname__ = 'vtkStaticCellLocator'