enum ¶

def __call__(self, taps: int | None = None, **kwargs: Any) -> Any:
    kernel: BlurMatrixBase[Any]

    match self:
        case BlurMatrix.MEAN_NO_CENTER:
            taps = fallback(taps, 1)
            mode = kwargs.pop("mode", ConvMode.SQUARE)

            matrix = [1 for _ in range(((2 * taps + 1) ** (2 if mode == ConvMode.SQUARE else 1)) - 1)]
            matrix.insert(len(matrix) // 2, 0)

            return BlurMatrixBase[int](matrix, mode)

        case BlurMatrix.MEAN:
            taps = fallback(taps, 1)
            mode = kwargs.pop("mode", ConvMode.SQUARE)

            kernel = BlurMatrixBase[int]([1 for _ in range(((2 * taps + 1)))], mode)

        case BlurMatrix.BINOMIAL:
            taps = fallback(taps, 1)
            mode = kwargs.pop("mode", ConvMode.HV)

            c = 1
            n = taps * 2 + 1

            matrix = list[int]()

            for i in range(1, taps + 2):
                matrix.append(c)
                c = c * (n - i) // i

            kernel = BlurMatrixBase(matrix[:-1] + matrix[::-1], mode)

        case BlurMatrix.LOG:
            taps = fallback(taps, 1)
            strength = kwargs.pop("strength", 100)
            mode = kwargs.pop("mode", ConvMode.HV)

            strength = max(1e-6, min(log2(3) * strength / 100, log2(3)))

            weight = 0.5 ** strength / ((1 - 0.5 ** strength) * 0.5)

            matrixf = [1.0]

            for _ in range(taps):
                matrixf.append(matrixf[-1] / weight)

            kernel = BlurMatrixBase([*matrixf[::-1], *matrixf[1:]], mode)

        case BlurMatrix.GAUSS:
            taps = fallback(taps, 1)
            sigma = kwargs.pop("sigma", 0.5)
            mode = kwargs.pop("mode", ConvMode.HV)
            scale_value = kwargs.pop("scale_value", 1023)

            if mode == ConvMode.SQUARE:
                scale_value = sqrt(scale_value)

            taps = self.get_taps(sigma, taps)

            if taps < 0:
                raise CustomValueError('Taps must be >= 0!')

            if sigma > 0.0:
                half_pisqrt = 1.0 / sqrt(2.0 * pi) * sigma
                doub_qsigma = 2 * sigma ** 2

                high, *mat = [half_pisqrt * exp(-x ** 2 / doub_qsigma) for x in range(taps + 1)]

                mat = [x * scale_value / high for x in mat]
                mat = [*mat[::-1], scale_value, *mat]
            else:
                mat = [scale_value]

            kernel = BlurMatrixBase(mat, mode)

        case _:
            raise CustomNotImplementedError("Unsupported blur matrix enum!", self, self)

    if mode == ConvMode.SQUARE:
        kernel = kernel.outer()

    return kernel

def from_radius(self: Literal[BlurMatrix.GAUSS], radius: int) -> BlurMatrixBase[float]:  # type: ignore[misc]
    assert self is BlurMatrix.GAUSS

    return BlurMatrix.GAUSS(None, sigma=(radius + 1.0) / 3)

def get_taps(self: Literal[BlurMatrix.GAUSS], sigma: float, taps: int | None = None) -> int:  # type: ignore[misc]
    assert self is BlurMatrix.GAUSS

    if taps is None:
        taps = ceil(abs(sigma) * 8 + 1) // 2

    return taps

def __call__(
    self, clip: vs.VideoNode, planes: PlanesT = None,
    bias: float | None = None, divisor: float | None = None, saturate: bool = True,
    passes: int = 1, expr_kwargs: KwargsT | None = None, **conv_kwargs: Any
) -> ConstantFormatVideoNode:
    """
    Performs a spatial or temporal convolution.
    It will either calls std.Convolution, std.AverageFrames or ExprOp.convolution
    based on the ConvMode mode picked.

    :param clip:            Clip to process.
    :param planes:          Specifies which planes will be processed.
    :param bias:            Value to add to the final result of the convolution
                            (before clamping the result to the format's range of valid values).
    :param divisor:         Divide the output of the convolution by this value (before adding bias).
                            The default is the sum of the elements of the matrix
    :param saturate:        If True, negative values become 0.
                            If False, absolute values are returned.
    :param passes:          Number of iterations.
    :param expr_kwargs:     A KwargsT of keyword arguments for ExprOp.convolution.__call__ when it is picked.
    :param **conv_kwargs:   Additional keyword arguments for std.Convolution, std.AverageFrames or ExprOp.convolution.

    :return:                Processed clip.
    """
    assert check_variable(clip, self)

    if len(self) <= 1:
        return clip

    expr_kwargs = expr_kwargs or KwargsT()

    fp16 = clip.format.sample_type == vs.FLOAT and clip.format.bits_per_sample == 16

    if self.mode.is_spatial:
        # std.Convolution is limited to 25 numbers
        # SQUARE mode is not optimized
        # std.Convolution doesn't support float 16
        if len(self) <= 25 and self.mode != ConvMode.SQUARE and not fp16:
            return iterate(clip, core.std.Convolution, passes, self, bias, divisor, planes, saturate, self.mode)

        return iterate(
            clip, ExprOp.convolution("x", self, bias, fallback(divisor, True), saturate, self.mode, **conv_kwargs),
            passes, planes=planes, **expr_kwargs
        )

    if all([
        not fp16,
        len(self) <= 31,
        not bias,
        saturate,
        (len(conv_kwargs) == 0 or (len(conv_kwargs) == 1 and "scenechange" in conv_kwargs))
    ]):
        return iterate(clip, core.std.AverageFrames, passes, self, divisor, planes=planes, **conv_kwargs)

    return self._averageframes_akarin(clip, planes, bias, divisor, saturate, passes, expr_kwargs, **conv_kwargs)

def outer(self) -> Self:
    from numpy import outer

    return self.__class__(list[_Nb](outer(self, self).flatten()), self.mode)  #pyright: ignore[reportArgumentType]

def __call__(
    self,
    clip: vs.VideoNode,
    previous_clip: vs.VideoNode | None = None,
    next_clip: vs.VideoNode | None = None,
    planes: PlanesT = None
) -> ConstantFormatVideoNode:
    from .rgtools import clense
    return clense(clip, previous_clip, next_clip, self, planes)

def __call__(self, force_expr: bool = True) -> Self:
    self.force_expr = force_expr

    return self

def __call__(self, clip: vs.VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode:
    from .rgtools import remove_grain
    from .util import norm_rmode_planes
    return remove_grain(clip, norm_rmode_planes(clip, self, planes))

def __call__(self, clip: vs.VideoNode, repairclip: vs.VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode:
    from .rgtools import repair
    from .util import norm_rmode_planes
    return repair(clip, repairclip, norm_rmode_planes(clip, self, planes))

def __call__(self, clip: vs.VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode:
    from .rgtools import vertical_cleaner
    from .util import norm_rmode_planes
    return vertical_cleaner(clip, norm_rmode_planes(clip, self, planes))