# 3D Gaussian Splatting : La Révolution du Rendu

> Comprendre et implémenter le 3D Gaussian Splatting avec Python. Tutoriel technique sur le pipeline SfM vers Splat, l'optimisation CUDA et le rendu temps réel.

- Adresse : https://fr.learngeodata.eu/blog/3d-gaussian-splatting-tutoriel
- Rubrique : Articles techniques
- Langue : fr
- Auteur : Dr. Florent Poux (https://fr.learngeodata.eu/formateur/florent-poux)
- Éditeur : 3D Geodata Academy (organisme de formation, France)
- Index du site pour les assistants : https://fr.learngeodata.eu/llms.txt
- Publié le 2025-12-18

---
## 1. La Théorie : Pourquoi des Gaussiennes ?

Contrairement aux voxels (discrets) ou aux maillages (rigides), une **Gaussienne 3D** est une primitive souple définie par :

- Une position moyenne (Mean) $\mu$
- Une matrice de covariance $\Sigma$ (décrivant l'étirement/rotation)
- Une opacité $\alpha$
- Une couleur dépendante de la vue (Harmoniques Sphériques)

Ce que contient une gaussienne 3D. Elle n'est pas un point : c'est une tache orientée, dont la forme, l'inclinaison, la transparence et la couleur sont toutes optimisées pendant l'entraînement. Cinquante-neuf valeurs par gaussienne, et plusieurs millions de gaussiennes par scène : c'est ce qui explique le poids des fichiers.

L'astuce de génie est la projection 2D (Splatting). On projette ces ellipsoïdes sur le plan image et on les trie (Depth Sort) pour alpha-blending. C'est ce tri + rasterisation qui est différentiable.

## 2. Initialisation : Le Rôle de COLMAP

Le 3DGS ne part pas de zéro. Il a besoin d'un nuage de points clairsemé (Sparse Point Cloud) généré par Structure-from-Motion (SfM). Ces points servent de centres initiaux pour les gaussiennes.

```
# Extraction de features et matching
colmap feature_extractor --database_path db.db --image_path images/
colmap exhaustive_matcher --database_path db.db

# Reconstruction sparse
colmap mapper --database_path db.db --image_path images/ --output_path sparse/
# Conversion text pour debug
colmap model_converter --input_path sparse/0 --output_path sparse/text --output_type TXT
```

## 3. La Boucle d'Entraînement (Optimization Loop)

Le "Learning" ici n'est pas un réseau de neurones (pas de MLP !). C'est une descente de gradient stochastique (SGD) directe sur les paramètres des gaussiennes. On compare l'image rendue à l'image réelle (Loss L1 + D-SSIM), et on backpropage l'erreur pour déplacer, grossir, ou changer la couleur des gaussiennes.

```
def training_step(iteration):
    # 1. Rasterisation Differentiable
    rendered_image = rasterizer(viewpoint_cam, pc)
    
    # 2. Calcul Loss
    gt_image = viewpoint_cam.original_image
    loss = (1.0 - lambda_dssim) * l1_loss(rendered_image, gt_image) + \
           lambda_dssim * (1.0 - ssim(rendered_image, gt_image))
           
    # 3. Backprop & Optimizer Step
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
    
    # 4. Densification (Adaptive Control)
    if iteration % densification_interval == 0:
        pc.densify_and_prune(grad_threshold, min_opacity, extent)
```

La **Densification** est clé : si une zone a une forte erreur de gradient (sous-reconstruite), on clone les gaussiennes (si petites) ou on les split (si trop grandes).

## 4. Compression et Export

Un modèle brut pèse lourd (2-4 Go). Pour le web, on quantifie les harmoniques sphériques et les quaternions de rotation. Un fichier `.ply` compressé peut descendre à 100 Mo.

| Attribut | Type Brut | Type Compressé | Gain |
| --- | --- | --- | --- |
| Position | float32 (12B) | float16 (6B) | 50% |
| Rotation | float32 (16B) | uint8 (4B) | 75% |
| SH (Color) | float32 (45 * 4B) | Codebook Index (1B) | 99% |

## 5. L'Écosystème Python

Bien que le code original soit en CUDA/C++, des wrappers Python comme `gsplat` (par Nerfstudio) rendent la tech accessible.

### Domptez le Rendu Neuronal

Dans notre module "Generative 3D", nous implémentons un solver Gaussian Splatting custom pour comprendre chaque ligne de l'algo.

[Le programme et les tarifs →](https://fr.learngeodata.eu/tarifs)