other ¶

@classmethod
def from_size(
    cls: type[DarSelf],
    clip_width: vs.VideoNode | int,
    _height: int | Sar | bool = True,
    _sar: Sar | bool = True,
    /,
    func: FuncExceptT | None = None
) -> DarSelf:
    width: int
    height: int
    sar: Sar | Literal[False]

    if isinstance(clip_width, vs.VideoNode):
        from ..functions import check_variable_resolution

        check_variable_resolution(clip_width, func or cls.from_size)

        width, height, sar = clip_width.width, clip_width.height, _height  # type: ignore

        if sar is True:
            sar = Sar.from_clip(clip_width)  # type: ignore
    else:
        width, height, sar = clip_width, _height, _sar if isinstance(_sar, Sar) else False  # type: ignore

    gcd = max_common_div(width, height)

    if sar is False:
        sar = Sar(1, 1)

    return cls(width // gcd * sar.numerator, height // gcd * sar.denominator)

def to_sar(self, active_area: float, 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.
    """
    return Sar.from_dar(self, active_area, height)

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

    key = Fraction(framerate)

    if strict:
        return _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 diffs[0][0]

    return _framerate_region_map[key]

@classmethod
def from_video(cls, clip: vs.VideoNode) -> Resolution:
    """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 Resolution(clip.width, clip.height)

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

    return Resolution(self.height, self.width)

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

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

@classmethod
def from_ar(cls: type[SarSelf], num: int, den: int, active_area: float, height: int) -> SarSelf:
    """
    Calculate the SAR from the given display aspect ratio and active image area.
    This method is used to obtain metadata to set in the video container for anamorphic video.

    For a list of known standards, refer to the following tables:
    `<https://web.archive.org/web/20140218044518/http://lipas.uwasa.fi/~f76998/video/conversion/#conversion_table>`_

    :param num:             The numerator.
    :param den:             The denominator.
    :param active_area:     The active image area.
    :param height:          The height of the image.

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

    return cls(Dar(num, den).to_sar(active_area, height))

@classmethod
def from_clip(cls: type[SarSelf], clip: HoldsPropValueT) -> SarSelf:
    """
    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))

@classmethod
def from_dar(cls: type[SarSelf], dar: Dar, active_area: float, height: int) -> SarSelf:
    """Calculate the SAR using a DAR object. See ``Dar.to_sar`` for more information."""

    sar_n, sar_d = dar.numerator * height, dar.denominator * active_area

    if isinstance(active_area, float):
        sar_n, sar_d = int(sar_n * 10000), int(sar_d * 10000)

    gcd = max_common_div(sar_n, sar_d)

    return cls(sar_n // gcd, sar_d // gcd)

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) -> vs.VideoNode:
    """Ensures all the frame properties necessary for scene change detection are created."""

    from ..exceptions import CustomRuntimeError

    stats_clip = []

    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], Sentinel.Type | int]:
    callback = self.check_cb(akarin)
    return (lambda n, f: Sentinel.check(n, callback(f)))

def prepare_clip(self, clip: vs.VideoNode, height: int | None = 360, akarin: bool | None = None) -> vs.VideoNode:
    """
    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. `None` 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 is not None:
        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)