noise ¶

def __call__(self, clip: vs.VideoNode, /, **kwargs: Any) -> vs.VideoNode | GrainerPartial:
    raise NotImplementedError

def __call__(
    self,
    clip: vs.VideoNode | MissingT = MISSING,
    /,
    strength: float | Sequence[float] = 0,
    static: bool = False,
    scale: float | tuple[float, float] = 1.0,
    scaler: ScalerLike = LanczosTwoPasses,
    temporal: float | tuple[float, int] = (0.0, 0),
    post_process: _PostProcessFunc | Iterable[_PostProcessFunc] | None = None,
    protect_edges: bool | EdgeLimits = True,
    protect_neutral_chroma: bool | None = None,
    luma_scaling: float | None = None,
    **kwargs: Any,
) -> vs.VideoNode | GrainerPartial:
    """
    Apply grain to a clip using the selected graining method.

    If no clip is passed, a partially applied grainer with the provided arguments is returned instead.

    Example usage:
        ```py
        # For PERLIN, SIMPLEX, and FBM_SIMPLEX, it is recommended to use `size` instead of `scale`,
        # as `size` allows for direct internal customization of each grain type.
        grained = Grainer.PERLIN(clip, (1.65, 0.65), temporal=(0.25, 2), luma_scaling=4, size=3.0, seed=333)
        ```

    Args:
        clip:
            The input clip to apply grain to. If omitted, returns a partially applied grainer.
        strength:
            Grain strength.
            A single float applies uniform strength to all planes.
            A sequence allows per-plane control.

        static:
            If True, the grain pattern is static (unchanging across frames).
        scale:
            Scaling divisor for the grain layer.
            Can be a float (uniform scaling) or a tuple (width, height scaling).
        scaler:
            Scaler used to resize the grain layer when `scale` is not 1.0.
        temporal:
            Temporal grain smoothing parameters. Either a float (weight) or a tuple of (weight, radius).
        post_process:
            One or more functions applied after grain generation (and temporal smoothing, if used).
        protect_edges:
            Protects edge regions of each plane from graining.

               - True: Use legal range based on clip format.
               - False: Disable edge protection.
               - Tuple: Specify custom edge limits per plane (see `EdgeLimits`).

        protect_neutral_chroma:
            Whether to disable graining on neutral chroma.
        luma_scaling:
            Sensitivity of the luma-adaptive graining mask.
            Higher values reduce grain in brighter areas; negative values invert behavior.
        **kwargs:
            Additional arguments to pass to the graining function or additional advanced options:

               - ``temporal_avg_func``: Temporal average function to use instead of the default standard mean.
               - ``protect_edges_blend``: Blend range (float) to soften edge protection thresholds.
               - ``protect_neutral_chroma_blend``: Blend range (float) for neutral chroma protection.
               - ``neutral_out``: (Boolean) Output the neutral layer instead of the merged clip.

    Returns:
        Grained video clip, or a `GrainerPartial` if `clip` is not provided.
    """
    kwargs.update(
        strength=strength,
        scale=scale,
        scaler=scaler,
        temporal=temporal,
        protect_edges=protect_edges,
        post_process=post_process,
        protect_neutral_chroma=protect_neutral_chroma,
        luma_scaling=luma_scaling,
    )

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

    assert check_variable(clip, self.name)

    if self == Grainer.PLACEBO:
        assert static is False, "PlaceboGrain does not support static noise!"

        grained = _apply_grainer(
            clip,
            lambda clip, strength, planes, **kwds: placebo_deband(
                clip, 8, 0.0, strength, planes, iterations=1, **kwds
            ),
            **kwargs,
            func=self.name,
        )
    else:
        if not isinstance(size := kwargs.pop("size", (None, None)), tuple):
            size = (size, size)

        kwargs.update(xsize=size[0], ysize=size[1])

        grained = _apply_grainer(
            clip,
            lambda clip, strength, planes, **kwds: core.noise.Add(
                clip,
                *strength[:2],  # type: ignore[misc]
                type=self.value,
                constant=static,
                **kwds,
            ),
            **kwargs,
            func=self.name,
        )

    return grained

def __call__(self, clip: vs.VideoNode, /, **kwargs: Any) -> vs.VideoNode:
    """
    Apply the grainer to the given clip with optional argument overrides.

    Args:
        clip: Clip to be processed.
        **kwargs: Additional keyword arguments to override or extend the stored ones.

    Returns:
        Processed clip.
    """
    return self.grainer(clip, **self.kwargs | kwargs)

def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any,
) -> vs.VideoNode | ConstantFormatVideoNode:
    assert check_variable(clip, self.__class__)

    width, height = self._wh_norm(clip, width, height)

    if width / clip.width > 1.5 or height / clip.height > 1.5:
        # If the scale is too big, we need to scale it in two passes, else the window
        # will be too big and the grain will be dampened down too much
        mod = max(clip.format.subsampling_w, clip.format.subsampling_h) << 1
        clip = super().scale(
            clip, mod_x((width + clip.width) / 2, mod), mod_x((height + clip.height) / 2, mod), **kwargs
        )

    return super().scale(clip, width, height, (0, 0), **kwargs)