docs ¶

@inject_self.cached
def descale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None, height: int | None,
    shift: tuple[float, float] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    """
    Perform a regular descaling operation.

    :param clip:        Input clip
    :param width:       Output width
    :param height:      Output height
    :param shift:       Shift clip during the operation.
                        Expects a tuple of (src_top, src_left).

    :rtype:             ``VideoNode``
    """
    width, height = self._wh_norm(clip, width, height)
    return depth(core.descale.Debicubic(
        depth(clip, 32), width, height, b=self.b, c=self.c, src_top=shift[0], src_left=shift[1], **kwargs
    ), clip)

@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: ScalerT | DescalerT | ResamplerT | KernelT | None = None,
    func_except: FuncExceptT | None = None
) -> Scaler | Descaler | Resampler | Kernel:
    from ..util import abstract_kernels
    return _base_ensure_obj(  # type: ignore
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

@classmethod
def from_param(
    cls: type[Kernel], kernel: ScalerT | DescalerT | ResamplerT | KernelT | None = None,
    func_except: FuncExceptT | None = None
) -> type[Scaler] | type[Descaler] | type[Resampler] | type[Kernel]:
    from ..util import abstract_kernels
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except  # type: ignore
    )

def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(True, clip, width, height, **kwargs)
    )

def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )  # type: ignore

def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> KwargsT:
    return dict(width=width, height=height) | kwargs

@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

@inject_self.cached.property
def kernel_radius(self) -> int:
    return _default_kernel_radius(__class__, self)  # type: ignore

@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * multi), ceil(clip.height * multi)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "multi" must result in a positive resolution!', self.multi, multi
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

@inject_self.cached.property
def pretty_string(self) -> str:
    attrs = {}

    if hasattr(self, 'b'):
        attrs.update(b=self.b, c=self.c)
    elif hasattr(self, 'taps'):
        attrs['taps'] = self.taps

    if hasattr(self, 'kwargs'):
        attrs.update(self.kwargs)

    return f"{self.__class__.__name__}{' (' + ', '.join(f'{k}={v}' for k, v in attrs.items()) + ')' if attrs else ''}"

@inject_self.cached
def resample(  # type: ignore[override]
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> vs.VideoNode:
    """
    Perform a regular resampling operation.

    :param clip:        Input clip
    :param format:      Output format
    :param matrix:      Output matrix. If `None`, will take the matrix from the input clip's frameprops.
    :param matrix_in:   Input matrix. If `None`, will take the matrix from the input clip's frameprops.

    :rtype:             ``VideoNode``
    """
    return core.resize.Bicubic(
        clip, format=get_video_format(format).id,
        filter_param_a=self.b, filter_param_b=self.c,
        matrix=matrix, matrix_in=matrix_in, **self.kwargs, **kwargs  # type: ignore
    )

@inject_self.cached
def scale(  # type: ignore[override]
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[float, float] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    """
    Perform a regular scaling operation.

    :param clip:        Input clip
    :param width:       Output width
    :param height:      Output height
    :param shift:       Shift clip during the operation.
                        Expects a tuple of (src_top, src_left).

    :rtype:             ``VideoNode``
    """
    width, height = self._wh_norm(clip, width, height)
    return core.resize.Bicubic(
        clip, width, height, src_top=shift[0], src_left=shift[1],
        filter_param_a=self.b, filter_param_b=self.c, **self.kwargs, **kwargs
    )

def shift(  # type: ignore
    self, clip: vs.VideoNode,
    shift_top: float | list[float] = 0.0, shift_left: float | list[float] = 0.0, **kwargs: Any
) -> vs.VideoNode:
    """
    Perform a regular shifting operation.

    :param clip:        Input clip
    :param shift:       Shift clip during the operation.\n
                        Expects a tuple of (src_top, src_left)\n
                        or two top, left arrays for shifting planes individually.

    :rtype:             ``VideoNode``
    """
    return core.resize.Bicubic(
        clip, src_top=shift_top, src_left=shift_left,  # type: ignore
        filter_param_a=self.b, filter_param_b=self.c,
        **self.kwargs, **kwargs
    )