Accept larger custom uploads with explicit paired demo resizing

README.md

@@ -25,10 +25,16 @@ Upload an aligned reference/distorted pair, select JLD or JLD-fast, and obtain
 a scalar distance plus a local lens response overlay. Lower means more similar.
 The overlay excludes the global CLS term and is normalized separately for each pair.
 
-Both images must have the same native size. The demo converts to RGB and
-center-crops to multiples of 14 pixels without resizing. Public demo resource
-limits are 262,144 pixels, a longest side of 1024 pixels, and 10 MB per image.
-Use the local package for larger images. The pretrained encoder loads on hosted
+Both images must be aligned and have the same size. Uploads may be up to
+24 megapixels, 8192 pixels on the longest side, and 10 MB each. By default,
+large pairs are reduced together with the same Lanczos filter to fit the
+hosted scoring limit of 262,144 pixels and a longest side of 1024 pixels.
+The result reports the original, resized, and scored dimensions. This score
+is for the resized pair. Disable **Resize large pairs for this demo** to
+require native resolution; large pairs then receive an explanatory error.
+Small pairs keep their native pixels. RGB conversion and a center crop to
+multiples of 14 pixels follow the official scorer. Use the local package for
+native-resolution scoring of larger images. The pretrained encoder loads on hosted
 startup, while the fitted lens is included in the package. The hosted Space uses
 free shared ZeroGPU access; queueing and daily usage limits may apply.
 

app.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from functools import lru_cache
+import math
 import os
 from pathlib import Path
 import threading
@@ -23,9 +24,13 @@ HERE = Path(__file__).resolve().parent
 EXAMPLES = HERE / "examples"
 MAX_PIXELS = 262_144
 MAX_SIDE = 1024
+MAX_UPLOAD_PIXELS = 24_000_000
+MAX_UPLOAD_SIDE = 8192
 MAX_FILE_BYTES = 10 * 1024 * 1024
 PATCH = 14
-Image.MAX_IMAGE_PIXELS = MAX_PIXELS
+# Gradio opens images before load_image runs. Its decoding limit must allow
+# uploads larger than the bounded scoring resolution.
+Image.MAX_IMAGE_PIXELS = MAX_UPLOAD_PIXELS
 warnings.filterwarnings("error", category=Image.DecompressionBombWarning)
 torch.set_num_threads(min(4, max(1, int(os.environ.get("JLD_CPU_THREADS", "2")))))
 MODEL_LOCK = threading.Lock()
@@ -58,9 +63,9 @@ def load_image(path: str | None) -> Image.Image:
             width, height = image.size
             if width < PATCH or height < PATCH:
                 raise gr.Error("Each image must be at least 14 pixels wide and high.")
-            if width * height > MAX_PIXELS or max(width, height) > MAX_SIDE:
+            if width * height > MAX_UPLOAD_PIXELS or max(width, height) > MAX_UPLOAD_SIDE:
                 raise gr.Error(
-                    "This demo accepts at most 262,144 pixels per image and a longest side of 1024 pixels. "
+                    "This demo accepts uploads up to 24 megapixels and a longest side of 8192 pixels. "
                     "Use the local package to score larger images at their native resolution."
                 )
             if getattr(image, "n_frames", 1) > 1:
@@ -69,7 +74,7 @@ def load_image(path: str | None) -> Image.Image:
     except gr.Error:
         raise
     except (Image.DecompressionBombWarning, Image.DecompressionBombError):
-        raise gr.Error("Image dimensions exceed this demo's memory limit.") from None
+        raise gr.Error("Upload exceeds the 24-megapixel image limit.") from None
     except (OSError, ValueError):
         raise gr.Error("Could not read the image. Please use a PNG, JPEG, or WebP image.") from None
 
@@ -111,24 +116,52 @@ def map_overlay(reference: Image.Image, patch_map: np.ndarray) -> Image.Image:
     return Image.blend(gray, heat, 0.6)
 
 
-def score_pair(reference_path: str | None, distorted_path: str | None, variant: str):
-    if variant not in ("full", "fast"):
-        raise gr.Error("Choose full or fast.")
-    reference, distorted = load_image(reference_path), load_image(distorted_path)
+def prepare_pair(reference: Image.Image, distorted: Image.Image, resize_large: bool):
+    """Apply the same explicit demo reduction to an aligned image pair."""
     if reference.size != distorted.size:
         raise gr.Error(
-            f"Images must have exactly the same native size: reference {reference.size}, "
-            f"distorted {distorted.size}. This demo does not resize or align your images."
+            f"Images must have exactly the same size: reference {reference.size}, "
+            f"distorted {distorted.size}. Upload an aligned pair; resizing does not align different images."
         )
+    width, height = reference.size
+    scale = min(1.0, math.sqrt(MAX_PIXELS / (width * height)), MAX_SIDE / width, MAX_SIDE / height)
+    if scale == 1.0:
+        return reference, distorted
+    if not resize_large:
+        raise gr.Error(
+            "This pair is too large for native-resolution scoring in the hosted demo. "
+            "Enable 'Resize large pairs for this demo' or use the local package at native resolution."
+        )
+    size = (int(width * scale), int(height * scale))
+    if min(size) < PATCH:
+        raise gr.Error("This aspect ratio is too narrow for the demo. Crop both images to the same region.")
+    return (reference.resize(size, Image.Resampling.LANCZOS),
+            distorted.resize(size, Image.Resampling.LANCZOS))
+
+
+def score_pair(reference_path: str | None, distorted_path: str | None, variant: str,
+               resize_large: bool = True):
+    if variant not in ("full", "fast"):
+        raise gr.Error("Choose full or fast.")
+    reference, distorted = load_image(reference_path), load_image(distorted_path)
+    native_size = reference.size
+    reference, distorted = prepare_pair(reference, distorted, resize_large)
     # Serialize calls even through direct API usage, including first model initialization.
     with MODEL_LOCK:
         value, patch_map = compute_distance_and_map(reference, distorted, variant)
     height, width = patch_map.shape[0] * PATCH, patch_map.shape[1] * PATCH
     name = "JLD" if variant == "full" else "JLD-fast"
+    if reference.size == native_size:
+        resolution = f"Native image size: {native_size[0]} × {native_size[1]}; no resizing."
+    else:
+        resolution = (
+            f"**Demo resize:** both images reduced from {native_size[0]} × {native_size[1]} "
+            f"to {reference.width} × {reference.height} with the same Lanczos filter. "
+            "This distance is measured on the resized pair. Use the local package for native-resolution scores."
+        )
     details = (
         f"**{name}: {value:.6f}**. Lower means more similar to the reference. "
-        f"Scored RGB crop: **{width} × {height} pixels**, from native "
-        f"{reference.width} × {reference.height}; no resizing.\n\n"
+        f"Scored RGB crop: **{width} × {height} pixels**. {resolution}\n\n"
         "The overlay shows **local projected patch displacement**, after the chroma prefilter. "
         "It excludes the global CLS term used by full JLD. Brighter colours mark larger local "
         "displacements. Colours are normalized to this pair's maximum, so do not compare colour "
@@ -147,26 +180,29 @@ def build_demo() -> gr.Blocks:
         )
         with gr.Row():
             reference = gr.Image(value=str(EXAMPLES / "parrots.png"), label="Reference image",
-                                 type="filepath", sources=["upload"], height=280)
+                                 type="filepath", sources=["upload"], height=280, interactive=True)
             distorted = gr.Image(value=str(EXAMPLES / "parrots_jpeg_q8.png"), label="Distorted image",
-                                 type="filepath", sources=["upload"], height=280)
+                                 type="filepath", sources=["upload"], height=280, interactive=True)
         variant = gr.Radio(
             choices=[("JLD: lens + global CLS term", "full"), ("JLD-fast: lens term only", "fast")],
             value="fast", label="Variant",
         )
         gr.Markdown(
-            "Use **aligned images of the same native size**. Both are converted to RGB and center-cropped "
-            "to multiples of 14 pixels. The demo keeps image resolution and accepts up to 262,144 pixels "
-            "per image, a longest side of 1024 pixels, and files up to 10 MB. "
+            "Upload **aligned images of the same size**, up to 24 megapixels, 8192 pixels on the longest "
+            "side, and 10 MB each. Large pairs can be resized together for this demo; the result shows "
+            "the actual scoring resolution. Smaller pairs keep their native resolution. "
+            "Scoring converts to RGB and center-crops to multiples of 14 pixels. "
             "The hosted demo uses free shared GPU access; queueing and daily usage limits may apply."
         )
+        resize_large = gr.Checkbox(value=True, label="Resize large pairs for this demo",
+                                  info="Uses the same scale for both images, up to 262,144 pixels and a longest side of 1024.")
         run = gr.Button("Compute distance and local map", variant="primary")
         with gr.Row():
             distance = gr.Number(value=None, label="Distance (lower means more similar)", precision=6,
                                  placeholder="Compute a pair to see its distance", interactive=False)
             response = gr.Image(label="Local lens response overlay (excludes CLS)", type="pil", height=300)
         explanation = gr.Markdown()
-        run.click(score_pair, [reference, distorted, variant], [distance, response, explanation],
+        run.click(score_pair, [reference, distorted, variant, resize_large], [distance, response, explanation],
                   api_name="score_pair", concurrency_limit=1, concurrency_id="jld")
         gr.Examples(
             examples=[

test_app.py

@@ -0,0 +1,100 @@
+"""Public-demo input checks and native-resolution rendering behavior."""
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+from PIL import Image
+import pytest
+
+import app
+
+
+def image_file(tmp_path: Path, size: tuple[int, int], name: str = "image.png") -> str:
+    path = tmp_path / name
+    Image.new("RGB", size, color=(60, 80, 100)).save(path)
+    return str(path)
+
+
+def test_missing_upload():
+    with pytest.raises(gr.Error, match="Choose both"):
+        app.load_image(None)
+
+
+@pytest.mark.parametrize("size", [(13, 100), (100, 13), (8193, 14)])
+def test_image_resource_limits(tmp_path, size):
+    with pytest.raises(gr.Error):
+        app.load_image(image_file(tmp_path, size))
+
+
+def test_upload_pixel_limit_checked_before_decoding(tmp_path, monkeypatch):
+    monkeypatch.setattr(app, "MAX_UPLOAD_PIXELS", 100)
+    with pytest.raises(gr.Error, match="24 megapixels"):
+        app.load_image(image_file(tmp_path, (14, 14)))
+
+
+def test_gradio_preprocessing_accepts_large_custom_upload(tmp_path):
+    component = gr.Image(type="filepath")
+    payload = component.data_model(path=image_file(tmp_path, (1400, 1120)))
+    path = component.preprocess(payload)
+    assert app.load_image(path).size == (1400, 1120)
+
+
+def test_large_aligned_pair_reduced_with_identical_filter():
+    image = Image.new("RGB", (1400, 1120), color=(60, 80, 100))
+    reference, distorted = app.prepare_pair(image, image.copy(), True)
+    assert reference.size == distorted.size
+    assert reference.width * reference.height <= app.MAX_PIXELS
+    assert max(reference.size) <= app.MAX_SIDE
+    assert abs(reference.width / reference.height - 1400 / 1120) < 0.01
+    assert np.array_equal(np.asarray(reference), np.asarray(distorted))
+
+
+def test_native_scoring_rejects_large_pair_before_model_load(tmp_path, monkeypatch):
+    def unexpected_score(*args):
+        raise AssertionError("Do not score a pair that exceeds the hosted resolution limit")
+    monkeypatch.setattr(app, "compute_distance_and_map", unexpected_score)
+    path = image_file(tmp_path, (1400, 1120))
+    with pytest.raises(gr.Error, match="Enable.*Resize large pairs"):
+        app.score_pair(path, path, "fast", False)
+
+
+def test_small_pair_keeps_original_pixels():
+    image = Image.new("RGB", (31, 43))
+    reference, distorted = app.prepare_pair(image, image, True)
+    assert reference is image and distorted is image
+
+
+def test_resized_result_reports_actual_scoring_grid(tmp_path, monkeypatch):
+    def score(reference, distorted, variant):
+        assert reference.size == distorted.size
+        return 0.25, np.zeros((reference.height // app.PATCH, reference.width // app.PATCH))
+    monkeypatch.setattr(app, "compute_distance_and_map", score)
+    path = image_file(tmp_path, (1400, 1120))
+    value, overlay, details = app.score_pair(path, path, "fast", True)
+    assert value == 0.25
+    assert "Demo resize" in details and "1400 × 1120" in details
+    assert "resized pair" in details
+    assert overlay.width * overlay.height <= app.MAX_PIXELS
+
+
+def test_mismatched_native_sizes_rejected_before_metric_load(tmp_path, monkeypatch):
+    def unexpected_model():
+        raise AssertionError("Do not load the encoder for an invalid pair")
+    monkeypatch.setattr(app, "metrics", unexpected_model)
+    with pytest.raises(gr.Error, match="same size"):
+        app.score_pair(image_file(tmp_path, (28, 28), "ref.png"),
+                       image_file(tmp_path, (29, 28), "dist.png"), "fast")
+
+
+def test_overlay_uses_native_center_crop():
+    reference = Image.new("RGB", (31, 43))
+    overlay = app.map_overlay(reference, np.zeros((3, 2), dtype=np.float32))
+    assert overlay.size == (28, 42)
+
+
+def test_supported_format_conversion_retains_dimensions(tmp_path):
+    path = tmp_path / "gray.png"
+    Image.new("L", (31, 43), color=80).save(path)
+    image = app.load_image(str(path))
+    assert image.mode == "RGB"
+    assert image.size == (31, 43)