edge ¶

Classes:

ASobel –

Modified Sobel-Feldman operator from AWarpSharp.
Cross –

"HotDoG" Operator from AVS ExTools by Dogway.
DoG –

Zero-cross (of the 2nd derivative) of a Difference of Gaussians
EdgeDetect –

Abstract edge detection interface.
EuclideanDistance –
ExKirsch –

Extended Russell Kirsch compass operator. 5x5 matrices.
ExLaplacian1 –

Extended Pierre-Simon de Laplace operator, 1st implementation.
ExLaplacian2 –

Extended Pierre-Simon de Laplace operator, 2nd implementation.
ExLaplacian3 –

Extended Pierre-Simon de Laplace operator, 3rd implementation.
ExLaplacian4 –

Extended Pierre-Simon de Laplace operator, 4th implementation.
ExPrewitt –

Extended Judith M. S. Prewitt operator.
ExSobel –

Extended Sobel-Feldman operator.
FDoG –

Flow-based Difference of Gaussian
FDoGTCanny –

Flow-based Difference of Gaussian TCanny Vapoursynth plugin.
Farid –

Farid & Simoncelli operator.
FreyChen –

Chen Frei operator. 3x3 matrices properly implemented.
FreyChenG41 –

"Chen Frei" operator. 3x3 matrices from G41Fun.
Kayyali –

Kayyali operator.
Kirsch –

Russell Kirsch compass operator.
KirschTCanny –

Russell Kirsch compass TCanny Vapoursynth plugin operator.
Kroon –

Dirk-Jan Kroon operator.
KroonTCanny –

Dirk-Jan Kroon TCanny Vapoursynth plugin operator.
Laplacian1 –

Pierre-Simon de Laplace operator 1st implementation.
Laplacian2 –

Pierre-Simon de Laplace operator 2nd implementation.
Laplacian3 –

Pierre-Simon de Laplace operator 3rd implementation.
Laplacian4 –

Pierre-Simon de Laplace operator 4th implementation.
LoG –

Laplacian of Gaussian operator.
MagDirection –

Direction of magnitude calculation.
MagnitudeMatrix –
Matrix1D –
Matrix3x3 –
Matrix5x5 –
MatrixEdgeDetect –
Max –
MinMax –

Min/max mask with separate luma/chroma radii.
Prewitt –

Judith M. S. Prewitt operator.
PrewittStd –

Judith M. S. Prewitt Vapoursynth plugin operator.
PrewittTCanny –

Judith M. S. Prewitt TCanny plugin operator.
RScharr –

Refined H. Scharr operator to more accurately calculate
RidgeDetect –
Robinson3 –

Robinson compass operator level 3.
Robinson5 –

Robinson compass operator level 5.
SavitzkyGolay –
SavitzkyGolayDeriv1Cubic11 –

Savitzky-Golay first cubic/quartic operator of size 11
SavitzkyGolayDeriv1Cubic13 –

Savitzky-Golay first cubic/quartic operator of size 13
SavitzkyGolayDeriv1Cubic15 –

Savitzky-Golay first cubic/quartic operator of size 15
SavitzkyGolayDeriv1Cubic17 –

Savitzky-Golay first cubic/quartic operator of size 17
SavitzkyGolayDeriv1Cubic19 –

Savitzky-Golay first cubic/quartic operator of size 19
SavitzkyGolayDeriv1Cubic21 –

Savitzky-Golay first cubic/quartic operator of size 21
SavitzkyGolayDeriv1Cubic23 –

Savitzky-Golay first cubic/quartic operator of size 23
SavitzkyGolayDeriv1Cubic25 –

Savitzky-Golay first cubic/quartic operator of size 25
SavitzkyGolayDeriv1Cubic5 –

Savitzky-Golay first cubic/quartic operator of size 5
SavitzkyGolayDeriv1Cubic7 –

Savitzky-Golay first cubic/quartic derivative operator of size 7
SavitzkyGolayDeriv1Cubic9 –

Savitzky-Golay first cubic/quartic operator of size 9
SavitzkyGolayDeriv1Quad11 –

Savitzky-Golay first quadratic derivative operator of size 11
SavitzkyGolayDeriv1Quad13 –

Savitzky-Golay first quadratic derivative operator of size 13
SavitzkyGolayDeriv1Quad15 –

Savitzky-Golay first quadratic derivative operator of size 15
SavitzkyGolayDeriv1Quad17 –

Savitzky-Golay first quadratic derivative operator of size 17
SavitzkyGolayDeriv1Quad19 –

Savitzky-Golay first quadratic derivative operator of size 19
SavitzkyGolayDeriv1Quad21 –

Savitzky-Golay first quadratic derivative operator of size 21
SavitzkyGolayDeriv1Quad23 –

Savitzky-Golay first quadratic derivative operator of size 23
SavitzkyGolayDeriv1Quad25 –

Savitzky-Golay first quadratic derivative operator of size 25
SavitzkyGolayDeriv1Quad5 –

Savitzky-Golay first quadratic derivative operator of size 5
SavitzkyGolayDeriv1Quad7 –

Savitzky-Golay first quadratic derivative operator of size 7
SavitzkyGolayDeriv1Quad9 –

Savitzky-Golay first quadratic derivative operator of size 9
SavitzkyGolayDeriv1Quint11 –

Savitzky-Golay first quintic/sextic derivative operator of size 11
SavitzkyGolayDeriv1Quint13 –

Savitzky-Golay first quintic/sextic derivative operator of size 13
SavitzkyGolayDeriv1Quint15 –

Savitzky-Golay first quintic/sextic derivative operator of size 15
SavitzkyGolayDeriv1Quint17 –

Savitzky-Golay first quintic/sextic derivative operator of size 17
SavitzkyGolayDeriv1Quint19 –

Savitzky-Golay first quintic/sextic derivative operator of size 19
SavitzkyGolayDeriv1Quint21 –

Savitzky-Golay first quintic/sextic derivative operator of size 21
SavitzkyGolayDeriv1Quint23 –

Savitzky-Golay first quintic/sextic derivative operator of size 23
SavitzkyGolayDeriv1Quint25 –

Savitzky-Golay first quintic/sextic derivative operator of size 25
SavitzkyGolayDeriv1Quint7 –

Savitzky-Golay first quintic/sextic derivative operator of size 7
SavitzkyGolayDeriv1Quint9 –

Savitzky-Golay first quintic/sextic derivative operator of size 9
SavitzkyGolayDeriv2Quad11 –

Savitzky-Golay second quadratic/cubic derivative operator of size 11
SavitzkyGolayDeriv2Quad13 –

Savitzky-Golay second quadratic/cubic derivative operator of size 13
SavitzkyGolayDeriv2Quad15 –

Savitzky-Golay second quadratic/cubic derivative operator of size 15
SavitzkyGolayDeriv2Quad17 –

Savitzky-Golay second quadratic/cubic derivative operator of size 17
SavitzkyGolayDeriv2Quad19 –

Savitzky-Golay second quadratic/cubic derivative operator of size 19
SavitzkyGolayDeriv2Quad21 –

Savitzky-Golay second quadratic/cubic derivative operator of size 21
SavitzkyGolayDeriv2Quad23 –

Savitzky-Golay second quadratic/cubic derivative operator of size 23
SavitzkyGolayDeriv2Quad25 –

Savitzky-Golay second quadratic/cubic derivative operator of size 25
SavitzkyGolayDeriv2Quad5 –

Savitzky-Golay second quadratic/cubic derivative operator of size 5
SavitzkyGolayDeriv2Quad7 –

Savitzky-Golay second quadratic/cubic derivative operator of size 7
SavitzkyGolayDeriv2Quad9 –

Savitzky-Golay second quadratic/cubic derivative operator of size 9
SavitzkyGolayDeriv2Quart11 –

Savitzky-Golay second quartic/quintic derivative operator of size 11
SavitzkyGolayDeriv2Quart13 –

Savitzky-Golay second quartic/quintic derivative operator of size 13
SavitzkyGolayDeriv2Quart15 –

Savitzky-Golay second quartic/quintic derivative operator of size 15
SavitzkyGolayDeriv2Quart17 –

Savitzky-Golay second quartic/quintic derivative operator of size 17
SavitzkyGolayDeriv2Quart19 –

Savitzky-Golay second quartic/quintic derivative operator of size 19
SavitzkyGolayDeriv2Quart21 –

Savitzky-Golay second quartic/quintic derivative operator of size 21
SavitzkyGolayDeriv2Quart23 –

Savitzky-Golay second quartic/quintic derivative operator of size 23
SavitzkyGolayDeriv2Quart25 –

Savitzky-Golay second quartic/quintic derivativeoperator of size 25
SavitzkyGolayDeriv2Quart7 –

Savitzky-Golay second quartic/quintic derivative operator of size 7
SavitzkyGolayDeriv2Quart9 –

Savitzky-Golay second quartic/quintic derivative operator of size 9
SavitzkyGolayDeriv3Cub11 –

Savitzky-Golay third cubic/quartic derivative operator of size 11
SavitzkyGolayDeriv3Cub13 –

Savitzky-Golay third cubic/quartic derivative operator of size 13
SavitzkyGolayDeriv3Cub15 –

Savitzky-Golay third cubic/quartic derivative operator of size 15
SavitzkyGolayDeriv3Cub17 –

Savitzky-Golay third cubic/quartic derivative operator of size 17
SavitzkyGolayDeriv3Cub19 –

Savitzky-Golay third cubic/quartic derivative operator of size 19
SavitzkyGolayDeriv3Cub21 –

Savitzky-Golay third cubic/quartic derivative operator of size 21
SavitzkyGolayDeriv3Cub23 –

Savitzky-Golay third cubic/quartic derivative operator of size 23
SavitzkyGolayDeriv3Cub25 –

Savitzky-Golay third cubic/quartic derivative operator of size 25
SavitzkyGolayDeriv3Cub5 –

Savitzky-Golay third cubic/quartic derivative operator of size 5
SavitzkyGolayDeriv3Cub7 –

Savitzky-Golay third cubic/quartic derivative operator of size 7
SavitzkyGolayDeriv3Cub9 –

Savitzky-Golay third cubic/quartic derivative operator of size 9
SavitzkyGolayDeriv3Quint11 –

Savitzky-Golay third quintic/sexic derivative operator of size 11
SavitzkyGolayDeriv3Quint13 –

Savitzky-Golay third quintic/sexic derivative operator of size 13
SavitzkyGolayDeriv3Quint15 –

Savitzky-Golay third quintic/sexic derivative operator of size 15
SavitzkyGolayDeriv3Quint17 –

Savitzky-Golay third quintic/sexic derivative operator of size 17
SavitzkyGolayDeriv3Quint19 –

Savitzky-Golay third quintic/sexic derivative operator of size 19
SavitzkyGolayDeriv3Quint21 –

Savitzky-Golay third quintic/sexic derivative operator of size 21
SavitzkyGolayDeriv3Quint23 –

Savitzky-Golay third quintic/sexic derivative operator of size 23
SavitzkyGolayDeriv3Quint25 –

Savitzky-Golay third quintic/sexic derivative operator of size 25
SavitzkyGolayDeriv3Quint7 –

Savitzky-Golay third quintic/sexic derivative operator of size 7
SavitzkyGolayDeriv3Quint9 –

Savitzky-Golay third quintic/sexic derivative operator of size 9
SavitzkyGolayDeriv4Quart11 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 11
SavitzkyGolayDeriv4Quart13 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 13
SavitzkyGolayDeriv4Quart15 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 15
SavitzkyGolayDeriv4Quart17 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 17
SavitzkyGolayDeriv4Quart19 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 19
SavitzkyGolayDeriv4Quart21 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 21
SavitzkyGolayDeriv4Quart23 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 23
SavitzkyGolayDeriv4Quart25 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 25
SavitzkyGolayDeriv4Quart7 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 7
SavitzkyGolayDeriv4Quart9 –

Savitzky-Golay fourth quartic/quintic derivative operator of size 9
SavitzkyGolayDeriv5Quint11 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 11
SavitzkyGolayDeriv5Quint13 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 13
SavitzkyGolayDeriv5Quint15 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 15
SavitzkyGolayDeriv5Quint17 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 17
SavitzkyGolayDeriv5Quint19 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 19
SavitzkyGolayDeriv5Quint21 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 21
SavitzkyGolayDeriv5Quint23 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 23
SavitzkyGolayDeriv5Quint25 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 25
SavitzkyGolayDeriv5Quint7 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 7
SavitzkyGolayDeriv5Quint9 –

Savitzky-Golay fifth quintic/sexic derivative operator of size 9
Scharr –

Original H. Scharr optimised operator which attempts
ScharrTCanny –

H. Scharr optimised TCanny Vapoursynth plugin operator.
SingleMatrix –
Sobel –

Sobel-Feldman operator.
SobelStd –

Sobel-Feldman Vapoursynth plugin operator.
SobelTCanny –

Sobel-Feldman Vapoursynth plugin operator.
TEdge –

(TEdgeMasktype=2) Avisynth plugin.
TEdgeTedgemask –

(tedgemask.TEdgeMask(threshold=0.0, type=2)) Vapoursynth plugin.
TheToof –

TheToof compass operator from SharpAAMCmod.
Tritical –

Operator used in Tritical's original TCanny filter.
TriticalTCanny –

Operator used in Tritical's original TCanny filter.

Functions:

get_all_edge_detects –

Returns all the EdgeDetect subclasses
get_all_ridge_detect –

Returns all the RidgeDetect subclasses

Attributes:

EdgeDetectT (TypeAlias) –
RidgeDetectT (TypeAlias) –

EdgeDetectT `module-attribute` ¶

EdgeDetectT: TypeAlias = type[EdgeDetect] | EdgeDetect | str

RidgeDetectT `module-attribute` ¶

RidgeDetectT: TypeAlias = type[RidgeDetect] | RidgeDetect | str

ASobel ¶

ASobel(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Modified Sobel-Feldman operator from AWarpSharp.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Cross ¶

Cross(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

"HotDoG" Operator from AVS ExTools by Dogway. Plain and simple cross first order derivative.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, 0, 0, 0, 0, 0, 0, 0, -1],
    [0, 0, -1, 0, 0, 0, 1, 0, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

DoG ¶

DoG(**kwargs: Any)

Bases: EuclideanDistance, Matrix5x5

Zero-cross (of the 2nd derivative) of a Difference of Gaussians

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [4, 6]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        0,
        0,
        5,
        0,
        0,
        0,
        5,
        10,
        5,
        0,
        5,
        10,
        20,
        10,
        5,
        0,
        5,
        10,
        5,
        0,
        0,
        0,
        5,
        0,
        0,
    ],
    [0, 25, 0, 25, 50, 25, 0, 25, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

EdgeDetect ¶

EdgeDetect(**kwargs: Any)

Bases: ABC

Abstract edge detection interface.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

EuclideanDistance ¶

EuclideanDistance(**kwargs: Any)

Bases: MatrixEdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExKirsch ¶

ExKirsch(mag_directions: MagDirection = ALL, **kwargs: Any)

Bases: MagnitudeMatrix, Max

Extended Russell Kirsch compass operator. 5x5 matrices.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
mag_directions –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, mag_directions: MagDirection = MagDirection.ALL, **kwargs: Any) -> None:
    super().__init__(**kwargs)

    self.mag_directions = mag_directions

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

mag_directions `instance-attribute` ¶

mag_directions = mag_directions

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        9,
        9,
        9,
        9,
        9,
        9,
        5,
        5,
        5,
        9,
        -7,
        -3,
        0,
        -3,
        -7,
        -7,
        -3,
        -3,
        -3,
        -7,
        -7,
        -7,
        -7,
        -7,
        -7,
    ],
    [
        9,
        9,
        9,
        9,
        -7,
        9,
        5,
        5,
        -3,
        -7,
        9,
        5,
        0,
        -3,
        -7,
        9,
        -3,
        -3,
        -3,
        -7,
        -7,
        -7,
        -7,
        -7,
        -7,
    ],
    [
        9,
        9,
        -7,
        -7,
        -7,
        9,
        5,
        -3,
        -3,
        -7,
        9,
        5,
        0,
        -3,
        -7,
        9,
        5,
        -3,
        -3,
        -7,
        9,
        9,
        -7,
        -7,
        -7,
    ],
    [
        -7,
        -7,
        -7,
        -7,
        -7,
        9,
        -3,
        -3,
        -3,
        -7,
        9,
        5,
        0,
        -3,
        -7,
        9,
        5,
        5,
        -3,
        -7,
        9,
        9,
        9,
        9,
        -7,
    ],
    [
        -7,
        -7,
        -7,
        -7,
        -7,
        -7,
        -3,
        -3,
        -3,
        -7,
        -7,
        -3,
        0,
        -3,
        -7,
        9,
        5,
        5,
        5,
        9,
        9,
        9,
        9,
        9,
        9,
    ],
    [
        -7,
        -7,
        -7,
        -7,
        -7,
        -7,
        -3,
        -3,
        -3,
        9,
        -7,
        -3,
        0,
        5,
        9,
        -7,
        -3,
        5,
        5,
        9,
        -7,
        9,
        9,
        9,
        9,
    ],
    [
        -7,
        -7,
        -7,
        9,
        9,
        -7,
        -3,
        -3,
        5,
        9,
        -7,
        -3,
        0,
        5,
        9,
        -7,
        -3,
        -3,
        5,
        9,
        -7,
        -7,
        -7,
        9,
        9,
    ],
    [
        -7,
        9,
        9,
        9,
        9,
        -7,
        -3,
        5,
        5,
        9,
        -7,
        -3,
        0,
        5,
        9,
        -7,
        -3,
        -3,
        -3,
        9,
        -7,
        -7,
        -7,
        -7,
        -7,
    ],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExLaplacian1 ¶

ExLaplacian1(**kwargs: Any)

Bases: SingleMatrix, Matrix5x5

Extended Pierre-Simon de Laplace operator, 1st implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        0,
        0,
        -1,
        0,
        0,
        0,
        0,
        -1,
        0,
        0,
        -1,
        -1,
        8,
        -1,
        -1,
        0,
        0,
        -1,
        0,
        0,
        0,
        0,
        -1,
        0,
        0,
    ]
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExLaplacian2 ¶

ExLaplacian2(**kwargs: Any)

Bases: SingleMatrix, Matrix5x5

Extended Pierre-Simon de Laplace operator, 2nd implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        0,
        1,
        -1,
        1,
        0,
        1,
        1,
        -4,
        1,
        1,
        -1,
        -4,
        8,
        -4,
        -1,
        1,
        1,
        -4,
        1,
        1,
        0,
        1,
        -1,
        1,
        0,
    ]
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExLaplacian3 ¶

ExLaplacian3(**kwargs: Any)

Bases: SingleMatrix, Matrix5x5

Extended Pierre-Simon de Laplace operator, 3rd implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        -1,
        1,
        -1,
        1,
        -1,
        1,
        2,
        -4,
        2,
        1,
        -1,
        -4,
        8,
        -4,
        -1,
        1,
        2,
        -4,
        2,
        1,
        -1,
        1,
        -1,
        1,
        -1,
    ]
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExLaplacian4 ¶

ExLaplacian4(**kwargs: Any)

Bases: SingleMatrix, Matrix5x5

Extended Pierre-Simon de Laplace operator, 4th implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        24,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
    ]
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

ExPrewitt ¶

ExPrewitt(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix5x5

Extended Judith M. S. Prewitt operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
    ],
    [
        2,
        2,
        2,
        2,
        2,
        1,
        1,
        1,
        1,
        1,
        0,
        0,
        0,
        0,
        0,
        -1,
        -1,
        -1,
        -1,
        -1,
        -2,
        -2,
        -2,
        -2,
        -2,
    ],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

ExSobel ¶

ExSobel(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix5x5

Extended Sobel-Feldman operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
        4,
        2,
        0,
        -2,
        -4,
        2,
        1,
        0,
        -1,
        -2,
        2,
        1,
        0,
        -1,
        -2,
    ],
    [
        2,
        2,
        4,
        2,
        2,
        1,
        1,
        2,
        1,
        1,
        0,
        0,
        0,
        0,
        0,
        -1,
        -1,
        -2,
        -1,
        -1,
        -2,
        -2,
        -4,
        -2,
        -2,
    ],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

FDoG ¶

FDoG(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix5x5

Flow-based Difference of Gaussian

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [2, 2]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        1,
        1,
        0,
        -1,
        -1,
        2,
        2,
        0,
        -2,
        -2,
        3,
        3,
        0,
        -3,
        -3,
        2,
        2,
        0,
        -2,
        -2,
        1,
        1,
        0,
        -1,
        -1,
    ],
    [
        1,
        2,
        3,
        2,
        1,
        1,
        2,
        3,
        2,
        1,
        0,
        0,
        0,
        0,
        0,
        -1,
        -2,
        -3,
        -2,
        -1,
        -1,
        -2,
        -3,
        -2,
        -1,
    ],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

FDoGTCanny ¶

FDoGTCanny(**kwargs: Any)

Bases: Matrix5x5, EdgeDetect

Flow-based Difference of Gaussian TCanny Vapoursynth plugin.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Farid ¶

Farid(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix5x5

Farid & Simoncelli operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        0.004127602875174862,
        0.027308149775363867,
        0.04673225765917656,
        0.027308149775363867,
        0.004127602875174862,
        0.010419993699470744,
        0.06893849946536831,
        0.11797400212587895,
        0.06893849946536831,
        0.010419993699470744,
        0.0,
        0.0,
        0.0,
        0.0,
        0.0,
        -0.010419993699470744,
        -0.06893849946536831,
        -0.11797400212587895,
        -0.06893849946536831,
        -0.010419993699470744,
        -0.004127602875174862,
        -0.027308149775363867,
        -0.04673225765917656,
        -0.027308149775363867,
        -0.004127602875174862,
    ],
    [
        0.004127602875174862,
        0.027308149775363867,
        0.04673225765917656,
        0.027308149775363867,
        0.004127602875174862,
        0.010419993699470744,
        0.06893849946536831,
        0.11797400212587895,
        0.06893849946536831,
        0.010419993699470744,
        0.0,
        0.0,
        0.0,
        0.0,
        0.0,
        -0.010419993699470744,
        -0.06893849946536831,
        -0.11797400212587895,
        -0.06893849946536831,
        -0.010419993699470744,
        -0.004127602875174862,
        -0.027308149775363867,
        -0.04673225765917656,
        -0.027308149775363867,
        -0.004127602875174862,
    ],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

FreyChen ¶

FreyChen(**kwargs: Any)

Bases: MatrixEdgeDetect

Chen Frei operator. 3x3 matrices properly implemented.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –
sqrt2 –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [
    2 * sqrt2,
    2 * sqrt2,
    2 * sqrt2,
    2 * sqrt2,
    2,
    2,
    6,
    6,
    3,
]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, sqrt2, 1, 0, 0, 0, -1, -sqrt2, -1],
    [1, 0, -1, sqrt2, 0, -sqrt2, 1, 0, -1],
    [0, -1, sqrt2, 1, 0, -1, -sqrt2, 1, 0],
    [sqrt2, -1, 0, -1, 0, 1, 0, 1, -sqrt2],
    [0, 1, 0, -1, 0, -1, 0, 1, 0],
    [-1, 0, 1, 0, 0, 0, 1, 0, -1],
    [1, -2, 1, -2, 4, -2, 1, -2, 1],
    [-2, 1, -2, 1, 4, 1, -2, 1, -2],
    [1, 1, 1, 1, 1, 1, 1, 1, 1],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

sqrt2 `class-attribute` `instance-attribute` ¶

sqrt2 = sqrt(2)

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

FreyChenG41 ¶

FreyChenG41(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

"Chen Frei" operator. 3x3 matrices from G41Fun.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [7, 7]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [-7, 0, 7, -10, 0, 10, -7, 0, 7],
    [-7, -10, -7, 0, 0, 0, 7, 10, 7],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

Kayyali ¶

Kayyali(**kwargs: Any)

Bases: SingleMatrix, Matrix3x3

Kayyali operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [[6, 0, -6, 0, 0, 0, -6, 0, 6]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Kirsch ¶

Kirsch(mag_directions: MagDirection = ALL, **kwargs: Any)

Bases: MagnitudeMatrix, Max, Matrix3x3

Russell Kirsch compass operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
mag_directions –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, mag_directions: MagDirection = MagDirection.ALL, **kwargs: Any) -> None:
    super().__init__(**kwargs)

    self.mag_directions = mag_directions

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

mag_directions `instance-attribute` ¶

mag_directions = mag_directions

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [5, 5, 5, -3, 0, -3, -3, -3, -3],
    [5, 5, -3, 5, 0, -3, -3, -3, -3],
    [5, -3, -3, 5, 0, -3, 5, -3, -3],
    [-3, -3, -3, 5, 0, -3, 5, 5, -3],
    [-3, -3, -3, -3, 0, -3, 5, 5, 5],
    [-3, -3, -3, -3, 0, 5, -3, 5, 5],
    [-3, -3, 5, -3, 0, 5, -3, -3, 5],
    [-3, 5, 5, -3, 0, 5, -3, -3, -3],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

KirschTCanny ¶

KirschTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Russell Kirsch compass TCanny Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Kroon ¶

Kroon(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Dirk-Jan Kroon operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [17, 17]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [-17, 0, 17, -61, 0, 61, -17, 0, 17],
    [-17, -61, -17, 0, 0, 0, 17, 61, 17],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

KroonTCanny ¶

KroonTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Dirk-Jan Kroon TCanny Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Laplacian1 ¶

Laplacian1(**kwargs: Any)

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 1st implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [[0, -1, 0, -1, 4, -1, 0, -1, 0]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Laplacian2 ¶

Laplacian2(**kwargs: Any)

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 2nd implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [[1, -2, 1, -2, 4, -2, 1, -2, 1]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Laplacian3 ¶

Laplacian3(**kwargs: Any)

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 3rd implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [[2, -1, 2, -1, -4, -1, 2, -1, 2]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Laplacian4 ¶

Laplacian4(**kwargs: Any)

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 4th implementation.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [[-1, -1, -1, -1, 8, -1, -1, -1, -1]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

LoG ¶

LoG(**kwargs: Any)

Bases: SingleMatrix, Matrix5x5

Laplacian of Gaussian operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [
        0,
        0,
        -1,
        0,
        0,
        0,
        -1,
        -2,
        -1,
        0,
        -1,
        -2,
        16,
        -2,
        -1,
        0,
        -1,
        -2,
        -1,
        0,
        0,
        0,
        -1,
        0,
        0,
    ]
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

MagDirection ¶

Bases: IntFlag

Direction of magnitude calculation.

Methods:

select_matrices –

Attributes:

ALL –
AXIS –
CORNERS –
E –
EAST –
N –
NE –
NORTH –
NW –
S –
SE –
SOUTH –
SW –
W –
WEST –

ALL `class-attribute` `instance-attribute` ¶

ALL = N | NW | W | SW | S | SE | E | NE

AXIS `class-attribute` `instance-attribute` ¶

AXIS = N | W | S | E

CORNERS `class-attribute` `instance-attribute` ¶

CORNERS = NW | SW | SE | NE

E `class-attribute` `instance-attribute` ¶

E = auto()

EAST `class-attribute` `instance-attribute` ¶

EAST = E | NE | SE

N `class-attribute` `instance-attribute` ¶

N = auto()

NE `class-attribute` `instance-attribute` ¶

NE = auto()

NORTH `class-attribute` `instance-attribute` ¶

NORTH = N | NW | NE

NW `class-attribute` `instance-attribute` ¶

NW = auto()

S `class-attribute` `instance-attribute` ¶

S = auto()

SE `class-attribute` `instance-attribute` ¶

SE = auto()

SOUTH `class-attribute` `instance-attribute` ¶

SOUTH = S | SW | SE

SW `class-attribute` `instance-attribute` ¶

SW = auto()

W `class-attribute` `instance-attribute` ¶

W = auto()

WEST `class-attribute` `instance-attribute` ¶

WEST = W | NW | SW

select_matrices ¶

select_matrices(matrices: Sequence[T]) -> Sequence[T]

Source code

def select_matrices(self, matrices: Sequence[T]) -> Sequence[T]:
    # In Python <3.11, composite flags are included in MagDirection's
    # collection and iteration interfaces.
    primary_flags = [flag for flag in MagDirection if flag != 0 and flag & (flag - 1) == 0]
    assert len(matrices) == len(primary_flags) and self

    return [matrix for flag, matrix in zip(primary_flags, matrices) if self & flag]

MagnitudeMatrix ¶

MagnitudeMatrix(mag_directions: MagDirection = ALL, **kwargs: Any)

Bases: MatrixEdgeDetect

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
mag_directions –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, mag_directions: MagDirection = MagDirection.ALL, **kwargs: Any) -> None:
    super().__init__(**kwargs)

    self.mag_directions = mag_directions

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

mag_directions `instance-attribute` ¶

mag_directions = mag_directions

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Matrix1D ¶

Matrix1D(**kwargs: Any)

Bases: EdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Matrix3x3 ¶

Matrix3x3(**kwargs: Any)

Bases: EdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Matrix5x5 ¶

Matrix5x5(**kwargs: Any)

Bases: EdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

MatrixEdgeDetect ¶

MatrixEdgeDetect(**kwargs: Any)

Bases: EdgeDetect

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Max ¶

Max(**kwargs: Any)

Bases: MatrixEdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

MinMax ¶

MinMax(rady: int = 2, radc: int = 0, **kwargs: Any)

Bases: EdgeDetect

Min/max mask with separate luma/chroma radii.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –
radc (int) –
rady (int) –

Source code

def __init__(self, rady: int = 2, radc: int = 0, **kwargs: Any) -> None:
    self.rady = rady
    self.radc = radc
    super().__init__(**kwargs)

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

radc `instance-attribute` ¶

radc: int = radc

rady `instance-attribute` ¶

rady: int = rady

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Prewitt ¶

Prewitt(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Judith M. S. Prewitt operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, 0, -1, 1, 0, -1, 1, 0, -1],
    [1, 1, 1, 0, 0, 0, -1, -1, -1],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

PrewittStd ¶

PrewittStd(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Judith M. S. Prewitt Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

PrewittTCanny ¶

PrewittTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Judith M. S. Prewitt TCanny plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

RScharr ¶

RScharr(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Refined H. Scharr operator to more accurately calculate 1st derivatives for a 3x3 kernel with coeffs 47 and 162.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [47, 47]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [-47, 0, 47, -162, 0, 162, -47, 0, 47],
    [-47, -162, -47, 0, 0, 0, 47, 162, 47],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

RidgeDetect ¶

RidgeDetect(**kwargs: Any)

Bases: MatrixEdgeDetect

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

Robinson3 ¶

Robinson3(**kwargs: Any)

Bases: Max, Matrix3x3

Robinson compass operator level 3.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, 1, 1, 0, 0, 0, -1, -1, -1],
    [1, 1, 0, 1, 0, -1, 0, -1, -1],
    [1, 0, -1, 1, 0, -1, 1, 0, -1],
    [0, -1, -1, 1, 0, -1, 1, 1, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Robinson5 ¶

Robinson5(**kwargs: Any)

Bases: Max, Matrix3x3

Robinson compass operator level 5.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, 2, 1, 0, 0, 0, -1, -2, -1],
    [2, 1, 0, 1, 0, -1, 0, -1, -2],
    [1, 0, -1, 2, 0, -2, 1, 0, -1],
    [0, -1, -2, 1, 0, -1, 2, 1, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolay ¶

SavitzkyGolay(**kwargs: Any)

Bases: EuclideanDistance, Matrix1D

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic11 ¶

SavitzkyGolayDeriv1Cubic11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [5148] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[300, -294, -532, -503, -296, 0, 296, 503, 532, 294, -300]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic13 ¶

SavitzkyGolayDeriv1Cubic13(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [24024] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1133,
        -660,
        -1578,
        -1796,
        -1489,
        -832,
        0,
        832,
        1489,
        1796,
        1578,
        660,
        -1133,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic15 ¶

SavitzkyGolayDeriv1Cubic15(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [334152] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        12922,
        -4121,
        -14150,
        -18334,
        -17842,
        -13843,
        -7506,
        0,
        7506,
        13843,
        17842,
        18334,
        14150,
        4121,
        -12922,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic17 ¶

SavitzkyGolayDeriv1Cubic17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [23256] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        748,
        -98,
        -643,
        -930,
        -1002,
        -902,
        -673,
        -358,
        0,
        358,
        673,
        902,
        1002,
        930,
        643,
        98,
        -748,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic19 ¶

SavitzkyGolayDeriv1Cubic19(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [255816] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        6936,
        68,
        -4648,
        -7481,
        -8700,
        -8574,
        -7372,
        -5363,
        -2816,
        0,
        2816,
        5363,
        7372,
        8574,
        8700,
        7481,
        4648,
        -68,
        -6936,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic21 ¶

SavitzkyGolayDeriv1Cubic21(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [3634092] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        84075,
        10032,
        -43284,
        -78176,
        -96947,
        -101900,
        -95338,
        -79564,
        -56881,
        -29592,
        0,
        29592,
        56881,
        79564,
        95338,
        101900,
        96947,
        78176,
        43284,
        -10032,
        -84075,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic23 ¶

SavitzkyGolayDeriv1Cubic23(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [197340] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        3938,
        815,
        -1518,
        -3140,
        -4130,
        -4567,
        -4530,
        -4098,
        -3350,
        -2365,
        -1222,
        0,
        1222,
        2365,
        3350,
        4098,
        4530,
        4567,
        4130,
        3140,
        1518,
        -815,
        -3938,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic25 ¶

SavitzkyGolayDeriv1Cubic25(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1776060] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        30866,
        8602,
        -8525,
        -20982,
        -29236,
        -33754,
        -35003,
        -33450,
        -29562,
        -23806,
        -16649,
        -8558,
        0,
        8558,
        16649,
        23806,
        29562,
        33450,
        35003,
        33754,
        29236,
        20982,
        8525,
        -8602,
        -30866,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic5 ¶

SavitzkyGolayDeriv1Cubic5(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 5

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [12] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[1, -8, 0, 8, -1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic7 ¶

SavitzkyGolayDeriv1Cubic7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [252] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[22, -67, -58, 0, 58, 67, -22]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Cubic9 ¶

SavitzkyGolayDeriv1Cubic9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1188] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[86, -142, -193, -126, 0, 126, 193, 142, -86]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad11 ¶

SavitzkyGolayDeriv1Quad11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [110] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad13 ¶

SavitzkyGolayDeriv1Quad13(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [182] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad15 ¶

SavitzkyGolayDeriv1Quad15(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [280] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad17 ¶

SavitzkyGolayDeriv1Quad17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [408] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad19 ¶

SavitzkyGolayDeriv1Quad19(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [570] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad21 ¶

SavitzkyGolayDeriv1Quad21(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [770] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad23 ¶

SavitzkyGolayDeriv1Quad23(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1012] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -11,
        -10,
        -9,
        -8,
        -7,
        -6,
        -5,
        -4,
        -3,
        -2,
        -1,
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        10,
        11,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad25 ¶

SavitzkyGolayDeriv1Quad25(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1300] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -12,
        -11,
        -10,
        -9,
        -8,
        -7,
        -6,
        -5,
        -4,
        -3,
        -2,
        -1,
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9,
        10,
        11,
        12,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad5 ¶

SavitzkyGolayDeriv1Quad5(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 5

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [10] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-2, -1, 0, 1, 2]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad7 ¶

SavitzkyGolayDeriv1Quad7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [28] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-3, -2, -1, 0, 1, 2, 3]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quad9 ¶

SavitzkyGolayDeriv1Quad9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [60] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-4, -3, -2, -1, 0, 1, 2, 3, 4]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint11 ¶

SavitzkyGolayDeriv1Quint11(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [17160] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [-573, 2166, -1249, -3774, -3084, 0, 3084, 3774, 1249, -2166, 573]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint13 ¶

SavitzkyGolayDeriv1Quint13(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [291720] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -9647,
        27093,
        -12,
        -33511,
        -45741,
        -31380,
        0,
        31380,
        45741,
        33511,
        12,
        -27093,
        9647,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint15 ¶

SavitzkyGolayDeriv1Quint15(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [2519400] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -78351,
        169819,
        65229,
        -130506,
        -266401,
        -279975,
        -175125,
        0,
        175125,
        279975,
        266401,
        130506,
        -65229,
        -169819,
        78351,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint17 ¶

SavitzkyGolayDeriv1Quint17(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [503880] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -14404,
        24661,
        16679,
        -8671,
        -32306,
        -43973,
        -40483,
        -23945,
        0,
        23945,
        40483,
        43973,
        32306,
        8671,
        -16679,
        -24661,
        14404,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint19 ¶

SavitzkyGolayDeriv1Quint19(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [9806280] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -255102,
        349928,
        322378,
        9473,
        -348823,
        -604484,
        -686099,
        -583549,
        -332684,
        0,
        332684,
        583549,
        686099,
        604484,
        348823,
        -9473,
        -322378,
        -349928,
        255102,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint21 ¶

SavitzkyGolayDeriv1Quint21(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [637408200] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -15033066,
        16649358,
        19052988,
        6402438,
        -10949942,
        -26040033,
        -34807914,
        -35613829,
        -28754154,
        -15977364,
        0,
        15977364,
        28754154,
        35613829,
        34807914,
        26040033,
        10949942,
        -6402438,
        -19052988,
        -16649358,
        15033066,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint23 ¶

SavitzkyGolayDeriv1Quint23(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [18747300] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -400653,
        359157,
        489687,
        265164,
        -106911,
        -478349,
        -752859,
        -878634,
        -840937,
        -654687,
        -357045,
        0,
        357045,
        654687,
        840937,
        878634,
        752859,
        478349,
        106911,
        -265164,
        -489687,
        -359157,
        400653,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint25 ¶

SavitzkyGolayDeriv1Quint25(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [429214500] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -8322182,
        6024183,
        9604353,
        6671883,
        544668,
        -6301491,
        -12139321,
        -15896511,
        -17062146,
        -15593141,
        -11820675,
        -6356625,
        0,
        6356625,
        11820675,
        15593141,
        17062146,
        15896511,
        12139321,
        6301491,
        -544668,
        -6671883,
        -9604353,
        -6024183,
        8322182,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint7 ¶

SavitzkyGolayDeriv1Quint7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay first quintic/sextic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [60] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-1, 9, -45, 0, 45, -9, 1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv1Quint9 ¶

SavitzkyGolayDeriv1Quint9(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay first quintic/sextic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [8580] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-254, 1381, -2269, -2879, 0, 2879, 2269, -1381, 254]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad11 ¶

SavitzkyGolayDeriv2Quad11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [429] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[15, 6, -1, -6, -9, -10, -9, -6, -1, 6, 15]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad13 ¶

SavitzkyGolayDeriv2Quad13(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1001] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[22, 11, 2, -5, -10, -13, -14, -13, -10, -5, 2, 11, 22]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad15 ¶

SavitzkyGolayDeriv2Quad15(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [6188] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [91, 52, 19, -8, -29, -44, -53, -56, -53, -44, -29, -8, 19, 52, 91]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad17 ¶

SavitzkyGolayDeriv2Quad17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [3876] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [40, 25, 12, 1, -8, -15, -20, -23, -24, -23, -20, -15, -8, 1, 12, 25, 40]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad19 ¶

SavitzkyGolayDeriv2Quad19(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [6783] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        51,
        34,
        19,
        6,
        -5,
        -14,
        -21,
        -26,
        -29,
        -30,
        -29,
        -26,
        -21,
        -14,
        -5,
        6,
        19,
        34,
        51,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad21 ¶

SavitzkyGolayDeriv2Quad21(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [33649] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        190,
        133,
        82,
        37,
        -2,
        -35,
        -62,
        -83,
        -98,
        -107,
        -110,
        -107,
        -98,
        -83,
        -62,
        -35,
        -2,
        37,
        82,
        133,
        190,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad23 ¶

SavitzkyGolayDeriv2Quad23(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [17710] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        77,
        56,
        37,
        20,
        5,
        -8,
        -19,
        -28,
        -35,
        -40,
        -43,
        -44,
        -43,
        -40,
        -35,
        -28,
        -19,
        -8,
        5,
        20,
        37,
        56,
        77,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad25 ¶

SavitzkyGolayDeriv2Quad25(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [26910] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        92,
        69,
        48,
        29,
        12,
        -3,
        -16,
        -27,
        -36,
        -43,
        -48,
        -51,
        -52,
        -51,
        -48,
        -43,
        -36,
        -27,
        -16,
        -3,
        12,
        29,
        48,
        69,
        92,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad5 ¶

SavitzkyGolayDeriv2Quad5(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 5

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [7] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[2, -1, -2, -1, 2]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad7 ¶

SavitzkyGolayDeriv2Quad7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [42] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[5, 0, -3, -4, -3, 0, 5]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quad9 ¶

SavitzkyGolayDeriv2Quad9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quadratic/cubic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [462] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[28, 7, -8, -17, -20, -17, -8, 7, 28]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart11 ¶

SavitzkyGolayDeriv2Quart11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quartic/quintic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1716] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-90, 174, 146, 1, -136, -190, -136, 1, 146, 174, -90]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart13 ¶

SavitzkyGolayDeriv2Quart13(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [58344] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -2211,
        2970,
        3504,
        1614,
        -971,
        -3016,
        -3780,
        -3016,
        -971,
        1614,
        3504,
        2970,
        -2211,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart15 ¶

SavitzkyGolayDeriv2Quart15(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1108536] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -31031,
        29601,
        44495,
        31856,
        6579,
        -19751,
        -38859,
        -45780,
        -38859,
        -19751,
        6579,
        31856,
        44495,
        29601,
        -31031,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart17 ¶

SavitzkyGolayDeriv2Quart17(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [100776] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -2132,
        1443,
        2691,
        2405,
        1256,
        -207,
        -1557,
        -2489,
        -2820,
        -2489,
        -1557,
        -207,
        1256,
        2405,
        2691,
        1443,
        -2132,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart19 ¶

SavitzkyGolayDeriv2Quart19(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1961256] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -32028,
        15028,
        35148,
        36357,
        25610,
        8792,
        -9282,
        -24867,
        -35288,
        -38940,
        -35288,
        -24867,
        -9282,
        8792,
        25610,
        36357,
        35148,
        15028,
        -32028,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart21 ¶

SavitzkyGolayDeriv2Quart21(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [980628] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -12597,
        3876,
        11934,
        13804,
        11451,
        6578,
        626,
        -5226,
        -10061,
        -13224,
        -14322,
        -13224,
        -10061,
        -5226,
        626,
        6578,
        11451,
        13804,
        11934,
        3876,
        -12597,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart23 ¶

SavitzkyGolayDeriv2Quart23(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [11248380] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -115577,
        20615,
        93993,
        119510,
        110545,
        78903,
        34815,
        -13062,
        -57645,
        -93425,
        -116467,
        -124410,
        -116467,
        -93425,
        -57645,
        -13062,
        34815,
        78903,
        110545,
        119510,
        93993,
        20615,
        -115577,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart25 ¶

SavitzkyGolayDeriv2Quart25(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivativeoperator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [17168580] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -143198,
        10373,
        99385,
        137803,
        138262,
        112067,
        69193,
        18285,
        -33342,
        -79703,
        -116143,
        -139337,
        -147290,
        -139337,
        -116143,
        -79703,
        -33342,
        18285,
        69193,
        112067,
        138262,
        137803,
        99385,
        10373,
        -143198,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart7 ¶

SavitzkyGolayDeriv2Quart7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quartic/quintic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [132] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-13, 67, -19, -70, -19, 67, -13]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv2Quart9 ¶

SavitzkyGolayDeriv2Quart9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay second quartic/quintic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1716] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-126, 371, 151, -211, -370, -211, 151, 371, -126]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub11 ¶

SavitzkyGolayDeriv3Cub11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [858] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-30, 6, 22, 23, 14, 0, -14, -23, -22, -6, 30]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub13 ¶

SavitzkyGolayDeriv3Cub13(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [572] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-11, 0, 6, 8, 7, 4, 0, -4, -7, -8, -6, 0, 11]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub15 ¶

SavitzkyGolayDeriv3Cub15(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [7956] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [-91, -13, 35, 58, 61, 49, 27, 0, -27, -49, -61, -58, -35, 13, 91]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub17 ¶

SavitzkyGolayDeriv3Cub17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [3876] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [-28, -7, 7, 15, 18, 17, 13, 7, 0, -7, -13, -17, -18, -15, -7, 7, 28]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub19 ¶

SavitzkyGolayDeriv3Cub19(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [42636] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -204,
        -68,
        28,
        89,
        120,
        126,
        112,
        83,
        44,
        0,
        -44,
        -83,
        -112,
        -126,
        -120,
        -89,
        -28,
        68,
        204,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub21 ¶

SavitzkyGolayDeriv3Cub21(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [86526] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -285,
        -114,
        12,
        98,
        149,
        170,
        166,
        142,
        103,
        54,
        0,
        -54,
        -103,
        -142,
        -166,
        -170,
        -149,
        -98,
        -12,
        114,
        285,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub23 ¶

SavitzkyGolayDeriv3Cub23(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [32890] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -77,
        -35,
        -3,
        20,
        35,
        43,
        45,
        42,
        35,
        25,
        13,
        0,
        -13,
        -25,
        -35,
        -42,
        -45,
        -43,
        -35,
        -20,
        3,
        35,
        77,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub25 ¶

SavitzkyGolayDeriv3Cub25(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [296010] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -506,
        -253,
        -55,
        93,
        196,
        259,
        287,
        285,
        258,
        211,
        149,
        77,
        0,
        -77,
        -149,
        -211,
        -258,
        -285,
        -287,
        -259,
        -196,
        -93,
        55,
        253,
        506,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub5 ¶

SavitzkyGolayDeriv3Cub5(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 5

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [2] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-1, 2, 0, -2, 1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub7 ¶

SavitzkyGolayDeriv3Cub7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [6] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-1, 1, 1, 0, -1, -1, 1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Cub9 ¶

SavitzkyGolayDeriv3Cub9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third cubic/quartic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [198] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-14, 7, 13, 9, 0, -9, -13, -7, 14]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint11 ¶

SavitzkyGolayDeriv3Quint11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third quintic/sexic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [2288] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[129, -402, -11, 340, 316, 0, -316, -340, 11, 402, -129]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint13 ¶

SavitzkyGolayDeriv3Quint13(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [38896] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1430,
        -3267,
        -1374,
        1633,
        3050,
        2252,
        0,
        -2252,
        -3050,
        -1633,
        1374,
        3267,
        -1430,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint15 ¶

SavitzkyGolayDeriv3Quint15(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [335920] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        8281,
        -14404,
        -10379,
        1916,
        11671,
        14180,
        9315,
        0,
        -9315,
        -14180,
        -11671,
        -1916,
        10379,
        14404,
        -8281,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint17 ¶

SavitzkyGolayDeriv3Quint17(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [67184] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1144,
        -1547,
        -1508,
        -351,
        876,
        1595,
        1604,
        983,
        0,
        -983,
        -1604,
        -1595,
        -876,
        351,
        1508,
        1547,
        -1144,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint19 ¶

SavitzkyGolayDeriv3Quint19(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1307504] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        15810,
        -16796,
        -20342,
        -9818,
        4329,
        15546,
        20525,
        18554,
        10868,
        0,
        -10868,
        -18554,
        -20525,
        -15546,
        -4329,
        9818,
        20342,
        16796,
        -15810,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint21 ¶

SavitzkyGolayDeriv3Quint21(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [84987760] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        748068,
        -625974,
        -908004,
        -598094,
        -62644,
        448909,
        787382,
        887137,
        749372,
        425412,
        0,
        -425412,
        -749372,
        -887137,
        -787382,
        -448909,
        62644,
        598094,
        908004,
        625974,
        -748068,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint23 ¶

SavitzkyGolayDeriv3Quint23(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [7498920] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        49115,
        -32224,
        -55233,
        -43928,
        -16583,
        13632,
        38013,
        51684,
        52959,
        42704,
        23699,
        0,
        -23699,
        -42704,
        -52959,
        -51684,
        -38013,
        -13632,
        16583,
        43928,
        55233,
        32224,
        -49115,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint25 ¶

SavitzkyGolayDeriv3Quint25(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay third quintic/sexic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [57228600] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        284372,
        -144463,
        -293128,
        -266403,
        -146408,
        5131,
        144616,
        244311,
        290076,
        279101,
        217640,
        118745,
        0,
        -118745,
        -217640,
        -279101,
        -290076,
        -244311,
        -144616,
        -5131,
        146408,
        266403,
        293128,
        144463,
        -284372,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint7 ¶

SavitzkyGolayDeriv3Quint7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third quintic/sexic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [8] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[1, -8, 13, 0, -13, 8, -1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv3Quint9 ¶

SavitzkyGolayDeriv3Quint9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay third quintic/sexic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1144] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[100, -457, 256, 459, 0, -459, -256, 457, -100]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart11 ¶

SavitzkyGolayDeriv4Quart11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [143] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[6, -6, -6, -1, 4, 6, 4, -1, -6, -6, 6]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart13 ¶

SavitzkyGolayDeriv4Quart13(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [4862] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[99, -66, -96, -54, 11, 64, 84, 64, 11, -54, -96, -66, 99]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart15 ¶

SavitzkyGolayDeriv4Quart15(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [92378] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1001,
        -429,
        -869,
        -704,
        -249,
        251,
        621,
        756,
        621,
        251,
        -249,
        -704,
        -869,
        -429,
        1001,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart17 ¶

SavitzkyGolayDeriv4Quart17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [8398] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [52, -13, -39, -39, -24, -3, 17, 31, 36, 31, 17, -3, -24, -39, -39, -13, 52]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart19 ¶

SavitzkyGolayDeriv4Quart19(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [163438] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        612,
        -68,
        -388,
        -453,
        -354,
        -168,
        42,
        227,
        352,
        396,
        352,
        227,
        42,
        -168,
        -354,
        -453,
        -388,
        -68,
        612,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart21 ¶

SavitzkyGolayDeriv4Quart21(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [408595] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        969,
        0,
        -510,
        -680,
        -615,
        -406,
        -130,
        150,
        385,
        540,
        594,
        540,
        385,
        150,
        -130,
        -406,
        -615,
        -680,
        -510,
        0,
        969,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart23 ¶

SavitzkyGolayDeriv4Quart23(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay fourth quartic/quintic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [937365] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1463,
        133,
        -627,
        -950,
        -955,
        -747,
        -417,
        -42,
        315,
        605,
        793,
        858,
        793,
        605,
        315,
        -42,
        -417,
        -747,
        -955,
        -950,
        -627,
        133,
        1463,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart25 ¶

SavitzkyGolayDeriv4Quart25(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay fourth quartic/quintic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1430715] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        1518,
        253,
        -517,
        -897,
        -982,
        -857,
        -597,
        -267,
        78,
        393,
        643,
        803,
        858,
        803,
        643,
        393,
        78,
        -267,
        -597,
        -857,
        -982,
        -897,
        -517,
        253,
        1518,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart7 ¶

SavitzkyGolayDeriv4Quart7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [11] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[3, -7, 1, 6, 1, -7, 3]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv4Quart9 ¶

SavitzkyGolayDeriv4Quart9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fourth quartic/quintic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [143] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[14, -21, -11, 9, 18, 9, -11, -21, 14]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint11 ¶

SavitzkyGolayDeriv5Quint11(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 11

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [52] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-3, 6, 1, -4, -4, 0, 4, 4, -1, -6, 3]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint13 ¶

SavitzkyGolayDeriv5Quint13(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 13

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [884] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-22, 33, 18, -11, -26, -20, 0, 20, 26, 11, -18, -33, 22]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint15 ¶

SavitzkyGolayDeriv5Quint15(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay fifth quintic/sexic derivative operator of size 15

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [83980] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -1001,
        1144,
        979,
        44,
        -751,
        -1000,
        -675,
        0,
        675,
        1000,
        751,
        -44,
        -979,
        -1144,
        1001,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint17 ¶

SavitzkyGolayDeriv5Quint17(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 17

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [16796] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -104,
        91,
        104,
        39,
        -36,
        -83,
        -88,
        -55,
        0,
        55,
        88,
        83,
        36,
        -39,
        -104,
        -91,
        104,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint19 ¶

SavitzkyGolayDeriv5Quint19(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 19

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [29716] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -102,
        68,
        98,
        58,
        -3,
        -54,
        -79,
        -74,
        -44,
        0,
        44,
        74,
        79,
        54,
        3,
        -58,
        -98,
        -68,
        102,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint21 ¶

SavitzkyGolayDeriv5Quint21(**kwargs: Any)

Bases: SavitzkyGolayNormalise

Savitzky-Golay fifth quintic/sexic derivative operator of size 21

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1931540] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -3876,
        1938,
        3468,
        2618,
        788,
        -1063,
        -2354,
        -2819,
        -2444,
        -1404,
        0,
        1404,
        2444,
        2819,
        2354,
        1063,
        -788,
        -2618,
        -3468,
        -1938,
        3876,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint23 ¶

SavitzkyGolayDeriv5Quint23(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 23

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [170430] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -209,
        76,
        171,
        152,
        77,
        -12,
        -87,
        -132,
        -141,
        -116,
        -65,
        0,
        65,
        116,
        141,
        132,
        87,
        12,
        -77,
        -152,
        -171,
        -76,
        209,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint25 ¶

SavitzkyGolayDeriv5Quint25(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 25

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [1300650] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [
    [
        -1012,
        253,
        748,
        753,
        488,
        119,
        -236,
        -501,
        -636,
        -631,
        -500,
        -275,
        0,
        275,
        500,
        631,
        636,
        501,
        236,
        -119,
        -488,
        -753,
        -748,
        -253,
        1012,
    ]
] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint7 ¶

SavitzkyGolayDeriv5Quint7(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 7

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [2] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-1, 4, -5, 0, 5, -4, 1]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SavitzkyGolayDeriv5Quint9 ¶

SavitzkyGolayDeriv5Quint9(**kwargs: Any)

Bases: SavitzkyGolay

Savitzky-Golay fifth quintic/sexic derivative operator of size 9

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors –
kwargs (KwargsT | None) –
matrices –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` `instance-attribute` ¶

divisors = [26] * 2

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` `instance-attribute` ¶

matrices = [[-4, 11, -4, -9, 0, 9, 4, -11, 4]] * 2

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Scharr ¶

Scharr(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Original H. Scharr optimised operator which attempts to achieve the perfect rotational symmetry with coefficients 3 and 10.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [3, 3]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [-3, 0, 3, -10, 0, 10, -3, 0, 3],
    [-3, -10, -3, 0, 0, 0, 3, 10, 3],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

ScharrTCanny ¶

ScharrTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

H. Scharr optimised TCanny Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SingleMatrix ¶

SingleMatrix(**kwargs: Any)

Bases: MatrixEdgeDetect, ABC

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Sobel ¶

Sobel(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Sobel-Feldman operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [1, 0, -1, 2, 0, -2, 1, 0, -1],
    [1, 2, 1, 0, 0, 0, -1, -2, -1],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

SobelStd ¶

SobelStd(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Sobel-Feldman Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

SobelTCanny ¶

SobelTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Sobel-Feldman Vapoursynth plugin operator.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

TEdge ¶

TEdge(**kwargs: Any)

Bases: EuclideanDistance, Matrix1D

(TEdgeMasktype=2) Avisynth plugin.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [62, 62]

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [12, -74, 0, 74, -12],
    [-12, 74, 0, -74, 12],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = ['h', 'v']

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

TEdgeTedgemask ¶

TEdgeTedgemask(**kwargs: Any)

Bases: Matrix1D, EdgeDetect

(tedgemask.TEdgeMask(threshold=0.0, type=2)) Vapoursynth plugin.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

TheToof ¶

TheToof(**kwargs: Any)

Bases: Max, Matrix3x3

TheToof compass operator from SharpAAMCmod.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = [4] * 4

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [5, 10, 5, 0, 0, 0, -5, -10, -5],
    [10, 5, 0, 5, 0, -5, 0, -5, -10],
    [5, 0, -5, 10, 0, -10, 5, 0, -5],
    [0, -5, -10, 5, 0, -5, 10, 5, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

Tritical ¶

Tritical(**kwargs: Any)

Bases: RidgeDetect, EuclideanDistance, Matrix3x3

Operator used in Tritical's original TCanny filter. Plain and simple orthogonal first order derivative.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –
ridgemask –

Makes ridge mask based on convolution kernel.

Attributes:

divisors (Sequence[float] | None) –
kwargs (KwargsT | None) –
matrices (Sequence[Sequence[float]]) –
mode_types (Sequence[str] | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

divisors `class-attribute` ¶

divisors: Sequence[float] | None = None

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

matrices `class-attribute` ¶

matrices: Sequence[Sequence[float]] = [
    [0, 0, 0, -1, 0, 1, 0, 0, 0],
    [0, 1, 0, 0, 0, 0, 0, -1, 0],
]

mode_types `class-attribute` ¶

mode_types: Sequence[str] | None = None

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownRidgeDetectError, [], func_except)

ridgemask ¶

ridgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> VideoNode

Makes ridge mask based on convolution kernel.

The resulting mask can be thresholded with lthr, hthr and multiplied with multi. Using a 32-bit float clip is recommended.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

VideoNode –

Mask clip

Source code

@inject_self
def ridgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> vs.VideoNode:
    """
    Makes ridge mask based on convolution kernel.

    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.
    Using a 32-bit float clip is recommended.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.RIDGE, planes, **kwargs)

TriticalTCanny ¶

TriticalTCanny(**kwargs: Any)

Bases: Matrix3x3, EdgeDetect

Operator used in Tritical's original TCanny filter. Plain and simple orthogonal first order derivative.

Methods:

edgemask –

Makes edge mask based on convolution kernel.
ensure_obj –
from_param –

Attributes:

kwargs (KwargsT | None) –

Source code

def __init__(self, **kwargs: Any) -> None:
    super().__init__()

    self.kwargs = kwargs

kwargs `class-attribute` `instance-attribute` ¶

kwargs: KwargsT | None = kwargs

edgemask ¶

edgemask(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any
) -> ConstantFormatVideoNode

Makes edge mask based on convolution kernel. The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

Low threshold. Anything below lthr will be set to 0
hthr ¶
(float | None, default: None ) –

High threshold. Anything above hthr will be set to the range max
multi ¶
(float, default: 1.0 ) –

Multiply all pixels by this before thresholding
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

ConstantFormatVideoNode –

Mask clip

Source code

@inject_self
@inject_kwargs_params
def edgemask(
    self,
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
    planes: PlanesT | tuple[PlanesT, bool] = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Makes edge mask based on convolution kernel.
    The resulting mask can be thresholded with lthr, hthr and multiplied with multi.

    Args:
        clip: Source clip
        lthr: Low threshold. Anything below lthr will be set to 0
        hthr: High threshold. Anything above hthr will be set to the range max
        multi: Multiply all pixels by this before thresholding
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        Mask clip
    """
    return self._mask(clip, lthr, hthr, multi, clamp, _Feature.EDGE, planes, **kwargs)

ensure_obj `classmethod` ¶

ensure_obj(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self

Source code

@classmethod
def ensure_obj(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    return _base_ensure_obj(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

from_param `classmethod` ¶

from_param(
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]

Source code

@classmethod
def from_param(
    cls,
    edge_detect: type[Self] | Self | str | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    return _base_from_param(cls, edge_detect, UnknownEdgeDetectError, [], func_except)

get_all_edge_detects ¶

get_all_edge_detects(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
) -> list[ConstantFormatVideoNode]

Returns all the EdgeDetect subclasses

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

See EdgeDetect.get_mask
hthr ¶
(float | None, default: None ) –

See EdgeDetect.get_mask
multi ¶
(float, default: 1.0 ) –

See EdgeDetect.get_mask
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

list[ConstantFormatVideoNode] –

A list edge masks

Source code

def get_all_edge_detects(
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
) -> list[ConstantFormatVideoNode]:
    """
    Returns all the EdgeDetect subclasses

    Args:
        clip: Source clip
        lthr: See [EdgeDetect.get_mask][vsmasktools.edge.EdgeDetect.edgemask]
        hthr: See [EdgeDetect.get_mask][vsmasktools.edge.EdgeDetect.edgemask]
        multi: See [EdgeDetect.get_mask][vsmasktools.edge.EdgeDetect.edgemask]
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        A list edge masks
    """

    def _all_subclasses(cls: type[EdgeDetect] = EdgeDetect) -> set[type[EdgeDetect]]:
        return set(cls.__subclasses__()).union(s for c in cls.__subclasses__() for s in _all_subclasses(c))

    all_subclasses = {
        s
        for s in _all_subclasses()
        if s.__name__
        not in {
            "MatrixEdgeDetect",
            "RidgeDetect",
            "SingleMatrix",
            "EuclideanDistance",
            "MagnitudeMatrix",
            "Max",
            "Matrix1D",
            "SavitzkyGolay",
            "SavitzkyGolayNormalise",
            "Matrix3x3",
            "Matrix5x5",
        }
    }
    return [
        edge_detect().edgemask(clip, lthr, hthr, multi, clamp).text.Text(edge_detect.__name__)
        for edge_detect in sorted(all_subclasses, key=lambda x: x.__name__)
    ]

get_all_ridge_detect ¶

get_all_ridge_detect(
    clip: VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
) -> list[ConstantFormatVideoNode]

Returns all the RidgeDetect subclasses

Parameters:

clip ¶
(VideoNode) –

Source clip
lthr ¶
(float, default: 0.0 ) –

See RidgeDetect.get_mask
hthr ¶
(float | None, default: None ) –

See RidgeDetect.get_mask
multi ¶
(float, default: 1.0 ) –

See RidgeDetect.get_mask
clamp ¶
(bool | tuple[float, float] | list[tuple[float, float]], default: False ) –

Clamp to TV or full range if True or specified range (low, high)

Returns:

list[ConstantFormatVideoNode] –

A list edge masks

Source code

def get_all_ridge_detect(
    clip: vs.VideoNode,
    lthr: float = 0.0,
    hthr: float | None = None,
    multi: float = 1.0,
    clamp: bool | tuple[float, float] | list[tuple[float, float]] = False,
) -> list[ConstantFormatVideoNode]:
    """
    Returns all the RidgeDetect subclasses

    Args:
        clip: Source clip
        lthr: See [RidgeDetect.get_mask][vsmasktools.edge.RidgeDetect.ridgemask]
        hthr: See [RidgeDetect.get_mask][vsmasktools.edge.RidgeDetect.ridgemask]
        multi: See [RidgeDetect.get_mask][vsmasktools.edge.RidgeDetect.ridgemask]
        clamp: Clamp to TV or full range if True or specified range `(low, high)`

    Returns:
        A list edge masks
    """

    def _all_subclasses(cls: type[RidgeDetect] = RidgeDetect) -> set[type[RidgeDetect]]:
        return set(cls.__subclasses__()).union(s for c in cls.__subclasses__() for s in _all_subclasses(c))

    all_subclasses = {
        s
        for s in _all_subclasses()
        if s.__name__
        not in {
            "MatrixEdgeDetect",
            "RidgeDetect",
            "SingleMatrix",
            "EuclideanDistance",
            "MagnitudeMatrix",
            "Max",
            "Matrix1D",
            "SavitzkyGolay",
            "SavitzkyGolayNormalise",
            "Matrix3x3",
            "Matrix5x5",
        }
    }
    return [
        edge_detect().ridgemask(clip, lthr, hthr, multi, clamp).text.Text(edge_detect.__name__)
        for edge_detect in sorted(all_subclasses, key=lambda x: x.__name__)
    ]

edge ¶

EdgeDetectT module-attribute ¶

RidgeDetectT module-attribute ¶

ASobel ¶

kwargs class-attribute instance-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

ensure_obj classmethod ¶

from_param classmethod ¶

Cross ¶

divisors class-attribute ¶

kwargs class-attribute instance-attribute ¶

matrices class-attribute ¶

mode_types class-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

ensure_obj classmethod ¶

from_param classmethod ¶

ridgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

DoG ¶

divisors class-attribute ¶

kwargs class-attribute instance-attribute ¶

matrices class-attribute ¶

mode_types class-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

ensure_obj classmethod ¶

from_param classmethod ¶

EdgeDetect ¶

kwargs class-attribute instance-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

ensure_obj classmethod ¶

from_param classmethod ¶

EuclideanDistance ¶

divisors class-attribute ¶

kwargs class-attribute instance-attribute ¶

matrices class-attribute ¶

mode_types class-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

ensure_obj classmethod ¶

from_param classmethod ¶

ExKirsch ¶

divisors class-attribute ¶

kwargs class-attribute instance-attribute ¶

mag_directions instance-attribute ¶

matrices class-attribute ¶

mode_types class-attribute ¶

edgemask ¶

clip ¶

lthr ¶

hthr ¶

multi ¶

clamp ¶

EdgeDetectT `module-attribute` ¶

RidgeDetectT `module-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

divisors `class-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

matrices `class-attribute` ¶

mode_types `class-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

divisors `class-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

matrices `class-attribute` ¶

mode_types `class-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

kwargs `class-attribute` `instance-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

divisors `class-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

matrices `class-attribute` ¶

mode_types `class-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

divisors `class-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

mag_directions `instance-attribute` ¶

matrices `class-attribute` ¶

mode_types `class-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

divisors `class-attribute` ¶

kwargs `class-attribute` `instance-attribute` ¶

matrices `class-attribute` ¶

mode_types `class-attribute` ¶

`clip` ¶

`lthr` ¶

`hthr` ¶

`multi` ¶

`clamp` ¶

ensure_obj `classmethod` ¶

from_param `classmethod` ¶

divisors `class-attribute` ¶