Skip to content

eedi3

This module implements wrappers for the Enhanced Edge Directed Interpolation (3rd gen.)

Classes:

  • EEDI3 –

    Base class for EEDI3 interpolating methods.

  • Eedi3 –

    Full implementation of the EEDI3 anti-aliaser

  • Eedi3DR –

    Concrete implementation of EEDI3 used as a double-rater.

  • Eedi3SS –

    Concrete implementation of EEDI3 used as a supersampler.

EEDI3 dataclass 

EEDI3(
    alpha: float = 0.25,
    beta: float = 0.5,
    gamma: float = 40,
    nrad: int = 2,
    mdis: int = 20,
    ucubic: bool = True,
    cost3: bool = True,
    vcheck: int = 2,
    vthresh0: float = 32.0,
    vthresh1: float = 64.0,
    vthresh2: float = 4.0,
    opt: int | None = None,
    device: int = -1,
    opencl: bool = False,
    mclip: VideoNode | None = None,
    sclip_aa: (
        type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None
    ) = lambda: Nnedi3(),
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: Interpolater

Base class for EEDI3 interpolating methods.

Methods:

Attributes:

  • alpha (float) –

    Controls the weight given to connecting similar neighborhoods.

  • beta (float) –

    Controls the weight given to the vertical difference created by the interpolation.

  • cost3 (bool) –

    Defines the neighborhood cost function used to measure similarity.

  • device (int) –

    Specifies the target OpenCL device.

  • 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.

  • gamma (float) –

    Penalizes changes in interpolation direction.

  • mclip (VideoNode | None) –

    A mask used to apply edge-directed interpolation only to specified pixels.

  • mdis (int) –

    Sets the maximum connection radius. The valid range is [1, 40].

  • nrad (int) –

    Sets the radius used for computing neighborhood similarity. The valid range is [0, 3].

  • opencl (bool) –

    Enables the use of the OpenCL variant for processing.

  • opt (int | None) –

    Specifies the CPU optimizations to use during processing.

  • scaler (ScalerT | None) –

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

  • sclip_aa (type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None) –

    Provides additional control over the interpolation by using a reference clip.

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

  • ucubic (bool) –

    Determines the type of interpolation used.

  • vcheck (int) –

    Defines the reliability check level for the resulting interpolation. The possible values are:

  • vthresh0 (float) –

    Threshold used to calculate the reliability for the first difference.

  • vthresh1 (float) –

    Threshold used for the second difference.

  • vthresh2 (float) –

    Threshold used to control the weighting of the interpolation direction.

alpha class-attribute instance-attribute 

alpha: float = 0.25

Controls the weight given to connecting similar neighborhoods. It must be in the range [0, 1]. A larger value for alpha will connect more lines and edges. Increasing alpha prioritizes connecting similar regions, which can reduce artifacts but may lead to excessive connections.

beta class-attribute instance-attribute 

beta: float = 0.5

Controls the weight given to the vertical difference created by the interpolation. It must also be in the range [0, 1], and the sum of alpha and beta must not exceed 1. A larger value for beta will reduce the number of connected lines and edges, making the result less directed by edges. At a value of 1.0, there will be no edge-directed interpolation at all.

cost3 class-attribute instance-attribute 

cost3: bool = True

Defines the neighborhood cost function used to measure similarity. - When cost3=True, a 3-neighborhood cost function is used. - When cost3=False, a 1-neighborhood cost function is applied.

device class-attribute instance-attribute 

device: int = -1

Specifies the target OpenCL device. The default value (-1) triggers auto-detection of the available device.

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.

gamma class-attribute instance-attribute 

gamma: float = 40

Penalizes changes in interpolation direction. The larger the value of gamma, the smoother the interpolation field will be between two lines. The range for gamma is [0, ∞]. Increasing gamma results in a smoother interpolation between lines but may reduce the sharpness of edges.

If lines are not connecting properly, try increasing alpha and possibly decreasing beta/gamma. If unwanted artifacts occur, reduce alpha and consider increasing beta or gamma.

mclip class-attribute instance-attribute 

mclip: VideoNode | None = None

A mask used to apply edge-directed interpolation only to specified pixels. Pixels where the mask value is 0 will be interpolated using cubic linear or bicubic methods instead. The primary purpose of the mask is to reduce computational overhead by limiting edge-directed interpolation to certain pixels.

mdis class-attribute instance-attribute 

mdis: int = 20

Sets the maximum connection radius. The valid range is [1, 40]. For example, with mdis=20, when interpolating the pixel at (50, 10) (x, y), the farthest connections allowed would be between (30, 9)/(70, 11) and (70, 9)/(30, 11). Larger values for mdis will allow connecting lines with smaller slopes, but this can also increase the chance of artifacts and slow down processing.

nrad class-attribute instance-attribute 

nrad: int = 2

Sets the radius used for computing neighborhood similarity. The valid range is [0, 3]. A larger value for nrad will consider a wider neighborhood for similarity, which can improve edge connections but may also increase processing time.

opencl class-attribute instance-attribute 

opencl: bool = False

Enables the use of the OpenCL variant for processing. Note that in most cases, OpenCL may be slower than the CPU version.

opt class-attribute instance-attribute 

opt: int | None = None

Specifies the CPU optimizations to use during processing. The possible values are:

  • None = Auto-adjust based on whether mclip is used.
  • 0 = Auto-detect the optimal optimization based on the CPU.
  • 1 = Use standard C implementation.
  • 2 = Use SSE2.
  • 3 = Use SSE4.1.
  • 4 = Use AVX.
  • 5 = Use AVX512.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

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

sclip_aa class-attribute instance-attribute 

sclip_aa: type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None = (
    field(default_factory=lambda: Nnedi3)
)

Provides additional control over the interpolation by using a reference clip. If set to None, vertical cubic interpolation is used as a fallback method instead.

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.

ucubic class-attribute instance-attribute 

ucubic: bool = True

Determines the type of interpolation used. - When ucubic=True, cubic 4-point interpolation is applied. - When ucubic=False, 2-point linear interpolation is used.

vcheck class-attribute instance-attribute 

vcheck: int = 2

Defines the reliability check level for the resulting interpolation. The possible values are: - 0: No reliability check - 1: Weak reliability check - 2: Medium reliability check - 3: Strong reliability check

vthresh0 class-attribute instance-attribute 

vthresh0: float = 32.0

Threshold used to calculate the reliability for the first difference.

vthresh1 class-attribute instance-attribute 

vthresh1: float = 64.0

Threshold used for the second difference.

vthresh2 class-attribute instance-attribute 

vthresh2: float = 4.0

Threshold used to control the weighting of the interpolation direction.

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 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    args = dict(
        alpha=self.alpha, beta=self.beta, gamma=self.gamma,
        nrad=self.nrad, mdis=self.mdis,
        ucubic=self.ucubic, cost3=self.cost3,
        vcheck=self.vcheck,
        vthresh0=self.vthresh0, vthresh1=self.vthresh1, vthresh2=self.vthresh2
    )

    if self.opencl:
        args.update(device=self.device)
    elif self.mclip is not None or kwargs.get('mclip'):
        # opt=3 appears to always give reliable speed boosts if mclip is used.
        args.update(opt=fallback(kwargs.pop('opt', None), self.opt, 3))

    return args | kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
185
186
187
188
189
190
191
192
193
194
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    aa_kwargs = self.get_aa_args(clip, **kwargs)
    aa_kwargs = self._handle_sclip(clip, double_y, aa_kwargs, **kwargs)

    if self.opencl:
        interpolated = core.eedi3m.EEDI3CL(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)
    else:
        interpolated = core.eedi3m.EEDI3(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)

    return self.shift_interpolate(clip, interpolated, double_y, **kwargs)

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

Eedi3 dataclass 

Eedi3(
    alpha: float = 0.25,
    beta: float = 0.5,
    gamma: float = 40,
    nrad: int = 2,
    mdis: int = 20,
    ucubic: bool = True,
    cost3: bool = True,
    vcheck: int = 2,
    vthresh0: float = 32.0,
    vthresh1: float = 64.0,
    vthresh2: float = 4.0,
    opt: int | None = None,
    device: int = -1,
    opencl: bool = False,
    mclip: VideoNode | None = None,
    sclip_aa: (
        type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None
    ) = lambda: Nnedi3(),
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: Eedi3DR, Eedi3SS, Antialiaser

Full implementation of the EEDI3 anti-aliaser

Methods:

Attributes:

  • alpha (float) –

    Controls the weight given to connecting similar neighborhoods.

  • beta (float) –

    Controls the weight given to the vertical difference created by the interpolation.

  • cost3 (bool) –

    Defines the neighborhood cost function used to measure similarity.

  • device (int) –

    Specifies the target OpenCL device.

  • 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.

  • gamma (float) –

    Penalizes changes in interpolation direction.

  • mclip (VideoNode | None) –

    A mask used to apply edge-directed interpolation only to specified pixels.

  • mdis (int) –

    Sets the maximum connection radius. The valid range is [1, 40].

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

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

  • nrad (int) –

    Sets the radius used for computing neighborhood similarity. The valid range is [0, 3].

  • opencl (bool) –

    Enables the use of the OpenCL variant for processing.

  • opt (int | None) –

    Specifies the CPU optimizations to use during processing.

  • scaler (ScalerT | None) –

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

  • sclip_aa (type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None) –

    Provides additional control over the interpolation by using a reference clip.

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

  • ucubic (bool) –

    Determines the type of interpolation used.

  • vcheck (int) –

    Defines the reliability check level for the resulting interpolation. The possible values are:

  • vthresh0 (float) –

    Threshold used to calculate the reliability for the first difference.

  • vthresh1 (float) –

    Threshold used for the second difference.

  • vthresh2 (float) –

    Threshold used to control the weighting of the interpolation direction.

alpha class-attribute instance-attribute 

alpha: float = 0.25

Controls the weight given to connecting similar neighborhoods. It must be in the range [0, 1]. A larger value for alpha will connect more lines and edges. Increasing alpha prioritizes connecting similar regions, which can reduce artifacts but may lead to excessive connections.

beta class-attribute instance-attribute 

beta: float = 0.5

Controls the weight given to the vertical difference created by the interpolation. It must also be in the range [0, 1], and the sum of alpha and beta must not exceed 1. A larger value for beta will reduce the number of connected lines and edges, making the result less directed by edges. At a value of 1.0, there will be no edge-directed interpolation at all.

cost3 class-attribute instance-attribute 

cost3: bool = True

Defines the neighborhood cost function used to measure similarity. - When cost3=True, a 3-neighborhood cost function is used. - When cost3=False, a 1-neighborhood cost function is applied.

device class-attribute instance-attribute 

device: int = -1

Specifies the target OpenCL device. The default value (-1) triggers auto-detection of the available device.

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.

gamma class-attribute instance-attribute 

gamma: float = 40

Penalizes changes in interpolation direction. The larger the value of gamma, the smoother the interpolation field will be between two lines. The range for gamma is [0, ∞]. Increasing gamma results in a smoother interpolation between lines but may reduce the sharpness of edges.

If lines are not connecting properly, try increasing alpha and possibly decreasing beta/gamma. If unwanted artifacts occur, reduce alpha and consider increasing beta or gamma.

mclip class-attribute instance-attribute 

mclip: VideoNode | None = None

A mask used to apply edge-directed interpolation only to specified pixels. Pixels where the mask value is 0 will be interpolated using cubic linear or bicubic methods instead. The primary purpose of the mask is to reduce computational overhead by limiting edge-directed interpolation to certain pixels.

mdis class-attribute instance-attribute 

mdis: int = 20

Sets the maximum connection radius. The valid range is [1, 40]. For example, with mdis=20, when interpolating the pixel at (50, 10) (x, y), the farthest connections allowed would be between (30, 9)/(70, 11) and (70, 9)/(30, 11). Larger values for mdis will allow connecting lines with smaller slopes, but this can also increase the chance of artifacts and slow down processing.

merge_func class-attribute instance-attribute 

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

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

nrad class-attribute instance-attribute 

nrad: int = 2

Sets the radius used for computing neighborhood similarity. The valid range is [0, 3]. A larger value for nrad will consider a wider neighborhood for similarity, which can improve edge connections but may also increase processing time.

opencl class-attribute instance-attribute 

opencl: bool = False

Enables the use of the OpenCL variant for processing. Note that in most cases, OpenCL may be slower than the CPU version.

opt class-attribute instance-attribute 

opt: int | None = None

Specifies the CPU optimizations to use during processing. The possible values are:

  • None = Auto-adjust based on whether mclip is used.
  • 0 = Auto-detect the optimal optimization based on the CPU.
  • 1 = Use standard C implementation.
  • 2 = Use SSE2.
  • 3 = Use SSE4.1.
  • 4 = Use AVX.
  • 5 = Use AVX512.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

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

sclip_aa class-attribute instance-attribute 

sclip_aa: type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None = (
    field(default_factory=lambda: Nnedi3)
)

Provides additional control over the interpolation by using a reference clip. If set to None, vertical cubic interpolation is used as a fallback method instead.

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.

ucubic class-attribute instance-attribute 

ucubic: bool = True

Determines the type of interpolation used. - When ucubic=True, cubic 4-point interpolation is applied. - When ucubic=False, 2-point linear interpolation is used.

vcheck class-attribute instance-attribute 

vcheck: int = 2

Defines the reliability check level for the resulting interpolation. The possible values are: - 0: No reliability check - 1: Weak reliability check - 2: Medium reliability check - 3: Strong reliability check

vthresh0 class-attribute instance-attribute 

vthresh0: float = 32.0

Threshold used to calculate the reliability for the first difference.

vthresh1 class-attribute instance-attribute 

vthresh1: float = 64.0

Threshold used for the second difference.

vthresh2 class-attribute instance-attribute 

vthresh2: float = 4.0

Threshold used to control the weighting of the interpolation direction.

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 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    args = dict(
        alpha=self.alpha, beta=self.beta, gamma=self.gamma,
        nrad=self.nrad, mdis=self.mdis,
        ucubic=self.ucubic, cost3=self.cost3,
        vcheck=self.vcheck,
        vthresh0=self.vthresh0, vthresh1=self.vthresh1, vthresh2=self.vthresh2
    )

    if self.opencl:
        args.update(device=self.device)
    elif self.mclip is not None or kwargs.get('mclip'):
        # opt=3 appears to always give reliable speed boosts if mclip is used.
        args.update(opt=fallback(kwargs.pop('opt', None), self.opt, 3))

    return args | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
242
243
244
245
246
247
248
249
250
251
252
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    if not self.mclip:
        return {}

    if not self._mclips:
        self._mclips = (self.mclip, self.mclip.std.Transpose())

    if self.mclip.width == clip.width and self.mclip.height == clip.height:
        return dict(mclip=self._mclips[0]) | kwargs

    return dict(mclip=self._mclips[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 
185
186
187
188
189
190
191
192
193
194
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    aa_kwargs = self.get_aa_args(clip, **kwargs)
    aa_kwargs = self._handle_sclip(clip, double_y, aa_kwargs, **kwargs)

    if self.opencl:
        interpolated = core.eedi3m.EEDI3CL(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)
    else:
        interpolated = core.eedi3m.EEDI3(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)

    return self.shift_interpolate(clip, interpolated, double_y, **kwargs)

kernel_radius 

kernel_radius() -> int
Source code 
232
233
234
@inject_self.cached.property
def kernel_radius(self) -> int:
    return self.nrad

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

Eedi3DR dataclass 

Eedi3DR(
    alpha: float = 0.25,
    beta: float = 0.5,
    gamma: float = 40,
    nrad: int = 2,
    mdis: int = 20,
    ucubic: bool = True,
    cost3: bool = True,
    vcheck: int = 2,
    vthresh0: float = 32.0,
    vthresh1: float = 64.0,
    vthresh2: float = 4.0,
    opt: int | None = None,
    device: int = -1,
    opencl: bool = False,
    mclip: VideoNode | None = None,
    sclip_aa: (
        type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None
    ) = lambda: Nnedi3(),
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: Eedi3SR, DoubleRater

Concrete implementation of EEDI3 used as a double-rater.

Methods:

Attributes:

  • alpha (float) –

    Controls the weight given to connecting similar neighborhoods.

  • beta (float) –

    Controls the weight given to the vertical difference created by the interpolation.

  • cost3 (bool) –

    Defines the neighborhood cost function used to measure similarity.

  • device (int) –

    Specifies the target OpenCL device.

  • 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.

  • gamma (float) –

    Penalizes changes in interpolation direction.

  • mclip (VideoNode | None) –

    A mask used to apply edge-directed interpolation only to specified pixels.

  • mdis (int) –

    Sets the maximum connection radius. The valid range is [1, 40].

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

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

  • nrad (int) –

    Sets the radius used for computing neighborhood similarity. The valid range is [0, 3].

  • opencl (bool) –

    Enables the use of the OpenCL variant for processing.

  • opt (int | None) –

    Specifies the CPU optimizations to use during processing.

  • scaler (ScalerT | None) –

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

  • sclip_aa (type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None) –

    Provides additional control over the interpolation by using a reference clip.

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

  • ucubic (bool) –

    Determines the type of interpolation used.

  • vcheck (int) –

    Defines the reliability check level for the resulting interpolation. The possible values are:

  • vthresh0 (float) –

    Threshold used to calculate the reliability for the first difference.

  • vthresh1 (float) –

    Threshold used for the second difference.

  • vthresh2 (float) –

    Threshold used to control the weighting of the interpolation direction.

alpha class-attribute instance-attribute 

alpha: float = 0.25

Controls the weight given to connecting similar neighborhoods. It must be in the range [0, 1]. A larger value for alpha will connect more lines and edges. Increasing alpha prioritizes connecting similar regions, which can reduce artifacts but may lead to excessive connections.

beta class-attribute instance-attribute 

beta: float = 0.5

Controls the weight given to the vertical difference created by the interpolation. It must also be in the range [0, 1], and the sum of alpha and beta must not exceed 1. A larger value for beta will reduce the number of connected lines and edges, making the result less directed by edges. At a value of 1.0, there will be no edge-directed interpolation at all.

cost3 class-attribute instance-attribute 

cost3: bool = True

Defines the neighborhood cost function used to measure similarity. - When cost3=True, a 3-neighborhood cost function is used. - When cost3=False, a 1-neighborhood cost function is applied.

device class-attribute instance-attribute 

device: int = -1

Specifies the target OpenCL device. The default value (-1) triggers auto-detection of the available device.

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.

gamma class-attribute instance-attribute 

gamma: float = 40

Penalizes changes in interpolation direction. The larger the value of gamma, the smoother the interpolation field will be between two lines. The range for gamma is [0, ∞]. Increasing gamma results in a smoother interpolation between lines but may reduce the sharpness of edges.

If lines are not connecting properly, try increasing alpha and possibly decreasing beta/gamma. If unwanted artifacts occur, reduce alpha and consider increasing beta or gamma.

mclip class-attribute instance-attribute 

mclip: VideoNode | None = None

A mask used to apply edge-directed interpolation only to specified pixels. Pixels where the mask value is 0 will be interpolated using cubic linear or bicubic methods instead. The primary purpose of the mask is to reduce computational overhead by limiting edge-directed interpolation to certain pixels.

mdis class-attribute instance-attribute 

mdis: int = 20

Sets the maximum connection radius. The valid range is [1, 40]. For example, with mdis=20, when interpolating the pixel at (50, 10) (x, y), the farthest connections allowed would be between (30, 9)/(70, 11) and (70, 9)/(30, 11). Larger values for mdis will allow connecting lines with smaller slopes, but this can also increase the chance of artifacts and slow down processing.

merge_func class-attribute instance-attribute 

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

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

nrad class-attribute instance-attribute 

nrad: int = 2

Sets the radius used for computing neighborhood similarity. The valid range is [0, 3]. A larger value for nrad will consider a wider neighborhood for similarity, which can improve edge connections but may also increase processing time.

opencl class-attribute instance-attribute 

opencl: bool = False

Enables the use of the OpenCL variant for processing. Note that in most cases, OpenCL may be slower than the CPU version.

opt class-attribute instance-attribute 

opt: int | None = None

Specifies the CPU optimizations to use during processing. The possible values are:

  • None = Auto-adjust based on whether mclip is used.
  • 0 = Auto-detect the optimal optimization based on the CPU.
  • 1 = Use standard C implementation.
  • 2 = Use SSE2.
  • 3 = Use SSE4.1.
  • 4 = Use AVX.
  • 5 = Use AVX512.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

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

sclip_aa class-attribute instance-attribute 

sclip_aa: type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None = (
    field(default_factory=lambda: Nnedi3)
)

Provides additional control over the interpolation by using a reference clip. If set to None, vertical cubic interpolation is used as a fallback method instead.

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.

ucubic class-attribute instance-attribute 

ucubic: bool = True

Determines the type of interpolation used. - When ucubic=True, cubic 4-point interpolation is applied. - When ucubic=False, 2-point linear interpolation is used.

vcheck class-attribute instance-attribute 

vcheck: int = 2

Defines the reliability check level for the resulting interpolation. The possible values are: - 0: No reliability check - 1: Weak reliability check - 2: Medium reliability check - 3: Strong reliability check

vthresh0 class-attribute instance-attribute 

vthresh0: float = 32.0

Threshold used to calculate the reliability for the first difference.

vthresh1 class-attribute instance-attribute 

vthresh1: float = 64.0

Threshold used for the second difference.

vthresh2 class-attribute instance-attribute 

vthresh2: float = 4.0

Threshold used to control the weighting of the interpolation direction.

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 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    args = dict(
        alpha=self.alpha, beta=self.beta, gamma=self.gamma,
        nrad=self.nrad, mdis=self.mdis,
        ucubic=self.ucubic, cost3=self.cost3,
        vcheck=self.vcheck,
        vthresh0=self.vthresh0, vthresh1=self.vthresh1, vthresh2=self.vthresh2
    )

    if self.opencl:
        args.update(device=self.device)
    elif self.mclip is not None or kwargs.get('mclip'):
        # opt=3 appears to always give reliable speed boosts if mclip is used.
        args.update(opt=fallback(kwargs.pop('opt', None), self.opt, 3))

    return args | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
242
243
244
245
246
247
248
249
250
251
252
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    if not self.mclip:
        return {}

    if not self._mclips:
        self._mclips = (self.mclip, self.mclip.std.Transpose())

    if self.mclip.width == clip.width and self.mclip.height == clip.height:
        return dict(mclip=self._mclips[0]) | kwargs

    return dict(mclip=self._mclips[1]) | kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
185
186
187
188
189
190
191
192
193
194
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    aa_kwargs = self.get_aa_args(clip, **kwargs)
    aa_kwargs = self._handle_sclip(clip, double_y, aa_kwargs, **kwargs)

    if self.opencl:
        interpolated = core.eedi3m.EEDI3CL(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)
    else:
        interpolated = core.eedi3m.EEDI3(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)

    return self.shift_interpolate(clip, interpolated, double_y, **kwargs)

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

Eedi3SR dataclass 

Eedi3SR(
    alpha: float = 0.25,
    beta: float = 0.5,
    gamma: float = 40,
    nrad: int = 2,
    mdis: int = 20,
    ucubic: bool = True,
    cost3: bool = True,
    vcheck: int = 2,
    vthresh0: float = 32.0,
    vthresh1: float = 64.0,
    vthresh2: float = 4.0,
    opt: int | None = None,
    device: int = -1,
    opencl: bool = False,
    mclip: VideoNode | None = None,
    sclip_aa: (
        type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None
    ) = lambda: Nnedi3(),
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: EEDI3, SingleRater, vs_object

Concrete implementation of EEDI3 used as a single-rater.

Methods:

Attributes:

  • alpha (float) –

    Controls the weight given to connecting similar neighborhoods.

  • beta (float) –

    Controls the weight given to the vertical difference created by the interpolation.

  • cost3 (bool) –

    Defines the neighborhood cost function used to measure similarity.

  • device (int) –

    Specifies the target OpenCL device.

  • 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.

  • gamma (float) –

    Penalizes changes in interpolation direction.

  • mclip (VideoNode | None) –

    A mask used to apply edge-directed interpolation only to specified pixels.

  • mdis (int) –

    Sets the maximum connection radius. The valid range is [1, 40].

  • nrad (int) –

    Sets the radius used for computing neighborhood similarity. The valid range is [0, 3].

  • opencl (bool) –

    Enables the use of the OpenCL variant for processing.

  • opt (int | None) –

    Specifies the CPU optimizations to use during processing.

  • scaler (ScalerT | None) –

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

  • sclip_aa (type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None) –

    Provides additional control over the interpolation by using a reference clip.

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

  • ucubic (bool) –

    Determines the type of interpolation used.

  • vcheck (int) –

    Defines the reliability check level for the resulting interpolation. The possible values are:

  • vthresh0 (float) –

    Threshold used to calculate the reliability for the first difference.

  • vthresh1 (float) –

    Threshold used for the second difference.

  • vthresh2 (float) –

    Threshold used to control the weighting of the interpolation direction.

alpha class-attribute instance-attribute 

alpha: float = 0.25

Controls the weight given to connecting similar neighborhoods. It must be in the range [0, 1]. A larger value for alpha will connect more lines and edges. Increasing alpha prioritizes connecting similar regions, which can reduce artifacts but may lead to excessive connections.

beta class-attribute instance-attribute 

beta: float = 0.5

Controls the weight given to the vertical difference created by the interpolation. It must also be in the range [0, 1], and the sum of alpha and beta must not exceed 1. A larger value for beta will reduce the number of connected lines and edges, making the result less directed by edges. At a value of 1.0, there will be no edge-directed interpolation at all.

cost3 class-attribute instance-attribute 

cost3: bool = True

Defines the neighborhood cost function used to measure similarity. - When cost3=True, a 3-neighborhood cost function is used. - When cost3=False, a 1-neighborhood cost function is applied.

device class-attribute instance-attribute 

device: int = -1

Specifies the target OpenCL device. The default value (-1) triggers auto-detection of the available device.

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.

gamma class-attribute instance-attribute 

gamma: float = 40

Penalizes changes in interpolation direction. The larger the value of gamma, the smoother the interpolation field will be between two lines. The range for gamma is [0, ∞]. Increasing gamma results in a smoother interpolation between lines but may reduce the sharpness of edges.

If lines are not connecting properly, try increasing alpha and possibly decreasing beta/gamma. If unwanted artifacts occur, reduce alpha and consider increasing beta or gamma.

mclip class-attribute instance-attribute 

mclip: VideoNode | None = None

A mask used to apply edge-directed interpolation only to specified pixels. Pixels where the mask value is 0 will be interpolated using cubic linear or bicubic methods instead. The primary purpose of the mask is to reduce computational overhead by limiting edge-directed interpolation to certain pixels.

mdis class-attribute instance-attribute 

mdis: int = 20

Sets the maximum connection radius. The valid range is [1, 40]. For example, with mdis=20, when interpolating the pixel at (50, 10) (x, y), the farthest connections allowed would be between (30, 9)/(70, 11) and (70, 9)/(30, 11). Larger values for mdis will allow connecting lines with smaller slopes, but this can also increase the chance of artifacts and slow down processing.

nrad class-attribute instance-attribute 

nrad: int = 2

Sets the radius used for computing neighborhood similarity. The valid range is [0, 3]. A larger value for nrad will consider a wider neighborhood for similarity, which can improve edge connections but may also increase processing time.

opencl class-attribute instance-attribute 

opencl: bool = False

Enables the use of the OpenCL variant for processing. Note that in most cases, OpenCL may be slower than the CPU version.

opt class-attribute instance-attribute 

opt: int | None = None

Specifies the CPU optimizations to use during processing. The possible values are:

  • None = Auto-adjust based on whether mclip is used.
  • 0 = Auto-detect the optimal optimization based on the CPU.
  • 1 = Use standard C implementation.
  • 2 = Use SSE2.
  • 3 = Use SSE4.1.
  • 4 = Use AVX.
  • 5 = Use AVX512.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

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

sclip_aa class-attribute instance-attribute 

sclip_aa: type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None = (
    field(default_factory=lambda: Nnedi3)
)

Provides additional control over the interpolation by using a reference clip. If set to None, vertical cubic interpolation is used as a fallback method instead.

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.

ucubic class-attribute instance-attribute 

ucubic: bool = True

Determines the type of interpolation used. - When ucubic=True, cubic 4-point interpolation is applied. - When ucubic=False, 2-point linear interpolation is used.

vcheck class-attribute instance-attribute 

vcheck: int = 2

Defines the reliability check level for the resulting interpolation. The possible values are: - 0: No reliability check - 1: Weak reliability check - 2: Medium reliability check - 3: Strong reliability check

vthresh0 class-attribute instance-attribute 

vthresh0: float = 32.0

Threshold used to calculate the reliability for the first difference.

vthresh1 class-attribute instance-attribute 

vthresh1: float = 64.0

Threshold used for the second difference.

vthresh2 class-attribute instance-attribute 

vthresh2: float = 4.0

Threshold used to control the weighting of the interpolation direction.

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 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    args = dict(
        alpha=self.alpha, beta=self.beta, gamma=self.gamma,
        nrad=self.nrad, mdis=self.mdis,
        ucubic=self.ucubic, cost3=self.cost3,
        vcheck=self.vcheck,
        vthresh0=self.vthresh0, vthresh1=self.vthresh1, vthresh2=self.vthresh2
    )

    if self.opencl:
        args.update(device=self.device)
    elif self.mclip is not None or kwargs.get('mclip'):
        # opt=3 appears to always give reliable speed boosts if mclip is used.
        args.update(opt=fallback(kwargs.pop('opt', None), self.opt, 3))

    return args | kwargs

get_sr_args 

get_sr_args(clip: VideoNode, **kwargs: Any) -> dict[str, Any]
Source code 
242
243
244
245
246
247
248
249
250
251
252
def get_sr_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    if not self.mclip:
        return {}

    if not self._mclips:
        self._mclips = (self.mclip, self.mclip.std.Transpose())

    if self.mclip.width == clip.width and self.mclip.height == clip.height:
        return dict(mclip=self._mclips[0]) | kwargs

    return dict(mclip=self._mclips[1]) | kwargs

interpolate 

interpolate(
    clip: VideoNode, double_y: bool, **kwargs: Any
) -> ConstantFormatVideoNode
Source code 
185
186
187
188
189
190
191
192
193
194
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    aa_kwargs = self.get_aa_args(clip, **kwargs)
    aa_kwargs = self._handle_sclip(clip, double_y, aa_kwargs, **kwargs)

    if self.opencl:
        interpolated = core.eedi3m.EEDI3CL(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)
    else:
        interpolated = core.eedi3m.EEDI3(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)

    return self.shift_interpolate(clip, interpolated, double_y, **kwargs)

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

Eedi3SS dataclass 

Eedi3SS(
    alpha: float = 0.25,
    beta: float = 0.5,
    gamma: float = 40,
    nrad: int = 2,
    mdis: int = 20,
    ucubic: bool = True,
    cost3: bool = True,
    vcheck: int = 2,
    vthresh0: float = 32.0,
    vthresh1: float = 64.0,
    vthresh2: float = 4.0,
    opt: int | None = None,
    device: int = -1,
    opencl: bool = False,
    mclip: VideoNode | None = None,
    sclip_aa: (
        type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None
    ) = lambda: Nnedi3(),
    *,
    field: int = 0,
    drop_fields: bool = True,
    transpose_first: bool = False,
    shifter: KernelT = Catrom,
    scaler: ScalerT | None = None
)

Bases: EEDI3, SuperSampler

Concrete implementation of EEDI3 used as a supersampler.

Methods:

Attributes:

  • alpha (float) –

    Controls the weight given to connecting similar neighborhoods.

  • beta (float) –

    Controls the weight given to the vertical difference created by the interpolation.

  • cost3 (bool) –

    Defines the neighborhood cost function used to measure similarity.

  • device (int) –

    Specifies the target OpenCL device.

  • 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.

  • gamma (float) –

    Penalizes changes in interpolation direction.

  • mclip (VideoNode | None) –

    A mask used to apply edge-directed interpolation only to specified pixels.

  • mdis (int) –

    Sets the maximum connection radius. The valid range is [1, 40].

  • nrad (int) –

    Sets the radius used for computing neighborhood similarity. The valid range is [0, 3].

  • opencl (bool) –

    Enables the use of the OpenCL variant for processing.

  • opt (int | None) –

    Specifies the CPU optimizations to use during processing.

  • scaler (ScalerT | None) –

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

  • sclip_aa (type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None) –

    Provides additional control over the interpolation by using a reference clip.

  • shifter (KernelT) –

    Kernel used for shifting operations. Default to Catrom.

  • transpose_first (bool) –

    Transpose the clip before any operation.

  • ucubic (bool) –

    Determines the type of interpolation used.

  • vcheck (int) –

    Defines the reliability check level for the resulting interpolation. The possible values are:

  • vthresh0 (float) –

    Threshold used to calculate the reliability for the first difference.

  • vthresh1 (float) –

    Threshold used for the second difference.

  • vthresh2 (float) –

    Threshold used to control the weighting of the interpolation direction.

alpha class-attribute instance-attribute 

alpha: float = 0.25

Controls the weight given to connecting similar neighborhoods. It must be in the range [0, 1]. A larger value for alpha will connect more lines and edges. Increasing alpha prioritizes connecting similar regions, which can reduce artifacts but may lead to excessive connections.

beta class-attribute instance-attribute 

beta: float = 0.5

Controls the weight given to the vertical difference created by the interpolation. It must also be in the range [0, 1], and the sum of alpha and beta must not exceed 1. A larger value for beta will reduce the number of connected lines and edges, making the result less directed by edges. At a value of 1.0, there will be no edge-directed interpolation at all.

cost3 class-attribute instance-attribute 

cost3: bool = True

Defines the neighborhood cost function used to measure similarity. - When cost3=True, a 3-neighborhood cost function is used. - When cost3=False, a 1-neighborhood cost function is applied.

device class-attribute instance-attribute 

device: int = -1

Specifies the target OpenCL device. The default value (-1) triggers auto-detection of the available device.

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.

gamma class-attribute instance-attribute 

gamma: float = 40

Penalizes changes in interpolation direction. The larger the value of gamma, the smoother the interpolation field will be between two lines. The range for gamma is [0, ∞]. Increasing gamma results in a smoother interpolation between lines but may reduce the sharpness of edges.

If lines are not connecting properly, try increasing alpha and possibly decreasing beta/gamma. If unwanted artifacts occur, reduce alpha and consider increasing beta or gamma.

mclip class-attribute instance-attribute 

mclip: VideoNode | None = None

A mask used to apply edge-directed interpolation only to specified pixels. Pixels where the mask value is 0 will be interpolated using cubic linear or bicubic methods instead. The primary purpose of the mask is to reduce computational overhead by limiting edge-directed interpolation to certain pixels.

mdis class-attribute instance-attribute 

mdis: int = 20

Sets the maximum connection radius. The valid range is [1, 40]. For example, with mdis=20, when interpolating the pixel at (50, 10) (x, y), the farthest connections allowed would be between (30, 9)/(70, 11) and (70, 9)/(30, 11). Larger values for mdis will allow connecting lines with smaller slopes, but this can also increase the chance of artifacts and slow down processing.

nrad class-attribute instance-attribute 

nrad: int = 2

Sets the radius used for computing neighborhood similarity. The valid range is [0, 3]. A larger value for nrad will consider a wider neighborhood for similarity, which can improve edge connections but may also increase processing time.

opencl class-attribute instance-attribute 

opencl: bool = False

Enables the use of the OpenCL variant for processing. Note that in most cases, OpenCL may be slower than the CPU version.

opt class-attribute instance-attribute 

opt: int | None = None

Specifies the CPU optimizations to use during processing. The possible values are:

  • None = Auto-adjust based on whether mclip is used.
  • 0 = Auto-detect the optimal optimization based on the CPU.
  • 1 = Use standard C implementation.
  • 2 = Use SSE2.
  • 3 = Use SSE4.1.
  • 4 = Use AVX.
  • 5 = Use AVX512.

scaler class-attribute instance-attribute 

scaler: ScalerT | None = None

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

sclip_aa class-attribute instance-attribute 

sclip_aa: type[Antialiaser] | Antialiaser | Literal[True] | VideoNode | None = (
    field(default_factory=lambda: Nnedi3)
)

Provides additional control over the interpolation by using a reference clip. If set to None, vertical cubic interpolation is used as a fallback method instead.

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.

ucubic class-attribute instance-attribute 

ucubic: bool = True

Determines the type of interpolation used. - When ucubic=True, cubic 4-point interpolation is applied. - When ucubic=False, 2-point linear interpolation is used.

vcheck class-attribute instance-attribute 

vcheck: int = 2

Defines the reliability check level for the resulting interpolation. The possible values are: - 0: No reliability check - 1: Weak reliability check - 2: Medium reliability check - 3: Strong reliability check

vthresh0 class-attribute instance-attribute 

vthresh0: float = 32.0

Threshold used to calculate the reliability for the first difference.

vthresh1 class-attribute instance-attribute 

vthresh1: float = 64.0

Threshold used for the second difference.

vthresh2 class-attribute instance-attribute 

vthresh2: float = 4.0

Threshold used to control the weighting of the interpolation direction.

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 
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
def get_aa_args(self, clip: vs.VideoNode, **kwargs: Any) -> dict[str, Any]:
    args = dict(
        alpha=self.alpha, beta=self.beta, gamma=self.gamma,
        nrad=self.nrad, mdis=self.mdis,
        ucubic=self.ucubic, cost3=self.cost3,
        vcheck=self.vcheck,
        vthresh0=self.vthresh0, vthresh1=self.vthresh1, vthresh2=self.vthresh2
    )

    if self.opencl:
        args.update(device=self.device)
    elif self.mclip is not None or kwargs.get('mclip'):
        # opt=3 appears to always give reliable speed boosts if mclip is used.
        args.update(opt=fallback(kwargs.pop('opt', None), self.opt, 3))

    return args | 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 
185
186
187
188
189
190
191
192
193
194
def interpolate(self, clip: vs.VideoNode, double_y: bool, **kwargs: Any) -> ConstantFormatVideoNode:
    aa_kwargs = self.get_aa_args(clip, **kwargs)
    aa_kwargs = self._handle_sclip(clip, double_y, aa_kwargs, **kwargs)

    if self.opencl:
        interpolated = core.eedi3m.EEDI3CL(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)
    else:
        interpolated = core.eedi3m.EEDI3(clip, self.field, double_y or not self.drop_fields, **aa_kwargs)

    return self.shift_interpolate(clip, interpolated, double_y, **kwargs)

kernel_radius 

kernel_radius() -> int
Source code 
232
233
234
@inject_self.cached.property
def kernel_radius(self) -> int:
    return self.nrad

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