# Big Data LiDAR : Traitement à l'Échelle du Téraoctet

> Stratégies avancées pour le traitement de milliards de points LiDAR avec Python. Memory mapping, Tiling, et calcul parallèle.

- Adresse : https://fr.learngeodata.eu/blog/lidar-big-data-python
- 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 2026-01-02

---
Une fenêtre de 140 mètres dans une dalle de 39 millions de points. C'est l'unité de travail dont parle cet article.

## 1. Le Goulot d'Étranglement Mémoire

Un point LiDAR standard (X, Y, Z, Intensité, R, G, B, GPS Time) pèse environ `32 à 64 octets` non compressé. Un milliard de points représente donc ~50 Go de RAM brute. Charger cela dans un script Python naïf provoquera un `MemoryError` immédiat sur la plupart des workstations.

## 2. Stratégie 1 : Le Chunking avec Laspy

La bibliothèque `laspy` permet de lire les fichiers `.LAZ` par morceaux (chunks) sans tout charger. C'est la première ligne de défense.

```
import laspy
import numpy as np

def process_massive_file(filepath, chunk_size=1_000_000):
    with laspy.open(filepath) as f:
        # Itérateur sur les points par paquets de 1 million
        for chunk in f.chunk_iterator(chunk_size):
            points = np.column_stack((chunk.x, chunk.y, chunk.z))
            
            # Traitement local (ex: filtrage hauteur)
            mask = points[:, 2] > 50.0
            # Sauvegarde incrémentale ou aggregation de statistiques
            save_result(points[mask])
```

Cette méthode garde l'empreinte mémoire constante (égale à `chunk_size`), quelle que soit la taille totale du fichier.

## 3. Stratégie 2 : Le Tiling Spatial (Tuilage)

Pour des opérations contextuelles (calcul de normales, maillage), le chunking séquentiel ne suffit pas car il brise la continuité spatiale. Nous devons découper le nuage en tuiles géographiques (Tiles) avec un `buffer` de recouvrement.

Le tuilage, et la bande qui le rend juste. Chaque tuile est traitée seule, dans son propre processus. Mais un point situé au bord n'a pas tous ses voisins dans sa tuile : normales, densité et segmentation y seraient fausses. On lit donc une bande de recouvrement chez les tuiles adjacentes, et on la jette après calcul.

PDAL (Point Data Abstraction Library) est l'outil roi pour générer ces tuiles via la ligne de commande ou son binding Python.

```
[
    "input.laz",
    {
        "type": "filters.splitter",
        "length": 100.0,
        "buffer": 2.0
    },
    {
        "type": "writers.las",
        "filename": "tile_#.laz"
    }
]
```

## 4. Stratégie 3 : Multiprocessing (Parallélisme)

Une fois les données tuilées (ou chunkées), nous pouvons saturer les cœurs du CPU. Le `GIL` Python nous empêche d'utiliser des Threads efficacement pour le calcul pur, nous utilisons donc `multiprocessing`.

```
from multiprocessing import Pool, cpu_count

def worker_task(tile_path):
    # Processus isolé : Charge, Traite, Sauvegarde
    pcd = load(tile_path)
    result = heavy_algorithm(pcd)
    return result.status

if __name__ == "__main__":
    files = glob.glob("tiles/*.laz")
    # Utilisation de tous les cœurs disponibles
    with Pool(processes=cpu_count()) as pool:
        results = pool.map(worker_task, files)
```

## 5. Memory Mapping (Memmap)

Pour les cas où l'accès aléatoire est nécessaire sur le dataset entier, `numpy.memmap` permet de mapper un fichier binaire sur le disque dur comme s'il était en RAM. L'OS gère le paging automatiquement.

| Méthode | Vitesse Accès | Capacité Max | Complexité |
| --- | --- | --- | --- |
| RAM (Standard) | Extrême (~50 GB/s) | Limité par RAM physique | Faible |
| HDD (Seek/Read) | Lente (~150 MB/s) | Illimitée | Moyenne |
| Memmap (NVMe) | Haute (~3-7 GB/s) | Limité par Disque | Moyenne |

## Synthèse : L'Architecture Idéale

Pour traiter une ville entière :

1. **Split :** PDAL pour découper en tuiles de 100 m de côté, avec recouvrement.
2. **Process :** Script Python Multiprocessing lançant un worker par tuile.
3. **Merge :** Fusion des résultats légers (vecteurs, métadonnées) dans une base de données spatiale (PostGIS).

### Devenez Architecte Big Data 3D

Savoir coder est une chose, concevoir des architectures scalables en est une autre. Notre module "Infrastructure" vous attend.

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