# 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 .vtkCell3D import vtkCell3D class vtkPolyhedron(vtkCell3D): """ vtkPolyhedron - a 3D cell defined by a set of polygonal faces Superclass: vtkCell3D vtkPolyhedron is a concrete implementation that represents a 3D cell defined by a set of polygonal faces. The polyhedron should be watertight, non-self-intersecting and manifold (each edge is used twice). Interpolation functions and weights are defined / computed using the method of Mean Value Coordinates (MVC). See the VTK class vtkMeanValueCoordinatesInterpolator for more information. The class does not require the polyhedron to be convex. However, the polygonal faces must be planar. Non-planar polygonal faces will definitely cause problems, especially in severely warped situations. @sa vtkCell3D vtkConvexPointSet vtkMeanValueCoordinatesInterpolator """ def CellBoundary(self, subId, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CellBoundary(self, subId:int, pcoords:(float, float, float), pts:vtkIdList) -> int C++: int CellBoundary(int subId, const double pcoords[3], vtkIdList *pts) override; Find the boundary face closest to the point defined by the pcoords[3] and subId of the cell (subId can be ignored). """ pass def Clip(self, value, scalars, locator, connectivity, inPd, outPd, inCd, cellId, outCd, insideOut): # real signature unknown; restored from __doc__ """ Clip(self, value:float, scalars:vtkDataArray, locator:vtkIncrementalPointLocator, connectivity:vtkCellArray, inPd:vtkPointData, outPd:vtkPointData, inCd:vtkCellData, cellId:int, outCd:vtkCellData, insideOut:int) -> None C++: void Clip(double value, vtkDataArray *scalars, vtkIncrementalPointLocator *locator, vtkCellArray *connectivity, vtkPointData *inPd, vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId, vtkCellData *outCd, int insideOut) override; Satisfy the vtkCell API. This method clips the input polyhedron and outputs a new polyhedron. The face information of the output polyhedron is encoded in the output vtkCellArray using a special format: CellLength [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]. Use the static method vtkUnstructuredGrid::DecomposePolyhedronCellArray to convert it into a standard format. Note: the algorithm assumes water-tight polyhedron cells. """ pass def Contour(self, value, scalars, locator, verts, lines, polys, inPd, outPd, inCd, cellId, outCd): # real signature unknown; restored from __doc__ """ Contour(self, value:float, scalars:vtkDataArray, locator:vtkIncrementalPointLocator, verts:vtkCellArray, lines:vtkCellArray, polys:vtkCellArray, inPd:vtkPointData, outPd:vtkPointData, inCd:vtkCellData, cellId:int, outCd:vtkCellData) -> None C++: void Contour(double value, vtkDataArray *scalars, vtkIncrementalPointLocator *locator, vtkCellArray *verts, vtkCellArray *lines, vtkCellArray *polys, vtkPointData *inPd, vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId, vtkCellData *outCd) override; Satisfy the vtkCell API. This method contours the input polyhedron and outputs a polygon. When the result polygon is not planar, it will be triangulated. The current implementation assumes water-tight polyhedron cells. """ pass def Derivatives(self, subId, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Derivatives(self, subId:int, pcoords:(float, float, float), values:(float, ...), dim:int, derivs:[float, ...]) -> None C++: void Derivatives(int subId, const double pcoords[3], const double *values, int dim, double *derivs) override; Computes derivatives at the point specified by the parameter coordinate. Current implementation uses all vertices and subId is not used. To accelerate the speed, the future implementation can triangulate and extract the local tetrahedron from subId and pcoords, then evaluate derivatives on the local tetrahedron. """ pass def EvaluateLocation(self, subId, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EvaluateLocation(self, subId:int, pcoords:(float, float, float), x:[float, float, float], weights:[float, ...]) -> None C++: void EvaluateLocation(int &subId, const double pcoords[3], double x[3], double *weights) override; The inverse of EvaluatePosition. Note the weights should be the MVC weights. """ pass def EvaluatePosition(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EvaluatePosition(self, x:(float, float, float), closestPoint:[float, float, float], subId:int, pcoords:[float, float, float], dist2:float, weights:[float, ...]) -> int C++: int EvaluatePosition(const double x[3], double closestPoint[3], int &subId, double pcoords[3], double &dist2, double weights[]) override; Satisfy the vtkCell API. The subId is ignored and zero is always returned. The parametric coordinates pcoords are normalized values in the bounding box of the polyhedron. The weights are determined by evaluating the MVC coordinates. The dist is always zero if the point x[3] is inside the polyhedron; otherwise it's the distance to the surface. """ pass def GetCellType(self): # real signature unknown; restored from __doc__ """ GetCellType(self) -> int C++: int GetCellType() override; See the vtkCell API for descriptions of these methods. """ return 0 def GetCentroid(self, centroid, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCentroid(self, centroid:[float, float, float]) -> bool C++: bool GetCentroid(double centroid[3]) override; Computes the centroid of the cell. """ pass def GetEdge(self, __a): # real signature unknown; restored from __doc__ """ GetEdge(self, __a:int) -> vtkCell C++: vtkCell *GetEdge(int) override; Return the edge cell from the edgeId of the cell. """ return vtkCell def GetEdgePoints(self, edgeId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetEdgePoints(self, edgeId:int, pts:(int, ...)) -> None C++: void GetEdgePoints(vtkIdType edgeId, const vtkIdType *&pts) override; See vtkCell3D API for description of these methods. @warning These method are unimplemented in vtkPolyhedron """ pass def GetEdgeToAdjacentFaces(self, edgeId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetEdgeToAdjacentFaces(self, edgeId:int, pts:(int, ...)) -> None C++: void GetEdgeToAdjacentFaces(vtkIdType edgeId, const vtkIdType *&pts) override; Get the ids of the two adjacent faces to edge of id edgeId. The output face ids are sorted from id of lowest rank to highest. Note that the faces are 0-offset; that is, they refer to the ids of the cells, not the face ids of the mesh that the cell belongs to. The edgeId must range between 0<=edgeIdGetNumberOfEdges(). """ pass def GetFace(self, faceId): # real signature unknown; restored from __doc__ """ GetFace(self, faceId:int) -> vtkCell C++: vtkCell *GetFace(int faceId) override; Return the face cell from the faceId of the cell. The returned vtkCell is an object owned by this instance, hence the return value must not be deleted by the caller. @warning Repeat calls to this function for different face ids will change the data stored in the internal member object whose pointer is returned by this function. @warning THIS METHOD IS NOT THREAD SAFE. """ return vtkCell def GetFacePoints(self, faceId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetFacePoints(self, faceId:int, pts:(int, ...)) -> int C++: vtkIdType GetFacePoints(vtkIdType faceId, const vtkIdType *&pts) override; Get the list of vertices that define a face. The list is terminated with a negative number. Note that the vertices are 0-offset; that is, they refer to the ids of the cell, not the point ids of the mesh that the cell belongs to. The faceId must range between 0<=faceIdGetNumberOfFaces(). @return The number of points in face faceId """ pass def GetFaces(self): # real signature unknown; restored from __doc__ """ GetFaces(self) -> Pointer C++: vtkIdType *GetFaces() override; """ pass def GetFaceToAdjacentFaces(self, faceId, faceIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetFaceToAdjacentFaces(self, faceId:int, faceIds:(int, ...)) -> int C++: vtkIdType GetFaceToAdjacentFaces(vtkIdType faceId, const vtkIdType *&faceIds) override; Get the ids of the adjacent faces to face of id faceId. The order of faces is consistent. They are always ordered in counter clockwise w.r.t. normal orientation. The first id faces[0] corresponds to the face sharing point of id pts[0] where pts is obtained from this->GetFacePoints(faceId, pts), being the "most counter clockwise" oriented w.r.t. face faceId. Note that the faces are 0-offset; that is, they refer to the ids of the cell, not the face ids of the mesh that the cell belongs to. The faceId must be between 0<=faceIdGetNumberOfFaces(); @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is inverted. @return The number of adjacent faces to faceId. """ pass def GetNumberOfEdges(self): # real signature unknown; restored from __doc__ """ GetNumberOfEdges(self) -> int C++: int GetNumberOfEdges() override; A polyhedron is represented internally by a set of polygonal faces. These faces can be processed to explicitly determine edges. """ return 0 def GetNumberOfFaces(self): # real signature unknown; restored from __doc__ """ GetNumberOfFaces(self) -> int C++: int GetNumberOfFaces() override; Return the number of faces in the cell. """ 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 GetParametricCenter(self, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetParametricCenter(self, pcoords:[float, float, float]) -> int C++: int GetParametricCenter(double pcoords[3]) override; Return the center of the cell in parametric coordinates. In this cell, the center of the bounding box is returned. """ pass def GetParametricCoords(self): # real signature unknown; restored from __doc__ """ GetParametricCoords(self) -> (float, ...) C++: double *GetParametricCoords() override; See vtkCell3D API for description of this method. """ pass def GetPointToIncidentEdges(self, pointId, edgeIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointToIncidentEdges(self, pointId:int, edgeIds:(int, ...)) -> int C++: vtkIdType GetPointToIncidentEdges(vtkIdType pointId, const vtkIdType *&edgeIds) override; Get the ids of the incident edges to point of id pointId. Edges are sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell at point of id pointId. The first edge corresponds to the edge containing point of id pts[0], where pts is obtained from this->GetPointToOnRingVertices(pointId, pts). Note that the edges are 0-offset; that is, they refer to the ids of the cell, not the edge ids of the mesh that the cell belongs to. The edgeId must be between 0<=edgeIdGetNumberOfEdges(); @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is inverted. @return The valence of point pointId. """ pass def GetPointToIncidentFaces(self, pointId, faceIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointToIncidentFaces(self, pointId:int, faceIds:(int, ...)) -> int C++: vtkIdType GetPointToIncidentFaces(vtkIdType pointId, const vtkIdType *&faceIds) override; Get the ids of the incident faces point of id pointId. Faces are sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell at point of id pointId. The first face corresponds to the face containing edge of id edges[0], where edges is obtained from this->GetPointToIncidentEdges(pointId, edges), such that face faces[0] is the "most counterclockwise" face incident to point pointId containing edges[0]. Note that the faces are 0-offset; that is, they refer to the ids of the cell, not the face ids of the mesh that the cell belongs to. The pointId must be between 0<=pointIdGetNumberOfPoints(). @warning If the vtkCell3D is "inside out", i.e. normals point inside the cell, the order is inverted. @return The valence of point pointId. """ pass def GetPointToOneRingPoints(self, pointId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointToOneRingPoints(self, pointId:int, pts:(int, ...)) -> int C++: vtkIdType GetPointToOneRingPoints(vtkIdType pointId, const vtkIdType *&pts) override; Get the ids of a one-ring surrounding point of id pointId. Points are sorted in counter clockwise order w.r.t. bisectrix pointing outside the cell at point of id pointId. The first point corresponds to the point contained in edges[0], where edges is obtained from this->GetPointToIncidentEdges(pointId, edges). Note that the points are 0-offset; that is, they refer to the ids of the cell, not the point ids of the mesh that the cell belongs to. The pointId must be between 0GetNumberOfPoints(). @return The valence of point pointId. """ pass def GetPolyData(self): # real signature unknown; restored from __doc__ """ GetPolyData(self) -> vtkPolyData C++: vtkPolyData *GetPolyData() Construct polydata if no one exist, then return this->PolyData """ return vtkPolyData def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() override; """ pass def InterpolateDerivs(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InterpolateDerivs(self, x:(float, float, float), derivs:[float, ...]) -> None C++: void InterpolateDerivs(const double x[3], double *derivs) override; """ pass def InterpolateFunctions(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InterpolateFunctions(self, x:(float, float, float), sf:[float, ...]) -> None C++: void InterpolateFunctions(const double x[3], double *sf) override; Compute the interpolation functions/derivatives (aka shape functions/derivatives). Here we use the MVC calculation process to compute the interpolation functions. """ pass def IntersectWithLine(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ 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++: int IntersectWithLine(const double p1[3], const double p2[3], double tol, double &t, double x[3], double pcoords[3], int &subId) override; Intersect the line (p1,p2) with a given tolerance tol to determine a point of intersection x[3] with parametric coordinate t along the line. The parametric coordinates are returned as well (subId can be ignored). Returns true if the line intersects a face. """ 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 IsConvex(self): # real signature unknown; restored from __doc__ """ IsConvex(self) -> bool C++: bool IsConvex() Determine whether or not a polyhedron is convex. This method is adapted from Devillers et al., "Checking the Convexity of Polytopes and the Planarity of Subdivisions", Computational Geometry, Volume 11, Issues 3 - 4, December 1998, Pages 187 - 208. """ return False def IsInside(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IsInside(self, x:(float, float, float), tolerance:float) -> int C++: int IsInside(const double x[3], double tolerance) A method particular to vtkPolyhedron. It determines whether a point x[3] is inside the polyhedron or not (returns 1 is the point is inside, 0 otherwise). The tolerance is expressed in normalized space; i.e., a fraction of the size of the bounding box. """ pass def IsPrimaryCell(self): # real signature unknown; restored from __doc__ """ IsPrimaryCell(self) -> int C++: int IsPrimaryCell() override; A polyhedron is a full-fledged primary cell. """ 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) -> vtkPolyhedron C++: vtkPolyhedron *NewInstance() """ return vtkPolyhedron def RequiresExplicitFaceRepresentation(self): # real signature unknown; restored from __doc__ """ RequiresExplicitFaceRepresentation(self) -> int C++: int RequiresExplicitFaceRepresentation() override; Methods supporting the definition of faces. Note that the GetFaces() returns a list of faces in vtkCellArray form; use the method GetNumberOfFaces() to determine the number of faces in the list. The SetFaces() method is also in vtkCellArray form, except that it begins with a leading count indicating the total number of faces in the list. """ return 0 def RequiresInitialization(self): # real signature unknown; restored from __doc__ """ RequiresInitialization(self) -> int C++: int RequiresInitialization() override; This cell requires that it be initialized prior to access. """ return 0 def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkPolyhedron C++: static vtkPolyhedron *SafeDownCast(vtkObjectBase *o) """ return vtkPolyhedron def SetFaces(self, faces, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetFaces(self, faces:[int, ...]) -> None C++: void SetFaces(vtkIdType *faces) override; """ pass def Triangulate(self, index, ptIds, pts): # real signature unknown; restored from __doc__ """ Triangulate(self, index:int, ptIds:vtkIdList, pts:vtkPoints) -> int C++: int Triangulate(int index, vtkIdList *ptIds, vtkPoints *pts) override; Use vtkOrderedTriangulator to tetrahedralize the polyhedron mesh. This method works well for a convex polyhedron but may return wrong result in a concave case. Once triangulation has been performed, the results are saved in ptIds and pts. The ptIds is a vtkIdList with 4xn number of ids (n is the number of result tetrahedrons). The first 4 represent the point ids of the first tetrahedron, the second 4 represents the point ids of the second tetrahedron and so on. The point ids represent global dataset ids. The points of result tetrahedons are stored in pts. Note that there are 4xm output points (m is the number of points in the original polyhedron). A point may be stored multiple times when it is shared by more than one tetrahedrons. The points stored in pts are ordered the same as they are listed in ptIds. """ return 0 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__': 'vtkPolyhedron', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetEdgePoints': , 'GetFacePoints': , 'GetEdgeToAdjacentFaces': , 'GetFaceToAdjacentFaces': , 'GetPointToIncidentEdges': , 'GetPointToIncidentFaces': , 'GetPointToOneRingPoints': , 'GetCentroid': , 'GetParametricCoords': , 'GetCellType': , 'RequiresInitialization': , 'Initialize': , 'GetNumberOfEdges': , 'GetEdge': , 'GetNumberOfFaces': , 'GetFace': , 'Contour': , 'Clip': , 'EvaluatePosition': , 'EvaluateLocation': , 'IntersectWithLine': , 'Triangulate': , 'Derivatives': , 'CellBoundary': , 'GetParametricCenter': , 'IsPrimaryCell': , 'InterpolateFunctions': , 'InterpolateDerivs': , 'RequiresExplicitFaceRepresentation': , 'SetFaces': , 'GetFaces': , 'IsInside': , 'IsConvex': , 'GetPolyData': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkPolyhedron - a 3D cell defined by a set of polygonal faces\\n\\nSuperclass: vtkCell3D\\n\\nvtkPolyhedron is a concrete implementation that represents a 3D cell\\ndefined by a set of polygonal faces. The polyhedron should be\\nwatertight, non-self-intersecting and manifold (each edge is used\\ntwice).\\n\\nInterpolation functions and weights are defined / computed using the\\nmethod of Mean Value Coordinates (MVC). See the VTK class\\nvtkMeanValueCoordinatesInterpolator for more information.\\n\\nThe class does not require the polyhedron to be convex. However, the\\npolygonal faces must be planar. Non-planar polygonal faces will\\ndefinitely cause problems, especially in severely warped situations.\\n\\n@sa\\nvtkCell3D vtkConvexPointSet vtkMeanValueCoordinatesInterpolator\\n\\n'})" __vtkname__ = 'vtkPolyhedron'