makeup-extract: install + run scripts for Makeup Extraction of 3D Representation (EG2023) (single photo -> FLAME UV materials + extracted makeup layers)

makeup-extract/README.md

@@ -0,0 +1,102 @@
+# 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

@@ -0,0 +1,227 @@
+#!/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

@@ -0,0 +1,127 @@
+#!/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"