Delete app.py

app.py

@@ -1,210 +0,0 @@
-"""
-Hunyuan3D-2 — Shape-only HuggingFace Space
-Uses Hunyuan3D-2mini-Turbo (0.6 B, step-distilled) for fast shape generation
-within standard ZeroGPU quota. No texture pipeline — mesh only.
-"""
-
-import os
-import tempfile
-
-import gradio as gr
-import spaces          # ZeroGPU decorator
-import torch
-from PIL import Image
-
-# ---------------------------------------------------------------------------
-# Lazy global pipeline — loaded once on first GPU call
-# ---------------------------------------------------------------------------
-_pipeline = None
-
-
-def _get_pipeline():
-    """Load the shape pipeline once and cache it."""
-    global _pipeline
-    if _pipeline is None:
-        from hy3dgen.shapegen import Hunyuan3DDiTFlowMatchingPipeline
-
-        _pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained(
-            "tencent/Hunyuan3D-2mini",
-            subfolder="hunyuan3d-dit-v2-mini-turbo",   # step-distilled turbo variant
-            use_safetensors=True,
-            torch_dtype=torch.float16,
-        )
-    return _pipeline
-
-
-# ---------------------------------------------------------------------------
-# Background removal (CPU-side pre-processing, outside the GPU block)
-# ---------------------------------------------------------------------------
-def remove_background(pil_image: Image.Image) -> Image.Image:
-    """Return RGBA image with background removed via rembg."""
-    try:
-        from rembg import remove as rembg_remove
-        return rembg_remove(pil_image)
-    except Exception:
-        # Graceful fallback: return image as-is (model handles white BG)
-        return pil_image.convert("RGBA")
-
-
-def preprocess_image(pil_image: Image.Image) -> Image.Image:
-    """Resize, strip background, and composite on white for the model."""
-    pil_image = pil_image.convert("RGBA")
-    pil_image = remove_background(pil_image)
-
-    # Composite RGBA onto white background (model was trained this way)
-    white_bg = Image.new("RGBA", pil_image.size, (255, 255, 255, 255))
-    white_bg.paste(pil_image, mask=pil_image.split()[3])
-    result = white_bg.convert("RGB")
-
-    # Resize to 512×512 — model's native conditioning resolution
-    result = result.resize((512, 512), Image.LANCZOS)
-    return result
-
-
-# ---------------------------------------------------------------------------
-# Core generation — wrapped in @spaces.GPU for ZeroGPU
-# ---------------------------------------------------------------------------
-@spaces.GPU(duration=60)    # 60 s is sufficient for mini-turbo at low step counts
-def generate_shape(image: Image.Image, seed: int, steps: int, octree_res: int):
-    """
-    Run Hunyuan3D-DiT shape generation and return a GLB file path.
-
-    Parameters
-    ----------
-    image : PIL.Image
-        Pre-processed condition image (RGB, 512×512).
-    seed : int
-        Random seed for reproducibility.
-    steps : int
-        Number of diffusion steps (fewer = faster; turbo model works well at 5-10).
-    octree_res : int
-        Octree resolution for mesh extraction — higher = more detail, slower.
-
-    Returns
-    -------
-    str
-        Path to the output .glb file (written to a temp directory).
-    """
-    pipeline = _get_pipeline()
-    pipeline = pipeline.to("cuda")
-
-    generator = torch.Generator(device="cuda").manual_seed(seed)
-
-    meshes = pipeline(
-        image=image,
-        num_inference_steps=steps,
-        octree_resolution=octree_res,
-        num_chunks=8000,          # chunk size for memory efficiency
-        generator=generator,
-        output_type="trimesh",
-    )
-    mesh = meshes[0]
-
-    # Save to a temp file so Gradio can serve it
-    tmp_dir = tempfile.mkdtemp()
-    out_path = os.path.join(tmp_dir, "shape.glb")
-    mesh.export(out_path)
-    return out_path
-
-
-# ---------------------------------------------------------------------------
-# Gradio UI
-# ---------------------------------------------------------------------------
-def run(image, seed, steps, octree_res, progress=gr.Progress(track_tqdm=True)):
-    if image is None:
-        raise gr.Error("Please upload an image first.")
-
-    progress(0.1, desc="Removing background …")
-    pil = Image.fromarray(image) if not isinstance(image, Image.Image) else image
-    processed = preprocess_image(pil)
-
-    progress(0.3, desc="Running shape diffusion …")
-    glb_path = generate_shape(processed, int(seed), int(steps), int(octree_res))
-
-    progress(1.0, desc="Done!")
-    return glb_path, processed, glb_path
-
-
-with gr.Blocks(title="Hunyuan3D-2 Shape Generator", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-        # 🧊 Hunyuan3D-2 — Shape Generator
-        Upload any image to generate an **untextured 3-D mesh** using
-        [Hunyuan3D-2mini-Turbo](https://huggingface.co/tencent/Hunyuan3D-2mini).
-        Shape only — no texture — so it stays well within the ZeroGPU free quota.
-        """
-    )
-
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(
-                label="Input Image",
-                type="pil",
-                sources=["upload", "webcam", "clipboard"],
-                height=340,
-            )
-
-            with gr.Accordion("⚙️ Advanced settings", open=False):
-                seed = gr.Slider(
-                    label="Seed",
-                    minimum=0, maximum=2**31 - 1,
-                    value=42, step=1,
-                )
-                steps = gr.Slider(
-                    label="Diffusion steps",
-                    minimum=5, maximum=50,
-                    value=5, step=1,
-                    info="5-15 works well with the turbo model.",
-                )
-                octree_res = gr.Slider(
-                    label="Octree resolution",
-                    minimum=128, maximum=512,
-                    value=192, step=64,
-                    info="Higher = finer mesh detail but more VRAM & time.",
-                )
-
-            generate_btn = gr.Button("✨ Generate Shape", variant="primary")
-
-        with gr.Column(scale=1):
-            preview_img = gr.Image(
-                label="Preprocessed image (sent to model)",
-                type="pil",
-                interactive=False,
-                height=200,
-            )
-            output_3d = gr.Model3D(
-                label="3-D Shape (GLB)",
-                height=400,
-                clear_color=[0.9, 0.9, 0.9, 1.0],
-            )
-            download_file = gr.File(label="⬇ Download GLB", visible=True)
-
-    gr.Examples(
-        examples=[
-            # Add your own example image paths here after uploading them to the Space
-        ],
-        inputs=[input_image],
-        label="Examples (upload your own to try)",
-    )
-
-    gr.Markdown(
-        """
-        ---
-        **Tips**
-        - Works best on isolated objects on a plain background.
-        - The background is removed automatically — results improve with clean subjects.
-        - Lower octree resolution (128–256) is faster and still looks great for most objects.
-        - Model: *Hunyuan3D-DiT-v2-mini-Turbo* — 0.6 B parameters, step-distilled.
-        """
-    )
-
-    # Wire up events
-    generate_btn.click(
-        fn=run,
-        inputs=[input_image, seed, steps, octree_res],
-        outputs=[output_3d, preview_img, download_file],
-    )
-
-
-if __name__ == "__main__":
-    demo.queue(max_size=5).launch()