prefilters ¶

def __call__(self, clip: vs.VideoNode, /, **kwargs: Any) -> vs.VideoNode:  # type: ignore
    for pref in self.prefilters:
        clip = pref(clip)

    return clip

def __call__(  # type: ignore
    self, clip: vs.VideoNode | MissingT = MISSING, /,
    planes: PlanesT = None, full_range: bool | float = False, **kwargs: Any
) -> vs.VideoNode | PrefilterPartial:
    ...

def __call__(  # type: ignore
    self: Prefilter, clip: vs.VideoNode | MissingT = MISSING, /,
    planes: PlanesT = None, full_range: bool | float = False, **kwargs: Any
) -> vs.VideoNode | PrefilterPartial:
    def _run(clip: vs.VideoNode, planes: PlanesT, **kwargs: Any) -> vs.VideoNode:
        assert check_variable(clip, self)

        pref_type = self

        planes = normalize_planes(clip, planes)

        if pref_type == Prefilter.NONE:
            return clip

        if pref_type == Prefilter.MINBLUR:
            return min_blur(clip, **kwargs, planes=planes)

        if pref_type == Prefilter.GAUSS:
            return gauss_blur(clip, kwargs.pop('sigma', 1.5), **kwargs, planes=planes)

        if pref_type == Prefilter.FLUXSMOOTHST:
            temp_thr, spat_thr = kwargs.pop('temp_thr', 2), kwargs.pop('spat_thr', 2)
            return flux_smooth(clip, temp_thr, spat_thr, **kwargs)

        if pref_type == Prefilter.DFTTEST:
            peak = get_peak_value(clip)
            pref_mask: vs.VideoNode | Literal[False] | tuple[int, int] | None = kwargs.pop("pref_mask", None)

            dftt = DFTTest(sloc={0.0: 4, 0.2: 9, 1.0: 15}, tr=0).denoise(
                clip, kwargs.pop("sloc", None), planes=planes, **kwargs
            )

            if pref_mask is False:
                return dftt

            lower, upper = 16., 75.

            if isinstance(pref_mask, tuple):
                lower, upper = pref_mask

            if not isinstance(pref_mask, vs.VideoNode):
                lower, upper = (scale_value(x, 8, clip) for x in (lower, upper))
                pref_mask = norm_expr(
                    get_y(clip),
                    f'x {lower} < {peak} x {upper} > 0 {peak} x {lower} - {peak} {upper} {lower} - / * - ? ?',
                    func=self
                )

            return dftt.std.MaskedMerge(clip, pref_mask, planes)

        if pref_type == Prefilter.NLMEANS:
            kwargs |= dict(strength=7.0, tr=1, sr=2, simr=2) | kwargs | dict(planes=planes)

            return nl_means(clip, **kwargs)

        if pref_type == Prefilter.BM3D:
            bm3d_arch: type[AbstractBM3D] = kwargs.pop('arch', None)
            gpu: bool | None = kwargs.pop('gpu', None)

            if gpu is None:
                gpu = hasattr(core, 'bm3dcuda')

            if bm3d_arch is None:
                if gpu:  # type: ignore
                    bm3d_arch = BM3DCudaRTC if hasattr(core, 'bm3dcuda_rtc') else BM3DCuda
                else:
                    bm3d_arch = BM3DCPU if hasattr(core, 'bm3dcpu') else BM3DM

            if bm3d_arch is BM3DM:
                sigma, profile = 10, Profile.FAST
            elif bm3d_arch is BM3DCPU:
                sigma, profile = 10, Profile.LOW_COMPLEXITY
            elif bm3d_arch in (BM3DCuda, BM3DCudaRTC):
                sigma, profile = 8, Profile.NORMAL
            else:
                raise ValueError

            sigmas = kwargs.pop(
                'sigma', [sigma if 0 in planes else 0, sigma if (1 in planes or 2 in planes) else 0]
            )

            bm3d_args = dict[str, Any](sigma=sigmas, tr=1, profile=profile) | kwargs

            return bm3d_arch.denoise(clip, **bm3d_args)

        if pref_type is Prefilter.BILATERAL:
            sigmaS = cast(float | list[float] | tuple[float | list[float], ...], kwargs.pop('sigmaS', 3.0))
            sigmaR = cast(float | list[float] | tuple[float | list[float], ...], kwargs.pop('sigmaR', 0.02))

            if isinstance(sigmaS, tuple):
                baseS, *otherS = sigmaS
            else:
                baseS, otherS = sigmaS, []

            if isinstance(sigmaR, tuple):
                baseR, *otherR = sigmaR
            else:
                baseR, otherR = sigmaR, []

            base, ref = clip, None
            max_len = max(len(otherS), len(otherR))

            if max_len:
                otherS = list[float | list[float]](reversed(normalize_seq(otherS or baseS, max_len)))
                otherR = list[float | list[float]](reversed(normalize_seq(otherR or baseR, max_len)))

                for siS, siR in zip(otherS, otherR):
                    base, ref = ref or clip, bilateral(base, ref, siS, siR, **kwargs)

            return bilateral(clip, ref, baseS, baseR, **kwargs)

        raise CustomNotImplementedError(func=self, reason=self)

    if clip is MISSING:
        return PrefilterPartial(self, planes, **kwargs)

    out = _run(clip, planes, **kwargs)

    if full_range is not False:
        if full_range is True:
            full_range = 2.0

        return prefilter_to_full_range(out, full_range)

    return out

def __call__(  # type: ignore
    self, clip: vs.VideoNode, /, planes: PlanesT | MissingT = MISSING, **kwargs: Any
) -> vs.VideoNode:
    return self.prefilter(
        clip, planes=self.planes if planes is MISSING else planes, **kwargs | self.kwargs
    )