PDAL : le couteau suisse en ligne de commande pour tes nuages de points

Si tu fais du LiDAR un peu sérieusement, tu vas vite te heurter à un mur : CloudCompare est génial pour explorer un nuage de points, mais pour appliquer le même traitement à 200 fichiers .las la nuit, ça devient ingérable.

PDAL résout ça.

Qu’est-ce que PDAL ?

PDAL (Point Data Abstraction Library) est une bibliothèque open-source qui te permet de manipuler des nuages de points en ligne de commande, via des pipelines JSON.

Concrètement, tu décris une suite d’opérations dans un fichier .json, tu lances PDAL, et il enchaîne tout : lecture, filtres, écriture. Comme un Photoshop d’actions mais pour les points.

Installation

Sur Windows, le plus simple est Conda :

conda install -c conda-forge pdal

Sur Mac/Linux, brew install pdal ou apt install pdal.

Pipeline 1 : ton premier pipeline, extraire le sol

Voilà un pipeline minimal qui prend un .las, garde uniquement les points classifiés comme sol (classe 2), et exporte en .laz compressé :

{
  "pipeline": [
    "entree.las",
    {
      "type": "filters.range",
      "limits": "Classification[2:2]"
    },
    {
      "type": "writers.las",
      "filename": "sortie.laz",
      "compression": "laszip"
    }
  ]
}

Lance-le avec :

pdal pipeline mon-pipeline.json

Typiquement, après ton vol drone, PDAL automatise toute la chaîne de post-traitement : nettoyage des points aberrants, extraction sol, puis export. Et si tu veux des nuages prêts pour le streaming, writers.copc te sort directement du COPC, le format LAZ indexé par octree pour les gros fichiers.

Avant tout : inspecte ton fichier avec pdal info

Avant de filtrer quoi que ce soit, regarde ce qu’il y a dans ton fichier. C’est le réflexe que tout le monde zappe :

pdal info entree.las --summary

Tu obtiens le nombre de points, l’emprise, le système de coordonnées et les dimensions disponibles. Et pour savoir si ton nuage est déjà classifié :

pdal info entree.las --stats --dimensions Classification

Si la classe 2 (sol) n’existe pas, inutile d’écrire un filters.range dessus — il te faut d’abord une classification. Justement, c’est le pipeline suivant.

Pipeline 2 : nettoyer puis classifier le sol

Le cas le plus courant en sortie de vol drone ou de LiDAR HD IGN brut : des points aberrants (oiseaux, multi-trajets, poussière) et aucune classification exploitable. Voilà le pipeline complet, dans l’ordre qui marche :

{
  "pipeline": [
    "nuage-brut.laz",
    {
      "type": "filters.outlier",
      "method": "statistical",
      "mean_k": 8,
      "multiplier": 2.5
    },
    {
      "type": "filters.smrf",
      "ignore": "Classification[7:7]",
      "slope": 0.15,
      "window": 16,
      "threshold": 0.5
    },
    {
      "type": "writers.las",
      "filename": "nuage-classifie.laz",
      "compression": "laszip"
    }
  ]
}

Ce qui se passe, étape par étape :

1. filters.outlier analyse les 8 voisins de chaque point (mean_k) et marque comme bruit (classe 7) tout point dont la distance moyenne dépasse 2,5 écarts-types. Plus la valeur de multiplier est basse, plus le filtre est agressif.
2. filters.smrf classe les points sol en classe 2, en ignorant le bruit détecté juste avant. Le paramètre qui change tout, c’est slope : 0.15 convient à un terrain vallonné classique ; monte vers 0.3-0.4 en zone très pentue, sinon le filtre mange tes talus.
3. L’export garde tous les points avec leur classification — tu pourras extraire le sol plus tard sans refaire le calcul.

Pipeline 3 : du nuage classifié au MNT raster

Une fois le sol classifié, tu peux sortir un MNT GeoTIFF directement, sans ouvrir le moindre logiciel :

{
  "pipeline": [
    "nuage-classifie.laz",
    {
      "type": "filters.range",
      "limits": "Classification[2:2]"
    },
    {
      "type": "writers.gdal",
      "filename": "mnt.tif",
      "resolution": 0.5,
      "output_type": "idw",
      "gdaldriver": "GTiff"
    }
  ]
}

resolution: 0.5 te donne un pixel de 50 cm — cohérent avec un nuage à 10-20 pts/m². Descendre à 0.1 sur un nuage trop peu dense ne crée pas de détail, juste des trous.

Traiter un dossier entier (le vrai gain)

C’est là que PDAL écrase tout le reste. Un nuage, ça va. Les 60 dalles d’une commune, c’est une boucle :

Get-ChildItem .\dalles\*.laz | ForEach-Object {
  pdal pipeline classification.json `
    --readers.las.filename=$_.FullName `
    --writers.las.filename=".\sortie\$($_.BaseName)-classifie.laz"
}

Le même pipeline JSON, réutilisé sur chaque fichier en surchargeant juste l’entrée et la sortie depuis la ligne de commande. Tu lances, tu vas boire un café, c’est fait. La version bash est identique dans l’esprit avec une boucle for f in dalles/*.laz.

Convertir en COPC pour le streaming

Dernier pipeline, le plus court mais celui que j’utilise le plus : convertir n’importe quel LAS/LAZ en COPC :

pdal translate entree.laz sortie.copc.laz --writers.copc.forward=all

Le COPC, c’est du LAZ indexé par octree : un viewer peut streamer uniquement les zones et niveaux de détail dont il a besoin, sans charger les 30 Go du fichier. Si tes nuages doivent être consultés (et pas seulement archivés), convertis-les.

Les filtres que j’utilise tout le temps

• filters.range : filtrer par classification, altitude, intensité
• filters.outlier : supprimer les points aberrants (oiseaux, drone qui passe…)
• filters.crop : découper un polygone d’emprise
• filters.icp : recalage entre deux nuages
• filters.smrf : extraction sol automatique (Simple Morphological Filter)
• filters.sample : décimer proprement (un point par rayon donné, mieux qu’un point sur N)

Les limites, pour être honnête

PDAL n’est pas magique. Pas de visualisation : tu contrôles tes résultats dans CloudCompare ou QGIS. Les messages d’erreur sont parfois cryptiques quand le JSON est mal formé — valide-le dans un éditeur qui connaît le JSON. Et sur le recalage fin multi-stations, un logiciel dédié avec contrôle visuel reste plus sûr que filters.icp en aveugle.

Quand utiliser PDAL plutôt que CloudCompare ?

• Tu fais le même traitement sur N fichiers → PDAL gagne
• Tu veux scripter / automatiser → PDAL gagne
• Tu veux explorer visuellement un nuage → CloudCompare gagne
• Tu fais une opération ponctuelle que tu ne referas pas → CloudCompare gagne

Les deux sont complémentaires. Sur Topolia, j’utilise CloudCompare pour cadrer une méthode, puis PDAL pour l’appliquer à la chaîne.

Pour aller plus loin

La doc officielle PDAL (pdal.io) est excellente. Tu trouveras la liste complète des filtres + des exemples concrets.

Et si tu te demandes à quoi ça sert concrètement : PDAL est exactement le moteur sur lequel s’appuie Topolia Desktop pour streamer des nuages de plusieurs dizaines de Go sans tout charger en RAM. Le même outil que celui dont je te parle ici, mais intégré sous le capot.