diff --git a/.gitattributes b/.gitattributes
index d08e4ab61215c868fc40d52ff43066554c99803c..100d0bb3ebc6786ce06bb5ee510dfea89d1a780f 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -41,3 +41,7 @@ examples/example-04.jpg filter=lfs diff=lfs merge=lfs -text
examples/example-05.pdf filter=lfs diff=lfs merge=lfs -text
examples/2.jpg filter=lfs diff=lfs merge=lfs -text
examples/4.jpg filter=lfs diff=lfs merge=lfs -text
+assets/example_mesh/crocodile.glb filter=lfs diff=lfs merge=lfs -text
+assets/example_mesh/dragon.glb filter=lfs diff=lfs merge=lfs -text
+assets/example_mesh/spaceman.glb filter=lfs diff=lfs merge=lfs -text
+assets/teaser.png filter=lfs diff=lfs merge=lfs -text
diff --git a/app.py b/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..843ccf1dbae8c9eb8a359144e24a10b90d400780
--- /dev/null
+++ b/app.py
@@ -0,0 +1,706 @@
+"""
+LATO.2 Gradio App — Image-to-3D Mesh Generation
+=================================================
+Factorized 3D Mesh Generation with Vertex and Topology Flow.
+
+Launches a Gradio interface that accepts an input image (or mesh),
+runs the full V-Flow → T-Flow pipeline, and displays the result
+with Rerun 3D viewer + GLB download.
+
+Usage:
+ python app.py [--share] [--port 7860]
+"""
+
+import argparse
+import os
+import sys
+import tempfile
+import time
+import uuid
+from pathlib import Path
+
+# ── project root on sys.path ──────────────────────────────────────────────────
+ROOT = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, ROOT)
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+os.environ.setdefault("XDG_RUNTIME_DIR", os.path.join(tempfile.gettempdir(), "runtime-root"))
+os.makedirs(os.environ["XDG_RUNTIME_DIR"], exist_ok=True)
+os.environ.setdefault("EGL_PLATFORM", "surfaceless")
+
+import gradio as gr
+import numpy as np
+import rerun as rr
+import torch
+import trimesh
+from gradio_rerun import Rerun
+from PIL import Image
+
+from dataset.utils import (
+ MESH_EXTENSIONS,
+ dedup_quantized_mesh,
+ extract_active_voxels,
+ quantize_mesh_clustering,
+)
+from models import (
+ DinoV2Encoder,
+ OffsetHead,
+ TopoFlowEulerSampler,
+ TopologySiTFlow,
+ TopologyVAE,
+ VertexSLatFlowModel,
+ VertFlowEulerCfgSampler,
+ VertexVAE,
+ VoxelFieldConditioner,
+)
+from modules.sparse import SparseTensor
+import utils.logging as logging
+from utils.inference import (
+ build_voxel_fields,
+ decode_vertices,
+ edges_to_faces,
+ pad_verts,
+)
+from utils.load import load_latov2_model
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Global model state (lazy-loaded once on first inference)
+# ═══════════════════════════════════════════════════════════════════════════════
+_models = {}
+_configs = {}
+_device = None
+
+OUTPUT_DIR = os.path.join(ROOT, "gradio_outputs")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+
+def _load_models():
+ """Load all LATO.2 sub-models once (idempotent)."""
+ global _models, _configs, _device
+
+ if _models:
+ return # already loaded
+
+ _device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+ device = _device
+ ckpt = os.path.join(ROOT, "ckpt")
+
+ logging.info("Loading LATO.2 models …")
+
+ # Stage 1 — vertex generation
+ vflow, vflow_cfg = load_latov2_model(VertexSLatFlowModel, os.path.join(ckpt, "vflow.pt"), device)
+ vvae, vvae_cfg = load_latov2_model(VertexVAE, os.path.join(ckpt, "vvae.pt"), device)
+ offset_head, _ = load_latov2_model(OffsetHead, os.path.join(ckpt, "offset_head.pt"), device)
+
+ # Stage 2 — topology generation
+ tflow, tflow_cfg = load_latov2_model(TopologySiTFlow, os.path.join(ckpt, "tflow.pt"), device)
+ tvae, _ = load_latov2_model(TopologyVAE, os.path.join(ckpt, "tvae.pt"), device)
+ voxel_encoder, venc_cfg = load_latov2_model(VoxelFieldConditioner, os.path.join(ckpt, "voxel_encoder.pt"), device)
+
+ # DINO-v2 image encoder
+ dino = (
+ DinoV2Encoder(
+ model_name=vflow_cfg["dino_version"],
+ hub_dir=os.path.join(ckpt, "dinov2"),
+ img_res=vflow_cfg["image_resolution"],
+ )
+ .to(device)
+ .eval()
+ )
+
+ _models = dict(
+ vflow=vflow, vvae=vvae, offset_head=offset_head,
+ tflow=tflow, tvae=tvae, voxel_encoder=voxel_encoder,
+ dino=dino,
+ vertex_sampler=VertFlowEulerCfgSampler(),
+ topo_sampler=TopoFlowEulerSampler(),
+ )
+ _configs = dict(vflow=vflow_cfg, vvae=vvae_cfg, tflow=tflow_cfg, venc=venc_cfg)
+ logging.info("All models loaded ✓")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Helper: prepare input mesh → active voxels + quantized vertices
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def _prepare_mesh_data(mesh_path: str, resolution: int, min_resolution: int):
+ """Quantize and extract voxels from a mesh file for the pipeline."""
+ quantized = quantize_mesh_clustering(mesh_path, resolution=resolution)
+ if quantized is None:
+ raise ValueError("Input mesh is empty or could not be loaded.")
+ v_int, offsets, faces = quantized
+ if len(faces) < 1 or len(v_int) < 3:
+ raise ValueError("Mesh is degenerate after quantization.")
+
+ gt_int, gt_offsets, gt_faces = dedup_quantized_mesh(v_int, offsets, faces, resolution)
+ if len(gt_int) < 3 or len(gt_faces) < 1:
+ raise ValueError("Too few vertices/faces after deduplication.")
+
+ quant_v = gt_int.astype(np.float64) / (resolution - 1.0) - 0.5
+ quant_v = np.clip(quant_v, -0.5 + 1e-6, 0.5 - 1e-6).astype(np.float32)
+
+ min_active = extract_active_voxels(quant_v, gt_faces, min_resolution)
+ return gt_int, gt_offsets, gt_faces, quant_v, min_active
+
+
+def _render_mesh_to_image(mesh_path: str, resolution: int, img_res: int = 518,
+ azimuth: float = 45.0, elevation: float = 30.0):
+ """Render a conditioning view from a mesh (used when no user image is provided)."""
+ quantized = quantize_mesh_clustering(mesh_path, resolution=resolution)
+ if quantized is None:
+ return None
+ v_int, _, faces = quantized
+ render_v = v_int.astype(np.float64) / resolution - 0.5
+
+ from dataset.mesh_render import WhiteModelRenderer
+ renderer = WhiteModelRenderer(
+ img_res=img_res,
+ mesh_color=(0.78, 0.78, 0.82),
+ bg_color=(0.0, 0.0, 0.0),
+ up_axis="y",
+ add_ground=False,
+ shadow=True,
+ crop_to_object=True,
+ crop_padding=1.2,
+ )
+ imgs, _ = renderer.render(
+ np.asarray(render_v, dtype=np.float64),
+ np.asarray(faces, dtype=np.int64),
+ num_views=1,
+ azimuths=[azimuth],
+ elevations=[elevation],
+ )
+ return imgs[0] # (H, W, 3) uint8
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Core generation pipeline
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def generate_mesh(
+ input_image: np.ndarray | None,
+ input_mesh_path: str | None,
+ vert_num: int,
+ cfg_strength: float,
+ vflow_steps: int,
+ tflow_steps: int,
+ seed: int,
+ progress=gr.Progress(track_tqdm=True),
+):
+ """
+ Main generation function.
+ - input_image: user-uploaded image (H, W, 3) uint8 — used as DINOv2 conditioning
+ - input_mesh_path: reference mesh file — provides the voxel scaffold
+ If only an image is supplied, the user must also supply a reference mesh for
+ the voxel scaffold (or we use one of the bundled examples).
+ """
+ _load_models() # ensure models are loaded
+
+ device = _device
+ m = _models
+ c = _configs
+
+ torch.manual_seed(seed)
+ np.random.seed(seed)
+
+ res = c["vvae"]["resolution"]
+ min_res = c["vvae"]["min_resolution"]
+ latent_dim = c["vflow"]["latent_dim"]
+ density_max = c["vflow"]["max_vertex_num"]
+ z_dim = int(c["tflow"]["args"]["z_dim"])
+ max_vertices = int(c["tflow"]["args"]["max_vertices"])
+ latent_scale = float(c["tflow"]["latent_scale"])
+ voxel_res = int(c["venc"]["resolution"])
+ inference_threshold = 0.5
+
+ run_id = str(uuid.uuid4())[:8]
+
+ # ── Resolve mesh scaffold ─────────────────────────────────────────────
+ if input_mesh_path is None or not os.path.isfile(input_mesh_path):
+ raise gr.Error(
+ "A reference mesh file is required to provide the voxel scaffold. "
+ "Please upload a .glb / .obj / .ply / .stl mesh."
+ )
+
+ progress(0.05, desc="Quantizing mesh & extracting voxels …")
+ gt_int, gt_offsets, gt_faces, quant_v, min_active = _prepare_mesh_data(
+ input_mesh_path, res, min_res
+ )
+
+ # ── Resolve conditioning image ────────────────────────────────────────
+ if input_image is not None:
+ cond_img = np.asarray(input_image, dtype=np.uint8)
+ if cond_img.ndim == 2:
+ cond_img = np.stack([cond_img] * 3, axis=-1)
+ elif cond_img.shape[-1] == 4:
+ cond_img = cond_img[:, :, :3]
+ else:
+ progress(0.08, desc="Rendering conditioning view from mesh …")
+ cond_img = _render_mesh_to_image(input_mesh_path, res)
+ if cond_img is None:
+ raise gr.Error("Could not render a conditioning view from the mesh.")
+
+ # ── Compute density conditioning ──────────────────────────────────────
+ clamped = float(min(max(vert_num, 200), 5000))
+ density = torch.tensor([clamped], dtype=torch.float32, device=device)
+ density = density / density_max * 1000.0
+
+ # ── Stage 1: V-Flow → V-VAE ──────────────────────────────────────────
+ progress(0.12, desc="Running V-Flow (vertex generation) …")
+ min_active_batched = torch.cat(
+ [torch.zeros(min_active.shape[0], 1, dtype=torch.int32), min_active], dim=1
+ )
+
+ with torch.no_grad():
+ cond = m["dino"](cond_img).float()
+ neg_cond = torch.zeros_like(cond)
+
+ with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16):
+ min_active_coords = min_active_batched.to(device)
+ noise = SparseTensor(
+ coords=min_active_coords.int(),
+ feats=torch.randn(
+ min_active_coords.shape[0], latent_dim, device=device
+ ),
+ )
+ z_pred = m["vertex_sampler"].sample(
+ model=m["vflow"],
+ noise=noise,
+ cond=cond,
+ neg_cond=neg_cond,
+ steps=vflow_steps,
+ cfg_strength=cfg_strength,
+ rescale_t=1.0,
+ density=density,
+ )
+ pred_coords, pred_offsets = decode_vertices(
+ m["vvae"], m["offset_head"], z_pred, inference_threshold
+ )
+
+ progress(0.55, desc="Decoding vertices …")
+
+ # Filter to batch 0
+ pred_sel = pred_coords[:, 0] == 0
+ vert_int = pred_coords[pred_sel, 1:].long()
+ vert_off = pred_offsets[pred_sel]
+ num_pred = int(vert_int.shape[0])
+
+ if num_pred < 3:
+ raise gr.Error(f"Only {num_pred} vertices generated. Try different parameters.")
+ if num_pred > max_vertices:
+ raise gr.Error(
+ f"Generated {num_pred} vertices exceeds T-Flow max ({max_vertices}). "
+ "Try reducing the vertex count."
+ )
+
+ # ── Stage 2: T-Flow → T-VAE ──────────────────────────────────────────
+ progress(0.60, desc="Running T-Flow (topology generation) …")
+
+ with torch.no_grad():
+ verts, mask, lengths = pad_verts([vert_int], device)
+ voxel_list = [min_active.long()]
+ field = build_voxel_fields(voxel_list, voxel_res, device)
+ cond_vox = m["voxel_encoder"](field)
+
+ z0 = torch.randn(verts.shape[0], verts.shape[1], z_dim, device=device)
+ z_flow = m["topo_sampler"].sample(
+ model=m["tflow"],
+ noise=z0,
+ verts=verts,
+ mask=mask,
+ cond=cond_vox,
+ steps=tflow_steps,
+ )
+ z = z_flow.float() / latent_scale
+
+ with torch.autocast("cuda", dtype=torch.bfloat16):
+ edges_list = m["tvae"].decode(
+ z,
+ verts=verts,
+ verts_mask=mask,
+ chunk_size=20000,
+ threshold=0.0,
+ )
+
+ progress(0.85, desc="Assembling faces & exporting …")
+ faces = edges_to_faces(edges_list[0], lengths[0], fill_quad_rings=True)
+
+ if faces.shape[0] == 0:
+ raise gr.Error("No faces were generated. Try different parameters or a different input.")
+
+ # ── Build final mesh ──────────────────────────────────────────────────
+ vert_np = vert_int.numpy()
+ off_np = vert_off.numpy()
+ vert_with_offset = (
+ vert_np.astype(np.float64) / res
+ - 0.5
+ + off_np.astype(np.float64) / (res * 2.0)
+ )
+ mesh = trimesh.Trimesh(vertices=vert_with_offset, faces=faces, process=False)
+
+ # ── Export to GLB ─────────────────────────────────────────────────────
+ glb_filename = f"lato2_{run_id}.glb"
+ glb_path = os.path.join(OUTPUT_DIR, glb_filename)
+ mesh.export(glb_path, file_type="glb")
+
+ # ── Build Rerun visualization ─────────────────────────────────────────
+ progress(0.92, desc="Building 3D visualization …")
+ rr_data = _build_rerun_stream(mesh, cond_img, run_id)
+
+ progress(1.0, desc="Done ✓")
+ return rr_data, glb_path
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Rerun 3D Visualization
+# ═══════════════════════════════════════════════════════════════════════════════
+
+def _build_rerun_stream(mesh: trimesh.Trimesh, cond_img: np.ndarray, run_id: str):
+ """Create an .rrd byte stream with the generated mesh + conditioning image."""
+ rrd_path = os.path.join(OUTPUT_DIR, f"lato2_{run_id}.rrd")
+
+ rr.init("LATO.2 — 3D Mesh Generation", spawn=False)
+ rec = rr.new_recording(application_id="LATO.2", recording_id=run_id)
+
+ vertices = np.asarray(mesh.vertices, dtype=np.float32)
+ faces = np.asarray(mesh.faces, dtype=np.uint32)
+
+ # Compute vertex normals for nicer shading
+ if mesh.vertex_normals is not None and len(mesh.vertex_normals) > 0:
+ normals = np.asarray(mesh.vertex_normals, dtype=np.float32)
+ else:
+ normals = None
+
+ # Log the generated mesh
+ rec.log(
+ "world/generated_mesh",
+ rr.Mesh3D(
+ vertex_positions=vertices,
+ triangle_indices=faces,
+ vertex_normals=normals,
+ ),
+ )
+
+ # Log the conditioning image
+ if cond_img is not None:
+ rec.log("conditioning_image", rr.Image(cond_img))
+
+ # Log mesh stats as text
+ rec.log(
+ "world/stats",
+ rr.TextDocument(
+ f"Vertices: {len(vertices)}\n"
+ f"Faces: {len(faces)}\n"
+ f"Bounding box: {vertices.min(axis=0).tolist()} → {vertices.max(axis=0).tolist()}"
+ ),
+ )
+
+ rrd_bytes = rec.memory_recording()
+ return rrd_bytes
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Gradio UI
+# ═══════════════════════════════════════════════════════════════════════════════
+
+TITLE = "LATO.2: Factorized 3D Mesh Generation"
+DESCRIPTION = """
+**LATO.2** factorizes mesh generation into a **Vertex Flow (V-Flow)** for vertex positions
+and a **Topology Flow (T-Flow)** for connectivity prediction.
+
+### How to use
+1. **Upload a conditioning image** — this drives the DINOv2 shape conditioning.
+2. **Upload a reference mesh** (.glb / .obj / .ply / .stl) — this provides the coarse voxel scaffold.
+ *If you skip the image, a rendered view of the mesh is used as conditioning instead.*
+3. Adjust parameters and click **🚀 Generate 3D Mesh**.
+4. Explore the result in the **Rerun 3D Viewer** and download the **.glb** file.
+"""
+
+EXAMPLES_DIR = os.path.join(ROOT, "assets", "example_mesh")
+
+CSS = """
+/* ── Dark premium theme overrides ──────────────────────────────────── */
+.gradio-container {
+ max-width: 1400px !important;
+ margin: auto;
+}
+
+#app-title {
+ text-align: center;
+ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+ -webkit-background-clip: text;
+ -webkit-text-fill-color: transparent;
+ background-clip: text;
+ font-size: 2.4rem;
+ font-weight: 800;
+ letter-spacing: -0.02em;
+ margin-bottom: 0.2em;
+ font-family: 'Inter', 'Segoe UI', sans-serif;
+}
+
+#app-subtitle {
+ text-align: center;
+ color: #9ca3af;
+ font-size: 1.05rem;
+ margin-top: -0.5em;
+ margin-bottom: 1.5em;
+}
+
+.generate-btn {
+ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+ border: none !important;
+ color: white !important;
+ font-weight: 700 !important;
+ font-size: 1.15rem !important;
+ padding: 14px 32px !important;
+ border-radius: 12px !important;
+ box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4) !important;
+ transition: all 0.3s ease !important;
+ letter-spacing: 0.02em !important;
+}
+
+.generate-btn:hover {
+ transform: translateY(-2px) !important;
+ box-shadow: 0 8px 25px rgba(102, 126, 234, 0.55) !important;
+}
+
+.param-accordion {
+ border: 1px solid rgba(102, 126, 234, 0.2) !important;
+ border-radius: 12px !important;
+ margin-top: 8px !important;
+}
+
+.download-btn {
+ background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%) !important;
+ border: none !important;
+ color: white !important;
+ font-weight: 700 !important;
+ font-size: 1.05rem !important;
+ padding: 12px 28px !important;
+ border-radius: 12px !important;
+ box-shadow: 0 4px 15px rgba(17, 153, 142, 0.35) !important;
+ transition: all 0.3s ease !important;
+}
+
+.download-btn:hover {
+ transform: translateY(-2px) !important;
+ box-shadow: 0 8px 25px rgba(17, 153, 142, 0.5) !important;
+}
+
+.info-badge {
+ display: inline-block;
+ background: rgba(102, 126, 234, 0.12);
+ color: #667eea;
+ padding: 4px 12px;
+ border-radius: 20px;
+ font-size: 0.85rem;
+ font-weight: 600;
+ margin: 4px 0;
+}
+
+footer { display: none !important; }
+"""
+
+def build_app():
+ """Construct the Gradio Blocks app."""
+ theme = gr.themes.Soft(
+ primary_hue=gr.themes.colors.indigo,
+ secondary_hue=gr.themes.colors.purple,
+ neutral_hue=gr.themes.colors.gray,
+ font=gr.themes.GoogleFont("Inter"),
+ ).set(
+ body_background_fill="*neutral_950",
+ body_background_fill_dark="*neutral_950",
+ block_background_fill="*neutral_900",
+ block_background_fill_dark="*neutral_900",
+ block_border_width="0px",
+ block_shadow="0 2px 12px rgba(0,0,0,0.3)",
+ input_background_fill="*neutral_800",
+ input_background_fill_dark="*neutral_800",
+ )
+
+ with gr.Blocks(
+ theme=theme,
+ css=CSS,
+ title="LATO.2 — Image to 3D Mesh",
+ ) as app:
+ # ── Header ────────────────────────────────────────────────────────
+ gr.HTML(
+ 'LATO.2
'
+ 'Factorized 3D Mesh Generation with Vertex & Topology Flow
'
+ )
+ gr.Markdown(DESCRIPTION)
+
+ with gr.Row(equal_height=False):
+ # ── LEFT: Inputs ──────────────────────────────────────────────
+ with gr.Column(scale=1, min_width=380):
+ gr.Markdown("### 📥 Inputs")
+
+ input_image = gr.Image(
+ label="Conditioning Image (optional)",
+ type="numpy",
+ height=280,
+ sources=["upload", "clipboard"],
+ elem_id="input-image",
+ )
+ input_mesh = gr.File(
+ label="Reference Mesh (.glb / .obj / .ply / .stl)",
+ file_types=[".glb", ".gltf", ".obj", ".ply", ".stl", ".off"],
+ type="filepath",
+ elem_id="input-mesh",
+ )
+
+ with gr.Accordion("⚙️ Generation Parameters", open=True, elem_classes="param-accordion"):
+ vert_num = gr.Slider(
+ label="Target Vertex Count",
+ minimum=200,
+ maximum=5000,
+ value=2000,
+ step=100,
+ info="Number of vertices in the generated mesh (200–5000)",
+ )
+ cfg_strength = gr.Slider(
+ label="CFG Strength",
+ minimum=0.0,
+ maximum=10.0,
+ value=3.0,
+ step=0.5,
+ info="Classifier-free guidance strength",
+ )
+ with gr.Row():
+ vflow_steps = gr.Slider(
+ label="V-Flow Steps",
+ minimum=4,
+ maximum=64,
+ value=24,
+ step=4,
+ info="Euler steps for vertex flow",
+ )
+ tflow_steps = gr.Slider(
+ label="T-Flow Steps",
+ minimum=10,
+ maximum=100,
+ value=50,
+ step=5,
+ info="Euler steps for topology flow",
+ )
+ seed = gr.Number(
+ label="Random Seed",
+ value=42,
+ precision=0,
+ info="Seed for reproducibility",
+ )
+
+ generate_btn = gr.Button(
+ "🚀 Generate 3D Mesh",
+ variant="primary",
+ size="lg",
+ elem_classes="generate-btn",
+ elem_id="generate-btn",
+ )
+
+ # ── Example meshes ────────────────────────────────────────
+ if os.path.isdir(EXAMPLES_DIR):
+ example_files = sorted(
+ os.path.join(EXAMPLES_DIR, f)
+ for f in os.listdir(EXAMPLES_DIR)
+ if os.path.splitext(f)[1].lower() in MESH_EXTENSIONS
+ )
+ if example_files:
+ gr.Markdown("### 📂 Example Meshes")
+ gr.Examples(
+ examples=[[None, f, 2000, 3.0, 24, 50, 42] for f in example_files],
+ inputs=[input_image, input_mesh, vert_num, cfg_strength, vflow_steps, tflow_steps, seed],
+ label="Click to load an example",
+ cache_examples=False,
+ )
+
+ # ── RIGHT: Outputs ────────────────────────────────────────────
+ with gr.Column(scale=2, min_width=600):
+ gr.Markdown("### 🖼️ 3D Output — Rerun Viewer")
+
+ rerun_viewer = Rerun(
+ streaming=False,
+ height=560,
+ elem_id="rerun-viewer",
+ )
+
+ gr.Markdown("---")
+ gr.Markdown("### 📦 Download")
+
+ glb_output = gr.File(
+ label="Generated GLB File",
+ type="filepath",
+ elem_id="glb-output",
+ interactive=False,
+ )
+
+ download_btn = gr.DownloadButton(
+ label="⬇️ Download GLB File",
+ size="lg",
+ elem_classes="download-btn",
+ elem_id="download-btn",
+ visible=False,
+ )
+
+ # ── Event wiring ──────────────────────────────────────────────────
+
+ def on_generate(image, mesh_path, vn, cfg, vfs, tfs, s):
+ rr_data, glb_path = generate_mesh(
+ input_image=image,
+ input_mesh_path=mesh_path,
+ vert_num=int(vn),
+ cfg_strength=float(cfg),
+ vflow_steps=int(vfs),
+ tflow_steps=int(tfs),
+ seed=int(s),
+ )
+ return (
+ rr_data,
+ glb_path,
+ gr.update(value=glb_path, visible=True),
+ )
+
+ generate_btn.click(
+ fn=on_generate,
+ inputs=[input_image, input_mesh, vert_num, cfg_strength, vflow_steps, tflow_steps, seed],
+ outputs=[rerun_viewer, glb_output, download_btn],
+ )
+
+ # ── Footer ────────────────────────────────────────────────────────
+ gr.HTML(
+ ''
+ '🔬 LATO.2 — Factorized 3D Mesh Generation with Vertex & Topology Flow
'
+ '
Hang Long, Tianhao Zhao et al. • '
+ 'arXiv 2607.10623 • '
+ '🤗 Model'
+ '