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

from .vtkAbstractImageInterpolator import vtkAbstractImageInterpolator

class vtkImageSincInterpolator(vtkAbstractImageInterpolator):
    """
    vtkImageSincInterpolator - perform sinc interpolation on images
    
    Superclass: vtkAbstractImageInterpolator
    
    vtkImageSincInterpolator provides various windowed sinc interpolation
    methods for image data.  The default is a five-lobed Lanczos
    interpolant, with a kernel size of 6.  The interpolator can also
    bandlimit the image, which can be used for antialiasing.  The
    interpolation kernels are evaluated via a lookup table for
    efficiency.@par Thanks: Thanks to David Gobbi at the Seaman Family MR
    Centre and Dept. of Clinical Neurosciences, Foothills Medical Centre,
    Calgary, for providing this class.
    @sa
    vtkImageReslice
    """
    def AntialiasingOff(self):
        """
        V.AntialiasingOff()
        C++: void AntialiasingOff()
        """
        ...
    
    def AntialiasingOn(self):
        """
        V.AntialiasingOn()
        C++: void AntialiasingOn()
        """
        ...
    
    def ComputeSupportSize(self, , p_int=..., p_int=..., p_int=...):
        """
        V.ComputeSupportSize((float, float, float, float, float, float,
            float, float, float, float, float, float, float, float, float,
             float), [int, int, int])
        C++: void ComputeSupportSize(const double matrix[16],
            int support[3]) override;
        
        Get the support size for use in computing update extents.  If the
        data will be sampled on a regular grid, then pass a matrix
        describing the structured coordinate transformation between the
        output and the input. Otherwise, pass nullptr as the matrix to
        retrieve the full kernel size.
        """
        ...
    
    def GetAntialiasing(self):
        """
        V.GetAntialiasing() -> int
        C++: int GetAntialiasing()
        """
        ...
    
    def GetBlurFactors(self, p_float=..., p_float=..., p_float=...):
        """
        V.GetBlurFactors([float, float, float])
        C++: void GetBlurFactors(double f[3])
        V.GetBlurFactors() -> (float, float, float)
        C++: double *GetBlurFactors()
        
        Blur the image by widening the windowed sinc kernel by the
        specified factors for the x, y, and z directions.  This reduces
        the bandwidth by these same factors.  If you turn Antialiasing
        on, then the blur factors will be computed automatically from the
        output sampling rate. Blurring increases the computation time
        because the kernel size increases by the blur factor.
        """
        ...
    
    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 GetRenormalization(self):
        """
        V.GetRenormalization() -> int
        C++: int GetRenormalization()
        """
        ...
    
    def GetUseWindowParameter(self):
        """
        V.GetUseWindowParameter() -> int
        C++: int GetUseWindowParameter()
        """
        ...
    
    def GetWindowFunction(self):
        """
        V.GetWindowFunction() -> int
        C++: int GetWindowFunction()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def GetWindowFunctionAsString(self):
        """
        V.GetWindowFunctionAsString() -> string
        C++: virtual const char *GetWindowFunctionAsString()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def GetWindowHalfWidth(self):
        """
        V.GetWindowHalfWidth() -> int
        C++: int GetWindowHalfWidth()
        """
        ...
    
    def GetWindowParameter(self):
        """
        V.GetWindowParameter() -> float
        C++: double GetWindowParameter()
        """
        ...
    
    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 IsSeparable(self):
        """
        V.IsSeparable() -> bool
        C++: bool IsSeparable() override;
        
        Returns true if the interpolator supports weight precomputation.
        This will always return true for this interpolator.
        """
        ...
    
    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() -> vtkImageSincInterpolator
        C++: vtkImageSincInterpolator *NewInstance()
        """
        ...
    
    def RenormalizationOff(self):
        """
        V.RenormalizationOff()
        C++: void RenormalizationOff()
        """
        ...
    
    def RenormalizationOn(self):
        """
        V.RenormalizationOn()
        C++: void RenormalizationOn()
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkImageSincInterpolator
        C++: static vtkImageSincInterpolator *SafeDownCast(
            vtkObjectBase *o)
        """
        ...
    
    def SetAntialiasing(self, p_int):
        """
        V.SetAntialiasing(int)
        C++: void SetAntialiasing(int antialiasing)
        
        Turn on antialiasing.  If antialiasing is on, then the
        BlurFactors will be computed automatically from the output
        sampling rate such that that the image will be bandlimited to the
        Nyquist frequency.  This is only applicable when the interpolator
        is being used by a resampling filter like vtkImageReslice.  Such
        a filter will indicate the output sampling by calling the
        interpolator's ComputeSupportSize() method, which will compute
        the blur factors at the same time that it computes the support
        size.
        """
        ...
    
    def SetBlurFactors(self, p_float, p_float_1, p_float_2):
        """
        V.SetBlurFactors(float, float, float)
        C++: void SetBlurFactors(double x, double y, double z)
        V.SetBlurFactors((float, float, float))
        C++: void SetBlurFactors(const double f[3])
        
        Blur the image by widening the windowed sinc kernel by the
        specified factors for the x, y, and z directions.  This reduces
        the bandwidth by these same factors.  If you turn Antialiasing
        on, then the blur factors will be computed automatically from the
        output sampling rate. Blurring increases the computation time
        because the kernel size increases by the blur factor.
        """
        ...
    
    def SetRenormalization(self, p_int):
        """
        V.SetRenormalization(int)
        C++: void SetRenormalization(int renormalization)
        
        Turn off renormalization.  Most of the sinc windows provide
        kernels for which the weights do not sum to one, and for which
        the sum depends on the offset.  This results in small ripple
        artifacts in the output. By default, the vtkImageSincInterpolator
        will renormalize these kernels. This method allows the
        renormalization to be turned off.
        """
        ...
    
    def SetUseWindowParameter(self, p_int):
        """
        V.SetUseWindowParameter(int)
        C++: void SetUseWindowParameter(int val)
        
        Turn this on in order to use SetWindowParameter.  If it is off,
        then the default parameter will be used for the window.
        """
        ...
    
    def SetWindowFunction(self, p_int):
        """
        V.SetWindowFunction(int)
        C++: virtual void SetWindowFunction(int mode)
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToBlackman(self):
        """
        V.SetWindowFunctionToBlackman()
        C++: void SetWindowFunctionToBlackman()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToBlackmanHarris3(self):
        """
        V.SetWindowFunctionToBlackmanHarris3()
        C++: void SetWindowFunctionToBlackmanHarris3()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToBlackmanHarris4(self):
        """
        V.SetWindowFunctionToBlackmanHarris4()
        C++: void SetWindowFunctionToBlackmanHarris4()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToBlackmanNuttall3(self):
        """
        V.SetWindowFunctionToBlackmanNuttall3()
        C++: void SetWindowFunctionToBlackmanNuttall3()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToBlackmanNuttall4(self):
        """
        V.SetWindowFunctionToBlackmanNuttall4()
        C++: void SetWindowFunctionToBlackmanNuttall4()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToCosine(self):
        """
        V.SetWindowFunctionToCosine()
        C++: void SetWindowFunctionToCosine()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToHamming(self):
        """
        V.SetWindowFunctionToHamming()
        C++: void SetWindowFunctionToHamming()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToHann(self):
        """
        V.SetWindowFunctionToHann()
        C++: void SetWindowFunctionToHann()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToKaiser(self):
        """
        V.SetWindowFunctionToKaiser()
        C++: void SetWindowFunctionToKaiser()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToLanczos(self):
        """
        V.SetWindowFunctionToLanczos()
        C++: void SetWindowFunctionToLanczos()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowFunctionToNuttall(self):
        """
        V.SetWindowFunctionToNuttall()
        C++: void SetWindowFunctionToNuttall()
        
        The window function to use.  The default is Lanczos, which is
        very popular and performs well with a kernel width of 6.  The
        Cosine window is included for historical reasons.  All other
        windows are described in AH Nuttall, "Some windows with very good
        sidelobe behavior," IEEE Transactions on Acoustics, Speech, and
        Signal Processing 29:84-91, 1981.
        """
        ...
    
    def SetWindowHalfWidth(self, p_int):
        """
        V.SetWindowHalfWidth(int)
        C++: void SetWindowHalfWidth(int n)
        
        Set the window half-width, this must be an integer between 1 and
        16, with a default value of 3.  The kernel size will be twice
        this value if no blur factors are applied. The total number of
        sinc lobes will be one less than twice the half-width, so if the
        half-width is 3 then the kernel size will be 6 and there will be
        5 sinc lobes.
        """
        ...
    
    def SetWindowParameter(self, p_float):
        """
        V.SetWindowParameter(float)
        C++: void SetWindowParameter(double parm)
        
        Set the alpha parameter for the Kaiser window function. This
        parameter will be ignored unless UseWindowParameter is On. If
        UseWindowParameter is Off, then alpha is set to be the same as n
        where n is the window half-width.  Using an alpha less than n
        increases the sharpness and ringing, while using an alpha greater
        than n increases the blurring.
        """
        ...
    
    def UseWindowParameterOff(self):
        """
        V.UseWindowParameterOff()
        C++: void UseWindowParameterOff()
        """
        ...
    
    def UseWindowParameterOn(self):
        """
        V.UseWindowParameterOn()
        C++: void UseWindowParameterOn()
        """
        ...
    
    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__ = ...


