Skip to content

vodesfunc.rescale_ext.base

__all__ module-attribute

__all__ = ['RescaleBase', 'RescaleNumbers', 'Ignore_Mask_Func']

Ignore_Mask_Func module-attribute

Ignore_Mask_Func = Callable[[vs.VideoNode, ScalingArgs, Kernel, BorderHandling], vs.VideoNode]

RescaleNumbers

Source code in vodesfunc/rescale_ext/base.py
class RescaleNumbers:
    height: float | int
    width: float | int
    base_height: int | None
    base_width: int | None
    border_handling: int = 0

height instance-attribute

height: float | int

width instance-attribute

width: float | int

base_height instance-attribute

base_height: int | None

base_width instance-attribute

base_width: int | None

border_handling class-attribute instance-attribute

border_handling: int = 0

RescaleBase

Bases: RescaleNumbers, VSObject

Source code in vodesfunc/rescale_ext/base.py
class RescaleBase(RescaleNumbers, VSObject):
    funcutil: FunctionUtil
    kernel: Kernel
    post_crop: KwargsT
    rescale_args: KwargsT
    descale_func_args: KwargsT
    field_based: FieldBasedLike | None = None
    sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES
    ignore_mask: bool | vs.VideoNode | Ignore_Mask_Func

    descaled: vs.VideoNode
    rescaled: vs.VideoNode
    upscaled: vs.VideoNode | None = None
    doubled: vs.VideoNode | None = None
    linemask_clip: vs.VideoNode | None = None
    errormask_clip: vs.VideoNode | None = None

    @abstractmethod
    def final(self) -> tuple[Self, vs.VideoNode]: ...

    def _return_creditmask(self) -> vs.VideoNode:
        return self.errormask_clip if isinstance(self.errormask_clip, vs.VideoNode) else core.std.BlankClip(self.funcutil.work_clip)

    def _return_linemask(self) -> vs.VideoNode:
        return self.linemask_clip if isinstance(self.linemask_clip, vs.VideoNode) else core.std.BlankClip(self.funcutil.work_clip)

    def __vs_del__(self, core_id: int) -> None:
        if not TYPE_CHECKING:
            self.descaled = None
            self.rescaled = None
        self.upscaled = None
        self.doubled = None
        self.linemask_clip = None
        self.errormask_clip = None
        self.ignore_mask = False
        for v in self.__dict__.values():
            if not isinstance(v, MutableMapping):
                continue

            for k2, v2 in v.items():
                if isinstance(v2, vs.VideoNode):
                    v[k2] = None

funcutil instance-attribute

funcutil: FunctionUtil

kernel instance-attribute

kernel: Kernel

post_crop instance-attribute

post_crop: KwargsT

rescale_args instance-attribute

rescale_args: KwargsT

descale_func_args instance-attribute

descale_func_args: KwargsT

field_based class-attribute instance-attribute

field_based: FieldBasedLike | None = None

sample_grid_model class-attribute instance-attribute

sample_grid_model: SampleGridModel = SampleGridModel.MATCH_EDGES

ignore_mask instance-attribute

ignore_mask: bool | VideoNode | Ignore_Mask_Func

descaled instance-attribute

descaled: VideoNode

rescaled instance-attribute

rescaled: VideoNode

upscaled class-attribute instance-attribute

upscaled: VideoNode | None = None

doubled class-attribute instance-attribute

doubled: VideoNode | None = None

linemask_clip class-attribute instance-attribute

linemask_clip: VideoNode | None = None

errormask_clip class-attribute instance-attribute

errormask_clip: VideoNode | None = None

final abstractmethod

final() -> tuple[Self, vs.VideoNode]
Source code in vodesfunc/rescale_ext/base.py
@abstractmethod
def final(self) -> tuple[Self, vs.VideoNode]: ...

__vs_del__

__vs_del__(core_id: int) -> None
Source code in vodesfunc/rescale_ext/base.py
def __vs_del__(self, core_id: int) -> None:
    if not TYPE_CHECKING:
        self.descaled = None
        self.rescaled = None
    self.upscaled = None
    self.doubled = None
    self.linemask_clip = None
    self.errormask_clip = None
    self.ignore_mask = False
    for v in self.__dict__.values():
        if not isinstance(v, MutableMapping):
            continue

        for k2, v2 in v.items():
            if isinstance(v2, vs.VideoNode):
                v[k2] = None