enum ¶

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

    match self:
        case BlurMatrix.CIRCLE:
            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:
            mode = kwargs.pop("mode", ConvMode.SQUARE)

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

        case BlurMatrix.BINOMIAL:
            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:
            mode = kwargs.pop("mode", ConvMode.HV)
            strength = kwargs.get("strength", 100)

            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)

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

    return kernel

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
) -> vs.VideoNode:
    """
    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.
    """
    if len(self) <= 1:
        return clip

    assert (check_variable(clip, self.__call__))

    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__(outer(self, self).flatten().tolist(), self.mode)

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

    return self

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

def __call__(self, clip: vs.VideoNode, repairclip: vs.VideoNode, planes: PlanesT = None) -> vs.VideoNode:
    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) -> vs.VideoNode:
    from .rgtools import vertical_cleaner
    from .util import norm_rmode_planes
    return vertical_cleaner(clip, norm_rmode_planes(clip, self, planes))