Contents

API Reference

Various masking tools for Vapoursynth

Edge Masks

Edge and ridge detection submodule

class vsmask.edge.EdgeDetect

Bases: ABC

Abstract edge detection interface.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.MatrixEdgeDetect

Bases: EdgeDetect, ABC

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SingleMatrix

Bases: MatrixEdgeDetect, ABC

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.EuclidianDistance

Bases: MatrixEdgeDetect, ABC

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.Max

Bases: MatrixEdgeDetect, ABC

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.RidgeDetect

Bases: MatrixEdgeDetect

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.Matrix1D

Bases: EdgeDetect, ABC

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.TEdge

Bases: EuclidianDistance, Matrix1D

(TEdgeMasktype=2) Avisynth plugin.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.TEdgeTedgemask

Bases: Matrix1D, EdgeDetect

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolay

Bases: EuclidianDistance, Matrix1D

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad5

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 5

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad7

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 7

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad9

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 9

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad11

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 11

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad13

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 13

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad15

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 15

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad17

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 17

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad19

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 19

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad21

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 21

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad23

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 23

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quad25

Bases: SavitzkyGolay

Savitzky-Golay first quadratic derivative operator of size 25

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic5

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 5

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic9

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 9

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic11

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 11

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic13

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 13

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic15

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 15

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic17

Bases: SavitzkyGolay

Savitzky-Golay first cubic/quartic operator of size 17

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic19

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 19

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic21

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 21

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic23

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 23

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Cubic25

Bases: SavitzkyGolayNormalise

Savitzky-Golay first cubic/quartic operator of size 25

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint9

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint11

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint13

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint15

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint17

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint19

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint21

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint23

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv1Quint25

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad5

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad13

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad15

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad17

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad19

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad21

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad23

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quad25

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart13

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart15

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart17

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart19

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart21

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart23

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv2Quart25

Bases: SavitzkyGolayNormalise

Savitzky-Golay second quartic/quintic derivativeoperator of size 25

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub5

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub13

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub15

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub17

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub19

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub21

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub23

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Cub25

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint13

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint15

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint17

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint19

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint21

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint23

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv3Quint25

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart13

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart15

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart17

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart19

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart21

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart23

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv4Quart25

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint7

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint9

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint11

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint13

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint15

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint17

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint19

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint21

Bases: SavitzkyGolayNormalise

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint23

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SavitzkyGolayDeriv5Quint25

Bases: SavitzkyGolay

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Matrix2x2

Bases: EdgeDetect, ABC

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Roberts

Bases: RidgeDetect, EuclidianDistance, Matrix2x2

Lawrence Roberts operator. 2x2 matrices computed in 3x3 matrices.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.Matrix3x3

Bases: EdgeDetect, ABC

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Laplacian1

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 1st implementation.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Laplacian2

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 2nd implementation.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Laplacian3

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 3rd implementation.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Laplacian4

Bases: SingleMatrix, Matrix3x3

Pierre-Simon de Laplace operator 4th implementation.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Kayyali

Bases: SingleMatrix, Matrix3x3

Kayyali operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Tritical

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Operator used in Tritical’s original TCanny filter. Plain and simple orthogonal first order derivative.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.TriticalTCanny

Bases: Matrix3x3, EdgeDetect

Operator used in Tritical’s original TCanny filter. Plain and simple orthogonal first order derivative.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Cross

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.Prewitt

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Judith M. S. Prewitt operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.PrewittStd

Bases: Matrix3x3, EdgeDetect

Judith M. S. Prewitt Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.PrewittTCanny

Bases: Matrix3x3, EdgeDetect

Judith M. S. Prewitt TCanny plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Sobel

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Sobel–Feldman operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.SobelStd

Bases: Matrix3x3, EdgeDetect

Sobel–Feldman Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.SobelTCanny

Bases: Matrix3x3, EdgeDetect

Sobel–Feldman Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ASobel

Bases: Matrix3x3, EdgeDetect

Modified Sobel–Feldman operator from AWarpSharp.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Scharr

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Original H. Scharr optimised operator which attempts to achieve the perfect rotational symmetry with coefficients 3 and 10.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.RScharr

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Refined H. Scharr operator to more accurately calculate 1st derivatives for a 3x3 kernel with coeffs 47 and 162.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.ScharrTCanny

Bases: Matrix3x3, EdgeDetect

8. Scharr optimised TCanny Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Kroon

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

Dirk-Jan Kroon operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.KroonTCanny

Bases: Matrix3x3, EdgeDetect

Dirk-Jan Kroon TCanny Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.FreyChenG41

Bases: RidgeDetect, EuclidianDistance, Matrix3x3

“Chen Frei” operator. 3x3 matrices from G41Fun.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.FreyChen

Bases: MatrixEdgeDetect

Chen Frei operator. 3x3 matrices properly implemented.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Robinson3

Bases: Max, Matrix3x3

Robinson compass operator level 3.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Robinson5

Bases: Max, Matrix3x3

Robinson compass operator level 5.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.TheToof

Bases: Max, Matrix3x3

TheToof compass operator from SharpAAMCmod.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Kirsch

Bases: Max, Matrix3x3

Russell Kirsch compass operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.KirschTCanny

Bases: Matrix3x3, EdgeDetect

Russell Kirsch compass TCanny Vapoursynth plugin operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.MinMax(rady=2, radc=0)

Bases: EdgeDetect

Min/max mask with separate luma/chroma radii.

Parameters

• rady (int) – Luma radius

• radc (int) – Chroma radius

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Matrix5x5

Bases: EdgeDetect, ABC

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ExLaplacian1

Bases: SingleMatrix, Matrix5x5

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ExLaplacian2

Bases: SingleMatrix, Matrix5x5

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ExLaplacian3

Bases: SingleMatrix, Matrix5x5

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ExLaplacian4

Bases: SingleMatrix, Matrix5x5

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.LoG

Bases: SingleMatrix, Matrix5x5

Laplacian of Gaussian operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.ExPrewitt

Bases: RidgeDetect, EuclidianDistance, Matrix5x5

Extended Judith M. S. Prewitt operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.ExSobel

Bases: RidgeDetect, EuclidianDistance, Matrix5x5

Extended Sobel–Feldman operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.FDoG

Bases: RidgeDetect, EuclidianDistance, Matrix5x5

Flow-based Difference of Gaussian

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.FDoGTCanny

Bases: Matrix5x5, EdgeDetect

Flow-based Difference of Gaussian TCanny Vapoursynth plugin.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.DoG

Bases: EuclidianDistance, Matrix5x5

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

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

class vsmask.edge.Farid

Bases: RidgeDetect, EuclidianDistance, Matrix5x5

Farid & Simoncelli operator.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

class vsmask.edge.ExKirsch

Bases: Max

Extended Russell Kirsch compass operator. 5x5 matrices.

edgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode

Returns

Mask clip

ridgemask(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

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

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – Low threshold. Anything below lthr will be set to 0

• hthr (Optional[float]) – High threshold. Anything above hthr will be set to the range max

• multi (float) – Multiply all pixels by this before thresholding

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

vs.VideoNode | NoReturn

Returns

Mask clip

vsmask.edge.get_all_edge_detects(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

Returns all the EdgeDetect subclasses

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – See EdgeDetect.get_mask()

• hthr (Optional[float]) – See EdgeDetect.get_mask()

• multi (float) – See EdgeDetect.get_mask()

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

List[vs.VideoNode]

Returns

A list edge masks

vsmask.edge.get_all_ridge_detect(clip, lthr=0.0, hthr=None, multi=1.0, clamp=False)

Returns all the RidgeDetect subclasses

Parameters

• clip (vs.VideoNode) – Source clip

• lthr (float) – See EdgeDetect.get_mask()

• hthr (Optional[float]) – See EdgeDetect.get_mask()

• multi (float) – See EdgeDetect.get_mask()

• clamp (bool | Tuple[float, float] | List[Tuple[float, float]]) – Clamp to TV or full range if True or specified range (low, high)

Return type

List[vs.VideoNode]

Returns

A list edge masks

Utility functions

vsmask.util.max_expr(n)

Dynamic variable max string to be integrated in std.Expr.

Parameters

n (int) – Number of elements.

Return type

str

Returns

Expression

class vsmask.util.XxpandMode(value)

Expand/inpand mode

RECTANGLE = <object object>

Rectangular shape

ELLIPSE = <object object>

Elliptical shape

LOSANGE = <object object>

Diamond shape

vsmask.util.morpho_transfo(clip, func, sw, sh=None, mode=XxpandMode.RECTANGLE, thr=None, planes=None)

Calls a morphological function in order to grow or shrink a clip from the desired width and height.

Parameters

• clip (vs.VideoNode) – Source clip.

• func (MorphoFunc) – Morphological function.

• sw (int) – Growing/shrinking shape width.

• sh (Optional[int]) – Growing/shrinking shape height. If not specified, default to sw.

• mode (XxpandMode) – Shape form. Ellipses are combinations of rectangles and losanges and look more like octogons. Losanges are truncated (not scaled) when sw and sh are not equal.

• thr (Optional[int]) – Allows to limit how much pixels are changed. Output pixels will not become less than input - threshold. The default is no limit.

• planes (int | Sequence[int] | None) – Specifies which planes will be processed. Any unprocessed planes will be simply copied.

Return type

vs.VideoNode

Returns

Transformed clip

vsmask.util.expand(clip, sw, sh=None, mode=XxpandMode.RECTANGLE, thr=None, planes=None)

Calls std.Maximum in order to grow each pixel with the largest value in its 3x3 neighbourhood from the desired width and height.

Parameters

• clip (vs.VideoNode) – Source clip.

• sw (int) – Growing shape width.

• sh (Optional[int]) – Growing shape height. If not specified, default to sw.

• mode (XxpandMode) – Shape form. Ellipses are combinations of rectangles and losanges and look more like octogons. Losanges are truncated (not scaled) when sw and sh are not equal.

• thr (Optional[int]) – Allows to limit how much pixels are changed. Output pixels will not become less than input - threshold. The default is no limit.

• planes (int | Sequence[int] | None) – Specifies which planes will be processed. Any unprocessed planes will be simply copied.

Return type

vs.VideoNode

Returns

Transformed clip

vsmask.util.inpand(clip, sw, sh=None, mode=XxpandMode.RECTANGLE, thr=None, planes=None)

Calls std.Minimum in order to shrink each pixel with the smallest value in its 3x3 neighbourhood from the desired width and height.

Parameters

• clip (vs.VideoNode) – Source clip.

• sw (int) – Shrinking shape width.

• sh (Optional[int]) – Shrinking shape height. If not specified, default to sw.

• mode (XxpandMode) – Shape form. Ellipses are combinations of rectangles and losanges and look more like octogons. Losanges are truncated (not scaled) when sw and sh are not equal.

• thr (Optional[int]) – Allows to limit how much pixels are changed. Output pixels will not become less than input - threshold. The default is no limit.

• planes (int | Sequence[int] | None) – Specifies which planes will be processed. Any unprocessed planes will be simply copied.

Return type

vs.VideoNode

Returns

Transformed clip

vsmask.util.max_planes(*clips, resizer=core.resize.Bilinear)

Set max value of all the planes of all the clips

Output clip format is a GRAY clip with the same bitdepth as the first clip

Parameters

• clips (VideoNode) – Source clips.

• resizer (ZResizer) – Resizer used for converting the clips to the same width, height and to 444.

Return type

VideoNode

Returns

Maxed clip

vsmask.util.region_mask(clip, left=0, right=0, top=0, bottom=0)

Alias for region_rel_mask()

Region relatively the clip with the desired numbers of pixels

Parameters

• clip (VideoNode) – Source clip

• left (int) – Left side

• right (int) – Right side

• top (int) – Top side

• bottom (int) – Bottom side

Return type

VideoNode

Returns

Regionned mask

vsmask.util.region_rel_mask(clip, left=0, right=0, top=0, bottom=0)

Region relatively the clip with the desired numbers of pixels

Parameters

• clip (VideoNode) – Source clip

• left (int) – Left side

• right (int) – Right side

• top (int) – Top side

• bottom (int) – Bottom side

Return type

VideoNode

Returns

Regionned mask

vsmask.util.region_abs_mask(clip, width, height, left=0, top=0)

Region the clip with absolute desired dimensions

Parameters

• clip (VideoNode) – Source clip

• width (int) – Width of the box

• height (int) – Height of the box

• left (int) – Shift from the left, AKA x parameter

• top (int) – Shift from the top, AKA y parameter

Return type

VideoNode

Returns

Regionned mask

License

vs-mask is under the MIT License. See the LICENSE file.

Conditions for Contributors

By contributing to this software project, you are agreeing to the following terms and conditions for your contributions: First, you agree your contributions are submitted under the MIT license. Second, you represent you are authorized to make the contributions and grant the license. If your employer has rights to intellectual property that includes your contributions, you represent that you have received permission to make contributions and grant the required license on behalf of that employer.