Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,34 @@
+# Python
+.venv/
+venv/
+env/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Outputs and weights
+outputs/
+weights/
+*.obj
+*.glb
+*.png
+!scripts/**/*.png
+TripoSR/
+*.ckpt
+*.safetensors
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Streamlit
+.streamlit/
+
+# Logs
+*.log
+performance_log.txt

.huggingfaceignore

@@ -0,0 +1,40 @@
+# Exclude from Hugging Face upload (hf upload)
+# Only code and config are uploaded; weights/outputs stay local.
+
+# Python
+.venv/
+venv/
+env/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Outputs and model weights (large; users download separately)
+outputs/
+weights/
+*.obj
+*.glb
+*.png
+TripoSR/
+*.ckpt
+*.safetensors
+*.bin
+
+# IDE and editor
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Streamlit
+.streamlit/
+
+# Logs
+*.log
+performance_log.txt
+
+# Git (keep .gitignore in repo)
+.git/

README.md

@@ -0,0 +1,155 @@
+# selfhostedmodels
+
+# Evoneural MVP – Local Mesh & Skybox
+
+Localhost MVP for **text → 3D mesh** and **text → 360° skybox** using local models (no hosted APIs).
+
+- **Mesh**: Text → image (Stable Diffusion) → 3D mesh (TripoSR). Output: `.obj` or `.glb`.
+- **Skybox**: Text → 2:1 equirectangular image (Stable Diffusion). Optional seamless edge check.
+
+**Default model:** `runwayml/stable-diffusion-v1-5` (no Hugging Face login required; first run downloads ~4GB).
+
+## Prerequisites
+
+- **Python 3.10** (recommended) — [python.org](https://www.python.org/downloads/)
+- **NVIDIA GPU** with CUDA (recommended; CPU is slower)
+- **Git** (for cloning TripoSR; mesh only)
+
+**No Conda?** Use **venv** (built into Python) — steps below.
+
+## 1. Environment
+
+### Option A: venv + pip (no Conda)
+
+From PowerShell (project folder is `evoneural`):
+
+```powershell
+cd D:\project\evoneural
+python -m venv .venv
+.venv\Scripts\Activate.ps1
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
+pip install -r requirements.txt
+```
+
+- **CPU only:** use `pip install torch torchvision` (no `--index-url`).
+- **CUDA 12.x:** use `cu121` instead of `cu118`.
+
+### Option B: Conda
+
+```powershell
+cd D:\project\evoneural
+conda env create -f environment.yml
+conda activate evoneural-mvp
+```
+
+If you use CPU-only or a different CUDA version, edit `environment.yml` (e.g. remove `pytorch-cuda=11.8` or set `pytorch-cuda=12.1`).
+
+## 2. TripoSR (for mesh)
+
+Mesh generation needs the TripoSR repo and its dependencies.
+
+```powershell
+cd D:\project\evoneural
+git clone https://github.com/VAST-AI-Research/TripoSR.git TripoSR
+pip install -r TripoSR/requirements.txt
+```
+
+On Windows, if `torchmcubes` fails, see [TripoSR README](https://github.com/VAST-AI-Research/TripoSR#troubleshooting) (CUDA version match, then reinstall torchmcubes).
+
+## 2b. Stable Diffusion model (Hugging Face)
+
+If you see **"Cannot load model ... model is not cached locally and an error occurred while trying to fetch metadata"**, the app cannot reach Hugging Face. Use one of these:
+
+**Option 1 – Log in (uses cached token)**  
+From a terminal with internet:
+
+```powershell
+huggingface-cli login
+```
+
+Paste a token from [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) (read access is enough). Then run the app again.
+
+**Option 2 – Set token in env**  
+Create a token at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens), then:
+
+```powershell
+$env:HF_TOKEN = "hf_xxxxxxxx"
+streamlit run app.py
+```
+
+**Option 3 – Download model once, then use offline**  
+On a machine that can reach Hugging Face:
+
+```powershell
+cd D:\project\evoneural
+.venv\Scripts\Activate.ps1
+python -m scripts.download_sd_model
+```
+
+Then set the path and run the app (no Hugging Face needed):
+
+```powershell
+$env:SD_MODEL_PATH = "D:\project\evoneural\weights\stable-diffusion-2-1-base"
+streamlit run app.py
+```
+
+## How it works
+
+1. **Skybox tab:** You enter a text prompt → the app loads Stable Diffusion (from cache or Hugging Face) → generates a 2:1 image → saves to `outputs/` and shows a download button. Optional “seamless” check compares left/right edges.
+2. **Mesh tab:** You enter a prompt (or upload an image) → the app generates an image with SD (if needed) → runs TripoSR on that image → outputs a `.obj` or `.glb` to `outputs/` (requires TripoSR repo cloned in `./TripoSR`).
+3. **Model loading:** The app first tries a local folder (`SD_MODEL_PATH` or `weights/stable-diffusion-2-1-base` if complete). If none, it loads `runwayml/stable-diffusion-v1-5` from the Hub (first run downloads the model; later runs use the cache). No token needed unless your network restricts Hugging Face.
+
+## 3. Run the app
+
+From the project root (with venv activated):
+
+```powershell
+cd D:\project\evoneural
+.venv\Scripts\Activate.ps1
+streamlit run app.py
+```
+
+Open **http://localhost:8501**.
+
+- **Text → 3D Mesh**: Enter a prompt (or upload an image). First run downloads SD 2.1 and TripoSR weights.
+- **Text → Skybox**: Enter a prompt; image is 2:1 (e.g. 1024×512). Use “Run seamless edge check” to compare left/right edges.
+
+Outputs are under `outputs/`. Use the download buttons to save mesh (`.glb`/`.obj`) and skybox (`.png`).
+
+## 4. Performance
+
+- **Skybox**: ~6–8 GB VRAM (SD 2.1, 1024×512, FP16). Use 2048×1024 only if you have enough VRAM.
+- **Mesh**: ~6 GB for TripoSR + ~6 GB for SD (text-to-image). Total peak can be ~10–12 GB if both run in same process.
+
+If you run out of VRAM:
+
+- Use 1024×512 for skybox.
+- Close other GPU apps.
+- Consider quantization (e.g. 8-bit) or CPU offload in diffusers (see [Optimization](#optimization)).
+
+## 5. Optimization (if VRAM is exceeded)
+
+- **Quantization**: Use `load_in_8bit=True` or `load_in_4bit=True` with `bitsandbytes` where supported in diffusers.
+- **Model CPU offload**: In diffusers, `pipe.enable_sequential_cpu_offload()` or `pipe.enable_model_cpu_offload()` to move parts to CPU and reduce peak VRAM (slower).
+- **Smaller resolution**: 512×512 for text-to-image; 1024×512 for skybox.
+
+## Project layout
+
+```
+evoneural/
+├── README.md
+├── app.py                 # Streamlit UI
+├── requirements.txt
+├── environment.yml
+├── scripts/
+│   ├── skybox_generator.py
+│   ├── mesh_generator.py
+│   ├── text_to_image.py
+│   └── check_seamless.py
+├── outputs/                # Generated meshes and skybox images
+└── TripoSR/                # Clone here (see step 2)
+```
+
+## License
+
+See TripoSR and Stable Diffusion model licenses (MIT / Stability). This MVP is for local use and evaluation.

app.py

@@ -0,0 +1,181 @@
+"""
+Evoneural MVP - Local 3D Mesh + Skybox Generation
+Run: streamlit run app.py
+Open: http://localhost:8501
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Ensure project root is on path
+ROOT = Path(__file__).resolve().parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import streamlit as st
+
+OUTPUTS = ROOT / "outputs"
+OUTPUTS.mkdir(exist_ok=True)
+
+
+def main() -> None:
+    st.set_page_config(
+        page_title="Evoneural MVP - Mesh & Skybox",
+        page_icon="🎮",
+        layout="wide",
+    )
+    st.title("Evoneural MVP – Local Mesh & Skybox")
+    st.caption("Text → 3D mesh (TripoSR) and Text → 360° skybox (Stable Diffusion). Runs on localhost.")
+
+    # Sidebar: model setup (token + download)
+    with st.sidebar:
+        st.subheader("Stable Diffusion model")
+        from scripts.skybox_generator import _default_local_weights_dir
+        local_model = _default_local_weights_dir()
+        if local_model:
+            st.success(f"Local model: found")
+            st.caption(os.path.basename(local_model))
+        else:
+            st.warning("No local model. Download below or need internet on first generate.")
+        hf_token = st.text_input(
+            "Hugging Face token (optional, if behind firewall)",
+            type="password",
+            key="hf_token",
+            placeholder="hf_...",
+            help="Get a token at huggingface.co/settings/tokens",
+        )
+        if hf_token:
+            os.environ["HF_TOKEN"] = hf_token
+        if st.button("Download model (~4GB to ./weights/sd-v1-5)", key="btn_download"):
+            with st.spinner("Downloading model... (may take several minutes)"):
+                try:
+                    from scripts.download_sd_model import download_sd_model
+                    path = download_sd_model(token=hf_token or os.environ.get("HF_TOKEN"))
+                    st.success(f"Model saved. Try generating a skybox.")
+                    st.rerun()
+                except Exception as e:
+                    st.error(str(e))
+                    st.caption("Set a Hugging Face token above if your network blocks Hugging Face.")
+
+    tab_mesh, tab_skybox = st.tabs(["🟦 Text → 3D Mesh", "🌅 Text → Skybox"])
+
+    with tab_mesh:
+        st.subheader("Generate 3D mesh from text")
+        st.markdown(
+            "Uses **Stable Diffusion** for text→image, then **TripoSR** for image→mesh. "
+            "TripoSR repo must be cloned into `./TripoSR` (see README)."
+        )
+        prompt_mesh = st.text_input(
+            "Prompt (e.g. for mesh)",
+            value="A highly detailed, sci-fi mechanical drone with glowing blue accents.",
+            key="mesh_prompt",
+        )
+        col1, col2 = st.columns(2)
+        with col1:
+            mesh_format = st.selectbox("Mesh format", ["glb", "obj"], key="mesh_fmt")
+            seed_mesh = st.number_input("Seed (optional)", value=42, min_value=0, key="mesh_seed")
+        with col2:
+            use_image = st.checkbox("Use uploaded image instead of text", value=False, key="use_img")
+            uploaded = st.file_uploader("Upload image for mesh", type=["png", "jpg"], key="mesh_upload") if use_image else None
+
+        if st.button("Generate mesh", key="btn_mesh"):
+            if not prompt_mesh.strip() and not use_image:
+                st.warning("Enter a prompt or upload an image.")
+            else:
+                with st.spinner("Running pipeline..."):
+                    try:
+                        from scripts.mesh_generator import (
+                            generate_mesh_from_image,
+                            generate_mesh_from_text,
+                            find_triposr_root,
+                        )
+                        triposr_root = find_triposr_root(str(ROOT))
+                        if not triposr_root:
+                            st.error(
+                                "TripoSR not found. Clone it: "
+                                "`git clone https://github.com/VAST-AI-Research/TripoSR.git TripoSR`"
+                            )
+                        elif use_image and uploaded:
+                            path = os.path.join(OUTPUTS, "uploaded_mesh_input.png")
+                            with open(path, "wb") as f:
+                                f.write(uploaded.getvalue())
+                            mesh_path, elapsed, msg = generate_mesh_from_image(
+                                path,
+                                output_dir=str(OUTPUTS / "mesh_run"),
+                                mesh_format=mesh_format,
+                            )
+                            if mesh_path:
+                                st.success(f"Done in {elapsed:.1f}s. {msg}")
+                                with open(mesh_path, "rb") as f:
+                                    st.download_button("Download mesh", f, file_name=os.path.basename(mesh_path), key="dl_mesh_upload")
+                            else:
+                                st.error(msg)
+                        else:
+                            mesh_path, elapsed, msg = generate_mesh_from_text(
+                                prompt_mesh,
+                                output_dir=str(OUTPUTS),
+                                mesh_format=mesh_format,
+                                seed=seed_mesh,
+                            )
+                            if mesh_path:
+                                st.success(f"Done in {elapsed:.1f}s. {msg}")
+                                with open(mesh_path, "rb") as f:
+                                    st.download_button("Download mesh", f, file_name=os.path.basename(mesh_path), key="dl_mesh")
+                            else:
+                                st.error(msg)
+                    except Exception as e:
+                        st.exception(e)
+
+    with tab_skybox:
+        st.subheader("Generate 2:1 equirectangular skybox")
+        st.markdown(
+            "Uses **Stable Diffusion 2.1** at 2:1 aspect (e.g. 1024×512). "
+            "Optional seamless check compares left/right edges."
+        )
+        prompt_sky = st.text_input(
+            "Prompt (e.g. for skybox)",
+            value="Cyberpunk city skyline at dusk, neon reflections, cinematic lighting.",
+            key="sky_prompt",
+        )
+        col1, col2 = st.columns(2)
+        with col1:
+            width = st.selectbox("Width", [1024, 2048], key="sky_w")
+            height = width // 2
+            seed_sky = st.number_input("Seed (optional)", value=42, min_value=0, key="sky_seed")
+        with col2:
+            check_seamless = st.checkbox("Run seamless edge check", value=True, key="seamless")
+
+        if st.button("Generate skybox", key="btn_sky"):
+            if not prompt_sky.strip():
+                st.warning("Enter a prompt.")
+            else:
+                with st.spinner("Generating skybox..."):
+                    try:
+                        from scripts.skybox_generator import generate_skybox
+                        from scripts.check_seamless import check_seamless as run_seamless
+
+                        out_path, elapsed, vram_mb = generate_skybox(
+                            prompt_sky,
+                            output_dir=str(OUTPUTS),
+                            width=width,
+                            height=height,
+                            seed=seed_sky,
+                        )
+                        st.success(f"Done in {elapsed:.1f}s. Peak VRAM: {vram_mb:.0f} MB")
+                        st.image(out_path, use_container_width=True)
+                        with open(out_path, "rb") as f:
+                            st.download_button("Download skybox", f, file_name=os.path.basename(out_path), key="dl_sky")
+
+                        if check_seamless:
+                            result = run_seamless(out_path)
+                            st.info(result["message"])
+                    except Exception as e:
+                        st.exception(e)
+
+    st.divider()
+    st.caption("Evoneural AI – Local ML Deployment MVP. Models run locally (no API).")
+
+
+if __name__ == "__main__":
+    main()

environment.yml

@@ -0,0 +1,25 @@
+# Conda environment for Evoneural MVP
+# Create: conda env create -f environment.yml
+# Activate: conda activate evoneural-mvp
+
+name: evoneural-mvp
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.10
+  - pip
+  - pytorch
+  - torchvision
+  - pytorch-cuda=11.8  # or 12.1; comment out if CPU-only
+  - pip:
+    - streamlit>=1.28.0
+    - diffusers>=0.25.0
+    - transformers>=4.35.0
+    - accelerate>=0.25.0
+    - safetensors>=0.4.0
+    - huggingface-hub>=0.20.0
+    - rembg>=2.0.50
+    - Pillow>=10.0.0

requirements.txt

@@ -0,0 +1,33 @@
+# Evoneural MVP - Local 3D Mesh + Skybox Generation
+# Python 3.10 recommended. Install PyTorch with CUDA first: https://pytorch.org
+
+# Core
+torch>=2.0.0
+torchvision>=0.15.0
+Pillow>=10.0.0
+
+# Streamlit UI
+streamlit>=1.28.0
+
+# Skybox: Stable Diffusion (diffusers)
+diffusers>=0.25.0
+transformers>=4.35.0
+accelerate>=0.25.0
+safetensors>=0.4.0
+
+# Optional: reduce VRAM for skybox
+# xformers  # uncomment if you have CUDA and want lower VRAM
+
+# Mesh: TripoSR dependencies (also need TripoSR repo cloned - see README)
+huggingface-hub>=0.20.0
+rembg>=2.0.50
+numpy>=1.24.0
+
+# Text-to-image for mesh (same as skybox stack)
+# (already above)
+
+# TripoSR-specific (install after cloning TripoSR, or use our subprocess runner)
+# omegaconf==2.3.0
+# einops==0.7.0
+# trimesh>=4.0.0
+# xatlas==0.0.9

scripts/__init__.py

@@ -0,0 +1 @@
+# Evoneural MVP scripts

scripts/check_seamless.py

@@ -0,0 +1,36 @@
+"""
+Seamless check for 2:1 equirectangular skybox: compare left vs right edge.
+Returns MSE and a simple pass/fail (low MSE = more seamless).
+"""
+
+import numpy as np
+from PIL import Image
+
+
+def check_seamless(image_path: str, column_width: int = 5) -> dict:
+    """
+    Load image, compare left and right edge columns. Equirectangular wraps,
+    so left and right should match for a seamless skybox.
+    Returns dict with mse, passed (bool), and message.
+    """
+    img = np.array(Image.open(image_path).convert("RGB"))
+    h, w = img.shape[:2]
+
+    if w < 2 * column_width:
+        return {
+            "mse": float("inf"),
+            "passed": False,
+            "message": f"Image width {w} too small for column width {column_width}",
+        }
+
+    left = img[:, :column_width].astype(np.float32)
+    right = img[:, -column_width:].astype(np.float32)
+    mse = float(np.mean((left - right) ** 2))
+
+    # Heuristic: MSE < 100 often looks reasonably seamless
+    passed = mse < 100
+    message = (
+        f"Left/right edge MSE = {mse:.2f}. "
+        + ("Seamless (edges match)." if passed else "Edges differ (consider 360° model).")
+    )
+    return {"mse": mse, "passed": passed, "message": message}

scripts/download_sd_model.py

@@ -0,0 +1,46 @@
+"""
+Download Stable Diffusion v1.5 to ./weights/sd-v1-5 for offline use.
+Run once (with internet). App auto-uses this folder if present.
+
+  python -m scripts.download_sd_model
+
+Set HF_TOKEN=your_token if behind firewall. Can also use "Download model" in the app sidebar.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+MODEL_ID = "runwayml/stable-diffusion-v1-5"
+DEFAULT_LOCAL_DIR = ROOT / "weights" / "sd-v1-5"
+
+
+def download_sd_model(local_dir: str | Path | None = None, token: str | None = None) -> str:
+    """Download runwayml/stable-diffusion-v1-5 to local_dir. Returns path on success, raises on failure."""
+    from huggingface_hub import snapshot_download
+    out_dir = Path(local_dir or DEFAULT_LOCAL_DIR)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    tok = token or os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    snapshot_download(
+        repo_id=MODEL_ID,
+        local_dir=str(out_dir),
+        token=tok,
+    )
+    return str(out_dir.resolve())
+
+
+def main() -> None:
+    out_dir = os.environ.get("SD_MODEL_PATH", str(DEFAULT_LOCAL_DIR))
+    try:
+        path = download_sd_model(local_dir=out_dir)
+        print(f"Done. App will use: {path}")
+        print("Run: streamlit run app.py")
+    except Exception as e:
+        print(f"Download failed: {e}", file=sys.stderr)
+        print("Set HF_TOKEN=your_token if behind firewall (huggingface.co/settings/tokens)", file=sys.stderr)
+        raise SystemExit(1) from e
+
+
+if __name__ == "__main__":
+    main()

scripts/mesh_generator.py

@@ -0,0 +1,123 @@
+"""
+Mesh generator: image → 3D mesh via TripoSR (local).
+Expects TripoSR repo cloned at project_root/TripoSR. Uses subprocess to run run.py.
+For text→mesh: first generate image with text_to_image(), then call this.
+"""
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def find_triposr_root(project_root: str | None = None) -> str | None:
+    """Locate TripoSR repo: ./TripoSR or ../TripoSR from script dir."""
+    if project_root is None:
+        project_root = str(Path(__file__).resolve().parent.parent)
+    candidates = [
+        os.path.join(project_root, "TripoSR"),
+        os.path.join(project_root, "..", "TripoSR"),
+    ]
+    for p in candidates:
+        run_py = os.path.join(p, "run.py")
+        if os.path.isfile(run_py):
+            return p
+    return None
+
+
+def generate_mesh_from_image(
+    image_path: str,
+    output_dir: str = "outputs",
+    mesh_format: str = "glb",
+    triposr_root: str | None = None,
+    device: str = "cuda:0",
+) -> tuple[str | None, float, str]:
+    """
+    Run TripoSR on an image. Returns (path_to_mesh, inference_time_sec, message).
+    If TripoSR is not found, returns (None, 0, error_message).
+    """
+    project_root = str(Path(__file__).resolve().parent.parent)
+    triposr_root = triposr_root or find_triposr_root(project_root)
+    if not triposr_root:
+        return (
+            None,
+            0.0,
+            "TripoSR not found. Clone it: git clone https://github.com/VAST-AI-Research/TripoSR.git",
+        )
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    # TripoSR writes to output_dir/0/mesh.obj (or mesh.glb)
+    run_py = os.path.join(triposr_root, "run.py")
+    cmd = [
+        sys.executable,
+        run_py,
+        image_path,
+        "--output-dir",
+        output_dir,
+        "--model-save-format",
+        mesh_format,
+        "--device",
+        device,
+    ]
+
+    t0 = time.perf_counter()
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=triposr_root,
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        t1 = time.perf_counter()
+        if result.returncode != 0:
+            return (
+                None,
+                t1 - t0,
+                f"TripoSR failed: {result.stderr or result.stdout or 'unknown'}",
+            )
+        # Output is output_dir/0/mesh.glb or mesh.obj
+        mesh_path = os.path.join(output_dir, "0", f"mesh.{mesh_format}")
+        if not os.path.isfile(mesh_path):
+            return (None, t1 - t0, f"TripoSR did not produce {mesh_path}")
+        return (os.path.abspath(mesh_path), t1 - t0, "OK")
+    except subprocess.TimeoutExpired:
+        t1 = time.perf_counter()
+        return (None, t1 - t0, "TripoSR timed out (120s)")
+    except Exception as e:
+        t1 = time.perf_counter()
+        return (None, t1 - t0, str(e))
+
+
+def generate_mesh_from_text(
+    prompt: str,
+    output_dir: str = "outputs",
+    mesh_format: str = "glb",
+    seed: int | None = None,
+) -> tuple[str | None, float, str]:
+    """
+    Text → image (SD) → mesh (TripoSR). Returns (path_to_mesh, total_time_sec, message).
+    """
+    # Import here so script can run from any cwd
+    _root = str(Path(__file__).resolve().parent.parent)
+    if _root not in sys.path:
+        sys.path.insert(0, _root)
+    from scripts.text_to_image import text_to_image
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    t0 = time.perf_counter()
+    try:
+        image_path, _ = text_to_image(prompt, output_dir=output_dir, seed=seed)
+    except Exception as e:
+        return (None, 0.0, f"Text-to-image failed: {e}")
+
+    mesh_path, mesh_time, msg = generate_mesh_from_image(
+        image_path,
+        output_dir=os.path.join(output_dir, "mesh_run"),
+        mesh_format=mesh_format,
+    )
+    total_time = time.perf_counter() - t0
+    if mesh_path:
+        return (mesh_path, total_time, msg)
+    return (None, total_time, msg)

scripts/skybox_generator.py

@@ -0,0 +1,149 @@
+"""
+Skybox generator: text → 2:1 equirectangular image (Stable Diffusion, local).
+Uses FP16 to reduce VRAM. Output 1024x512 or 2048x1024.
+"""
+
+import os
+import time
+from pathlib import Path
+
+import torch
+
+# Default: v1.5 works without license acceptance. Use SD_MODEL_ID to prefer SD 2.1.
+DEFAULT_MODEL_ID = "runwayml/stable-diffusion-v1-5"
+FALLBACK_MODEL_ID = "runwayml/stable-diffusion-v1-5"  # Same; alternate if primary fails
+
+
+def get_device() -> str:
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def _is_complete_sd_dir(path: Path) -> bool:
+    """True if path looks like a complete Stable Diffusion pipeline (has unet weights)."""
+    if not path.is_dir():
+        return False
+    unet = path / "unet"
+    if not unet.is_dir():
+        return False
+    return any(
+        (unet / f).exists()
+        for f in ("diffusion_pytorch_model.safetensors", "diffusion_pytorch_model.bin")
+    )
+
+
+def _default_local_weights_dir() -> str | None:
+    """First complete SD folder under weights/ (sd-v1-5 or stable-diffusion-2-1-base)."""
+    try:
+        root = Path(__file__).resolve().parent.parent
+        for name in ("sd-v1-5", "stable-diffusion-2-1-base"):
+            local = root / "weights" / name
+            if _is_complete_sd_dir(local):
+                return str(local)
+        return None
+    except Exception:
+        return None
+
+
+def _resolve_model_path_and_token():
+    """Use local path if set or default weights/ folder exists, else Hub id. Token from HF_TOKEN or huggingface-cli login."""
+    local = os.environ.get("SD_MODEL_PATH", "").strip()
+    if local and os.path.isdir(local):
+        return local, None
+    default_local = _default_local_weights_dir()
+    if default_local:
+        return default_local, None
+    model_id = os.environ.get("SD_MODEL_ID", DEFAULT_MODEL_ID)
+    token = os.environ.get("HF_TOKEN") or True  # True = use cached login
+    return model_id, token
+
+
+def generate_skybox(
+    prompt: str,
+    output_dir: str = "outputs",
+    width: int = 1024,
+    height: int = 512,
+    seed: int | None = None,
+    model_id: str | None = None,
+) -> tuple[str, float, float]:
+    """
+    Generate a 2:1 equirectangular skybox image from a text prompt.
+    Returns (path_to_image, inference_time_sec, peak_vram_mb).
+    """
+    from diffusers import StableDiffusionPipeline
+
+    device = get_device()
+    dtype = torch.float16 if device == "cuda" else torch.float32
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+    pretrained, token = _resolve_model_path_and_token()
+    load_id = model_id or pretrained
+    local_only = os.path.isdir(load_id)
+    pipe = None
+    last_error = None
+
+    def _load(pid: str, local: bool) -> bool:
+        nonlocal pipe, last_error
+        try:
+            pipe = StableDiffusionPipeline.from_pretrained(
+                pid,
+                torch_dtype=dtype,
+                safety_checker=None,
+                token=None if local else (token or True),
+                local_files_only=local,
+            )
+            return True
+        except Exception as err:
+            last_error = err
+            return False
+
+    if _load(load_id, local_only):
+        pass
+    elif not local_only and _load(FALLBACK_MODEL_ID, False):
+        pass
+    if pipe is None:
+        raise RuntimeError(
+            "Could not load Stable Diffusion. Need internet to download the model (first run).\n"
+            "  - Set HF_TOKEN=your_token if behind firewall (huggingface.co/settings/tokens)\n"
+            "  - Or download once: huggingface-cli download runwayml/stable-diffusion-v1-5 --local-dir ./weights/sd-v1-5"
+        ) from last_error
+
+    pipe = pipe.to(device)
+
+    # Optional: enable xformers for lower VRAM (uncomment if installed)
+    # if device == "cuda":
+    #     pipe.enable_xformers_memory_efficient_attention()
+
+    if device == "cuda":
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.synchronize()
+
+    generator = None
+    if seed is not None:
+        generator = torch.Generator(device=device).manual_seed(seed)
+
+    t0 = time.perf_counter()
+    image = pipe(
+        prompt=prompt,
+        width=width,
+        height=height,
+        num_inference_steps=50,
+        generator=generator,
+    ).images[0]
+
+    if device == "cuda":
+        torch.cuda.synchronize()
+    t1 = time.perf_counter()
+    inference_time = t1 - t0
+    peak_vram_mb = (
+        torch.cuda.max_memory_allocated() / 1024 / 1024
+        if device == "cuda"
+        else 0.0
+    )
+
+    # Save with safe filename
+    safe_name = "".join(c if c.isalnum() or c in " -_" else "_" for c in prompt)[:60]
+    out_path = os.path.join(output_dir, f"skybox_{safe_name.strip()}.png")
+    image.save(out_path)
+
+    return out_path, inference_time, peak_vram_mb

scripts/text_to_image.py

@@ -0,0 +1,80 @@
+"""
+Text-to-image for mesh pipeline: generate a single image from prompt (SD 2.1, local).
+Uses same SD_MODEL_PATH / HF_TOKEN as skybox_generator.
+"""
+
+import os
+import time
+from pathlib import Path
+
+import torch
+
+from scripts.skybox_generator import _resolve_model_path_and_token, FALLBACK_MODEL_ID
+
+
+def get_device() -> str:
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def text_to_image(
+    prompt: str,
+    output_dir: str = "outputs",
+    size: int = 512,
+    seed: int | None = None,
+    model_id: str | None = None,
+) -> tuple[str, float]:
+    """Generate one image from text. Returns (path_to_image, inference_time_sec)."""
+    from diffusers import StableDiffusionPipeline
+
+    device = get_device()
+    dtype = torch.float16 if device == "cuda" else torch.float32
+
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+    pretrained, token = _resolve_model_path_and_token()
+    load_id = model_id or pretrained
+    local_only = os.path.isdir(load_id)
+    pipe = None
+    try:
+        pipe = StableDiffusionPipeline.from_pretrained(
+            load_id,
+            torch_dtype=dtype,
+            safety_checker=None,
+            token=None if local_only else (token or True),
+            local_files_only=local_only,
+        )
+    except Exception:
+        if not local_only:
+            try:
+                pipe = StableDiffusionPipeline.from_pretrained(
+                    FALLBACK_MODEL_ID,
+                    torch_dtype=dtype,
+                    safety_checker=None,
+                    token=token or True,
+                )
+            except Exception:
+                pass
+    if pipe is None:
+        raise RuntimeError(
+            "Could not load Stable Diffusion. Need internet (first run). Set HF_TOKEN if behind firewall."
+        )
+    pipe = pipe.to(device)
+
+    generator = None
+    if seed is not None:
+        generator = torch.Generator(device=device).manual_seed(seed)
+
+    t0 = time.perf_counter()
+    image = pipe(
+        prompt=prompt,
+        width=size,
+        height=size,
+        num_inference_steps=50,
+        generator=generator,
+    ).images[0]
+    t1 = time.perf_counter()
+
+    safe_name = "".join(c if c.isalnum() or c in " -_" else "_" for c in prompt)[:50]
+    out_path = os.path.join(output_dir, f"mesh_input_{safe_name.strip()}.png")
+    image.save(out_path)
+    return out_path, t1 - t0

scripts/upload_to_hf.py

@@ -0,0 +1,54 @@
+"""
+Upload evoneural code and config to Hugging Face (no weights/outputs).
+Run from project root: python -m scripts.upload_to_hf
+
+Requires: pip install huggingface_hub, and HF token (huggingface-cli login or HF_TOKEN).
+"""
+from pathlib import Path
+
+REPO_ID = "evoneural/evoneuralIn3D"
+ROOT = Path(__file__).resolve().parent.parent
+
+# Same exclusions as .huggingfaceignore so only code/config are uploaded
+IGNORE_PATTERNS = [
+    ".venv/*",
+    "venv/*",
+    "env/*",
+    "__pycache__/*",
+    "*.pyc",
+    "outputs/*",
+    "weights/*",
+    "*.obj",
+    "*.glb",
+    "*.png",
+    "TripoSR/*",
+    "*.ckpt",
+    "*.safetensors",
+    "*.bin",
+    ".idea/*",
+    ".vscode/*",
+    ".streamlit/*",
+    "*.log",
+    "performance_log.txt",
+    ".git/*",
+]
+
+
+def main() -> None:
+    from huggingface_hub import HfApi
+
+    api = HfApi()
+    # Create repo if it doesn't exist (needs write token)
+    api.create_repo(repo_id=REPO_ID, repo_type="model", exist_ok=True)
+    print(f"Uploading to {REPO_ID} (code and config only)...")
+    api.upload_folder(
+        folder_path=str(ROOT),
+        repo_id=REPO_ID,
+        repo_type="model",
+        ignore_patterns=IGNORE_PATTERNS,
+    )
+    print(f"Done. See https://huggingface.co/{REPO_ID}")
+
+
+if __name__ == "__main__":
+    main()