Zo bouw je een animeerbare 4D-avatar uit slechts enkele foto's met CAP4D

Het maken van bestuurbare 3D-hoofden uit één of meer foto's stuit meestal op hetzelfde probleem. Of je krijgt een plat masker zonder achterkant van het hoofd en correcte geometrie, of je hebt een studio met twintig gesynchroniseerde camera's nodig om het neurale netwerk te trainen.

Een paar dagen geleden stuitte ik op de CAP4D-repository van onderzoekers aan de University of Toronto en LG Electronics, geaccepteerd op CVPR 2025. De auteurs publiceerden een pipeline die een willekeurige set foto's of een korte video van een monoculaire camera gebruikt en een volledig animeerbare 4D-avatar bouwt op basis van 3D Gaussian Splatting.

Wat er onder de motorkap zit

Als we de architectuur opsplitsen, bestaat de pipeline uit vier fasen:

1. Gezichtstracking via FLAME. Het script voert bronframes door een 3D-trackingtool (Pixel3DMM of de aankomende FlowFace), waarbij hoofdparameters worden aangepast aan het FLAME-parametrische model.
2. Multi-View Diffusion (MMDM). Hier hebben de auteurs Stable Diffusion en ControlNet genomen en deze fijnafgestemd om consistente hoofdbeelden te genereren bij verschillende gezichtsuitdrukkingen en houdingen. Het diffusienetwerk "voltooit" letterlijk het gezicht op hoeken die niet aanwezig waren in de oorspronkelijke foto's.
3. Gaussian-training (Gaussian Splatting). Een representatie gebaseerd op GaussianAvatars wordt getraind op de gegenereerde en bronafbeeldingen. Gaussians zijn gebonden aan het FLAME-polygonale mesh, wat stabiele geometrie biedt tijdens vervormingen.
4. Animatie en PLY-export. De voltooide avatar kan worden aangestuurd door parameters uit bestaande bestanden of gezichtsuitdrukkingen overdragen vanuit elke andere video. Het resultaat wordt geëxporteerd naar een .ply-bestand dat rechtstreeks in de browser kan worden geopend via de Brush-engine.

Installatie en eerste struikelblokken

De README beschrijft een standaard Conda-omgeving setup, maar er zijn een paar plekken waar je gemakkelijk kunt struikelen:

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

Vervolgens moet je PyTorch3D handmatig bouwen met CUDA-ondersteuning:

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

Om met het parametrische model te werken, moet je je registreren op de FLAME-website (gratis voor niet-commercieel gebruik) en omgevingsvariabelen instellen:

export FLAME_USERNAME=your_flame_user_name
export FLAME_PWD=your_flame_password

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

Als het downloadscript faalt vanwege NumPy-versieproblemen, biedt de repository vriendelijk een scripts/fixes/fix_flame_pickle.py-hulpprogramma.

Snelle test op kant-en-klare personages

Om te verifiëren dat alle CUDA-kernels en bibliotheken correct zijn geïnstalleerd, hebben de auteurs een testrun toegevoegd:

bash scripts/test_pipeline.sh

Als een video van Nikola Tesla wordt weergegeven in examples/debug_output/, is je omgeving correct ingesteld. Vervolgens kun je de kant-en-klare voorbeelden bouwen (Tesla, Lincoln of de repositoryauteur Felix):

bash scripts/generate_tesla.sh

Het script zal een animatiebestand exported_animation.ply uitvoeren. Je kunt het uploaden naar hun webviewer op GitHub Pages en de camera met je muis direct in het browservenster draaien met 60 FPS.

Uitvoeren op je eigen data

Wanneer je je eigen gezicht of een personage uit video tot leven wilt wekken, is het proces iets gecompliceerder. Je hebt de Pixel3DMM-repository nodig voor monculaire tracking:

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

Vervolgens voer je tracking uit op de map met foto's en de doelvideo waaruit expressies worden geëxtraheerd:

# Трекинг исходных фотографий
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/

Genereer synthetische weergaven met het diffusiemodel:

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/

Pas Gaussians aan de geometrie aan:

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

Voor degenen die de stappen niet individueel willen aanroepen, hebben de auteurs de hele pipeline verpakt in één bash-script:

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

Hardware en valkuilen

De pipeline is resource-intensief. De MMDM-fase gebruikt alle beschikbare GPU, verbruikt een aanzienlijke hoeveelheid VRAM en vereist 64 GB RAM. Op één consumenten-GPU kan het genereren van afbeeldingen enkele uren duren.

De tweede nuance heeft te maken met tracking. Momenteel vertrouwt het hoofdcript op de externe Pixel3DMM, die soms faalt bij complexe hoeken. De auteurs hebben hun diffusiegewichten getraind met annotaties van FlowFace, maar de FlowFace-module zelf wordt binnenkort beloofd in de repository. Hierdoor kunnen aangepaste generaties er iets minder scherp uitzien dan de officiële demos.

Voor wie dit project bedoeld is

Als je werkt met neurale rendering, digitale avatars voor games, animatie voor indie-projecten, of gewoon 3D Gaussian Splatting verkent, is de CAP4D-code zeker de moeite waard om te bekijken. Het demonstreert mooi hoe je 2D-diffusie kunt combineren met een 3D-representatie via het strikte FLAME-parametrische mesh, waardoor het probleem van onvoldoende standpunten wordt omzeild.

Voor een snelle start raad ik aan om eerst te experimenteren met de kant-en-klare presets met Lincoln en Tesla om de webrendererprestaties te evalueren, en pas daarna over te gaan tot het bouwen van aangepaste pipelines op je eigen dataset.