Como Criar um Avatar 4D Animável a Partir de Algumas Fotos Usando CAP4D

Criar cabeças 3D controláveis a partir de uma ou mais fotos geralmente esbarra no mesmo problema. Ou você obtém uma máscara plana sem a parte de trás da cabeça e geometria adequada, ou precisa de um estúdio com vinte câmeras sincronizadas para treinar a rede neural.

Há alguns dias, encontrei o repositório CAP4D de pesquisadores da Universidade de Toronto e LG Electronics, aceito no CVPR 2025. Os autores lançaram um pipeline que recebe um conjunto arbitrário de fotos ou um vídeo curto de uma câmera monocular e constrói um avatar 4D totalmente animável baseado em 3D Gaussian Splatting.

Como funciona por baixo dos panos

Se analisarmos a arquitetura, o pipeline consiste em quatro etapas:

1. Rastreamento facial via FLAME. O script processa os frames de origem através de uma ferramenta de rastreamento 3D (Pixel3DMM ou a próxima FlowFace), ajustando os parâmetros da cabeça ao modelo paramétrico FLAME.
2. Difusão Multi-Vista (MMDM). Aqui os autores usaram Stable Diffusion e ControlNet, refinando-os para gerar visualizações consistentes da cabeça em diferentes expressões faciais e poses. A rede de difusão literalmente "completa" o rosto em ângulos que não estavam presentes nas fotos originais.
3. Treinamento Gaussiano (Gaussian Splatting). Uma representação baseada em GaussianAvatars é treinada nas imagens geradas e de origem. Os gaussianos são vinculados à malha poligonal FLAME, proporcionando geometria estável durante as deformações.
4. Animação e exportação PLY. O avatar finalizado pode ser controlado por parâmetros de arquivos existentes ou transferir expressões faciais de qualquer outro vídeo. O resultado é exportado para um arquivo .ply que abre diretamente no navegador através do motor Brush.

Instalação e primeiros obstáculos

O README descreve a configuração padrão do ambiente Conda, mas há alguns pontos onde é fácil tropeçar:

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

Em seguida, você precisa compilar manualmente o PyTorch3D com suporte a CUDA:

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

Para trabalhar com o modelo paramétrico, você precisa se registrar no site do FLAME (gratuito para uso não comercial) e configurar variáveis de 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 o script de download falhar devido a problemas de versão do NumPy, o repositório gentilmente fornece um utilitário scripts/fixes/fix_flame_pickle.py.

Teste rápido em personagens prontos

Para verificar se todos os kernels CUDA e bibliotecas estão instalados corretamente, os autores adicionaram um teste:

bash scripts/test_pipeline.sh

Se um vídeo de Nikola Tesla renderiza em examples/debug_output/, seu ambiente está configurado corretamente. Em seguida, você pode compilar os exemplos prontos (Tesla, Lincoln ou o autor do repositório Felix):

bash scripts/generate_tesla.sh

O script irá gerar um arquivo de animação exported_animation.ply. Você pode carregá-lo no visualizador web deles no GitHub Pages e girar a câmera com o mouse diretamente na janela do navegador a 60 FPS.

Executando com seus próprios dados

Quando quiser dar vida ao seu próprio rosto ou um personagem de vídeo, o processo é um pouco mais complexo. Você precisará do repositório Pixel3DMM para rastreamento monocular:

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

Em seguida, execute o rastreamento na pasta com as fotos e o vídeo alvo do qual as expressões são extraídas:

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

Gere visualizações sintéticas com o modelo de difusão:

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/

Ajuste os gaussianos à 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

Para quem não quer chamar as etapas individualmente, os autores empacotaram todo o pipeline em um único script bash:

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

Hardware e pegadinhas

O pipeline é intensivo em recursos. A etapa MMDM utiliza toda a GPU disponível, consome uma quantidade considerável de VRAM e requer 64 GB de RAM. Em uma única GPU de consumidor, a geração de imagens pode levar algumas horas.

A segunda nuance está relacionada ao rastreamento. Atualmente, o script principal depende do Pixel3DMM de terceiros, que às vezes falha em ângulos complexos. Os autores treinaram seus pesos de difusão com anotações do FlowFace, mas o módulo FlowFace em si deve ser lançado no repositório em breve. Por isso, gerações personalizadas podem parecer ligeiramente menos nítidas do que as demos oficiais.

Para quem este projeto é

Se você está trabalhando com renderização neural, avatares digitais para jogos, animação para projetos indie ou apenas explorando 3D Gaussian Splatting, o código CAP4D definitivamente vale a pena conferir. Ele demonstra bem como combinar difusão 2D com uma representação 3D através da malha paramétrica FLAME, contornando o problema de pontos de vista insuficientes.

Para começar rapidamente, recomendo primeiro brincar com os presets prontos do Lincoln e Tesla para avaliar o desempenho do renderizador web, e só então passar para construir pipelines personalizados no seu próprio conjunto de dados.