feat: two-stage accordion UI (Stage 1 multiview gen + Stage 2 3D recon)

app.py

@@ -1,6 +1,9 @@
 import os
+import shutil
 import tempfile
+from datetime import datetime
 from pathlib import Path
+
 import gradio as gr
 
 # Strip trailing whitespace/newlines from API keys (HF Secrets UI sometimes adds \n)
@@ -10,6 +13,7 @@ for _key in ("FAL_KEY", "HF_TOKEN"):
         os.environ[_key] = _val.strip()
 
 from src.checkpoints import ensure_sam3d_checkpoints, link_mv_sam3d_checkpoints
+from src.fal_multiview import generate_multiview_parallel, DEFAULT_ANGLES
 from src.fal_sam3 import extract_main_object_alpha
 from src.mv_sam3d import run_mv_sam3d_inference
 from src.utils import (
@@ -23,6 +27,176 @@ from src.utils import (
 
 MV_ROOT = Path("/mv_sam3d")
 
+# ── Sample directories ──────────────────────────────────────────────────────
+# Stage 1 samples: single images for multi-view generation
+SAMPLES_S1_DIR = Path("/data/samples/stage1")
+SAMPLES_S1_DIR.mkdir(parents=True, exist_ok=True)
+
+# Stage 2 samples: multi-view image sets
+SAMPLES_S2_DIR = Path("/data/samples/stage2")
+SAMPLES_S2_DIR.mkdir(parents=True, exist_ok=True)
+
+# Built-in Stage 2 samples from MV-SAM3D/data
+BUILTIN_S2_DIR = MV_ROOT / "data"
+
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+def _list_stage1_samples() -> list[str]:
+    """Return list of sample names (subfolders or images in SAMPLES_S1_DIR)."""
+    if not SAMPLES_S1_DIR.exists():
+        return []
+    samples = []
+    for p in sorted(SAMPLES_S1_DIR.iterdir()):
+        if p.is_file() and p.suffix.lower() in (".png", ".jpg", ".jpeg", ".webp"):
+            samples.append(p.name)
+    return samples
+
+
+def _list_stage2_samples() -> list[str]:
+    """Return list of sample set names for Stage 2."""
+    names = []
+    # Built-in samples from MV-SAM3D/data
+    if BUILTIN_S2_DIR.exists():
+        for d in sorted(BUILTIN_S2_DIR.iterdir()):
+            if d.is_dir() and (d / "images").is_dir():
+                names.append(f"[builtin] {d.name}")
+    # User / Stage-1 generated samples
+    if SAMPLES_S2_DIR.exists():
+        for d in sorted(SAMPLES_S2_DIR.iterdir()):
+            if d.is_dir():
+                names.append(d.name)
+    return names
+
+
+def _load_stage2_sample(name: str) -> list[str]:
+    """Load image file paths from a named Stage 2 sample set."""
+    if name.startswith("[builtin] "):
+        folder = BUILTIN_S2_DIR / name.replace("[builtin] ", "")
+        images_dir = folder / "images"
+    else:
+        folder = SAMPLES_S2_DIR / name
+        images_dir = folder  # flat folder of images
+    if not images_dir.exists():
+        return []
+    exts = {".png", ".jpg", ".jpeg", ".webp"}
+    files = sorted(
+        [str(p) for p in images_dir.iterdir() if p.suffix.lower() in exts],
+        key=lambda f: natural_key(Path(f).name),
+    )
+    return files
+
+
+# ── Stage 1: Multi-View Generation ─────────────────────────────────────────
+
+def run_stage1(
+    image_file,
+    angles_str,
+    vertical_angle,
+    zoom,
+    lora_scale,
+    guidance_scale,
+    num_steps,
+    seed_val,
+    progress=gr.Progress(),
+):
+    """Generate multi-view images from a single input image."""
+    if image_file is None:
+        raise gr.Error("Please upload or select a source image.")
+
+    # Parse image path
+    img_path = image_file if isinstance(image_file, str) else image_file.name
+
+    # Parse angles
+    try:
+        angles = [float(a.strip()) for a in angles_str.split(",") if a.strip()]
+    except ValueError:
+        raise gr.Error("Invalid angles format. Use comma-separated numbers like: 0,60,120,180,240,300")
+
+    if not angles:
+        angles = DEFAULT_ANGLES
+
+    seed = int(seed_val) if seed_val and int(seed_val) >= 0 else None
+
+    progress(0.05, desc="Uploading image & starting generation...")
+
+    results = generate_multiview_parallel(
+        image_path=img_path,
+        horizontal_angles=angles,
+        vertical_angle=vertical_angle,
+        zoom=zoom,
+        lora_scale=lora_scale,
+        guidance_scale=guidance_scale,
+        num_inference_steps=int(num_steps),
+        seed=seed,
+        on_progress=lambda frac, msg: progress(0.05 + frac * 0.9, desc=msg),
+    )
+
+    progress(0.98, desc="Saving generated views...")
+
+    # Save to temp dir for gallery display
+    out_paths = []
+    for angle, img in results:
+        tmp = tempfile.NamedTemporaryFile(suffix=f"_{int(angle)}deg.png", delete=False)
+        img.save(tmp.name, format="PNG")
+        out_paths.append(tmp.name)
+
+    progress(1.0, desc=f"Done! Generated {len(results)} views.")
+    return out_paths
+
+
+def send_to_stage2(gallery_images, progress=gr.Progress()):
+    """Save Stage 1 gallery images as a new Stage 2 sample set."""
+    if not gallery_images:
+        raise gr.Error("No generated views to send. Run Stage 1 first.")
+
+    # Create a named folder
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    name = f"multiview_{ts}"
+    dst = SAMPLES_S2_DIR / name
+    dst.mkdir(parents=True, exist_ok=True)
+
+    for i, item in enumerate(gallery_images):
+        # gallery_images items can be (filepath, caption) tuples or just filepaths
+        src_path = item[0] if isinstance(item, (list, tuple)) else item
+        shutil.copy2(src_path, dst / f"{i}.png")
+
+    # Return updated dropdown choices and select the new one
+    choices = _list_stage2_samples()
+    return (
+        gr.update(choices=choices, value=name),
+        f"✅ Saved {len(gallery_images)} views as sample set '{name}'",
+    )
+
+
+def save_stage1_sample(image_file):
+    """Save uploaded image as a Stage 1 sample."""
+    if image_file is None:
+        return gr.update()
+    src = image_file if isinstance(image_file, str) else image_file.name
+    dst = SAMPLES_S1_DIR / Path(src).name
+    shutil.copy2(src, dst)
+    choices = _list_stage1_samples()
+    return gr.update(choices=choices)
+
+
+def load_stage1_sample(sample_name):
+    """Load a Stage 1 sample image."""
+    if not sample_name:
+        return None
+    path = SAMPLES_S1_DIR / sample_name
+    return str(path) if path.exists() else None
+
+
+# ── Stage 2: 3D Reconstruction ─────────────────────────────────────────────
+
+def load_s2_sample(sample_name):
+    """Load a Stage 2 sample set into the file upload."""
+    if not sample_name:
+        return None
+    files = _load_stage2_sample(sample_name)
+    return files if files else None
+
 
 def build_mv_input_from_uploads(
     files, mask_prompt: str, prompt: str | None, pick_mode: str, max_masks: int,
@@ -37,7 +211,6 @@ def build_mv_input_from_uploads(
     if not files:
         raise gr.Error("Upload at least 2 images (multi-view).")
 
-    # Sort by filename (natural sort: 1,2,10)
     files_sorted = sorted(files, key=lambda f: natural_key(Path(f).name))
 
     workdir = Path(tempfile.mkdtemp(prefix="mv_input_"))
@@ -52,11 +225,9 @@ def build_mv_input_from_uploads(
         img = load_rgb_image(fp)
 
         if skip_sam3:
-            # Simple white background removal (no API call)
             progress((i + 1) / max(n, 1), desc=f"Removing white bg {i+1}/{n}")
             alpha = remove_white_background_alpha(img, threshold=white_threshold)
         else:
-            # fal SAM-3 main object alpha mask (L, 0..255)
             progress((i + 1) / max(n, 1), desc=f"SAM-3 masking view {i+1}/{n}")
             alpha = extract_main_object_alpha(
                 image_path=fp,
@@ -65,20 +236,19 @@ def build_mv_input_from_uploads(
                 max_masks=max_masks,
             )
 
-        # Save RGB image to images/{i}.png
         rgb_path = images_dir / f"{i}.png"
         save_rgb_png(img, rgb_path)
 
-        # Save RGBA mask image to <mask_prompt>/{i}.png (alpha channel stores mask)
         rgba = make_rgba_with_alpha(img, alpha)
         mask_path = masks_dir / f"{i}.png"
         save_rgba_png(rgba, mask_path)
 
-    return input_dir, [str((images_dir / f"{i}.png")) for i in range(n)]
+    return input_dir, [str(images_dir / f"{i}.png") for i in range(n)]
 
 
-def run_pipeline(
+def run_stage2_pipeline(
     files,
+    s2_sample_name,
     mask_prompt,
     sam3_prompt,
     pick_mode,
@@ -92,15 +262,23 @@ def run_pipeline(
     da3_npz,
     progress=gr.Progress(),
 ):
-    # 1) ensure checkpoints in /data and link into MV repo
+    # Resolve files: from upload or from sample
+    actual_files = files
+    if (not actual_files or len(actual_files) == 0) and s2_sample_name:
+        actual_files = _load_stage2_sample(s2_sample_name)
+
+    if not actual_files or len(actual_files) < 2:
+        raise gr.Error("Provide at least 2 multi-view images (upload or select a sample set).")
+
+    # 1) ensure checkpoints
     progress(0.02, desc="Ensuring SAM-3D checkpoints...")
     ensure_sam3d_checkpoints()
     link_mv_sam3d_checkpoints(MV_ROOT)
 
-    # 2) build input folder using fal SAM-3 masks (or white bg removal)
+    # 2) build input folder
     progress(0.05, desc="Preparing multi-view input...")
     input_dir, preview_imgs = build_mv_input_from_uploads(
-        files=files,
+        files=actual_files,
         mask_prompt=mask_prompt,
         prompt=sam3_prompt,
         pick_mode=pick_mode,
@@ -123,7 +301,6 @@ def run_pipeline(
         da3_npz_path=(Path(da3_npz) if da3_npz else None),
     )
 
-    # 4) outputs
     progress(1.0, desc="Done!")
     return (
         out.viewer_path,
@@ -135,93 +312,234 @@ def run_pipeline(
     )
 
 
-with gr.Blocks() as demo:
+# ══════════════════════════════════════════════════════════════════════════════
+#  Gradio UI
+# ════════════════════════��═════════════════════════════════════════════════════
+
+with gr.Blocks(title="Multi-View 3D Reconstruction") as demo:
+
     gr.Markdown(
         """
-# MV-SAM3D + fal SAM-3 (Main Object Mask)
-Upload multi-view images → fal SAM-3 extracts main object mask per view → MV-SAM3D outputs GLB + PLY.
+# 🎯 Multi-View 3D Object Reconstruction
+**Stage 1** — Generate multi-view images from a single photo (fal Qwen Multi-Angles)
+**Stage 2** — Reconstruct 3D model from multi-view images (MV-SAM3D)
 
-**Secrets required:** `FAL_KEY` and (maybe) `HF_TOKEN`.
+Each stage runs independently. Stage 1 results can be sent to Stage 2 as a sample set.
 """
     )
 
-    with gr.Row():
-        files = gr.Files(label="Multi-view images (PNG/JPG)", file_types=["image"])
-        da3_npz = gr.File(label="(Optional) DA3 output (.npz) for visibility/mixed", file_types=[".npz"])
+    # ── STAGE 1 ─────────────────────────────────────────────────────────────
+    with gr.Accordion("🖼️ Stage 1: Single Image → Multi-View Generation", open=True):
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                s1_image = gr.Image(
+                    label="Source image (single object photo)",
+                    type="filepath",
+                    height=300,
+                )
+            with gr.Column(scale=1):
+                s1_samples_dd = gr.Dropdown(
+                    label="Stage 1 Samples",
+                    choices=_list_stage1_samples(),
+                    value=None,
+                    interactive=True,
+                    info="Select a saved sample or upload a new image",
+                )
+                s1_save_btn = gr.Button("💾 Save current image as sample", size="sm")
+
+        # Advanced settings
+        with gr.Accordion("⚙️ Advanced Settings", open=False):
+            with gr.Row():
+                s1_angles = gr.Textbox(
+                    label="Horizontal angles (comma-separated degrees)",
+                    value="0, 60, 120, 180, 240, 300",
+                    info="0°=front, 90°=right, 180°=back, 270°=left",
+                )
+                s1_vertical = gr.Slider(
+                    label="Vertical angle",
+                    minimum=-30, maximum=90, value=0, step=5,
+                    info="-30°=low angle, 0°=eye level, 90°=bird's eye",
+                )
+            with gr.Row():
+                s1_zoom = gr.Slider(label="Zoom", minimum=0, maximum=10, value=5, step=0.5)
+                s1_lora = gr.Slider(label="LoRA scale", minimum=0, maximum=2, value=1.0, step=0.1)
+            with gr.Row():
+                s1_guidance = gr.Slider(label="Guidance scale", minimum=1, maximum=20, value=4.5, step=0.5)
+                s1_steps = gr.Slider(label="Inference steps", minimum=10, maximum=50, value=28, step=1)
+                s1_seed = gr.Number(label="Seed (-1 = random)", value=-1, precision=0)
+
+        s1_run_btn = gr.Button("🚀 Generate Multi-Views", variant="primary", size="lg")
+
+        s1_gallery = gr.Gallery(
+            label="Generated multi-view images",
+            columns=6,
+            height=280,
+            object_fit="contain",
+        )
+
+        with gr.Row():
+            s1_send_btn = gr.Button("📤 Send to Stage 2 Sample Sets", variant="secondary", size="lg")
+            s1_status = gr.Textbox(label="Status", interactive=False, scale=2)
+
+        # ── Stage 1 event handlers
+        s1_samples_dd.change(
+            fn=load_stage1_sample,
+            inputs=[s1_samples_dd],
+            outputs=[s1_image],
+        )
+
+        s1_save_btn.click(
+            fn=save_stage1_sample,
+            inputs=[s1_image],
+            outputs=[s1_samples_dd],
+        )
 
-    with gr.Row():
-        mask_prompt = gr.Textbox(label="mask_prompt folder name", value="object")
-        skip_sam3 = gr.Checkbox(
-            label="Skip SAM-3 (remove white background instead)",
-            value=False,
-            info="Check to skip fal SAM-3 API and use simple white background removal",
+        s1_run_btn.click(
+            fn=run_stage1,
+            inputs=[
+                s1_image,
+                s1_angles,
+                s1_vertical,
+                s1_zoom,
+                s1_lora,
+                s1_guidance,
+                s1_steps,
+                s1_seed,
+            ],
+            outputs=[s1_gallery],
         )
 
-    with gr.Row():
-        white_threshold = gr.Slider(
+    # ── STAGE 2 ─────────────────────────────────────────────────────────────
+    with gr.Accordion("🧊 Stage 2: Multi-View → 3D Reconstruction (MV-SAM3D)", open=True):
+
+        with gr.Row():
+            s2_samples_dd = gr.Dropdown(
+                label="Sample sets",
+                choices=_list_stage2_samples(),
+                value=None,
+                interactive=True,
+                info="Select a built-in or generated sample set",
+                scale=1,
+            )
+            s2_load_btn = gr.Button("📂 Load Sample", size="sm", scale=0)
+
+        with gr.Row():
+            s2_files = gr.Files(label="Multi-view images (PNG/JPG)", file_types=["image"])
+            s2_da3_npz = gr.File(
+                label="(Optional) DA3 output (.npz)",
+                file_types=[".npz"],
+            )
+
+        with gr.Row():
+            s2_mask_prompt = gr.Textbox(label="mask_prompt folder name", value="object")
+            s2_skip_sam3 = gr.Checkbox(
+                label="Skip SAM-3 (remove white background instead)",
+                value=False,
+                info="Use simple white background removal instead of fal SAM-3 API",
+            )
+
+        s2_white_threshold = gr.Slider(
             label="White BG threshold (R,G,B ≥ threshold → background)",
             minimum=200, maximum=255, value=240, step=1,
             visible=False,
         )
 
-    with gr.Row():
-        sam3_prompt = gr.Textbox(label="SAM-3 prompt (optional, e.g. 'stuffed toy' / 'person')", value="")
-        pick_mode = gr.Dropdown(label="Pick main object mode", choices=["largest", "best_score"], value="largest")
-        max_masks = gr.Slider(label="SAM-3 max_masks", minimum=1, maximum=10, value=5, step=1)
+        with gr.Row():
+            s2_sam3_prompt = gr.Textbox(
+                label="SAM-3 prompt (optional, e.g. 'stuffed toy')",
+                value="",
+            )
+            s2_pick_mode = gr.Dropdown(
+                label="Pick main object mode",
+                choices=["largest", "best_score"],
+                value="largest",
+            )
+            s2_max_masks = gr.Slider(
+                label="SAM-3 max_masks",
+                minimum=1, maximum=10, value=5, step=1,
+            )
+
+        # Toggle SAM-3 vs white BG options
+        s2_skip_sam3.change(
+            fn=lambda s: (
+                gr.update(visible=s),
+                gr.update(visible=not s),
+                gr.update(visible=not s),
+                gr.update(visible=not s),
+            ),
+            inputs=[s2_skip_sam3],
+            outputs=[s2_white_threshold, s2_sam3_prompt, s2_pick_mode, s2_max_masks],
+        )
+
+        with gr.Accordion("⚙️ MV-SAM3D Parameters", open=False):
+            s2_image_names = gr.Textbox(
+                label="image_names (comma-separated, optional)",
+                placeholder="0,1,2,3,4,5",
+            )
+            with gr.Row():
+                s2_stage1_w = gr.Checkbox(label="Stage 1 weighting", value=False)
+                s2_stage2_w = gr.Checkbox(label="Stage 2 weighting", value=False)
+                s2_w_source = gr.Dropdown(
+                    label="Stage 2 weight source",
+                    choices=["entropy", "visibility", "mixed"],
+                    value="entropy",
+                )
+
+        s2_run_btn = gr.Button("🚀 Run 3D Reconstruction", variant="primary", size="lg")
+
+        with gr.Row():
+            s2_viewer = gr.Model3D(label="3D Preview (GLB)")
+            s2_gallery = gr.Gallery(
+                label="Prepared inputs (images/*.png)",
+                columns=4,
+                height=240,
+            )
+
+        with gr.Row():
+            s2_glb = gr.File(label="result.glb")
+            s2_ply = gr.File(label="result.ply")
+            s2_npz = gr.File(label="params.npz")
 
-    # Toggle visibility: show white threshold when skipping SAM-3, hide SAM-3 options
-    skip_sam3.change(
-        fn=lambda s: (gr.update(visible=s), gr.update(visible=not s), gr.update(visible=not s), gr.update(visible=not s)),
-        inputs=[skip_sam3],
-        outputs=[white_threshold, sam3_prompt, pick_mode, max_masks],
-    )
+        s2_log = gr.Textbox(label="Log tail", lines=15)
 
-    gr.Markdown("### MV-SAM3D params")
+        # ── Stage 2 event handlers
 
-    with gr.Row():
-        image_names = gr.Textbox(label="image_names (comma-separated, optional)", placeholder="0,1,2,3,4,5,6,7")
+        # Wire "Send to Stage 2" button from Stage 1
+        s1_send_btn.click(
+            fn=send_to_stage2,
+            inputs=[s1_gallery],
+            outputs=[s2_samples_dd, s1_status],
+        )
 
-    with gr.Row():
-        stage1_weighting = gr.Checkbox(label="Stage 1 weighting", value=False)
-        stage2_weighting = gr.Checkbox(label="Stage 2 weighting", value=False)
-        stage2_weight_source = gr.Dropdown(
-            label="Stage 2 weight source",
-            choices=["entropy", "visibility", "mixed"],
-            value="entropy",
+        # Load sample set into file upload
+        s2_load_btn.click(
+            fn=load_s2_sample,
+            inputs=[s2_samples_dd],
+            outputs=[s2_files],
+        )
+
+        # Run 3D reconstruction
+        s2_run_btn.click(
+            fn=run_stage2_pipeline,
+            inputs=[
+                s2_files,
+                s2_samples_dd,
+                s2_mask_prompt,
+                s2_sam3_prompt,
+                s2_pick_mode,
+                s2_max_masks,
+                s2_skip_sam3,
+                s2_white_threshold,
+                s2_image_names,
+                s2_stage1_w,
+                s2_stage2_w,
+                s2_w_source,
+                s2_da3_npz,
+            ],
+            outputs=[s2_viewer, s2_glb, s2_ply, s2_npz, s2_log, s2_gallery],
         )
 
-    run_btn = gr.Button("Run", variant="primary")
-
-    with gr.Row():
-        viewer = gr.Model3D(label="Preview (GLB)")
-        preview_gallery = gr.Gallery(label="Prepared inputs (images/*.png)", columns=4, height=240)
-
-    with gr.Row():
-        glb_dl = gr.File(label="result.glb")
-        ply_dl = gr.File(label="result.ply")
-        npz_dl = gr.File(label="params.npz")
-
-    log_box = gr.Textbox(label="Log tail", lines=18)
-
-    run_btn.click(
-        fn=run_pipeline,
-        inputs=[
-            files,
-            mask_prompt,
-            sam3_prompt,
-            pick_mode,
-            max_masks,
-            skip_sam3,
-            white_threshold,
-            image_names,
-            stage1_weighting,
-            stage2_weighting,
-            stage2_weight_source,
-            da3_npz,
-        ],
-        outputs=[viewer, glb_dl, ply_dl, npz_dl, log_box, preview_gallery],
-    )
 
 if __name__ == "__main__":
     demo.launch()
-

src/fal_multiview.py

@@ -0,0 +1,112 @@
+"""
+Stage 1: Generate multi-view images from a single image using
+fal-ai/qwen-image-edit-2511-multiple-angles (parallel calls).
+"""
+
+import io
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Optional
+
+import requests
+from PIL import Image
+import fal_client
+
+DEFAULT_ANGLES = [0, 60, 120, 180, 240, 300]
+
+FAL_ENDPOINT = "fal-ai/qwen-image-edit-2511-multiple-angles"
+
+
+def _download_image(url: str, timeout: int = 120) -> Image.Image:
+    r = requests.get(url, timeout=timeout)
+    r.raise_for_status()
+    return Image.open(io.BytesIO(r.content)).convert("RGB")
+
+
+def _generate_single_view(
+    image_url: str,
+    horizontal_angle: float,
+    vertical_angle: float = 0.0,
+    zoom: float = 5.0,
+    lora_scale: float = 1.0,
+    guidance_scale: float = 4.5,
+    num_inference_steps: int = 28,
+    seed: Optional[int] = None,
+) -> Image.Image:
+    """Call fal API for a single angle and return the generated PIL image."""
+    args = {
+        "image_urls": [image_url],
+        "horizontal_angle": horizontal_angle,
+        "vertical_angle": vertical_angle,
+        "zoom": zoom,
+        "lora_scale": lora_scale,
+        "guidance_scale": guidance_scale,
+        "num_inference_steps": num_inference_steps,
+        "output_format": "png",
+        "num_images": 1,
+        "enable_safety_checker": False,
+    }
+    if seed is not None:
+        args["seed"] = seed
+
+    result = fal_client.subscribe(FAL_ENDPOINT, arguments=args)
+
+    images = result.get("images", [])
+    if not images:
+        raise RuntimeError(f"fal multiview returned no images for angle {horizontal_angle}°")
+    return _download_image(images[0]["url"])
+
+
+def generate_multiview_parallel(
+    image_path: str | Path,
+    horizontal_angles: list[float] | None = None,
+    vertical_angle: float = 0.0,
+    zoom: float = 5.0,
+    lora_scale: float = 1.0,
+    guidance_scale: float = 4.5,
+    num_inference_steps: int = 28,
+    seed: Optional[int] = None,
+    max_workers: int = 6,
+    on_progress=None,
+) -> list[tuple[float, Image.Image]]:
+    """
+    Generate multi-view images in parallel.
+    Returns list of (horizontal_angle, PIL.Image) sorted by angle.
+    """
+    if horizontal_angles is None:
+        horizontal_angles = DEFAULT_ANGLES
+
+    # Upload source image once
+    image_url = fal_client.upload_file(str(image_path))
+
+    results: dict[float, Image.Image] = {}
+    total = len(horizontal_angles)
+
+    with ThreadPoolExecutor(max_workers=min(max_workers, total)) as pool:
+        future_to_angle = {
+            pool.submit(
+                _generate_single_view,
+                image_url=image_url,
+                horizontal_angle=angle,
+                vertical_angle=vertical_angle,
+                zoom=zoom,
+                lora_scale=lora_scale,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+                seed=seed,
+            ): angle
+            for angle in horizontal_angles
+        }
+
+        done_count = 0
+        for future in as_completed(future_to_angle):
+            angle = future_to_angle[future]
+            done_count += 1
+            img = future.result()  # raises on error
+            results[angle] = img
+            if on_progress:
+                on_progress(done_count / total, f"Generated view {done_count}/{total} ({angle}°)")
+
+    # Return sorted by angle
+    return [(a, results[a]) for a in sorted(results.keys())]
+