Functions and Methods

kernels while ensuring the interface will always remain the same, even across different plugins with their own settings and expected behavior.

For example, if you want to downscale a video clip to 1280x720 using Bicubic (b=0, c=1), you can call the preset, vskernels.kernels.SharpBicubic, like so:

kernels.SharpBicubic().scale(clip, width=1280, height=720)

Of course, there is also a generic Bicubic class should you want to assign the values manually.

kernels.Bicubic(b=0, c=1).scale(clip, width=1280, height=720)

This allows for easy customizability, and every kernel can be given unique parameters if required.

kernels.Bicubic(b=0, c=0.5)
kernels.Lanczos(taps=3)
kernels.Impulse(impulse, oversample=8, taps=1)

Using this interface allows for consistency, which makes supporting a wide array of kernels in your own function very simple.

Supporting Kernels in Your Own Function

`vskernels.kernels.get_kernel`(name)	Get a kernel by name.
`vskernels.kernels.get_all_kernels`()	Get all kernels as a list.

Kernels are very flexible, so if you want to use them as-is, they’re simple enough to add. However, you should also consider newer users and their inexperience with Kernels, but potential exposure to abusing strings for “presets”.

With that in mind, we believe the most optimal method to implement kernels is by allowing your function to accept both a Kernel object and a string. This allows users who want to make full use of kernels to do so while not making it any harder for newer users to rely on strings.

Below is some example code for implementing kernel support into a simple descaling function:

from vskernels import Kernel, get_kernel

def descale(clip: vs.VideoNode,
            width: int = 1280, height: int = 720,
            kernel: Kernel | str = 'bicubic') -> vs.VideoNode:
    """A simple descaling function"""

    if isinstance(kernel, str):
        kernel = get_kernel(kernel)()

    descaled_clip = kernel.descale(clip, width, height)
    return descaled_clip

Which in turn allows users to call the function in multiple ways:

import vskernels as kernels

example1 = descale(clip, 1280, 720, kernels.Bicubic())
example2 = descale(clip, 1280, 720, 'bicubic')

Easy as pie!

Functions

class vskernels.kernels.get_kernel(name)

Get a kernel by name.

Parameters: name (str) – Kernel name.
Return type: Type[Kernel]
Returns: Kernel class.

class vskernels.kernels.get_all_kernels

Get all kernels as a list.

Return type: List[Type[Kernel]]

Methods

Every Kernel class comes with a set of methods:

class vskernels.kernels.Example.scale(self, clip, width, height, shift=(0, 0))

Perform a regular scaling operation

Parameters

clip (VideoNode) – Input clip
width (int) – Output width
height (int) – Output height
shift (Tuple[float, float]) – Shift clip during the operation. Expects a tuple of (src_top, src_left).

Return type

VideoNode

class vskernels.kernels.Example.descale(self, clip, width, height, shift=(0, 0))

Perform a regular descaling operation

Parameters

clip (VideoNode) – Input clip
width (int) – Output width
height (int) – Output height
shift (Tuple[float, float]) – Shift clip during the operation. Expects a tuple of (src_top, src_left).

Return type

VideoNode

class vskernels.kernels.Example.shift(self, clip, shift=(0, 0))

Perform a regular shifting operation

Parameters

clip (VideoNode) – Input clip
shift (Tuple[float, float]) – Shift clip during the operation. Expects a tuple of (src_top, src_left).

Return type

VideoNode

class vskernels.kernels.Example.resample(self, clip, format, matrix=None, matrix_in=None)

Perform a regular resampling operation

Parameters

clip (vs.VideoNode) – Input clip
format (vs.PresetFormat | vs.VideoFormat) – Output format
matrix (vs.MatrixCoefficients | Matrix | None) – Output matrix. If None, will take the matrix from the input clip’s frameprops.
matrix_in (vs.MatrixCoefficients | Matrix | None) – Input matrix. If None, will take the matrix from the input clip’s frameprops.

Return type

VideoNode

All Available Kernels

class vskernels.kernels.BSpline(**kwargs)

Bases: vskernels.kernels.Bicubic

Bicubic b=1, c=0

class vskernels.kernels.Bessel(oversample, **kwargs)