Inputs left, results right; scale picker for the comparison

README.md

@@ -12,7 +12,6 @@ pinned: true
 license: mit
 short_description: Zoom any photo to 256x, one 4x step at a time
 tags:
-  - arxiv:2609.06490
   - super-resolution
   - image-to-image
   - diffusion
@@ -34,8 +33,6 @@ from the last.
 - Code: https://github.com/dipta007/OracleZoom
 - Project page: https://dipta007.github.io/OracleZoom/
 - Model: https://huggingface.co/dipta007/OracleZoom
-- Training data: https://huggingface.co/datasets/dipta007/OracleZoom-4KLSDB-train
-- Collection (everything in one place): https://huggingface.co/collections/dipta007/oraclezoom
 
 ## Running it yourself
 
@@ -60,17 +57,3 @@ on three `torch.load` calls, whose default flipped in torch 2.6.
 Past the first step or two there is no ground truth left to recover, so the deep levels are
 plausible detail rather than measured detail. The zoom is a crop of your photo, not a real
 lens moving closer. The paper says which claims we do and do not make.
-
-## Citation
-
-```bibtex
-@misc{dipta2026oraclezoomonpolicyselfdistillationinspired,
-  title={OracleZoom: On-Policy Self-Distillation Inspired Reference-Constrained Recursive Image Super Resolution},
-  author={Shubhashis Roy Dipta and Sourajit Saha and Shaswati Saha and Nobin Sarwar},
-  year={2026},
-  eprint={2609.06490},
-  archivePrefix={arXiv},
-  primaryClass={cs.CV},
-  url={https://arxiv.org/abs/2609.06490}
-}
-```

app.py

@@ -53,8 +53,12 @@ CSS = """
 .contain {max-width:1400px !important}
 footer {display:none !important}
 #zoom-target img {cursor:crosshair}
-/* a deep run wraps to two rows; keep any scrollbar from rendering light on a dark theme */
-#levels, #levels * {scrollbar-color: var(--border-color-primary) transparent}
+/* Let the level strip size itself. Any fixed height is wrong at some window width or depth:
+   too short and it scrolls, too tall and it leaves a dead band. .gallery-container is the one
+   that actually carries the height; styling only the outer block leaves the band behind. */
+#levels, #levels .gallery-container, #levels .grid-wrap {
+  height:auto !important; max-height:none !important; min-height:0 !important;
+  overflow:visible !important; flex-grow:0 !important}
 """
 
 
@@ -88,13 +92,10 @@ def pick_point(evt: gr.SelectData):
 
 
 def _gallery_paths(gallery):
-    """The (path, label) pairs Gradio hands back for a Gallery value."""
-    out = []
-    for item in gallery or []:
-        img = item.get("image", item) if isinstance(item, dict) else item
-        path = img.get("path") if isinstance(img, dict) else img
-        out.append((path, (item.get("caption") if isinstance(item, dict) else None) or ""))
-    return out
+    """Gradio hands a Gallery back to a handler as (media, caption) tuples, media being a path
+    because the component is filepath-typed. Not dicts, which is what the payload looks like."""
+    return [(item[0], item[1] or "") for item in gallery or []
+            if isinstance(item, (tuple, list)) and len(item) == 2]
 
 
 def pick_scale(gallery, cx, cy, choice):
@@ -120,14 +121,14 @@ def scale_choices(levels):
     return [label(UPSCALE ** n) for n in range(1, int(levels) + 1)]
 
 
-GALLERY_ROW_H = 245
+CLIP_H = 480          # tuned so the right column ends level with the Zoom in button
 
 
 def gallery_shape(levels):
-    """One row up to five levels, two beyond. Tall enough that neither row ever scrolls."""
+    """One row up to five levels, two beyond. Height is left to CSS, which hugs the content."""
     items = int(levels) + 1
     rows = 1 if items <= 5 else 2
-    return gr.update(columns=-(-items // rows), rows=rows, height=GALLERY_ROW_H * rows)
+    return gr.update(columns=-(-items // rows), rows=rows)
 
 
 def estimate_duration(image, levels, cx, cy):
@@ -183,12 +184,16 @@ def _example_scale_options():
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="amber"), css=CSS,
                title="OracleZoom: zoom past 256x") as demo:
     gr.HTML(HEADER)
-    # Three wide rows, not one tall stack: set it up, watch it, then inspect it. Each row uses
-    # the full width, which is what keeps four large visuals from queueing up vertically.
+    # Inputs down the left, results down the right. Both columns carry real content the whole
+    # way, which is what stops one of them stretching a component into an empty band.
     with gr.Row(equal_height=False):
         with gr.Column(scale=4):
             image = gr.Image(label="Your photo", type="pil", height=300,
                              sources=["upload", "clipboard"])
+            # Inputs only, no fn: the outputs it would fill live further down the page, and
+            # Gradio can only wire components that already exist.
+            gr.Examples(examples=[f"samples/{n}.png" for n in SAMPLES], inputs=[image],
+                        label="Or try any of these")
             # Seeded with the example so the box overlay explains itself before any upload.
             target = gr.Image(value=preview(None, 4, 0.5, 0.5), elem_id="zoom-target",
                               label="Click to move the zoom point", type="pil",
@@ -202,37 +207,21 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="amber"), css=CSS,
                                     f"Fewer steps finish sooner.")
             go = gr.Button("🔎 Zoom in", variant="primary", size="lg")
             status = gr.Markdown("Showing an example. Upload a photo, then press **Zoom in**.")
+            gr.Markdown("##### Vision Language Model at each step:")
+            prompts = gr.Markdown(EXAMPLE_NOTE)
         with gr.Column(scale=6):
             clip = gr.Video(value=EXAMPLE_CLIP, label="The zoom", elem_id="hero", autoplay=True,
-                            loop=True, show_share_button=True, height=470)
-
-    with gr.Row():
-        gallery = gr.Gallery(value=EXAMPLE_LEVELS, label="Every level, start to finish",
-                             elem_id="levels", object_fit="cover", show_download_button=True,
-                             **{k: v for k, v in gallery_shape(len(EXAMPLE_LEVELS) - 1).items()
-                                if k != "__type__"})
-
-    with gr.Row(equal_height=False):
-        with gr.Column(scale=5):
+                            loop=True, show_share_button=True, height=CLIP_H)
+            gallery = gr.Gallery(value=EXAMPLE_LEVELS, label="Every level, start to finish",
+                                 elem_id="levels", object_fit="cover", show_download_button=True,
+                                 **{k: v for k, v in gallery_shape(len(EXAMPLE_LEVELS) - 1).items()
+                                    if k != "__type__"})
             scale = gr.Radio(_example_scale_options(), value=EXAMPLE_LEVELS[-1][1],
                              label="Compare at",
                              info="Left is the plain enlargement that step began from, "
                                   "right is what OracleZoom drew. Switching is free.")
-            compare = gr.ImageSlider(value=EXAMPLE_COMPARE, height=480, elem_id="compare",
+            compare = gr.ImageSlider(value=EXAMPLE_COMPARE, height=470, elem_id="compare",
                                      show_label=False)
-        with gr.Column(scale=5):
-            gr.Markdown("##### Vision Language Model at each step:")
-            prompts = gr.Markdown(EXAMPLE_NOTE)
-
-    with gr.Row():
-        gr.Examples(
-            examples=[f"samples/{n}.png" for n in SAMPLES],
-            inputs=[image],
-            outputs=[status, clip, gallery, compare, prompts, scale],
-            fn=run_example,
-            cache_examples=True,
-            label="Or try one of these (already computed)",
-        )
 
     controls = [image, levels, cx, cy]
     for c in controls:

dev_ui.py

@@ -0,0 +1,52 @@
+"""Run the interface locally with the models stubbed out, for laying out the UI.
+
+No GPU, no weights, no downloads. The fake zoom just bicubic-enlarges, so the pictures are
+meant to be blurry: this is for arranging the page, not for judging output.
+
+    uv run --no-project --python 3.12 --with "gradio==5.50.0" --with spaces --with pillow \
+        --with numpy --with imageio --with imageio-ffmpeg python space/dev_ui.py
+"""
+import os
+import sys
+import types
+
+from PIL import Image
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+os.chdir(HERE)
+
+import geometry  # noqa: E402  (after the path insert, on purpose)
+
+FAKE_PROMPTS = [
+    "spotted fur, whiskers, amber eye, fine hairs",
+    "dense guard hairs, rosette edge, warm tones",
+    "single hair shafts, follicle, soft focus",
+    "fine keratin fibre, grain, pale strands",
+    "fibre bundle, faint striations",
+    "surface texture, low contrast",
+    "granular detail, muted",
+    "flat texture, little structure",
+]
+
+
+def fake_zoom(models, image, levels=4, upscale=4, center=(0.5, 0.5)):
+    cur = geometry.resize_and_center_crop(image)
+    yield 0, 1, "", cur, cur
+    for i in range(levels):
+        blurry = geometry.zoom_window(cur, upscale, center).resize(cur.size, Image.BICUBIC)
+        yield i + 1, upscale ** (i + 1), FAKE_PROMPTS[i % len(FAKE_PROMPTS)], blurry, blurry
+        cur = blurry
+
+
+stub = types.ModuleType("zoom")
+stub.Models = type("Models", (), {"__init__": lambda self, weights=None: None})
+stub.zoom = fake_zoom
+sys.modules["zoom"] = stub
+
+import app  # noqa: E402  (must follow the stub)
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", "7861"))
+    print(f"stubbed UI on http://127.0.0.1:{port}  (blurry output is expected)")
+    app.demo.queue().launch(server_port=port, quiet=True)

test_app_smoke.py

@@ -113,20 +113,36 @@ def test_the_scale_picker_offers_one_option_per_step(app):
     assert "input" not in app.scale_choices(app.MAX_STEPS)
 
 
+def as_gallery_input(levels):
+    """What Gradio actually hands a handler for a filepath Gallery: (path, caption) tuples.
+    Passing dicts here instead is what hid a real bug: the picker silently did nothing."""
+    return [(path, caption) for path, caption in levels]
+
+
+def test_a_gallery_input_is_parsed_as_media_caption_tuples(app):
+    got = app._gallery_paths(as_gallery_input(app.EXAMPLE_LEVELS))
+    assert got == [(p, c) for p, c in app.EXAMPLE_LEVELS]
+
+
 def test_switching_scale_rebuilds_the_pair_without_the_gpu(app):
     """Runs off the level images already on screen, so it must not touch zoom.zoom."""
-    gallery = [{"image": {"path": p}, "caption": c} for p, c in app.EXAMPLE_LEVELS]
-    left, right = app.pick_scale(gallery, 0.5, 0.5, "16x")
-    assert left.size == right.size == (512, 512)
-    from PIL import Image
     import numpy as np
+    from PIL import Image
+    left, right = app.pick_scale(as_gallery_input(app.EXAMPLE_LEVELS), 0.5, 0.5, "16x")
+    assert left.size == right.size == (512, 512)
     expected = np.asarray(Image.open("samples/example_16x.png").convert("RGB"))
     assert np.array_equal(np.asarray(right), expected)
 
 
+def test_every_offered_scale_can_be_switched_to(app):
+    for _, caption in app.EXAMPLE_LEVELS[1:]:
+        pair = app.pick_scale(as_gallery_input(app.EXAMPLE_LEVELS), 0.5, 0.5, caption)
+        assert pair[0].size == pair[1].size == (512, 512), caption
+
+
 def test_switching_to_a_scale_that_was_not_run_changes_nothing(app):
     import gradio as gr
-    gallery = [{"image": {"path": p}, "caption": c} for p, c in app.EXAMPLE_LEVELS]
+    gallery = as_gallery_input(app.EXAMPLE_LEVELS)
     assert app.pick_scale(gallery, 0.5, 0.5, "65536x") == gr.skip()
     assert app.pick_scale(gallery, 0.5, 0.5, "input") == gr.skip()
 
@@ -136,16 +152,21 @@ def test_the_level_strip_wraps_to_two_rows_instead_of_scrolling(app):
     for steps in (1, 2, 3, 4):
         shape = app.gallery_shape(steps)
         assert shape["rows"] == 1 and shape["columns"] == steps + 1
-        assert shape["height"] == app.GALLERY_ROW_H
     for steps in (5, 6, 7, 8):
         shape = app.gallery_shape(steps)
         items = steps + 1
         assert shape["rows"] == 2
-        assert shape["height"] == 2 * app.GALLERY_ROW_H
         # every item has a cell, and no more than one cell goes spare
         assert shape["columns"] * 2 >= items > shape["columns"] * 2 - 2
 
 
+def test_the_strip_never_pins_a_height(app):
+    """A fixed height is wrong at some width: too short scrolls, too tall leaves a dead band.
+    CSS hugs the content instead, so nothing here may set height."""
+    assert all("height" not in app.gallery_shape(n) for n in range(1, app.MAX_STEPS + 1))
+    assert "#levels" in app.CSS and "height:auto !important" in app.CSS
+
+
 def test_a_deep_run_labels_every_level(app, photo):
     _, clip, gallery, _, _, scale = list(app.run(photo, app.MAX_STEPS, 0.5, 0.5))[-1]
     try: