Upload folder using huggingface_hub

gen_eiffel_base.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+"""Eiffel diorama candidates with a CLEAN solid base (circle / square) so the
+splat doesn't reconstruct a ragged 'cut' edge."""
+import pathlib
+import hf_call
+
+ROOT = "https://ideogram-ai-ideogram4.hf.space"
+OUT = pathlib.Path(__file__).parent / "images"
+
+BASE = ("An architectural scale-model diorama of the Eiffel Tower standing on the "
+        "Champ de Mars, with tree-lined garden promenades, rows of trees and green "
+        "lawns spreading around its base. The whole diorama sits on a solid thick "
+        "{shape} display pedestal with a clean smooth {edge} edge and visible side "
+        "thickness, the ENTIRE {shape} base fully visible and centered in the frame "
+        "with margin around it. Isolated on a pure solid black background, gentle "
+        "elevated three-quarter view, dramatic soft studio lighting, photorealistic, "
+        "crisp fine detail, sharp focus, no people, no text, no watermark.")
+
+CANDIDATES = {
+    "eiffel-circle": BASE.format(shape="circular", edge="round"),
+    "eiffel-square": BASE.format(shape="square",   edge="straight"),
+}
+
+for slug, prompt in CANDIDATES.items():
+    dest = OUT / f"{slug}.jpg"
+    print(f"[gen ] {slug} ...", flush=True)
+    data = hf_call.call(ROOT, "generate", [
+        prompt, "Quality · 48 steps", "Ideogram (remote)", 1024, 1024, 0, True,
+    ])
+    hf_call.download(data[0], dest, space_root=ROOT)
+    print(f"[ok  ] {slug} -> {dest} ({dest.stat().st_size//1024} kB)", flush=True)
+
+print("DONE")

gen_eiffel_hq.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Re-generate the Eiffel Tower splat at higher quality: more gaussians and
+more refinement steps. Tries decreasing gaussian counts if the space rejects
+a high value, and writes to splats/tour-eiffel.ply."""
+import pathlib, time
+import hf_call
+
+ROOT = "https://vast-ai-triposplat.hf.space"
+SRC  = pathlib.Path(__file__).parent / "images" / "tour-eiffel.jpg"
+DEST = pathlib.Path(__file__).parent / "splats" / "tour-eiffel.ply"
+
+GAUSSIAN_CANDIDATES = [524288, 393216, 327680, 262144]
+STEPS = 32
+
+ok = False
+for ng in GAUSSIAN_CANDIDATES:
+    for attempt in range(1, 4):
+        try:
+            print(f"[up  ] uploading image (ng={ng}, try {attempt}) ...", flush=True)
+            fd = hf_call.upload(ROOT, SRC)
+            print(f"[gen ] generating HQ splat: {ng} gaussians, {STEPS} steps ...", flush=True)
+            data = hf_call.call(ROOT, "generate", [
+                fd, 42, STEPS, 3.0, ng, "ply",
+            ], timeout=2400)
+            hf_call.download(data[1], DEST, space_root=ROOT)
+            print(f"[ok  ] tour-eiffel HQ -> {DEST} ({DEST.stat().st_size//1024} kB, {ng} gaussians)", flush=True)
+            ok = True
+            break
+        except Exception as e:
+            print(f"[err ] ng={ng} attempt {attempt}: {e}", flush=True)
+            time.sleep(12)
+    if ok:
+        break
+
+print("DONE" if ok else "FAILED")

gen_eiffel_scene.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""Generate richer Eiffel Tower 'scene diorama' candidate images (tower + its
+setting) on black, for the user to pick from before splatting."""
+import pathlib
+import hf_call
+
+ROOT = "https://ideogram-ai-ideogram4.hf.space"
+OUT = pathlib.Path(__file__).parent / "images"
+OUT.mkdir(exist_ok=True)
+
+COMMON = ("scene presented as a floating circular diorama isolated on a pure solid "
+          "black background, dramatic soft three-quarter studio lighting, photorealistic, "
+          "crisp fine detail, sharp focus, no people, no text, no watermark, "
+          "elevated three-quarter aerial view")
+
+CANDIDATES = {
+    "eiffel-gardens": (
+        "The Eiffel Tower rising from the Champ de Mars, with the long tree-lined "
+        "garden promenades, rows of trees and manicured green lawns spreading out "
+        "around its base, the complete iron tower fully visible, " + COMMON),
+    "eiffel-bridge": (
+        "The Eiffel Tower with the Pont d'Iéna stone bridge crossing the river Seine "
+        "directly in front of it, tree-lined riverbanks and quays, the complete iron "
+        "tower fully visible behind the bridge, " + COMMON),
+}
+
+for slug, prompt in CANDIDATES.items():
+    dest = OUT / f"{slug}.jpg"
+    print(f"[gen ] {slug} ...", flush=True)
+    data = hf_call.call(ROOT, "generate", [
+        prompt, "Quality · 48 steps", "Ideogram (remote)", 1024, 1024, 0, True,
+    ])
+    hf_call.download(data[0], dest, space_root=ROOT)
+    print(f"[ok  ] {slug} -> {dest} ({dest.stat().st_size//1024} kB)", flush=True)
+
+print("DONE")

gen_hq.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Reusable high-quality splat generator: 524K gaussians (with fallbacks) + 32 steps.
+Usage: python3 gen_hq.py <slug> [<slug> ...]  (reads images/<slug>.jpg -> splats/<slug>.ply)"""
+import sys, pathlib, time
+import hf_call
+
+ROOT = "https://vast-ai-triposplat.hf.space"
+IMG  = pathlib.Path(__file__).parent / "images"
+OUT  = pathlib.Path(__file__).parent / "splats"
+OUT.mkdir(exist_ok=True)
+
+GAUSSIANS = [524288, 393216, 327680, 262144]
+STEPS = 32
+
+for slug in sys.argv[1:]:
+    src = IMG / f"{slug}.jpg"
+    dest = OUT / f"{slug}.ply"
+    if not src.exists():
+        print(f"[miss] {slug}: no image", flush=True); continue
+    ok = False
+    for ng in GAUSSIANS:
+        for attempt in range(1, 4):
+            try:
+                print(f"[up  ] {slug} (ng={ng}, try {attempt}) ...", flush=True)
+                fd = hf_call.upload(ROOT, src)
+                print(f"[gen ] {slug}: {ng} gaussians, {STEPS} steps ...", flush=True)
+                data = hf_call.call(ROOT, "generate", [fd, 42, STEPS, 3.0, ng, "ply"], timeout=2400)
+                hf_call.download(data[1], dest, space_root=ROOT)
+                print(f"[ok  ] {slug} -> {dest} ({dest.stat().st_size//1024} kB, {ng} gaussians)", flush=True)
+                ok = True; break
+            except Exception as e:
+                print(f"[err ] {slug} ng={ng} attempt {attempt}: {e}", flush=True)
+                time.sleep(12)
+        if ok: break
+    if not ok:
+        print(f"[FAIL] {slug}", flush=True)
+
+print("DONE")

gen_images.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Generate dark-background, isolated-specimen images of Paris monuments
+via the ideogram-ai/ideogram4 Gradio space, then save them locally."""
+import pathlib
+import hf_call
+
+ROOT = "https://ideogram-ai-ideogram4.hf.space"
+OUT = pathlib.Path(__file__).parent / "images"
+OUT.mkdir(exist_ok=True)
+
+MONUMENTS = {
+    "tour-eiffel":     "the Eiffel Tower, the complete iron lattice tower",
+    "opera-garnier":   "the Palais Garnier opera house of Paris, the complete ornate Beaux-Arts opera building with its green dome, columned facade and gilded rooftop sculptures",
+    "arc-de-triomphe": "the Arc de Triomphe, the complete triumphal arch",
+    "sacre-coeur":     "the Sacré-Cœur Basilica of Montmartre, the complete white-domed basilica",
+    "moulin-rouge":    "the Moulin Rouge cabaret of Paris, the complete building with its iconic bright red windmill on the roof, red facade and awnings",
+    "pantheon":        "the Panthéon of Paris, the complete neoclassical monument with its large dome and tall columned portico",
+}
+
+def prompt_for(subject):
+    return (
+        f"A photorealistic architectural studio photograph of {subject}, "
+        "the entire structure fully visible and centered in the frame, "
+        "isolated on a pure solid black background, dramatic soft three-quarter "
+        "studio lighting, crisp fine detail, sharp focus, no people, no text, "
+        "no watermark, museum specimen presentation, full object 3/4 view"
+    )
+
+for slug, subject in MONUMENTS.items():
+    dest = OUT / f"{slug}.jpg"
+    if dest.exists():
+        print(f"[skip] {slug}", flush=True)
+        continue
+    print(f"[gen ] {slug} ...", flush=True)
+    data = hf_call.call(ROOT, "generate", [
+        prompt_for(subject),     # prompt
+        "Quality · 48 steps",    # mode
+        "Ideogram (remote)",     # upsampler
+        1024,                    # width
+        1024,                    # height
+        0,                       # seed
+        True,                    # randomize_seed
+    ])
+    img = data[0]
+    hf_call.download(img, dest, space_root=ROOT)
+    print(f"[ok  ] {slug} -> {dest} ({dest.stat().st_size//1024} kB)", flush=True)
+
+print("DONE")

gen_splats.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Turn each monument image into a 3D gaussian splat (.ply) via the
+VAST-AI/TripoSplat Gradio space."""
+import pathlib, sys, time
+import hf_call
+
+ROOT = "https://vast-ai-triposplat.hf.space"
+IMG = pathlib.Path(__file__).parent / "images"
+OUT = pathlib.Path(__file__).parent / "splats"
+OUT.mkdir(exist_ok=True)
+
+SLUGS = ["tour-eiffel", "louvre-pyramid", "arc-de-triomphe",
+         "sacre-coeur", "notre-dame", "obelisque"]
+
+# allow running a subset:  python3 gen_splats.py tour-eiffel obelisque
+if len(sys.argv) > 1:
+    SLUGS = sys.argv[1:]
+
+for slug in SLUGS:
+    src = IMG / f"{slug}.jpg"
+    dest = OUT / f"{slug}.ply"
+    if dest.exists():
+        print(f"[skip] {slug}", flush=True)
+        continue
+    if not src.exists():
+        print(f"[miss] {slug} image not found", flush=True)
+        continue
+    ok = False
+    for attempt in range(1, 5):
+        try:
+            print(f"[up  ] {slug} uploading image (try {attempt}) ...", flush=True)
+            filedata = hf_call.upload(ROOT, src)
+            print(f"[gen ] {slug} generating splat (this can take a few min) ...", flush=True)
+            data = hf_call.call(ROOT, "generate", [
+                filedata,   # image
+                42,         # seed
+                20,         # steps
+                3.0,        # guidance_scale
+                262144,     # num_gaussians
+                "ply",      # output_format
+            ], timeout=1800)
+            # returns (preprocessed_image, ply_file, download_file, info_string)
+            ply = data[1]
+            hf_call.download(ply, dest, space_root=ROOT)
+            print(f"[ok  ] {slug} -> {dest} ({dest.stat().st_size//1024} kB)", flush=True)
+            ok = True
+            break
+        except Exception as e:
+            print(f"[err ] {slug} attempt {attempt}: {e}", flush=True)
+            time.sleep(15)
+    if not ok:
+        print(f"[FAIL] {slug} gave up after retries", flush=True)
+
+print("DONE")

hf_call.py

@@ -0,0 +1,65 @@
+"""Minimal Gradio REST helper (no gradio_client dependency).
+Implements: upload file, call endpoint, poll SSE result."""
+import os, json, pathlib, requests
+
+def token():
+    return (os.environ.get("HF_TOKEN")
+            or pathlib.Path("~/.cache/huggingface/token").expanduser().read_text().strip())
+
+def _headers():
+    return {"Authorization": f"Bearer {token()}"}
+
+def upload(space_root, filepath):
+    """Upload a local file, return the gradio FileData dict to reference it."""
+    with open(filepath, "rb") as f:
+        r = requests.post(f"{space_root}/gradio_api/upload",
+                          headers=_headers(),
+                          files={"files": (pathlib.Path(filepath).name, f)},
+                          timeout=300)
+    r.raise_for_status()
+    server_path = r.json()[0]
+    return {"path": server_path, "meta": {"_type": "gradio.FileData"},
+            "orig_name": pathlib.Path(filepath).name, "url": None,
+            "size": None, "mime_type": None, "is_stream": False}
+
+def call(space_root, api_name, data, timeout=900):
+    """Call /gradio_api/call/{api_name} with ordered `data` list; poll SSE; return data list."""
+    r = requests.post(f"{space_root}/gradio_api/call/{api_name}",
+                      headers={**_headers(), "Content-Type": "application/json"},
+                      data=json.dumps({"data": data}), timeout=60)
+    r.raise_for_status()
+    event_id = r.json()["event_id"]
+    # poll the SSE stream
+    with requests.get(f"{space_root}/gradio_api/call/{api_name}/{event_id}",
+                      headers=_headers(), stream=True, timeout=timeout) as s:
+        s.raise_for_status()
+        event = None
+        for raw in s.iter_lines(decode_unicode=True):
+            if raw is None or raw == "":
+                continue
+            if raw.startswith("event:"):
+                event = raw.split(":", 1)[1].strip()
+            elif raw.startswith("data:"):
+                payload = raw.split(":", 1)[1].strip()
+                if event == "complete":
+                    return json.loads(payload)
+                if event == "error":
+                    raise RuntimeError(f"Gradio error: {payload}")
+    raise RuntimeError("SSE stream ended without a 'complete' event")
+
+def download(url_or_data, dest, space_root=None):
+    """Download a gradio result (url string or FileData dict) to dest."""
+    if isinstance(url_or_data, dict):
+        url = url_or_data.get("url")
+        if not url and url_or_data.get("path") and space_root:
+            url = f"{space_root}/gradio_api/file={url_or_data['path']}"
+    else:
+        url = url_or_data
+    if url and url.startswith("/") and space_root:
+        url = space_root + url
+    r = requests.get(url, headers=_headers(), stream=True, timeout=600)
+    r.raise_for_status()
+    with open(dest, "wb") as f:
+        for chunk in r.iter_content(chunk_size=1 << 16):
+            f.write(chunk)
+    return dest