fft ¶

def denoise(
    self,
    clip_or_sloc: vs.VideoNode | SLocationT | SLocation.MultiDim,
    sloc: SLocationT | SLocation.MultiDim | None = None,
    /,
    tr: int = 0,
    ftype: int = FilterType.WIENER,
    swin: int | SynthesisType | None = None,
    twin: int | SynthesisType | None = None,
    planes: PlanesT = None,
    func: FuncExceptT | None = None,
    **kwargs: Any
) -> vs.VideoNode:
    """
    Denoises a clip using Discrete Fourier Transform (DFT).

    More informations:
        - VapourSynth DFTTest plugin: https://github.com/HomeOfVapourSynthEvolution/VapourSynth-DFTTest/blob/master/README.md
        - AviSynth DFTTest docs: http://avisynth.nl/index.php/Dfttest
        - vs-dfttest2 docstring: https://github.com/AmusementClub/vs-dfttest2/blob/573bb36c53df93c46a38926c7c654569e3679732/dfttest2.py#L614-L764

    Examples:
        Apply a constant sigma:
        ```py
        denoised = DFTTest().denoise(clip, sigma=16)
        ```

        Use frequency-dependent sigma values:
        ```py
        denoised = DFTTest().denoise(clip, {0: 0, 0.25: 4, 0.5: 8, 0.75: 16, 1.0: 32})
        ```

    :param clip_or_sloc:    Either a video clip or frequency location.
    :param sloc:            Frequency location (used if `clip_or_sloc` is a video clip).
    :param tr:              Temporal radius for denoising (equivalent to `tbsize`).
    :param ftype:           Filter type for denoising (see [FilterType][vsdenoise.fft.DFTTest.FilterType] enum, e.g.).
    :param swin:            Synthesis window size (can use [SynthesisType][vsdenoise.fft.DFTTest.SynthesisType] enum).
    :param twin:            Temporal window size (can use [SynthesisType][vsdenoise.fft.DFTTest.SynthesisType] enum).
    :param planes:          Planes to apply the denoising filter.
    :param func:            Function returned for custom error handling.
    :param kwargs:          Additional parameters for the denoising process.
    :return:                The denoised video node.
    """
    func = func or self.denoise

    nclip: vs.VideoNode | None

    if isinstance(clip_or_sloc, vs.VideoNode):
        nclip = clip_or_sloc
        nsloc = self.default_slocation if sloc is None else sloc
    else:
        nclip = self.clip
        nsloc = clip_or_sloc

    if nclip is None:
        raise CustomValueError('You must pass a clip!', func)

    assert check_progressive(nclip, func)

    ckwargs = dict[str, Any](
        tbsize=tr * 2 + 1,
        ftype=ftype,
        swin=swin,
        twin=twin,
        planes=planes
    )

    if isinstance(nsloc, DFTTest.SLocation.MultiDim):
        ckwargs.update(ssx=nsloc.horizontal, ssy=nsloc.vertical, sst=nsloc.temporal)
    else:
        ckwargs.update(slocation=DFTTest.SLocation.from_param(nsloc))

    for k, v in ckwargs.items():
        if isinstance(v, DFTTest.SLocation):
            ckwargs[k] = list[float](flatten(v.items()))

    return self.backend.DFTTest(nclip, **KwargsNotNone(ckwargs) | self.default_args | kwargs)

def extract_freq(
    self, clip: vs.VideoNode, sloc: SLocationT | SLocation.MultiDim, **kwargs: Any
) -> vs.VideoNode:
    """
    Extracts the frequency domain from the given clip by subtracting the denoised clip from the original.

    :param clip:    The clip from which the frequency domain is to be extracted.
    :param sloc:    The frequency location for the extraction process.
    :param kwargs:  Additional parameters for the extraction process.
    :return:        The clip with the extracted frequency domain.
    """
    kwargs = dict(func=self.extract_freq) | kwargs
    return clip.std.MakeDiff(self.denoise(clip, sloc, **kwargs))

def insert_freq(
    self, low: vs.VideoNode, high: vs.VideoNode, sloc: SLocationT | SLocation.MultiDim, **kwargs: Any
) -> vs.VideoNode:
    """
    Inserts the frequency domain from one clip into another by merging the frequency information.

    :param low:     The low-frequency component clip.
    :param high:    The high-frequency component clip.
    :param sloc:    The frequency location for the merging process.
    :param kwargs:  Additional parameters for the merging process.
    :return:        The merged clip with the inserted frequency domain.
    """
    return low.std.MergeDiff(self.extract_freq(high, sloc, **dict(func=self.insert_freq) | kwargs))

def merge_freq(
    self, low: vs.VideoNode, high: vs.VideoNode, sloc: SLocationT | SLocation.MultiDim, **kwargs: Any
) -> vs.VideoNode:
    """
    Merges the low and high-frequency components by applying denoising to the low-frequency component.

    :param low:     The low-frequency component clip.
    :param high:    The high-frequency component clip.
    :param sloc:    The frequency location for the merging process.
    :param kwargs:  Additional parameters for the merging process.
    :return:        The merged clip with the denoised low-frequency and high-frequency components.
    """
    return self.insert_freq(
        self.denoise(low, sloc, **kwargs), high, sloc, **dict(func=self.merge_freq) | kwargs
    )