nativeres 0.1.0__py3-none-any.whl

nativeres/__init__.py

@@ -0,0 +1,3 @@
+from .funcs import get_dct_distribution, get_descale_error, getfnative, getfscaler, getnative, getscaler
+
+__all__ = ["get_dct_distribution", "get_descale_error", "getfnative", "getfscaler", "getnative", "getscaler"]

nativeres/cli/__init__.py

@@ -0,0 +1,313 @@
+"""CLI module"""
+
+import sys
+import warnings
+from itertools import zip_longest
+from logging import INFO, basicConfig, captureWarnings, getLogger
+from typing import Annotated, Any, Literal, assert_never, cast
+
+from jetpytools import SPath
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.pretty import pretty_repr
+from rich.progress import BarColumn, Progress, TextColumn
+from rich.style import Style
+from rich.table import Table
+from vskernels import ComplexKernel
+from vsmasktools import EdgeDetect
+from vssource import Indexer
+
+from .. import funcs
+from ..constants import HIGH_RATE, LOW_RATE
+from ..kernels import default_kernels
+from .components import (
+    app,
+    base_dim_opt,
+    crop_opt,
+    cull_rate_opt,
+    debug_opt,
+    dim_mode_opt,
+    dim_opt,
+    frame_opt,
+    global_debug_opt,
+    indexer_opt,
+    input_file_arg,
+    kernel_opt,
+    mask_opt,
+    metric_mode_opt,
+    radius_opt,
+    range_dim_opt,
+    show_default_kernels_opt,
+    show_vskernels_opt,
+    step_opt,
+)
+from .helpers import get_progress, get_videonode_from_input
+
+console = Console(stderr=True)
+
+warnings.filterwarnings("always")
+captureWarnings(True)
+basicConfig(
+    level=INFO,
+    handlers=[RichHandler(console=console)],
+    format="{name}: {message}",
+    style="{",
+)
+
+logger = getLogger(__name__)
+
+
+@app.callback()
+def callback(
+    show_kernels: Annotated[bool, show_default_kernels_opt] = False,
+    show_vskernels: Annotated[bool, show_vskernels_opt] = False,
+    debug: Annotated[bool, debug_opt] = False,
+    global_debug: Annotated[bool, global_debug_opt] = False,
+) -> None:
+    """Descale analysis tools for VapourSynth."""
+    ...
+
+
+@app.command(
+    help="[bold]Determine the native resolution of upscaled material.[/]\n\n"
+    "Analyzes a range of dimensions to find which one produces the lowest error when inverse scaled.\n"
+    "Primary use case is finding the native resolution of upscaled anime.",
+    no_args_is_help=True,
+)
+def getnative(
+    input_file: Annotated[SPath, input_file_arg],
+    range_dim: Annotated[tuple[int, int] | None, range_dim_opt] = None,
+    dim_mode: Annotated[Literal["height", "width"], dim_mode_opt] = "height",
+    kernel: Annotated[ComplexKernel, kernel_opt] = cast(ComplexKernel, "bilinear"),
+    frame: Annotated[int, frame_opt] = 0,
+    step: Annotated[float, step_opt] = 1,
+    crop: Annotated[tuple[int, int, int, int] | None, crop_opt] = None,
+    metric_mode: Annotated[funcs.MetricMode, metric_mode_opt] = "MAE",
+    indexer: Annotated[Indexer, indexer_opt] = cast(Indexer, "bs"),
+) -> None:
+    import numpy as np
+    from PySide6.QtWidgets import QApplication, QMainWindow, QStyle
+
+    from ..plotting import RescalePlotWidget
+
+    clip = get_videonode_from_input(input_file, indexer)
+
+    # Resolve dimension and the range of dimensions to check
+    if range_dim:
+        start, stop = range_dim
+    else:
+        match dim_mode:
+            case "height":
+                dim = clip.height
+            case "width":
+                dim = clip.width
+            case _:
+                assert_never(dim_mode)
+
+        start, stop = int(dim * LOW_RATE), int(dim * HIGH_RATE)
+
+    # Build the list of dims (int or fractional)
+    step_f = float(step)
+    if step_f.is_integer():
+        dims = range(start, stop + 1, int(step_f))
+        x_label_fmt = "%.0f"
+    else:
+        num = int((stop - start) / step_f) + 1
+        dims = np.linspace(start, start + step_f * (num - 1), num).tolist()
+        x_label_fmt = f"%.{str(step_f)[::-1].find('.') + 1}f"
+
+    # Pair with the fixed dimension
+    match dim_mode:
+        case "height":
+            dimensions = zip_longest([clip.width], dims, fillvalue=clip.width)
+        case "width":
+            dimensions = zip_longest(dims, [clip.height], fillvalue=clip.height)
+        case _:
+            assert_never(dim_mode)
+
+    # Pretty progress
+    progress = get_progress(console)
+    gtask_id = progress.add_task("Gathering data...", total=None)
+
+    logger.debug(kernel)
+
+    with progress:
+        results = funcs.getnative(
+            clip,
+            frame,
+            dimensions,
+            kernel,
+            crop,
+            metric_mode=metric_mode,
+            progress_cb=lambda curr, total: progress.update(gtask_id, advance=1, total=total, visible=True),
+        )
+        progress.update(gtask_id, total=100, completed=100, refresh=True)
+
+    dims, errors = zip(*results)
+
+    # Show the plot window
+    app = QApplication(sys.argv)
+    win = QMainWindow()
+    win.setWindowTitle("Native Resolution Analysis")
+    win.setWindowIcon(win.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogContentsView))
+    win.resize(1000, 600)
+
+    plot = RescalePlotWidget(
+        f"Error plot - {kernel.pretty_string} on {dim_mode}",
+        [getattr(d, dim_mode) for d in dims],
+        errors,
+        dim_mode.title(),
+    )
+    plot.axis_x.setLabelFormat(x_label_fmt)
+
+    win.setCentralWidget(plot)
+
+    win.show()
+    app.exec()
+
+
+@app.command(
+    help="[bold]Identify the best inverse scaler for a given resolution.[/]\n\n"
+    "Compares multiple kernels against a specific target resolution to determine which one "
+    "was likely used for the original upscaling.",
+    epilog="""
+[dim]Notes:
+
+ - getscaler gives heuristic results; it's not infallible.
+
+ - Always visually verify the suggested scaler and parameters on multiple frames before trusting them.[/dim]
+""",
+    no_args_is_help=True,
+)
+def getscaler(
+    input_file: Annotated[SPath, input_file_arg],
+    dim: Annotated[float, dim_opt],
+    dim_mode: Annotated[Literal["height", "width"], dim_mode_opt] = "height",
+    base_dim_opt: Annotated[int | None, base_dim_opt] = None,
+    kernels: Annotated[list[ComplexKernel], kernel_opt] = [],
+    frame: Annotated[int, frame_opt] = 0,
+    crop: Annotated[tuple[int, int, int, int] | None, crop_opt] = None,
+    metric_mode: Annotated[funcs.MetricMode, metric_mode_opt] = "MAE",
+    mask: Annotated[type[EdgeDetect] | None, mask_opt] = None,
+    indexer: Annotated[Indexer, indexer_opt] = cast(Indexer, "bs"),
+) -> None:
+    clip = get_videonode_from_input(input_file, indexer)
+
+    # Resolve dimension to check
+    scaler_args: dict[str, Any] = {
+        "width": clip.width,
+        "height": clip.height,
+        dim_mode: dim,
+        f"base_{dim_mode}": base_dim_opt,
+    }
+
+    progress = Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        console=console,
+        transient=True,
+    )
+    task = progress.add_task("Gathering data...", total=None)
+
+    with progress:
+        ress = funcs.getscaler(
+            clip,
+            frame,
+            kernels=(*default_kernels, *kernels),
+            crop=crop,
+            metric_mode=metric_mode,
+            mask=mask,
+            **scaler_args,
+        )
+    progress.update(task, completed=100, total=100, visible=False, refresh=True)
+
+    # Results are sorted and displayed to the CLI for the user
+    sorted_ress = sorted(ress, key=lambda r: r.error)
+    best = sorted_ress[0]
+
+    logger.debug("%s", pretty_repr(sorted_ress, max_width=200, indent_size=2))
+
+    width, height = scaler_args["width"], scaler_args["height"]
+
+    dwidth = f"{width:.0f}" if float(width).is_integer() else f"{width:.3f}"
+    dheight = f"{height:.0f}" if float(height).is_integer() else f"{height:.3f}"
+
+    table = Table(
+        title=f"Results for frame {frame} — Resolution: {dwidth}x{dheight}",
+        title_style=Style(bold=True),
+        caption=f"Smallest error archieved by {best.kernel.pretty_string}: {best.error:.13f}",
+        caption_style=Style(bold=True, dim=True),
+        caption_justify="left",
+        min_width=80,
+    )
+    table.add_column("Kernel")
+    table.add_column("Error %", justify="center")
+    table.add_column(metric_mode, justify="right")
+
+    for res in sorted_ress:
+        table.add_row(
+            res.kernel.pretty_string, f"{res.error * 100 / best.error if best.error else 0:.2f} %", f"{res.error:.13f}"
+        )
+
+    console.rule()
+    console.print(table, new_line_start=True)
+    console.rule()
+    console.print(
+        "Getfscaler is not infallible!\n"
+        "Always visually verify the suggested scaler and parameters on multiple frames before trusting them.",
+        style=Style(color="yellow", dim=True),
+    )
+
+
+@app.command(
+    help="[bold]Visualize the frequency distribution of a frame.[/]\n\n"
+    "Calculates the Discrete Cosine Transform (DCT) of the image rows/columns "
+    "to identify spikes that may indicate the native resolution or scaling artifacts.",
+    no_args_is_help=True,
+)
+def getfreq(
+    input_file: Annotated[SPath, input_file_arg],
+    frame: Annotated[int, frame_opt] = 0,
+    cull_rate: Annotated[float, cull_rate_opt] = 3.0,
+    radius: Annotated[int, radius_opt] = 50,
+    indexer: Annotated[Indexer, indexer_opt] = cast(Indexer, "bs"),
+) -> None:
+    from PySide6.QtWidgets import QApplication, QMainWindow, QStyle
+
+    from ..funcs import get_dct_distribution
+    from ..plotting import FrequencyPlotWidget
+
+    clip = get_videonode_from_input(input_file, indexer)
+
+    progress = get_progress(console)
+    task = progress.add_task("Calculating DCT distribution...", total=None)
+
+    with progress:
+        dct_h, dct_v = get_dct_distribution(clip, frame, cull_rate=cull_rate)
+        progress.update(task, completed=100, total=100, visible=False, refresh=True)
+
+    min_val_h, max_val_h = int(clip.width * LOW_RATE), int(clip.width * HIGH_RATE)
+    min_val_v, max_val_v = int(clip.height * LOW_RATE), int(clip.height * HIGH_RATE)
+
+    # Show the plot window
+    app = QApplication(sys.argv)
+    win = QMainWindow()
+    win.setWindowTitle("Frequency Analysis")
+    win.setWindowIcon(win.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogContentsView))
+    win.resize(1000, 600)
+
+    plot = FrequencyPlotWidget(
+        f"DCT Frequency - {input_file.name}",
+        dct_h,
+        dct_v,
+        min_val_h,
+        max_val_h,
+        min_val_v,
+        max_val_v,
+        check_radius=radius,
+    )
+
+    win.setCentralWidget(plot)
+
+    win.show()
+    app.exec()

nativeres/cli/components.py

@@ -0,0 +1,171 @@
+from click import BadParameter
+from jetpytools import SPath
+from typer import Argument, Option, Typer
+from vsmasktools import EdgeDetect
+
+from ..funcs import resolve_kernel
+from .helpers import (
+    resolve_dimension,
+    resolve_dimension_mode,
+    resolve_idx,
+    set_debug,
+    set_global_debug,
+    show_default_kernels,
+    show_vskernels,
+)
+
+# DEBUG
+debug_opt = Option(
+    "--debug",
+    help="Enable debug output.",
+    hidden=True,
+    is_eager=True,
+    callback=set_debug,
+)
+global_debug_opt = Option(
+    "--global-debug",
+    help="Enable global debug output.",
+    hidden=True,
+    is_eager=True,
+    callback=set_global_debug,
+)
+
+
+# App
+app = Typer(
+    name="nativeres",
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=True,
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+# Commons
+input_file_arg = Argument(
+    help="Path to the source material to analyze. "
+    "Supports videos, images, or VapourSynth scripts. For scripts, the first output is used.",
+    metavar="INPUT",
+    resolve_path=True,
+    parser=SPath,
+)
+frame_opt = Option(
+    "--frame",
+    "-f",
+    help="The specific frame number to extract and analyze from video inputs. Ignored for images.",
+    metavar="INTEGER",
+    rich_help_panel="Common",
+)
+kernel_opt = Option(
+    "--kernel",
+    "-k",
+    help="The kernel(s) to use for inverse scaling.\n\n"
+    "Can be a kernel name or a class call with parameters (e.g., 'Bicubic(b=0, c=0.5)').\n\n"
+    "Use --show-kernels for a list of available kernels.",
+    metavar="Kernel|Kernel(arg0=..., arg1=...)",
+    parser=lambda v: resolve_kernel(v, BadParameter),
+    rich_help_panel="Common",
+)
+
+dim_mode_opt = Option(
+    "--dim-mode",
+    "-dm",
+    help="Specifies whether to analyze based on the [bold]height[/] or [bold]width[/] of the frame.",
+    metavar="height|width|h|w",
+    parser=resolve_dimension_mode,
+    rich_help_panel="Common",
+)
+crop_opt = Option(
+    "--crop",
+    "-c",
+    help="Crop the input frame before analysis to remove black bars.\n\n"
+    "Format: [bold]LEFT RIGHT TOP BOTTOM[/] (e.g., '0 0 240 240').",
+    metavar="L R T B",
+    rich_help_panel="Common",
+)
+metric_mode_opt = Option(
+    "--metric-mode",
+    "-mm",
+    help="The mathematical metric used to compare scaling results.\n\n"
+    "- [bold]MAE[/] (Mean Absolute Error)\n\n"
+    "- [bold]MSE[/] (Mean Squared Error)\n\n"
+    "- [bold]RMSE[/] (Root Mean Squared Error)",
+    metavar="MAE|MSE|RMSE",
+    parser=lambda value: value.upper(),
+    rich_help_panel="Common",
+)
+indexer_opt = Option(
+    "--indexer",
+    "-idx",
+    help="The VapourSynth indexer used to load files.\n\nSpecifying the plugin namespace is also allowed (e.g., 'bs').",
+    metavar="STRING",
+    parser=resolve_idx,
+    show_default="BestSource",
+    rich_help_panel="Common",
+)
+
+# Helpers
+show_default_kernels_opt = Option(
+    "--show-kernels",
+    help="Show the default checked kernels for getscaler and exit.",
+    is_eager=True,
+    show_default=False,
+    callback=show_default_kernels,
+    rich_help_panel="Helpers",
+)
+show_vskernels_opt = Option(
+    "--show-vskernels",
+    help="Show the builtin supported kernels from vskernels and exit.",
+    is_eager=True,
+    show_default=False,
+    callback=show_vskernels,
+    rich_help_panel="Helpers",
+)
+
+# getnative exclusive
+range_dim_opt = Option(
+    "--range-dim",
+    "-rd",
+    help="The inclusive range of resolutions to test.\n\nSpecify as [bold]START END[/] (e.g., '500 1080').",
+    metavar="INTEGER INTEGER",
+    show_default=False,
+)
+step_opt = Option("--step", "-s", help="The increment step between resolutions in the tested range.", metavar="NUMBER")
+
+
+# getscaler exclusive
+dim_opt = Argument(
+    help="The suspected native resolution to verify. "
+    "Use an integer for exact pixels (e.g., 720) or a float for sub-pixel dimensions (e.g., 719.8).",
+    metavar="NUMBER",
+    parser=resolve_dimension,
+)
+base_dim_opt = Option(
+    "--base-dim",
+    "-b",
+    help="Base integer dimension if checking for fractional resolution.",
+)
+mask_opt = Option(
+    "--mask",
+    "-m",
+    help="Edge-detection mask to reduce noise influence on the metric. "
+    "Pass a mask name (e.g., 'Prewitt') or a class name from vsmasktools.",
+    metavar="EDGEDETECT",
+    parser=EdgeDetect.from_param,
+)
+
+
+# Frequency exclusive
+cull_rate_opt = Option(
+    "--cull-rate",
+    "-cr",
+    help="Cull the sides/top of the frame to focus on the center.",
+    metavar="NUMBER",
+    show_default=True,
+)
+radius_opt = Option(
+    "--radius",
+    "-r",
+    help="Radius for finding peaks/spikes in the frequency plot.",
+    metavar="INTEGER",
+    show_default=True,
+)

nativeres/cli/helpers.py

@@ -0,0 +1,115 @@
+from logging import DEBUG, getLogger
+from typing import Any
+
+from jetpytools import CustomValueError, SPath, get_subclasses
+from rich.console import Console
+from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn, TimeRemainingColumn
+from typer import BadParameter, Exit
+from vskernels import ComplexKernel
+from vssource import BestSource, CacheIndexer, Indexer
+from vstools import Matrix, vs
+
+
+# Callbacks
+def resolve_dimension(value: str) -> float:
+    nb = float(value)
+
+    if nb.is_integer():
+        return int(nb)
+
+    return nb
+
+
+def resolve_idx(idx: str) -> Indexer:
+    indexer = Indexer.from_param(idx, BadParameter)
+
+    args = dict[str, Any]()
+
+    if issubclass(indexer, CacheIndexer):
+        # Set cache path to None
+        args[indexer._cache_arg_name] = None
+
+        if issubclass(indexer, BestSource):
+            args["show_pretty_progress"] = True
+
+    return indexer(**args)
+
+
+def resolve_dimension_mode(mode: str) -> str:
+    match mode:
+        case "height" | "h":
+            return "height"
+        case "width" | "w":
+            return "width"
+        case _:
+            raise BadParameter("Unknown dimension passed")
+
+
+def set_debug(value: bool) -> None:
+    if value:
+        getLogger((__package__ or "").split(".")[0]).setLevel(DEBUG)
+
+
+def set_global_debug(value: bool) -> None:
+    if value:
+        getLogger().setLevel(DEBUG)
+
+
+def show_default_kernels(value: bool) -> None:
+    if value:
+        from ..kernels import default_kernels
+
+        console = Console(stderr=True)
+
+        for kernel in default_kernels:
+            console.print(str(kernel))
+
+        raise Exit(0)
+
+
+def show_vskernels(value: bool) -> None:
+    if value:
+        all_kernels = {k for k in get_subclasses(ComplexKernel) if not k.is_abstract}
+
+        console = Console(stderr=True)
+
+        for kernel in sorted(all_kernels, key=lambda k: k.__name__):
+            console.print(kernel.__name__)
+
+        raise Exit(0)
+
+
+# Helpers
+def get_videonode_from_input(path: SPath, indexer: Indexer) -> vs.VideoNode:
+    if not path.exists():
+        raise BadParameter(f"{path.to_str()!r} doesn't exist.")
+
+    if path.suffix in (".py", ".vpy"):
+        from vsengine import load_script
+
+        load_script(path, module="__nativeres__").result()
+        out = next(iter(vs.get_outputs().values()))
+
+        if not isinstance(out, vs.VideoOutputTuple):
+            raise CustomValueError("Unknown VapourSynth output", get_videonode_from_input, type(out))
+
+        return out.clip
+
+    if isinstance(indexer, BestSource):
+        from signal import SIG_DFL, SIGINT, signal
+
+        signal(SIGINT, SIG_DFL)
+
+    clip = indexer.source(path, 32, idx_props=False)
+    return clip.resize.Bilinear(format=vs.GRAYS, matrix=Matrix.BT709, matrix_in=Matrix.from_video(clip))
+
+
+def get_progress(console: Console) -> Progress:
+    return Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    )

nativeres/constants.py

@@ -0,0 +1 @@
+LOW_RATE, HIGH_RATE = 0.465, 0.925