qtgmc ¶

@cachedproperty
def basic(self) -> vs.VideoNode:
    """Output of [QTempGaussMC.basic][vsdeinterlace.QTempGaussMC.basic]."""

    smoothed = self._binomial_degrain(self.bobbed, self.settings.basic_tr, **self.settings.basic_degrain_args)

    if self.settings.basic_tr:
        smoothed = mask_shimmer(smoothed, self.bobbed, **self.settings.basic_mask_shimmer_args, func=self.func)

        if self.settings.source_match_iterations:
            smoothed = self._source_match(smoothed)

    if self.settings.lossless_mode is self.settings.LosslessMode.PRESHARPEN:
        smoothed = self._lossless(smoothed)

    resharp = self._sharpen(smoothed)

    if self.settings.sharpen_limit_mode.is_presmooth and self._sharpness_limiting_enabled:
        if self.settings.back_blend_mode in (
            self.settings.BackBlendMode.PRELIMIT,
            self.settings.BackBlendMode.BOTH,
        ):
            resharp = self._back_blend(resharp, smoothed)

        resharp = self._sharpen_limit(resharp)

        if self.settings.back_blend_mode in (
            self.settings.BackBlendMode.POSTLIMIT,
            self.settings.BackBlendMode.BOTH,
        ):
            resharp = self._back_blend(resharp, smoothed)
    elif self.settings.back_blend_mode is not self.settings.BackBlendMode.NONE and self._sharpening_enabled:
        resharp = self._back_blend(resharp, smoothed)

    return self._noise_restore(resharp, self.settings.basic_noise_restore)

@cachedproperty
def bobbed(self) -> vs.VideoNode:
    """
    High-quality bobbed clip.

    Used as a spatial interpolation base for [QTempGaussMC.basic][vsdeinterlace.QTempGaussMC.basic] and
    [QTempGaussMC.source_match][vsdeinterlace.QTempGaussMC.source_match].
    """

    bobbed = self._interpolate(self._bobber_input, self.settings.basic_bobber)

    if self._repair_mask_enabled:
        mask = self.mv.mask(
            direction=MVDirection.BACKWARD,
            kind=MaskMode.SAD,
            thscd=self.settings.analyze_thscd,
            **self.settings.basic_mask_args,
        )
        bobbed = self._denoise_output.std.MaskedMerge(bobbed, mask)

    return bobbed

@cachedproperty
def denoise(self) -> vs.VideoNode:
    """
    Output of [QTempGaussMC.denoise][vsdeinterlace.QTempGaussMC.denoise].

    Only available when using noise processing.
    """

    if self.settings.denoise_mc_denoise and self.settings.denoise_tr:
        denoised = self.mv.compensate(
            tr=self.settings.denoise_tr,
            thscd=self.settings.analyze_thscd,
            temporal_func=lambda clip: self.settings.denoise_func(clip, tr=self.settings.denoise_tr),
            **self.settings.denoise_func_comp_args,
        )
    else:
        denoised = self.settings.denoise_func(self.draft, tr=self.settings.denoise_tr)

    if self.mode in (self.Mode.DEINTERLACE, self.Mode.BOB):
        denoised = reinterlace(denoised, self.tff, self.func)

    return denoised

@cachedproperty
def draft(self) -> vs.VideoNode:
    """
    Draft processed clip.

    Used as a base for [QTempGaussMC.prefilter][vsdeinterlace.QTempGaussMC.prefilter] and
    [QTempGaussMC.denoise][vsdeinterlace.QTempGaussMC.denoise].

    Only available when using noise or motion-compensated processing.
    """

    if self.mode in (self.Mode.DEINTERLACE, self.Mode.BOB):
        return Catrom().bob(self.clip, tff=self.tff)

    return self.clip

@cachedproperty
def final(self) -> vs.VideoNode:
    """Output of [QTempGaussMC.final][vsdeinterlace.QTempGaussMC.final]."""

    if self.settings.final_tr:
        smoothed = self.mv.degrain(
            self.basic,
            tr=self.settings.final_tr,
            thsad=self.settings.final_thsad,
            thsad2=self.settings.final_thsad2,
            thscd=self.settings.analyze_thscd,
            **self.settings.final_degrain_args,
        )
    else:
        smoothed = self.basic

    if smoothed is not self.bobbed:
        smoothed = mask_shimmer(smoothed, self.bobbed, **self.settings.final_mask_shimmer_args, func=self.func)

    if self.settings.sharpen_limit_mode.is_postsmooth and self._sharpness_limiting_enabled:
        smoothed = self._sharpen_limit(smoothed)

    if self.settings.lossless_mode is self.settings.LosslessMode.POSTSMOOTH:
        smoothed = self._lossless(smoothed)

    return self._noise_restore(smoothed, self.settings.final_noise_restore)

def freeze(self) -> Self:
    """
    Freeze the graph at its current evaluation state.

    Cached properties remain accessible; however, attempting to access a property that has not been evaluated raises
    an `AttributeError`
    """

    cache = self.__dict__.setdefault(cachedproperty.cache_key, {})

    if not isinstance(cache, self._FrozenCache):
        self.__dict__[cachedproperty.cache_key] = self._FrozenCache(cache)

    return self

@cachedproperty
def motion_blur(self) -> vs.VideoNode:
    """Output of [QTempGaussMC.motion_blur][vsdeinterlace.QTempGaussMC.motion_blur]."""

    if self._motion_blur_level:
        blurred = self.mv.flow_blur(
            self.final,
            blur=self._motion_blur_level,
            thscd=self.settings.analyze_thscd,
            **self.settings.motion_blur_blur_args,
        )

        if self.settings.motion_blur_mask_args.get("ml") != 0:
            mask = self.mv.mask(
                direction=MVDirection.BACKWARD,
                kind=MaskMode.VECTOR_LENGTH,
                thscd=self.settings.analyze_thscd,
                **self.settings.motion_blur_mask_args,
            )

            blurred = self.final.std.MaskedMerge(blurred, mask)
    else:
        blurred = self.final

    if self._motion_blur_fps_divisor > 1:
        blurred = blurred[:: self._motion_blur_fps_divisor]

    return blurred

@cachedproperty
def mv(self) -> MVTools:
    """
    [MVTools][vsdenoise.mvtools.mvtools.MVTools] instance used during processing.

    Only available when using motion-compensated processing.
    """

    preset = dict(self.settings.analyze_preset)
    if not self.settings.analyze_vectors:
        preset.update(search_clip=self.prefilter)

    mv = MVTools(self.draft, vectors=self.settings.analyze_vectors, **preset)

    if self.settings.analyze_vectors:
        return mv

    noise_restore_enabled = bool(self.settings.basic_noise_restore or self.settings.final_noise_restore)

    tr = max(
        self.settings.analyze_force_tr,
        self.settings.denoise_tr
        if self.settings.denoise_mc_denoise and (self.settings.denoise_full_denoise or noise_restore_enabled)
        else 0,
        self.settings.denoise_stabilize is not False and noise_restore_enabled,
        self._repair_mask_enabled,
        self.settings.basic_tr,
        self.settings.source_match_tr
        if self.settings.source_match_iterations > 1 and self.settings.basic_tr
        else 0,
        self.settings.sharpen_limit_radius
        if self.settings.sharpen_limit_mode.is_temporal and self._sharpness_limiting_enabled
        else 0,
        self.settings.final_tr,
        bool(self._motion_blur_level),
    )

    blksize = self.settings.analyze_blksize
    mv.analyze(tr=tr, blksize=blksize, overlap_div=self.settings.analyze_overlap)

    for _ in range(self.settings.analyze_refine):
        blksize = refine_blksize(blksize)
        mv.recalculate(
            thsad=self.settings.analyze_thsad_recalc, blksize=blksize, overlap_div=self.settings.analyze_overlap
        )

    return mv

@cachedproperty
def noise(self) -> vs.VideoNode:
    """
    Noise extracted by [QTempGaussMC.denoise][vsdeinterlace.QTempGaussMC.denoise].

    Only available when using noise restoration.
    """

    noise = self.clip.std.MakeDiff(self.denoise)

    if self.mode in (self.Mode.DEINTERLACE, self.Mode.BOB):
        match self.settings.denoise_deint:
            case self.settings.NoiseDeintMode.WEAVE:
                noise = noise.std.SeparateFields(self.tff.is_tff).std.DoubleWeave(self.tff.is_tff)
            case self.settings.NoiseDeintMode.BOB:
                noise = Catrom().bob(noise, tff=self.tff)
            case self.settings.NoiseDeintMode.GENERATE:
                noise = noise.std.SeparateFields(self.tff.is_tff)

                noise_min = Morpho.inpand(noise, sw=2, sh=1, func=self.func)
                noise_max = Morpho.expand(noise, sw=2, sh=1, func=self.func)

                noise_gen = Grainer.GAUSS(
                    noise,
                    # Use the maximum variance that satisfies the 3-sigma rule.
                    (0.5 * 255 / 3) ** 2,
                    protect_edges=False,
                    protect_neutral_chroma=False,
                    neutral_out=True,
                )
                noise_gen = norm_expr(
                    [noise_max, noise_min, noise_gen],
                    # Limitation: This gain map can never reach 1.0 with integer formats.
                    # Peak gain at 8-bit: (255 - 128) / 256 + 0.5 = ~0.996.
                    "y x y - z neutral - range_size / 0.5 + * +",
                    func=self.func,
                )
                noise = reweave(noise, noise_gen, self.tff.field, self.func)

        noise = FieldBased.PROGRESSIVE.apply(noise)

    if self.settings.denoise_stabilize is not False:
        noise_comp, _ = self.mv.compensate(
            noise,
            direction=MVDirection.BACKWARD,
            tr=1,
            thscd=self.settings.analyze_thscd,
            interleave=False,
            **self.settings.denoise_stabilize_comp_args,
        )

        noise = norm_expr(
            [noise, *noise_comp],
            "x neutral - abs y neutral - abs > x y ? dup x y + 2 / swap - {weight} * +",
            weight=self.settings.denoise_stabilize,
            func=self.func,
        )

    return noise

@cachedproperty
def prefilter(self) -> vs.VideoNode:
    """
    Output of [QTempGaussMC.prefilter][vsdeinterlace.QTempGaussMC.prefilter].

    Only available when motion vectors need to be generated.
    """

    if self.mode is self.Mode.REPAIR:
        search = BlurMatrix.BINOMIAL()(self.draft, mode=ConvMode.VERTICAL, func=self.func)
    else:
        search = self.draft

    if self.settings.prefilter_tr:
        smoothed = BlurMatrix.BINOMIAL(self.settings.prefilter_tr, mode=ConvMode.TEMPORAL)(
            sc_detect(search, self.settings.prefilter_sc_threshold), scenechange=True, func=self.func
        )
        smoothed = mask_shimmer(smoothed, search, **self.settings.prefilter_mask_shimmer_args, func=self.func)
    else:
        smoothed = search

    sigma, blend_weight = self.settings.prefilter_strength
    lim1, lim2, lim3 = [scale_delta(thr, 8, self.clip) for thr in self.settings.prefilter_limit]

    blurred = gauss_blur(smoothed, sigma) if sigma and blend_weight else smoothed
    limited = norm_expr(
        [blurred, smoothed, search],
        "y x y - {weight} * + BLUR! z y {lim1} - y {lim1} + clamp TWEAK! "
        "BLUR@ {lim2} + TWEAK@ < BLUR@ {lim3} + BLUR@ {lim2} - TWEAK@ > BLUR@ {lim3} - "
        "TWEAK@ BLUR@ TWEAK@ - {bias} * + ? ?",
        weight=blend_weight,
        lim1=lim1,
        lim2=lim2,
        lim3=lim3,
        bias=self.settings.prefilter_bias,
        func=self.func,
    )

    return prefilter_to_full_range(limited, func=self.func, **self.settings.prefilter_range_expansion_args)