rescale ¶

def __init__(
    self,
    clip: vs.VideoNode,
    /,
    height: int | float,
    kernel: KernelT,
    upscaler: ScalerT = ArtCNN,
    downscaler: ScalerT = Hermite(linear=True),
    width: int | float | None = None,
    base_height: int | None = None,
    base_width: int | None = None,
    crop: tuple[LeftCrop, RightCrop, TopCrop, BottomCrop] = CropRel(),
    shift: tuple[TopShift, LeftShift] = (0, 0),
    field_based: FieldBasedT | bool | None = None,
    border_handling: int | BorderHandling = BorderHandling.MIRROR
) -> None:
    """Initialize the rescaling process.

    :param clip:                Clip to be rescaled
    :param height:              Height to be descaled to.
                                Forcing the value to float will ensure a fractionnal descale
    :param kernel:              Kernel used for descaling
    :param upscaler:            Scaler that supports doubling, defaults to ArtCNN
    :param downscaler:          Scaler used for downscaling the upscaled clip back to input res,
                                defaults to Hermite(linear=True)
    :param width:               Width to be descaled to. If None, automatically calculated from the height
    :param base_height:         Integer height at which the clip will be contained.
                                If None, automatically calculated from the height
    :param base_width:          Integer width at which the clip will be contained.
                                If None, automatically calculated from the width
    :param crop:                Cropping values to apply before descale.
                                The ratio descale height / source height will be preserved even after descale.
                                The cropped area is restored when calling the `upscale` property.
    :param shift:               Shifts to apply during descale and upscale, defaults to (0, 0)
    :param field_based:         Parameter specifying the source is a cross-converted/interlaced upscaled content
    :param border_handling:     Adjust the way the clip is padded internally during the scaling process.
                                Accepted values are:
                                    0: Assume the image was resized with mirror padding.
                                    1: Assume the image was resized with zero padding.
                                    2: Assume the image was resized with extend padding,
                                       where the outermost row was extended infinitely far.
                                Defaults to 0
    """
    self._line_mask: vs.VideoNode | None = None
    self._credit_mask: vs.VideoNode | None = None
    self._ignore_mask: vs.VideoNode | None = None
    self._crop = crop
    self._pre = clip

    self.descale_args = ScalingArgs.from_args(
        clip, height, width, base_height, base_width, shift[0], shift[1], crop, mode='hw'
    )

    super().__init__(clip, kernel, upscaler, downscaler, field_based, border_handling)

    if self._crop > (0, 0, 0, 0):
        self.clipy = self.clipy.std.Crop(*self._crop)

def __init__(
    self,
    clip: vs.VideoNode,
    /,
    kernel: KernelT,
    upscaler: ScalerT = ArtCNN,
    downscaler: ScalerT = Hermite(linear=True),
    field_based: FieldBasedT | bool | None = None,
    border_handling: int | BorderHandling = BorderHandling.MIRROR
) -> None:
    assert check_variable(clip, self.__class__)

    self.clipy, *chroma = split(clip)
    self.chroma = chroma

    self.kernel = Kernel.ensure_obj(kernel)
    self.upscaler = Scaler.ensure_obj(upscaler)

    self.downscaler = Scaler.ensure_obj(downscaler)

    self.field_based = FieldBased.from_param(field_based)

    self.border_handling = BorderHandling(int(border_handling))