3D Gaussian Splatting pour le rendu de champs de radiance en temps réel

Guide de lecture

Problème et motivation

Les champs de radiance neuronaux (NeRFs) ont transformé la synthèse de nouvelles vues en optimisant des représentations continues implicites de scènes à l'aide de perceptrons multicouches (MLPs). Cependant, le rendu de ces champs continus repose sur un ray-marching volumétrique stochastique, qui exige l'évaluation de dizaines ou de centaines d'échantillons par rayon. Cela engendre de lourdes charges de calcul, des temps d'entraînement prolongés (par exemple, jusqu'à 48 heures pour Mip-NeRF360) et des vitesses d'inférence très lentes (plusieurs secondes par image), empêchant toute navigation en temps réel à des résolutions élevées telles que le 1080p.

Bien que des variantes plus rapides de champs de radiance (telles que Plenoxels et InstantNGP) s'appuient sur des grilles de voxels ou de hachage pour accélérer l'entraînement, elles font souvent des compromis sur la fidélité visuelle et peinent à gérer l'espace vide ou les détails à haute fréquence. À l'inverse, les approches basées sur des points offrent une géométrie explicite bien adaptée aux GPU, mais la rastérisation traditionnelle de points requiert une géométrie stéréo multi-vues (MVS) dense pour éviter les trous, ou dépend d'un post-traitement par CNN qui introduit des scintillements temporels.

Cet article propose une représentation de scène non structurée et explicite utilisant des gaussiennes 3D couplées à un rastériseur rapide par blocs, atteignant la fidélité de rendu des meilleurs champs de radiance implicites tout en garantissant des fréquences d'images en temps réel et des temps d'optimisation compétitifs.

Idées clés

1. Représentation non structurée par gaussiennes 3D : Au lieu de réseaux de coordonnées continues ou de grilles denses, le champ de radiance est paramétré par des gaussiennes 3D discrètes dotées de matrices de covariance anisotropes complètes, initialisées à partir de nuages de points épars issus de Structure-from-Motion (SfM) sans nécessiter de normales ni de MVS dense.
2. Paramétrisation par échelle et rotation : Pour garantir que la matrice de covariance reste semi-définie positive tout au long de la descente de gradient, elle est découplée en un vecteur d'échelle 3D et un quaternion unitaire.
3. Contrôle adaptatif de la densité : L'optimisation gère dynamiquement la densité de la scène en suivant les gradients de position dans l'espace vue : en clonant les gaussiennes sous-reconstruites et en divisant les gaussiennes sur-reconstruites, tout en élaguant les splats transparents ou excessivement grands.
4. Rastérisation par blocs consciente de la visibilité : Un rastériseur GPU sur mesure organise les pixels de l'écran en blocs de $16\times 16$, trie les splats en profondeur par trame à l'aide d'un tri Radix rapide, et effectue un mélange alpha de projections anisotropes d'avant en arrière sans restreindre le nombre de splats recevant des mises à jour de gradient.

Méthode

1. Représentation de scène par gaussiennes 3D

Une gaussienne 3D centrée sur la moyenne $\mu$ est définie par sa matrice de covariance $\Sigma$ dans l'espace monde : $$G(x)=e^{-\frac{1}{2}(x-\mu {)}^T{\Sigma }^{-1}(x-\mu )}$$

Pour garantir que $\Sigma$ reste semi-définie positive pendant l'optimisation, elle est factorisée en une matrice de rotation $R$ et une matrice d'échelle $S$ : $$\Sigma =RS{S}^T{R}^T$$ Ici, $S$ est stocké sous la forme d'un vecteur 3D $s$ évalué avec une activation exponentielle, et $R$ est paramétré par un quaternion unitaire normalisé $q$.

Pour le rendu, les gaussiennes 3D sont projetées vers les coordonnées 2D de l'image selon le cadre du splatting EWA. Étant donné une transformation de vue $W$ et le jacobien $J$ de l'approximation affine de la transformation projective, la matrice de covariance 2D ${\Sigma }^{\prime }$ dans l'espace écran est : $${\Sigma }^{\prime }=JW\Sigma W^T{J}^T$$ La troisième ligne et la troisième colonne sont supprimées, produisant une matrice de covariance $2\times 2$ pour le splatting planaire.

2. Rendu et formation de l'image

Chaque gaussienne possède une opacité $\alpha$ (contrainte dans $[0,1)$ via une activation sigmoïde) et des coefficients d'harmoniques sphériques (SH) décrivant la couleur dépendante de la vue $\mathbf{c}$. Le mélange de $N$ gaussiennes superposées et ordonnées au niveau d'un pixel suit la formulation volumétrique standard : $$C=\sum _{i\in \mathcal{N}}{\mathbf{c}}_i{\alpha }_i\prod _{j=1}^{i-1}(1-{\alpha }_j)$$ où ${\alpha }_i$ est déterminé en évaluant la gaussienne projetée en 2D multipliée par l'opacité apprise par point.

3. Optimisation et contrôle adaptatif

La fonction de perte combine une perte ${\mathcal{L}}_1$ avec une perte D-SSIM (avec $\lambda =0,2$) : $$\mathcal{L}=(1-\lambda ){\mathcal{L}}_1+\lambda {\mathcal{L}}_{\text{D-SSIM}}$$

Le contrôle adaptatif de la densité s'exécute toutes les 100 itérations sur les gaussiennes dont le gradient moyen de position dans l'espace vue dépasse ${\tau }_{\text{pos}}=0,0002$ :

• Clonage (sous-reconstruction) : Pour les petites gaussiennes, un duplicata est créé et déplacé le long de la direction du gradient de position.
• Division (sur-reconstruction) : Pour les grandes gaussiennes, la primitive est remplacée par deux gaussiennes plus petites dont les échelles sont réduites d'un facteur $\varphi =1,6$, en échantillonnant leurs positions initiales à partir de la gaussienne parente.
• Élagage : Élimine les gaussiennes où $\alpha <{ϵ}_{\alpha }$ ou celles qui sont excessivement grandes dans l'espace monde/vue. Toutes les $N=3000$ itérations, les opacités sont réinitialisées près de zéro pour éliminer les artefacts flottants.

4. Rastériseur par blocs différentiable et rapide

• L'écran est divisé en blocs de $16\times 16$ pixels.
• Les gaussiennes franchissant le frustum culling à un intervalle de confiance de 99 % se voient attribuer des clés de 64 bits codant l'identifiant du bloc et la profondeur dans l'espace vue.
• Un unique tri Radix sur GPU ordonne toutes les instances à l'échelle de l'image.
• Les blocs de threads accumulent la couleur par bloc d'avant en arrière jusqu'à ce que $\alpha$ atteigne la saturation (arrêt avant de dépasser $0,9999$).
• La passe arrière parcourt les blocs d'arrière en avant, récupérant les opacités intermédiaires en divisant l'opacité accumulée finale par l'$\alpha$ de chaque primitive, évitant ainsi des tampons mémoire dynamiques coûteux par pixel.

Résultats

• Jeu de données Mip-NeRF360 : Après 30K itérations (temps d'entraînement moyen de 41 min 33 s), 3D Gaussian Splatting atteint une moyenne de SSIM de 0,815, un PSNR de 27,21 dB et un LPIPS de 0,214, égalant ou surpassant Mip-NeRF360 (SSIM 0,792, PSNR 27,69 dB, LPIPS 0,237, 48 heures d'entraînement), tout en rendant à 134 FPS contre 0,06 FPS pour Mip-NeRF360.
• Configuration rapide (7K itérations) : Offre un SSIM de 0,770 et un PSNR de 25,60 dB en seulement 6 min 25 s à 160 FPS, surpassant InstantNGP-Base (SSIM 0,671, 11,7 FPS) et Plenoxels (SSIM 0,626, 6,79 FPS) pour des temps d'entraînement comparables.
• Tanks&Temples & Deep Blending : Sur Tanks&Temples, 30K itérations atteignent un SSIM de 0,841 et un PSNR de 23,14 dB à 154 FPS. Sur Deep Blending, la méthode atteint un SSIM de 0,903 et un PSNR de 29,41 dB à 137 FPS.
• Synthetic Blender : Obtient un PSNR moyen de 33,32 dB à partir d'une initialisation entièrement aléatoire de 100K points, avec un rendu à 180–300 FPS.

Limites et questions ouvertes

• Vues non observées et valeurs aberrantes : Une couverture clairsemée ou des angles de vue éloignés des trajectoires d'entraînement peuvent produire des artefacts visibles, tels que des gaussiennes étirées ou formant des taches.
• Artefacts de sautillement (popping) : Des changements brusques dans l'ordonnancement en profondeur ou un élagage strict aux bordures d'écran peuvent introduire des sautillements lors de la navigation, soulignant la nécessité d'un meilleur anticrénelage.
• Consommation de mémoire : Bien que compacte par rapport aux nuages de points denses classiques, cette représentation explicite nécessite plusieurs centaines de mégaoctets (ex. : 400 à 750 Mo pour des scènes comptant 1 à 5 millions de gaussiennes), et l'entraînement de prototypes non optimisés peut faire grimper la mémoire GPU au-delà de 20 Go.
• Absence de régularisation : Le cadre n'inclut pas de régularisateurs explicites de lissage géométrique ou de densité, laissant place à des artefacts flottants d'arrière-plan dans les régions peu contraintes par les rayons des caméras.