Skip to content

util

Classes:

Functions:

LinearLight dataclass 

LinearLight(
    clip: VideoNode,
    linear: bool = True,
    sigmoid: bool | tuple[Slope, Center] = False,
    resampler: ResamplerT | None = Catrom,
    out_fmt: VideoFormat | None = None,
)

Classes:

Attributes:

clip instance-attribute 

clip: VideoNode

linear class-attribute instance-attribute 

linear: bool = True

out_fmt class-attribute instance-attribute 

out_fmt: VideoFormat | None = None

resampler class-attribute instance-attribute 

resampler: ResamplerT | None = Catrom

sigmoid class-attribute instance-attribute 

sigmoid: bool | tuple[Slope, Center] = False

LinearLightProcessing dataclass 

LinearLightProcessing(ll: LinearLight)

Bases: baseclass

Methods:

Attributes:

linear class-attribute instance-attribute 

linear = cachedproperty[[Self], VideoNode, Self, VideoNode, ...](
    get_linear, set_linear
)

ll instance-attribute 

ll: LinearLight

get_linear 

get_linear() -> VideoNode
Source code 
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
def get_linear(self) -> vs.VideoNode:
    wclip: vs.VideoNode = self.ll._wclip

    if self.ll._wclip.format.color_family is vs.YUV:
        wclip = self.ll._resampler.resample(wclip, vs.RGBS, None, self.ll._matrix)
    else:
        wclip = depth(wclip, 32)

    if self.ll.linear:
        wclip = Point.scale_function(wclip, transfer_in=self.ll._curve, transfer=Transfer.LINEAR)

    if self.ll.sigmoid:
        if Transfer.from_video(wclip, func=self.__class__) in (Transfer.ST2084, Transfer.STD_B67):
            raise InvalidTransferError(
                self.__class__, Transfer.from_video(wclip, func=self.__class__),
                'Sigmoid scaling is not supported with HDR!'
            )

        wclip = norm_expr(
            wclip,
            '{center} 1 {slope} / 1 x 0 max 1 min {scale} * {offset} + / 1 - log * -',
            center=self.ll._scenter, slope=self.ll._sslope,
            scale=self.ll._sscale, offset=self.ll._soffset,
            func=self.__class__
        )

    return wclip

out 

out() -> VideoNode
Source code 
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
@cachedproperty
def out(self) -> vs.VideoNode:
    if not self.ll._exited:
        raise CustomRuntimeError(
            'You can\'t get .out while still inside of the context manager!', func=self.__class__
        )

    if not hasattr(self, '_linear'):
        raise CustomValueError('You need to set .linear before getting .out!', self.__class__)

    processed = self._linear

    if self.ll.sigmoid:
        processed = norm_expr(
            processed,
            '1 1 {slope} {center} x 0 max 1 min - * exp + / {offset} - {scale} /',
            slope=self.ll._sslope, center=self.ll._scenter,
            offset=self.ll._soffset, scale=self.ll._sscale,
            func=self.__class__
        )

    if self.ll.linear:
        processed = Point.scale_function(processed, transfer_in=Transfer.LINEAR, transfer=self.ll._curve)

    return resample_to(processed, self.ll._fmt, self.ll._matrix, self.ll._resampler)

set_linear 

set_linear(processed: VideoNode) -> None
Source code 
172
173
174
175
176
177
def set_linear(self, processed: vs.VideoNode) -> None:
    if self.ll._exited:
        raise CustomRuntimeError(
            'You can\'t set .linear after going out of the context manager!', func=self.__class__
        )
    self._linear = processed

NoScale 

NoScale(b: float = 0, c: float = 1 / 2, **kwargs: Any)

Bases: NoScaleBase, Bicubic

Methods:

Attributes:

Source code 
41
42
43
44
def __init__(self, b: float = 0, c: float = 1 / 2, **kwargs: Any) -> None:
    self.b = b
    self.c = c
    super().__init__(**kwargs)

b instance-attribute 

b = b

c instance-attribute 

c = c

descale_function class-attribute instance-attribute 

descale_function = Debicubic

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

resample_function class-attribute instance-attribute 

resample_function = Bicubic

scale_function class-attribute instance-attribute 

scale_function = Bicubic

descale 

descale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    field_based: FieldBased | None = None,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    blur: float = 1.0,
    ignore_mask: VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `border_handling`, `sample_grid_model` and `field_based` from Descaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    # `linear` and `sigmoid` from LinearDescaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    # `blur` and `ignore_mask` parameters from ZimgDescaler
    blur: float = 1.0, ignore_mask: vs.VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    ...

ensure_obj classmethod 

ensure_obj(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> Kernel

ensure_obj(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Scaler

ensure_obj(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Descaler

ensure_obj(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Resampler

ensure_obj(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScaler
Source code 
647
648
649
650
651
652
653
654
@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

from_kernel staticmethod 

from_kernel(kernel: KernelT) -> type[Kernel]
Source code 
117
118
119
120
121
122
123
124
@staticmethod
def from_kernel(kernel: KernelT) -> type[Kernel]:
    kernel_t = Kernel.from_param(kernel)

    class inner_no_scale(kernel_t, NoScaleBase):  # type: ignore
        ...

    return inner_no_scale

from_param classmethod 

from_param(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> type[Kernel]

from_param(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Scaler]

from_param(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Descaler]

from_param(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Resampler]

from_param(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScaler]
Source code 
611
612
613
614
615
616
617
@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_descale_args 

get_descale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
673
674
675
676
677
678
679
680
681
682
683
@inject_kwargs_params
def get_descale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(True, clip, width, height, **kwargs)
    )

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
701
702
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
46
47
48
49
50
51
52
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    args = super().get_params_args(is_descale, clip, width, height, **kwargs)
    if is_descale:
        return args | dict(b=self.b, c=self.c)
    return args | dict(filter_param_a=self.b, filter_param_b=self.c)

get_resample_args 

get_resample_args(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
661
662
663
664
665
666
667
668
669
670
671
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(src_top=shift[0], src_left=shift[1])
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, width, height, **kwargs)
    )

kernel_radius 

kernel_radius() -> int
Source code 
54
55
56
57
58
@inject_self.cached.property
def kernel_radius(self) -> int:
    if (self.b, self.c) == (0, 0):
        return 1
    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

resample 

resample(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
438
439
440
441
442
443
444
445
446
@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
105
106
107
108
109
110
111
112
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    ...

shift 

shift(
    clip: VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

NoScaleBase 

NoScaleBase(**kwargs: Any)

Bases: Scaler

Methods:

Attributes:

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

  • scale_function (Callable[..., VideoNode]) –

    Scale function called internally when scaling

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

scale_function instance-attribute 

scale_function: Callable[..., VideoNode]

Scale function called internally when scaling

ensure_obj classmethod 

ensure_obj(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScalerT
Source code 
201
202
203
204
205
206
207
208
@classmethod
def ensure_obj(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScalerT:
    return _base_ensure_obj(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

from_param classmethod 

from_param(
    scaler: str | type[BaseScalerT] | BaseScalerT | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScalerT]
Source code 
192
193
194
195
196
197
198
199
@classmethod
def from_param(
    cls: type[BaseScalerT], scaler: str | type[BaseScalerT] | BaseScalerT | None = None, /,
    func_except: FuncExceptT | None = None
) -> type[BaseScalerT]:
    return _base_from_param(
        cls, (mro := cls.mro())[mro.index(BaseScaler) - 1], scaler, cls._err_class, [], func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
299
300
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.scale, self.supersample)

get_scale_args 

get_scale_args(
    clip: VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
@inject_kwargs_params
def get_scale_args(
    self, clip: vs.VideoNode, shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None, height: int | None = None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            src_top=shift[0],
            src_left=shift[1]
        )
        | self.get_clean_kwargs(*funcs)
        | dict(width=width, height=height)
        | kwargs
    )

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    try:
        width, height = Scaler._wh_norm(clip, width, height)
        return super().scale(clip, clip.width, clip.height, shift, **kwargs)
    except Exception:
        return clip

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

NoShift 

NoShift(b: float = 0, c: float = 1 / 2, **kwargs: Any)

Bases: Bicubic, NoShiftBase

Class util used to always pass shift=(0, 0)

By default it inherits from :py:class:vskernels.Bicubic, this behaviour can be changed with :py:attr:Noshift.from_kernel

Use case, for example vsaa's ZNedi3: 

test = ...  # some clip, 480x480
doubled_no_shift = Znedi3(field=0, nsize=4, nns=3, shifter=NoShift).scale(test, 960, 960)
down = Point.scale(double, 480, 480)

Methods:

Attributes:

Source code 
41
42
43
44
def __init__(self, b: float = 0, c: float = 1 / 2, **kwargs: Any) -> None:
    self.b = b
    self.c = c
    super().__init__(**kwargs)

b instance-attribute 

b = b

c instance-attribute 

c = c

descale_function class-attribute instance-attribute 

descale_function = Debicubic

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

resample_function class-attribute instance-attribute 

resample_function = Bicubic

scale_function class-attribute instance-attribute 

scale_function = Bicubic

descale 

descale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    field_based: FieldBased | None = None,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    blur: float = 1.0,
    ignore_mask: VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `border_handling`, `sample_grid_model` and `field_based` from Descaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    # `linear` and `sigmoid` from LinearDescaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    # `blur` and `ignore_mask` parameters from ZimgDescaler
    blur: float = 1.0, ignore_mask: vs.VideoNode | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    ...

ensure_obj classmethod 

ensure_obj(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> Kernel

ensure_obj(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Scaler

ensure_obj(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Descaler

ensure_obj(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Resampler

ensure_obj(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScaler
Source code 
647
648
649
650
651
652
653
654
@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

from_kernel staticmethod 

from_kernel(kernel: KernelT) -> type[Kernel]

Function or decorator for making a kernel not shift.

As example, in vsaa: 

doubled_no_shift = Znedi3(..., shifter=NoShift.from_kernel('lanczos')).scale(...)

# which in *this case* can also be written as this
doubled_no_shift = Znedi3(..., shifter=NoShift, scaler=Lanczos).scale(...)

Or for some other code: 

@NoShift.from_kernel
class CustomCatromWithoutShift(Catrom):
    # some cool code
    ...

Source code 
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
@staticmethod
def from_kernel(kernel: KernelT) -> type[Kernel]:
    """
    Function or decorator for making a kernel not shift.

    As example, in vsaa:
    ```
    doubled_no_shift = Znedi3(..., shifter=NoShift.from_kernel('lanczos')).scale(...)

    # which in *this case* can also be written as this
    doubled_no_shift = Znedi3(..., shifter=NoShift, scaler=Lanczos).scale(...)
    ```

    Or for some other code:
    ```
    @NoShift.from_kernel
    class CustomCatromWithoutShift(Catrom):
        # some cool code
        ...
    ```
    """

    kernel_t = Kernel.from_param(kernel)

    class inner_no_shift(NoShiftBase, kernel_t):  # type: ignore
        ...

    return inner_no_shift

from_param classmethod 

from_param(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> type[Kernel]

from_param(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Scaler]

from_param(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Descaler]

from_param(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Resampler]

from_param(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScaler]
Source code 
611
612
613
614
615
616
617
@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_descale_args 

get_descale_args(clip: VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]
Source code 
37
38
def get_descale_args(self, clip: vs.VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]:
    return super().get_descale_args(clip, (0, 0), *(args and args[1:]), **kwargs)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
701
702
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> dict[str, Any]
Source code 
46
47
48
49
50
51
52
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    args = super().get_params_args(is_descale, clip, width, height, **kwargs)
    if is_descale:
        return args | dict(b=self.b, c=self.c)
    return args | dict(filter_param_a=self.b, filter_param_b=self.c)

get_resample_args 

get_resample_args(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

get_scale_args 

get_scale_args(clip: VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]
Source code 
34
35
def get_scale_args(self, clip: vs.VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]:
    return super().get_scale_args(clip, (0, 0), *(args and args[1:]), **kwargs)

kernel_radius 

kernel_radius() -> int
Source code 
54
55
56
57
58
@inject_self.cached.property
def kernel_radius(self) -> int:
    if (self.b, self.c) == (0, 0):
        return 1
    return 2

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

resample 

resample(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
438
439
440
441
442
443
444
445
446
@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    sar: Sar | float | bool | None = None,
    dar: Dar | float | bool | None = None,
    dar_in: Dar | bool | float | None = None,
    keep_ar: bool | None = None,
    linear: bool = False,
    sigmoid: bool | tuple[Slope, Center] = False,
    blur: float = 1.0,
    **kwargs: Any
) -> VideoNode
Source code 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    *,
    # `border_handling`, `sample_grid_model`, `sar`, `dar`, `dar_in` and `keep_ar` from KeepArScaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    sar: Sar | float | bool | None = None, dar: Dar | float | bool | None = None,
    dar_in: Dar | bool | float | None = None, keep_ar: bool | None = None,
    # `linear` and `sigmoid` from LinearScaler
    linear: bool = False, sigmoid: bool | tuple[Slope, Center] = False,
    # ZimgComplexKernel adds blur parameter
    blur: float = 1.0,
    **kwargs: Any
) -> vs.VideoNode:
    ...

shift 

shift(
    clip: VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

NoShiftBase 

NoShiftBase(**kwargs: Any)

Bases: Kernel

Methods:

Attributes:

  • descale_function (Callable[..., ConstantFormatVideoNode]) –

    Descale function called internally when descaling

  • kwargs (KwargsT) –

    Arguments passed to the internal scale function

  • resample_function (Callable[..., ConstantFormatVideoNode]) –

    Resample function called internally when resampling

  • scale_function (Callable[..., VideoNode]) –

    Scale function called internally when scaling

Source code 
182
183
def __init__(self, **kwargs: Any) -> None:
    self.kwargs = kwargs

descale_function instance-attribute 

descale_function: Callable[..., ConstantFormatVideoNode]

Descale function called internally when descaling

kwargs instance-attribute 

kwargs: KwargsT = kwargs

Arguments passed to the internal scale function

resample_function instance-attribute 

resample_function: Callable[..., ConstantFormatVideoNode]

Resample function called internally when resampling

scale_function instance-attribute 

scale_function: Callable[..., VideoNode]

Scale function called internally when scaling

descale 

descale(
    clip: VideoNode,
    width: int | None,
    height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = MIRROR,
    sample_grid_model: SampleGridModel = MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
@inject_self.cached
@inject_kwargs_params
def descale(
    self, clip: vs.VideoNode, width: int | None, height: int | None,
    shift: ShiftT = (0, 0),
    *,
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBased | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    width, height = self._wh_norm(clip, width, height)

    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs |= dict(border_handling=BorderHandling.from_param(border_handling, self.descale))

    if field_based.is_inter:
        shift_y, shift_x = self._shift_norm(shift, False, self.descale)

        kwargs_tf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[0], shift_x[0]), **kwargs)
        kwargs_bf, shift = sample_grid_model.for_src(clip, width, height, (shift_y[1], shift_x[1]), **kwargs)

        de_kwargs_tf = self.get_descale_args(clip, (shift_y[0], shift_x[0]), *de_base_args, **kwargs_tf)
        de_kwargs_bf = self.get_descale_args(clip, (shift_y[1], shift_x[1]), *de_base_args, **kwargs_bf)

        if height % 2:
            raise CustomIndexError('You can\'t descale to odd resolution when crossconverted!', self.descale)

        field_shift = 0.125 * height / clip.height

        fields = clip.std.SeparateFields(field_based.is_tff)

        interleaved = core.std.Interleave([
            self.descale_function(fields[offset::2], **_norm_props_enums(
                de_kwargs | dict(src_top=de_kwargs.get('src_top', 0.0) + (field_shift * mult))
            ))
            for offset, mult, de_kwargs in [(0, 1, de_kwargs_tf), (1, -1, de_kwargs_bf)]
        ])

        descaled = interleaved.std.DoubleWeave(field_based.is_tff)[::2]
    else:
        shift = self._shift_norm(shift, True, self.descale)

        kwargs, shift = sample_grid_model.for_src(clip, width, height, shift, **kwargs)

        de_kwargs = self.get_descale_args(clip, shift, *de_base_args, **kwargs)

        descaled = self.descale_function(clip, **_norm_props_enums(de_kwargs))

    return depth(descaled, bits)

ensure_obj classmethod 

ensure_obj(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> Kernel

ensure_obj(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Scaler

ensure_obj(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Descaler

ensure_obj(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> Resampler

ensure_obj(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> BaseScaler
Source code 
647
648
649
650
651
652
653
654
@classmethod
def ensure_obj(
    cls: type[Kernel], kernel: str | type[BaseScaler] | BaseScaler | None = None, /,
    func_except: FuncExceptT | None = None
) -> BaseScaler:
    return _base_ensure_obj(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

from_param classmethod 

from_param(
    kernel: KernelT | None = ..., /, func_except: FuncExceptT | None = None
) -> type[Kernel]

from_param(
    kernel: ScalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Scaler]

from_param(
    kernel: DescalerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Descaler]

from_param(
    kernel: ResamplerT | KernelT | None = ...,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Resampler]

from_param(
    kernel: str | type[BaseScaler] | BaseScaler | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[BaseScaler]
Source code 
611
612
613
614
615
616
617
@classmethod
def from_param(
    cls, kernel: str | type[BaseScaler] | BaseScaler | None = None, /, func_except: FuncExceptT | None = None
) -> type[BaseScaler]:
    return _base_from_param(
        cls, Kernel, kernel, UnknownKernelError, abstract_kernels, func_except
    )

get_clean_kwargs 

get_clean_kwargs(*funcs: Callable[..., Any] | None) -> KwargsT
Source code 
216
217
def get_clean_kwargs(self, *funcs: Callable[..., Any] | None) -> KwargsT:
    return _clean_self_kwargs(funcs, self)

get_descale_args 

get_descale_args(clip: VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]
Source code 
37
38
def get_descale_args(self, clip: vs.VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]:
    return super().get_descale_args(clip, (0, 0), *(args and args[1:]), **kwargs)

get_implemented_funcs 

get_implemented_funcs() -> tuple[Callable[..., Any], ...]
Source code 
701
702
def get_implemented_funcs(self) -> tuple[Callable[..., Any], ...]:
    return (self.shift, )

get_params_args 

get_params_args(
    is_descale: bool,
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any
) -> KwargsT
Source code 
656
657
658
659
def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> KwargsT:
    return dict(width=width, height=height) | kwargs

get_resample_args 

get_resample_args(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    *funcs: Callable[..., Any],
    **kwargs: Any
) -> KwargsT
Source code 
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
@inject_kwargs_params
def get_resample_args(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None, matrix_in: MatrixT | None,
    *funcs: Callable[..., Any], **kwargs: Any
) -> KwargsT:
    return (
        dict(
            format=get_video_format(format).id,
            matrix=Matrix.from_param(matrix),
            matrix_in=Matrix.from_param(matrix_in)
        )
        | self.get_clean_kwargs(*funcs)
        | self.get_params_args(False, clip, **kwargs)
    )

get_scale_args 

get_scale_args(clip: VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]
Source code 
34
35
def get_scale_args(self, clip: vs.VideoNode, *args: Any, **kwargs: Any) -> dict[str, Any]:
    return super().get_scale_args(clip, (0, 0), *(args and args[1:]), **kwargs)

kernel_radius 

kernel_radius() -> int
Source code 
210
211
212
213
214
@inject_self.cached.property
def kernel_radius(self) -> int:
    if hasattr(self, '_static_kernel_radius'):
        return ceil(self._static_kernel_radius)
    raise CustomNotImplementedError('kernel_radius is not implemented!', self.__class__)

multi 

multi(
    clip: VideoNode,
    multi: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def multi(
    self, clip: vs.VideoNode, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:

    import warnings

    warnings.warn('The "multi" method is deprecated. Use "supersample" instead.', DeprecationWarning)

    return self.supersample(clip, multi, shift, **kwargs)

pretty_string 

pretty_string() -> str
Source code 
225
226
227
@inject_self.cached.property
def pretty_string(self) -> str:
    return self._pretty_string()

resample 

resample(
    clip: VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
438
439
440
441
442
443
444
445
446
@inject_self.cached
@inject_kwargs_params
def resample(
    self, clip: vs.VideoNode, format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None, matrix_in: MatrixT | None = None, **kwargs: Any
) -> ConstantFormatVideoNode:
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
243
244
245
246
247
248
249
250
251
252
253
254
255
@inject_self.cached
@inject_kwargs_params
def scale(
    self, clip: vs.VideoNode, width: int | None = None, height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    width, height = Scaler._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    return self.scale_function(
        clip, **_norm_props_enums(self.get_scale_args(clip, shift, width, height, **kwargs))
    )

shift 

shift(
    clip: VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
@inject_self.cached
@inject_kwargs_params
def shift(
    self,
    clip: vs.VideoNode,
    shifts_or_top: float | tuple[float, float] | list[float] | None = None,
    shift_left: float | list[float] | None = None,
    /,
    **kwargs: Any
) -> ConstantFormatVideoNode:
    assert check_variable_format(clip, self.shift)

    n_planes = clip.format.num_planes

    def _shift(src: VideoNodeT, shift: tuple[TopShift, LeftShift] = (0, 0)) -> VideoNodeT:
        return self.scale(src, src.width, src.height, shift, **kwargs)

    if not shifts_or_top and not shift_left:
        return _shift(clip)

    if isinstance(shifts_or_top, tuple):
        return _shift(clip, shifts_or_top)

    if isinstance(shifts_or_top, float) and isinstance(shift_left, float):
        return _shift(clip, (shifts_or_top, shift_left))

    if shifts_or_top is None:
        shifts_or_top = 0.0
    if shift_left is None:
        shift_left = 0.0

    shifts_top = shifts_or_top if isinstance(shifts_or_top, list) else [shifts_or_top]
    shifts_left = shift_left if isinstance(shift_left, list) else [shift_left]

    if not shifts_top:
        shifts_top = [0.0] * n_planes
    elif (ltop := len(shifts_top)) > n_planes:
        shifts_top = shifts_top[:n_planes]
    else:
        shifts_top += shifts_top[-1:] * (n_planes - ltop)

    if not shifts_left:
        shifts_left = [0.0] * n_planes
    elif (lleft := len(shifts_left)) > n_planes:
        shifts_left = shifts_left[:n_planes]
    else:
        shifts_left += shifts_left[-1:] * (n_planes - lleft)

    if len(set(shifts_top)) == len(set(shifts_left)) == 1 or n_planes == 1:
        return _shift(clip, (shifts_top[0], shifts_left[0]))

    planes = split(clip)

    shifted_planes = [
        plane if top == left == 0 else _shift(plane, (top, left))
        for plane, top, left in zip(planes, shifts_top, shifts_left)
    ]

    return core.std.ShufflePlanes(shifted_planes, [0, 0, 0], clip.format.color_family)

supersample 

supersample(
    clip: VideoNode,
    rfactor: float = 2.0,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode
Source code 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
@inject_self.cached
def supersample(
    self, clip: vs.VideoNode, rfactor: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> vs.VideoNode:
    assert check_variable_resolution(clip, self.multi)

    dst_width, dst_height = ceil(clip.width * rfactor), ceil(clip.height * rfactor)

    if max(dst_width, dst_height) <= 0.0:
        raise CustomValueError(
            'Multiplying the resolution by "rfactor" must result in a positive resolution!', self.supersample, rfactor
        )

    return self.scale(clip, dst_width, dst_height, shift, **kwargs)

resample_to 

resample_to(
    clip: VideoNode,
    out_fmt: HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    resampler: ResamplerT = Catrom,
) -> VideoNode
Source code 
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
def resample_to(
    clip: vs.VideoNode, out_fmt: HoldsVideoFormatT, matrix: MatrixT | None = None, resampler: ResamplerT = Catrom
) -> vs.VideoNode:
    out_fmt = get_video_format(out_fmt)
    assert clip.format

    resampler = Resampler.from_param(resampler)

    if out_fmt == clip.format:
        return clip

    if out_fmt.color_family is clip.format.color_family:
        return depth(clip, out_fmt)

    if out_fmt.subsampling_w == out_fmt.subsampling_h == 0:
        return Point.resample(clip, out_fmt, matrix)

    return resampler.resample(clip, out_fmt, matrix)