# 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 vtkSphericalPointIterator(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSphericalPointIterator - Traverse a collection of points in spherical ordering. Superclass: vtkObject vtkSphericalPointIterator is a state-based iterator for traversing a set of points (i.e., a neighborhood of points) in a dataset, providing a point traversal order across user-defined "axes" which span a 2D or 3D space (typically a circle or sphere). The points along each axes may be sorted in increasing radial order. To define the points, specify a dataset (i.e., its associated points, whether the points are represented implicitly or explicitly) and an associated neighborhood over which to iterate. Methods for iterating over the points are provided. For example, consider the axes of iteration to be the four rays emanating from the center of a square and passing through the center of each of the four edges of the square. Points to be iterated over are associated (using a dot product) with each of the four axes, and then can be sorted along each axis. Then the order of iteration is then: (axis0,pt0), (axis1,pt0), (axis2,pt0), (axis3,pt0), (axis0,pt1), (axis1,pt1), (axis2,pt1), (axis3,pt1), (axis0,pt2), (axis1,pt2), (axis2,pt2), (axis3,pt2), and so on in a "spiraling" fashion until all points are visited. Thus the order of visitation is: iteration i visits all N axes in order, returning the jth point sorted along each of the N axes (i.e., i increases the fastest). Alternatively, methods exist to randomly access points, or points associated with an axes, so that custom iteration methods can be defined. The iterator can be defined with any number of axes (defined by 3D vectors). The axes must not be coincident, and typically are equally spaced from one another. The order which the axes are defined determines the order in which the axes (and hence the points) are traversed. So for example, in a 2D sphere, four axes in the (-x,+x,-y,+y) directions would provide a "ping pong" iteration, while four axes ordered in the (+x,+y,-x,-y) directions would provide a counterclockwise rotation iteration. The iterator provides thread-safe iteration of dataset points. It supports both random and forward iteration. @warning The behavior of the iterator depends on the ordering of the iteration axes. It is possible to obtain a wide variety of iteration patterns depending on these axes. For example, if only one axis is defined, then a "linear" pattern is possible (i.e., visiting points in the half space defined by the vector); if two axes, then a "diagonal" iteration pattern; and so on. Note that points are sorted along the iteration axes depending on the their projection onto them (e.g., using the dot product). Because only points with positive projection are associated with an axis, it is possible that some points in the neighborhood will not be processed (i.e., if a point in the neighborhood does not positively project onto any of the axes, then it will not be iterated over). Thus if all points are to be iterated over, then the axes must form a basis which covers all points using positive projections. @sa vtkVoronoi2D vtkVoronoi3D vtkStaticPointLocator vtkPointLocator """ def BuildRepresentation(self, pd): # real signature unknown; restored from __doc__ """ BuildRepresentation(self, pd:vtkPolyData) -> None C++: void BuildRepresentation(vtkPolyData *pd) A convenience method that produces a geometric representation of the iterator (e.g., axes + center). The representation simply draws lines for each of the axes emanating from the center point. Each line (or line cell) is assigned cell data which is the axis number. This is typically used for debugging or educational purposes. Note that the method is valid only after Initialize() has been invoked. """ pass def GetAxes(self): # real signature unknown; restored from __doc__ """ GetAxes(self) -> vtkDoubleArray C++: virtual vtkDoubleArray *GetAxes() """ pass def GetAxisPoints(self, axis, npts, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetAxisPoints(self, axis:int, npts:int, pts:(int, ...)) -> None C++: void GetAxisPoints(int axis, vtkIdType &npts, const vtkIdType *&pts) Return the list of points along the specified ith axis. """ pass def GetCurrentPoint(self, ptId, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCurrentPoint(self, ptId:int, x:[float, float, float]) -> None C++: void GetCurrentPoint(vtkIdType &ptId, double x[3]) GetCurrentPoint(self) -> int C++: vtkIdType GetCurrentPoint() Get the current point (point id and coordinates) during forward iteration. """ pass def GetDataSet(self): # real signature unknown; restored from __doc__ """ GetDataSet(self) -> vtkDataSet C++: virtual vtkDataSet *GetDataSet() """ return vtkDataSet def GetNumberOfAxes(self): # real signature unknown; restored from __doc__ """ GetNumberOfAxes(self) -> int C++: vtkIdType GetNumberOfAxes() Return the number of axes defined. The value returned is valid only after Initialize() is invoked. """ 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 GetPoint(self, axis, ptIdx): # real signature unknown; restored from __doc__ """ GetPoint(self, axis:int, ptIdx:int) -> int C++: vtkIdType GetPoint(int axis, int ptIdx) Provide random access to the jth point of the ith axis. Returns the point id located at (axis,ptIdx); or a value <0 if the requested point does not exist. """ return 0 def GetSorting(self): # real signature unknown; restored from __doc__ """ GetSorting(self) -> int C++: virtual int GetSorting() """ return 0 def GetSortingMaxValue(self): # real signature unknown; restored from __doc__ """ GetSortingMaxValue(self) -> int C++: virtual int GetSortingMaxValue() """ return 0 def GetSortingMinValue(self): # real signature unknown; restored from __doc__ """ GetSortingMinValue(self) -> int C++: virtual int GetSortingMinValue() """ return 0 def GoToFirstPoint(self): # real signature unknown; restored from __doc__ """ GoToFirstPoint(self) -> None C++: void GoToFirstPoint() Begin iterating over the neighborhood of points. It is possible that not all points are iterated over - those points not projecting onto any axis with a positive dot product are not visited. """ pass def GoToNextPoint(self): # real signature unknown; restored from __doc__ """ GoToNextPoint(self) -> None C++: void GoToNextPoint() Go to the next point in the neighborhood. This is only valid when IsDoneWithTraversal() returns false; """ pass def Initialize(self, center, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Initialize(self, center:[float, float, float], neighborhood:vtkIdList) -> bool C++: bool Initialize(double center[3], vtkIdList *neighborhood) Initialize(self, center:[float, float, float], numNei:int, neighborhood:[int, ...]) -> bool C++: bool Initialize(double center[3], vtkIdType numNei, vtkIdType *neighborhood) Initialize(self, center:[float, float, float]) -> bool C++: bool Initialize(double center[3]) Initialize the iteration process around a position [x], over a set of points (the neighborhood) defined by a list of numNei point ids. (The point ids refer to the points contained in the dataset.) If initialization fails (because the Axes or the DataSet have not been defined) then false is returned; true otherwise. One of the Initialize() variants enables iteration over all points in the dataset. """ 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 IsDoneWithTraversal(self): # real signature unknown; restored from __doc__ """ IsDoneWithTraversal(self) -> bool C++: bool IsDoneWithTraversal() Return true if set traversal is completed. Otherwise false. """ return False 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) -> vtkSphericalPointIterator C++: vtkSphericalPointIterator *NewInstance() """ return vtkSphericalPointIterator def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSphericalPointIterator C++: static vtkSphericalPointIterator *SafeDownCast( vtkObjectBase *o) """ return vtkSphericalPointIterator def SetAxes(self, _arg): # real signature unknown; restored from __doc__ """ SetAxes(self, _arg:vtkDoubleArray) -> None C++: virtual void SetAxes(vtkDoubleArray *_arg) SetAxes(self, axesType:int, resolution:int=6) -> None C++: void SetAxes(int axesType, int resolution=6) Define the axes for the point iterator. This only needs to be defined once (typically immediately after instantiation). The axes data array must be a 3-component array, where each 3-tuple defines a vector defining a axis. The number of axes is limited to 100,000 or less (typically the numbers of axes are <=20). The order in which the axes are defined determines the order in which the axes are traversed. Depending on the order, it's possible to create a variety of traversal patterns, ranging from clockwise/counterclockwise to spiral to ping pong (e.g., -x,+x, -y,+y, -z,+z). Note: the defining axes need not be normalized, they are normalized and copied into internal iterator storage in the Initialize() method. """ pass def SetDataSet(self, _arg): # real signature unknown; restored from __doc__ """ SetDataSet(self, _arg:vtkDataSet) -> None C++: virtual void SetDataSet(vtkDataSet *_arg) Define the dataset and its associated points over which to iterate. """ pass def SetSorting(self, _arg): # real signature unknown; restored from __doc__ """ SetSorting(self, _arg:int) -> None C++: virtual void SetSorting(int _arg) Specify whether points along each axis are radially sorted, and if so, whether in an ascending or descending direction. (Note that some operators such as the locator query FindClosestNPoints() return radially sorted neighborhoods in ascending direction and often do not need sorting - this can save significant time.) """ pass def SetSortTypeToAscending(self): # real signature unknown; restored from __doc__ """ SetSortTypeToAscending(self) -> None C++: void SetSortTypeToAscending() """ pass def SetSortTypeToDescending(self): # real signature unknown; restored from __doc__ """ SetSortTypeToDescending(self) -> None C++: void SetSortTypeToDescending() """ pass def SetSortTypeToNone(self): # real signature unknown; restored from __doc__ """ SetSortTypeToNone(self) -> None C++: void SetSortTypeToNone() """ 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.""" AxesType = None # (!) real value is "" CUBE_AXES = 3 CUBE_OCTAHEDRON_AXES = 5 DODECAHEDRON_AXES = 6 ICOSAHEDRON_AXES = 7 OCTAHEDRON_AXES = 4 SortType = None # (!) real value is "" SORT_ASCENDING = 1 SORT_DESCENDING = 2 SORT_NONE = 0 XY_CCW_AXES = 1 XY_CW_AXES = 0 XY_SQUARE_AXES = 2 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSphericalPointIterator\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'SetDataSet\': , \'GetDataSet\': , \'SetAxes\': , \'GetAxes\': , \'SetSorting\': , \'GetSortingMinValue\': , \'GetSortingMaxValue\': , \'GetSorting\': , \'SetSortTypeToNone\': , \'SetSortTypeToAscending\': , \'SetSortTypeToDescending\': , \'Initialize\': , \'GoToFirstPoint\': , \'IsDoneWithTraversal\': , \'GoToNextPoint\': , \'GetCurrentPoint\': , \'GetPoint\': , \'GetNumberOfAxes\': , \'GetAxisPoints\': , \'BuildRepresentation\': , \'AxesType\': , \'SortType\': , \'XY_CW_AXES\': 0, \'XY_CCW_AXES\': 1, \'XY_SQUARE_AXES\': 2, \'CUBE_AXES\': 3, \'OCTAHEDRON_AXES\': 4, \'CUBE_OCTAHEDRON_AXES\': 5, \'DODECAHEDRON_AXES\': 6, \'ICOSAHEDRON_AXES\': 7, \'SORT_NONE\': 0, \'SORT_ASCENDING\': 1, \'SORT_DESCENDING\': 2, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': \'vtkSphericalPointIterator - Traverse a collection of points in\\nspherical ordering.\\n\\nSuperclass: vtkObject\\n\\nvtkSphericalPointIterator is a state-based iterator for traversing a\\nset of points (i.e., a neighborhood of points) in a dataset,\\nproviding a point traversal order across user-defined "axes" which\\nspan a 2D or 3D space (typically a circle or sphere). The points\\nalong each axes may be sorted in increasing radial order. To define\\nthe points, specify a dataset (i.e., its associated points, whether\\nthe points are represented implicitly or explicitly) and an\\nassociated neighborhood over which to iterate. Methods for iterating\\nover the points are provided.\\n\\nFor example, consider the axes of iteration to be the four rays\\nemanating from the center of a square and passing through the center\\nof each of the four edges of the square. Points to be iterated over\\nare associated (using a dot product) with each of the four axes, and\\nthen can be sorted along each axis. Then the order of iteration is\\nthen: (axis0,pt0), (axis1,pt0), (axis2,pt0), (axis3,pt0),\\n(axis0,pt1), (axis1,pt1), (axis2,pt1), (axis3,pt1), (axis0,pt2),\\n(axis1,pt2), (axis2,pt2), (axis3,pt2), and so on in a "spiraling"\\nfashion until all points are visited. Thus the order of visitation\\nis: iteration i visits all N axes in order, returning the jth point\\nsorted along each of the N axes (i.e., i increases the fastest).\\nAlternatively, methods exist to randomly access points, or points\\nassociated with an axes, so that custom iteration methods can be\\ndefined.\\n\\nThe iterator can be defined with any number of axes (defined by 3D\\nvectors). The axes must not be coincident, and typically are equally\\nspaced from one another. The order which the axes are defined\\ndetermines the order in which the axes (and hence the points) are\\ntraversed. So for example, in a 2D sphere, four axes in the\\n(-x,+x,-y,+y) directions would provide a "ping pong" iteration, while\\nfour axes ordered in the (+x,+y,-x,-y) directions would provide a\\ncounterclockwise rotation iteration.\\n\\nThe iterator provides thread-safe iteration of dataset points. It\\nsupports both random and forward iteration.\\n\\n@warning\\nThe behavior of the iterator depends on the ordering of the iteration\\naxes. It is possible to obtain a wide variety of iteration patterns\\ndepending on these axes. For example, if only one axis is defined,\\nthen a "linear" pattern is possible (i.e., visiting points in the\\nhalf space defined by the vector); if two axes, then a "diagonal"\\niteration pattern; and so on. Note that points are sorted along the\\niteration axes depending on the their projection onto them (e.g.,\\nusing the dot product). Because only points with positive projection\\nare associated with an axis, it is possible that some points in the\\nneighborhood will not be processed (i.e., if a point in the\\nneighborhood does not positively project onto any of the axes, then\\nit will not be iterated over). Thus if all points are to be iterated\\nover, then the axes must form a basis which covers all points using\\npositive projections.\\n\\n@sa\\nvtkVoronoi2D vtkVoronoi3D vtkStaticPointLocator vtkPointLocator\\n\\n\'})' __vtkname__ = 'vtkSphericalPointIterator'