misc ¶

@classmethod
def from_clip(cls, clip: vs.VideoNode, keyframes: Keyframes | str, *args: Any, **kwargs: Any) -> vs.VideoNode:
    return cls(clip, keyframes, *args, **kwargs).get_eval()

def get_clip(self, key: int) -> vs.VideoNode:
    return self.clip.std.SetFrameProps(**dict(zip(self.prop_keys, self.scene_avgs[key])))

def get_eval(self) -> vs.VideoNode:
    return self.clip.std.FrameEval(lambda n: self[self.keyframes.scenes.indices[n]])

@classmethod
def COLOR(
    cls, clip: vs.VideoNode, left: int = 0, right: int = 0, top: int = 0, bottom: int = 0,
    color: int | float | bool | None | MissingT | Sequence[int | float | bool | None | MissingT] = (False, MISSING)
) -> ConstantFormatVideoNode:
    """
    Pad a clip with a constant color.

    Visual example:

        ```
        >>> |ABCDE
        >>> padder.COLOR(left=3, color=Z)
        >>> ZZZ|ABCDE
        ```

    :param clip:        Input clip.
    :param left:        Padding added to the left side of the clip.
    :param right:       Padding added to the right side of the clip.
    :param top:         Padding added to the top side of the clip.
    :param bottom:      Padding added to the bottom side of the clip.
    :param color:       Constant color that should be added on the sides:
                            * number: This will be treated as such and not converted or clamped.
                            * False: Lowest value for this clip format and color range.
                            * True: Highest value for this clip format and color range.
                            * None: Neutral value for this clip format.
                            * MISSING: Automatically set to False if RGB, else None.

    :return:            Padded clip with colored borders.
    """

    from ..functions import normalize_seq
    from ..utils import core, get_lowest_values, get_neutral_values, get_peak_values

    assert check_variable_format(clip, "padder")

    cls._base(clip, left, right, top, bottom)

    def _norm(colr: int | float | bool | None | MissingT) -> Sequence[int | float]:
        if colr is MISSING:
            colr = False if clip.format.color_family is vs.RGB else None

        if colr is False:
            return get_lowest_values(clip, clip)

        if colr is True:
            return get_peak_values(clip, clip)

        if colr is None:
            return get_neutral_values(clip)

        return normalize_seq(colr, clip.format.num_planes)

    if not isinstance(color, Sequence):
        norm_colors = _norm(color)
    else:
        norm_colors = [_norm(c)[i] for i, c in enumerate(normalize_seq(color, clip.format.num_planes))]

    return core.std.AddBorders(clip, left, right, top, bottom, norm_colors)

@classmethod
def MIRROR(cls, clip: VideoNodeT, left: int = 0, right: int = 0, top: int = 0, bottom: int = 0) -> VideoNodeT:
    """
    Pad a clip with reflect mode. This will reflect the clip on each side.

    Visual example:

        ```
        >>> |ABCDE
        >>> padder.MIRROR(left=3)
        >>> CBA|ABCDE
        ```

    :param clip:        Input clip.
    :param left:        Padding added to the left side of the clip.
    :param right:       Padding added to the right side of the clip.
    :param top:         Padding added to the top side of the clip.
    :param bottom:      Padding added to the bottom side of the clip.

    :return:            Padded clip with reflected borders.
    """

    from ..utils import core

    width, height, *_ = cls._base(clip, left, right, top, bottom)

    padded = core.resize.Point(
        core.std.CopyFrameProps(clip, clip.std.BlankClip()),
        width, height,
        src_top=-top, src_left=-left,
        src_width=width, src_height=height
    )
    return core.std.CopyFrameProps(padded, clip)

@classmethod
def REPEAT(cls, clip: vs.VideoNode, left: int = 0, right: int = 0, top: int = 0, bottom: int = 0) -> ConstantFormatVideoNode:
    """
    Pad a clip with repeat mode. This will simply repeat the last row/column till the end.

    Visual example:

        ```
        >>> |ABCDE
        >>> padder.REPEAT(left=3)
        >>> AAA|ABCDE
        ```

    :param clip:        Input clip.
    :param left:        Padding added to the left side of the clip.
    :param right:       Padding added to the right side of the clip.
    :param top:         Padding added to the top side of the clip.
    :param bottom:      Padding added to the bottom side of the clip.

    :return:            Padded clip with repeated borders.
    """

    *_, fmt, w_sub, h_sub = cls._base(clip, left, right, top, bottom)

    padded = clip.std.AddBorders(left, right, top, bottom)

    right, bottom = clip.width + left, clip.height + top

    pads = [
        (left, right, top, bottom),
        (left // w_sub, right // w_sub, top // h_sub, bottom // h_sub),
    ][:fmt.num_planes]

    return padded.akarin.Expr([
        """
            X {left} < L! Y {top} < T! X {right} > R! Y {bottom} > B!

            T@ B@ or L@ R@ or and
                L@
                    T@ {left} {top}  x[] {left} {bottom} x[] ?
                    T@ {right} {top} x[] {right} {bottom} x[] ?
                ?
                L@
                    {left} Y x[]
                    R@
                        {right} Y x[]
                        T@
                            X {top} x[]
                            B@
                                X {bottom} x[]
                                x
                            ?
                        ?
                    ?
                ?
            ?
        """.format(
            left=l_, right=r_ - 1, top=t_, bottom=b_ - 1
        )
        for l_, r_, t_, b_ in pads
    ])

@classmethod
def mod_padding(
    cls, sizes: tuple[int, int] | vs.VideoNode, mod: int = 16, min: int = 4, align: Align = Align.MIDDLE_CENTER
) -> tuple[int, int, int, int]:
    sizes, _ = cls._get_sizes_crop_scale(sizes, 1)
    ph, pv = (mod - (((x + min * 2) - 1) % mod + 1) for x in sizes)
    left, top = floor(ph / 2), floor(pv / 2)
    left, right, top, bottom = tuple(x + min for x in (left, ph - left, top, pv - top))

    if align & BaseAlign.TOP:
        bottom += top
        top = 0
    elif align & BaseAlign.BOTTOM:
        top += bottom
        bottom = 0

    if align & BaseAlign.LEFT:
        right += left
        left = 0
    elif align & BaseAlign.RIGHT:
        left += right
        right = 0

    return left, right, top, bottom

@classmethod
def mod_padding_crop(
    cls, sizes: tuple[int, int] | vs.VideoNode, mod: int = 16, min: int = 4,
    crop_scale: float | tuple[float, float] = 2, align: Align = Align.MIDDLE_CENTER
) -> tuple[tuple[int, int, int, int], tuple[int, int, int, int]]:
    sizes, crop_scale = cls._get_sizes_crop_scale(sizes, crop_scale)
    padding = cls.mod_padding(sizes, mod, min, align)
    return padding, tuple(x * crop_scale[0 if i < 2 else 1] for x, i in enumerate(padding))  # type: ignore

def COLOR(
    self, clip: vs.VideoNode,
    color: int | float | bool | None | Sequence[int | float | bool | None] = (False, None)
) -> ConstantFormatVideoNode:
    """
    Pad a clip with a constant color.

    :param clip:        Input clip.
    :param color:       Constant color that should be added on the sides:
                            * number: This will be treated as such and not converted or clamped.
                            * False: Lowest value for this clip format and color range.
                            * True: Highest value for this clip format and color range.
                            * None: Neutral value for this clip format.
                            * MISSING: Automatically set to False if RGB, else None.

    :return:            Padded clip with colored borders.
    """
    padding = padder.mod_padding(clip, self.mod, self.min, self.align)
    out = padder.COLOR(clip, *padding, color)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out

def CROP(self, clip: vs.VideoNode, crop_scale: float | tuple[float, float] | None = None) -> ConstantFormatVideoNode:
    """
    Crop a clip with the padding values.

    :param clip:        Input clip.
    :param crop_scale:  Optional scale factor for the padding values. If None, no scaling is applied.
    :return:            Cropped clip.
    """
    (padding, sizes) = self.pad_ops.pop(0)

    if crop_scale is None:
        crop_scale = (clip.width / sizes[0], clip.height / sizes[1])

    crop_pad = padder._crop_padding(padder._get_sizes_crop_scale(clip, crop_scale)[1])

    return clip.std.Crop(*(x * y for x, y in zip(padding, crop_pad)))

def MIRROR(self, clip: VideoNodeT) -> VideoNodeT:
    """
    Pad a clip with reflect mode. This will reflect the clip on each side.

    :param clip:        Input clip.
    :return:            Padded clip with reflected borders.
    """
    padding = padder.mod_padding(clip, self.mod, self.min, self.align)
    out = padder.MIRROR(clip, *padding)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out

def REPEAT(self, clip: vs.VideoNode) -> ConstantFormatVideoNode:
    """
    Pad a clip with repeat mode. This will simply repeat the last row/column till the end.

    :param clip:        Input clip.
    :return:            Padded clip with repeated borders.
    """
    padding = padder.mod_padding(clip, self.mod, self.min, self.align)
    out = padder.REPEAT(clip, *padding)
    self.pad_ops.append((padding, (out.width, out.height)))
    return out