Come Creare un Avatar 4D Animabile da un Paio di Foto Usando CAP4D

Creare teste 3D controllabili da una o più foto di solito si scontra con lo stesso problema. O ottieni una maschera piatta senza la parte posteriore della testa e una geometria corretta, oppure hai bisogno di uno studio con venti telecamere sincronizzate per addestrare la rete neurale.

Qualche giorno fa mi sono imbattuto nel repository CAP4D di ricercatori dell'Università di Toronto e LG Electronics, accettato al CVPR 2025. Gli autori hanno rilasciato una pipeline che prende un set arbitrario di foto o un breve video da una telecamera monoculare e costruisce un avatar 4D completamente animabile basato su 3D Gaussian Splatting.

Cosa c'è sotto il cofano

Se analizziamo l'architettura, la pipeline è composta da quattro fasi:

1. Face tracking tramite FLAME. Lo script elabora i frame sorgente attraverso uno strumento di tracking 3D (Pixel3DMM o il prossimo FlowFace), adattando i parametri della testa al modello parametrico FLAME.
2. Multi-View Diffusion (MMDM). Qui gli autori hanno preso Stable Diffusion e ControlNet, raffinandole per generare viste coerenti della testa attraverso diverse espressioni facciali e pose. La rete di diffusione letteralmente "completa" il volto ad angoli che non erano presenti nelle foto originali.
3. Training Gaussiano (Gaussian Splatting). Una rappresentazione basata su GaussianAvatars viene addestrata sulle immagini generate e sorgente. I Gaussian sono legati alla mesh poligonale FLAME, fornendo geometria stabile durante le deformazioni.
4. Animazione ed esportazione PLY. L'avatar finito può essere guidato da parametri da file esistenti o trasferire espressioni facciali da qualsiasi altro video. Il risultato viene esportato in un file .ply che si apre direttamente nel browser tramite il motore Brush.

Installazione e primi ostacoli

Il README descrive la configurazione standard dell'ambiente Conda, ma ci sono un paio di punti in cui è facile inciampare:

git clone https://github.com/felixtaubner/cap4d/
cd cap4d

conda create --name cap4d_env python=3.10
conda activate cap4d_env

pip install -r requirements.txt
export PYTHONPATH=$(realpath "./"):$PYTHONPATH

Successivamente, devi compilare manualmente PyTorch3D con supporto CUDA:

export FORCE_CUDA=1
pip install "git+https://github.com/facebookresearch/pytorch3d.git@stable"

Per lavorare con il modello parametrico, devi registrarti sul sito web FLAME (gratuito per uso non commerciale) e impostare le variabili d'ambiente:

export FLAME_USERNAME=your_flame_user_name
export FLAME_PWD=your_flame_password

bash scripts/download_flame.sh 
bash scripts/download_mmdm_weights.sh

Se lo script di download fallisce a causa di problemi di versione di NumPy, il repository fornisce gentilmente un'utilità scripts/fixes/fix_flame_pickle.py.

Test rapido su personaggi già pronti

Per verificare che tutti i kernel CUDA e le librerie siano correttamente installati, gli autori hanno aggiunto un test:

bash scripts/test_pipeline.sh

Se un video di Nikola Tesla viene renderizzato in examples/debug_output/, il tuo ambiente è configurato correttamente. Successivamente, puoi costruire gli esempi già pronti (Tesla, Lincoln, o l'autore del repository Felix):

bash scripts/generate_tesla.sh

Lo script produrrà un file di animazione exported_animation.ply. Puoi caricarlo sul loro visualizzatore web su GitHub Pages e ruotare la telecamera con il mouse direttamente nella finestra del browser a 60 FPS.

Esecuzione sui tuoi dati

Quando vuoi dare vita al tuo volto o a un personaggio da video, il processo è un po' più articolato. Avrai bisogno del repository Pixel3DMM per il tracking monoculare:

export PIXEL3DMM_PATH=$(realpath "../PATH/TO/pixel3dmm")
export CAP4D_PATH=$(realpath "./")
bash scripts/install_pixel3Dmm.sh

Successivamente, esegui il tracking sulla cartella con le foto e il video target da cui vengono estratte le espressioni:

# Трекинг исходных фотографий
bash scripts/track_video_pixel3dmm.sh examples/input/my_face/cam0/ examples/output/custom/reference_tracking/

# Трекинг видео-драйвера с движениями
bash scripts/track_video_pixel3dmm.sh examples/input/animation/driving.mp4 examples/output/custom/driving_video_tracking/

Genera viste sintetiche con il modello di diffusione:

python cap4d/inference/generate_images.py \
  --config_path configs/generation/default.yaml \
  --reference_data_path examples/output/custom/reference_tracking/ \
  --output_path examples/output/custom/mmdm/

Adatta i Gaussian alla geometria:

python gaussianavatars/train.py \
  --config_path configs/avatar/default.yaml \
  --source_paths examples/output/custom/mmdm/reference_images/ examples/output/custom/mmdm/generated_images/ \
  --model_path examples/output/custom/avatar/ \
  --interval 5000

Per chi non vuole chiamare i passaggi individualmente, gli autori hanno impacchettato l'intera pipeline in un singolo script bash:

bash scripts/generate_avatar.sh examples/input/my_face/cam0/ examples/output/my_avatar/ default examples/input/animation/driving.mp4

Hardware e insidie

La pipeline richiede molte risorse. La fase MMDM utilizza tutte le GPU disponibili, consuma una buona quantità di VRAM e richiede 64 GB di RAM. Su una singola GPU consumer, la generazione delle immagini può richiedere un paio d'ore.

La seconda sfumatura è legata al tracking. Attualmente, lo script principale si basa su Pixel3DMM di terze parti, che a volte fallisce su angoli complessi. Gli autori hanno addestrato i pesi di diffusione con annotazioni da FlowFace, ma il modulo FlowFace stesso dovrebbe essere rilasciato nel repository a breve. Per questo motivo, le generazioni personalizzate potrebbero apparire leggermente meno nitide dei demo ufficiali.

A chi serve questo progetto

Se stai lavorando su neural rendering, avatar digitali per giochi, animazione per progetti indie, o semplicemente esplorando 3D Gaussian Splatting, il codice CAP4D vale sicuramente la pena di essere controllato. Dimostra elegantemente come combinare diffusione 2D con una rappresentazione 3D attraverso la rigida mesh parametrica FLAME, bypassando il problema dei punti di vista insufficienti.

Per un avvio rapido, ti consiglio di giocare prima con i preset già pronti con Lincoln e Tesla per valutare le prestazioni del web renderer, e solo successivamente passare alla costruzione di pipeline personalizzate sul tuo dataset.