freqs ¶

def __call__(
    self,
    *_clips: VideoNodeIterableT[vs.VideoNode],
    planes: Planes = None,
    func: FuncExcept | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Applies the selected mean to multiple clips.

    Args:
        *_clips: Input clips to combine.
        planes: Which planes to process.
        func: An optional function to use for error handling.
        **kwargs: Additional keyword arguments for certain modes.

               - p (float): Exponent for `LEHMER` mode. Defaults to 3.
    Raises:
        CustomValueError: If there is no clip.

    Returns:
        A new clip containing the combined frames.
    """

    func = func or self.__class__

    clips = flatten_vnodes(_clips)

    assert check_variable_format(clips, func)

    if not clips:
        raise CustomValueError("There is no clip to evaluate.", func)

    if (n_clips := len(clips)) < 2:
        return clips[0]

    return self.expr(n_clips, **kwargs)(clips, planes=planes, func=func)

def expr(
    self, n: SupportsIndex | Sequence[SupportsString] | HoldsVideoFormat | VideoFormatLike, **kwargs: Any
) -> ExprList:
    """
    Builds a mean expression using a specified mode.

    Args:
        n: Object from which to infer the variables.
        **kwargs: Additional keyword arguments for certain modes.

               - p (float): Exponent for `LEHMER` mode. Defaults to 3.

    Returns:
        Mean expression.
    """
    evars = n if isinstance(n, Sequence) else ExprVars(n)

    if (n_len := len(evars)) < 2:
        return ExprList([evars[0]])

    match self:
        case MeanMode.LEHMER:
            p = kwargs.pop("p", self.value)

            expr = ExprList((f"{v} neutral - D{i}!" for i, v in enumerate(evars)))

            for x in range(2):
                expr.extend([[f"D{i}@ {p - x} pow" for i in range(n_len)], ExprOp.ADD * (n_len - 1), f"P{x}!"])

            expr.append("P1@ 0 = 0 P0@ P1@ / ? neutral +")

            return expr
        case MeanMode.HARMONIC | MeanMode.GEOMETRIC | MeanMode.CONTRAHARMONIC:
            return MeanMode.LEHMER.expr(n, p=self.value)
        case MeanMode.MEDIAN:
            n_op = (n_len - 1) // 2
            mean = "" if n_len % 2 else "+ 2 /"

            return ExprList(
                [
                    f"{' '.join(str(v) for v in evars)}",
                    f"sort{n_len}",
                    f"drop{n_op}",
                    f"{mean}",
                    f"swap{n_op}",
                    f"drop{n_op}",
                ]
            )
        case MeanMode.ARITHMETIC:
            op = ExprOp.ADD
            kwargs.update(expr_suffix=f"{n_len} /")
        case MeanMode.MINIMUM:
            op = ExprOp.MIN
        case MeanMode.MAXIMUM:
            op = ExprOp.MAX

    return combine_expr(evars, op, **kwargs)

def single(
    self,
    clip: vs.VideoNode,
    radius: int | Sequence[int] = 1,
    mode: ConvMode = ConvMode.SQUARE,
    exclude: Iterable[tuple[int, int]] | None = None,
    include: Iterable[tuple[int, int]] | None = None,
    planes: Planes = None,
    func: FuncExcept | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Applies the selected mean to one clip, spatially or temporally.

    Args:
        clip: Input clip.
        radius: The radius per plane (Sequence) or uniform radius (int). Only int is allowed in temporal mode.
        mode: The convolution mode. Defaults to ConvMode.SQUARE.
        exclude: Optional set of (x, y) coordinates to exclude from the matrix.
        include: Optional set of (x, y) coordinates to include in the matrix.
        planes: Which planes to process.
        func: An optional function to use for error handling.
        **kwargs: Additional keyword arguments for certain modes.

               - p (float): Exponent for `LEHMER` mode. Defaults to 3.

    Raises:
        CustomValueError: If a list is passed for radius in temporal mode, which is unsupported.

    Returns:
        A new clip with the mean applied.
    """
    func = func or f"{self!s}.single"

    assert check_variable_format(clip, func)

    if mode == ConvMode.TEMPORAL:
        if not isinstance(radius, int):
            raise CustomValueError("A list of radius isn't supported for ConvMode.TEMPORAL!", func, radius)

        clips = shift_clip_multi(clip, (-radius, radius))

        (ops,) = ExprOp.matrix(ExprVars(len(clips)), radius, mode, exclude, include)

        return self.expr(ops, **kwargs)(*clips, planes=planes, func=func)

    radius = normalize_seq(radius, clip.format.num_planes)
    expr_plane = list[list[ExprList]]()

    for r in radius:
        expr_passes = list[ExprList]()

        for mat in ExprOp.matrix("x", r, mode, exclude, include):
            expr_passes.append(self.expr(mat, **kwargs))

        expr_plane.append(expr_passes)

    for e in zip(*expr_plane):
        clip = norm_expr(clip, e, planes, func=func)

    return clip