Fichiers
2026-10-11 01:54:18 +02:00

531 lignes
23 KiB
Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
lidar_to_heightmap.py — dalle LiDAR HD IGN (.laz / .copc.laz) -> heightmap .vchm
PHASE 7. Premier maillon reel du pipeline : remplace le bruit procedural de la
Phase 4 par du terrain mesure. L'outil est VOLONTAIREMENT SEPARE du moteur — il
tourne une fois, hors ligne, et le jeu ne lit qu'une grille de float deja propre.
Mettre un decodeur LAZ dans le moteur aurait ajoute une dependance lourde pour
un travail qui n'a aucune raison d'etre refait a chaque lancement.
python tools/lidar_to_heightmap.py ENTREE.copc.laz -o SORTIE.vchm [options]
Exemple reel (celui de la Phase 7) :
python tools/lidar_to_heightmap.py ^
data/lidar/LHD_FXX_0907_6440_PTS_LAMB93_IGN69.copc.laz ^
-o assets/terrain/LHD_0907_6440_1m.vchm --cell 1.0
Options utiles :
--cell N taille de cellule en metres (defaut 1.0)
--stat S median (defaut) | mean | min — agregation des points d'un noeud
--classes L classes LAS retenues (defaut 2 = sol)
--no-despike desactive le filtre de pics
--zero-base ramene l'altitude minimale a 0 au lieu de garder l'IGN69
--report-only analyse et statistiques, sans ecrire de fichier
Dependances : laspy + lazrs + numpy
python -m pip install "laspy[lazrs]" numpy
Pourquoi laspy/lazrs et pas PDAL : PDAL est bien le standard du domaine, mais sur
Windows il ne se livre en pratique que par conda, absent de cette machine.
laspy 2.x avec le backend lazrs (l'implementation Rust de LASzip) lit exactement
le meme LAZ 1.4 classifie, s'installe en une commande par pip, et tout le travail
qu'on lui demanderait ici — filtrer une classe, binner sur une grille, agreger —
est de toute facon du numpy. Le jour ou PDAL serait disponible, il produirait la
meme grille : le format .vchm ci-dessous ne depend pas du lecteur.
FORMAT DE SORTIE .vchm ("Vercora HeightMap"), petit-boutiste, en-tete de 120
octets suivi des altitudes :
offset taille champ
0 4 magie "VCHM"
4 4 uint32 version = 1
8 4 uint32 samplesX (echantillons d'ouest en est)
12 4 uint32 samplesZ (echantillons du nord vers le sud)
16 4 float32 spacing (metres entre deux echantillons voisins)
20 4 uint32 reserve = 0
24 8 float64 originEast coordonnee X (Lambert 93) de l'echantillon ix=0
32 8 float64 originNorth coordonnee Y (Lambert 93) de l'echantillon iz=0
40 4 float32 minHeight
44 4 float32 maxHeight
48 4 uint32 crsEpsg (2154 pour le Lambert 93)
52 4 uint32 flags bit 0 : les altitudes sont absolues (IGN69)
56 64 char[64] label nom de la dalle, complete par des zeros
120 ... float32 heights[samplesZ * samplesX], index = iz * samplesX + ix
SENS DES AXES — le point delicat, et la raison pour laquelle les lignes sont
stockees du NORD vers le SUD. Le moteur est en repere main droite avec Y vers le
haut, donc X ^ Y = Z. En posant X = Est et Y = Haut, on obtient
Z = Est ^ Haut = -Nord : le nord est en -Z. Ecrire les lignes du nord vers le sud
fait donc correspondre iz croissant a Z croissant, et le terrain s'affiche dans
le bon sens. Stocker du sud vers le nord donnerait un relief en MIROIR — une
erreur invisible sur du bruit procedural, et tres difficile a diagnostiquer plus
tard sur une orthophoto.
Les altitudes restent ABSOLUES (IGN69) par defaut : c'est la donnee mesuree, et
c'est ce que originEast/originNorth pretendent decrire. Le recentrage horizontal
(la dalle est centree sur l'origine du monde) est fait par le moteur au
chargement, pas ici — ainsi le fichier reste geo-reference et deux dalles
voisines resteront raccordables.
"""
from __future__ import annotations
import argparse
import math
import os
import struct
import sys
import time
import numpy as np
try:
import laspy
except ImportError: # pragma: no cover - message d'aide, pas de la logique
sys.exit("laspy est absent. Installer :\n"
' python -m pip install "laspy[lazrs]" numpy')
MAGIC = b"VCHM"
VERSION = 1
HEADER_SIZE = 120
LABEL_SIZE = 64
FLAG_ABSOLUTE_ALTITUDE = 1 << 0
# Nomenclature LAS standard, telle qu'utilisee par l'IGN pour LiDAR HD.
# Sert uniquement aux messages : le filtre, lui, prend les numeros bruts.
CLASS_NAMES = {
1: "non classe",
2: "sol",
3: "vegetation basse",
4: "vegetation moyenne",
5: "vegetation haute",
6: "bati",
9: "eau",
17: "tablier de pont",
64: "sursol perenne",
65: "artefact",
66: "point virtuel",
67: "divers bati",
}
def human_size(n: int) -> str:
for unit in ("o", "Ko", "Mo", "Go"):
if n < 1024 or unit == "Go":
return f"{n:.1f} {unit}" if unit != "o" else f"{n} o"
n /= 1024.0
return f"{n} o"
# ---------------------------------------------------------------------------
# 1. Lecture du nuage
# ---------------------------------------------------------------------------
def read_ground_points(path: str, classes: set[int], chunk_size: int):
"""Renvoie (x, y, z) des points des classes demandees, plus des statistiques.
Lecture PAR MORCEAUX : une dalle LiDAR HD fait ~29 millions de points, dont
on ne garde ici que le quart (le sol). Tout charger d'un bloc marcherait sur
cette machine, mais garder seulement les points retenus borne la memoire a la
taille du RESULTAT et non a celle du fichier — ce qui reste vrai le jour ou
l'on enchainera plusieurs dalles.
"""
xs, ys, zs = [], [], []
histogram = {}
total = 0
with laspy.open(path) as reader:
header = reader.header
for chunk in reader.chunk_iterator(chunk_size):
cls = np.asarray(chunk.classification)
total += cls.size
values, counts = np.unique(cls, return_counts=True)
for value, count in zip(values.tolist(), counts.tolist()):
histogram[value] = histogram.get(value, 0) + count
keep = np.isin(cls, list(classes))
if not keep.any():
continue
xs.append(np.asarray(chunk.x)[keep])
ys.append(np.asarray(chunk.y)[keep])
zs.append(np.asarray(chunk.z)[keep].astype(np.float64))
if not xs:
raise SystemExit(
f"Aucun point des classes {sorted(classes)} dans {os.path.basename(path)}. "
"Cette dalle est-elle bien la version CLASSIFIEE ?")
return (np.concatenate(xs), np.concatenate(ys), np.concatenate(zs),
header, total, histogram)
# ---------------------------------------------------------------------------
# 2. Grille
# ---------------------------------------------------------------------------
def bounds_from_name(path: str):
"""(x_min, y_min, x_max, y_max) nominal deduit du nom d'une dalle LiDAR HD.
'LHD_FXX_0899_6440_PTS_LAMB93_IGN69.copc.laz' -> coin NORD-OUEST a
X = 899 km, Y = 6440 km, donc la dalle couvre X 899000..900000 et
Y 6439000..6440000 : le Y du nom est le HAUT de la dalle, pas le bas.
Retourne None si le nom ne suit pas la nomenclature.
"""
parts = os.path.basename(path).split("_")
for index in range(len(parts) - 1):
a, b = parts[index], parts[index + 1]
if a.isdigit() and b.isdigit() and len(a) == 4 and len(b) == 4:
x_min = int(a) * 1000
y_max = int(b) * 1000
return (x_min, y_max - 1000, x_min + 1000, y_max)
return None
def build_grid(x, y, z, x_min, y_min, x_max, y_max, cell, stat):
"""Agrege les points sur une grille reguliere, un echantillon par NOEUD.
Les echantillons sont sur les noeuds (ix = 0 tombe pile sur x_min) et non au
centre des cellules : les bords de la grille coincident alors exactement avec
les bords de la dalle, donc deux dalles voisines partageront leurs
echantillons de bord au lieu de se chevaucher d'une demi-cellule. Chaque
point est affecte au noeud le plus PROCHE, ce qui revient a un carre de cote
`cell` centre sur le noeud.
Renvoie (heights, counts) en shape (nz, nx), lignes du NORD vers le SUD,
heights valant NaN la ou aucun point n'est tombe.
"""
nx = int(round((x_max - x_min) / cell)) + 1
nz = int(round((y_max - y_min) / cell)) + 1
# REGLE D'AFFECTATION, valable pour les deux axes : un point appartient au
# noeud dont l'intervalle [c - cell/2, c + cell/2[ contient sa coordonnee
# PROJETEE. C'est cette definition, et non ce code, que rejoue
# tools/check_terrain_file.py.
#
# floor(t + 0.5) et NON np.rint : rint arrondit les ex aequo vers l'entier
# PAIR, si bien qu'un point tombant pile sur la frontiere entre deux noeuds
# part a gauche ou a droite selon la PARITE de l'indice. Les coordonnees LAZ
# etant quantifiees au centimetre, ces ex aequo sont frequents et non
# marginaux.
#
# Le renversement nord-sud est fait APRES l'arrondi, sur l'indice entier, et
# c'est essentiel : arrondir directement (y_max - y) inverserait aussi le
# sens de l'intervalle semi-ouvert, qui deviendrait ]c - cell/2, c + cell/2]
# sur cet axe et [c - cell/2, c + cell/2[ sur l'autre. Deux dalles voisines
# raccordees le long d'une frontiere est-ouest se disputeraient alors leur
# ligne commune. Erreur reellement commise et attrapee par le controle croise
# (des noeuds "vides" pour l'un contenaient un point pour l'autre) : sur une
# dalle isolee elle ne deplacait qu'une poignee de points, donc rien de
# visible a l'ecran.
ix = np.floor((x - x_min) / cell + 0.5).astype(np.int64)
iz_from_south = np.floor((y - y_min) / cell + 0.5).astype(np.int64)
iz = (nz - 1) - iz_from_south
inside = (ix >= 0) & (ix < nx) & (iz >= 0) & (iz < nz)
ix, iz, z = ix[inside], iz[inside], z[inside]
key = iz * nx + ix
counts_flat = np.bincount(key, minlength=nx * nz)
if stat == "mean":
sums = np.bincount(key, weights=z, minlength=nx * nz)
with np.errstate(invalid="ignore", divide="ignore"):
values = sums / counts_flat
elif stat == "min":
values = np.full(nx * nz, np.inf)
np.minimum.at(values, key, z)
values[np.isinf(values)] = np.nan
else: # median
# Tri lexicographique (cle, puis altitude) : les points d'un meme noeud
# se retrouvent contigus ET tries, donc la mediane est une simple
# indexation au milieu de chaque groupe. Entierement vectorise, la ou
# une boucle Python sur le million de noeuds couterait des minutes.
order = np.lexsort((z, key))
key_sorted = key[order]
z_sorted = z[order]
unique_keys, starts, group_counts = np.unique(
key_sorted, return_index=True, return_counts=True)
middle = starts + group_counts // 2
median = z_sorted[middle]
even = (group_counts % 2) == 0
if even.any():
median = median.copy()
median[even] = 0.5 * (z_sorted[middle[even]] + z_sorted[middle[even] - 1])
values = np.full(nx * nz, np.nan)
values[unique_keys] = median
values = np.where(counts_flat > 0, values, np.nan)
return values.reshape(nz, nx), counts_flat.reshape(nz, nx)
def neighbour_stack(grid):
"""Empile les 8 voisins de chaque cellule, bords prolonges par recopie."""
padded = np.pad(grid, 1, mode="edge")
nz, nx = grid.shape
out = np.empty((8, nz, nx), dtype=grid.dtype)
k = 0
for dz in (0, 1, 2):
for dx in (0, 1, 2):
if dz == 1 and dx == 1:
continue
out[k] = padded[dz:dz + nz, dx:dx + nx]
k += 1
return out
def fill_holes(heights, max_passes=512):
"""Bouche les trous par dilatation iterative : chaque passe remplit une
cellule vide par la MOYENNE de ses voisins deja connus.
Aucun trou n'est tolere dans le maillage final — un NaN qui arrive au GPU
donne un triangle degenere et un terrain qui clignote. Le nombre de passes
effectuees est renvoye : il vaut exactement le rayon du plus gros trou, ce
qui est le diagnostic le plus parlant sur la qualite de la dalle.
"""
filled = heights.copy()
known = ~np.isnan(filled)
passes = 0
while not known.all() and passes < max_passes:
neighbours = neighbour_stack(np.where(known, filled, 0.0))
valid = neighbour_stack(known.astype(np.float32))
total = neighbours.sum(axis=0)
weight = valid.sum(axis=0)
newly = (~known) & (weight > 0)
if not newly.any():
break
filled[newly] = total[newly] / weight[newly]
known |= newly
passes += 1
remaining = int((~known).sum())
if remaining:
# Ne peut arriver que si la grille est entierement vide, ou si un trou
# depasse max_passes cellules de rayon. Plutot que de laisser passer des
# NaN, on rabat sur la mediane globale et on le dit tres fort.
fallback = float(np.nanmedian(filled)) if np.isfinite(filled).any() else 0.0
filled[~known] = fallback
print(f" !! {remaining} cellules jamais atteintes apres {passes} passes, "
f"rabattues sur {fallback:.2f} m")
return filled, passes, remaining
def despike(heights, measured, abs_tolerance, mad_factor):
"""Remplace les cellules isolees qui s'ecartent trop de leur voisinage.
Le vrai risque avec une dalle reelle n'est pas le bruit — la mediane par
noeud l'a deja absorbe — mais la cellule dont TOUS les points sont faux
(echo parasite classe sol par erreur). Le critere doit donc etre severe
envers un point isole et indulgent envers une falaise, car cette dalle en a
de vraies : 562 m de denivele sur 1 km. D'ou le double seuil — il faut
depasser A LA FOIS une tolerance absolue et un multiple de la dispersion
LOCALE. Sur un versant raide la dispersion locale est grande, donc le filtre
s'y desactive de lui-meme ; sur un replat elle est proche de zero et le
moindre pic ressort.
Seules les cellules MESUREES sont candidates : celles issues du bouchage de
trous sont deja lisses par construction.
"""
neighbours = neighbour_stack(heights)
local_median = np.median(neighbours, axis=0)
deviation = np.abs(heights - local_median)
# MAD -> ecart-type par le facteur 1.4826 (loi normale).
local_mad = np.median(np.abs(neighbours - local_median), axis=0) * 1.4826
threshold = np.maximum(abs_tolerance, mad_factor * local_mad)
spikes = measured & (deviation > threshold)
cleaned = heights.copy()
cleaned[spikes] = local_median[spikes]
return cleaned, int(spikes.sum()), float(deviation[spikes].max()) if spikes.any() else 0.0
# ---------------------------------------------------------------------------
# 3. Ecriture
# ---------------------------------------------------------------------------
def write_vchm(path, heights, spacing, origin_east, origin_north, label,
epsg, absolute):
nz, nx = heights.shape
data = np.ascontiguousarray(heights, dtype="<f4")
header = struct.pack(
"<4sIIIfI dd ffII",
MAGIC, VERSION, nx, nz, float(spacing), 0,
float(origin_east), float(origin_north),
float(data.min()), float(data.max()),
int(epsg), FLAG_ABSOLUTE_ALTITUDE if absolute else 0,
)
header += label.encode("ascii", "replace")[:LABEL_SIZE].ljust(LABEL_SIZE, b"\0")
assert len(header) == HEADER_SIZE, len(header)
os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
with open(path, "wb") as f:
f.write(header)
f.write(data.tobytes())
# ---------------------------------------------------------------------------
def main() -> int:
parser = argparse.ArgumentParser(
description="Convertit une dalle LiDAR HD IGN en heightmap .vchm.")
parser.add_argument("input", help="fichier .laz / .copc.laz classifie")
parser.add_argument("-o", "--output", help="fichier .vchm a ecrire")
parser.add_argument("--cell", type=float, default=1.0,
help="taille de cellule en metres (defaut 1.0)")
parser.add_argument("--stat", choices=("median", "mean", "min"), default="median",
help="agregation des points d'un noeud (defaut median)")
parser.add_argument("--classes", default="2",
help="classes LAS retenues, separees par des virgules "
"(defaut 2 = sol)")
parser.add_argument("--chunk", type=int, default=4_000_000,
help="points lus par morceau (defaut 4 millions)")
parser.add_argument("--no-despike", action="store_true",
help="desactive le filtre de pics")
parser.add_argument("--spike-tolerance", type=float, default=5.0,
help="ecart absolu minimal pour qu'une cellule soit un "
"pic, en metres (defaut 5.0)")
parser.add_argument("--spike-factor", type=float, default=6.0,
help="multiple de la dispersion locale au-dela duquel "
"une cellule est un pic (defaut 6.0)")
parser.add_argument("--zero-base", action="store_true",
help="ramene l'altitude minimale a 0 (defaut : garder "
"les altitudes absolues IGN69)")
parser.add_argument("--report-only", action="store_true",
help="analyse seulement, n'ecrit aucun fichier")
parser.add_argument("--bounds-from-name", action="store_true",
help="imposer l'emprise NOMINALE de la dalle deduite de "
"son nom (LHD_FXX_0899_6440_... -> X 899000..900000, "
"Y 6439000..6440000) au lieu de l'emprise des points. "
"Indispensable en assemblage multi-dalles.")
args = parser.parse_args()
if args.cell <= 0:
return parser.error("--cell doit etre > 0")
if not args.report_only and not args.output:
return parser.error("-o/--output est requis (ou utiliser --report-only)")
classes = {int(c) for c in args.classes.split(",") if c.strip()}
started = time.time()
size = os.path.getsize(args.input)
print(f"Entree : {os.path.basename(args.input)} ({human_size(size)})")
x, y, z, header, total, histogram = read_ground_points(
args.input, classes, args.chunk)
print(f" {total:,} points lus, point format {header.point_format.id}, "
f"LAS {header.version}")
print(" classification :")
for value in sorted(histogram):
name = CLASS_NAMES.get(value, "?")
mark = " <-- retenu" if value in classes else ""
print(f" {value:3d} {name:<18s} {histogram[value]:>11,} "
f"({100.0 * histogram[value] / total:5.2f} %){mark}")
print(f" retenus : {x.size:,} points "
f"({100.0 * x.size / total:.2f} %), "
f"soit {x.size / max(1.0, (x.max() - x.min()) * (y.max() - y.min())):.2f} pts/m2")
# Emprise : celle declaree par l'en-tete LAS, ecretee sur des metres entiers.
# On ne prend PAS l'emprise des points retenus : elle varierait selon la
# classe demandee, et deux dalles voisines ne se raccorderaient plus.
x_min = math.floor(header.mins[0])
y_min = math.floor(header.mins[1])
x_max = math.ceil(header.maxs[0])
y_max = math.ceil(header.maxs[1])
if args.bounds_from_name:
# ASSEMBLAGE MULTI-DALLES : l'emprise ci-dessus vient des POINTS, pas de
# la dalle. Une dalle dont les echos s'arretent 30 cm avant le bord (bord
# de mission, plan d'eau non reflechissant, trou de vol) donnerait une
# grille de 1000 au lieu de 1001 echantillons : elle serait refusee comme
# non carree, ou pire, se raccorderait decalee d'un metre a ses voisines.
# Le nom de la dalle, lui, porte l'emprise nominale garantie par l'IGN.
nominal = bounds_from_name(args.input)
if nominal is None:
return parser.error(
f"--bounds-from-name : impossible de lire les coordonnees dans "
f"'{os.path.basename(args.input)}' (attendu LHD_FXX_<X>_<Y>_...)")
forced_x_min, forced_y_min, forced_x_max, forced_y_max = nominal
if (forced_x_min, forced_y_min, forced_x_max, forced_y_max) != \
(x_min, y_min, x_max, y_max):
print(f" emprise des points : X {x_min} .. {x_max}, "
f"Y {y_min} .. {y_max} (ecartee)")
x_min, y_min, x_max, y_max = nominal
print(f" emprise NOMINALE (nom de dalle) : X {x_min} .. {x_max}, "
f"Y {y_min} .. {y_max} ({x_max - x_min} x {y_max - y_min} m)")
else:
print(f" emprise (Lambert 93) : X {x_min} .. {x_max}, Y {y_min} .. {y_max} "
f"({x_max - x_min} x {y_max - y_min} m)")
heights, counts = build_grid(x, y, z, x_min, y_min, x_max, y_max,
args.cell, args.stat)
nz, nx = heights.shape
measured = counts > 0
holes = int((~measured).sum())
print(f"\nGrille : {nx} x {nz} echantillons, pas de {args.cell} m, "
f"agregation '{args.stat}'")
print(f" points par cellule : min {counts[measured].min()}, "
f"median {int(np.median(counts[measured]))}, max {counts.max()}")
print(f" trous : {holes:,} cellules sans aucun point "
f"({100.0 * holes / counts.size:.3f} %)")
heights, passes, unreached = fill_holes(heights)
if holes:
print(f" bouches en {passes} passes "
f"(rayon du plus gros trou : {passes} cellules)")
if not args.no_despike:
heights, spikes, worst = despike(heights, measured,
args.spike_tolerance, args.spike_factor)
print(f" pics corriges : {spikes:,} cellules "
f"({100.0 * spikes / heights.size:.4f} %)"
+ (f", ecart max {worst:.1f} m" if spikes else ""))
if not np.isfinite(heights).all():
raise SystemExit("BUG : des valeurs non finies subsistent dans la grille.")
absolute = not args.zero_base
if args.zero_base:
heights = heights - heights.min()
print(f"\nAltitudes : {heights.min():.2f} .. {heights.max():.2f} m "
f"(denivele {heights.max() - heights.min():.2f} m)"
+ ("" if absolute else " [ramenees a zero]"))
label = os.path.splitext(os.path.splitext(os.path.basename(args.input))[0])[0]
if args.report_only:
print("\n--report-only : rien n'a ete ecrit.")
return 0
epsg = 2154 # Lambert 93. Les dalles LiDAR HD metropolitaines y sont toutes.
write_vchm(args.output, heights, args.cell, x_min, y_max, label, epsg, absolute)
written = os.path.getsize(args.output)
print(f"\nSortie : {args.output} ({human_size(written)})")
print(f" origine (echantillon 0,0 = coin NORD-OUEST) : "
f"E {x_min}, N {y_max} [EPSG:{epsg}]")
print(f" emprise monde : {(nx - 1) * args.cell:.0f} x {(nz - 1) * args.cell:.0f} m")
print(f"Termine en {time.time() - started:.1f} s.")
return 0
if __name__ == "__main__":
sys.exit(main())