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

from .vtkDirectionEncoder import vtkDirectionEncoder

class vtkRecursiveSphereDirectionEncoder(vtkDirectionEncoder):
    """
    vtkRecursiveSphereDirectionEncoder - A direction encoder based on the
    recursive subdivision of an octahedron
    
    Superclass: vtkDirectionEncoder
    
    vtkRecursiveSphereDirectionEncoder is a direction encoder which uses
    the vertices of a recursive subdivision of an octahedron (with the
    vertices pushed out onto the surface of an enclosing sphere) to
    encode directions into a two byte value.
    
    @sa
    vtkDirectionEncoder
    """
    def GetDecodedGradient(self, p_int):
        """
        V.GetDecodedGradient(int) -> (float, float, float)
        C++: float *GetDecodedGradient(int value) override;
        
        / Given an encoded value, return a pointer to the normal vector
        """
        ...
    
    def GetDecodedGradientTable(self):
        """
        V.GetDecodedGradientTable() -> (float, ...)
        C++: float *GetDecodedGradientTable(void) override;
        
        Get the decoded gradient table. There are
        this->GetNumberOfEncodedDirections() entries in the table, each
        containing a normal (direction) vector. This is a flat structure
        - 3 times the number of directions floats in an array.
        """
        ...
    
    def GetEncodedDirection(self, p_float=..., p_float=..., p_float=...):
        """
        V.GetEncodedDirection([float, float, float]) -> int
        C++: int GetEncodedDirection(float n[3]) override;
        
        Given a normal vector n, return the encoded direction
        """
        ...
    
    def GetNumberOfEncodedDirections(self):
        """
        V.GetNumberOfEncodedDirections() -> int
        C++: int GetNumberOfEncodedDirections(void) override;
        
        Return the number of encoded directions
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Get the name of this class
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Get the name of this class
        """
        ...
    
    def GetRecursionDepth(self):
        """
        V.GetRecursionDepth() -> int
        C++: virtual int GetRecursionDepth()
        
        Set / Get the recursion depth for the subdivision. This indicates
        how many time one triangle on the initial 8-sided sphere model is
        replaced by four triangles formed by connecting triangle edge
        midpoints. A recursion level of 0 yields 8 triangles with 6
        unique vertices. The normals are the vectors from the sphere
        center through the vertices. The number of directions will be 11
        since the four normals with 0 z values will be duplicated in the
        table - once with +0 values and the other time with -0 values,
        and an addition index will be used to represent the (0,0,0)
        normal. If we instead choose a recursion level of 6 (the maximum
        that can fit within 2 bytes) the number of directions is 16643,
        with 16386 unique directions and a zero normal.
        """
        ...
    
    def GetRecursionDepthMaxValue(self):
        """
        V.GetRecursionDepthMaxValue() -> int
        C++: virtual int GetRecursionDepthMaxValue()
        
        Set / Get the recursion depth for the subdivision. This indicates
        how many time one triangle on the initial 8-sided sphere model is
        replaced by four triangles formed by connecting triangle edge
        midpoints. A recursion level of 0 yields 8 triangles with 6
        unique vertices. The normals are the vectors from the sphere
        center through the vertices. The number of directions will be 11
        since the four normals with 0 z values will be duplicated in the
        table - once with +0 values and the other time with -0 values,
        and an addition index will be used to represent the (0,0,0)
        normal. If we instead choose a recursion level of 6 (the maximum
        that can fit within 2 bytes) the number of directions is 16643,
        with 16386 unique directions and a zero normal.
        """
        ...
    
    def GetRecursionDepthMinValue(self):
        """
        V.GetRecursionDepthMinValue() -> int
        C++: virtual int GetRecursionDepthMinValue()
        
        Set / Get the recursion depth for the subdivision. This indicates
        how many time one triangle on the initial 8-sided sphere model is
        replaced by four triangles formed by connecting triangle edge
        midpoints. A recursion level of 0 yields 8 triangles with 6
        unique vertices. The normals are the vectors from the sphere
        center through the vertices. The number of directions will be 11
        since the four normals with 0 z values will be duplicated in the
        table - once with +0 values and the other time with -0 values,
        and an addition index will be used to represent the (0,0,0)
        normal. If we instead choose a recursion level of 6 (the maximum
        that can fit within 2 bytes) the number of directions is 16643,
        with 16386 unique directions and a zero normal.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Get the name of this class
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Get the name of this class
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkRecursiveSphereDirectionEncoder
        C++: vtkRecursiveSphereDirectionEncoder *NewInstance()
        
        Get the name of this class
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase)
            -> vtkRecursiveSphereDirectionEncoder
        C++: static vtkRecursiveSphereDirectionEncoder *SafeDownCast(
            vtkObjectBase *o)
        
        Get the name of this class
        """
        ...
    
    def SetRecursionDepth(self, p_int):
        """
        V.SetRecursionDepth(int)
        C++: virtual void SetRecursionDepth(int _arg)
        
        Set / Get the recursion depth for the subdivision. This indicates
        how many time one triangle on the initial 8-sided sphere model is
        replaced by four triangles formed by connecting triangle edge
        midpoints. A recursion level of 0 yields 8 triangles with 6
        unique vertices. The normals are the vectors from the sphere
        center through the vertices. The number of directions will be 11
        since the four normals with 0 z values will be duplicated in the
        table - once with +0 values and the other time with -0 values,
        and an addition index will be used to represent the (0,0,0)
        normal. If we instead choose a recursion level of 6 (the maximum
        that can fit within 2 bytes) the number of directions is 16643,
        with 16386 unique directions and a zero normal.
        """
        ...
    
    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__ = ...


