Skip to content

sangnom

This module implements wrappers for the SangNom single field deinterlacer using edge-directed interpolation

Classes:

  • SANGNOM –

    Base class for SANGNOM interpolating methods.

  • SangNom –

    Full implementation of the SANGNOM anti-aliaser

  • SangNomDR –

    Concrete implementation of SANGNOM used as a double-rater.

  • SangNomSS –

    Concrete implementation of SANGNOM used as a supersampler.

SANGNOM dataclass 

SANGNOM(
    aa_strength: int | Sequence[int] = 48,
    double_fps: bool = False,
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: Interpolater

Base class for SANGNOM interpolating methods.

Methods:

Attributes:

  • aa_strength (int | Sequence[int]) –

    The strength of luma anti-aliasing, applied to an 8-bit clip.

  • double_fps (bool) –

    Whether to double the frame rate of the clip.

  • drop_fields (bool) –

    Whether to discard the unused field based on the field setting.

  • field (int) –

    Controls the mode of operation and which field is kept in the resized image.

  • scaler (ScalerT | None) –

    Scaler used for additional scaling operations. If None, default to shifter

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

aa_strength class-attribute instance-attribute 

aa_strength: int | Sequence[int] = 48

The strength of luma anti-aliasing, applied to an 8-bit clip. Must be an integer between 0 and 128, inclusive.

double_fps class-attribute instance-attribute 

double_fps: bool = False

Whether to double the frame rate of the clip.

drop_fields class-attribute instance-attribute 

drop_fields: bool = True

Whether to discard the unused field based on the field setting.

field class-attribute instance-attribute 

field: int = 0

Controls the mode of operation and which field is kept in the resized image. - 0: Same rate, keeps the bottom field. - 1: Same rate, keeps the top field. - 2: Double rate (alternates each frame), starts with the bottom field. - 3: Double rate (alternates each frame), starts with the top field.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

Scaler used for additional scaling operations. If None, default to shifter

shifter class-attribute instance-attribute 

shifter: KernelT = Catrom

Kernel used for shifting operations. Default to Catrom.

transpose_first class-attribute instance-attribute 

transpose_first: bool = False

Transpose the clip before any operation.

copy 

copy(**kwargs: Any) -> Self

Returns a new Antialiaser class replacing specified fields with new values

Source code 
137
138
139
def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

get_aa_args 

get_aa_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
46
47
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    return dict(aa=self.aa_strength, order=0 if self.double_fps else self.field + 1) | kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
49
50
51
52
53
54
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    interpolated = core.sangnom.SangNom(
        clip, dh=double_y or not self.drop_fields, **self.get_aa_args(clip, **kwargs) | kwargs
    )

    return self.shift_interpolate(clip, interpolated, double_y)

shift_interpolate 

shift_interpolate(
    clip: VideoNode, inter: VideoNode, double_y: bool
) -> ConstantFormatVideoNode

Applies a post-shifting interpolation operation to the interpolated clip.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • inter

    (VideoNode) –

    Interpolated clip.

  • double_y

    (bool) –

    Whether the height has been doubled

Returns:

  • ConstantFormatVideoNode –

    Shifted clip.

Source code 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

SangNom dataclass 

SangNom(
    aa_strength: int | Sequence[int] = 48,
    double_fps: bool = False,
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: SangNomDR, SangNomSS, Antialiaser

Full implementation of the SANGNOM anti-aliaser

Methods:

  • aa –
  • copy –

    Returns a new Antialiaser class replacing specified fields with new values

  • draa –
  • get_aa_args –
  • get_sr_args –

    Retrieves arguments for single rating processing.

  • get_ss_args –

    Retrieves arguments for super sampling processing.

  • interpolate –
  • scale –

    Scale the given clip using super sampling method.

  • shift_interpolate –

    Applies a post-shifting interpolation operation to the interpolated clip.

Attributes:

  • aa_strength (int | Sequence[int]) –

    The strength of luma anti-aliasing, applied to an 8-bit clip.

  • double_fps (bool) –

    Whether to double the frame rate of the clip.

  • drop_fields (bool) –

    Whether to discard the unused field based on the field setting.

  • field (int) –

    Controls the mode of operation and which field is kept in the resized image.

  • merge_func (Callable[[VideoNode, VideoNode], ConstantFormatVideoNode]) –

    Function used to merge the clips after the double-rate operation.

  • scaler (ScalerT | None) –

    Scaler used for additional scaling operations. If None, default to shifter

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

aa_strength class-attribute instance-attribute 

aa_strength: int | Sequence[int] = 48

The strength of luma anti-aliasing, applied to an 8-bit clip. Must be an integer between 0 and 128, inclusive.

double_fps class-attribute instance-attribute 

double_fps: bool = False

Whether to double the frame rate of the clip.

drop_fields class-attribute instance-attribute 

drop_fields: bool = True

Whether to discard the unused field based on the field setting.

field class-attribute instance-attribute 

field: int = 0

Controls the mode of operation and which field is kept in the resized image. - 0: Same rate, keeps the bottom field. - 1: Same rate, keeps the top field. - 2: Double rate (alternates each frame), starts with the bottom field. - 3: Double rate (alternates each frame), starts with the top field.

merge_func class-attribute instance-attribute 

merge_func: Callable[[VideoNode, VideoNode], ConstantFormatVideoNode] = Merge

Function used to merge the clips after the double-rate operation.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

Scaler used for additional scaling operations. If None, default to shifter

shifter class-attribute instance-attribute 

shifter: KernelT = Catrom

Kernel used for shifting operations. Default to Catrom.

transpose_first class-attribute instance-attribute 

transpose_first: bool = False

Transpose the clip before any operation.

aa 

aa(
    clip: VideoNode, y: bool = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode, dir: AADirection = BOTH, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode,
    y_or_dir: bool | AADirection = True,
    x: bool = True,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
324
325
326
327
328
329
330
331
332
333
334
def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

copy 

copy(**kwargs: Any) -> Self

Returns a new Antialiaser class replacing specified fields with new values

Source code 
137
138
139
def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

draa 

draa(
    clip: VideoNode, y: bool = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode

draa(
    clip: VideoNode, dir: AADirection = BOTH, /, **kwargs: Any
) -> ConstantFormatVideoNode

draa(
    clip: VideoNode,
    y_or_dir: bool | AADirection = True,
    x: bool = True,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
def draa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    original_field = int(self.field)

    self.field = 0
    aa0 = super()._do_aa(clip, y, x, **kwargs)

    self.field = 1
    aa1 = super()._do_aa(clip, y, x, **kwargs)

    self.field = original_field

    return self.merge_func(aa0, aa1)

get_aa_args 

get_aa_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
46
47
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    return dict(aa=self.aa_strength, order=0 if self.double_fps else self.field + 1) | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]

Retrieves arguments for single rating processing.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments.

Returns:

Source code 
287
288
289
290
291
292
293
294
295
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

get_ss_args 

get_ss_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]

Retrieves arguments for super sampling processing.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments.

Returns:

Source code 
178
179
180
181
182
183
184
185
186
def get_ss_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for super sampling processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
49
50
51
52
53
54
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    interpolated = core.sangnom.SangNom(
        clip, dh=double_y or not self.drop_fields, **self.get_aa_args(clip, **kwargs) | kwargs
    )

    return self.shift_interpolate(clip, interpolated, double_y)

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode

Scale the given clip using super sampling method.

Parameters:

  • clip

    (VideoNode) –

    The input clip to be scaled.

  • width

    (int | None, default: None ) –

    The target width for scaling. If None, the width of the input clip will be used.

  • height

    (int | None, default: None ) –

    The target height for scaling. If None, the height of the input clip will be used.

  • shift

    (tuple[TopShift, LeftShift], default: (0, 0) ) –

    A tuple representing the shift values for the y and x axes.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to be passed to the interpolate or full_interpolate methods.

Returns:

  • VideoNode –

    The scaled clip.

Source code 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    """
    Scale the given clip using super sampling method.

    :param clip:        The input clip to be scaled.
    :param width:       The target width for scaling. If None, the width of the input clip will be used.
    :param height:      The target height for scaling. If None, the height of the input clip will be used.
    :param shift:       A tuple representing the shift values for the y and x axes.
    :param **kwargs:    Additional arguments to be passed to the `interpolate` or `full_interpolate` methods.

    :return:            The scaled clip.
    """
    assert check_progressive(clip, self.scale)

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

    if (clip.width, clip.height) == (width, height):
        return clip

    kwargs = self.get_aa_args(clip, **kwargs) | self.get_ss_args(clip, **kwargs) | kwargs

    divw, divh = (ceil(size) for size in (width / clip.width, height / clip.height))

    mult_x, mult_y = (int(log2(divs)) for divs in (divw, divh))

    cdivw, cdivh = 1 << clip.format.subsampling_w, 1 << clip.format.subsampling_h

    upscaled = clip

    def _transpose(before: bool, is_width: int, y: int, x: int) -> None:
        nonlocal upscaled

        before = self.transpose_first if before else not self.transpose_first

        if ((before or not y) if is_width else (before and x)):
            upscaled = upscaled.std.Transpose()

    for (y, x) in zip_longest([True] * mult_y, [True] * mult_x, fillvalue=False):
        if isinstance(self, _FullInterpolate) and self.is_full_interpolate_enabled(x, y):
            upscaled = self.full_interpolate(upscaled, y, x, **kwargs)
        else:
            for isx, val in enumerate([y, x]):
                if val:
                    _transpose(True, isx, y, x)

                    upscaled = self.interpolate(upscaled, True, **kwargs)

                    _transpose(False, isx, y, x)

        topshift = leftshift = cleftshift = ctopshift = 0.0

        if y and self._shift:
            topshift = ctopshift = self._shift

            if cdivw == 2 and cdivh == 2:
                ctopshift -= 0.125
            elif cdivw == 1 and cdivh == 2:
                ctopshift += 0.125

        cresshift = 0.0

        if x and self._shift:
            leftshift = cleftshift = self._shift

            if cdivw in {4, 2} and cdivh in {4, 2, 1}:
                cleftshift = self._shift + 0.5

                if cdivw == 4 and cdivh == 1:
                    cresshift = 0.125 * 1
                elif cdivw == 2 and cdivh == 2:
                    cresshift = 0.125 * 2
                elif cdivw == 2 and cdivh == 1:
                    cresshift = 0.125 * 3

                cleftshift -= cresshift

        if isinstance(self._shifter, NoShift):
            if upscaled.format.subsampling_h or upscaled.format.subsampling_w:
                upscaled = Catrom.shift(upscaled, 0, [0, cleftshift + cresshift])
        else:
            upscaled = self._shifter.shift(
                upscaled, [topshift, ctopshift], [leftshift, cleftshift]
            )

    return self._scaler.scale(upscaled, width, height, shift)

shift_interpolate 

shift_interpolate(
    clip: VideoNode, inter: VideoNode, double_y: bool
) -> ConstantFormatVideoNode

Applies a post-shifting interpolation operation to the interpolated clip.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • inter

    (VideoNode) –

    Interpolated clip.

  • double_y

    (bool) –

    Whether the height has been doubled

Returns:

  • ConstantFormatVideoNode –

    Shifted clip.

Source code 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

SangNomDR dataclass 

SangNomDR(
    aa_strength: int | Sequence[int] = 48,
    double_fps: bool = False,
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: SangNomSR, DoubleRater

Concrete implementation of SANGNOM used as a double-rater.

Methods:

Attributes:

  • aa_strength (int | Sequence[int]) –

    The strength of luma anti-aliasing, applied to an 8-bit clip.

  • double_fps (bool) –

    Whether to double the frame rate of the clip.

  • drop_fields (bool) –

    Whether to discard the unused field based on the field setting.

  • field (int) –

    Controls the mode of operation and which field is kept in the resized image.

  • merge_func (Callable[[VideoNode, VideoNode], ConstantFormatVideoNode]) –

    Function used to merge the clips after the double-rate operation.

  • scaler (ScalerT | None) –

    Scaler used for additional scaling operations. If None, default to shifter

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

aa_strength class-attribute instance-attribute 

aa_strength: int | Sequence[int] = 48

The strength of luma anti-aliasing, applied to an 8-bit clip. Must be an integer between 0 and 128, inclusive.

double_fps class-attribute instance-attribute 

double_fps: bool = False

Whether to double the frame rate of the clip.

drop_fields class-attribute instance-attribute 

drop_fields: bool = True

Whether to discard the unused field based on the field setting.

field class-attribute instance-attribute 

field: int = 0

Controls the mode of operation and which field is kept in the resized image. - 0: Same rate, keeps the bottom field. - 1: Same rate, keeps the top field. - 2: Double rate (alternates each frame), starts with the bottom field. - 3: Double rate (alternates each frame), starts with the top field.

merge_func class-attribute instance-attribute 

merge_func: Callable[[VideoNode, VideoNode], ConstantFormatVideoNode] = Merge

Function used to merge the clips after the double-rate operation.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

Scaler used for additional scaling operations. If None, default to shifter

shifter class-attribute instance-attribute 

shifter: KernelT = Catrom

Kernel used for shifting operations. Default to Catrom.

transpose_first class-attribute instance-attribute 

transpose_first: bool = False

Transpose the clip before any operation.

aa 

aa(
    clip: VideoNode, y: bool = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode, dir: AADirection = BOTH, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode,
    y_or_dir: bool | AADirection = True,
    x: bool = True,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
324
325
326
327
328
329
330
331
332
333
334
def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

copy 

copy(**kwargs: Any) -> Self

Returns a new Antialiaser class replacing specified fields with new values

Source code 
137
138
139
def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

draa 

draa(
    clip: VideoNode, y: bool = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode

draa(
    clip: VideoNode, dir: AADirection = BOTH, /, **kwargs: Any
) -> ConstantFormatVideoNode

draa(
    clip: VideoNode,
    y_or_dir: bool | AADirection = True,
    x: bool = True,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
def draa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    original_field = int(self.field)

    self.field = 0
    aa0 = super()._do_aa(clip, y, x, **kwargs)

    self.field = 1
    aa1 = super()._do_aa(clip, y, x, **kwargs)

    self.field = original_field

    return self.merge_func(aa0, aa1)

get_aa_args 

get_aa_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
46
47
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    return dict(aa=self.aa_strength, order=0 if self.double_fps else self.field + 1) | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]

Retrieves arguments for single rating processing.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments.

Returns:

Source code 
287
288
289
290
291
292
293
294
295
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
49
50
51
52
53
54
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    interpolated = core.sangnom.SangNom(
        clip, dh=double_y or not self.drop_fields, **self.get_aa_args(clip, **kwargs) | kwargs
    )

    return self.shift_interpolate(clip, interpolated, double_y)

shift_interpolate 

shift_interpolate(
    clip: VideoNode, inter: VideoNode, double_y: bool
) -> ConstantFormatVideoNode

Applies a post-shifting interpolation operation to the interpolated clip.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • inter

    (VideoNode) –

    Interpolated clip.

  • double_y

    (bool) –

    Whether the height has been doubled

Returns:

  • ConstantFormatVideoNode –

    Shifted clip.

Source code 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

SangNomSR dataclass 

SangNomSR(
    aa_strength: int | Sequence[int] = 48,
    double_fps: bool = False,
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: SANGNOM, SingleRater

Concrete implementation of SANGNOM used as a single-rater.

Methods:

  • aa –
  • copy –

    Returns a new Antialiaser class replacing specified fields with new values

  • get_aa_args –
  • get_sr_args –

    Retrieves arguments for single rating processing.

  • interpolate –
  • shift_interpolate –

    Applies a post-shifting interpolation operation to the interpolated clip.

Attributes:

  • aa_strength (int | Sequence[int]) –

    The strength of luma anti-aliasing, applied to an 8-bit clip.

  • double_fps (bool) –

    Whether to double the frame rate of the clip.

  • drop_fields (bool) –

    Whether to discard the unused field based on the field setting.

  • field (int) –

    Controls the mode of operation and which field is kept in the resized image.

  • scaler (ScalerT | None) –

    Scaler used for additional scaling operations. If None, default to shifter

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

aa_strength class-attribute instance-attribute 

aa_strength: int | Sequence[int] = 48

The strength of luma anti-aliasing, applied to an 8-bit clip. Must be an integer between 0 and 128, inclusive.

double_fps class-attribute instance-attribute 

double_fps: bool = False

Whether to double the frame rate of the clip.

drop_fields class-attribute instance-attribute 

drop_fields: bool = True

Whether to discard the unused field based on the field setting.

field class-attribute instance-attribute 

field: int = 0

Controls the mode of operation and which field is kept in the resized image. - 0: Same rate, keeps the bottom field. - 1: Same rate, keeps the top field. - 2: Double rate (alternates each frame), starts with the bottom field. - 3: Double rate (alternates each frame), starts with the top field.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

Scaler used for additional scaling operations. If None, default to shifter

shifter class-attribute instance-attribute 

shifter: KernelT = Catrom

Kernel used for shifting operations. Default to Catrom.

transpose_first class-attribute instance-attribute 

transpose_first: bool = False

Transpose the clip before any operation.

aa 

aa(
    clip: VideoNode, y: bool = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode, dir: AADirection = BOTH, /, **kwargs: Any
) -> ConstantFormatVideoNode

aa(
    clip: VideoNode,
    y_or_dir: bool | AADirection = True,
    x: bool = True,
    /,
    **kwargs: Any,
) -> ConstantFormatVideoNode
Source code 
324
325
326
327
328
329
330
331
332
333
334
def aa(
    self, clip: vs.VideoNode, y_or_dir: bool | AADirection = True, x: bool = True, /, **kwargs: Any
) -> ConstantFormatVideoNode:
    if isinstance(y_or_dir, AADirection):
        y, x = y_or_dir.to_yx()
    else:
        y = y_or_dir

    clip = self._preprocess_clip(clip)

    return self._do_aa(clip, y, x, **kwargs)

copy 

copy(**kwargs: Any) -> Self

Returns a new Antialiaser class replacing specified fields with new values

Source code 
137
138
139
def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

get_aa_args 

get_aa_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
46
47
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    return dict(aa=self.aa_strength, order=0 if self.double_fps else self.field + 1) | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]

Retrieves arguments for single rating processing.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments.

Returns:

Source code 
287
288
289
290
291
292
293
294
295
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for single rating processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
49
50
51
52
53
54
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    interpolated = core.sangnom.SangNom(
        clip, dh=double_y or not self.drop_fields, **self.get_aa_args(clip, **kwargs) | kwargs
    )

    return self.shift_interpolate(clip, interpolated, double_y)

shift_interpolate 

shift_interpolate(
    clip: VideoNode, inter: VideoNode, double_y: bool
) -> ConstantFormatVideoNode

Applies a post-shifting interpolation operation to the interpolated clip.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • inter

    (VideoNode) –

    Interpolated clip.

  • double_y

    (bool) –

    Whether the height has been doubled

Returns:

  • ConstantFormatVideoNode –

    Shifted clip.

Source code 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter

SangNomSS dataclass 

SangNomSS(
    aa_strength: int | Sequence[int] = 48,
    double_fps: bool = False,
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: SANGNOM, SuperSampler

Concrete implementation of SANGNOM used as a supersampler.

Methods:

  • copy –

    Returns a new Antialiaser class replacing specified fields with new values

  • get_aa_args –
  • get_ss_args –

    Retrieves arguments for super sampling processing.

  • interpolate –
  • scale –

    Scale the given clip using super sampling method.

  • shift_interpolate –

    Applies a post-shifting interpolation operation to the interpolated clip.

Attributes:

  • aa_strength (int | Sequence[int]) –

    The strength of luma anti-aliasing, applied to an 8-bit clip.

  • double_fps (bool) –

    Whether to double the frame rate of the clip.

  • drop_fields (bool) –

    Whether to discard the unused field based on the field setting.

  • field (int) –

    Controls the mode of operation and which field is kept in the resized image.

  • scaler (ScalerT | None) –

    Scaler used for additional scaling operations. If None, default to shifter

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

aa_strength class-attribute instance-attribute 

aa_strength: int | Sequence[int] = 48

The strength of luma anti-aliasing, applied to an 8-bit clip. Must be an integer between 0 and 128, inclusive.

double_fps class-attribute instance-attribute 

double_fps: bool = False

Whether to double the frame rate of the clip.

drop_fields class-attribute instance-attribute 

drop_fields: bool = True

Whether to discard the unused field based on the field setting.

field class-attribute instance-attribute 

field: int = 0

Controls the mode of operation and which field is kept in the resized image. - 0: Same rate, keeps the bottom field. - 1: Same rate, keeps the top field. - 2: Double rate (alternates each frame), starts with the bottom field. - 3: Double rate (alternates each frame), starts with the top field.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

Scaler used for additional scaling operations. If None, default to shifter

shifter class-attribute instance-attribute 

shifter: KernelT = Catrom

Kernel used for shifting operations. Default to Catrom.

transpose_first class-attribute instance-attribute 

transpose_first: bool = False

Transpose the clip before any operation.

copy 

copy(**kwargs: Any) -> Self

Returns a new Antialiaser class replacing specified fields with new values

Source code 
137
138
139
def copy(self, **kwargs: Any) -> Self:
    """Returns a new Antialiaser class replacing specified fields with new values"""
    return replace(self, **kwargs)

get_aa_args 

get_aa_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
46
47
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    return dict(aa=self.aa_strength, order=0 if self.double_fps else self.field + 1) | kwargs

get_ss_args 

get_ss_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]

Retrieves arguments for super sampling processing.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments.

Returns:

Source code 
178
179
180
181
182
183
184
185
186
def get_ss_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    """
    Retrieves arguments for super sampling processing.

    :param clip:        Source clip.
    :param **kwargs:    Additional arguments.
    :return:            Passed keyword arguments.
    """
    return kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
49
50
51
52
53
54
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    interpolated = core.sangnom.SangNom(
        clip, dh=double_y or not self.drop_fields, **self.get_aa_args(clip, **kwargs) | kwargs
    )

    return self.shift_interpolate(clip, interpolated, double_y)

scale 

scale(
    clip: VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> VideoNode

Scale the given clip using super sampling method.

Parameters:

  • clip

    (VideoNode) –

    The input clip to be scaled.

  • width

    (int | None, default: None ) –

    The target width for scaling. If None, the width of the input clip will be used.

  • height

    (int | None, default: None ) –

    The target height for scaling. If None, the height of the input clip will be used.

  • shift

    (tuple[TopShift, LeftShift], default: (0, 0) ) –

    A tuple representing the shift values for the y and x axes.

  • **kwargs

    (Any, default: {} ) –

    Additional arguments to be passed to the interpolate or full_interpolate methods.

Returns:

  • VideoNode –

    The scaled clip.

Source code 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
@inject_self.cached
def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    **kwargs: Any
) -> vs.VideoNode:
    """
    Scale the given clip using super sampling method.

    :param clip:        The input clip to be scaled.
    :param width:       The target width for scaling. If None, the width of the input clip will be used.
    :param height:      The target height for scaling. If None, the height of the input clip will be used.
    :param shift:       A tuple representing the shift values for the y and x axes.
    :param **kwargs:    Additional arguments to be passed to the `interpolate` or `full_interpolate` methods.

    :return:            The scaled clip.
    """
    assert check_progressive(clip, self.scale)

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

    if (clip.width, clip.height) == (width, height):
        return clip

    kwargs = self.get_aa_args(clip, **kwargs) | self.get_ss_args(clip, **kwargs) | kwargs

    divw, divh = (ceil(size) for size in (width / clip.width, height / clip.height))

    mult_x, mult_y = (int(log2(divs)) for divs in (divw, divh))

    cdivw, cdivh = 1 << clip.format.subsampling_w, 1 << clip.format.subsampling_h

    upscaled = clip

    def _transpose(before: bool, is_width: int, y: int, x: int) -> None:
        nonlocal upscaled

        before = self.transpose_first if before else not self.transpose_first

        if ((before or not y) if is_width else (before and x)):
            upscaled = upscaled.std.Transpose()

    for (y, x) in zip_longest([True] * mult_y, [True] * mult_x, fillvalue=False):
        if isinstance(self, _FullInterpolate) and self.is_full_interpolate_enabled(x, y):
            upscaled = self.full_interpolate(upscaled, y, x, **kwargs)
        else:
            for isx, val in enumerate([y, x]):
                if val:
                    _transpose(True, isx, y, x)

                    upscaled = self.interpolate(upscaled, True, **kwargs)

                    _transpose(False, isx, y, x)

        topshift = leftshift = cleftshift = ctopshift = 0.0

        if y and self._shift:
            topshift = ctopshift = self._shift

            if cdivw == 2 and cdivh == 2:
                ctopshift -= 0.125
            elif cdivw == 1 and cdivh == 2:
                ctopshift += 0.125

        cresshift = 0.0

        if x and self._shift:
            leftshift = cleftshift = self._shift

            if cdivw in {4, 2} and cdivh in {4, 2, 1}:
                cleftshift = self._shift + 0.5

                if cdivw == 4 and cdivh == 1:
                    cresshift = 0.125 * 1
                elif cdivw == 2 and cdivh == 2:
                    cresshift = 0.125 * 2
                elif cdivw == 2 and cdivh == 1:
                    cresshift = 0.125 * 3

                cleftshift -= cresshift

        if isinstance(self._shifter, NoShift):
            if upscaled.format.subsampling_h or upscaled.format.subsampling_w:
                upscaled = Catrom.shift(upscaled, 0, [0, cleftshift + cresshift])
        else:
            upscaled = self._shifter.shift(
                upscaled, [topshift, ctopshift], [leftshift, cleftshift]
            )

    return self._scaler.scale(upscaled, width, height, shift)

shift_interpolate 

shift_interpolate(
    clip: VideoNode, inter: VideoNode, double_y: bool
) -> ConstantFormatVideoNode

Applies a post-shifting interpolation operation to the interpolated clip.

Parameters:

  • clip

    (VideoNode) –

    Source clip.

  • inter

    (VideoNode) –

    Interpolated clip.

  • double_y

    (bool) –

    Whether the height has been doubled

Returns:

  • ConstantFormatVideoNode –

    Shifted clip.

Source code 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def shift_interpolate(
    self,
    clip: vs.VideoNode,
    inter: vs.VideoNode,
    double_y: bool,
) -> ConstantFormatVideoNode:
    """
    Applies a post-shifting interpolation operation to the interpolated clip.

    :param clip:        Source clip.
    :param inter:       Interpolated clip.
    :param double_y:    Whether the height has been doubled
    :return:            Shifted clip.
    """
    assert check_variable(clip, self.__class__)
    assert check_variable(inter, self.__class__)

    if not double_y and not self.drop_fields:
        shift = (self._shift * int(not self.field), 0)

        inter = self._scaler.scale(inter, clip.width, clip.height, shift)

        return self._post_interpolate(clip, inter, double_y)  # type: ignore[arg-type]

    return inter