enum ¶

def __call__(self, radius: int | None = None, **kwargs: Any) -> Any:
    """
    Generate the blur kernel based on the enum variant.

    Args:
        radius: Size of the kernel in each direction.
        **kwargs: Additional keywords arguments:

               - sigma: [GAUSS only] Standard deviation of the Gaussian kernel.
               - mode: Convolution mode. Default depends on kernel.

    Returns:
        A `BlurMatrixBase` instance representing the kernel.
    """
    kernel: BlurMatrixBase[Any]

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

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

            return self.custom(matrix, mode)

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

            kernel = self.custom((1 for _ in range((2 * radius + 1))), mode)

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

            kernel = self.custom([math.comb(2 * radius, i) for i in range(2 * radius + 1)], mode)

        case BlurMatrix.GAUSS:
            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 = math.sqrt(scale_value)

            if radius is None:
                radius = self.get_radius(sigma)

            if sigma > 0.0:
                doub_qsigma = 2 * sigma**2
                mat = [scale_value * math.exp(-(x**2) / doub_qsigma) for x in range(1, radius + 1)]
                mat = [*mat[::-1], scale_value, *mat]
            else:
                mat = [scale_value]

            kernel = self.custom(mat, mode)

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

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

    return kernel

@classmethod
def custom[Nb: float | int](cls, values: Iterable[Nb], mode: ConvMode = ConvMode.SQUARE) -> BlurMatrixBase[Nb]:
    """
    Create a custom BlurMatrixBase kernel with explicit values and mode.

    Args:
        values: The kernel coefficients.
        mode: Convolution mode to use.

    Returns:
        A BlurMatrixBase instance.
    """
    return BlurMatrixBase(values, mode=mode)

@classmethod
def from_param(cls, value: Any, func_except: FuncExcept | None = None) -> Self:
    """
    Return the enum value from a parameter.

    Args:
        value: Value to instantiate the enum class.
        func_except: Exception function.

    Returns:
        Enum value.

    Raises:
        NotFoundEnumValue: Variable not found in the given enum.
    """
    func_except = func_except or cls.from_param

    try:
        return cls(value)
    except (ValueError, TypeError):
        pass

    if isinstance(func_except, tuple):
        func_name, var_name = func_except
    else:
        func_name, var_name = func_except, repr(cls)

    raise NotFoundEnumValueError(
        'The given value for "{var_name}" argument must be a valid {enum_name}, not "{value}"!\n'
        "Valid values are: [{readable_enum}].",
        func_name,
        var_name=var_name,
        enum_name=cls,
        value=value,
        readable_enum=(f"{name} ({value!s})" for name, value in cls.__members__.items()),
        reason=value,
    ) from None

def from_radius(self: Literal[BlurMatrix.GAUSS], radius: int) -> BlurMatrixBase[float]:  # type: ignore[misc]
    """
    Generate a Gaussian blur kernel from an intuitive radius.

    This is a shortcut that converts a blur radius to a corresponding sigma value.

    Args:
        radius: Blur radius.

    Returns:
        Gaussian blur matrix.
    """
    assert self is BlurMatrix.GAUSS

    return BlurMatrix.GAUSS(None, sigma=self.get_sigma(radius))

def get_radius(self: Literal[BlurMatrix.GAUSS], sigma: float) -> int:  # type: ignore[misc]
    """
    Compute the radius required for a given sigma value.

    Args:
        sigma: Gaussian sigma value.

    Returns:
        Radius.
    """
    assert self is BlurMatrix.GAUSS

    return math.ceil(sigma * 6 + 1) // 2

def get_sigma(self: Literal[BlurMatrix.GAUSS], radius: int) -> float:  # type: ignore[misc]
    """
    Generate a Gaussian sigma value from an intuitive radius.

    This is a shortcut that converts a blur radius to a corresponding sigma value.

    Args:
        radius: Blur radius.

    Returns:
        Gaussian sigma value
    """
    assert self is BlurMatrix.GAUSS

    return radius / 3

def __call__(
    self,
    clip: vs.VideoNode | Iterable[vs.VideoNode],
    planes: Planes = None,
    bias: float | None = None,
    divisor: float | None = None,
    saturate: bool = True,
    passes: int = 1,
    func: FuncExcept | None = None,
    expr_kwargs: dict[str, Any] | None = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Apply the blur kernel to the given clip via spatial or temporal convolution.

    Chooses the appropriate backend (`std.Convolution`, `std.AverageFrames`, or `ExprOp.convolution`)
    depending on kernel size, mode, format, and other constraints.

    Args:
        clip: Source clip.
        planes: Planes to process. Defaults to all.
        bias: Value added to result before clamping.
        divisor: Divides the result of the convolution (before adding bias). Defaults to sum of kernel values.
        saturate: If True, negative values are clamped to zero. If False, absolute values are returned.
        passes: Number of convolution passes to apply.
        func: Function returned for custom error handling. This should only be set by VS package developers.
        expr_kwargs: Extra kwargs passed to ExprOp.convolution when used.
        **kwargs: Any other args passed to the underlying VapourSynth function.

    Returns:
        Processed (blurred) video clip.
    """
    func = func or self
    clip = to_arr(clip)
    expr_kwargs = expr_kwargs or {}

    if len(self) <= 1:
        return clip[0]

    process = self._spatial_conv if self.mode.is_spatial else self._temporal_conv
    return process(clip, planes, bias, divisor, saturate, passes, func, expr_kwargs, **kwargs)

def outer(self) -> Self:
    """
    Convert a 1D kernel into a 2D square kernel by computing the outer product.

    Returns:
        New `BlurMatrixBase` instance with 2D kernel and same mode.
    """
    import numpy as np

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