rgtools ¶

Bases: CustomStrEnum

Enum that specifies the temporal clense mode to use.

Clense modes refer to different ways of applying temporal median filtering over multiple frames.

Each mode maps to a function provided by the zsmooth plugin.

Methods:

• __call__ –

  Apply the selected clense mode to a clip using

Attributes:

• BACKWARD –

  Use the current and previous two frames for temporal median filtering.

• BOTH –

  Standard clense: median of previous, current, and next frame.

• FORWARD –

  Use the current and next two frames for temporal median filtering.

• NONE –

  No clense filtering. Returns the original clip unchanged.

BACKWARD = 'BackwardClense'

BOTH = 'Clense'

FORWARD = 'ForwardClense'

NONE = ''

__call__(
    clip: VideoNode,
    previous_clip: VideoNode | None = None,
    next_clip: VideoNode | None = None,
    planes: PlanesT = None,
) -> ConstantFormatVideoNode

393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410

def __call__(
    self,
    clip: vs.VideoNode,
    previous_clip: vs.VideoNode | None = None,
    next_clip: vs.VideoNode | None = None,
    planes: PlanesT = None
) -> ConstantFormatVideoNode:
    """
    Apply the selected clense mode to a clip using
    the [zsmooth](https://github.com/adworacz/zsmooth?tab=readme-ov-file#clense--forwardclense--backwardclense) plugin.

    :param clip:             Source clip to process.
    :param previous_clip:    Optional alternate clip to source previous frames. Defaults to `clip`.
    :param next_clip:        Optional alternate clip to source next frames. Defaults to `clip`.
    :param planes:           Planes to process. Defaults to all.
    :return:                 Clensed clip with temporal median filtering.
    """
    return clense(clip, previous_clip, next_clip, self, planes)

Bases: CustomIntEnum

Enum representing available spatial filtering strategies in RemoveGrain.

These modes serve a wide range of use cases, such as clamping outliers, removing noise, or simple dehaloing.

More information here.

Methods:

• __call__ –

  Apply the selected remove grain mode to a clip.

Attributes:

• BINOMIAL_BLUR –

  Deprecated. Use BlurMatrix.BINOMIAL. Applies weighted 3×3 blur.

• BOB_BOTTOM_CLOSE –

  Interpolate bottom field using the closest neighboring pixels.

• BOB_BOTTOM_INTER –

  Bottom field interpolation using a more complex formula than mode 14.

• BOB_TOP_CLOSE –

  Interpolate top field using the closest neighboring pixels.

• BOB_TOP_INTER –

  Top field interpolation using a more complex formula than mode 13.

• BOX_BLUR –

  Alias for MEAN.

• BOX_BLUR_NO_CENTER –

  Alias for MEAN_NO_CENTER.

• EDGE_CLIP_LIGHT –

  Light edge clipping (prioritizes the range between opposites).

• EDGE_CLIP_MEDIUM –

  Balanced version of mode 6 (change vs. range ratio 1:1).

• EDGE_CLIP_MODERATE –

  Line-sensitive clipping with moderate sensitivity (change prioritized 2:1).

• EDGE_CLIP_STRONG –

  Line-sensitive clipping that minimizes change to the center pixel.

• EDGE_DEHALO –

  Very light dehaloing. Rarely useful.

• EDGE_DEHALO2 –

  More conservative version of mode 23.

• LINE_CLIP_CLOSE –

  Clip using the line with closest neighbors. Useful for fixing 1-pixel gaps.

• LINE_CLIP_OPP –

  Line-sensitive clipping using opposite neighbors with minimal deviation.

• MEAN –

  Deprecated. Use BlurMatrix.MEAN. Arithmetic mean of 3×3 neighborhood.

• MEAN_NO_CENTER –

  Deprecated. Use BlurMatrix.MEAN_NO_CENTER. Mean of neighborhood (excluding center).

• MINMAX_AROUND1 –

  Clamp pixel to the min/max of its 3×3 neighborhood (excluding center).

• MINMAX_AROUND2 –

  Clamp to the second lowest/highest in the neighborhood.

• MINMAX_AROUND3 –

  Clamp to the third lowest/highest in the neighborhood.

• MINMAX_MEDIAN –

  Deprecated. Similar to mode 1, but clamps to fourth-lowest/highest.

• MINMAX_MEDIAN_OPP –

  Clip using min/max of opposing neighbor pairs.

• MIN_SHARP –

  Replaces pixel with its closest neighbor. A poor but sharp denoiser.

• MIN_SHARP2 –

  Minimal sharpening also known as "non destructive sharpen".

• NONE –

  The input plane is simply passed through.

• OPP_CLIP_AVG –

  Clip to min/max of averages of 4 opposing pixel pairs.

• OPP_CLIP_AVG_FAST –

  Faster variant of mode 21 with simpler rounding.

• SMART_RGC –

  Like mode 17, but preserves corners. Does not preserve thin lines.

• SMART_RGCL –

  Uses 12 pixel pairs instead of 8. Similar to 26, but slightly stronger.

• SMART_RGCL2 –

  Variant of 27 with different pairs. Usually visually similar.

BINOMIAL_BLUR = 11

BOB_BOTTOM_CLOSE = 14

BOB_BOTTOM_INTER = 16

BOB_TOP_CLOSE = 13

BOB_TOP_INTER = 15

BOX_BLUR = MEAN

BOX_BLUR_NO_CENTER = MEAN_NO_CENTER

EDGE_CLIP_LIGHT = 8

EDGE_CLIP_MEDIUM = 7

EDGE_CLIP_MODERATE = 6

EDGE_CLIP_STRONG = 5

EDGE_DEHALO = 23

EDGE_DEHALO2 = 24

LINE_CLIP_CLOSE = 9

LINE_CLIP_OPP = 18

MEAN = 20

MEAN_NO_CENTER = 19

MINMAX_AROUND1 = 1

MINMAX_AROUND2 = 2

MINMAX_AROUND3 = 3

MINMAX_MEDIAN = 4

MINMAX_MEDIAN_OPP = 17

MIN_SHARP = 10

MIN_SHARP2 = 25

NONE = 0

OPP_CLIP_AVG = 21

OPP_CLIP_AVG_FAST = 22

SMART_RGC = 26

SMART_RGCL = 27

SMART_RGCL2 = 28

__call__(clip: VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode

303
304
305
306
307
308
309
310
311
312
313

def __call__(self, clip: vs.VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode:
    """
    Apply the selected remove grain mode to a `clip`.

    :param clip:            Clip to process.
    :param planes:          Planes to process. Defaults to all.
    :return:                Processed (denoised) clip.
    """
    from .util import norm_rmode_planes

    return remove_grain(clip, norm_rmode_planes(clip, self, planes))

Bases: CustomIntEnum

Enum that specifies the mode for repairing or limiting a source clip using a reference clip.

These modes define different spatial strategies for constraining each pixel in the source clip based on the reference clip's local neighborhood, typically using 3×3 squares or line-sensitive patterns.

Commonly used in denoising, artifact removal, or detail-preserving restoration.

Methods:

• __call__ –

  Apply the selected repair mode to a clip using a repairclip.

Attributes:

• CLIP_REF_RG17 –

  Use RemoveGrain mode 17's result to constrain the pixel.

• CLIP_REF_RG18 –

  Use RemoveGrain mode 18's result to constrain the pixel.

• CLIP_REF_RG19 –

  Use RemoveGrain mode 19's result to constrain the pixel.

• CLIP_REF_RG20 –

  Use RemoveGrain mode 20's result to constrain the pixel.

• CLIP_REF_RG21 –

  Use RemoveGrain mode 21's result to constrain the pixel.

• CLIP_REF_RG22 –

  Use RemoveGrain mode 22's result to constrain the pixel.

• CLIP_REF_RG23 –

  Use RemoveGrain mode 23's result to constrain the pixel.

• CLIP_REF_RG24 –

  Use RemoveGrain mode 24's result to constrain the pixel.

• CLIP_REF_RG26 –

  Use RemoveGrain mode 26's result to constrain the pixel.

• CLIP_REF_RG27 –

  Use RemoveGrain mode 27's result to constrain the pixel.

• CLIP_REF_RG28 –

  Use RemoveGrain mode 28's result to constrain the pixel.

• CLIP_REF_RG5 –

  Use RemoveGrain mode 5's result to constrain the pixel.

• CLIP_REF_RG6 –

  Use RemoveGrain mode 6's result to constrain the pixel.

• LINE_CLIP_CLOSE –

  Line-sensitive clamp using the closest neighbors.

• LINE_CLIP_LIGHT –

  Line-sensitive clamping with a light effect.

• LINE_CLIP_MEDIUM –

  Line-sensitive clamping with a moderate effect.

• LINE_CLIP_MIN –

  Line-sensitive clamping with minimal alteration.

• LINE_CLIP_STRONG –

  Line-sensitive clamping with a strong effect.

• MINMAX_SQUARE1 –

  Clamp using the 1st min/max from a 3×3 square in the reference clip.

• MINMAX_SQUARE2 –

  Clamp using the 2nd min/max from a 3×3 square in the reference clip.

• MINMAX_SQUARE3 –

  Clamp using the 3rd min/max from a 3×3 square in the reference clip.

• MINMAX_SQUARE4 –

  Clamp using the 4th min/max from a 3×3 square in the reference clip.

• MINMAX_SQUARE_REF1 –

  Same as mode 1, but clips with min/max of 1st rank and the center pixel of the reference clip.

• MINMAX_SQUARE_REF2 –

  Same as mode 2, but clips with min/max of 2nd rank and the center pixel of the reference clip.

• MINMAX_SQUARE_REF3 –

  Same as mode 3, but clips with min/max of 3rd rank and the center pixel of the reference clip.

• MINMAX_SQUARE_REF4 –

  Same as mode 4, but clips with min/max of 4th rank and the center pixel of the reference clip.

• MINMAX_SQUARE_REF_CLOSE –

  Replace pixel with the closest value in the 3×3 reference square.

• NONE –

  No repair. The input plane is passed through unchanged.

CLIP_REF_RG17 = 17

CLIP_REF_RG18 = 18

CLIP_REF_RG19 = 19

CLIP_REF_RG20 = 20

CLIP_REF_RG21 = 21

CLIP_REF_RG22 = 22

CLIP_REF_RG23 = 23

CLIP_REF_RG24 = 24

CLIP_REF_RG26 = 26

CLIP_REF_RG27 = 27

CLIP_REF_RG28 = 28

CLIP_REF_RG5 = 15

CLIP_REF_RG6 = 16

LINE_CLIP_CLOSE = 9

LINE_CLIP_LIGHT = 6

LINE_CLIP_MEDIUM = 7

LINE_CLIP_MIN = 5

LINE_CLIP_STRONG = 8

MINMAX_SQUARE1 = 1

MINMAX_SQUARE2 = 2

MINMAX_SQUARE3 = 3

MINMAX_SQUARE4 = 4

MINMAX_SQUARE_REF1 = 11

MINMAX_SQUARE_REF2 = 12

MINMAX_SQUARE_REF3 = 13

MINMAX_SQUARE_REF4 = 14

MINMAX_SQUARE_REF_CLOSE = 10

NONE = 0

__call__(
    clip: VideoNode, repairclip: VideoNode, planes: PlanesT = None
) -> ConstantFormatVideoNode

128
129
130
131
132
133
134
135
136
137
138
139
140
141

def __call__(
    self, clip: vs.VideoNode, repairclip: vs.VideoNode, planes: PlanesT = None
) -> ConstantFormatVideoNode:
    """
    Apply the selected repair mode to a `clip` using a `repairclip`.

    :param clip:            Input clip to process (typically filtered).
    :param repairclip:      Reference clip for bounds (often the original or a less-processed version).
    :param planes:          Planes to process. Defaults to all.
    :return:                Clip with repaired pixels, bounded by the reference.
    """
    from .util import norm_rmode_planes

    return repair(clip, repairclip, norm_rmode_planes(clip, self, planes))

Bases: CustomIntEnum

Enum that specifies the vertical cleaner mode to use in the zsmooth plugin.

Methods:

• __call__ –

  Applies the vertical cleaning mode to the given clip.

Attributes:

• MEDIAN –

  Applies a strict vertical median filter.

• NONE –

  The input plane is simply passed through.

• PRESERVING –

  Applies a detail-preserving vertical median filter (less aggressive).

MEDIAN = 1

NONE = 0

PRESERVING = 2

__call__(clip: VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode

480
481
482
483
484
485
486
487
488
489

def __call__(self, clip: vs.VideoNode, planes: PlanesT = None) -> ConstantFormatVideoNode:
    """
    Applies the vertical cleaning mode to the given clip.

    :param clip:        Source clip to process.
    :param planes:      Planes to process. Defaults to all.
    :return:            Filtered clip.
    """
    from .util import norm_rmode_planes
    return vertical_cleaner(clip, norm_rmode_planes(clip, self, planes))