# 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 class vtkFindCellStrategy(__vtkmodules_vtkCommonCore.vtkObject): """ vtkFindCellStrategy - helper class to manage the vtkPointSet::FindCell() METHOD Superclass: vtkObject vtkFindCellStrategy is a helper class to manage the use of locators for locating cells containing a query point x[3], the so-called FindCell() method. The use of vtkDataSet::FindCell() is a common operation in applications such as streamline generation and probing. However, in some dataset types FindCell() can be implemented very simply (e.g., vtkImageData) while in other datasets it is a complex operation requiring supplemental objects like locators to perform efficiently. In particular, vtkPointSet and its subclasses (like vtkUnstructuredGrid) require complex strategies to efficiently implement the FindCell() operation. Subclasses of the abstract vtkFindCellStrategy implement several of these strategies. The are two key methods to this class and subclasses. The Initialize() method negotiates with an input dataset to define the locator to use: either a locator associated with the input dataset, or possibly an alternative locator defined by the strategy (subclasses of vtkFindCellStrategy do this). The second important method, FindCell() mimics vtkDataSet::FindCell() and can be used in place of it. Note that vtkFindCellStrategy is in general not thread-safe as the strategies contain state used to accelerate the search process. Hence if multiple threads are attempting to invoke FindCell(), each thread needs to have its own instance of the vtkFindCellStrategy. @sa vtkPointSet vtkPolyData vtkStructuredGrid vtkUnstructuredGrid vtkAbstractInterpolatedVelocityField vtkClosetPointStrategy vtkCellLocatorStrategy vtkClosestNPointsStrategy """ def CopyParameters(self, from_): # real signature unknown; restored from __doc__ """ CopyParameters(self, from_:vtkFindCellStrategy) -> None C++: virtual void CopyParameters(vtkFindCellStrategy *from) Copy essential parameters between instances of this class. This generally is used to copy from instance prototype to another, or to copy strategies between thread instances. Sub-classes can contribute to the parameter copying process via chaining. """ pass def FindCell(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindCell(self, x:[float, float, float], cell:vtkCell, gencell:vtkGenericCell, cellId:int, tol2:float, subId:int, pcoords:[float, float, float], weights:[float, ...]) -> int C++: virtual vtkIdType FindCell(double x[3], vtkCell *cell, vtkGenericCell *gencell, vtkIdType cellId, double tol2, int &subId, double pcoords[3], double *weights) Virtual method for finding a cell. Subclasses must satisfy this API. This method is of the same signature as vtkDataSet::FindCell(). This method is not thread safe: separate instances of vtkFindCellStrategy should be created for each thread invoking FindCell(). This is done for performance reasons to reduce the number of objects created/destroyed on each FindCell() invocation. """ 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++: virtual vtkIdType FindClosestPointWithinRadius(double x[3], double radius, double closestPoint[3], vtkGenericCell *cell, vtkIdType &cellId, int &subId, double &dist2, int &inside) 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. This version takes in a vtkGenericCell to avoid allocating and deallocating the cell. This is much faster than the version which does not take a *cell, especially when this function is called many times in a row such as by a for loop, where the allocation and dealloction can be done only once outside the for loop. If a closest point is found, "cell" contains the points and ptIds for the cell "cellId" upon exit. 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 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 Initialize(self, ps): # real signature unknown; restored from __doc__ """ Initialize(self, ps:vtkPointSet) -> int C++: virtual int Initialize(vtkPointSet *ps) All subclasses of this class must provide an initialize method. This method performs handshaking and setup between the vtkPointSet dataset and associated locator(s). A return value==0 means the initialization process failed. The initialization is set up in such a way as to prevent multiple locators from being built. """ return 0 def InsideCellBounds(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InsideCellBounds(self, x:[float, float, float], cellId:int) -> bool C++: virtual bool InsideCellBounds(double x[3], vtkIdType cellId) Quickly test if a point is inside the bounds of a particular cell. """ 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) -> vtkFindCellStrategy C++: vtkFindCellStrategy *NewInstance() """ return vtkFindCellStrategy def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkFindCellStrategy C++: static vtkFindCellStrategy *SafeDownCast(vtkObjectBase *o) """ return vtkFindCellStrategy 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__': 'vtkFindCellStrategy', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'Initialize': , 'FindCell': , 'FindClosestPointWithinRadius': , 'InsideCellBounds': , 'CopyParameters': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkFindCellStrategy - helper class to manage the\\nvtkPointSet::FindCell() METHOD\\n\\nSuperclass: vtkObject\\n\\nvtkFindCellStrategy is a helper class to manage the use of locators\\nfor locating cells containing a query point x[3], the so-called\\nFindCell() method. The use of vtkDataSet::FindCell() is a common\\noperation in applications such as streamline generation and probing.\\nHowever, in some dataset types FindCell() can be implemented very\\nsimply (e.g., vtkImageData) while in other datasets it is a complex\\noperation requiring supplemental objects like locators to perform\\nefficiently. In particular, vtkPointSet and its subclasses (like\\nvtkUnstructuredGrid) require complex strategies to efficiently\\nimplement the FindCell() operation. Subclasses of the abstract\\nvtkFindCellStrategy implement several of these strategies.\\n\\nThe are two key methods to this class and subclasses. The\\nInitialize() method negotiates with an input dataset to define the\\nlocator to use: either a locator associated with the input dataset,\\nor possibly an alternative locator defined by the strategy\\n(subclasses of vtkFindCellStrategy do this). The second important\\nmethod, FindCell() mimics vtkDataSet::FindCell() and can be used in\\nplace of it.\\n\\nNote that vtkFindCellStrategy is in general not thread-safe as the\\nstrategies contain state used to accelerate the search process. Hence\\nif multiple threads are attempting to invoke FindCell(), each thread\\nneeds to have its own instance of the vtkFindCellStrategy.\\n\\n@sa\\nvtkPointSet vtkPolyData vtkStructuredGrid vtkUnstructuredGrid\\nvtkAbstractInterpolatedVelocityField vtkClosetPointStrategy\\nvtkCellLocatorStrategy vtkClosestNPointsStrategy\\n\\n'})" __vtkname__ = 'vtkFindCellStrategy'