Remove paper folders — centralized in private aleph65/Papers

3dgazenet/README.md

@@ -1,72 +0,0 @@
-# 3dgazenet — 3DGazeNet single-photo → 3D gaze + dense eye meshes
-
-One photo in, per-face 3D gaze direction plus dense 3D eye reconstructions
-out, using [3DGazeNet](https://github.com/eververas/3DGazeNet) (Ververas et
-al., ECCV 2024) — gaze estimation as dense 3D eye-mesh regression,
-generalizing to new environments without adaptation. Uses the authors' demo
-model (resnet18, 128×128 input) trained on ETH-XGaze + GazeCapture + Gaze360 +
-MPIIFaceGaze + VFHQ. Runs on the native python of the `plx1029/comfyui-qwen`
-RunPod image (python 3.12, torch 2.8+cu128) — **no venv, no conda, torch is
-not reinstalled**.
-
-## Install (once per pod, ~2 min + ~1.6 GB downloads)
-
-```bash
-./gazenet_install.sh
-```
-
-Everything lands in `$GAZENET_HOME` (default `/workspace/3dgazenet`).
-Re-running is safe; completed steps are skipped. The demo data zip (3 gaze
-checkpoints, `eyes3d.pkl` dense-eye template, test media) comes from the
-authors' official Google Drive via gdown. The insightface `buffalo_l` face
-detector is **reused from the p3dm install** if present.
-
-## Run (~10 s per photo)
-
-```bash
-./gazenet_run.sh photo.jpg                  # -> /workspace/outputs/3dgazenet/photo/
-./gazenet_run.sh photo.jpg -o /some/dir --det-size 640 --force
-```
-
-All faces in the image are processed (files get an `_f<i>` suffix when more
-than one). Outputs: `<name>_gaze.jpg` (drawn eye contours, iris circles, gaze
-direction), `<name>_facedet.jpg` (detection check), `<name>_gaze.json` (gaze
-vectors — direct regression, per-eye from mesh, combined — plus pitch/yaw in
-rad and deg, iris centers in px, bbox, 5-pt landmarks), `<name>_eye_left.obj`
-/ `<name>_eye_right.obj` (dense 481-vertex 3D eye meshes incl. eyeball + iris
-in image-space coords, from the paper's core dense-regression output), and
-`<name>_raw.pkl` (the complete model output dict).
-
-Pipeline: insightface `buffalo_l` face detection (5-pt landmarks) → roll
-normalization → per-element crops (left eye, right eye, face) → resnet18
-regression of 2×481 eye vertices + gaze vector → gaze = combination of direct
-vector and per-eye mesh directions (`gaze_out` in the json).
-
-The wrapper `gazenet_infer.py` drives the authors' demo `GazeNetInference`
-class and exports all of the above (the stock demo only writes the drawn jpg).
-
-## Porting notes (vs. upstream repo)
-
-Upstream targets python 3.9 / torch 2.5 / numpy 1.26 via conda. On the native
-py3.12 / torch 2.8 / numpy 2.1 env **zero source patches were needed** — the
-only additions are:
-
-- `easydict` (tiny config dep) — everything else (insightface, onnxruntime,
-  opencv, matplotlib) is already in the native env (p3dm installed
-  insightface/onnxruntime)
-- `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` at runtime (checkpoint predates torch
-  2.6 `weights_only` default)
-- pip runs against a constraints file pinning the already-installed
-  numpy/torch/opencv/… so the ComfyUI env is never disturbed
-
-The main repo also ships a research pipeline (`preprocess_inference.py` +
-`inference.py` with a fitting optimizer, separate GDrive data bundle); the
-demo model is the recommended, most robust entry point for in-the-wild
-images and is what these scripts use.
-
-## Licenses
-
-3DGazeNet code and the demo checkpoints are downloaded from the authors'
-official sources at install time and are **not** redistributed here. The
-model is trained on datasets with research-only terms (ETH-XGaze,
-GazeCapture, Gaze360, MPIIFaceGaze, VFHQ) — treat outputs accordingly.

3dgazenet/gazenet_infer.py

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-"""Single-image 3DGazeNet inference with full result export.
-
-Wraps the demo's GazeNetInference to save, per detected face: gaze vectors
-(json), dense 3D eye meshes (obj, image-space coords), iris centers, the
-drawn visualization, the face-detection visualization, and a raw pickle of
-everything the model returns.
-
-Usage: python3 gazenet_infer.py --image photo.jpg --out outdir --name photo
-"""
-import argparse
-import json
-import os
-import pickle
-import sys
-
-import cv2
-import numpy as np
-
-PATH_DEMO = os.path.join(os.path.dirname(os.path.abspath(__file__)), '3DGazeNet', 'demo')
-sys.path.insert(0, PATH_DEMO)
-os.environ.setdefault('TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD', '1')
-
-from inference import GazeNetInference  # noqa: E402
-from utils import load_eyes3d, draw_results  # noqa: E402
-
-
-def pitchyaw_from_vector(g):
-    # model convention: x right, y down, z out of the image towards the
-    # camera (z ~ +1 when looking straight at the camera); pitch positive up,
-    # yaw positive to the image left, (0, 0) = looking at the camera
-    x, y, z = g / np.linalg.norm(g)
-    return float(np.arcsin(-y)), float(np.arctan2(-x, z))
-
-
-def write_eye_obj(path, verts, trilist):
-    with open(path, 'w') as f:
-        f.write('# 3DGazeNet eye mesh, image-space coords (px)\n')
-        for v in verts:
-            f.write(f'v {v[0]:.4f} {v[1]:.4f} {v[2]:.4f}\n')
-        for t in trilist:
-            f.write(f'f {t[0]+1} {t[1]+1} {t[2]+1}\n')
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument('--image', required=True)
-    ap.add_argument('--out', required=True)
-    ap.add_argument('--name', default=None)
-    ap.add_argument('--det-thresh', type=float, default=0.5)
-    ap.add_argument('--det-size', type=int, default=224)
-    args = ap.parse_args()
-
-    name = args.name or os.path.splitext(os.path.basename(args.image))[0]
-    os.makedirs(args.out, exist_ok=True)
-
-    image = cv2.imread(args.image)
-    assert image is not None, f'cannot read {args.image}'
-
-    gazenet = GazeNetInference(args.det_thresh, args.det_size)
-    bboxs, kpts, faces = gazenet.face_detector.run(image)
-    assert kpts is not None and len(kpts) > 0, 'no face detected'
-
-    # face detection visualization
-    cv2.imwrite(os.path.join(args.out, f'{name}_facedet.jpg'),
-                gazenet.face_detector.draw_bbox(image, faces))
-
-    trilist = load_eyes3d()['trilist_eye']
-    results, out_img = [], image
-    for i, kpt in enumerate(kpts):
-        res = gazenet.gaze_predictor(image, kpt, undo_roll=True)
-        assert res is not None, f'gaze prediction failed for face {i}'
-        results.append(res)
-        out_img = draw_results(out_img, kpts[i], res)
-
-    cv2.imwrite(os.path.join(args.out, f'{name}_gaze.jpg'), out_img)
-
-    summary = []
-    for i, (res, bbox, kpt) in enumerate(zip(results, bboxs, kpts)):
-        sfx = '' if len(results) == 1 else f'_f{i}'
-        for side in ('left', 'right'):
-            write_eye_obj(os.path.join(args.out, f'{name}{sfx}_eye_{side}.obj'),
-                          res['verts_eyes'][side], trilist)
-        gaze = np.asarray(res['gaze_out'], dtype=float)
-        pitch, yaw = pitchyaw_from_vector(gaze)
-        summary.append({
-            'face_index': i,
-            'bbox_xyxy': np.asarray(bbox).tolist(),
-            'kpt5': np.asarray(kpt).tolist(),
-            'gaze_out': gaze.tolist(),
-            'gaze_pitch_yaw_rad': [pitch, yaw],
-            'gaze_pitch_yaw_deg': [np.degrees(pitch), np.degrees(yaw)],
-            'gaze_direct': np.asarray(res['gaze']).tolist(),
-            'gaze_from_eyes': {k: np.asarray(v).tolist()
-                               for k, v in res['gaze_from_eyes'].items()},
-            'gaze_combined': np.asarray(res['gaze_combined']).tolist(),
-            'iris_center_px': {k: np.asarray(v).tolist()
-                               for k, v in res['centers_iris'].items()},
-        })
-
-    with open(os.path.join(args.out, f'{name}_gaze.json'), 'w') as f:
-        json.dump({'image': os.path.basename(args.image),
-                   'n_faces': len(results),
-                   'convention': 'gaze vectors: x right, y down, z towards camera '
-                                 '(z ~ +1 when looking at the camera); pitch positive '
-                                 'up, yaw positive to image left, (0,0) = at camera',
-                   'faces': summary}, f, indent=2)
-
-    with open(os.path.join(args.out, f'{name}_raw.pkl'), 'wb') as f:
-        pickle.dump({'bboxs': bboxs, 'kpts': kpts, 'results': results,
-                     'trilist_eye': trilist}, f)
-
-    for s in summary:
-        p, y = s['gaze_pitch_yaw_deg']
-        print(f"face {s['face_index']}: gaze={np.round(s['gaze_out'], 4).tolist()} "
-              f"pitch={p:.1f}deg yaw={y:.1f}deg")
-
-
-if __name__ == '__main__':
-    main()

3dgazenet/gazenet_install.sh

@@ -1,110 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# gazenet_install.sh — one-shot installer for 3DGazeNet (single photo ->
-#                      3D gaze vector + dense 3D eye meshes)
-#
-# Installs https://github.com/eververas/3DGazeNet (ECCV 2024, demo pipeline)
-# into the NATIVE python environment (no venv, no conda, no torch reinstall).
-# Tested on: Ubuntu 24.04, python 3.12, torch 2.8.0+cu128, H100 (RunPod image
-# plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (the script will not install torch)
-#   - ~1.6 GB disk (demo data zip from the authors' Google Drive: 3 gaze
-#     checkpoints + eyes3d template + test media)
-#
-# Usage:
-#   ./gazenet_install.sh
-#
-# Layout (override with GAZENET_HOME):
-#   $GAZENET_HOME/3DGazeNet        code (+ demo/data with weights)
-#   $GAZENET_HOME/gazenet_infer.py single-image inference wrapper
-# =============================================================================
-set -euo pipefail
-
-GAZENET_HOME="${GAZENET_HOME:-/workspace/3dgazenet}"
-REPO="$GAZENET_HOME/3DGazeNet"
-
-log() { echo -e "\n\033[1;36m[gazenet-install]\033[0m $*"; }
-
-mkdir -p "$GAZENET_HOME"
-cd "$GAZENET_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch"
-python3 - <<'EOF'
-import torch
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-
-# ---------------------------------------------------- constraints (protect env)
-log "generating pip constraints from current env"
-python3 - > "$GAZENET_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","opencv-python",
-          "matplotlib","onnxruntime","insightface","requests"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $GAZENET_HOME/constraints.txt"
-
-# ------------------------------------------------------------------ pip deps
-# insightface + onnxruntime are already in the native env (from
-# p3dm_install.sh); the demo additionally needs only easydict (+ gdown for the
-# data download). No source patches are required at all on py3.12/torch2.8.
-log "installing python dependencies (native env, constrained)"
-pip install -q $CONS easydict gdown
-python3 -c "import insightface, onnxruntime" 2>/dev/null || \
-  pip install -q $CONS insightface onnxruntime
-
-# ------------------------------------------------------------------ 3DGazeNet
-if [ ! -d "$REPO" ]; then
-  log "cloning 3DGazeNet"
-  git clone --depth 1 https://github.com/eververas/3DGazeNet.git "$REPO"
-fi
-
-# ------------------------------------------------------------- model weights
-# Official demo data zip (Google Drive, ~760 MB): res18 gaze checkpoints
-# (ALL, ALL+VFHQ, Gaze360), eyes3d.pkl dense-eye template, test media.
-if [ ! -s "$REPO/demo/data/checkpoints/res18_x128_all_vfhq_vert.pth" ] || \
-   [ ! -s "$REPO/demo/data/eyes3d.pkl" ]; then
-  log "downloading demo data (~760 MB, official Google Drive)"
-  gdown 1aVbPD51-8EqpJ89TqiTr40pmrpk6iESl -O "$GAZENET_HOME/gazenet_data.zip" -q
-  unzip -o -q "$GAZENET_HOME/gazenet_data.zip" -d "$GAZENET_HOME/gazenet_data_tmp"
-  rm -rf "$REPO/demo/data"
-  mv "$GAZENET_HOME/gazenet_data_tmp/data" "$REPO/demo/data"
-  rm -rf "$GAZENET_HOME/gazenet_data.zip" "$GAZENET_HOME/gazenet_data_tmp"
-fi
-
-# insightface buffalo_l detector (auto-downloaded by insightface on first use;
-# fetched explicitly here for determinism, same source as p3dm_install.sh)
-if [ ! -f ~/.insightface/models/buffalo_l/det_10g.onnx ] && \
-   [ ! -d ~/.insightface/models/buffalo_l/buffalo_l ]; then
-  log "downloading insightface buffalo_l detector"
-  mkdir -p ~/.insightface/models
-  gdown 1navJMy0DTr1_DHjLWu1i48owCPvXWfYc -O ~/.insightface/models/buffalo_l.zip -q
-  unzip -o -q ~/.insightface/models/buffalo_l.zip -d ~/.insightface/models/buffalo_l
-  rm ~/.insightface/models/buffalo_l.zip
-fi
-
-# ------------------------------------------------------------------ verify
-log "verifying imports + files"
-REPO_DIR="$REPO" python3 - <<'EOF'
-import os, sys, warnings
-warnings.filterwarnings("ignore")
-import easydict, insightface, onnxruntime, cv2, matplotlib
-repo = os.environ["REPO_DIR"]
-sys.path.insert(0, os.path.join(repo, "demo"))
-from utils import load_eyes3d
-eyes3d = load_eyes3d()
-assert eyes3d["trilist_eye"].shape[1] == 3
-for f in ["demo/data/checkpoints/res18_x128_all_vfhq_vert.pth",
-          "demo/data/eyes3d.pkl"]:
-    assert os.path.getsize(os.path.join(repo, f)) > 0, f
-print("  all good")
-EOF
-
-log "install complete. run:  ./gazenet_run.sh <photo.jpg>"

3dgazenet/gazenet_run.sh

@@ -1,60 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# gazenet_run.sh — single photo in -> 3D gaze + dense 3D eye meshes (3DGazeNet)
-#
-# Usage:
-#   ./gazenet_run.sh <photo.(jpg|png)> [-o <output_dir>] [--det-size N] [--force]
-#
-#   -o DIR        output directory  (default: /workspace/outputs/3dgazenet/<name>)
-#   --det-size N  face detection input size (default 224; try 640 for small faces)
-#   --force       redo even if cached results exist
-#
-# Outputs (in <output_dir>), per detected face (suffix _f<i> if several):
-#   <name>_gaze.jpg        input with drawn eye meshes, iris circles + gaze
-#   <name>_facedet.jpg     face detection boxes + 5-point landmarks
-#   <name>_gaze.json       gaze vectors (direct, per-eye, combined), pitch/yaw
-#                          (rad + deg), iris centers (px), bbox, landmarks
-#   <name>_eye_left.obj    dense 3D eye mesh, 481 verts (image-space px)
-#   <name>_eye_right.obj   dense 3D eye mesh, 481 verts (image-space px)
-#   <name>_raw.pkl         everything the model returns (verts, vectors, tris)
-#
-# Requires gazenet_install.sh to have been run first.
-# =============================================================================
-set -euo pipefail
-
-GAZENET_HOME="${GAZENET_HOME:-/workspace/3dgazenet}"
-REPO="$GAZENET_HOME/3DGazeNet"
-
-IMG="" ; OUT="" ; DET_SIZE=224 ; FORCE=0
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -o)         OUT="$2"; shift 2;;
-    --det-size) DET_SIZE="$2"; shift 2;;
-    --force)    FORCE=1; shift;;
-    -h|--help)  grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-    *)          IMG="$1"; shift;;
-  esac
-done
-[ -n "$IMG" ] && [ -f "$IMG" ] || { echo "usage: $0 <photo.jpg> [-o outdir] [--det-size N] [--force]"; exit 1; }
-[ -f "$REPO/demo/data/eyes3d.pkl" ] || { echo "3DGazeNet not installed - run gazenet_install.sh first"; exit 1; }
-
-# sanitized job name from the file stem
-STEM="$(basename "$IMG")"; STEM="${STEM%.*}"
-NAME="$(echo "$STEM" | tr -c 'a-zA-Z0-9' '_' | sed 's/_*$//;s/^_*//' | cut -c1-60)"
-OUT="${OUT:-/workspace/outputs/3dgazenet/$NAME}"
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1   # repo predates torch>=2.6 weights_only default
-
-log() { echo -e "\033[1;35m[3dgazenet]\033[0m $*"; }
-T0=$(date +%s)
-
-if [ "$FORCE" = 1 ]; then rm -rf "$OUT"; fi
-if [ ! -f "$OUT/${NAME}_gaze.json" ]; then
-  log "running 3DGazeNet (insightface detection -> res18 dense eye regression)"
-  python3 "$GAZENET_HOME/gazenet_infer.py" --image "$IMG" --out "$OUT" --name "$NAME" \
-      --det-size "$DET_SIZE" 2> >(grep -viE "warning|provider|set det-size|model ignore|find model" >&2 || true)
-fi
-[ -f "$OUT/${NAME}_gaze.json" ] || { echo "ERROR: inference failed for $IMG"; exit 1; }
-
-log "done in $(( $(date +%s) - T0 ))s -> $OUT"
-ls -la "$OUT"

deca/README.md

@@ -1,79 +0,0 @@
-# deca — DECA single-photo → detailed 3D FLAME face mesh
-
-One photo in, detailed 3D face reconstruction out, using
-[DECA](https://github.com/yfeng95/DECA) (Feng et al., SIGGRAPH 2021):
-a coarse FLAME mesh plus a person-specific detail (wrinkle) displacement map
-that can be re-posed with new expressions. Runs on the native python of the
-`plx1029/comfyui-qwen` RunPod image (python 3.12, torch 2.8+cu128) —
-**no venv, no conda, torch is not reinstalled**.
-
-## Install (once per pod, ~2 min + ~450 MB downloads)
-
-```bash
-./deca_install.sh
-```
-
-Everything lands in `$DECA_HOME` (default `/workspace/deca`). Re-running is
-safe; completed steps are skipped. The FLAME 2020 model is **reused from the
-p3dm install** if present (same file MICA uses); otherwise it is downloaded
-with FLAME account creds (`FLAME_USERNAME`/`FLAME_PASSWORD` env vars, free
-account at https://flame.is.tue.mpg.de). `deca_model.tar` comes from the
-authors' official Google Drive via gdown.
-
-## Run (~15 s per photo on H100; first run +30 s for CUDA JIT compile and the
-face-alignment s3fd detector weights download)
-
-```bash
-./deca_run.sh photo.jpg                    # -> /workspace/outputs/deca/photo/
-./deca_run.sh photo.jpg -o /some/dir --force
-```
-
-Outputs: `<name>.obj` (coarse FLAME mesh, 5023 verts, with UV texture
-extracted from the photo — obj/mtl/png opens textured in Blender),
-`<name>_detail.obj` (dense mesh with wrinkles baked in), `<name>_normals.png`
-(uv-space detail normal map, referenced by the mtl as displacement),
-`<name>_vis.jpg` + `<name>_vis_original_size.jpg` (input | 2d/3d landmarks |
-coarse shape | detail shape | depth), `<name>_depth.jpg`.
-
-Plus `raw/` with the machine-readable results: `<name>.mat` (all regressed
-FLAME codes — shape 100, expression 50, pose 6, camera, spherical-harmonics
-lighting 27, detail latent 128 — plus vertices, transformed vertices, 2d/3d
-landmarks, uv texture/displacement maps), `kpt2d`/`kpt3d` txt, and every
-per-part image (cropped and original-resolution renders).
-
-Pipeline: FAN (face-alignment) crop → ResNet50 encoder → FLAME decoder +
-detail displacement decoder → textured render with DECA's own CUDA
-"standard" rasterizer (JIT-compiled; enables original-resolution rendering).
-
-## What the installer patches (vs. upstream repo)
-
-Upstream targets python 3.7 / torch 1.6 / numpy 1.x / cuda 10.2 + gcc-7. To
-run on the native py3.12 / torch 2.8 / numpy 2.1 env:
-
-- `face_alignment.LandmarksType._2D` → `.TWO_D` (face-alignment ≥ 1.4)
-- numpy 2: `np.int` alias removed → `np.int64` (decalib/utils/util.py)
-- standard rasterizer CUDA source: `Tensor::data<T>()` → `data_ptr<T>()`,
-  `.type()` → `.scalar_type()` in `AT_DISPATCH`, build flags `-std=c++14
-  -ccbin=gcc-7` → `-std=c++17` (torch 2.x requirement)
-- **chumpy** installed `--no-deps` and patched (`getargspec` →
-  `getfullargspec`, numpy alias imports) — only needed to unpickle FLAME
-  (already done identically by p3dm_install.sh; skipped if present)
-- `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` at runtime (repo predates torch 2.6
-  `weights_only` default)
-- pip runs against a constraints file pinning the already-installed
-  numpy/torch/opencv/kornia/… so the ComfyUI env is never disturbed; the only
-  new packages are `face-alignment`, `yacs` (and `chumpy` if p3dm absent) —
-  pytorch3d is NOT required (DECA's own rasterizer is used)
-
-Optional not installed: `FLAME_albedo_from_BFM.npz` (needs a Basel Face Model
-registration) would enable `--useTex` FLAME albedo output; instead the run
-uses `--extractTex`, which extracts the UV texture directly from the photo
-(higher fidelity for the visible area, mean-texture fill elsewhere).
-
-## Licenses
-
-DECA code is MIT, but the FLAME model (registration required) and
-`deca_model.tar` are downloaded from their official sources at install time
-and are **not** redistributed in this repo. Check the
-[DECA license](https://github.com/yfeng95/DECA/blob/master/LICENSE) for
-usage terms of the pretrained model.

deca/deca_install.sh

@@ -1,144 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# deca_install.sh — one-shot installer for DECA (single photo -> detailed
-#                   3D FLAME face mesh with animatable expression wrinkles)
-#
-# Installs https://github.com/yfeng95/DECA into the NATIVE python environment
-# (no venv, no conda, no torch reinstall). Tested on: Ubuntu 24.04,
-# python 3.12, torch 2.8.0+cu128, H100 (RunPod image plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (the script will not install torch)
-#   - nvcc in PATH (needed once for the standard-rasterizer JIT compile)
-#   - FLAME 2020 model: reused from an existing p3dm install if present,
-#     otherwise downloaded with FLAME account creds (https://flame.is.tue.mpg.de)
-#     via env vars FLAME_USERNAME / FLAME_PASSWORD (prompts if unset).
-#
-# Usage:
-#   ./deca_install.sh
-#
-# Layout (override with DECA_HOME):
-#   $DECA_HOME/DECA        code + weights (deca_model.tar, FLAME 2020)
-#   $DECA_HOME/staging     per-image input staging
-#   $DECA_HOME/results     per-image raw demo outputs
-# =============================================================================
-set -euo pipefail
-
-DECA_HOME="${DECA_HOME:-/workspace/deca}"
-REPO="$DECA_HOME/DECA"
-
-log() { echo -e "\n\033[1;36m[deca-install]\033[0m $*"; }
-
-mkdir -p "$DECA_HOME" "$DECA_HOME/staging" "$DECA_HOME/results"
-cd "$DECA_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch/nvcc"
-python3 - <<'EOF'
-import torch
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-command -v nvcc >/dev/null || echo "  WARNING: nvcc not found - standard rasterizer JIT compile will fail at runtime"
-
-# ---------------------------------------------------- constraints (protect env)
-# Pin the currently-installed versions of shared heavyweight packages so pip
-# cannot up/downgrade them while installing DECA deps (keeps ComfyUI safe).
-log "generating pip constraints from current env"
-python3 - > "$DECA_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","scikit-image",
-          "opencv-python","kornia","imageio","requests"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $DECA_HOME/constraints.txt"
-
-# ------------------------------------------------------------------ pip deps
-# Most deps (kornia, scikit-image, opencv, imageio, ninja) are already in the
-# native env (or from p3dm_install.sh). face-alignment provides the FAN
-# detector used for cropping; yacs the config system.
-log "installing python dependencies (native env, constrained)"
-pip install -q $CONS face-alignment yacs ninja gdown
-
-# chumpy: only needed to unpickle FLAME. Needs patching for py>=3.11 / numpy>=2.
-if ! python3 -c "import chumpy" 2>/dev/null; then
-  log "installing + patching chumpy for py3.12/numpy2"
-  pip install -q --no-deps --no-build-isolation chumpy
-  CHDIR=$(python3 -c "import importlib.util,os; print(os.path.dirname(importlib.util.find_spec('chumpy').origin))")
-  grep -rl "inspect.getargspec" "$CHDIR"/*.py | xargs -r sed -i "s/inspect\.getargspec/inspect.getfullargspec/g"
-  sed -i "s/^from numpy import bool, int, float, complex, object, unicode, str, nan, inf$/from numpy import nan, inf/" "$CHDIR/__init__.py"
-  python3 -c "import chumpy" || { echo "chumpy patch failed"; exit 1; }
-fi
-
-# ------------------------------------------------------------------ DECA
-if [ ! -d "$REPO" ]; then
-  log "cloning DECA"
-  git clone --depth 1 https://github.com/yfeng95/DECA.git "$REPO"
-fi
-
-# ------------------------------------------- py3.12 / numpy2 / torch2.8 patches
-log "applying compat patches"
-# face-alignment >=1.4 renamed the enum
-sed -i 's/face_alignment\.LandmarksType\._2D/face_alignment.LandmarksType.TWO_D/' \
-  "$REPO/decalib/datasets/detectors.py"
-# numpy 2 removed the np.int alias
-sed -i 's/\.astype(np\.int)/.astype(np.int64)/g' "$REPO/decalib/utils/util.py"
-# torch 2.x removed Tensor::data<T>() and .type() in AT_DISPATCH; old flags
-# assumed cuda 10.2 + gcc-7
-sed -i 's/\.data<scalar_t>()/.data_ptr<scalar_t>()/g; s/\.data<int>()/.data_ptr<int>()/g; s/\.data<float>()/.data_ptr<float>()/g' \
-  "$REPO/decalib/utils/rasterizer/standard_rasterize_cuda_kernel.cu" \
-  "$REPO/decalib/utils/rasterizer/standard_rasterize_cuda.cpp"
-sed -i '/AT_DISPATCH/s/\.type()/.scalar_type()/' \
-  "$REPO/decalib/utils/rasterizer/standard_rasterize_cuda_kernel.cu"
-sed -i "s/extra_cuda_cflags = \['-std=c++14', '-ccbin=\\\$\\\$(which gcc-7)'\])/extra_cuda_cflags = ['-std=c++17'])/" \
-  "$REPO/decalib/utils/renderer.py"
-grep -q "std=c++17" "$REPO/decalib/utils/renderer.py" || { echo "renderer patch failed"; exit 1; }
-
-# ------------------------------------------------------------------ FLAME 2020
-if [ ! -f "$REPO/data/generic_model.pkl" ]; then
-  P3DM_FLAME="/workspace/p3dm/pixel3dmm/src/pixel3dmm/preprocessing/MICA/data/FLAME2020/generic_model.pkl"
-  if [ -f "$P3DM_FLAME" ]; then
-    log "reusing FLAME 2020 from p3dm install"
-    cp "$P3DM_FLAME" "$REPO/data/generic_model.pkl"
-  else
-    log "downloading FLAME 2020 (requires FLAME account)"
-    if [ -z "${FLAME_USERNAME:-}" ]; then read -rp "FLAME username: " FLAME_USERNAME; fi
-    if [ -z "${FLAME_PASSWORD:-}" ]; then read -rsp "FLAME password: " FLAME_PASSWORD; echo; fi
-    urle () { local LANG=C i x; for (( i = 0; i < ${#1}; i++ )); do x="${1:i:1}"; [[ "${x}" == [a-zA-Z0-9.~-] ]] && echo -n "${x}" || printf '%%%02X' "'${x}"; done; }
-    U=$(urle "$FLAME_USERNAME"); P=$(urle "$FLAME_PASSWORD")
-    wget -q --post-data "username=$U&password=$P" 'https://download.is.tue.mpg.de/download.php?domain=flame&sfile=FLAME2020.zip&resume=1' -O "$REPO/data/FLAME2020.zip" --no-check-certificate --continue
-    unzip -o -q "$REPO/data/FLAME2020.zip" -d "$REPO/data/FLAME2020_tmp"
-    mv "$REPO/data/FLAME2020_tmp/generic_model.pkl" "$REPO/data/generic_model.pkl"
-    rm -rf "$REPO/data/FLAME2020.zip" "$REPO/data/FLAME2020_tmp"
-  fi
-  [ -f "$REPO/data/generic_model.pkl" ] || { echo "FLAME download failed"; exit 1; }
-fi
-
-# ------------------------------------------------------------- model weights
-if [ ! -s "$REPO/data/deca_model.tar" ]; then
-  log "downloading deca_model.tar (~430 MB, official Google Drive)"
-  gdown 1rp8kdyLPvErw2dTmqtjISRVvQLj6Yzje -O "$REPO/data/deca_model.tar" -q
-fi
-[ -s "$REPO/data/deca_model.tar" ] || { echo "deca_model.tar download failed"; exit 1; }
-
-# ------------------------------------------------------------------ verify
-log "verifying imports + files"
-REPO_DIR="$REPO" python3 - <<'EOF'
-import os, sys, warnings
-warnings.filterwarnings("ignore")
-import chumpy, face_alignment, yacs, kornia
-repo = os.environ["REPO_DIR"]
-sys.path.insert(0, repo)
-from decalib.utils.config import cfg
-for f in ["data/deca_model.tar", "data/generic_model.pkl",
-          "data/head_template.obj", "data/landmark_embedding.npy",
-          "data/fixed_displacement_256.npy", "data/texture_data_256.npy"]:
-    p = os.path.join(repo, f)
-    assert os.path.getsize(p) > 0, p
-print("  all good")
-EOF
-
-log "install complete. run:  ./deca_run.sh <photo.jpg>"

deca/deca_run.sh

@@ -1,96 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# deca_run.sh — single photo in -> detailed 3D FLAME face mesh out (DECA)
-#
-# Usage:
-#   ./deca_run.sh <photo.(jpg|png)> [-o <output_dir>] [--force]
-#
-#   -o DIR     output directory  (default: /workspace/outputs/deca/<name>)
-#   --force    redo reconstruction even if cached results exist
-#
-# Outputs (in <output_dir>):
-#   <name>.obj              coarse FLAME mesh with UV texture (obj/mtl/png
-#                           triplet + normal map, opens textured in Blender)
-#   <name>_detail.obj       detailed mesh (expression wrinkles as displacement)
-#   <name>.mtl, <name>.png, <name>_normals.png   texture + uv normal map
-#   <name>_vis.jpg          input | landmarks 2d/3d | coarse | detail | depth
-#   <name>_vis_original_size.jpg   same, rendered at input resolution
-#   <name>_depth.jpg        rendered depth map
-#   raw/                    machine-readable results: <name>.mat (all FLAME
-#                           codes: shape/exp/pose/cam/light/detail + verts,
-#                           landmarks, uv maps), kpt2d/kpt3d txt, per-part
-#                           images (crop + original-size renders)
-#
-# Requires deca_install.sh to have been run first.
-# =============================================================================
-set -euo pipefail
-
-DECA_HOME="${DECA_HOME:-/workspace/deca}"
-REPO="$DECA_HOME/DECA"
-
-IMG="" ; OUT="" ; FORCE=0
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -o)      OUT="$2"; shift 2;;
-    --force) FORCE=1; shift;;
-    -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-    *)       IMG="$1"; shift;;
-  esac
-done
-[ -n "$IMG" ] && [ -f "$IMG" ] || { echo "usage: $0 <photo.jpg> [-o outdir] [--force]"; exit 1; }
-[ -f "$REPO/data/deca_model.tar" ] || { echo "DECA not installed - run deca_install.sh first"; exit 1; }
-
-# sanitized job name from the file stem (used as folder + file identifier)
-STEM="$(basename "$IMG")"; STEM="${STEM%.*}"
-NAME="$(echo "$STEM" | tr -c 'a-zA-Z0-9' '_' | sed 's/_*$//;s/^_*//' | cut -c1-60)"
-OUT="${OUT:-/workspace/outputs/deca/$NAME}"
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1   # repo predates torch>=2.6 weights_only default
-if [ -z "${TORCH_CUDA_ARCH_LIST:-}" ]; then
-  export TORCH_CUDA_ARCH_LIST="$(python3 -c "import torch; print('%d.%d+PTX' % torch.cuda.get_device_capability())")"
-fi
-
-log() { echo -e "\033[1;35m[deca]\033[0m $*"; }
-T0=$(date +%s)
-
-# stage the photo in a folder named after the job (demo processes a folder)
-STAGE="$DECA_HOME/staging/$NAME"
-RES="$DECA_HOME/results/$NAME"
-if [ "$FORCE" = 1 ]; then rm -rf "$STAGE" "$RES"; fi
-mkdir -p "$STAGE"
-cp -f "$IMG" "$STAGE/$NAME.${IMG##*.}"
-
-cd "$REPO"
-log "reconstructing (FAN crop -> DECA encode/decode -> standard rasterizer render)"
-if [ ! -f "$RES/$NAME/$NAME.obj" ]; then
-  python3 demos/demo_reconstruct.py -i "$STAGE" -s "$RES" \
-      --rasterizer_type standard --render_orig 1 \
-      --saveDepth 1 --saveKpt 1 --saveObj 1 --saveMat 1 --saveImages 1 --saveVis 1 \
-      > /dev/null 2>&1 \
-    || { echo "reconstruction failed, rerunning verbosely:"; \
-         python3 demos/demo_reconstruct.py -i "$STAGE" -s "$RES" \
-             --rasterizer_type standard --render_orig 1 \
-             --saveDepth 1 --saveKpt 1 --saveObj 1 --saveMat 1 --saveImages 1 --saveVis 1; exit 1; }
-fi
-[ -f "$RES/$NAME/$NAME.obj" ] || { echo "ERROR: no face detected / reconstruction failed for $IMG"; exit 1; }
-
-# --------------------------------------------------------------- final outputs
-mkdir -p "$OUT" "$OUT/raw"
-cp "$RES/$NAME/$NAME.obj"          "$OUT/$NAME.obj"
-cp "$RES/$NAME/${NAME}_detail.obj" "$OUT/${NAME}_detail.obj"
-cp "$RES/$NAME/$NAME.png"          "$OUT/$NAME.png"
-cp "$RES/$NAME/${NAME}_normals.png" "$OUT/${NAME}_normals.png"
-# the generated mtl embeds an absolute path for the displacement map -> relative
-sed "s|disp .*${NAME}_normals\.png|disp ${NAME}_normals.png|" "$RES/$NAME/$NAME.mtl" > "$OUT/$NAME.mtl"
-cp "$RES/${NAME}_vis.jpg" "$OUT/${NAME}_vis.jpg"
-[ -f "$RES/${NAME}_vis_original_size.jpg" ] && cp "$RES/${NAME}_vis_original_size.jpg" "$OUT/${NAME}_vis_original_size.jpg"
-cp "$RES/$NAME/${NAME}_depth.jpg" "$OUT/${NAME}_depth.jpg"
-
-# raw machine-readable results (FLAME codes, landmarks, per-part images)
-cp "$RES/$NAME/$NAME.mat"          "$OUT/raw/"
-cp "$RES/$NAME/${NAME}_kpt2d.txt"  "$OUT/raw/"
-cp "$RES/$NAME/${NAME}_kpt3d.txt"  "$OUT/raw/"
-cp "$RES/$NAME/"*.jpg              "$OUT/raw/" 2>/dev/null || true
-
-log "done in $(( $(date +%s) - T0 ))s -> $OUT"
-ls -la "$OUT"

facelift/README.md

@@ -1,115 +0,0 @@
-# facelift — FaceLift single photo → 3D Gaussian-splat head
-
-One photo in, a full 3D head as a Gaussian splat out, using
-[FaceLift](https://github.com/weijielyu/FaceLift) (Lyu et al., ICCV 2025,
-UC Merced / Adobe Research): an Era3D-style multi-view diffusion model
-generates 6 consistent head views (incl. the unseen back), then a GS-LRM
-transformer regresses a 3D Gaussian splat from them. Runs against the native
-python of the `plx1029/comfyui-qwen` RunPod image (python 3.12, torch
-2.8+cu128) — **torch is never reinstalled**.
-
-## Environment: venv with `--system-site-packages` (why not fully native)
-
-FaceLift's custom multi-view UNet subclasses diffusers-0.30-era internals
-(`LoRACompatibleConv`, `ImagePositionalEmbeddings`, private `load_state_dict`)
-and imports `CLIPFeatureExtractor`, which the image's transformers 5.x
-removed. Pinning those in the native env would downgrade
-transformers 5.12 → 4.44 and huggingface-hub 1.x → 0.x globally and risk
-breaking ComfyUI. So the installer creates
-`/workspace/facelift/venv` with `--system-site-packages`: torch, torchvision,
-numpy, pillow, scipy, einops etc. are reused from the image, and only the
-pinned diffusion stack (diffusers 0.30.3, transformers 4.44.2, tokenizers
-0.19, hub 0.36) plus small pure-python deps are layered venv-locally. The
-native env is untouched. A constraints file pinning the native versions
-guards every pip call from shadowing numpy/torch/….
-
-## Install (once per pod, ~5 min + ~10 GB downloads, no accounts needed)
-
-```bash
-./facelift_install.sh
-```
-
-Everything lands in `$FACELIFT_HOME` (default `/workspace/facelift`).
-Re-running is safe; completed steps are skipped. Weights come from the
-authors' public HF repo [wlyu/OpenFaceLift](https://huggingface.co/wlyu/OpenFaceLift)
-(~9.3 GB: 6-view unCLIP SD2.1 pipeline + GS-LRM checkpoint), plus VGG19
-matconvnet weights (~548 MB, loss init), u2net.onnx (~176 MB, rembg) and
-MTCNN weights — all cached persistently under
-`/workspace/facelift/weights_cache`.
-
-## Run (~2.5 min per photo on H100: ~35 s model load + diffusion + orbit export)
-
-```bash
-./facelift_run.sh photo.jpg                # -> /workspace/outputs/facelift/photo/
-./facelift_run.sh photo.jpg -o /some/root  # root dir; per-image subfolder inside
-./facelift_run.sh photo.jpg --seed 7 --steps 75 --guidance 3.0
-./facelift_run.sh photo.jpg --render_res 2048 --n_orbit_views 16
-./facelift_run.sh photo.jpg --no-crop      # input already a centered head shot
-```
-
-Inference + export pass live in `facelift_infer.py` (a companion script that
-wraps upstream `inference.py`'s model init and adds the export stage — the
-upstream repo stays unpatched). Output folders are **never overwritten**: an
-existing `<stem>/` gets `_v2`, `_v3`, … suffixes.
-
-Per-image output layout (`<root>/<stem>[_vN]/`):
-
-- `orbit/` — **primary output, for KeenTools FaceBuilder / mesh fitting**:
-  ~36 orbit renders of the splat (34 unique — the two frontal extras at ±45°
-  coincide with the 22.5° ring and are deduplicated): eye-level ring every
-  22.5° (16), +20° ring every 45° (8), −15° ring every 45° (8), frontal
-  extras at yaw ±15°/±45°. Rendered natively at 2048² (no upscaling) as
-  lossless sRGB-tagged RGBA PNG with clean alpha (black/white two-pass
-  composite difference, un-premultiplied). `orbit/gray/` holds the same
-  frames flattened on neutral 18 % gray (FaceBuilder dislikes hard
-  white/black edges). Filenames `orbit_e{+EL}_y{YAW:03d}.png`, sortable.
-- `opencv_cameras.json` — intrinsics + extrinsics (OpenCV `w2c`, same schema
-  as `data_sample/gslrm/*/opencv_cameras.json`) for every orbit view, so the
-  renders are directly usable for 2DGS/GOF/COLMAP-style reconstruction.
-- `mvdiff/cam_000..005.png` — the 6 diffusion-generated views
-- `gaussians.ply` — filtered splat, standard 3DGS PLY (SuperSplat/Blender)
-- `input_processed.png` — the cropped/aligned image the model consumed
-- `turntable.mp4` — eye-level 360°, 60 frames @ 30 fps, QC eyeballing only
-- `run_meta.json` — seed, guidance, steps, render args, FaceLift git commit,
-  torch/diffusers/transformers versions, elapsed time (determinism record)
-
-Pipeline: rembg background removal + MTCNN face crop → 6-view unCLIP
-diffusion (512², 75 steps default) → GS-LRM splat regression (fp16 autocast)
-→ opacity/scale/floater filtering → orbit export + turntable via the repo's
-own diff-gaussian-rasterization renderer (`render_opencv_cam`) — no extra
-renderer dependency. Orbit cameras reuse the repo's rig convention
-(radius 2.7, hfov 50°, azimuth 270 = frontal).
-
-## What the installer does differently vs. upstream `setup_env.sh`
-
-Upstream force-reinstalls torch 2.4/cu124 into the env. Instead:
-
-- venv `--system-site-packages`; torch/torchvision/numpy/… reused (see above)
-- `accelerate>=1.2` instead of upstream's `accelerate==0.33.0`, which pins
-  numpy<2 (image has numpy 2.1); 1.x is API-compatible here
-- `xformers==0.0.32.post2` installed `--no-deps` — the prebuilt wheel matching
-  torch 2.8.0+cu128 (upstream's 0.0.27 targets torch 2.4). Both the MV-UNet's
-  custom XFormers attention processors and GS-LRM's flash attention use it
-- `facenet-pytorch` installed `--no-deps` (it pins its own torch)
-- **diff-gaussian-rasterization** built from source with `#include <cstdint>`
-  prepended to `cuda_rasterizer/rasterizer_impl.h` (upstream fails to compile
-  with gcc-13), `--no-build-isolation` so it compiles against the native torch
-- `opencv-python-headless` (no GUI libs) instead of `opencv-python`
-- `scikit-image` latest instead of upstream's 0.21 pin (py3.8-era, won't
-  build on 3.12); `lpips`, `pytorch-msssim`, `easydict`, `plyfile`,
-  `videoio`, `matplotlib`, `jaxtyping`, `rembg`+`onnxruntime` as upstream
-- no wandb/gradio/ffmpeg-python (training/webui-only; ffmpeg binary is native)
-
-Runtime (in `facelift_run.sh`): `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` (repo
-predates the torch 2.6 `weights_only` default), `VGG19_WEIGHTS_PATH` /
-`U2NET_HOME` / `TORCH_HOME` pointed at the persistent `weights_cache/`.
-No source patches to FaceLift itself. The run script calls `inference.main()`
-programmatically because the CLI's `--auto_crop` flag is `store_true` with
-`default=True` and can never be disabled from the command line.
-
-## Licenses
-
-Code is Apache-2.0 (Adobe Inc.). The model weights are under the
-**Adobe Research License v1.2 (research / non-commercial use only)** and are
-downloaded from the authors' official HF repo at install time, not
-redistributed here.

facelift/facelift_infer.py

@@ -1,312 +0,0 @@
-#!/usr/bin/env python3
-"""
-facelift_infer.py — FaceLift single-image inference + export pass.
-
-Wraps the upstream FaceLift inference.py (model init + preprocessing +
-6-view diffusion + GS-LRM) and adds an automatic export pass per image:
-
-  outputs/{image_stem}[_vN]/
-    orbit/                orbit renders of the splat, RGBA PNG + 18%-gray
-    orbit/gray/           flattened copies (same filenames)
-    mvdiff/               the 6 diffusion-generated views (cam_000..005.png)
-    gaussians.ply         filtered 3D Gaussian splat (standard 3DGS layout)
-    opencv_cameras.json   intrinsics + extrinsics of every orbit view
-    input_processed.png   the cropped/aligned image the model consumed
-    turntable.mp4         eye-level 360°, 60 frames @ 30 fps (QC only)
-    run_meta.json         seed / guidance / steps / git commit / versions
-
-Orbit rig (~36 views, deduplicated): eye-level ring every 22.5° (16 views),
-+20° ring every 45° (8), -15° ring every 45° (8), plus frontal extras at
-yaw ±15°/±45° eye-level. Yaw 0 = frontal; azimuth convention matches the
-repo's own turntable (azimuth 270 = front). Renders use the repo's
-gslrm renderer (render_opencv_cam) — no extra renderer dependency; alpha
-comes from a black/white two-pass composite difference.
-
-Never overwrites: an existing output folder gets _v2, _v3, ... suffixes.
-"""
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-import time
-import warnings
-
-FACELIFT_HOME = os.environ.get("FACELIFT_HOME", "/workspace/facelift")
-REPO = os.environ.get("FACELIFT_REPO", os.path.join(FACELIFT_HOME, "FaceLift"))
-sys.path.insert(0, REPO)
-
-import numpy as np
-import torch
-from PIL import Image
-from easydict import EasyDict as edict
-from einops import rearrange
-
-from inference import (  # upstream FaceLift
-    DEFAULT_IMG_SIZE,
-    initialize_face_detector,
-    initialize_gslrm_model,
-    initialize_mvdiffusion_pipeline,
-    get_model_paths,
-    setup_camera_parameters,
-)
-from gslrm.model.gaussians_renderer import (
-    imageseq2video,
-    render_opencv_cam,
-    render_turntable,
-)
-from utils_folder.face_utils import preprocess_image, preprocess_image_without_cropping
-
-warnings.filterwarnings("ignore")
-
-ORBIT_RADIUS = 2.7   # matches the repo's input cameras + turntable
-ORBIT_HFOV = 50.0    # deg, matches fx=548.99@512
-FRONT_AZIMUTH = 270.0  # repo convention: azimuth 270 = frontal view
-GRAY_18 = 118.0 / 255.0  # neutral 18% gray in sRGB
-
-try:  # sRGB ICC tag for every PNG (lossless; FaceBuilder-friendly)
-    from PIL import ImageCms
-    _SRGB = ImageCms.ImageCmsProfile(ImageCms.createProfile("sRGB")).tobytes()
-except Exception:
-    _SRGB = None
-
-
-def save_png(array_uint8: np.ndarray, path: str) -> None:
-    img = Image.fromarray(array_uint8)
-    if _SRGB:
-        img.save(path, format="PNG", icc_profile=_SRGB)
-    else:
-        img.save(path, format="PNG")
-
-
-def build_orbit_views(n_eye: int) -> list:
-    """(elevation, yaw) pairs; yaw 0 = front. Duplicates (by rounded degree) removed."""
-    views = []
-    for yaw in np.linspace(0, 360, n_eye, endpoint=False):
-        views.append((0.0, float(yaw)))
-    for elev in (20.0, -15.0):
-        for yaw in np.linspace(0, 360, max(n_eye // 2, 1), endpoint=False):
-            views.append((elev, float(yaw)))
-    for yaw in (15.0, -15.0, 45.0, -45.0):  # frontal-hemisphere extras
-        views.append((0.0, float(yaw) % 360.0))
-    seen, out = set(), []
-    for elev, yaw in views:
-        key = (int(round(elev)), int(round(yaw)) % 360)
-        if key not in seen:
-            seen.add(key)
-            out.append((elev, yaw))
-    return out
-
-
-def orbit_camera(elev_deg: float, yaw_deg: float, res: int):
-    """OpenCV-convention c2w + pinhole intrinsics for one orbit view.
-
-    Same math as the repo's get_turntable_cameras, plus elevation."""
-    fx = res / (2.0 * np.tan(np.deg2rad(ORBIT_HFOV) / 2.0))
-    fxfycxcy = np.array([fx, fx, res / 2.0, res / 2.0], dtype=np.float64)
-    azim = np.deg2rad(FRONT_AZIMUTH + yaw_deg)
-    elev = np.deg2rad(elev_deg)
-    cam_pos = np.array([
-        ORBIT_RADIUS * np.cos(elev) * np.cos(azim),
-        ORBIT_RADIUS * np.cos(elev) * np.sin(azim),
-        ORBIT_RADIUS * np.sin(elev),
-    ])
-    forward = -cam_pos / np.linalg.norm(cam_pos)
-    up_vector = np.array([0.0, 0.0, 1.0])
-    right = np.cross(forward, up_vector)
-    right = right / np.linalg.norm(right)
-    up = np.cross(right, forward)
-    up = up / np.linalg.norm(up)
-    c2w = np.eye(4)
-    c2w[:3, :3] = np.stack((right, -up, forward), axis=1)
-    c2w[:3, 3] = cam_pos
-    return c2w, fxfycxcy
-
-
-def render_rgba(pc, res: int, c2w: torch.Tensor, fxfycxcy: torch.Tensor):
-    """Two-pass render -> (rgb premultiplied, alpha), both [*, H, W] float in [0,1].
-
-    black-bg pass gives premultiplied color C0; white-bg pass C1 = C0 + (1-A),
-    so A = 1 - (C1 - C0)."""
-    with torch.no_grad():
-        c0 = render_opencv_cam(pc, res, res, c2w, fxfycxcy, bg_color=(0.0, 0.0, 0.0))["render"]
-        c1 = render_opencv_cam(pc, res, res, c2w, fxfycxcy, bg_color=(1.0, 1.0, 1.0))["render"]
-    alpha = (1.0 - (c1 - c0).clamp(0.0, 1.0).mean(dim=0, keepdim=True)).clamp(0.0, 1.0)
-    return c0.clamp(0.0, 1.0), alpha
-
-
-def export_orbit_pass(pc, out_dir: str, render_res: int, n_orbit_views: int) -> list:
-    """Render the orbit rig, save RGBA + gray PNGs, return camera frames."""
-    orbit_dir = os.path.join(out_dir, "orbit")
-    os.makedirs(os.path.join(orbit_dir, "gray"), exist_ok=True)
-    device = pc._xyz.device
-    frames = []
-    for elev, yaw in build_orbit_views(n_orbit_views):
-        c2w_np, fxfycxcy_np = orbit_camera(elev, yaw, render_res)
-        c2w = torch.from_numpy(c2w_np).float().to(device)
-        fxfycxcy = torch.from_numpy(fxfycxcy_np).float().to(device)
-        premult, alpha = render_rgba(pc, render_res, c2w, fxfycxcy)
-
-        # un-premultiply for a clean-alpha RGBA (straight color under the matte)
-        straight = torch.where(alpha > 1e-4, premult / alpha.clamp(min=1e-4),
-                               torch.zeros_like(premult)).clamp(0.0, 1.0)
-        rgba = torch.cat([straight, alpha], dim=0)
-        rgba = (rearrange(rgba, "c h w -> h w c").cpu().numpy() * 255.0).round().astype(np.uint8)
-        gray = premult + (1.0 - alpha) * GRAY_18
-        gray = (rearrange(gray.clamp(0, 1), "c h w -> h w c").cpu().numpy() * 255.0).round().astype(np.uint8)
-
-        name = f"orbit_e{int(round(elev)):+03d}_y{int(round(yaw)) % 360:03d}.png"
-        save_png(rgba, os.path.join(orbit_dir, name))
-        save_png(gray, os.path.join(orbit_dir, "gray", name))
-
-        w2c = np.linalg.inv(c2w_np)
-        frames.append({
-            "w": render_res, "h": render_res,
-            "fx": float(fxfycxcy_np[0]), "fy": float(fxfycxcy_np[1]),
-            "cx": float(fxfycxcy_np[2]), "cy": float(fxfycxcy_np[3]),
-            "w2c": w2c.tolist(),
-            "file_path": f"orbit/{name}",
-        })
-    torch.cuda.empty_cache()
-    return frames
-
-
-def versioned_dir(root: str, stem: str) -> str:
-    """outputs/{stem}, else _v2, _v3, ... — never overwrite."""
-    out = os.path.join(root, stem)
-    version = 2
-    while os.path.exists(out):
-        out = os.path.join(root, f"{stem}_v{version}")
-        version += 1
-    return out
-
-
-def git_commit(path: str) -> str:
-    try:
-        return subprocess.check_output(
-            ["git", "-C", path, "rev-parse", "HEAD"], text=True).strip()
-    except Exception:
-        return "unknown"
-
-
-def main():
-    parser = argparse.ArgumentParser(description="FaceLift inference + export pass")
-    parser.add_argument("--input", "-i", required=True, help="input photo (jpg/png)")
-    parser.add_argument("--output_root", "-o", default="/workspace/outputs/facelift",
-                        help="parent output dir; per-image subfolder is created inside")
-    parser.add_argument("--seed", type=int, default=4)
-    parser.add_argument("--guidance_scale_2D", type=float, default=3.0)
-    parser.add_argument("--step_2D", type=int, default=75)
-    parser.add_argument("--render_res", type=int, default=2048,
-                        help="orbit render resolution (splats are resolution-independent)")
-    parser.add_argument("--n_orbit_views", type=int, default=16,
-                        help="views in the eye-level ring; +20/-15 rings get half each")
-    parser.add_argument("--no_crop", action="store_true", help="skip MTCNN auto-crop")
-    args = parser.parse_args()
-
-    t0 = time.time()
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    stem = os.path.splitext(os.path.basename(args.input))[0]
-    out_dir = versioned_dir(args.output_root, stem)
-    os.makedirs(os.path.join(out_dir, "mvdiff"), exist_ok=True)
-
-    # ------------------------------------------------------------- models
-    mvdiff_ckpt, gslrm_ckpt, gslrm_cfg = get_model_paths()
-    pipeline, generator, prompt_embeds = initialize_mvdiffusion_pipeline(mvdiff_ckpt, device)
-    gslrm_model = initialize_gslrm_model(gslrm_ckpt, gslrm_cfg, device)
-    fxfycxcy_in, c2w_in = setup_camera_parameters(device)
-    torch.manual_seed(args.seed)
-    generator.manual_seed(args.seed)
-
-    # ------------------------------------------------------- preprocess
-    image_np = np.array(Image.open(args.input))
-    if args.no_crop:
-        input_image = preprocess_image_without_cropping(image_np)
-    else:
-        try:
-            input_image = preprocess_image(image_np)
-        except Exception as exc:
-            print(f"auto-crop failed ({exc}); falling back to no-crop preprocessing")
-            input_image = preprocess_image_without_cropping(image_np)
-    input_image.save(os.path.join(out_dir, "input_processed.png"),
-                     format="PNG", **({"icc_profile": _SRGB} if _SRGB else {}))
-
-    # ------------------------------------------------- 6-view diffusion
-    mv_imgs = pipeline(
-        input_image, None,
-        prompt_embeds=prompt_embeds,
-        guidance_scale=args.guidance_scale_2D,
-        num_images_per_prompt=1,
-        num_inference_steps=args.step_2D,
-        generator=generator,
-        eta=1.0,
-    ).images
-    if len(mv_imgs) == 7:
-        views = [mv_imgs[i] for i in (1, 2, 3, 4, 5, 6)]
-    elif len(mv_imgs) == 6:
-        views = list(mv_imgs)
-    else:
-        raise ValueError(f"Unexpected number of views: {len(mv_imgs)}")
-    for i, view in enumerate(views):
-        view.save(os.path.join(out_dir, "mvdiff", f"cam_{i:03d}.png"),
-                  format="PNG", **({"icc_profile": _SRGB} if _SRGB else {}))
-
-    # ------------------------------------------------------------ GS-LRM
-    lrm_input = np.stack([np.array(v) for v in views], axis=0)
-    lrm_input = torch.from_numpy(lrm_input).float()[None].to(device) / 255.0
-    lrm_input = rearrange(lrm_input, "b v h w c -> b v c h w")
-    index = torch.stack([
-        torch.zeros(lrm_input.size(1)).long(),
-        torch.arange(lrm_input.size(1)).long(),
-    ], dim=-1)[None].to(device)
-    batch = edict({"image": lrm_input, "c2w": c2w_in, "fxfycxcy": fxfycxcy_in, "index": index})
-    with torch.autocast(enabled=True, device_type="cuda", dtype=torch.float16):
-        result = gslrm_model.forward(batch, create_visual=False, split_data=True)
-
-    # same filtering as upstream inference.py, then splat + all renders share it
-    pc = result.gaussians[0].apply_all_filters(
-        opacity_thres=0.04,
-        scaling_thres=0.1,
-        floater_thres=0.6,
-        crop_bbx=[-0.91, 0.91, -0.91, 0.91, -1.0, 1.0],
-        cam_origins=None,
-        nearfar_percent=(0.0001, 1.0),
-    )
-    pc.save_ply(os.path.join(out_dir, "gaussians.ply"))
-
-    # ------------------------------------------------------- export pass
-    print(f"orbit export: {args.render_res}x{args.render_res} RGBA")
-    frames = export_orbit_pass(pc, out_dir, args.render_res, args.n_orbit_views)
-    with open(os.path.join(out_dir, "opencv_cameras.json"), "w") as f:
-        json.dump({"id": os.path.basename(out_dir), "frames": frames}, f, indent=2)
-
-    # eye-level 360° turntable, QC only
-    strip = render_turntable(pc, rendering_resolution=DEFAULT_IMG_SIZE, num_views=60)
-    video = np.ascontiguousarray(rearrange(strip, "h (v w) c -> v h w c", v=60))
-    imageseq2video(video, os.path.join(out_dir, "turntable.mp4"), fps=30)
-
-    with open(os.path.join(out_dir, "run_meta.json"), "w") as f:
-        json.dump({
-            "input": os.path.abspath(args.input),
-            "seed": args.seed,
-            "guidance_scale_2D": args.guidance_scale_2D,
-            "step_2D": args.step_2D,
-            "render_res": args.render_res,
-            "n_orbit_views": args.n_orbit_views,
-            "num_orbit_renders": len(frames),
-            "auto_crop": not args.no_crop,
-            "facelift_git_commit": git_commit(REPO),
-            "versions": {
-                "torch": torch.__version__,
-                "diffusers": __import__("diffusers").__version__,
-                "transformers": __import__("transformers").__version__,
-            },
-            "elapsed_seconds": round(time.time() - t0, 1),
-        }, f, indent=2)
-
-    print(f"done in {time.time() - t0:.0f}s -> {out_dir}")
-
-
-if __name__ == "__main__":
-    main()

facelift/facelift_install.sh

@@ -1,190 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# facelift_install.sh — one-shot installer for FaceLift (single photo ->
-#                       3D Gaussian-splat head + turntable video)
-#
-# Installs https://github.com/weijielyu/FaceLift (ICCV 2025, UC Merced/Adobe).
-# Pipeline: multi-view diffusion (Era3D-style unCLIP SD2.1) generates 6 head
-# views -> GS-LRM transformer regresses a 3D Gaussian splat of the full head.
-#
-# Env strategy: a venv with --system-site-packages. The native image packages
-# (torch 2.8.0+cu128, torchvision, numpy 2.1, pillow, scipy, einops, ...) are
-# REUSED — torch is never reinstalled. Only the version-pinned diffusion stack
-# (diffusers 0.30.3, transformers 4.44.2, hub 0.x) is layered inside the venv,
-# because FaceLift's custom UNet/pipeline hooks diffusers-0.30-era internals
-# and the image's transformers 5.x removed CLIPFeatureExtractor. The native
-# env is left 100% untouched (ComfyUI safe).
-#
-# Tested on: Ubuntu 24.04, python 3.12, torch 2.8.0+cu128, H100
-# (RunPod image plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (never reinstalled)
-#   - nvcc in PATH (compiles diff-gaussian-rasterization once)
-#   - ~11 GB disk for weights (public downloads, no account needed)
-#
-# Usage:
-#   ./facelift_install.sh
-#
-# Layout (override with FACELIFT_HOME):
-#   $FACELIFT_HOME/FaceLift        code + checkpoints (~9.3 GB, wlyu/OpenFaceLift)
-#   $FACELIFT_HOME/venv            --system-site-packages venv
-#   $FACELIFT_HOME/weights_cache   VGG19 .mat, u2net.onnx, MTCNN weights
-#   $FACELIFT_HOME/staging|results per-image staging / raw outputs
-# =============================================================================
-set -euo pipefail
-
-FACELIFT_HOME="${FACELIFT_HOME:-/workspace/facelift}"
-REPO="$FACELIFT_HOME/FaceLift"
-VENV="$FACELIFT_HOME/venv"
-VPY="$VENV/bin/python"
-VPIP="$VENV/bin/pip"
-
-log() { echo -e "\n\033[1;36m[facelift-install]\033[0m $*"; }
-
-mkdir -p "$FACELIFT_HOME" "$FACELIFT_HOME/staging" "$FACELIFT_HOME/results" \
-         "$FACELIFT_HOME/weights_cache/u2net" "$FACELIFT_HOME/weights_cache/torch"
-cd "$FACELIFT_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch/nvcc"
-python3 - <<'EOF'
-import torch
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-command -v nvcc >/dev/null || { echo "ERROR: nvcc not found (needed to compile diff-gaussian-rasterization)"; exit 1; }
-
-# ------------------------------------------------------------------ repo
-if [ ! -d "$REPO" ]; then
-  log "cloning FaceLift"
-  git clone --depth 1 https://github.com/weijielyu/FaceLift "$REPO"
-fi
-
-# ------------------------------------------------------------------ venv
-# --system-site-packages: torch/torchvision/numpy/pillow/scipy/einops etc. come
-# from the native image; venv-local installs shadow only what must differ.
-if [ ! -x "$VPY" ]; then
-  log "creating venv (system-site-packages, reuses native torch 2.8)"
-  python3 -m venv --system-site-packages "$VENV"
-fi
-
-# ---------------------------------------------------- constraints (protect env)
-# Pin the native versions of shared packages so pip can never pull a different
-# (venv-local) numpy/torch/... that would shadow the native ones.
-log "generating pip constraints from native env"
-python3 - > "$FACELIFT_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","einops","kornia",
-          "safetensors","regex","requests","rich","tqdm","psutil","pyyaml",
-          "typing-extensions","packaging","sympy","networkx","jinja2",
-          "filelock","fsspec","charset-normalizer","idna","urllib3","certifi"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $FACELIFT_HOME/constraints.txt"
-
-# ------------------------------------------------------------------ pip deps
-# Pinned diffusion stack: FaceLift's custom MV-UNet imports diffusers-0.30
-# internals (LoRACompatibleConv, ImagePositionalEmbeddings, private
-# load_state_dict) and transformers-4.x CLIPFeatureExtractor — both gone in
-# the image's diffusers-latest/transformers-5. transformers 4.44.2 pulls a
-# matching tokenizers 0.19 + huggingface-hub 0.x into the venv. accelerate
-# is NOT the upstream 0.33 pin (that needs numpy<2): any >=1.2 works.
-log "installing pinned diffusion stack into venv"
-"$VPIP" install -q $CONS "diffusers==0.30.3" "transformers==4.44.2" "accelerate>=1.2"
-
-log "installing remaining python deps (native versions reused where possible)"
-"$VPIP" install -q $CONS "opencv-python-headless==4.10.0.84" "lpips==0.1.4" \
-    pytorch-msssim easydict plyfile matplotlib scikit-image jaxtyping ninja \
-    "videoio==0.3.0"
-"$VPIP" install -q $CONS rembg onnxruntime
-# facenet-pytorch pins its own torch -> --no-deps (runtime deps already present)
-"$VPIP" install -q --no-deps facenet-pytorch
-# xformers: prebuilt wheel matching torch 2.8.0+cu128; --no-deps so pip cannot
-# touch torch. If the native torch changes minor version, bump this pin.
-"$VPY" -c "import xformers" 2>/dev/null || "$VPIP" install -q --no-deps "xformers==0.0.32.post2"
-
-# ---------------------------------------- diff-gaussian-rasterization (CUDA)
-# Upstream source misses <cstdint> includes -> fails with gcc-13; patch + build.
-if ! "$VPY" -c "import diff_gaussian_rasterization" 2>/dev/null; then
-  log "building diff-gaussian-rasterization (one-time CUDA compile)"
-  if [ ! -d "$FACELIFT_HOME/diff-gaussian-rasterization" ]; then
-    git clone --recursive --depth 1 https://github.com/graphdeco-inria/diff-gaussian-rasterization \
-      "$FACELIFT_HOME/diff-gaussian-rasterization"
-  fi
-  DGR="$FACELIFT_HOME/diff-gaussian-rasterization"
-  grep -q "#include <cstdint>" "$DGR/cuda_rasterizer/rasterizer_impl.h" \
-    || sed -i '1i #include <cstdint>' "$DGR/cuda_rasterizer/rasterizer_impl.h"
-  ARCH="$(python3 -c "import torch; print('%d.%d+PTX' % torch.cuda.get_device_capability())")"
-  TORCH_CUDA_ARCH_LIST="${TORCH_CUDA_ARCH_LIST:-$ARCH}" \
-    "$VPIP" install -q --no-build-isolation "$DGR"
-fi
-
-# ------------------------------------------------------------- model weights
-# ~9.3 GB from the authors' public HF repo (Adobe Research License).
-if [ ! -s "$REPO/checkpoints/gslrm/ckpt_0000000000021125.pt" ] \
-   || [ ! -d "$REPO/checkpoints/mvdiffusion/pipeckpts" ]; then
-  log "downloading FaceLift checkpoints (~9.3 GB, wlyu/OpenFaceLift)"
-  "$VPY" - <<EOF
-from huggingface_hub import snapshot_download
-snapshot_download(repo_id="wlyu/OpenFaceLift",
-                  local_dir="$REPO/checkpoints",
-                  local_dir_use_symlinks=False)
-EOF
-fi
-
-# VGG19 matconvnet weights (~548 MB): GSLRM's perceptual loss downloads these
-# at model init even for inference; cache them persistently in /workspace.
-VGG="$FACELIFT_HOME/weights_cache/imagenet-vgg-verydeep-19.mat"
-if [ ! -s "$VGG" ]; then
-  log "downloading VGG19 weights (~548 MB)"
-  wget -q "https://www.vlfeat.org/matconvnet/models/imagenet-vgg-verydeep-19.mat" -O "$VGG"
-fi
-
-# u2net.onnx (~176 MB, rembg background removal) + MTCNN face-detector weights:
-# prefetch into the persistent cache so runs work without re-downloading.
-if [ ! -s "$FACELIFT_HOME/weights_cache/u2net/u2net.onnx" ]; then
-  log "prefetching u2net.onnx (rembg)"
-  U2NET_HOME="$FACELIFT_HOME/weights_cache/u2net" "$VPY" -c "from rembg import new_session; new_session('u2net')"
-fi
-TORCH_HOME="$FACELIFT_HOME/weights_cache/torch" "$VPY" -c "
-import warnings; warnings.filterwarnings('ignore')
-from facenet_pytorch import MTCNN; MTCNN()" >/dev/null 2>&1 || true
-
-# ------------------------------------------------- companion inference script
-# facelift_infer.py (inference + orbit-render export pass) ships alongside
-# these scripts; copy it in from the download location or fetch from the repo.
-if [ ! -s "$FACELIFT_HOME/facelift_infer.py" ]; then
-  SRC_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-  if [ -s "$SRC_DIR/facelift_infer.py" ]; then
-    cp "$SRC_DIR/facelift_infer.py" "$FACELIFT_HOME/"
-  else
-    log "fetching facelift_infer.py from HF"
-    wget -q "https://huggingface.co/aleph65/ComfyUI/resolve/main/facelift/facelift_infer.py" \
-      -O "$FACELIFT_HOME/facelift_infer.py"
-  fi
-fi
-
-# ------------------------------------------------------------------ verify
-log "verifying imports + files"
-cd "$REPO"
-TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1 TORCH_HOME="$FACELIFT_HOME/weights_cache/torch" "$VPY" - <<'EOF'
-import os, warnings
-warnings.filterwarnings("ignore")
-import diffusers, transformers, xformers, diff_gaussian_rasterization, cv2, rembg
-from mvdiffusion.pipelines.pipeline_mvdiffusion_unclip import StableUnCLIPImg2ImgPipeline
-from gslrm.model.gaussians_renderer import render_turntable, imageseq2video
-from utils_folder.face_utils import preprocess_image
-from facenet_pytorch import MTCNN
-for f in ["checkpoints/gslrm/ckpt_0000000000021125.pt",
-          "checkpoints/mvdiffusion/pipeckpts/unet/diffusion_pytorch_model.safetensors",
-          "mvdiffusion/data/fixed_prompt_embeds_6view/clr_embeds.pt"]:
-    assert os.path.getsize(f) > 0, f
-print(f"  diffusers {diffusers.__version__} transformers {transformers.__version__} xformers {xformers.__version__}")
-print("  all good")
-EOF
-
-log "install complete. run:  ./facelift_run.sh <photo.jpg>"

facelift/facelift_run.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# facelift_run.sh — single photo in -> 3D Gaussian-splat head + export pass
-#
-# Usage:
-#   ./facelift_run.sh <photo.(jpg|png)> [-o <output_root>] [options]
-#
-#   -o DIR            output ROOT (default: /workspace/outputs/facelift);
-#                     results land in <root>/<image-stem>/ — never overwritten,
-#                     an existing folder gets a _v2, _v3, ... suffix
-#   --seed N          diffusion seed                  (default: 4)
-#   --steps N         diffusion steps                 (default: 75)
-#   --guidance F      classifier-free guidance scale  (default: 3.0)
-#   --render_res N    orbit render resolution         (default: 2048)
-#   --n_orbit_views N eye-level ring view count       (default: 16)
-#   --no-crop         skip MTCNN auto-crop (input already a centered head shot)
-#
-# Outputs (in <root>/<stem>[_vN]/):
-#   orbit/            ~36 orbit renders of the splat for mesh fitting
-#                     (KeenTools FaceBuilder etc.): eye-level ring every 22.5°,
-#                     +20° and -15° rings every 45°, frontal extras at ±15°/±45°.
-#                     2048² RGBA PNG, clean alpha, sRGB tagged;
-#                     orbit/gray/ = same frames flattened on neutral 18% gray
-#   opencv_cameras.json  intrinsics + extrinsics (OpenCV w2c) of every orbit
-#                     view — directly usable for 2DGS/GOF/COLMAP-style recon
-#   mvdiff/           the 6 diffusion-generated views (cam_000..005.png)
-#   gaussians.ply     filtered 3D Gaussian splat (standard 3DGS PLY)
-#   input_processed.png  the cropped/aligned image the model consumed
-#   turntable.mp4     eye-level 360°, 60 frames @ 30 fps (QC eyeballing)
-#   run_meta.json     seed/guidance/steps/render args/git commit/versions
-#
-# Requires facelift_install.sh to have been run first.
-# ~2.5 min per photo on H100 (~35 s model load + diffusion + orbit export).
-# =============================================================================
-set -euo pipefail
-
-FACELIFT_HOME="${FACELIFT_HOME:-/workspace/facelift}"
-REPO="$FACELIFT_HOME/FaceLift"
-VPY="$FACELIFT_HOME/venv/bin/python"
-INFER="$FACELIFT_HOME/facelift_infer.py"
-
-IMG="" ; OUT="/workspace/outputs/facelift" ; SEED=4 ; STEPS=75 ; GUIDANCE=3.0
-RENDER_RES=2048 ; N_ORBIT=16 ; CROP_FLAG=""
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -o)              OUT="$2"; shift 2;;
-    --seed)          SEED="$2"; shift 2;;
-    --steps)         STEPS="$2"; shift 2;;
-    --guidance)      GUIDANCE="$2"; shift 2;;
-    --render_res)    RENDER_RES="$2"; shift 2;;
-    --n_orbit_views) N_ORBIT="$2"; shift 2;;
-    --no-crop)       CROP_FLAG="--no_crop"; shift;;
-    -h|--help)       grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-    *)               IMG="$1"; shift;;
-  esac
-done
-[ -n "$IMG" ] && [ -f "$IMG" ] || { echo "usage: $0 <photo.jpg> [-o outroot] [--seed N] [--steps N] [--guidance F] [--render_res N] [--n_orbit_views N] [--no-crop]"; exit 1; }
-[ -x "$VPY" ] && [ -s "$REPO/checkpoints/gslrm/ckpt_0000000000021125.pt" ] \
-  || { echo "FaceLift not installed - run facelift_install.sh first"; exit 1; }
-[ -s "$INFER" ] || { echo "missing $INFER - download it alongside these scripts"; exit 1; }
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1   # repo predates torch>=2.6 weights_only default
-export VGG19_WEIGHTS_PATH="$FACELIFT_HOME/weights_cache/imagenet-vgg-verydeep-19.mat"
-export U2NET_HOME="$FACELIFT_HOME/weights_cache/u2net"
-export TORCH_HOME="$FACELIFT_HOME/weights_cache/torch"
-export FACELIFT_HOME
-
-log() { echo -e "\033[1;35m[facelift]\033[0m $*"; }
-T0=$(date +%s)
-
-mkdir -p "$OUT"
-log "reconstructing (rembg+MTCNN -> 6-view diffusion -> GS-LRM splat -> orbit export)"
-cd "$REPO"
-"$VPY" "$INFER" -i "$IMG" -o "$OUT" --seed "$SEED" --step_2D "$STEPS" \
-    --guidance_scale_2D "$GUIDANCE" --render_res "$RENDER_RES" \
-    --n_orbit_views "$N_ORBIT" $CROP_FLAG
-
-# newest matching output folder (the infer script versions _v2, _v3, ...)
-STEM="$(basename "$IMG")"; STEM="${STEM%.*}"
-FINAL="$(ls -dt "$OUT/$STEM" "$OUT/$STEM"_v* 2>/dev/null | head -1)"
-[ -n "$FINAL" ] && [ -f "$FINAL/gaussians.ply" ] \
-  || { echo "ERROR: reconstruction failed for $IMG (no face detected?)"; exit 1; }
-
-log "done in $(( $(date +%s) - T0 ))s -> $FINAL"
-ls -la "$FINAL"; echo "orbit renders: $(ls "$FINAL/orbit" | grep -c '^orbit_')"

ffhq-uv/README.md

@@ -1,77 +0,0 @@
-# ffhq-uv — FFHQ-UV single-photo → 3D face mesh + UV texture
-
-One photo in, fitted 3D face mesh (HiFi3D++ topology) plus a 1024×1024 facial
-UV-texture map out, using [FFHQ-UV](https://github.com/csbhr/FFHQ-UV)
-(Bai et al., CVPR 2023) RGB fitting. Runs on the native python of the
-`plx1029/comfyui-qwen` RunPod image (python 3.12, torch 2.8+cu128) —
-**no venv, no conda, torch is not reinstalled**.
-
-## Install (once per pod, ~3 min + ~2.5 GB downloads)
-
-```bash
-./ffhq_uv_install.sh
-```
-
-Everything lands in `$FFHQUV_HOME` (default `/workspace/ffhq-uv`). Re-running
-is safe; completed steps are skipped. Checkpoints and topology assets are
-fetched from the **official Hugging Face mirror** (`csbhr/FFHQ-UV`) — no
-Baidu/OneDrive account needed, and no registration (unlike FLAME/p3dm).
-
-## Run (~2 min per photo on H100)
-
-```bash
-./ffhq_uv_run.sh photo.jpg                 # -> /workspace/outputs/ffhq-uv/photo/
-./ffhq_uv_run.sh photo.jpg -o /some/dir --force
-```
-
-Outputs: `<name>_uv.png` (1024×1024 UV-texture map — the headline output),
-`<name>_id.obj` (neutral/identity head mesh, HiFi3D++ topology, 20481 verts),
-`<name>_exp.obj` (mesh with the photo's expression), `<name>.mtl` (links the
-meshes to the texture — the obj/mtl/png triplet opens textured in Blender or
-any obj viewer), `<name>_vis.png` (input | skin mask | parsing | landmarks |
-fitted render | uv), `<name>_input_vis.png` (preprocessing check).
-
-Plus a `raw/` subfolder with the complete machine-readable fitting results:
-all three stages' meshes/coeffs (`stage*_coeffs.pt`: HiFi3D++ id/exp/tex
-coefficients, pose, lighting, predicted 68 landmarks; stages 2-3 also GAN
-latents `latents_z`/`latents_w`), per-step optimization visuals, fitting log,
-tensorboard events, the aligned 224×224 input tensors (`input_data.pt`,
-`preprocess/<name>_processed.pt`: image, skin mask, parse mask, landmarks,
-arcface warp matrix).
-
-Pipeline: MTCNN 5-pt + 68-landmark detection (TF frozen graphs, CPU) → skin
-mask + face parsing → similarity alignment to 224×224 → Deep3D (HiFi3D++
-basis) coefficient init → StyleGAN2-based texture-GAN latent search (spherical
-surface, fixed shape, 100 steps) → joint texture+shape optimization (200
-steps, arcface id loss + VGG/LPIPS + photometric + landmark losses, rendered
-with nvdiffrast CUDA rasterizer).
-
-## What the installer does differently (vs. upstream repo)
-
-Upstream targets python 3.7 / torch 1.7.1 / TF 1.15 + conda. To run on the
-native py3.12 / torch 2.8 / numpy 2.1 env:
-
-- **checkpoints from the official HF mirror** (`csbhr/FFHQ-UV` dataset repo)
-  instead of Baidu Netdisk/OneDrive; only the ~2.5 GB the RGB-fitting
-  pipeline needs (not the 300+ GB dataset, not the StyleGAN/e4e/DPR editing
-  checkpoints used only for dataset creation)
-- **tensorflow-cpu** (modern 2.x) instead of tensorflow-gpu 1.15; the two TF1
-  frozen-graph detectors (MTCNN, 68-landmarks) are run through the
-  `tf.compat.v1` API — the only source patch needed. CPU on purpose: seconds
-  of inference, and no CUDA/cuDNN conflicts with torch
-- **no pytorch3d needed** (RGB fitting only uses nvdiffrast, already present
-  from p3dm; the installer installs it if missing); stylegan2 custom CUDA ops
-  JIT-compile on first use and fall back to reference implementations if the
-  build fails
-- `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` at runtime (repo predates torch 2.6
-  `weights_only` default)
-- pip runs against a constraints file pinning the already-installed
-  numpy/torch/opencv/kornia/… so the ComfyUI env is never disturbed; only two
-  new packages are actually installed (`dominate`, `tensorflow-cpu`)
-
-## Licenses
-
-FFHQ-UV code and checkpoints are for **non-commercial research** use (see the
-[upstream repo](https://github.com/csbhr/FFHQ-UV)); checkpoints are downloaded
-from the authors' official Hugging Face mirror at install time and are not
-redistributed here. HiFi3D++ topology © Tencent AI Lab (REALY).

ffhq-uv/ffhq_uv_install.sh

@@ -1,151 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# ffhq_uv_install.sh — one-shot installer for FFHQ-UV RGB fitting
-#                      (single photo -> 3D face mesh + 1024x1024 UV texture)
-#
-# Installs https://github.com/csbhr/FFHQ-UV (RGB_Fitting pipeline, HiFi3D++
-# topology + GAN texture decoder) into the NATIVE python environment (no venv,
-# no conda, no torch reinstall). Tested on: Ubuntu 24.04, python 3.12,
-# torch 2.8.0+cu128, H100 (RunPod image plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (the script will not install torch)
-#   - ~2.5 GB disk for checkpoints (downloaded from the official HF mirror
-#     csbhr/FFHQ-UV — no Baidu/OneDrive account needed)
-#
-# Usage:
-#   ./ffhq_uv_install.sh
-#
-# Layout (override with FFHQUV_HOME):
-#   $FFHQUV_HOME/FFHQ-UV          code + checkpoints + topo assets
-#   $FFHQUV_HOME/staging          per-image input staging
-#   $FFHQUV_HOME/fitting_output   per-image fitting results
-# =============================================================================
-set -euo pipefail
-
-FFHQUV_HOME="${FFHQUV_HOME:-/workspace/ffhq-uv}"
-REPO="$FFHQUV_HOME/FFHQ-UV"
-
-log() { echo -e "\n\033[1;36m[ffhq-uv-install]\033[0m $*"; }
-
-mkdir -p "$FFHQUV_HOME" "$FFHQUV_HOME/staging" "$FFHQUV_HOME/fitting_output"
-cd "$FFHQUV_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch"
-python3 - <<'EOF'
-import torch
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-
-# ---------------------------------------------------- constraints (protect env)
-# Pin the currently-installed versions of shared heavyweight packages so pip
-# cannot up/downgrade them while installing FFHQ-UV deps (keeps ComfyUI safe).
-log "generating pip constraints from current env"
-python3 - > "$FFHQUV_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","scikit-image",
-          "opencv-python","kornia","tensorboard","huggingface_hub",
-          "transformers","safetensors","requests"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $FFHQUV_HOME/constraints.txt"
-
-# ------------------------------------------------------------------ pip deps
-# Almost everything (opencv, kornia, scikit-image, tensorboard, nvdiffrast) is
-# already in the native env. Only two new packages are needed:
-#   dominate        - tiny, HTML logging used by the fitting logger
-#   tensorflow-cpu  - runs the two frozen-graph detectors (MTCNN + 68 landmarks)
-#                     in step1 preprocessing; CPU build on purpose (a few sec of
-#                     inference, avoids CUDA/cuDNN clashes with torch)
-log "installing python dependencies (native env, constrained)"
-python3 -c "import dominate" 2>/dev/null || pip install -q $CONS dominate
-python3 -c "import tensorflow" 2>/dev/null || pip install -q $CONS tensorflow-cpu
-
-# nvdiffrast: normally already present (e.g. from p3dm_install.sh)
-python3 -c "import nvdiffrast" 2>/dev/null || {
-  log "installing nvdiffrast"
-  pip install -q $CONS ninja
-  pip install -q $CONS --no-build-isolation "git+https://github.com/NVlabs/nvdiffrast.git"
-}
-
-# ------------------------------------------------------------------ FFHQ-UV
-if [ ! -d "$REPO" ]; then
-  log "cloning FFHQ-UV"
-  git clone --depth 1 https://github.com/csbhr/FFHQ-UV.git "$REPO"
-fi
-
-# ------------------------------------------------------- numpy 2 compat patch
-# numpy 2 moved VisibleDeprecationWarning into np.exceptions, and no longer
-# builds ragged arrays implicitly (t[0]/t[1] are 1-element arrays)
-sed -i 's/category=np\.VisibleDeprecationWarning/category=np.exceptions.VisibleDeprecationWarning/;
-        s/trans_params = np\.array(\[w0, h0, s, t\[0\], t\[1\]\])/trans_params = np.array([w0, h0, s, float(t[0]), float(t[1])])/' \
-  "$REPO/RGB_Fitting/utils/preprocess_utils.py"
-
-# --------------------------------------------------- tf1 -> tf2 compat patches
-# The MTCNN + 68-landmark detectors are TF1 frozen graphs; modern tensorflow
-# runs them through the compat.v1 API with eager execution disabled.
-log "applying tensorflow compat patches"
-for f in "$REPO/RGB_Fitting/third_party/mtcnn/detect_face_with_mtcnn.py" \
-         "$REPO/RGB_Fitting/third_party/landmark68/detect_lm68.py"; do
-  grep -q "tensorflow.compat.v1" "$f" || \
-    sed -i 's/^import tensorflow as tf$/import tensorflow.compat.v1 as tf; tf.disable_eager_execution()/' "$f"
-  grep -q "tensorflow.compat.v1" "$f" || { echo "tf compat patch failed: $f"; exit 1; }
-done
-
-# ------------------------------------------------- checkpoints + topo assets
-# Official HF mirror of the project (csbhr/FFHQ-UV) hosts all checkpoints and
-# topology assets — only the files the RGB-fitting pipeline needs are fetched.
-log "downloading checkpoints + topo assets (~2.5 GB, official HF mirror)"
-REPO_DIR="$REPO" python3 - <<'EOF'
-import os
-from huggingface_hub import snapshot_download
-snapshot_download(
-    repo_id="csbhr/FFHQ-UV", repo_type="dataset",
-    local_dir=os.environ["REPO_DIR"],
-    allow_patterns=[
-        "checkpoints/lm_model/68lm_detector.pb",
-        "checkpoints/mtcnn_model/mtcnn_model.pb",
-        "checkpoints/parsing_model/79999_iter.pth",
-        "checkpoints/resnet_model/resnet18-5c106cde.pth",
-        "checkpoints/deep3d_model/epoch_latest.pth",
-        "checkpoints/arcface_model/ms1mv3_arcface_r50_fp16_backbone.pth",
-        "checkpoints/texgan_model/texgan_ffhq_uv.pth",
-        "checkpoints/vgg_model/vgg16.pt",
-        "topo_assets/*",
-    ],
-)
-print("  checkpoints ok")
-EOF
-
-# ------------------------------------------------------------------ verify
-log "verifying imports + files"
-REPO_DIR="$REPO" python3 - <<'EOF'
-import os, warnings
-warnings.filterwarnings("ignore")
-os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
-import nvdiffrast, kornia, dominate, cv2, skimage
-import tensorflow.compat.v1 as tf
-assert hasattr(tf, "GraphDef") and hasattr(tf, "InteractiveSession")
-repo = os.environ["REPO_DIR"]
-for f in ["checkpoints/lm_model/68lm_detector.pb",
-          "checkpoints/mtcnn_model/mtcnn_model.pb",
-          "checkpoints/parsing_model/79999_iter.pth",
-          "checkpoints/resnet_model/resnet18-5c106cde.pth",
-          "checkpoints/deep3d_model/epoch_latest.pth",
-          "checkpoints/arcface_model/ms1mv3_arcface_r50_fp16_backbone.pth",
-          "checkpoints/texgan_model/texgan_ffhq_uv.pth",
-          "checkpoints/vgg_model/vgg16.pt",
-          "topo_assets/hifi3dpp_model_info.mat",
-          "topo_assets/unwrap_1024_info.mat",
-          "topo_assets/similarity_Lm3D_all.mat"]:
-    p = os.path.join(repo, f)
-    assert os.path.getsize(p) > 0, p
-print("  all good")
-EOF
-
-log "install complete. run:  ./ffhq_uv_run.sh <photo.jpg>"

ffhq-uv/ffhq_uv_run.sh

@@ -1,101 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# ffhq_uv_run.sh — single photo in -> 3D face mesh + UV texture out (FFHQ-UV)
-#
-# Usage:
-#   ./ffhq_uv_run.sh <photo.(jpg|png)> [-o <output_dir>] [--force]
-#
-#   -o DIR     output directory  (default: /workspace/outputs/ffhq-uv/<name>)
-#   --force    redo preprocessing/fitting even if cached results exist
-#
-# Outputs (in <output_dir>):
-#   <name>_uv.png         1024x1024 facial UV-texture map (headline output)
-#   <name>_id.obj         fitted head mesh, identity/neutral (HiFi3D++ topology)
-#   <name>_exp.obj        fitted head mesh with expression
-#   <name>.mtl            material linking the meshes to the UV texture
-#   <name>_vis.png        input | skin mask | parsing | landmarks | render | uv
-#   <name>_input_vis.png  preprocessing visualization (step1)
-#   raw/                  full fitting results (all stages, coeffs, latents,
-#                         logs, per-step visuals) + preprocessed input data
-#
-# Requires ffhq_uv_install.sh to have been run first.
-# =============================================================================
-set -euo pipefail
-
-FFHQUV_HOME="${FFHQUV_HOME:-/workspace/ffhq-uv}"
-REPO="$FFHQUV_HOME/FFHQ-UV"
-TEXGAN="texgan_ffhq_uv.pth"
-
-IMG="" ; OUT="" ; FORCE=0
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -o)      OUT="$2"; shift 2;;
-    --force) FORCE=1; shift;;
-    -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-    *)       IMG="$1"; shift;;
-  esac
-done
-[ -n "$IMG" ] && [ -f "$IMG" ] || { echo "usage: $0 <photo.jpg> [-o outdir] [--force]"; exit 1; }
-[ -d "$REPO" ] || { echo "FFHQ-UV not installed - run ffhq_uv_install.sh first"; exit 1; }
-
-# sanitized job name from the file stem (used as folder + file identifier)
-STEM="$(basename "$IMG")"; STEM="${STEM%.*}"
-NAME="$(echo "$STEM" | tr -c 'a-zA-Z0-9' '_' | sed 's/_*$//;s/^_*//' | cut -c1-60)"
-OUT="${OUT:-/workspace/outputs/ffhq-uv/$NAME}"
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1   # repo predates torch>=2.6 weights_only default
-export TF_CPP_MIN_LOG_LEVEL=3               # silence tensorflow banner
-if [ -z "${TORCH_CUDA_ARCH_LIST:-}" ]; then
-  export TORCH_CUDA_ARCH_LIST="$(python3 -c "import torch; print('%d.%d+PTX' % torch.cuda.get_device_capability())")"
-fi
-
-log() { echo -e "\033[1;35m[ffhq-uv]\033[0m $*"; }
-T0=$(date +%s)
-
-# stage the photo in a folder named after the job (step1 processes a folder)
-STAGE="$FFHQUV_HOME/staging/$NAME"
-PROC="$STAGE/processed_data"
-FITOUT="$FFHQUV_HOME/fitting_output/$NAME"
-if [ "$FORCE" = 1 ]; then rm -rf "$STAGE" "$FITOUT"; fi
-mkdir -p "$STAGE"
-cp -f "$IMG" "$STAGE/$NAME.${IMG##*.}"
-
-cd "$REPO/RGB_Fitting"
-
-log "1/2 preprocessing (MTCNN + 68 landmarks, skin mask, face parsing, alignment)"
-if [ ! -f "$PROC/$NAME.pt" ]; then
-  python3 step1_process_data.py --input_dir "$STAGE" --output_dir "$PROC" \
-      --checkpoints_dir ../checkpoints --topo_dir ../topo_assets > /dev/null 2>&1 \
-    || { echo "preprocessing failed, rerunning verbosely:"; \
-         python3 step1_process_data.py --input_dir "$STAGE" --output_dir "$PROC" \
-             --checkpoints_dir ../checkpoints --topo_dir ../topo_assets; exit 1; }
-fi
-[ -f "$PROC/$NAME.pt" ] || { echo "ERROR: no face detected / preprocessing failed for $IMG"; exit 1; }
-
-log "2/2 RGB fitting (deep3d init -> texture search -> joint tex+shape optimization)"
-if [ ! -f "$FITOUT/$NAME/stage3_mesh_id.obj" ]; then
-  python3 step2_fit_processed_data.py --input_dir "$PROC" --output_dir "$FITOUT" \
-      --checkpoints_dir ../checkpoints --topo_dir ../topo_assets \
-      --texgan_model_name "$TEXGAN" 2>&1 | grep -E "Stage|stage [0-9]|Fit image|Error|Traceback" || true
-fi
-RES="$FITOUT/$NAME"
-[ -f "$RES/stage3_mesh_id.obj" ] || { echo "ERROR: fitting produced no mesh"; exit 1; }
-
-# --------------------------------------------------------------- final outputs
-mkdir -p "$OUT" "$OUT/raw"
-cp "$RES/stage3_uv.png" "$OUT/${NAME}_uv.png"
-# meshes + material, renamed with internal references fixed up
-sed "s/stage3_mesh\.mlt/${NAME}.mtl/"   "$RES/stage3_mesh_id.obj"  > "$OUT/${NAME}_id.obj"
-sed "s/stage3_mesh\.mlt/${NAME}.mtl/"   "$RES/stage3_mesh_exp.obj" > "$OUT/${NAME}_exp.obj"
-sed "s/stage3_uv\.png/${NAME}_uv.png/"  "$RES/stage3_mesh.mlt"     > "$OUT/${NAME}.mtl"
-cp "$RES/stage3_vis.png" "$OUT/${NAME}_vis.png"
-[ -f "${PROC}_vis/$NAME.png" ] && cp "${PROC}_vis/$NAME.png" "$OUT/${NAME}_input_vis.png"
-
-# raw fitting + preprocessing data (all stages, coeffs, GAN latents, logs,
-# per-step visuals, aligned input tensors) for downstream use
-cp -r "$RES/." "$OUT/raw/"
-mkdir -p "$OUT/raw/preprocess"
-cp "$PROC/$NAME.pt" "$OUT/raw/preprocess/${NAME}_processed.pt"
-
-log "done in $(( $(date +%s) - T0 ))s -> $OUT"
-ls -la "$OUT"

makeup-extract/README.md

@@ -1,102 +0,0 @@
-# makeup-extract — 3D makeup extraction from a single photo
-
-Support scripts for [YangXingchao/makeup-extract](https://github.com/YangXingchao/makeup-extract)
-(*Makeup Extraction of 3D Representation via Illumination-Aware Image
-Decomposition*, Yang, Taketomi, Kanamori — Computer Graphics Forum / Eurographics 2023).
-
-From one face photo the pipeline reconstructs a coarse FLAME face, unwraps and
-completes the UV texture, decomposes it into materials (diffuse albedo, normal,
-diffuse/specular shading) and extracts the **makeup as a separate layer**:
-
-| output | meaning |
-|---|---|
-| `bare_skin.png` | UV albedo with makeup removed |
-| `make_base.png` | makeup base color (UV) |
-| `make_alpha.png` | makeup alpha/opacity matte (UV, white = no makeup) |
-| `make_blend.png` | premultiplied makeup layer (`base * alpha`, UV) |
-| `albe_refine.png`, `norm_refine.png`, `diff_refine.png`, `rnsr_refine.png`, `tex_refine.png`, `completion.png` | refined UV materials / completed texture |
-| `img_compose.png`, `img_compose_with_bg.png` | face re-rendered from the decomposed materials (sanity check — should resemble the aligned input) |
-
-## Install
-
-```bash
-./makeup_extract_install.sh
-```
-
-One-shot, idempotent, installs into the **native** python env (no venv; a pip
-constraints file protects torch/numpy/etc. from being touched). Tested on
-Ubuntu 24.04, python 3.12, torch 2.8.0+cu128, H100 (image `plx1029/comfyui-qwen`).
-
-What it does:
-
-- apt-installs GL/EGL dev headers (`libglvnd-dev`, mesa dev packages) as a
-  safety net for nvdiffrast's GL path. Note: current nvdiffrast (2026)
-  deprecates `RasterizeGLContext` and silently maps it to the CUDA
-  rasterizer, so the upstream `dr.RasterizeGLContext()` calls run headless
-  with no OpenGL involved at all.
-- pip-installs `ninja`, `gdown`, `nvdiffrast` (from GitHub,
-  `--no-build-isolation` so it compiles against native torch), and a patched
-  `chumpy` (py3.12/numpy2 fixes; only needed to unpickle FLAME).
-- clones the upstream repo to `$MAKEUP_EXTRACT_HOME/makeup-extract`
-  (default `/workspace/makeup-extract/makeup-extract`).
-- downloads weights:
-  - pipeline checkpoints (`coarse_reconstruction.pkl`, `uv_completion.pkl`,
-    `makeup_extraction.pkl`) from the paper's official Google Drive folder;
-  - FLAME assets `generic_model.pkl` (FLAME2020), `FLAME_masks.pkl`,
-    `FLAME_texture.npz` — from the **official** site when
-    `FLAME_USERNAME`/`FLAME_PASSWORD` are set, otherwise from the public HF
-    mirror `camenduru/show`. Either way the
-    [FLAME license](https://flame.is.tue.mpg.de/modellicense.html)
-    (non-commercial scientific research) applies — register at
-    flame.is.tue.mpg.de;
-  - `albedoModel2020_FLAME_albedoPart.npz` from the official
-    [AlbedoMM](https://github.com/waps101/AlbedoMM) GitHub release (its own
-    non-commercial license applies).
-
-## Run
-
-```bash
-./makeup_extract_run.sh <photo.jpg> [out_dir]
-# e.g.
-./makeup_extract_run.sh /workspace/face2.jpg
-```
-
-Runs all six upstream steps (preprocess → coarse reconstruction → UV
-completion → material refinement → makeup extraction → re-render). Curated
-outputs land in `/workspace/outputs/makeup-extract/<stem>/`; raw per-step
-outputs are cached in `$MAKEUP_EXTRACT_HOME/results/<stem>/` (delete to
-re-run). ~1–2 min per image on an H100 (step 3 is a 500-iteration
-optimization; first run adds nvdiffrast JIT compile + VGG19/resnet18 aux
-downloads, cached under `weights_cache/torch`).
-
-## Deviations from upstream
-
-- **No upstream file is modified.** All adaptation is done via environment and
-  wrapper:
-  - `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` at runtime (repo predates the
-    torch ≥2.6 `torch.load(weights_only=True)` default; checkpoints contain
-    non-tensor objects).
-  - `TORCH_HOME` redirected to `weights_cache/torch` so auto-downloaded VGG19 /
-    resnet18 weights survive pod restarts (`/root` is ephemeral).
-  - Non-square inputs are padded to square by the run script before step 0
-    (upstream's landmark scaling assumes square input).
-- Dependency versions differ from upstream's `requirements.txt` pins
-  (numpy 1.23 → 2.1, kornia 0.6 → 0.8, opencv 4.7 → 5.0, scipy native): the
-  code is compatible as-is; no `np.int`-era aliases are used. `chumpy` is
-  patched for py3.12/numpy2 (`getargspec` → `getfullargspec`, removed-alias
-  import) as in the `deca/` implementation.
-- FLAME assets fall back to a public HF mirror when no FLAME credentials are
-  provided (see Install above).
-
-## Layout
-
-```
-/workspace/makeup-extract/
-  makeup_extract_install.sh   this installer
-  makeup_extract_run.sh       single-image runner
-  makeup-extract/             upstream clone + checkpoints/ + resources/
-  staging/<stem>/             squared input copy
-  results/<stem>/             raw per-step outputs (cache)
-  weights_cache/torch/        VGG19 / resnet18 hub cache
-/workspace/outputs/makeup-extract/<stem>/   curated outputs
-```

makeup-extract/makeup_extract_install.sh

@@ -1,227 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# makeup_extract_install.sh — one-shot installer for makeup-extract
-#   (Eurographics 2023: "Makeup Extraction of 3D Representation via
-#    Illumination-Aware Image Decomposition", Yang et al.)
-#   single face photo -> FLAME-based UV materials (albedo / normal / shading)
-#   + extracted makeup layers (bare skin, makeup base, alpha, blend)
-#   + re-rendered composite.
-#
-# Installs https://github.com/YangXingchao/makeup-extract into the NATIVE
-# python environment (no venv, no conda, no torch reinstall). Tested on:
-# Ubuntu 24.04, python 3.12, torch 2.8.0+cu128, H100
-# (RunPod image plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (this script will not install torch)
-#   - nvcc + gcc (nvdiffrast CUDA/GL plugins JIT-compile on first use)
-#   - NVIDIA EGL driver libs (libEGL_nvidia.so.0) for the headless GL
-#     rasterizer context — present on this image
-#   - FLAME assets (see below): official downloads need FLAME account creds
-#     via env vars FLAME_USERNAME / FLAME_PASSWORD
-#     (https://flame.is.tue.mpg.de). Without creds the script falls back to
-#     a public Hugging Face mirror (camenduru/show). Either way you must
-#     comply with the FLAME license (non-commercial scientific research).
-#
-# Downloads:
-#   - pretrained pipeline checkpoints (~1 GB, official Google Drive folder)
-#   - FLAME2020 generic_model.pkl (~54 MB), FLAME_masks.pkl (~0.2 MB),
-#     FLAME_texture.npz (~1.3 GB)
-#   - AlbedoMM albedoModel2020_FLAME_albedoPart.npz (~1.8 GB, official
-#     GitHub release, CC BY 4.0 non-commercial per AlbedoMM README)
-#
-# Usage:
-#   ./makeup_extract_install.sh
-#
-# Layout (override with MAKEUP_EXTRACT_HOME):
-#   $MAKEUP_EXTRACT_HOME/makeup-extract   upstream clone + weights
-#   $MAKEUP_EXTRACT_HOME/staging          per-image input staging
-#   $MAKEUP_EXTRACT_HOME/results          per-image raw outputs
-#   $MAKEUP_EXTRACT_HOME/weights_cache    torch hub cache (VGG19, resnet18)
-# =============================================================================
-set -euo pipefail
-
-if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0; fi
-
-M_HOME="${MAKEUP_EXTRACT_HOME:-/workspace/makeup-extract}"
-REPO="$M_HOME/makeup-extract"
-
-log() { echo -e "\n\033[1;36m[makeup-extract-install]\033[0m $*"; }
-
-mkdir -p "$M_HOME" "$M_HOME/staging" "$M_HOME/results" "$M_HOME/weights_cache"
-cd "$M_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch/nvcc"
-python3 - <<'EOF'
-import torch
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-command -v nvcc >/dev/null || echo "  WARNING: nvcc not found - nvdiffrast JIT compile will fail at runtime"
-
-# ---------------------------------------------------- constraints (protect env)
-# Pin currently-installed shared heavyweights so pip cannot up/downgrade them
-# while installing deps (keeps the ComfyUI env safe).
-log "generating pip constraints from current env"
-python3 - > "$M_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","kornia",
-          "opencv-python","opencv-python-headless","requests","einops",
-          "safetensors","huggingface-hub"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $M_HOME/constraints.txt"
-
-# ------------------------------------------------- system GL/EGL dev packages
-# nvdiffrast's GL rasterizer plugin JIT-compiles against EGL/GLES headers.
-# The NVIDIA EGL driver (libEGL_nvidia.so.0) is already on the image; we only
-# add the glvnd dispatcher + headers.
-if ! dpkg -s libglvnd-dev >/dev/null 2>&1; then
-  log "installing GL/EGL dev packages (apt)"
-  apt-get update -qq
-  DEBIAN_FRONTEND=noninteractive apt-get install -y -qq \
-    pkg-config libglvnd0 libgl1 libglx0 libegl1 libgles2 \
-    libglvnd-dev libgl1-mesa-dev libegl1-mesa-dev libgles2-mesa-dev
-else
-  log "GL/EGL dev packages already installed"
-fi
-
-# ------------------------------------------------------------------ pip deps
-log "installing python dependencies (native env, constrained)"
-pip install -q $CONS ninja gdown
-
-if ! python3 -c "import nvdiffrast" 2>/dev/null; then
-  log "installing nvdiffrast from GitHub (compiles CUDA extension against native torch)"
-  TORCH_CUDA_ARCH_LIST="$(python3 -c 'import torch; print("%d.%d" % torch.cuda.get_device_capability())')" \
-    pip install -q $CONS --no-build-isolation "git+https://github.com/NVlabs/nvdiffrast.git"
-fi
-
-# chumpy: only needed to unpickle FLAME. Needs patching for py>=3.11 / numpy>=2.
-if ! python3 -c "import chumpy" 2>/dev/null; then
-  log "installing + patching chumpy for py3.12/numpy2"
-  pip install -q --no-deps --no-build-isolation chumpy
-  CHDIR=$(python3 -c "import importlib.util,os; print(os.path.dirname(importlib.util.find_spec('chumpy').origin))")
-  grep -rl "inspect.getargspec" "$CHDIR"/*.py | xargs -r sed -i "s/inspect\.getargspec/inspect.getfullargspec/g"
-  sed -i "s/^from numpy import bool, int, float, complex, object, unicode, str, nan, inf$/from numpy import nan, inf/" "$CHDIR/__init__.py"
-  python3 -c "import chumpy" || { echo "chumpy patch failed"; exit 1; }
-fi
-
-# ------------------------------------------------------------------ repo
-if [ ! -d "$REPO" ]; then
-  log "cloning makeup-extract"
-  git clone --depth 1 https://github.com/YangXingchao/makeup-extract.git "$REPO"
-fi
-
-# -------------------------------------------------------- pipeline checkpoints
-# Official Google Drive folder from the README.
-CKPTS="coarse_reconstruction.pkl uv_completion.pkl makeup_extraction.pkl"
-need_ckpt=0
-for c in $CKPTS; do [ -s "$REPO/checkpoints/$c" ] || need_ckpt=1; done
-if [ "$need_ckpt" = 1 ]; then
-  log "downloading pretrained checkpoints (official Google Drive)"
-  gdown --folder 1lwkR9JcrbZ7fNylTSJQQEiGnt3s2LQYq -O "$REPO/checkpoints" -q
-fi
-for c in $CKPTS; do
-  [ -s "$REPO/checkpoints/$c" ] || { echo "checkpoint $c missing after download"; exit 1; }
-done
-
-# ------------------------------------------------------------------ FLAME assets
-RES="$REPO/resources"
-
-flame_official() { # $1 = sfile, $2 = out zip
-  urle () { local LANG=C i x; for (( i = 0; i < ${#1}; i++ )); do x="${1:i:1}"; [[ "${x}" == [a-zA-Z0-9.~-] ]] && echo -n "${x}" || printf '%%%02X' "'${x}"; done; }
-  local U P; U=$(urle "$FLAME_USERNAME"); P=$(urle "$FLAME_PASSWORD")
-  wget -q --post-data "username=$U&password=$P" \
-    "https://download.is.tue.mpg.de/download.php?domain=flame&sfile=$1&resume=1" \
-    -O "$2" --no-check-certificate --continue
-}
-
-hf_mirror() { # $1 = path in camenduru/show, $2 = dest file
-  python3 - "$1" "$2" <<'EOF'
-import shutil, sys
-from huggingface_hub import hf_hub_download
-src = hf_hub_download("camenduru/show", sys.argv[1])
-shutil.copyfile(src, sys.argv[2])
-EOF
-}
-
-HAVE_CREDS=0
-[ -n "${FLAME_USERNAME:-}" ] && [ -n "${FLAME_PASSWORD:-}" ] && HAVE_CREDS=1
-
-if [ ! -s "$RES/generic_model.pkl" ]; then
-  P3DM_FLAME="/workspace/p3dm/pixel3dmm/src/pixel3dmm/preprocessing/MICA/data/FLAME2020/generic_model.pkl"
-  if [ -f "$P3DM_FLAME" ]; then
-    log "reusing FLAME 2020 from p3dm install"
-    cp "$P3DM_FLAME" "$RES/generic_model.pkl"
-  elif [ "$HAVE_CREDS" = 1 ]; then
-    log "downloading FLAME 2020 (official, needs FLAME account)"
-    flame_official "FLAME2020.zip" "$RES/FLAME2020.zip"
-    unzip -o -q "$RES/FLAME2020.zip" -d "$RES/FLAME2020_tmp"
-    mv "$RES/FLAME2020_tmp/generic_model.pkl" "$RES/generic_model.pkl"
-    rm -rf "$RES/FLAME2020.zip" "$RES/FLAME2020_tmp"
-  else
-    log "downloading FLAME 2020 generic_model.pkl (HF mirror camenduru/show; set FLAME_USERNAME/FLAME_PASSWORD for official source)"
-    hf_mirror "models/models_MICA/FLAME2020/generic_model.pkl" "$RES/generic_model.pkl"
-  fi
-fi
-
-if [ ! -s "$RES/FLAME_masks.pkl" ]; then
-  if [ "$HAVE_CREDS" = 1 ]; then
-    log "downloading FLAME vertex masks (official)"
-    flame_official "FLAME_masks.zip" "$RES/FLAME_masks.zip"
-    unzip -o -q "$RES/FLAME_masks.zip" -d "$RES/FLAME_masks_tmp"
-    mv "$RES/FLAME_masks_tmp/FLAME_masks.pkl" "$RES/FLAME_masks.pkl"
-    rm -rf "$RES/FLAME_masks.zip" "$RES/FLAME_masks_tmp"
-  else
-    log "downloading FLAME_masks.pkl (HF mirror)"
-    hf_mirror "data/FLAME_masks.pkl" "$RES/FLAME_masks.pkl"
-  fi
-fi
-
-if [ ! -s "$RES/FLAME_texture.npz" ]; then
-  if [ "$HAVE_CREDS" = 1 ]; then
-    log "downloading FLAME texture space (official, ~1.3 GB)"
-    flame_official "TextureSpace.zip" "$RES/TextureSpace.zip"
-    unzip -o -q "$RES/TextureSpace.zip" -d "$RES/TextureSpace_tmp"
-    mv "$RES/TextureSpace_tmp/FLAME_texture.npz" "$RES/FLAME_texture.npz"
-    rm -rf "$RES/TextureSpace.zip" "$RES/TextureSpace_tmp"
-  else
-    log "downloading FLAME_texture.npz (HF mirror, ~1.3 GB)"
-    hf_mirror "data/flame/FLAME_texture.npz" "$RES/FLAME_texture.npz"
-  fi
-fi
-
-if [ ! -s "$RES/albedoModel2020_FLAME_albedoPart.npz" ]; then
-  log "downloading AlbedoMM albedo model (official GitHub release, ~1.8 GB)"
-  wget -q --show-progress --continue \
-    "https://github.com/waps101/AlbedoMM/releases/download/v1.0/albedoModel2020_FLAME_albedoPart.npz" \
-    -O "$RES/albedoModel2020_FLAME_albedoPart.npz"
-fi
-
-# ------------------------------------------------------------------ verify
-log "verifying imports + files"
-REPO_DIR="$REPO" python3 - <<'EOF'
-import os, sys, warnings
-warnings.filterwarnings("ignore")
-import chumpy, gdown, kornia, cv2, nvdiffrast
-repo = os.environ["REPO_DIR"]
-sys.path.insert(0, repo)
-import networks  # pulls torchvision resnet50 + icosahedron
-for f in ["checkpoints/coarse_reconstruction.pkl", "checkpoints/uv_completion.pkl",
-          "checkpoints/makeup_extraction.pkl",
-          "resources/generic_model.pkl", "resources/FLAME_masks.pkl",
-          "resources/FLAME_texture.npz",
-          "resources/albedoModel2020_FLAME_albedoPart.npz",
-          "resources/landmark_embedding.npy", "resources/skin_mask.png",
-          "libs/face_parsing/module_weight/79999_iter.pth",
-          "libs/face_landmark/checkpoint/mobilenet_224_model_best_gdconv_external.pth.tar"]:
-    p = os.path.join(repo, f)
-    assert os.path.exists(p) and os.path.getsize(p) > 0, p
-print("  all good")
-EOF
-
-log "install complete. run:  ./makeup_extract_run.sh <photo.jpg>"

makeup-extract/makeup_extract_run.sh

@@ -1,127 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# makeup_extract_run.sh — single photo -> 3D makeup decomposition
-#
-# Runs the full 6-step makeup-extract pipeline (Yang et al., EG 2023) on one
-# face image:
-#   step 0  landmark crop + face parsing        -> aligned_img / mask
-#   step 1  coarse FLAME material reconstruction -> UV albedo/normal/shading
-#   step 2  UV texture completion (DSD-GAN)
-#   step 3  material refinement (500-iter optimization, VGG/TV losses)
-#   step 4  makeup extraction (bare skin / base / alpha / blend)
-#   step 5  re-render composite with extracted textures
-#
-# Usage:
-#   ./makeup_extract_run.sh <photo.jpg> [out_dir]
-#
-#   out_dir default: /workspace/outputs/makeup-extract/<image-stem>/
-#
-# Notes:
-#   - non-square inputs are padded to square first (upstream assumes square)
-#   - raw per-step outputs are cached in $MAKEUP_EXTRACT_HOME/results/<stem>/;
-#     delete that folder to force a re-run
-# =============================================================================
-set -euo pipefail
-
-if [ $# -lt 1 ] || [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
-  grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0
-fi
-
-M_HOME="${MAKEUP_EXTRACT_HOME:-/workspace/makeup-extract}"
-REPO="$M_HOME/makeup-extract"
-
-log() { echo -e "\n\033[1;36m[makeup-extract]\033[0m $*"; }
-
-IMG="$(realpath "$1")"
-[ -f "$IMG" ] || { echo "input image not found: $IMG"; exit 1; }
-
-for f in checkpoints/coarse_reconstruction.pkl resources/generic_model.pkl \
-         resources/FLAME_texture.npz resources/albedoModel2020_FLAME_albedoPart.npz; do
-  [ -s "$REPO/$f" ] || { echo "missing $REPO/$f - run ./makeup_extract_install.sh first"; exit 1; }
-done
-
-STEM=$(basename "$IMG" | sed 's/\.[^.]*$//' | tr -c 'a-zA-Z0-9' '_' | sed 's/_*$//;s/^_*//' | cut -c1-60)
-STAGE="$M_HOME/staging/$STEM"
-RESULTS="$M_HOME/results/$STEM"
-OUT_DIR="${2:-/workspace/outputs/makeup-extract/$STEM}"
-mkdir -p "$STAGE" "$RESULTS" "$OUT_DIR"
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1      # repo predates torch 2.6 torch.load change
-export TORCH_HOME="$M_HOME/weights_cache/torch" # VGG19/resnet18 aux weights (keep off ephemeral /root)
-
-START=$(date +%s)
-
-# ---------------------------------------------------------------- stage input
-# Upstream step_0 assumes a square image; pad to square (centered, black).
-log "staging input (pad to square if needed)"
-IMG_PATH="$IMG" STAGED="$STAGE/input.png" python3 - <<'EOF'
-import os, cv2
-img = cv2.imread(os.environ["IMG_PATH"])
-h, w = img.shape[:2]
-if h != w:
-    s = max(h, w)
-    top = (s - h) // 2; left = (s - w) // 2
-    img = cv2.copyMakeBorder(img, top, s - h - top, left, s - w - left,
-                             cv2.BORDER_CONSTANT, value=(0, 0, 0))
-    print(f"  padded {w}x{h} -> {s}x{s}")
-cv2.imwrite(os.environ["STAGED"], img)
-EOF
-
-cd "$REPO"
-
-# ---------------------------------------------------------------- pipeline
-if [ -s "$RESULTS/render_texture/img_compose_with_bg.png" ]; then
-  log "cached results found in $RESULTS (delete to re-run)"
-else
-  log "step 0/5: landmark crop + face parsing"
-  python3 step_0_preprocess.py -i "$STAGE/input.png" -o "$RESULTS"
-
-  log "step 1/5: coarse facial material reconstruction"
-  python3 step_1_coarse_reconstruction.py \
-    --aligned_img_path "$RESULTS/aligned_img.png" \
-    --segmented_img_path "$RESULTS/segmented_img.png" \
-    -o "$RESULTS/coarse_reconstruction"
-
-  log "step 2/5: UV completion"
-  python3 step_2_uv_completion.py \
-    --uv_mm_path "$RESULTS/coarse_reconstruction/uv_rncr.png" \
-    --uv_tex_path "$RESULTS/coarse_reconstruction/uv_tex.png" \
-    -o "$RESULTS/material_refinement"
-
-  log "step 3/5: material refinement (500-iter optimization)"
-  python3 step_3_material_refinement.py \
-    --mm_param_path "$RESULTS/coarse_reconstruction/mm_param.npz" \
-    --uv_albe_path "$RESULTS/coarse_reconstruction/uv_albe.png" \
-    --uv_norm_path "$RESULTS/coarse_reconstruction/uv_norm.png" \
-    --uv_rnsr_path "$RESULTS/coarse_reconstruction/uv_rnsr.png" \
-    --completion_tex_path "$RESULTS/material_refinement/completion.png" \
-    -o "$RESULTS/material_refinement"
-
-  log "step 4/5: makeup extraction"
-  python3 step_4_makeup_extraction.py \
-    --uv_albe_path "$RESULTS/material_refinement/albe_refine.png" \
-    -o "$RESULTS/makeup_extraction"
-
-  log "step 5/5: render composite"
-  python3 step_5_render_texture.py \
-    --mm_param_path "$RESULTS/coarse_reconstruction/mm_param.npz" \
-    --uv_bare_skin_path "$RESULTS/makeup_extraction/bare_skin.png" \
-    --uv_make_alpha_path "$RESULTS/makeup_extraction/make_alpha.png" \
-    --uv_make_blend_path "$RESULTS/makeup_extraction/make_blend.png" \
-    --uv_diffuse_shading_path "$RESULTS/material_refinement/diff_refine.png" \
-    --uv_specular_shading_path "$RESULTS/material_refinement/rnsr_refine.png" \
-    --input_aligned_image "$RESULTS/aligned_img.png" \
-    --aligned_image_mask_path "$RESULTS/mask_img.png" \
-    -o "$RESULTS/render_texture"
-fi
-
-# ---------------------------------------------------------------- outputs
-log "collecting outputs"
-cp "$RESULTS/aligned_img.png" "$OUT_DIR/"
-cp "$RESULTS/makeup_extraction/"{bare_skin,make_base,make_alpha,make_blend}.png "$OUT_DIR/"
-cp "$RESULTS/material_refinement/"{albe_refine,norm_refine,diff_refine,rnsr_refine,tex_refine,completion}.png "$OUT_DIR/"
-cp "$RESULTS/render_texture/"{img_compose,img_compose_with_bg}.png "$OUT_DIR/"
-
-ELAPSED=$(( $(date +%s) - START ))
-log "done in ${ELAPSED}s. outputs in $OUT_DIR"
-ls -la "$OUT_DIR"

p3dm/README.md

@@ -1,63 +0,0 @@
-# p3dm — Pixel3DMM single-photo → 3D head mesh
-
-One photo in, fitted 3D FLAME head mesh out, using
-[Pixel3DMM](https://github.com/SimonGiebenhain/pixel3dmm) (Giebenhain et al. 2025).
-Runs on the native python of the `plx1029/comfyui-qwen` RunPod image
-(python 3.12, torch 2.8+cu128) — **no venv, no conda, torch is not reinstalled**.
-
-## Install (once per pod, ~5 min + ~5 GB downloads)
-
-```bash
-export FLAME_USERNAME="you@mail.com"   # free account: https://flame.is.tue.mpg.de
-export FLAME_PASSWORD="..."
-./p3dm_install.sh
-```
-
-Everything lands in `$P3DM_HOME` (default `/workspace/p3dm`). Re-running is safe;
-completed steps are skipped. FLAME creds are only needed the first time.
-
-## Run (~2 min per photo on H100, first run +1 min for CUDA JIT)
-
-```bash
-./p3dm_run.sh photo.jpg                        # -> /workspace/outputs/photo/
-./p3dm_run.sh photo.jpg -o /some/dir --iters 800 --force
-```
-
-Outputs: `<name>.ply` (posed mesh, FLAME topology 5023 verts),
-`<name>_canonical.ply` (neutral pose), `<name>_overlay.mp4` (input vs. fit),
-`<name>_normals.png` / `<name>_uv.png` (network predictions), `<name>_crop.jpg`.
-
-Plus a `raw/` subfolder with the machine-readable fit data:
-`<name>.frame` (torch pickle: FLAME shape/exp/jaw/neck/eyes params + fitted
-camera `fl`/`pp`/`R_base_0`/`t_base_0` + `img_size`), float32 un-quantized
-`<name>_normals.npy` (512×512×3) and `<name>_uv.npy` (512×512×2),
-`<name>_cropbox.npy` (ymin/ymax/xmin/xmax of the face crop in the staged
-image), `<name>_seg.png` (facer segmentation), `<name>_landmarks.npy`
-(PIPNet), `<name>_mica_identity.npy`. The FLAME UV layout lives in the repo's
-`assets/` (`flame_uv_coords.npy`, `head_template.obj`).
-
-Pipeline: crop+landmarks (PIPNet) → identity (MICA) → segmentation (facer)
-→ ViT normals + uv prediction → FLAME fitting (nvdiffrast).
-
-## What the installer patches (vs. upstream repo)
-
-Upstream targets python 3.9 / torch 2.x / numpy 1.23. To run on the native
-py3.12 / torch 2.8 / numpy 2.1 env, the installer applies:
-
-- **pytorch3d** from MiroPsota's prebuilt wheel index (no source build)
-- **chumpy** patched (`getargspec` → `getfullargspec`, numpy alias imports)
-- numpy 2 aliases (`np.Inf`, `np.float`, `np.bool`, …) rewritten in MICA/pixel3dmm
-- `scipy.integrate.simps` → `simpson` (PIPNet)
-- PIPNet's Cython NMS replaced with pure-numpy NMS (Cython 3 can't build it)
-- FaceBoxes detector auto-downscales large images (fixes missed detection on
-  high-res headshots where the face fills the frame)
-- `TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1` at runtime (repo predates torch 2.6
-  `weights_only` default)
-- pip runs against a constraints file pinning the already-installed
-  numpy/torch/pillow/… so the ComfyUI env is never disturbed
-
-## Licenses
-
-FLAME (registration required) and MICA weights are downloaded from their
-official sources at install time and are **not** redistributed in this repo.
-Pixel3DMM is CC BY-NC 4.0 — non-commercial use.

p3dm/p3dm_install.sh

@@ -1,248 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# p3dm_install.sh — one-shot installer for Pixel3DMM (single-photo -> 3D head)
-#
-# Installs https://github.com/SimonGiebenhain/pixel3dmm plus its preprocessing
-# stack (facer, MICA, PIPNet) into the NATIVE python environment (no venv, no
-# conda, no torch reinstall). Tested on: Ubuntu 24.04, python 3.12,
-# torch 2.8.0+cu128, H100 (RunPod image plx1029/comfyui-qwen).
-#
-# Idempotent: safe to re-run; finished steps are skipped.
-#
-# Requirements:
-#   - torch with CUDA already installed (the script will not install torch)
-#   - nvcc in PATH (needed once, at first run, for nvdiffrast JIT compile)
-#   - FLAME account creds (https://flame.is.tue.mpg.de) via env vars
-#     FLAME_USERNAME / FLAME_PASSWORD, otherwise the script prompts for them.
-#
-# Usage:
-#   FLAME_USERNAME=you@mail.com FLAME_PASSWORD=... ./p3dm_install.sh
-#
-# Layout (override with P3DM_HOME):
-#   $P3DM_HOME/pixel3dmm        code + weights
-#   $P3DM_HOME/preprocessed     per-image preprocessing cache
-#   $P3DM_HOME/tracking_output  per-image fitting results
-# =============================================================================
-set -euo pipefail
-
-P3DM_HOME="${P3DM_HOME:-/workspace/p3dm}"
-REPO="$P3DM_HOME/pixel3dmm"
-PP="$REPO/src/pixel3dmm/preprocessing"
-
-log() { echo -e "\n\033[1;36m[p3dm-install]\033[0m $*"; }
-
-mkdir -p "$P3DM_HOME" "$P3DM_HOME/preprocessed" "$P3DM_HOME/tracking_output"
-cd "$P3DM_HOME"
-
-# ---------------------------------------------------------------- sanity checks
-log "checking python/torch/nvcc"
-python3 - <<'EOF'
-import torch, sys
-assert torch.cuda.is_available(), "CUDA torch required"
-print(f"  torch {torch.__version__} cuda {torch.version.cuda} ok")
-EOF
-command -v nvcc >/dev/null || echo "  WARNING: nvcc not found - nvdiffrast JIT compile will fail at runtime"
-
-# ---------------------------------------------------- constraints (protect env)
-# Pin the currently-installed versions of shared heavyweight packages so pip
-# cannot up/downgrade them while installing pixel3dmm deps (keeps ComfyUI safe).
-log "generating pip constraints from current env"
-python3 - > "$P3DM_HOME/constraints.txt" <<'EOF'
-from importlib.metadata import version, PackageNotFoundError
-for p in ["numpy","torch","torchvision","pillow","scipy","einops","transformers","huggingface_hub","safetensors"]:
-    try: print(f"{p}=={version(p)}")
-    except PackageNotFoundError: pass
-EOF
-CONS="-c $P3DM_HOME/constraints.txt"
-
-# ------------------------------------------------------------------ pip deps
-log "installing python dependencies (native env, constrained)"
-pip install -q $CONS omegaconf opencv-python tensorboard wandb scikit-image pyvista \
-  dreifus h5py pytorch_lightning mediapy ninja insightface onnxruntime loguru yacs \
-  distinctipy validators timm tyro environs gdown face-alignment trimesh
-
-# pytorch3d: prebuilt wheel matching the local torch (MiroPsota builds), else source build
-if ! python3 -c "import pytorch3d" 2>/dev/null; then
-  log "installing pytorch3d (prebuilt wheel)"
-  PT=$(python3 -c "import torch; print(torch.__version__.split('+')[0])")
-  CU=$(python3 -c "import torch; print('cu'+torch.version.cuda.replace('.',''))")
-  pip install -q $CONS "pytorch3d==0.7.9+pt${PT}${CU}" \
-    -f https://miropsota.github.io/torch_packages_builder/pytorch3d/ \
-    || { log "no prebuilt wheel for pt${PT}${CU}, building from source (slow)"; \
-         pip install -q $CONS --no-build-isolation "git+https://github.com/facebookresearch/pytorch3d.git@stable"; }
-fi
-
-# nvdiffrast (compiles CUDA kernels lazily at first use)
-python3 -c "import nvdiffrast" 2>/dev/null || {
-  log "installing nvdiffrast"
-  pip install -q $CONS --no-build-isolation "git+https://github.com/NVlabs/nvdiffrast.git"
-}
-
-# chumpy: only needed to unpickle FLAME. Needs patching for py>=3.11 / numpy>=2.
-if ! python3 -c "import chumpy" 2>/dev/null; then
-  log "installing + patching chumpy for py3.12/numpy2"
-  pip install -q --no-deps --no-build-isolation chumpy || pip install -q --no-deps --no-build-isolation chumpy
-  CHDIR=$(python3 -c "import importlib.util,os; print(os.path.dirname(importlib.util.find_spec('chumpy').origin))")
-  grep -rl "inspect.getargspec" "$CHDIR"/*.py | xargs -r sed -i "s/inspect\.getargspec/inspect.getfullargspec/g"
-  sed -i "s/^from numpy import bool, int, float, complex, object, unicode, str, nan, inf$/from numpy import nan, inf/" "$CHDIR/__init__.py"
-  python3 -c "import chumpy" || { echo "chumpy patch failed"; exit 1; }
-fi
-
-# ------------------------------------------------------------------ pixel3dmm
-if [ ! -d "$REPO" ]; then
-  log "cloning pixel3dmm"
-  git clone --depth 1 https://github.com/SimonGiebenhain/pixel3dmm.git "$REPO"
-fi
-pip show pixel3dmm >/dev/null 2>&1 || (cd "$REPO" && pip install -q -e . --no-deps)
-
-# env paths config
-mkdir -p ~/.config/pixel3dmm
-cat > ~/.config/pixel3dmm/.env <<EOF
-PIXEL3DMM_CODE_BASE="$REPO"
-PIXEL3DMM_PREPROCESSED_DATA="$P3DM_HOME/preprocessed"
-PIXEL3DMM_TRACKING_OUTPUT="$P3DM_HOME/tracking_output"
-EOF
-
-# ------------------------------------------------- preprocessing repos + patches
-cd "$PP"
-if [ ! -d facer ]; then
-  log "cloning facer"
-  git clone --depth 1 https://github.com/FacePerceiver/facer.git
-  cp replacement_code/farl.py facer/facer/face_parsing/farl.py
-  cp replacement_code/facer_transform.py facer/facer/transform.py
-fi
-pip show pyfacer >/dev/null 2>&1 || (cd facer && pip install -q -e . --no-deps)
-
-if [ ! -d MICA ]; then
-  log "cloning MICA"
-  git clone --depth 1 https://github.com/Zielon/MICA.git
-  cp replacement_code/mica_demo.py MICA/demo.py
-  cp replacement_code/mica.py MICA/micalib/models/mica.py
-fi
-
-if [ ! -d PIPNet ]; then
-  log "cloning PIPNet"
-  git clone --depth 1 https://github.com/jhb86253817/PIPNet.git
-fi
-
-log "applying py3.12 / numpy2 / scipy compat patches"
-# scipy renamed simps -> simpson
-grep -rl "from scipy.integrate import simps$" PIPNet/lib 2>/dev/null | \
-  xargs -r sed -i "s/from scipy.integrate import simps$/from scipy.integrate import simpson as simps/"
-# numpy 2 removed aliases (MICA + pixel3dmm)
-grep -rlE "np\.(Inf|float\b|int\b|bool\b|object\b|NaN)" --include=*.py MICA "$REPO/src/pixel3dmm/utils" | \
-  xargs -r sed -i -E "s/np\.Inf/np.inf/g; s/np\.NaN/np.nan/g; s/np\.float\b/np.float64/g; s/np\.int\b/np.int64/g; s/np\.bool\b/bool/g; s/np\.object\b/object/g"
-# let FaceBoxes auto-downscale large images (fixes missed detections on
-# high-res headshots where the face fills the frame) and map coords back
-sed -i "s|detections, _ = detector.detect(image, my_thresh, 1)|detections, _p3dm_s = detector.detect(image, my_thresh, None); detections = [[d[0], d[1], int(d[2]/_p3dm_s), int(d[3]/_p3dm_s), int(d[4]/_p3dm_s), int(d[5]/_p3dm_s)] for d in detections]|" \
-  "$REPO/src/pixel3dmm/preprocessing/pipnet_utils.py"
-# save un-quantized float32 .npy next to the 8-bit PNG network predictions
-REPO_PATH="$REPO" python3 - <<'PYEOF'
-import os
-path = os.environ["REPO_PATH"] + "/scripts/network_inference.py"
-src = open(path).read()
-anchor = "                            f'{out_folders[prediction_type]}/{image_names[i][:-4]}.png')\n"
-patch = anchor + """
-                        # also dump the un-quantized prediction (same [0,1] convention as the PNG)
-                        np.save(f'{out_folders[prediction_type]}/{image_names[i][:-4]}.npy',
-                                tmp_output.permute(1, 2, 0).detach().cpu().float().numpy())
-"""
-if "un-quantized prediction" not in src:
-    assert anchor in src, "network_inference.py anchor not found"
-    src = src.replace(anchor, patch)
-    # skip-if-done check must account for the extra .npy per image
-    old_skip = """        if os.path.exists(out_folders[prediction_type]):
-            if len(os.listdir(out_folders[prediction_type])) == len(image_names):
-                return"""
-    new_skip = """        if os.path.exists(out_folders[prediction_type]):
-            _done = os.listdir(out_folders[prediction_type])
-            if all(f[:-4] + '.png' in _done and f[:-4] + '.npy' in _done for f in image_names):
-                return"""
-    assert old_skip in src, "network_inference.py skip anchor not found"
-    src = src.replace(old_skip, new_skip)
-    open(path, "w").write(src)
-PYEOF
-# replace PIPNet's Cython nms (does not build with Cython>=3) with pure numpy
-cat > PIPNet/FaceBoxesV2/utils/nms_wrapper.py <<'PYEOF'
-# Pure-numpy NMS replacement for the original Cython extension.
-import numpy as np
-
-
-def nms(dets, thresh):
-    if dets.shape[0] == 0:
-        return []
-    x1, y1, x2, y2, scores = dets[:, 0], dets[:, 1], dets[:, 2], dets[:, 3], dets[:, 4]
-    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    order = scores.argsort()[::-1]
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(int(i))
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-        w = np.maximum(0.0, xx2 - xx1 + 1)
-        h = np.maximum(0.0, yy2 - yy1 + 1)
-        inter = w * h
-        ovr = inter / (areas[i] + areas[order[1:]] - inter)
-        inds = np.where(ovr <= thresh)[0]
-        order = order[inds + 1]
-    return keep
-PYEOF
-
-# ------------------------------------------------------------------ FLAME assets
-FLAME_DIR="$PP/MICA/data"
-if [ ! -f "$FLAME_DIR/FLAME2020/generic_model.pkl" ]; then
-  log "downloading FLAME 2020+2023 (requires FLAME account)"
-  if [ -z "${FLAME_USERNAME:-}" ]; then read -rp "FLAME username: " FLAME_USERNAME; fi
-  if [ -z "${FLAME_PASSWORD:-}" ]; then read -rsp "FLAME password: " FLAME_PASSWORD; echo; fi
-  urle () { local LANG=C i x; for (( i = 0; i < ${#1}; i++ )); do x="${1:i:1}"; [[ "${x}" == [a-zA-Z0-9.~-] ]] && echo -n "${x}" || printf '%%%02X' "'${x}"; done; }
-  U=$(urle "$FLAME_USERNAME"); P=$(urle "$FLAME_PASSWORD")
-  mkdir -p "$FLAME_DIR/FLAME2020" "$FLAME_DIR/FLAME2023"
-  wget -q --post-data "username=$U&password=$P" 'https://download.is.tue.mpg.de/download.php?domain=flame&sfile=FLAME2020.zip&resume=1' -O "$FLAME_DIR/FLAME2020.zip" --no-check-certificate --continue
-  wget -q --post-data "username=$U&password=$P" 'https://download.is.tue.mpg.de/download.php?domain=flame&sfile=FLAME2023.zip&resume=1' -O "$FLAME_DIR/FLAME2023.zip" --no-check-certificate --continue
-  unzip -o -q "$FLAME_DIR/FLAME2020.zip" -d "$FLAME_DIR/FLAME2020/"
-  unzip -o -q "$FLAME_DIR/FLAME2023.zip" -d "$FLAME_DIR/FLAME2023/"
-  rm -f "$FLAME_DIR/FLAME2020.zip" "$FLAME_DIR/FLAME2023.zip"
-  # the zips nest one level deeper than the code expects -> flatten
-  [ -d "$FLAME_DIR/FLAME2020/FLAME2020" ] && mv "$FLAME_DIR/FLAME2020/FLAME2020/"* "$FLAME_DIR/FLAME2020/" && rmdir "$FLAME_DIR/FLAME2020/FLAME2020"
-  [ -d "$FLAME_DIR/FLAME2023/FLAME2023" ] && mv "$FLAME_DIR/FLAME2023/FLAME2023/"* "$FLAME_DIR/FLAME2023/" && rmdir "$FLAME_DIR/FLAME2023/FLAME2023"
-  [ -f "$FLAME_DIR/FLAME2020/generic_model.pkl" ] || { echo "FLAME download failed (bad credentials?)"; exit 1; }
-fi
-
-# ------------------------------------------------------------- model weights
-dl () { # dl <gdrive-id> <dest>
-  if [ ! -s "$2" ]; then log "downloading $(basename "$2")"; mkdir -p "$(dirname "$2")"; gdown "$1" -O "$2" -q; fi
-  [ -s "$2" ] || { echo "download failed: $2"; exit 1; }
-}
-dl 1SDV_8_qWTe__rX_8e4Fi-BE3aES0YzJY "$REPO/pretrained_weights/uv.ckpt"
-dl 1KYYlpN-KGrYMVcAOT22NkVQC0UAfycMD "$REPO/pretrained_weights/normals.ckpt"
-dl 1bYsI_spptzyuFmfLYqYkcJA6GZWZViNt "$PP/MICA/data/pretrained/mica.tar"
-dl 1nVkaSbxy3NeqblwMTGvLg4nF49cI_99C "$PP/PIPNet/snapshots/WFLW/pip_32_16_60_r18_l2_l1_10_1_nb10/epoch59.pth"
-
-# insightface detection/recognition models (hosted on gdrive per MICA install)
-mkdir -p ~/.insightface/models
-if [ ! -d ~/.insightface/models/antelopev2/antelopev2 ] && [ ! -f ~/.insightface/models/antelopev2/glintr100.onnx ]; then
-  dl 16PWKI_RjjbE4_kqpElG-YFqe8FpXjads ~/.insightface/models/antelopev2.zip
-  unzip -o -q ~/.insightface/models/antelopev2.zip -d ~/.insightface/models/antelopev2 && rm ~/.insightface/models/antelopev2.zip
-fi
-if [ ! -d ~/.insightface/models/buffalo_l/buffalo_l ] && [ ! -f ~/.insightface/models/buffalo_l/det_10g.onnx ]; then
-  dl 1navJMy0DTr1_DHjLWu1i48owCPvXWfYc ~/.insightface/models/buffalo_l.zip
-  unzip -o -q ~/.insightface/models/buffalo_l.zip -d ~/.insightface/models/buffalo_l && rm ~/.insightface/models/buffalo_l.zip
-fi
-
-# ------------------------------------------------------------------ verify
-log "verifying imports"
-python3 - <<'EOF'
-import pytorch3d, nvdiffrast, chumpy, insightface, facer, pixel3dmm
-from pixel3dmm import env_paths
-import os
-for f in [env_paths.CKPT_UV_PRED, env_paths.CKPT_N_PRED,
-          env_paths.FLAME_ASSETS + '/FLAME2020/generic_model.pkl',
-          env_paths.FLAME_ASSETS + '/pretrained/mica.tar']:
-    assert os.path.getsize(f) > 0, f
-print("  all good")
-EOF
-
-log "install complete. run:  ./p3dm_run.sh <photo.jpg>"

p3dm/p3dm_run.sh

@@ -1,100 +0,0 @@
-#!/usr/bin/env bash
-# =============================================================================
-# p3dm_run.sh — single photo in -> 3D FLAME head mesh out (Pixel3DMM)
-#
-# Usage:
-#   ./p3dm_run.sh <photo.(jpg|png)> [-o <output_dir>] [--iters N] [--force]
-#
-#   -o DIR     output directory        (default: /workspace/outputs/<name>)
-#   --iters N  fitting iterations      (default: 800, per-paper single-image)
-#   --force    redo preprocessing/fit even if cached results exist
-#
-# Outputs (in <output_dir>):
-#   <name>.ply            posed 3D head mesh (FLAME topology)
-#   <name>_canonical.ply  canonical (neutral-pose) mesh
-#   <name>_overlay.mp4    input vs. fitted-mesh render comparison
-#   <name>_normals.png    predicted screen-space normals
-#   <name>_uv.png         predicted uv correspondence map
-#   <name>_crop.jpg       the face crop that was fitted
-#
-# Requires p3dm_install.sh to have been run first.
-# =============================================================================
-set -euo pipefail
-
-P3DM_HOME="${P3DM_HOME:-/workspace/p3dm}"
-REPO="$P3DM_HOME/pixel3dmm"
-
-IMG="" ; OUT="" ; ITERS=800 ; FORCE=0
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -o)      OUT="$2"; shift 2;;
-    --iters) ITERS="$2"; shift 2;;
-    --force) FORCE=1; shift;;
-    -h|--help) grep '^#' "$0" | sed 's/^# \{0,1\}//'; exit 0;;
-    *)       IMG="$1"; shift;;
-  esac
-done
-[ -n "$IMG" ] && [ -f "$IMG" ] || { echo "usage: $0 <photo.jpg> [-o outdir] [--iters N] [--force]"; exit 1; }
-[ -d "$REPO" ] || { echo "pixel3dmm not installed - run p3dm_install.sh first"; exit 1; }
-
-# sanitized job name from the file stem (pixel3dmm uses it as an identifier)
-STEM="$(basename "$IMG")"; STEM="${STEM%.*}"
-NAME="$(echo "$STEM" | tr -c 'a-zA-Z0-9' '_' | sed 's/_*$//;s/^_*//' | cut -c1-60)"
-OUT="${OUT:-/workspace/outputs/$NAME}"
-
-export TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD=1   # repo predates torch>=2.6 weights_only default
-if [ -z "${TORCH_CUDA_ARCH_LIST:-}" ]; then
-  export TORCH_CUDA_ARCH_LIST="$(python3 -c "import torch; print('%d.%d+PTX' % torch.cuda.get_device_capability())")"
-fi
-
-log() { echo -e "\033[1;35m[p3dm]\033[0m $*"; }
-T0=$(date +%s)
-
-# stage the photo in a folder named after the job (pipeline expects a folder or video)
-STAGE="$P3DM_HOME/staging/$NAME"
-PRE="$P3DM_HOME/preprocessed/$NAME"
-if [ "$FORCE" = 1 ]; then rm -rf "$STAGE" "$PRE" "$P3DM_HOME/tracking_output/${NAME}_nV"*; fi
-mkdir -p "$STAGE"
-cp -f "$IMG" "$STAGE/$NAME.${IMG##*.}"
-
-cd "$REPO"
-log "1/4 preprocessing (crop, landmarks, segmentation, MICA)"
-python3 scripts/run_preprocessing.py --video_or_images_path "$STAGE" > /dev/null 2>&1 \
-  || { echo "preprocessing failed, rerunning verbosely:"; python3 scripts/run_preprocessing.py --video_or_images_path "$STAGE"; exit 1; }
-[ -d "$PRE/cropped" ] || { echo "ERROR: no face detected / cropping failed for $IMG"; exit 1; }
-
-log "2/4 normals prediction"
-python3 scripts/network_inference.py model.prediction_type=normals video_name="$NAME" > /dev/null 2>&1 \
-  || { python3 scripts/network_inference.py model.prediction_type=normals video_name="$NAME"; exit 1; }
-
-log "3/4 uv-map prediction"
-python3 scripts/network_inference.py model.prediction_type=uv_map video_name="$NAME" > /dev/null 2>&1 \
-  || { python3 scripts/network_inference.py model.prediction_type=uv_map video_name="$NAME"; exit 1; }
-
-log "4/4 FLAME fitting ($ITERS iters)"
-python3 scripts/track.py video_name="$NAME" iters="$ITERS" 2>&1 | grep -E "DONE|Error|Traceback" || true
-
-TRACK_DIR="$(ls -td "$P3DM_HOME/tracking_output/${NAME}_nV"*/ 2>/dev/null | head -1)"
-[ -n "$TRACK_DIR" ] && [ -f "$TRACK_DIR/mesh/00000.ply" ] || { echo "ERROR: tracking produced no mesh"; exit 1; }
-
-mkdir -p "$OUT"
-cp "$TRACK_DIR/mesh/00000.ply"      "$OUT/$NAME.ply"
-cp "$TRACK_DIR/mesh/canonical.ply"  "$OUT/${NAME}_canonical.ply"
-[ -f "$TRACK_DIR/result.mp4" ] && cp "$TRACK_DIR/result.mp4" "$OUT/${NAME}_overlay.mp4"
-cp "$PRE/p3dmm/normals/00000.png"   "$OUT/${NAME}_normals.png" 2>/dev/null || true
-cp "$PRE/p3dmm/uv_map/00000.png"    "$OUT/${NAME}_uv.png"      2>/dev/null || true
-CROP=$(ls "$PRE/cropped/" | head -1); cp "$PRE/cropped/$CROP" "$OUT/${NAME}_crop.${CROP##*.}" 2>/dev/null || true
-
-# raw fitting + preprocessing data (FLAME params, fitted camera, float preds,
-# crop transform, segmentation, landmarks) for downstream use
-mkdir -p "$OUT/raw"
-cp "$TRACK_DIR/checkpoint/00000.frame"    "$OUT/raw/${NAME}.frame"
-cp "$PRE/p3dmm/normals/00000.npy"         "$OUT/raw/${NAME}_normals.npy"      2>/dev/null || true
-cp "$PRE/p3dmm/uv_map/00000.npy"          "$OUT/raw/${NAME}_uv.npy"           2>/dev/null || true
-cp "$PRE/crop_ymin_ymax_xmin_xmax.npy"    "$OUT/raw/${NAME}_cropbox.npy"      2>/dev/null || true
-cp "$PRE/seg_og/00000.png"                "$OUT/raw/${NAME}_seg.png"          2>/dev/null || true
-cp "$PRE/PIPnet_landmarks/00000.npy"      "$OUT/raw/${NAME}_landmarks.npy"    2>/dev/null || true
-cp "$PRE/mica/00000/identity.npy"         "$OUT/raw/${NAME}_mica_identity.npy" 2>/dev/null || true
-
-log "done in $(( $(date +%s) - T0 ))s -> $OUT"
-ls -la "$OUT"