qtgmc ¶

def analyze(
    self,
    *,
    force_tr: int = 0,
    preset: Mapping[str, Any] = MVToolsPreset.HQ_SAD,
    blksize: int | tuple[int, int] = 16,
    overlap: int | tuple[int, int] = 2,
    refine: int = 1,
    thsad_recalc: int | None = None,
    thscd: int | tuple[int | None, 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.
        overlap: The blksize divisor for block overlap. Larger overlapping reduces blocking artifacts.
        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.
    """

    self.analyze_force_tr = force_tr
    self.analyze_preset = preset
    self.analyze_blksize = blksize
    self.analyze_overlap = overlap
    self.analyze_refine = refine
    self.analyze_thsad_recalc = thsad_recalc
    self.analyze_thscd = thscd

    return self

def back_blend(self, *, mode: BackBlendMode = BackBlendMode.PRELIMIT, 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: BobberLike = NNEDI3(nsize=1),
    noise_restore: float = 0,
    degrain_args: QTGMCArgs.Degrain | None = None,
    mask_args: QTGMCArgs.Mask | None = {"ml": 10},
    mask_shimmer_args: QTGMCArgs.MaskShimmer | None = {"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:

               - erosion_distance: How much to deflate then reflate to remove thin areas.
                 Default is 0 for this stage.
               - over_dilation: Extra inflation to ensure areas to restore back are fully caught.
                 Default is 0.
    """

    self.basic_tr = tr
    self.basic_thsad = thsad
    self.basic_bobber = (
        deepcopy(bobber) if isinstance(bobber, Bobber) else Bobber.ensure_obj(bobber, self.__class__)
    )
    self.basic_noise_restore = noise_restore
    self.basic_degrain_args = fallback(degrain_args, QTGMCArgs.Degrain())
    self.basic_mask_args = fallback(mask_args, QTGMCArgs.Mask())
    self.basic_mask_shimmer_args = fallback(mask_shimmer_args, QTGMCArgs.MaskShimmer())

    return self

def deinterlace(self) -> vs.VideoNode:
    """
    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 = 1,
    func: DFTTest | _DenoiseFuncTr = DFTTest(sigma=8),
    mode: NoiseProcessMode = NoiseProcessMode.IDENTIFY,
    deint: NoiseDeintMode = NoiseDeintMode.GENERATE,
    mc_denoise: bool = True,
    stabilize: tuple[float, float] | Literal[False] = (0.6, 0.2),
    func_comp_args: QTGMCArgs.Compensate | None = None,
    stabilize_comp_args: QTGMCArgs.Compensate | 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.
        mc_denoise: Whether to perform motion-compensated denoising.
        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.denoise if isinstance(func, DFTTest) else func
    self.denoise_mode = mode
    self.denoise_deint = deint
    self.denoise_mc_denoise = mc_denoise
    self.denoise_stabilize: tuple[float, float] | Literal[False] = stabilize
    self.denoise_func_comp_args = fallback(func_comp_args, QTGMCArgs.Compensate())
    self.denoise_stabilize_comp_args = fallback(stabilize_comp_args, QTGMCArgs.Compensate())

    return self

def final(
    self,
    *,
    tr: int = 1,
    thsad: int | tuple[int, int] = 256,
    noise_restore: float = 0,
    degrain_args: QTGMCArgs.Degrain | None = None,
    mask_shimmer_args: QTGMCArgs.MaskShimmer | None = {"erosion_distance": 4},
) -> 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: Arguments passed to the mask_shimmer call:

               - erosion_distance: How much to deflate then reflate to remove thin areas.
                 Default is 4 for this stage.
               - over_dilation: Extra inflation to ensure areas to restore back are fully caught.
                 Default is 0.
    """

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

    return self

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

    Args:
        mode: Specifies at which stage to re-weave the original fields.
        anti_comb: Whether to apply combing reduction post-processing.
    """

    self.lossless_mode = mode
    self.lossless_anti_comb = anti_comb

    return self

def motion_blur(
    self,
    *,
    shutter_angle: tuple[float, float] = (180, 180),
    fps_divisor: int = 1,
    blur_args: QTGMCArgs.Blur | None = None,
    mask_args: QTGMCArgs.Mask | None = {"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_blur_args = fallback(blur_args, QTGMCArgs.Blur())
    self.motion_blur_mask_args = fallback(mask_args, QTGMCArgs.Mask())

    return self

def prefilter(
    self,
    *,
    tr: int = 2,
    sc_threshold: float = 0.1,
    postprocess: SearchPostProcess = SearchPostProcess.GAUSSBLUR_EDGESOFTEN,
    strength: tuple[float, float] | Literal[False] = (1.9, 0.1),
    limit: tuple[float, float, float] = (3, 7, 2),
    bias: float = 0.51,
    range_expansion_args: QTGMCArgs.PrefilterToFullRange | None = None,
    mask_shimmer_args: QTGMCArgs.MaskShimmer | None = {"erosion_distance": 4},
) -> 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 (8-bit) thresholds for the gaussian blur post-processing. Only for
            [SearchPostProcess.GAUSSBLUR_EDGESOFTEN][vsdeinterlace.qtgmc.QTempGaussMC.SearchPostProcess.GAUSSBLUR_EDGESOFTEN].
        bias: Bias for blending the gaussian blurred clip with the limited output. Only for
            [SearchPostProcess.GAUSSBLUR_EDGESOFTEN][vsdeinterlace.qtgmc.QTempGaussMC.SearchPostProcess.GAUSSBLUR_EDGESOFTEN].
        range_expansion_args: Arguments passed to
            [prefilter_to_full_range][vsdenoise.prefilters.prefilter_to_full_range].
        mask_shimmer_args: Arguments passed to the mask_shimmer call:

               - erosion_distance: How much to deflate then reflate to remove thin areas.
                 Default is 4 for this stage.
               - over_dilation: Extra inflation to ensure areas to restore back are fully caught.
                 Default is 0.
    """

    self.prefilter_tr = tr
    self.prefilter_sc_threshold = sc_threshold
    self.prefilter_postprocess = postprocess
    self.prefilter_strength: tuple[float, float] | Literal[False] = strength
    self.prefilter_limit = limit
    self.prefilter_bias = bias
    self.prefilter_range_expansion_args = fallback(range_expansion_args, QTGMCArgs.PrefilterToFullRange())
    self.prefilter_mask_shimmer_args = fallback(mask_shimmer_args, QTGMCArgs.MaskShimmer())

    return self

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

    Args:
        mode: Specifies the type of sharpening to use.
            Defaults to [SharpenMode.UNSHARP][vsdeinterlace.qtgmc.QTempGaussMC.SharpenMode.UNSHARP] for
                [InputType.PROGRESSIVE][vsdeinterlace.qtgmc.QTempGaussMC.InputType.PROGRESSIVE] or
                [SharpenMode.UNSHARP_MINMAX][vsdeinterlace.qtgmc.QTempGaussMC.SharpenMode.UNSHARP_MINMAX] otherwise.
        strength: Sharpening strength. Defaults to 1 for
            [SourceMatchMode.NONE][vsdeinterlace.qtgmc.QTempGaussMC.SourceMatchMode.NONE] or 0 otherwise.
        clamp: Clamp the sharpening strength of
            [SharpenMode.UNSHARP_MINMAX][vsdeinterlace.qtgmc.QTempGaussMC.SharpenMode.UNSHARP_MINMAX] to the min/max
            average plus/minus this.
        thin: How much to vertically thin edges.
    """

    self.sharpen_mode = mode
    self.sharpen_strength = strength
    self.sharpen_clamp = normalize_seq(clamp, 2)
    self.sharpen_thin = thin

    return self

def sharpen_limit(
    self,
    *,
    mode: SharpenLimitMode = SharpenLimitMode.TEMPORAL_PRESMOOTH,
    radius: int | None = None,
    clamp: float | tuple[float, float] = 0,
    comp_args: QTGMCArgs.Compensate | 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. Defaults to 1 for
            [SourceMatchMode.NONE][vsdeinterlace.qtgmc.QTempGaussMC.SourceMatchMode.NONE] or 0 otherwise.
        clamp: How much undershoot/overshoot to allow.
        comp_args: Arguments passed to [MVTools.compensate][vsdenoise.mvtools.mvtools.MVTools.compensate] for
            temporal limiting.
    """

    self.sharpen_limit_mode = mode
    self.sharpen_limit_radius = radius
    self.sharpen_limit_clamp = clamp
    self.sharpen_limit_comp_args = fallback(comp_args, QTGMCArgs.Compensate())

    return self

def source_match(
    self,
    *,
    tr: int = 1,
    bobber: BobberLike | None = None,
    mode: SourceMatchMode = SourceMatchMode.NONE,
    similarity: float = 0.5,
    enhance: float = 0.5,
    degrain_args: QTGMCArgs.Degrain | 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. Defaults to the basic bobber.
        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.source_match_tr = tr
    self.source_match_bobber = bobber
    self.source_match_mode = mode
    self.source_match_similarity = similarity
    self.source_match_enhance = enhance
    self.source_match_degrain_args = fallback(degrain_args, QTGMCArgs.Degrain())

    return self