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})
        ```

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

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

    Args:
        clip: The clip from which the frequency domain is to be extracted.
        sloc: The frequency location for the extraction process.
        **kwargs: Additional parameters for the extraction process.

    Returns:
        The clip with the extracted frequency domain.
    """
    kwargs = {"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.

    Args:
        low: The low-frequency component clip.
        high: The high-frequency component clip.
        sloc: The frequency location for the merging process.
        **kwargs: Additional parameters for the merging process.

    Returns:
        The merged clip with the inserted frequency domain.
    """
    return low.std.MergeDiff(self.extract_freq(high, sloc, **{"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.

    Args:
        low: The low-frequency component clip.
        high: The high-frequency component clip.
        sloc: The frequency location for the merging process.
        **kwargs: Additional parameters for the merging process.

    Returns:
        The merged clip with the denoised low-frequency and high-frequency components.
    """
    return self.insert_freq(self.denoise(low, sloc, **kwargs), high, sloc, **{"func": self.merge_freq} | kwargs)