qtgmc ¶

def analyze(
    self,
    *,
    force_tr: int = 1,
    preset: MVToolsPreset = MVToolsPreset.HQ_SAD,
    blksize: int | tuple[int, int] = 16,
    refine: int = 1,
    thsad_recalc: int | None = None,
    thscd: int | tuple[int | None, int | float | None] | None = (180, 38.5),
) -> Self:
    """
    Configure parameters for the motion analysis stage.

    :param force_tr:        Always analyze motion to at least this, even if otherwise unnecessary.
    :param preset:          MVTools preset defining base values for the MVTools object.
    :param blksize:         Size of a block. Larger blocks are less sensitive to noise, are faster,
                            but also less accurate.
    :param refine:          Number of times to recalculate motion vectors with halved block size.
    :param thsad_recalc:    Only bad quality new vectors with a SAD above this will be re-estimated by search.
                            thsad value is scaled to 8x8 block size.
    :param thscd:           Scene change detection thresholds:
                             - First value: SAD threshold for considering a block changed between frames.
                             - Second value: Percentage of changed blocks needed to trigger a scene change.
    """

    preset.pop("search_clip", None)

    self.analyze_tr = force_tr
    self.analyze_preset = preset
    self.analyze_blksize = blksize if isinstance(blksize, tuple) else (blksize, blksize)
    self.analyze_refine = refine
    self.analyze_thsad_recalc = thsad_recalc
    self.analyze_thscd = thscd

    return self

def back_blend(
    self,
    *,
    mode: BackBlendMode = BackBlendMode.BOTH,
    sigma: float = 1.4,
) -> Self:
    """
    Configure parameters for the back_blend stage.

    :param mode:     Specifies at which stage to perform back-blending.
    :param sigma:    Gaussian blur sigma.
    """

    self.backblend_mode = mode
    self.backblend_sigma = sigma

    return self

def basic(
    self,
    *,
    tr: int = 2,
    thsad: int | tuple[int, int] = 640,
    bobber: Deinterlacer = NNEDI3(nsize=1),
    noise_restore: float = 0.0,
    degrain_args: KwargsT | None = None,
    mask_args: KwargsT | None | Literal[False] = None,
    mask_shimmer_args: KwargsT | None = KwargsT(erosion_distance=0),
) -> Self:
    """
    Configure parameters for the basic stage.

    :param tr:                  Temporal radius of the motion compensated binomial smooth.
    :param thsad:               Thsad of the motion compensated binomial smooth.
    :param bobber:              Bobber to use for initial spatial interpolation.
    :param noise_restore:       How much noise to restore after this stage.
    :param degrain_args:        Arguments passed to [_binomial_degrain][vsdeinterlace.qtgmc.QTempGaussMC._binomial_degrain].
    :param mask_args:           Arguments passed to [MVTools.mask][vsdenoise.mvtools.mvtools.MVTools.mask]
                                for [InputType.REPAIR][vsdeinterlace.qtgmc.QTempGaussMC.InputType.REPAIR].
    :param mask_shimmer_args:   Arguments passed to [_mask_shimmer][vsdeinterlace.qtgmc.QTempGaussMC._mask_shimmer].
    """  # noqa: E501

    self.basic_tr = tr
    self.basic_thsad = thsad
    self.basic_bobber = bobber.copy(tff=self.tff, double_rate=self.double_rate)
    self.basic_noise_restore = noise_restore
    self.basic_degrain_args = fallback(degrain_args, KwargsT())
    self.basic_mask_shimmer_args = fallback(mask_shimmer_args, KwargsT())
    self.basic_mask_args: KwargsT | Literal[False] = fallback(mask_args, KwargsT())

    return self

def deinterlace(self) -> ConstantFormatVideoNode:
    """
    Start the deinterlacing process.

    :return:    Deinterlaced clip.
    """

    self._apply_prefilter()
    self._apply_analyze()
    self._apply_denoise()
    self._apply_basic()
    self._apply_final()
    self._apply_motion_blur()

    return self.motion_blur_output

def denoise(
    self,
    *,
    tr: int = 2,
    func: _DenoiseFuncTr | VSFunctionKwArgs[vs.VideoNode, vs.VideoNode] = partial(DFTTest().denoise, sigma=8),
    mode: NoiseProcessMode = NoiseProcessMode.IDENTIFY,
    deint: NoiseDeintMode = NoiseDeintMode.GENERATE,
    stabilize: tuple[float, float] | Literal[False] = (0.6, 0.2),
    func_comp_args: KwargsT | None = None,
    stabilize_comp_args: KwargsT | None = None,
) -> Self:
    """
    Configure parameters for the denoise stage.

    :param tr:                     Temporal radius of the denoising function & it's motion compensation.
    :param func:                   Denoising function to use.
    :param mode:                   Noise handling method to use.
    :param deint:                  Noise deinterlacing method to use.
    :param stabilize:              Weights to use when blending source noise with compensated noise.
    :param func_comp_args:         Arguments passed to [MVTools.compensate][vsdenoise.mvtools.mvtools.MVTools.compensate] for denoising.
    :param stabilize_comp_args:    Arguments passed to [MVTools.compensate][vsdenoise.mvtools.mvtools.MVTools.compensate] for stabilization.
    """  # noqa: E501

    self.denoise_tr = tr
    self.denoise_func = func
    self.denoise_mode = mode
    self.denoise_deint = deint
    self.denoise_stabilize: tuple[float, float] | Literal[False] = stabilize
    self.denoise_func_comp_args = fallback(func_comp_args, KwargsT())
    self.denoise_stabilize_comp_args = fallback(stabilize_comp_args, KwargsT())

    return self

def final(
    self,
    *,
    tr: int = 3,
    thsad: int | tuple[int, int] = 256,
    noise_restore: float = 0.0,
    degrain_args: KwargsT | None = None,
    mask_shimmer_args: KwargsT | None = None,
) -> Self:
    """
    Configure parameters for the final stage.

    :param tr:                   Temporal radius of the motion compensated smooth.
    :param thsad:                Thsad of the motion compensated smooth.
    :param noise_restore:        How much noise to restore after this stage.
    :param degrain_args:         Arguments passed to [MVTools.degrain][vsdenoise.mvtools.mvtools.MVTools.degrain].
    :param mask_shimmer_args:    Arguments passed to [_mask_shimmer][vsdeinterlace.qtgmc.QTempGaussMC._mask_shimmer].
    """  # noqa: E501

    self.final_tr = tr
    self.final_thsad = thsad
    self.final_noise_restore = noise_restore
    self.final_degrain_args = fallback(degrain_args, KwargsT())
    self.final_mask_shimmer_args = fallback(mask_shimmer_args, KwargsT())

    return self

def lossless(
    self,
    *,
    mode: LosslessMode = LosslessMode.NONE,
) -> Self:
    """
    Configure parameter for the lossless stage.

    :param mode:    Specifies at which stage to re-weave the original fields.
    """

    self.lossless_mode = mode

    return self

def motion_blur(
    self,
    *,
    shutter_angle: tuple[int | float, int | float] = (180, 180),
    fps_divisor: int = 1,
    blur_args: KwargsT | None = None,
    mask_args: KwargsT | None | Literal[False] = KwargsT(ml=4),
) -> Self:
    """
    Configure parameters for the motion blur stage.

    :param shutter_angle:    Tuple containing the source and output shutter angle. Will apply motion blur if they do not match.
    :param fps_divisor:      Factor by which to reduce framerate.
    :param blur_args:        Arguments passed to [MVTools.flow_blur][vsdenoise.mvtools.mvtools.MVTools.flow_blur].
    :param mask_args:        Arguments passed to [MVTools.mask][vsdenoise.mvtools.mvtools.MVTools.mask].
    """  # noqa: E501

    self.motion_blur_shutter_angle = shutter_angle
    self.motion_blur_fps_divisor = fps_divisor
    self.motion_blur_args = fallback(blur_args, KwargsT())
    self.motion_blur_mask_args: KwargsT | Literal[False] = fallback(mask_args, KwargsT())

    return self

def prefilter(
    self,
    *,
    tr: int = 2,
    sc_threshold: float | Literal[False] = 0.1,
    postprocess: SearchPostProcess = SearchPostProcess.GAUSSBLUR_EDGESOFTEN,
    strength: tuple[float, float] = (1.9, 0.1),
    limit: tuple[int | float, int | float, int | float] = (3, 7, 2),
    range_expansion_args: KwargsT | None | Literal[False] = None,
    mask_shimmer_args: KwargsT | None = None,
) -> Self:
    """
    Configure parameters for the prefilter stage.

    :param tr:                      Radius of the initial temporal binomial smooth.
    :param sc_threshold:            Threshold for scene changes, disables sc detection if False.
    :param postprocess:             Post-processing routine to use.
    :param strength:                Tuple containing gaussian blur sigma & blend weight of the blur.
    :param limit:                   3-step limiting thresholds for the gaussian blur post-processing.
    :param range_expansion_args:    Arguments passed to [prefilter_to_full_range][vsdenoise.prefilters.prefilter_to_full_range].
    :param mask_shimmer_args:       Arguments passed to [_mask_shimmer][vsdeinterlace.qtgmc.QTempGaussMC._mask_shimmer].
    """  # noqa: E501

    self.prefilter_tr = tr
    self.prefilter_sc_threshold = sc_threshold
    self.prefilter_postprocess = postprocess
    self.prefilter_blur_strength = strength
    self.prefilter_soften_limit = limit
    self.prefilter_range_expansion_args: KwargsT | Literal[False] = fallback(range_expansion_args, KwargsT())
    self.prefilter_mask_shimmer_args = fallback(mask_shimmer_args, KwargsT())

    return self

def sharpen(
    self,
    *,
    mode: SharpMode | None = None,
    strength: float = 1.0,
    clamp: int | float | tuple[int | float, int | float] = 1,
    thin: float = 0.0,
) -> Self:
    """
    Configure parameters for the sharpen stage.

    :param mode:        Specifies the type of sharpening to use.
    :param strength:    Sharpening strength.
    :param clamp:       Clamp the sharpening strength of
                        [SharpMode.UNSHARP_MINMAX][vsdeinterlace.qtgmc.QTempGaussMC.SharpMode.UNSHARP_MINMAX]
                        to the min/max average plus/minus this.
    :param thin:        How much to vertically thin edges.
    """

    if mode is None:
        self.sharp_mode = self.SharpMode.NONE if self.match_mode else self.SharpMode.UNSHARP_MINMAX
    else:
        self.sharp_mode = mode

    self.sharp_strength = strength
    self.sharp_clamp = normalize_seq(clamp, 2)
    self.sharp_thin = thin

    return self

def sharpen_limit(
    self,
    *,
    mode: SharpLimitMode | None = None,
    radius: int = 3,
    clamp: int | float | tuple[int | float, int | float] = 0,
    comp_args: KwargsT | None = None,
) -> Self:
    """
    Configure parameters for the sharpen_limit stage.

    :param mode:         Specifies type of limiting & at which stage to perform it.
    :param radius:       Radius of sharpness limiting.
    :param clamp:        How much undershoot/overshoot to allow.
    :param comp_args:    Arguments passed to [MVTools.compensate][vsdenoise.mvtools.mvtools.MVTools.compensate] for temporal limiting.
    """  # noqa: E501

    if mode is None:
        self.limit_mode = self.SharpLimitMode.NONE if self.match_mode else self.SharpLimitMode.TEMPORAL_PRESMOOTH
    else:
        self.limit_mode = mode

    self.limit_radius = radius
    self.limit_clamp = clamp
    self.limit_comp_args = fallback(comp_args, KwargsT())

    return self

def source_match(
    self,
    *,
    tr: int = 1,
    bobber: Deinterlacer | None = None,
    mode: SourceMatchMode = SourceMatchMode.NONE,
    similarity: float = 0.5,
    enhance: float = 0.5,
    degrain_args: KwargsT | None = None,
) -> Self:
    """
    Configure parameters for the source_match stage.

    :param tr:              Temporal radius of the refinement motion compensated binomial smooth.
    :param bobber:          Bobber to use for refined spatial interpolation.
    :param mode:            Specifies number of refinement steps to perform.
    :param similarity:      Temporal similarity of the error created by smoothing.
    :param enhance:         Sharpening strength prior to source match refinement.
    :param degrain_args:    Arguments passed to [_binomial_degrain][vsdeinterlace.qtgmc.QTempGaussMC._binomial_degrain].
    """  # noqa: E501

    self.match_tr = tr
    self.match_bobber = fallback(bobber, self.basic_bobber).copy(tff=self.tff, double_rate=self.double_rate)
    self.match_mode = mode
    self.match_similarity = similarity
    self.match_enhance = enhance
    self.match_degrain_args = fallback(degrain_args, KwargsT())

    return self