vodesfunc.rescale

def descale(
    self,
    kernel: KernelLike,
    width: int | float,
    height: int | float,
    base_height: int | None = None,
    base_width: int | None = None,
    shift: tuple[float, float] = (0, 0),
    field_based: FieldBasedLike | None = None,
    ignore_mask: bool | vs.VideoNode | Ignore_Mask_Func = False,
    sample_grid_model: SampleGridModel | int = SampleGridModel.MATCH_EDGES,
    mode: str = "hw",
) -> Self:
    """
    Performs descale and rescale (with the same kernel) using the "traditional" getfnative approach with base_width/height for fractional descales.

    :param kernel:              Kernel to descale with
    :param height:              Height to descale to
    :param width:               Width to descale to. Please be absolutely certain of what you're doing if you're using get_w for this.
    :param base_height:         Padded height used in a "fractional" descale
    :param base_width:          Padded width used in a "fractional" descale
                                Both of these are technically optional but highly recommended to have set for float width/height.

    :param shift:               A custom shift to be applied
    :param mode:                Whether to descale only height, only width, or both.
                                "h" or "w" respectively for the former two.
    :param field_based:         To descale a cross-converted/interlaced clip.
                                Will try to take the prop from the clip if `None` was passed.
    :param ignore_mask:         Manual mask of areas to ignore in the descale process. This is most commonly used to avoid clipping.\n
                                `True` will generate a mask to avoid clipping on borders. This is implemented in `border_clipping_mask` in this package.\n
                                You can also pass your own function to generate a mask using all arguments and for both steps.\n
                                See the aforementioned function for how this works.
    :param sample_grid_model:   See the [vs-jetpack docs](https://jaded-encoding-thaumaturgy.github.io/vs-jetpack/api/vskernels/types/#vskernels.types.SampleGridModel) for this.\n
                                This param will only be used as a fallback if the kernel doesn't have one passed to it.\n
                                Do note that this will always show up as `MATCH_EDGES` in `descale_func_args` and `rescale_args` since shifts are handled internally in ScalingArgs.
    """
    clip = self.funcutil.work_clip

    if isinstance(height, float) and len(stack := inspect.stack()) > 1:
        has_getw = [ctx for ctx in stack[1].code_context if "get_w" in ctx.lower()]
        if has_getw:
            print("RescaleBuilder: Please make sure get_w returns the width you really want!")

    self.kernel = Kernel.ensure_obj(kernel)
    self.border_handling = self.kernel.kwargs.get("border_handling", 0)
    self.field_based = FieldBased.from_param_or_video(field_based, clip)
    self.ignore_mask = self.kernel.kwargs.get("ignore_mask", ignore_mask)
    self.sample_grid_model = SampleGridModel(self.kernel.kwargs.get("sample_grid_model", sample_grid_model))

    self.height = height if "h" in mode else clip.height
    self.width = width if "w" in mode else clip.width
    self.base_height = base_height
    self.base_width = base_width

    if (isinstance(width, float) or isinstance(height, float)) and self.field_based.is_inter:
        raise CustomValueError("Float is not supported for fieldbased descales!", self.descale)

    if self.field_based.is_inter:
        self._fieldbased_descale(clip, width=self.width, height=self.height, shift=shift, border_handling=self.border_handling)
    else:
        self._non_fieldbased_descale(clip, width, height, base_height, base_width, shift, mode)

    self.descaled = self.descaled.std.CopyFrameProps(clip)
    self.rescaled = self.rescaled.std.CopyFrameProps(clip)

    return self

def descale_raw(
    self,
    kernel: KernelLike,
    width: int,
    height: int,
    src_left: float | None = None,
    src_top: float | None = None,
    src_width: float | None = None,
    src_height: float | None = None,
    mode: str = "hw",
    ignore_mask: bool | vs.VideoNode | Ignore_Mask_Func = False,
) -> Self:
    """
    Performs descale and rescale (with the same kernel) using raw src_* values directly.

    :param kernel:              Kernel to descale with.\n
                                If you want `border_handling`, pass that as a parameter to the kernel.
    :param height:              Height to descale to
    :param width:               Width to descale to. Please be absolutely certain of what you're doing if you're using get_w for this.
    :param src_left:            Used to select the source region of the input to use. Can also be used to shift the image. Defaults to the whole image.
    :param src_top:             See above.
    :param src_width:           See above.
    :param src_height:          See above.
    :param mode:                Whether to descale only height, only width, or both.
                                "h" or "w" respectively for the former two.
    :param ignore_mask:         Manual mask of areas to ignore in the descale process. This is most commonly used to avoid clipping.\n
                                `True` will generate a mask to avoid clipping on borders. This is implemented in `border_clipping_mask` in this package.\n
                                You can also pass your own function to generate a mask using all arguments and for both steps.\n
                                See the aforementioned function for how this works.
    """
    clip = self.funcutil.work_clip

    self.kernel = Kernel.ensure_obj(kernel)
    self.border_handling = self.kernel.kwargs.get("border_handling", 0)
    self.ignore_mask = self.kernel.kwargs.get("ignore_mask", ignore_mask)
    self.field_based = FieldBased.PROGRESSIVE  # otherwise currently unsupported
    self.sample_grid_model = SampleGridModel.MATCH_EDGES  # otherwise currently (?) unsupported

    self._raw_non_fieldbased_descale(clip, width, height, src_left, src_top, src_width, src_height, mode)

    self.descaled = self.descaled.std.CopyFrameProps(clip)
    self.rescaled = self.rescaled.std.CopyFrameProps(clip)

    return self

def post_descale(self, func: VSFunctionNoArgs | list[VSFunctionNoArgs]) -> Self:
    """
    A function to apply any arbitrary function on the descaled clip.\n
    I can't think of a good usecase/example for this but I was asked to add this before.

    :param func:    This can be any function or list of functions that take a videonode input
                    and returns a videonode. You are responsible for keeping the format the same.
    """
    if not isinstance(func, list):
        func = [func]

    for f in func:
        if not callable(f):
            raise CustomValueError(f"post_descale: Function {f.__name__} is not callable!", self.post_descale)

        self.descaled = f(self.descaled)

    return self

def linemask(
    self,
    mask: vs.VideoNode | EdgeDetectLike | None = None,
    downscaler: ScalerLike | None = None,
    maximum_iter: int = 0,
    inflate_iter: int = 0,
    expand: int | tuple[int, int | None] = 0,
    kernel_window: int | None = None,
    prefilter: bool | VSFunctionNoArgs = False,
    **kwargs,
) -> Self:
    """
    A function to apply a linemask to the final output.

    :param mask:            This can be a masking function like `Kirsch` (also the default if `None`) or a clip.
    :param downscaler:      Downscaler to use if creating a linemask on the doubled clip. Defaults to `Bilinear` if `None`.
    :param maximum_iter:    Apply std.Maximum x amount of times
    :param inflate_iter:    Apply std.inflate x amount of times
    :param expand:          Apply an ellipse morpho expand with the passed amount.
                            Can be a tuple of (horizontal, vertical) or a single value for both.
    :param kernel_window:   To override kernel radius used in case of border_handling being used.
    :param prefilter:       Prefilter the input clip for the mask function.\n
                            `True` will call `prefilter_to_full_range`. `False` to disable.
    :param **kwargs:        Any other params to pass to the edgemask creation. For example `lthr` or `hthr`.
    """
    if self.upscaled:
        raise SyntaxError("RescaleBuilder: Downscaled clip already created. Create linemasks before calling downscale.")
    if isinstance(mask, vs.VideoNode):
        self.linemask_clip = mask
        return self
    edgemaskFunc = EdgeDetect.ensure_obj(mask or Kirsch())

    # Perform on doubled clip if exists and downscale

    wclip = self.doubled if self.doubled else self.funcutil.work_clip
    if prefilter:
        wclip = prefilter_to_full_range(wclip) if not callable(prefilter) else prefilter(wclip)

    if self.doubled:
        scaler = Scaler.ensure_obj(downscaler or Bilinear())
        self.linemask_clip = edgemaskFunc.edgemask(wclip, **kwargs)
        self.linemask_clip = scaler.scale(self.linemask_clip, self.funcutil.work_clip.width, self.funcutil.work_clip.height, **self.post_crop)
    else:
        self.linemask_clip = edgemaskFunc.edgemask(wclip, **kwargs)

    self.linemask_clip = self._process_mask(self.linemask_clip, maximum_iter, inflate_iter, expand)

    if self.border_handling:
        from .misc import get_border_crop

        borders = get_border_crop(self.funcutil.work_clip, self, kernel_window)
        self.linemask_clip = self.linemask_clip.std.Crop(*borders).std.AddBorders(*borders, 1)

    self.linemask_clip = limiter(self.linemask_clip)

    return self

def errormask(
    self, mask: vs.VideoNode | float = 0.05, maximum_iter: int = 2, inflate_iter: int = 3, expand: int | tuple[int, int | None] = 0
) -> Self:
    """
    A function to apply a basic error mask to the final output.

    :param mask:            With a float, and by default, will be created internally. Could also pass a clip.
    :param maximum_iter:    Apply std.Maximum x amount of times
    :param inflate_iter:    Apply std.inflate x amount of times
    :param expand:          Apply an ellipse morpho expand with the passed amount.
                            Can be a tuple of (horizontal, vertical) or a single value for both.
    """
    self.errormask_clip = self._errormask(mask, maximum_iter, inflate_iter, expand)
    return self

def errormask_zoned(
    self,
    ranges: FrameRangesN,
    mask: vs.VideoNode | float = 0.05,
    maximum_iter: int = 2,
    inflate_iter: int = 3,
    expand: int | tuple[int, int | None] = 0,
) -> Self:
    """
    A function to apply a basic error mask to the final output.\n
    But with this rfs'd to certain ranges.
    """
    if not ranges:
        return self
    err_mask = self._errormask(mask, maximum_iter, inflate_iter, expand)
    if not self.errormask_clip:
        self.errormask_clip = core.std.BlankClip(self.funcutil.work_clip, format=get_video_format(err_mask))

    self.errormask_clip = replace_ranges(self.errormask_clip, err_mask, ranges)
    return self

def double(self, upscaler: ScalerLike = ArtCNN.R8F64) -> Self:
    """
    Upscales the descaled clip by 2x

    :param upscaler:        Any kind of vsscale scaler. Defaults to ArtCNN.R8F64.
    """

    scaler = Scaler.ensure_obj(upscaler)
    self.doubled = scaler.supersample(self.descaled)
    return self

def post_double(self, func: VSFunctionNoArgs | list[VSFunctionNoArgs]) -> Self:
    """
    A function to apply any arbitrary function on the doubled clip.

    :param func:    This can be any function or list of functions that take a videonode input
                    and returns a videonode. You are responsible for keeping the format the same.
    """
    if not self.doubled:
        raise SyntaxError("post_double: Doubled clip has not been generated yet. Please call this after double().")

    if not isinstance(func, list):
        func = [func]

    for f in func:
        if not callable(f):
            raise CustomValueError(f"post_double: Function {f.__name__} is not callable!", self.post_double)

        self.doubled = f(self.doubled)

    return self

def downscale(self, downscaler: ScalerLike | None = None) -> Self:
    """
    Downscales the clip back the size of the original input clip and applies the masks, if any.

    :param downscaler:      Any vsscale scaler to use. Defaults to Linear Hermite.
    """
    if downscaler is None:
        scaler = Hermite(linear=True)
    else:
        scaler = Scaler.ensure_obj(downscaler)
    if not self.doubled:
        raise SyntaxError("Downscale/Final is the last one that should be called in a chain!")
    wclip = self.funcutil.work_clip
    self.upscaled = scaler.scale(self.doubled, wclip.width, wclip.height, **self.post_crop)
    self._apply_masks()
    self.upscaled = self.upscaled.std.CopyFrameProps(wclip)
    return self

def final(self) -> tuple[Self, vs.VideoNode]:
    """
    This is the last function in the chain that also returns the final clip.
    It internally calls `downscale` if you haven't done so before and then merges the resulting clip with the input chroma, if any.

    :return: A tuple of this class and the resulting final rescale.
    """
    if not self.upscaled:
        self.downscale()
    if not self.upscaled:
        raise TypeError("No downscaled clip has been generated yet!")

    return (self, self.funcutil.return_clip(self.upscaled))