"""
This type stub file was generated by pyright.
"""

from .vtkCell3D import vtkCell3D

class vtkPentagonalPrism(vtkCell3D):
    """
    vtkPentagonalPrism - a 3D cell that represents a convex prism with
    pentagonal base
    
    Superclass: vtkCell3D
    
    vtkPentagonalPrism is a concrete implementation of vtkCell to
    represent a linear convex 3D prism with pentagonal base. Such prism
    is defined by the ten points (0-9), where (0,1,2,3,4) is the base of
    the prism which, using the right hand rule, forms a pentagon whose
    normal points is in the direction of the opposite face (5,6,7,8,9).
    
    @par Thanks: Thanks to Philippe Guerville who developed this class.
    Thanks to Charles Pignerol (CEA-DAM, France) who ported this class
    under VTK 4.
    
    Thanks to Jean Favre (CSCS, Switzerland) who contributed to integrate
    this class in VTK.
    
    Please address all comments to Jean Favre (jfavre at cscs.ch).
    
    @par Thanks: The Interpolation functions and derivatives were changed
    in June 2015 by Bill Lorensen. These changes follow the formulation
    in: http://dilbert.engr.ucdavis.edu/~suku/nem/papers/polyelas.pdf
    NOTE: An additional copy of this paper is located at:
    http://www.vtk.org/Wiki/File:ApplicationOfPolygonalFiniteElementsInLin
    earElasticity.pdf
    """
    def CellBoundary(self, p_int, , vtkIdList):
        """
        V.CellBoundary(int, (float, float, float), vtkIdList) -> int
        C++: int CellBoundary(int subId, const double pcoords[3],
            vtkIdList *pts) override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def ComputeCentroid(self, vtkPoints, int_tuple, p_float=..., p_float=..., p_float=...):
        """
        V.ComputeCentroid(vtkPoints, (int, ...), [float, float, float])
            -> bool
        C++: static bool ComputeCentroid(vtkPoints *points,
            const vtkIdType *pointIds, double centroid[3])
        
        Static method version of GetCentroid.
        """
        ...
    
    def Derivatives(self, p_int, , float_tuple, p_int_1, *float):
        """
        V.Derivatives(int, (float, float, float), (float, ...), int,
            [float, ...])
        C++: void Derivatives(int subId, const double pcoords[3],
            const double *values, int dim, double *derivs) override;
        
        Compute derivatives given cell subId and parametric coordinates.
        The values array is a series of data value(s) at the cell points.
        There is a one-to-one correspondence between cell point and data
        value(s). Dim is the number of data values per cell point. Derivs
        are derivatives in the x-y-z coordinate directions for each data
        value. Thus, if computing derivatives for a scalar function in a
        hexahedron, dim=1, 8 values are supplied, and 3 deriv values are
        returned (i.e., derivatives in x-y-z directions). On the other
        hand, if computing derivatives of velocity (vx,vy,vz) dim=3, 24
        values are supplied ((vx,vy,vz)1, (vx,vy,vz)2, ....()8), and 9
        deriv values are returned ((d(vx)/dx),(d(vx)/dy),(d(vx)/dz),
        (d(vy)/dx),(d(vy)/dy), (d(vy)/dz),
        (d(vz)/dx),(d(vz)/dy),(d(vz)/dz)).
        """
        ...
    
    def EvaluateLocation(self, p_int, , p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.EvaluateLocation(int, (float, float, float), [float, float,
            float], [float, ...])
        C++: void EvaluateLocation(int &subId, const double pcoords[3],
            double x[3], double *weights) override;
        
        Determine global coordinate (x[3]) from subId and parametric
        coordinates. Also returns interpolation weights. (The number of
        weights is equal to the number of points in the cell.)
        """
        ...
    
    def EvaluatePosition(self, , p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.EvaluatePosition((float, float, float), [float, float, float],
            int, [float, float, float], float, [float, ...]) -> int
        C++: int EvaluatePosition(const double x[3],
            double closestPoint[3], int &subId, double pcoords[3],
            double &dist2, double weights[]) override;
        
        Given a point x[3] return inside(=1), outside(=0) cell, or (-1)
        computational problem encountered; evaluate parametric
        coordinates, sub-cell id (!=0 only if cell is composite),
        distance squared of point x[3] to cell (in particular, the
        sub-cell indicated), closest point on cell to x[3] (unless
        closestPoint is null, in which case, the closest point and dist2
        are not found), and interpolation weights in cell. (The number of
        weights is equal to the number of points defining the cell).
        Note: on rare occasions a -1 is returned from the method. This
        means that numerical error has occurred and all data returned
        from this method should be ignored. Also, inside/outside is
        determine parametrically. That is, a point is inside if it
        satisfies parametric limits. This can cause problems for cells of
        topological dimension 2 or less, since a point in 3D can project
        onto the cell within parametric limits but be "far" from the
        cell.  Thus the value dist2 may be checked to determine true
        in/out.
        """
        ...
    
    def GetCellDimension(self):
        """
        V.GetCellDimension() -> int
        C++: int GetCellDimension() override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetCellType(self):
        """
        V.GetCellType() -> int
        C++: int GetCellType() override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetCentroid(self, p_float=..., p_float=..., p_float=...):
        """
        V.GetCentroid([float, float, float]) -> bool
        C++: bool GetCentroid(double centroid[3]) override;
        
        Computes the centroid of the cell.
        """
        ...
    
    def GetEdge(self, p_int):
        """
        V.GetEdge(int) -> vtkCell
        C++: vtkCell *GetEdge(int edgeId) override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetEdgeArray(self, p_int):
        """
        V.GetEdgeArray(int) -> (int, ...)
        C++: static const vtkIdType *GetEdgeArray(vtkIdType edgeId)
        
        Return the ids of the vertices defining edge/face
        (`edgeId`/`faceId'). Ids are related to the cell, not to the
        dataset.
        
        ote The return type changed. It used to be int*, it is now const
        vtkIdType*. This is so ids are unified between vtkCell and
        vtkPoints, and so vtkCell ids can be used as inputs in algorithms
        such as vtkPolygon::ComputeNormal.
        """
        ...
    
    def GetEdgePoints(self, p_int, int_tuple):
        """
        V.GetEdgePoints(int, (int, ...))
        C++: void GetEdgePoints(vtkIdType edgeId, const vtkIdType *&pts)
            override;
        V.GetEdgePoints(int, [int, ...])
        C++: virtual void GetEdgePoints(int edgeId, int *&pts) override;
        
        See vtkCell3D API for description of these methods.
        """
        ...
    
    def GetEdgeToAdjacentFaces(self, p_int, int_tuple):
        """
        V.GetEdgeToAdjacentFaces(int, (int, ...))
        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().
        """
        ...
    
    def GetEdgeToAdjacentFacesArray(self, p_int):
        """
        V.GetEdgeToAdjacentFacesArray(int) -> (int, int)
        C++: static const vtkIdType *GetEdgeToAdjacentFacesArray(
            vtkIdType edgeId)
        
        Static method version of GetEdgeToAdjacentFaces.
        """
        ...
    
    def GetFace(self, p_int):
        """
        V.GetFace(int) -> vtkCell
        C++: vtkCell *GetFace(int faceId) override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetFaceArray(self, p_int):
        """
        V.GetFaceArray(int) -> (int, ...)
        C++: static const vtkIdType *GetFaceArray(vtkIdType faceId)
        
        Return the ids of the vertices defining edge/face
        (`edgeId`/`faceId'). Ids are related to the cell, not to the
        dataset.
        
        ote The return type changed. It used to be int*, it is now const
        vtkIdType*. This is so ids are unified between vtkCell and
        vtkPoints, and so vtkCell ids can be used as inputs in algorithms
        such as vtkPolygon::ComputeNormal.
        """
        ...
    
    def GetFacePoints(self, p_int, int_tuple):
        """
        V.GetFacePoints(int, (int, ...)) -> int
        C++: vtkIdType GetFacePoints(vtkIdType faceId,
            const vtkIdType *&pts) override;
        V.GetFacePoints(int, [int, ...])
        C++: virtual void GetFacePoints(int faceId, int *&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
        """
        ...
    
    def GetFaceToAdjacentFaces(self, p_int, int_tuple):
        """
        V.GetFaceToAdjacentFaces(int, (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.
        """
        ...
    
    def GetFaceToAdjacentFacesArray(self, p_int):
        """
        V.GetFaceToAdjacentFacesArray(int) -> (int, int, int, int, int)
        C++: static const vtkIdType *GetFaceToAdjacentFacesArray(
            vtkIdType faceId)
        
        Static method version of GetFaceToAdjacentFaces.
        """
        ...
    
    def GetNumberOfEdges(self):
        """
        V.GetNumberOfEdges() -> int
        C++: int GetNumberOfEdges() override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetNumberOfFaces(self):
        """
        V.GetNumberOfFaces() -> int
        C++: int GetNumberOfFaces() override;
        
        See the vtkCell3D API for descriptions of these methods.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetParametricCenter(self, p_float=..., p_float=..., p_float=...):
        """
        V.GetParametricCenter([float, float, float]) -> int
        C++: int GetParametricCenter(double pcoords[3]) override;
        
        Return the center of the wedge in parametric coordinates.
        """
        ...
    
    def GetParametricCoords(self):
        """
        V.GetParametricCoords() -> (float, ...)
        C++: double *GetParametricCoords() override;
        
        Return a contiguous array of parametric coordinates of the points
        defining this cell. In other words, (px,py,pz, px,py,pz, etc..) 
        The coordinates are ordered consistent with the definition of the
        point ordering for the cell. This method returns a non-nullptr
        pointer when the cell is a primary type (i.e., IsPrimaryCell() is
        true). Note that 3D parametric coordinates are returned no matter
        what the topological dimension of the cell.
        """
        ...
    
    def GetPointToIncidentEdges(self, p_int, int_tuple):
        """
        V.GetPointToIncidentEdges(int, (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.
        """
        ...
    
    def GetPointToIncidentEdgesArray(self, p_int):
        """
        V.GetPointToIncidentEdgesArray(int) -> (int, int, int)
        C++: static const vtkIdType *GetPointToIncidentEdgesArray(
            vtkIdType pointId)
        
        Static method version of GetPointToIncidentEdgesArray.
        """
        ...
    
    def GetPointToIncidentFaces(self, p_int, int_tuple):
        """
        V.GetPointToIncidentFaces(int, (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.
        """
        ...
    
    def GetPointToIncidentFacesArray(self, p_int):
        """
        V.GetPointToIncidentFacesArray(int) -> (int, int, int)
        C++: static const vtkIdType *GetPointToIncidentFacesArray(
            vtkIdType pointId)
        
        Static method version of GetPointToIncidentFacesArray.
        """
        ...
    
    def GetPointToOneRingPoints(self, p_int, int_tuple):
        """
        V.GetPointToOneRingPoints(int, (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.
        """
        ...
    
    def GetPointToOneRingPointsArray(self, p_int):
        """
        V.GetPointToOneRingPointsArray(int) -> (int, int, int)
        C++: static const vtkIdType *GetPointToOneRingPointsArray(
            vtkIdType pointId)
        
        Static method version of GetPointToOneRingPoints.
        """
        ...
    
    def InterpolateDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.InterpolateDerivs((float, float, float), [float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float])
        C++: void InterpolateDerivs(const double pcoords[3],
            double derivs[30]) override;
        
        Compute the interpolation functions/derivatives (aka shape
        functions/derivatives)
        """
        ...
    
    def InterpolateFunctions(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.InterpolateFunctions((float, float, float), [float, float,
            float, float, float, float, float, float, float, float])
        C++: void InterpolateFunctions(const double pcoords[3],
            double weights[10]) override;
        
        Compute the interpolation functions/derivatives (aka shape
        functions/derivatives)
        """
        ...
    
    def InterpolationDerivs(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.InterpolationDerivs((float, float, float), [float, float, float,
             float, float, float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float, float, float, float, float, float, float, float,
            float, float])
        C++: static void InterpolationDerivs(const double pcoords[3],
            double derivs[30])
        """
        ...
    
    def InterpolationFunctions(self, , p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.InterpolationFunctions((float, float, float), [float, float,
            float, float, float, float, float, float, float, float])
        C++: static void InterpolationFunctions(const double pcoords[3],
            double weights[10])
        """
        ...
    
    def IntersectWithLine(self, , , p_float_6, p_float_7, p_float=..., p_float=..., p_float=..., *args, **kwargs):
        """
        V.IntersectWithLine((float, float, float), (float, float, float),
            float, float, [float, float, float], [float, float, float],
            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 with a ray. Return parametric coordinates (both line
        and cell) and global intersection coordinates, given ray
        definition p1[3], p2[3] and tolerance tol. The method returns
        non-zero value if intersection occurs. A parametric distance t
        between 0 and 1 along the ray representing the intersection
        point, the point coordinates x[3] in data coordinates and also
        pcoords[3] in parametric coordinates. subId is the index within
        the cell if a composed cell like a triangle strip.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsInsideOut(self):
        """
        V.IsInsideOut() -> bool
        C++: bool IsInsideOut() override;
        
        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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkPentagonalPrism
        C++: vtkPentagonalPrism *NewInstance()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPentagonalPrism
        C++: static vtkPentagonalPrism *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def Triangulate(self, p_int, vtkIdList, vtkPoints):
        """
        V.Triangulate(int, vtkIdList, vtkPoints) -> int
        C++: int Triangulate(int index, vtkIdList *ptIds, vtkPoints *pts)
            override;
        
        Generate simplices of proper dimension. If cell is 3D,
        tetrahedron are generated; if 2D triangles; if 1D lines; if 0D
        points. The form of the output is a sequence of points, each n+1
        points (where n is topological cell dimension) defining a
        simplex. The index is a parameter that controls which
        triangulation to use (if more than one is possible). If numerical
        degeneracy encountered, 0 is returned, otherwise 1 is returned.
        This method does not insert new points: all the points that
        define the simplices are the points that define the cell.
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


