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.

    Args:
        force_tr: Always analyze motion to at least this, even if otherwise unnecessary.
        preset: MVTools preset defining base values for the MVTools object.
        blksize: Size of a block. Larger blocks are less sensitive to noise, are faster, but also less accurate.
        refine: Number of times to recalculate motion vectors with halved block size.
        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.
        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.

    Args:
        mode: Specifies at which stage to perform back-blending.
        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.

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

    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.

    Returns:
        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.

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

    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.

    Args:
        tr: Temporal radius of the motion compensated smooth.
        thsad: Thsad of the motion compensated smooth.
        noise_restore: How much noise to restore after this stage.
        degrain_args: Arguments passed to [MVTools.degrain][vsdenoise.mvtools.mvtools.MVTools.degrain].
        mask_shimmer_args: mask_shimmer_args: Arguments passed to the mask_shimmer call.
    """

    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.

    Args:
        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.

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

    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.

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

    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.

    Args:
        mode: Specifies the type of sharpening to use.
        strength: Sharpening strength.
        clamp: Clamp the sharpening strength of
            [SharpMode.UNSHARP_MINMAX][vsdeinterlace.qtgmc.QTempGaussMC.SharpMode.UNSHARP_MINMAX] to the min/max
            average plus/minus this.
        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.

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

    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.

    Args:
        tr: Temporal radius of the refinement motion compensated binomial smooth.
        bobber: Bobber to use for refined spatial interpolation.
        mode: Specifies number of refinement steps to perform.
        similarity: Temporal similarity of the error created by smoothing.
        enhance: Sharpening strength prior to source match refinement.
        degrain_args: Arguments passed to the binomial_degrain call.
    """

    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