# 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 .vtkCell import vtkCell class vtkCell3D(vtkCell): """ vtkCell3D - abstract class to specify 3D cell interface Superclass: vtkCell vtkCell3D is an abstract class that extends the interfaces for 3D data cells, and implements methods needed to satisfy the vtkCell API. The 3D cells include hexehedra, tetrahedra, wedge, pyramid, and voxel. @sa vtkTetra vtkHexahedron vtkVoxel vtkWedge vtkPyramid """ def Clip(self, value, cellScalars, locator, connectivity, inPd, outPd, inCd, cellId, outCd, insideOut): # real signature unknown; restored from __doc__ """ Clip(self, value:float, cellScalars:vtkDataArray, locator:vtkIncrementalPointLocator, connectivity:vtkCellArray, inPd:vtkPointData, outPd:vtkPointData, inCd:vtkCellData, cellId:int, outCd:vtkCellData, insideOut:int) -> None C++: void Clip(double value, vtkDataArray *cellScalars, vtkIncrementalPointLocator *locator, vtkCellArray *connectivity, vtkPointData *inPd, vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId, vtkCellData *outCd, int insideOut) override; Cut (or clip) the cell based on the input cellScalars and the specified value. The output of the clip operation will be one or more cells of the same topological dimension as the original cell. The flag insideOut controls what part of the cell is considered inside - normally cell points whose scalar value is greater than "value" are considered inside. If insideOut is on, this is reversed. Also, if the output cell data is non-nullptr, the cell data from the clipped cell is passed to the generated contouring primitives. (Note: the CopyAllocate() method must be invoked on both the output cell and point data. The cellId refers to the cell from which the cell data is copied.) (Satisfies vtkCell API.) """ pass def Contour(self, value, cellScalars, locator, verts, lines, polys, inPd, outPd, inCd, cellId, outCd): # real signature unknown; restored from __doc__ """ Contour(self, value:float, cellScalars: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 *cellScalars, vtkIncrementalPointLocator *locator, vtkCellArray *verts, vtkCellArray *lines, vtkCellArray *polys, vtkPointData *inPd, vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId, vtkCellData *outCd) override; Generate contouring primitives. The scalar list cellScalars are scalar values at each cell point. The point locator is essentially a points list that merges points as they are inserted (i.e., prevents duplicates). Contouring primitives can be vertices, lines, or polygons. It is possible to interpolate point data along the edge by providing input and output point data - if outPd is nullptr, then no interpolation is performed. Also, if the output cell data is non-nullptr, the cell data from the contoured cell is passed to the generated contouring primitives. (Note: the CopyAllocate() method must be invoked on both the output cell and point data. The cellId refers to the cell from which the cell data is copied.) """ pass def GetCellDimension(self): # real signature unknown; restored from __doc__ """ GetCellDimension(self) -> int C++: int GetCellDimension() override; The topological dimension of the cell. (Satisfies vtkCell API.) """ return 0 def GetCentroid(self, centroid, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetCentroid(self, centroid:[float, float, float]) -> bool C++: virtual bool GetCentroid(double centroid[3]) Computes the centroid of the cell. """ pass def GetEdgePoints(self, edgeId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetEdgePoints(self, edgeId:int, pts:(int, ...)) -> None C++: virtual void GetEdgePoints(vtkIdType edgeId, const vtkIdType *&pts) Get the pair of vertices that define an edge. The method returns the number of vertices, along with an array of vertices. 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 edgeId must range between 0<=edgeIdGetNumberOfEdges(). """ pass def GetEdgeToAdjacentFaces(self, edgeId, faceIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetEdgeToAdjacentFaces(self, edgeId:int, faceIds:(int, ...)) -> None C++: virtual void GetEdgeToAdjacentFaces(vtkIdType edgeId, const vtkIdType *&faceIds) 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 GetFacePoints(self, faceId, pts, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetFacePoints(self, faceId:int, pts:(int, ...)) -> int C++: virtual vtkIdType GetFacePoints(vtkIdType faceId, const vtkIdType *&pts) 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 GetFaceToAdjacentFaces(self, faceId, faceIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetFaceToAdjacentFaces(self, faceId:int, faceIds:(int, ...)) -> int C++: virtual vtkIdType GetFaceToAdjacentFaces(vtkIdType faceId, const vtkIdType *&faceIds) 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 GetMergeTolerance(self): # real signature unknown; restored from __doc__ """ GetMergeTolerance(self) -> float C++: virtual double GetMergeTolerance() """ return 0.0 def GetMergeToleranceMaxValue(self): # real signature unknown; restored from __doc__ """ GetMergeToleranceMaxValue(self) -> float C++: virtual double GetMergeToleranceMaxValue() """ return 0.0 def GetMergeToleranceMinValue(self): # real signature unknown; restored from __doc__ """ GetMergeToleranceMinValue(self) -> float C++: virtual double GetMergeToleranceMinValue() """ return 0.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 GetPointToIncidentEdges(self, pointId, edgeIds, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointToIncidentEdges(self, pointId:int, edgeIds:(int, ...)) -> int C++: virtual vtkIdType GetPointToIncidentEdges(vtkIdType pointId, const vtkIdType *&edgeIds) 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++: virtual vtkIdType GetPointToIncidentFaces(vtkIdType pointId, const vtkIdType *&faceIds) 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++: virtual vtkIdType GetPointToOneRingPoints(vtkIdType pointId, const vtkIdType *&pts) 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 Inflate(self, dist): # real signature unknown; restored from __doc__ """ Inflate(self, dist:float) -> int C++: int Inflate(double dist) override; Inflates the cell. Each face is displaced following its normal by a distance of value `dist`. If dist is negative, then the cell shrinks. The resulting cell edges / faces are colinear / coplanar to their previous self. Degenerate parts of the 3D cell are unchanged. This happens a points to which incident faces are homogeneous to a plane, to a line, or to a point. \return 1 if inflation was successful, 0 if no inflation was performed """ return 0 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 IsInsideOut(self): # real signature unknown; restored from __doc__ """ IsInsideOut(self) -> bool C++: virtual bool IsInsideOut() Returns true if the normals of the vtkCell3D point inside the cell. @warning This flag is not precomputed. It is advised for the return result of this method to be stored in a local boolean by the user if needed multiple times. """ 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) -> vtkCell3D C++: vtkCell3D *NewInstance() """ return vtkCell3D def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkCell3D C++: static vtkCell3D *SafeDownCast(vtkObjectBase *o) """ return vtkCell3D def SetMergeTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetMergeTolerance(self, _arg:float) -> None C++: virtual void SetMergeTolerance(double _arg) Set the tolerance for merging clip intersection points that are near the vertices of cells. This tolerance is used to prevent the generation of degenerate tetrahedra during clipping. """ 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__': 'vtkCell3D', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetEdgePoints': , 'GetFacePoints': , 'GetEdgeToAdjacentFaces': , 'GetFaceToAdjacentFaces': , 'GetPointToIncidentEdges': , 'GetPointToIncidentFaces': , 'GetPointToOneRingPoints': , 'IsInsideOut': , 'GetCentroid': , 'Contour': , 'Clip': , 'GetCellDimension': , 'Inflate': , 'SetMergeTolerance': , 'GetMergeToleranceMinValue': , 'GetMergeToleranceMaxValue': , 'GetMergeTolerance': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkCell3D - abstract class to specify 3D cell interface\\n\\nSuperclass: vtkCell\\n\\nvtkCell3D is an abstract class that extends the interfaces for 3D\\ndata cells, and implements methods needed to satisfy the vtkCell API.\\nThe 3D cells include hexehedra, tetrahedra, wedge, pyramid, and\\nvoxel.\\n\\n@sa\\nvtkTetra vtkHexahedron vtkVoxel vtkWedge vtkPyramid\\n\\n'})" __vtkname__ = 'vtkCell3D'