other ¶

@classmethod
def from_clip(cls, clip: vs.VideoNode, sar: bool = True) -> Self:
    """
    Get the DAR from the specified clip and SAR.

    :param clip:     Clip or frame that holds the frame properties.
    :param sar:      Whether to use SAR metadata.

    :return:         A DAR object created using the specified clip and SAR.
    """

    return cls.from_res(clip.width, clip.height, Sar.from_clip(clip) if sar else None)

@classmethod
def from_res(cls, width: int, height: int, sar: Sar | None = None) -> Self:
    """
    Get the DAR from the specified dimensions and SAR.

    :param width:      The width of the image.
    :param height:     The height of the image.
    :param sar:        The SAR object. Optional.

    :return:           A DAR object created using the specified dimensions and SAR.
    """

    dar = Fraction(width, height)

    if sar:
        if sar.denominator > sar.numerator:
            dar /= sar
        else:
            dar *= sar

    return cls(dar)

def to_sar(self, active_area: int | Fraction, height: int) -> Sar:
    """
    Convert the DAR to a SAR object.

    :param active_area:     The active image area. For more information, see ``Sar.from_ar``.
    :param height:          The height of the image.

    :return:                A SAR object created using the DAR.
    """

    assert isinstance(active_area, int | Fraction)

    return Sar.from_ar(active_area, height, self)

@classmethod
def from_framerate(cls, framerate: float | Fraction, strict: bool = False) -> Self:
    """Determine the Region using a given framerate."""

    key = Fraction(framerate)

    if strict:
        return cls(_framerate_region_map[key])

    if key not in _framerate_region_map:
        diffs = [(k, abs(float(key) - float(v))) for k, v in _region_framerate_map.items()]

        diffs.sort(key=lambda x: x[1])

        return cls(diffs[0][0])

    return cls(_framerate_region_map[key])

@classmethod
def from_video(cls, clip: vs.VideoNode) -> Self:
    """Create a Resolution object using a given clip's dimensions."""

    from ..functions import check_variable_resolution

    assert check_variable_resolution(clip, cls.from_video)

    return cls(clip.width, clip.height)

def transpose(self) -> Self:
    """Flip the Resolution matrix over its diagonal."""

    return self.__class__(self.height, self.width)

def apply(self, clip: VideoNodeT) -> VideoNodeT:
    """Apply the SAR values as _SARNum and _SARDen frame properties to a clip."""

    return vs.core.std.SetFrameProps(clip, _SARNum=self.numerator, _SARDen=self.denominator)

@classmethod
def from_ar(cls, active_area: int | Fraction, height: int, dar: Dar) -> Self:
    """
    Calculate the SAR using a DAR object & active area. See ``Dar.to_sar`` for more information.

    For a list of known standards, refer to the following tables:
    `<https://docs.google.com/spreadsheets/d/1pzVHFusLCI7kys2GzK9BTk3w7G8zcLxgHs3DMsurF7g>`_

    :param active_area:     The active image area.
    :param height:          The height of the image.
    :param dar:             The DAR object.

    :return:                A SAR object created using DAR and active image area information.
    """

    assert isinstance(active_area, int | Fraction)

    return cls(dar / (Fraction(active_area) / height))

@classmethod
def from_clip(cls, clip: HoldsPropValueT) -> Self:
    """
    Get the SAR from the clip's frame properties.

    :param clip:        Clip or frame that holds the frame properties.

    :return:            A SAR object of the SAR properties from the given clip.
    """

    from ..utils import get_prop

    return cls(get_prop(clip, '_SARNum', int, None, 1), get_prop(clip, '_SARDen', int, None, 1))

def check_cb(self, akarin: bool | None = None) -> Callable[[vs.VideoFrame], bool]:
    if akarin is None:
        akarin = hasattr(vs.core, 'akarin')

    if akarin:
        return (lambda f: bool(f[0][0, 0]))

    keys = set(self.prop_keys)
    prop_key = next(iter(keys))

    if self is SceneChangeMode.WWXD_SCXVID_UNION:
        return (lambda f: any(f.props[key] == 1 for key in keys))

    if self is SceneChangeMode.WWXD_SCXVID_INTERSECTION:
        return (lambda f: all(f.props[key] == 1 for key in keys))

    return (lambda f: f.props[prop_key] == 1)

def ensure_presence(self, clip: vs.VideoNode, akarin: bool | None = None) -> ConstantFormatVideoNode:
    """Ensures all the frame properties necessary for scene change detection are created."""

    from ..exceptions import CustomRuntimeError
    from ..functions import check_variable_format

    assert check_variable_format(clip, self.ensure_presence)

    stats_clip = list[ConstantFormatVideoNode]()

    if self.is_SCXVID:
        if not hasattr(vs.core, 'scxvid'):
            raise CustomRuntimeError(
                'You are missing scxvid!\n\tDownload it from https://github.com/dubhater/vapoursynth-scxvid',
                self.ensure_presence
            )
        stats_clip.append(clip.scxvid.Scxvid())

    if self.is_WWXD:
        if not hasattr(vs.core, 'wwxd'):
            raise CustomRuntimeError(
                'You are missing wwxd!\n\tDownload it from https://github.com/dubhater/vapoursynth-wwxd',
                self.ensure_presence
            )
        stats_clip.append(clip.wwxd.WWXD())

    return self._prepare_akarin(clip, stats_clip, akarin)

def lambda_cb(self, akarin: bool | None = None) -> Callable[[int, vs.VideoFrame], SentinelT | int]:
    callback = self.check_cb(akarin)
    return (lambda n, f: Sentinel.check(n, callback(f)))

def prepare_clip(self, clip: vs.VideoNode, height: int | Literal[False] = 360, akarin: bool | None = None) -> ConstantFormatVideoNode:
    """
    Prepare a clip for scene change metric calculations.

    The clip will always be resampled to YUV420 8bit if it's not already,
    as that's what the plugins support.

    :param clip:        Clip to process.
    :param height:      Output height of the clip. Smaller frame sizes are faster to process,
                        but may miss more scene changes or introduce more false positives.
                        Width is automatically calculated. `False` means no resizing operation is performed.
                        Default: 360.
    :param akarin:      Use the akarin plugin for speed optimizations. `None` means it will check if its available,
                        and if it is, use it. Default: None.

    :return:            A prepared clip for performing scene change metric calculations on.
    """
    from ..utils import get_w

    if height:
        clip = clip.resize.Bilinear(get_w(height, clip), height, vs.YUV420P8)
    elif not clip.format or (clip.format and clip.format.id != vs.YUV420P8):
        clip = clip.resize.Bilinear(format=vs.YUV420P8)

    return self.ensure_presence(clip, akarin)