# 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 vtkConvexPointSet(vtkCell3D):
    """
    vtkConvexPointSet - a 3D cell defined by a set of convex points
    
    Superclass: vtkCell3D
    
    vtkConvexPointSet is a concrete implementation that represents a 3D
    cell defined by a convex set of points. An example of such a cell is
    an octant (from an octree). vtkConvexPointSet uses the ordered
    triangulations approach (vtkOrderedTriangulator) to create
    triangulations guaranteed to be compatible across shared faces. This
    allows a general approach to processing complex, convex cell types.
    
    @sa
    vtkHexahedron vtkPyramid vtkTetra vtkVoxel vtkWedge
    """
    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;
        
        Returns the set of points forming a face of the triangulation of
        these points that are on the boundary of the cell that are
        closest parametrically to the point specified.
        """
        pass

    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;
        
        Satisfy the vtkCell API. This method contours by triangulating
        the cell and then adding clip-edge intersection points into the
        triangulation; extracting the clipped region.
        """
        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;
        
        Satisfy the vtkCell API. This method contours by triangulating
        the cell and then contouring the resulting tetrahedra.
        """
        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 by triangulating and from subId and pcoords,
        evaluating derivatives on the resulting 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.
        """
        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. This method determines the subId,
        pcoords, and weights by triangulating the convex point set, and
        then determining which tetrahedron the point lies in.
        """
        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 vtkConvexPointSet
        """
        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<=edgeId<this->GetNumberOfEdges().
        """
        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<=faceId<this->GetNumberOfFaces().
        
        @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++: 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<=faceId<this->GetNumberOfFaces();
        
        @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 convex point set has no explicit cell edge or faces; however
        implicitly (after triangulation) it does. Currently the method
        GetNumberOfEdges() always returns 0 while the GetNumberOfFaces()
        returns the number of boundary triangles of the triangulation of
        the convex point set. The method GetNumberOfFaces() triggers a
        triangulation of the convex point set; repeated calls to
        GetFace() then return the boundary faces. (Note:
        GetNumberOfEdges() currently returns 0 because it is a rarely
        used method and hard to implement. It can be changed in the
        future.
        """
        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.
        """
        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<=edgeId<this->GetNumberOfEdges();
        
        @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<=pointId<this->GetNumberOfPoints().
        
        @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 0<pointId<this->GetNumberOfPoints().
        @return The valence of point pointId.
        """
        pass

    def HasFixedTopology(self): # real signature unknown; restored from __doc__
        """
        HasFixedTopology(self) -> int
        C++: virtual int HasFixedTopology()
        
        See vtkCell3D API for description of this method.
        """
        return 0

    def Initialize(self): # real signature unknown; restored from __doc__
        """
        Initialize(self) -> None
        C++: void Initialize() override;
        """
        pass

    def InterpolateDerivs(self, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        InterpolateDerivs(self, pcoords:(float, float, float),
            derivs:[float, ...]) -> None
        C++: void InterpolateDerivs(const double pcoords[3],
            double *derivs) override;
        """
        pass

    def InterpolateFunctions(self, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        InterpolateFunctions(self, pcoords:(float, float, float),
            sf:[float, ...]) -> None
        C++: void InterpolateFunctions(const double pcoords[3],
            double *sf) override;
        
        Compute the interpolation functions/derivatives (aka shape
        functions/derivatives)
        """
        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;
        
        Triangulates the cells and then intersects them to determine the
        intersection point.
        """
        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 IsPrimaryCell(self): # real signature unknown; restored from __doc__
        """
        IsPrimaryCell(self) -> int
        C++: int IsPrimaryCell() override;
        
        A convex point set is triangulated prior to any operations on it
        so it is not a primary cell, it is a composite 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) -> vtkConvexPointSet
        C++: vtkConvexPointSet *NewInstance()
        """
        return vtkConvexPointSet

    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) -> vtkConvexPointSet
        C++: static vtkConvexPointSet *SafeDownCast(vtkObjectBase *o)
        """
        return vtkConvexPointSet

    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;
        
        Triangulate using methods of vtkOrderedTriangulator.
        """
        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__': 'vtkConvexPointSet', 'IsTypeOf': <method 'IsTypeOf' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'IsA': <method 'IsA' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'SafeDownCast': <method 'SafeDownCast' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'NewInstance': <method 'NewInstance' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetNumberOfGenerationsFromBaseType': <method 'GetNumberOfGenerationsFromBaseType' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetNumberOfGenerationsFromBase': <method 'GetNumberOfGenerationsFromBase' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'HasFixedTopology': <method 'HasFixedTopology' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetEdgePoints': <method 'GetEdgePoints' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetFacePoints': <method 'GetFacePoints' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetEdgeToAdjacentFaces': <method 'GetEdgeToAdjacentFaces' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetFaceToAdjacentFaces': <method 'GetFaceToAdjacentFaces' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetPointToIncidentEdges': <method 'GetPointToIncidentEdges' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetPointToIncidentFaces': <method 'GetPointToIncidentFaces' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetPointToOneRingPoints': <method 'GetPointToOneRingPoints' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetCentroid': <method 'GetCentroid' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetParametricCoords': <method 'GetParametricCoords' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetCellType': <method 'GetCellType' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'RequiresInitialization': <method 'RequiresInitialization' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'Initialize': <method 'Initialize' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetNumberOfEdges': <method 'GetNumberOfEdges' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetEdge': <method 'GetEdge' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetNumberOfFaces': <method 'GetNumberOfFaces' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetFace': <method 'GetFace' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'Contour': <method 'Contour' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'Clip': <method 'Clip' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'EvaluatePosition': <method 'EvaluatePosition' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'EvaluateLocation': <method 'EvaluateLocation' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'IntersectWithLine': <method 'IntersectWithLine' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'Triangulate': <method 'Triangulate' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'Derivatives': <method 'Derivatives' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'CellBoundary': <method 'CellBoundary' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'GetParametricCenter': <method 'GetParametricCenter' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'IsPrimaryCell': <method 'IsPrimaryCell' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'InterpolateFunctions': <method 'InterpolateFunctions' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, 'InterpolateDerivs': <method 'InterpolateDerivs' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__new__': <built-in method __new__ of type object at 0x00007FF81D618070>, '__repr__': <slot wrapper '__repr__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__str__': <slot wrapper '__str__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__getattribute__': <slot wrapper '__getattribute__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__setattr__': <slot wrapper '__setattr__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__delattr__': <slot wrapper '__delattr__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__dict__': <attribute '__dict__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__this__': <attribute '__this__' of 'vtkmodules.vtkCommonDataModel.vtkConvexPointSet' objects>, '__doc__': 'vtkConvexPointSet - a 3D cell defined by a set of convex points\\n\\nSuperclass: vtkCell3D\\n\\nvtkConvexPointSet is a concrete implementation that represents a 3D\\ncell defined by a convex set of points. An example of such a cell is\\nan octant (from an octree). vtkConvexPointSet uses the ordered\\ntriangulations approach (vtkOrderedTriangulator) to create\\ntriangulations guaranteed to be compatible across shared faces. This\\nallows a general approach to processing complex, convex cell types.\\n\\n@sa\\nvtkHexahedron vtkPyramid vtkTetra vtkVoxel vtkWedge\\n\\n'})"
    __vtkname__ = 'vtkConvexPointSet'