rgtools ¶

@Clense
def clense(
    clip: vs.VideoNode,
    previous_clip: vs.VideoNode | None = None,
    next_clip: vs.VideoNode | None = None,
    mode: Clense.Mode | str = Clense.Mode.NONE,
    planes: PlanesT = None,
) -> ConstantFormatVideoNode:
    """
    Apply a clense (temporal median) filter based on the specified mode.

    Example:
        ```py
        clensed = clense(clip, ..., mode=clense.Mode.BOTH)
        ```

        Alternatively, directly using the enum:
        ```py
        clensed = clense.Mode.BOTH(clip, ...)
        ```

    Args:
        clip: Source clip to process.
        previous_clip: Optional alternate clip to source previous frames. Defaults to `clip`.
        next_clip: Optional alternate clip to source next frames. Defaults to `clip`.
        mode: Mode of filtering. One of [Mode][vsrgtools.rgtools.Clense.Mode] or its string values.
        planes: Planes to process. Defaults to all.

    Returns:
        Clensed clip with temporal median filtering.
    """
    assert check_variable(clip, clense)

    kwargs = KwargsNotNone(previous=previous_clip, next=next_clip)

    if mode == Clense.Mode.NONE:
        return clip

    return getattr(clip.zsmooth, mode)(planes=planes, **kwargs)

@RemoveGrain
def remove_grain(
    clip: vs.VideoNode, mode: int | RemoveGrain.Mode | Sequence[int | RemoveGrain.Mode], planes: PlanesT = None
) -> ConstantFormatVideoNode:
    """
    Apply spatial denoising using the RemoveGrain algorithm.

    Supports a variety of pixel clamping, edge-aware filtering, and blur strategies.
    See [RemoveGrain.Mode][vsrgtools.rgtools.RemoveGrain.Mode] for all available modes.

    - Modes 1-24 are natively implemented in [zsmooth.RemoveGrain](https://github.com/adworacz/zsmooth?tab=readme-ov-file#removegrain).
    - Modes 25+ fall back to expression-based implementations.

    Example:
        ```py
        denoised = remove_grain(clip, remove_grain.Mode.EDGE_CLIP_STRONG)
        ```

        Alternatively, directly using the enum:
        ```py
        denoised = remove_grain.Mode.EDGE_CLIP_STRONG(clip)
        ```

    Args:
        clip: Clip to process.
        mode: Mode(s) to use. Can be a single mode or per-plane list. See
            [RemoveGrain.Mode][vsrgtools.rgtools.RemoveGrain.Mode] for details.
        planes: Planes to process. Default to all.

    Returns:
        Processed (denoised) clip.
    """
    assert check_variable(clip, remove_grain)

    mode = normalize_param_planes(clip, mode, planes, RemoveGrain.Mode.NONE)

    if not sum(mode):
        return clip

    if all(m in range(24 + 1) for m in mode):
        return clip.zsmooth.RemoveGrain(mode)

    return norm_expr(clip, tuple([removegrain_aka_exprs[m]() for m in mode]), func=remove_grain)

@Repair
def repair(
    clip: vs.VideoNode,
    repairclip: vs.VideoNode,
    mode: int | Repair.Mode | Sequence[int | Repair.Mode],
    planes: PlanesT = None,
) -> ConstantFormatVideoNode:
    """
    Constrains the input `clip` using a `repairclip` by clamping pixel values
    based on a chosen [mode][vsrgtools.rgtools.Repair.Mode].

    This is typically used to limit over-aggressive filtering (e.g., from `RemoveGrain`) while keeping
    the corrections within reasonable bounds derived from the reference (`repairclip`). Often used in detail
    restoration workflows.

    - Modes 1-24 directly map to [zsmooth.Repair](https://github.com/adworacz/zsmooth?tab=readme-ov-file#repair)
      plugin modes.
    - Modes 26+ fall back to expression-based implementations.

    Example:
        ```py
        repaired = repair(filtered, clip, repair.Mode.MINMAX_SQUARE_REF3)
        ```

        Alternatively, directly using the enum:
        ```py
        repaired = repair.Mode.MINMAX_SQUARE_REF3(clip)
        ```

    Args:
        clip: Input clip to process (typically filtered).
        repairclip: Reference clip for bounds (often the original or a less-processed version).
        mode: Repair mode(s) used to constrain pixels. Can be a single mode or a list per plane. See
            [Repair.Mode][vsrgtools.rgtools.Repair.Mode] for details.
        planes: Planes to process. Default to all.

    Returns:
        Clip with repaired pixels, bounded by the reference.
    """
    assert check_variable(clip, repair)
    assert check_variable(repairclip, repair)

    mode = normalize_param_planes(clip, mode, planes, Repair.Mode.NONE)

    if not sum(mode):
        return clip

    if all(m in range(24 + 1) for m in mode):
        return clip.zsmooth.Repair(repairclip, mode)

    return norm_expr([clip, repairclip], tuple([repair_aka_exprs[m]() for m in mode]), func=repair)

@VerticalCleaner
def vertical_cleaner(
    clip: vs.VideoNode,
    mode: int | VerticalCleaner.Mode | Sequence[int | VerticalCleaner.Mode],
    planes: PlanesT = None,
) -> ConstantFormatVideoNode:
    """
    Applies a fast vertical median or relaxed median filter to the clip
    using the [zsmooth](https://github.com/adworacz/zsmooth?tab=readme-ov-file#verticalcleaner) plugin.

    Example:
        ```py
        cleaned = vertical_cleaner(clip, vertical_cleaner.Mode.PRESERVING)
        ```

        Alternatively, directly using the enum:
        ```py
        cleaned = vertical_cleaner.Mode.PRESERVING(clip)
        ```

    Args:
        clip: Source clip to process.
        mode: Mode of vertical cleaning to apply.
            Can be:

               - A single enum/int (applied to all planes),
               - A sequence of enums/ints (one per plane).

        planes: Planes to process. Defaults to all.

    Returns:
        Filtered clip.
    """
    assert check_variable(clip, vertical_cleaner)

    mode = normalize_param_planes(clip, mode, planes, VerticalCleaner.Mode.NONE)

    if not sum(mode):
        return clip

    return clip.zsmooth.VerticalCleaner(mode)