complex ¶

def descale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool | None = None,
    sigmoid: bool | tuple[Slope, Center] = False,
    # ComplexDescaler adds border_handling, sample_grid_model, field_based,  ignore_mask and blur
    border_handling: int | BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: int | SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBasedT | None = None,
    ignore_mask: vs.VideoNode | None = None,
    blur: float | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Descale a clip to the given resolution, with image borders handling and sampling grid alignment,
    optionally using linear light processing.

    Supports both progressive and interlaced sources. When interlaced, it will separate fields,
    perform per-field descaling, and weave them back.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:                The source clip.
    :param width:               Target descaled width (defaults to clip width if None).
    :param height:              Target descaled height (defaults to clip height if None).
    :param shift:               Subpixel shift (top, left) or per-field shifts.
    :param linear:              Whether to linearize the input before descaling. If None, inferred from sigmoid.
    :param sigmoid:             Whether to use sigmoid transfer curve. Can be True, False, or a tuple of (slope, center).
                                `True` applies the defaults values (6.5, 0.75).
                                Keep in mind sigmoid slope has to be in range 1.0-20.0 (inclusive)
                                and sigmoid center has to be in range 0.0-1.0 (inclusive).
    :param border_handling:     Method for handling image borders during sampling.
    :param sample_grid_model:   Model used to align sampling grid.
    :param field_based:         Field-based processing mode (interlaced or progressive).
    :param ignore_mask:         Optional mask specifying areas to ignore during descaling.
    :param blur:                Amount of blur to apply during scaling.
    :param kwargs:              Additional arguments passed to `descale_function`.
    :return:                    The descaled video node, optionally processed in linear light.
    """
    width, height = self._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs.update(
        linear=linear,
        sigmoid=sigmoid,
        border_handling=BorderHandling.from_param(border_handling, self.descale),
        ignore_mask=ignore_mask,
        blur=blur
    )

    sample_grid_model = SampleGridModel(sample_grid_model)

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

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

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

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

        field_shift = 0.125 * height / clip.height

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

        descaled_tf = super().descale(
            fields[0::2],
            **de_kwargs_tf | dict(src_top=de_kwargs_tf.get("src_top", 0.0) + field_shift),
        )
        descaled_bf = super().descale(
            fields[1::2],
            **de_kwargs_bf | dict(src_top=de_kwargs_bf.get("src_top", 0.0) - field_shift),
        )
        interleaved = vs.core.std.Interleave([descaled_tf, descaled_bf])

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

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

        descaled = super().descale(clip, **self.get_descale_args(clip, shift, *de_base_args, **kwargs))

    return depth(descaled, bits)

@classmethod
def ensure_obj(
    cls,
    scaler: str | type[Self] | Self | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> Self:
    """
    Ensure that the input is a scaler instance, resolving it if necessary.

    :param scaler:          Scaler identifier (string, class, or instance).
    :param func_except:     Function returned for custom error handling.
    :return:                Scaler instance.
    """
    return _base_ensure_obj(cls, scaler, func_except)

@classmethod
def from_param(
    cls,
    scaler: str | type[Self] | Self | None = None,
    /,
    func_except: FuncExceptT | None = None,
) -> type[Self]:
    """
    Resolve and return a scaler type from a given input (string, type, or instance).

    :param scaler:          Scaler identifier (string, class, or instance).
    :param func_except:     Function returned for custom error handling.
    :return:                Resolved scaler type.
    """
    return _base_from_param(cls, scaler, cls._err_class, func_except)

def get_descale_args(
    self,
    clip: vs.VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Construct the argument dictionary used for descaling.

    :param clip:    The source clip.
    :param shift:   Subpixel shift (top, left).
    :param width:   Target width for descaling.
    :param height:  Target height for descaling.
    :param kwargs:  Extra keyword arguments to merge.
    :return:        Combined keyword argument dictionary.
    """
    return dict(width=width, height=height, src_top=shift[0], src_left=shift[1]) | self.kwargs | kwargs

def get_rescale_args(
    self,
    clip: vs.VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Construct the argument dictionary used for upscaling.

    :param clip:    The source clip.
    :param shift:   Subpixel shift (top, left).
    :param width:   Target width for upscaling.
    :param height:  Target height for upscaling.
    :param kwargs:  Extra keyword arguments to merge.
    :return:        Combined keyword argument dictionary.
    """
    return dict(width=width, height=height, src_top=shift[0], src_left=shift[1]) | self.kwargs | kwargs

@cached_property
def kernel_radius(self) -> int:
    """
    Return the effective kernel radius for the scaler.

    :raises CustomNotImplementedError:  If no kernel radius is defined.
    :return:                            Kernel radius.
    """
    ...

@cached_property
def pretty_string(self) -> str:
    """
    Cached property returning a user-friendly string representation.

    :return: Pretty-printed string with arguments.
    """
    return self._pretty_string()

def rescale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool | None = None,
    sigmoid: bool | tuple[Slope, Center] = False,
    # ComplexDescaler adds border_handling, sample_grid_model, field_based, ignore_mask and blur
    border_handling: int | BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: int | SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBasedT | None = None,
    ignore_mask: vs.VideoNode | None = None,
    blur: float | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Rescale a clip to the given resolution from a previously descaled clip,
    with image borders handling and sampling grid alignment, optionally using linear light processing.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:                The source clip.
    :param width:               Target scaled width (defaults to clip width if None).
    :param height:              Target scaled height (defaults to clip height if None).
    :param shift:               Subpixel shift (top, left) or per-field shifts.
    :param linear:              Whether to linearize the input before rescaling. If None, inferred from sigmoid.
    :param sigmoid:             Whether to use sigmoid transfer curve. Can be True, False, or a tuple of (slope, center).
                                `True` applies the defaults values (6.5, 0.75).
                                Keep in mind sigmoid slope has to be in range 1.0-20.0 (inclusive)
                                and sigmoid center has to be in range 0.0-1.0 (inclusive).
    :param border_handling:     Method for handling image borders during sampling.
    :param sample_grid_model:   Model used to align sampling grid.
    :param field_based:         Field-based processing mode (interlaced or progressive).
    :param ignore_mask:         Optional mask specifying areas to ignore during rescaling.
    :param blur:                Amount of blur to apply during rescaling.
    :param kwargs:              Additional arguments passed to `rescale_function`.
    :return:                    The scaled clip.
    """
    width, height = self._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs.update(
        border_handling=BorderHandling.from_param(border_handling, self.rescale), ignore_mask=ignore_mask, blur=blur
    )

    sample_grid_model = SampleGridModel(sample_grid_model)

    if field_based.is_inter:
        raise NotImplementedError
    else:
        shift = _descale_shift_norm(shift, True, self.rescale)

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

        rescaled = super().rescale(
            clip, **self.get_rescale_args(clip, shift, *de_base_args, **kwargs), linear=linear, sigmoid=sigmoid
        )

    return depth(rescaled, bits)

def descale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool | None = None,
    sigmoid: bool | tuple[Slope, Center] = False,
    # ComplexDescaler adds border_handling, sample_grid_model, field_based,  ignore_mask and blur
    border_handling: int | BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: int | SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBasedT | None = None,
    ignore_mask: vs.VideoNode | None = None,
    blur: float | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Descale a clip to the given resolution, with image borders handling and sampling grid alignment,
    optionally using linear light processing.

    Supports both progressive and interlaced sources. When interlaced, it will separate fields,
    perform per-field descaling, and weave them back.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:                The source clip.
    :param width:               Target descaled width (defaults to clip width if None).
    :param height:              Target descaled height (defaults to clip height if None).
    :param shift:               Subpixel shift (top, left) or per-field shifts.
    :param linear:              Whether to linearize the input before descaling. If None, inferred from sigmoid.
    :param sigmoid:             Whether to use sigmoid transfer curve. Can be True, False, or a tuple of (slope, center).
                                `True` applies the defaults values (6.5, 0.75).
                                Keep in mind sigmoid slope has to be in range 1.0-20.0 (inclusive)
                                and sigmoid center has to be in range 0.0-1.0 (inclusive).
    :param border_handling:     Method for handling image borders during sampling.
    :param sample_grid_model:   Model used to align sampling grid.
    :param field_based:         Field-based processing mode (interlaced or progressive).
    :param ignore_mask:         Optional mask specifying areas to ignore during descaling.
    :param blur:                Amount of blur to apply during scaling.
    :param kwargs:              Additional arguments passed to `descale_function`.
    :return:                    The descaled video node, optionally processed in linear light.
    """
    width, height = self._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs.update(
        linear=linear,
        sigmoid=sigmoid,
        border_handling=BorderHandling.from_param(border_handling, self.descale),
        ignore_mask=ignore_mask,
        blur=blur
    )

    sample_grid_model = SampleGridModel(sample_grid_model)

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

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

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

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

        field_shift = 0.125 * height / clip.height

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

        descaled_tf = super().descale(
            fields[0::2],
            **de_kwargs_tf | dict(src_top=de_kwargs_tf.get("src_top", 0.0) + field_shift),
        )
        descaled_bf = super().descale(
            fields[1::2],
            **de_kwargs_bf | dict(src_top=de_kwargs_bf.get("src_top", 0.0) - field_shift),
        )
        interleaved = vs.core.std.Interleave([descaled_tf, descaled_bf])

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

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

        descaled = super().descale(clip, **self.get_descale_args(clip, shift, *de_base_args, **kwargs))

    return depth(descaled, bits)

@classmethod
def ensure_obj(cls, kernel: KernelLike | None = None, /, func_except: FuncExceptT | None = None) -> Self:
    """
    Ensure that the given kernel input is returned as a kernel instance.

    :param kernel:              Kernel name, class, or instance. Defaults to current class if None.
    :param func_except:         Function returned for custom error handling.

    :return:                    The resolved and instantiated kernel.
    """
    return _base_ensure_obj(cls, kernel, func_except)

@classmethod
def from_param(cls, kernel: KernelLike | None = None, /, func_except: FuncExceptT | None = None) -> type[Self]:
    """
    Resolve and return a kernel class from a string name, class type, or instance.

    :param kernel:              Kernel identifier as a string, class type, or instance. If None, defaults to the current class.
    :param func_except:         Function returned for custom error handling.

    :return:                    The resolved kernel class.
    :raises UnknownKernelError: If the kernel could not be identified.
    """
    return _base_from_param(cls, kernel, cls._err_class, func_except)

def get_descale_args(
    self,
    clip: vs.VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Generate and normalize argument dictionary for a descale operation.

    :param clip:    The source clip.
    :param shift:   Vertical and horizontal shift to apply.
    :param width:   Target width.
    :param height:  Target height.
    :param kwargs:  Additional arguments to pass to the descale function.

    :return:        Dictionary of keyword arguments for the descale function.
    """
    return dict(src_top=shift[0], src_left=shift[1]) | self.get_params_args(True, clip, width, height, **kwargs)

def get_params_args(
    self, is_descale: bool, clip: vs.VideoNode, width: int | None = None, height: int | None = None, **kwargs: Any
) -> dict[str, Any]:
    """
    Generate a base set of parameters to pass for scaling, descaling, or resampling.

    :param is_descale:  Whether this is for a descale operation.
    :param clip:        The source clip.
    :param width:       Target width.
    :param height:      Target height.
    :param kwargs:      Additional keyword arguments to include.

    :return:            Dictionary of combined parameters.
    """
    return dict(width=width, height=height) | self.kwargs | kwargs

def get_resample_args(
    self,
    clip: vs.VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None,
    matrix_in: MatrixT | None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Generate and normalize argument dictionary for a resample operation.

    :param clip:        The source clip.
    :param format:      The target video format, which can either be:
                            - an integer format ID,
                            - a `vs.PresetVideoFormat` or `vs.VideoFormat`,
                            - or a source from which a valid `VideoFormat` can be extracted.
    :param matrix:      Target color matrix.
    :param matrix_in:   Source color matrix.
    :param kwargs:      Additional arguments to pass to the resample function.

    :return:            Dictionary of keyword arguments for the resample function.
    """
    return dict(
        format=get_video_format(format).id, matrix=Matrix.from_param(matrix), matrix_in=Matrix.from_param(matrix_in)
    ) | self.get_params_args(False, clip, **kwargs)

def get_rescale_args(
    self,
    clip: vs.VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Generate and normalize argument dictionary for a rescale operation.

    :param clip:    The source clip.
    :param shift:   Vertical and horizontal shift to apply.
    :param width:   Target width.
    :param height:  Target height.
    :param kwargs:  Additional arguments to pass to the rescale function.

    :return:        Dictionary of keyword arguments for the rescale function.
    """
    return dict(src_top=shift[0], src_left=shift[1]) | self.get_params_args(True, clip, width, height, **kwargs)

def get_scale_args(
    self,
    clip: vs.VideoNode,
    shift: tuple[TopShift, LeftShift] = (0, 0),
    width: int | None = None,
    height: int | None = None,
    **kwargs: Any,
) -> dict[str, Any]:
    """
    Generate and normalize argument dictionary for a scale operation.

    :param clip:    The source clip.
    :param shift:   Vertical and horizontal shift to apply.
    :param width:   Target width.
    :param height:  Target height.
    :param kwargs:  Additional arguments to pass to the scale function.

    :return:        Dictionary of keyword arguments for the scale function.
    """
    return dict(src_top=shift[0], src_left=shift[1]) | self.get_params_args(False, clip, width, height, **kwargs)

@cached_property
def kernel_radius(self) -> int:
    """
    Return the effective kernel radius for the scaler.

    :raises CustomNotImplementedError:  If no kernel radius is defined.
    :return:                            Kernel radius.
    """
    ...

@deprecated('The "multi" method is deprecated. Use "supersample" instead.', category=DeprecationWarning)
def multi(
    self, clip: VideoNodeT, multi: float = 2.0, shift: tuple[TopShift, LeftShift] = (0, 0), **kwargs: Any
) -> VideoNodeT:
    """
    Deprecated alias for `supersample`.

    :param clip:    The source clip.
    :param multi:   Supersampling factor.
    :param shift:   Subpixel shift (top, left) applied during scaling.
    :param kwargs:  Additional arguments forwarded to the scale function.
    :return:        The supersampled clip.
    """
    return self.supersample(clip, multi, shift, **kwargs)

@cached_property
def pretty_string(self) -> str:
    """
    Cached property returning a user-friendly string representation.

    :return: Pretty-printed string with arguments.
    """
    return self._pretty_string()

def resample(
    self,
    clip: vs.VideoNode,
    format: int | VideoFormatT | HoldsVideoFormatT,
    matrix: MatrixT | None = None,
    matrix_in: MatrixT | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Resample a video clip to the given format.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:        The source clip.
    :param format:      The target video format, which can either be:
                            - an integer format ID,
                            - a `vs.PresetVideoFormat` or `vs.VideoFormat`,
                            - or a source from which a valid `VideoFormat` can be extracted.
    :param matrix:      An optional color transformation matrix to apply.
    :param matrix_in:   An optional input matrix for color transformations.
    :param kwargs:      Additional keyword arguments passed to the `resample_function`.
    :return:            The resampled clip.
    """
    return self.resample_function(
        clip, **_norm_props_enums(self.get_resample_args(clip, format, matrix, matrix_in, **kwargs))
    )

def rescale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    shift: ShiftT = (0, 0),
    *,
    # `linear` and `sigmoid` parameters from LinearDescaler
    linear: bool | None = None,
    sigmoid: bool | tuple[Slope, Center] = False,
    # ComplexDescaler adds border_handling, sample_grid_model, field_based, ignore_mask and blur
    border_handling: int | BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: int | SampleGridModel = SampleGridModel.MATCH_EDGES,
    field_based: FieldBasedT | None = None,
    ignore_mask: vs.VideoNode | None = None,
    blur: float | None = None,
    **kwargs: Any,
) -> ConstantFormatVideoNode:
    """
    Rescale a clip to the given resolution from a previously descaled clip,
    with image borders handling and sampling grid alignment, optionally using linear light processing.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:                The source clip.
    :param width:               Target scaled width (defaults to clip width if None).
    :param height:              Target scaled height (defaults to clip height if None).
    :param shift:               Subpixel shift (top, left) or per-field shifts.
    :param linear:              Whether to linearize the input before rescaling. If None, inferred from sigmoid.
    :param sigmoid:             Whether to use sigmoid transfer curve. Can be True, False, or a tuple of (slope, center).
                                `True` applies the defaults values (6.5, 0.75).
                                Keep in mind sigmoid slope has to be in range 1.0-20.0 (inclusive)
                                and sigmoid center has to be in range 0.0-1.0 (inclusive).
    :param border_handling:     Method for handling image borders during sampling.
    :param sample_grid_model:   Model used to align sampling grid.
    :param field_based:         Field-based processing mode (interlaced or progressive).
    :param ignore_mask:         Optional mask specifying areas to ignore during rescaling.
    :param blur:                Amount of blur to apply during rescaling.
    :param kwargs:              Additional arguments passed to `rescale_function`.
    :return:                    The scaled clip.
    """
    width, height = self._wh_norm(clip, width, height)
    check_correct_subsampling(clip, width, height)

    field_based = FieldBased.from_param_or_video(field_based, clip)

    clip, bits = expect_bits(clip, 32)

    de_base_args = (width, height // (1 + field_based.is_inter))
    kwargs.update(
        border_handling=BorderHandling.from_param(border_handling, self.rescale), ignore_mask=ignore_mask, blur=blur
    )

    sample_grid_model = SampleGridModel(sample_grid_model)

    if field_based.is_inter:
        raise NotImplementedError
    else:
        shift = _descale_shift_norm(shift, True, self.rescale)

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

        rescaled = super().rescale(
            clip, **self.get_rescale_args(clip, shift, *de_base_args, **kwargs), linear=linear, sigmoid=sigmoid
        )

    return depth(rescaled, bits)

def scale(
    self,
    clip: vs.VideoNode,
    width: int | None = None,
    height: int | None = None,
    # ComplexScaler adds shift per planes
    shift: tuple[TopShift | list[TopShift], LeftShift | list[LeftShift]] = (0, 0),
    *,
    # `linear` and `sigmoid` from LinearScaler
    linear: bool | None = None,
    sigmoid: bool | tuple[Slope, Center] = False,
    # `border_handling`, `sample_grid_model`, `sar`, `dar`, `dar_in` and `keep_ar` from KeepArScaler
    border_handling: BorderHandling = BorderHandling.MIRROR,
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES,
    sar: Sar | float | bool | None = None,
    dar: Dar | float | bool | None = None,
    dar_in: Dar | bool | float | None = None,
    keep_ar: bool | None = None,
    # ComplexScaler adds blur
    blur: float | None = None,
    **kwargs: Any,
) -> vs.VideoNode | ConstantFormatVideoNode:
    """
    Scale a clip to the given resolution, with aspect ratio and linear light support.

    Keyword arguments passed during initialization are automatically injected here,
    unless explicitly overridden by the arguments provided at call time.
    Only arguments that match named parameters in this method are injected.

    :param clip:                The source clip.
    :param width:               Target width (defaults to clip width if None).
    :param height:              Target height (defaults to clip height if None).
    :param shift:               Subpixel shift (top, left) applied during scaling.
                                If a tuple is provided, it is used uniformly.
                                If a list is given, the shift is applied per plane.
    :param linear:              Whether to linearize the input before descaling. If None, inferred from sigmoid.
    :param sigmoid:             Whether to use sigmoid transfer curve. Can be True, False, or a tuple of (slope, center).
                                `True` applies the defaults values (6.5, 0.75).
                                Keep in mind sigmoid slope has to be in range 1.0-20.0 (inclusive)
                                and sigmoid center has to be in range 0.0-1.0 (inclusive).
    :param border_handling:     Method for handling image borders during sampling.
    :param sample_grid_model:   Model used to align sampling grid.
    :param sar:                 Sample aspect ratio to assume or convert to.
    :param dar:                 Desired display aspect ratio.
    :param dar_in:              Input display aspect ratio, if different from clip's.
    :param keep_ar:             Whether to adjust dimensions to preserve aspect ratio.
    :param blur:                Amount of blur to apply during scaling.
    :return:                    Scaled clip, optionally aspect-corrected and linearized.
    """
    kwargs.update(
        linear=linear,
        sigmoid=sigmoid,
        border_handling=border_handling,
        sample_grid_model=sample_grid_model,
        sar=sar,
        dar=dar,
        dar_in=dar_in,
        keep_ar=keep_ar,
        blur=blur
    )

    shift_top, shift_left = shift

    if isinstance(shift_top, (int, float)) and isinstance(shift_left, (int, float)):
        return super().scale(clip, width, height, (shift_top, shift_left), **kwargs)

    assert check_variable_format(clip, self.scale)

    n_planes = clip.format.num_planes

    shift_top = normalize_seq(shift_top, n_planes)
    shift_left = normalize_seq(shift_left, n_planes)

    if n_planes == 1:
        if len(set(shift_top)) > 1 or len(set(shift_left)) > 1:
            raise CustomValueError(
                "Inconsistent shift values detected for a single plane. "
                "All shift values must be identical when passing a GRAY clip.",
                self.scale,
                (shift_top, shift_left),
            )

        return super().scale(clip, width, height, (shift_top[0], shift_left[0]), **kwargs)

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

    format_in = clip.format
    format_out = get_video_format(fallback(kwargs.pop("format", None), self.kwargs.get("format"), clip.format))

    chromaloc = ChromaLocation.from_video(clip, func=self.scale)
    chromaloc_in = ChromaLocation(
        fallback(kwargs.pop("chromaloc_in", None), self.kwargs.get("chromaloc_in"), chromaloc)
    )
    chromaloc_out = ChromaLocation(
        fallback(kwargs.pop("chromaloc", None), self.kwargs.get("chromaloc"), chromaloc)
    )

    off_left, off_top = chromaloc_in.get_offsets(format_in)
    off_left_out, off_top_out = chromaloc_out.get_offsets(format_out)

    factor_w = 1 / 2 ** format_in.subsampling_w
    factor_h = 1 / 2 ** format_in.subsampling_h

    # Offsets for format out
    offc_left = (abs(off_left) + off_left_out) * factor_w
    offc_top = (abs(off_top) + off_top_out) * factor_h

    # Offsets for scale out
    if format_out.subsampling_w:
        offc_left = ((abs(off_left) + off_left * (clip.width / width)) * factor_w) + offc_left
    if format_out.subsampling_h:
        offc_top = ((abs(off_top) + off_top * (clip.height / height)) * factor_h) + offc_top

    for i in range(1, n_planes):
        shift_left[i] += offc_left
        shift_top[i] += offc_top

    scaled_planes = list[vs.VideoNode]()

    for i, (plane, top, left) in enumerate(zip(split(clip), shift_top, shift_left)):
        if i:
            w = round(width * 1 / 2 ** format_out.subsampling_h)
            h = round(height * 1 / 2 ** format_out.subsampling_h)
        else:
            w, h = width, height

        scaled_planes.append(
            super().scale(
                plane,
                w,
                h,
                (top, left),
                format=format_out.replace(color_family=vs.GRAY, subsampling_w=0, subsampling_h=0),
                **kwargs
            )
        )

    merged = vs.core.std.ShufflePlanes(scaled_planes, [0, 0, 0], format_out.color_family, clip)

    if chromaloc_in != chromaloc_out:
        return chromaloc_out.apply(merged)

    return merged