Fichiers
vercora/tools/check_terrain_file.py
T
2026-10-11 01:54:18 +02:00

228 lignes
9.8 KiB
Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
check_terrain_file.py — controle croise d'un .vchm contre le .laz d'origine.
python tools/check_terrain_file.py DALLE.vchm NUAGE.copc.laz
Relit le fichier produit par lidar_to_heightmap.py et, pour une serie de points
de sonde, compare l'altitude stockee a la MEDIANE DES POINTS SOL BRUTS du nuage
dans un rayon d'une demi-cellule. Rien n'est partage avec le convertisseur a part
le format du fichier : une erreur d'indexation ou d'orientation dans l'un ne peut
pas se compenser dans l'autre.
CE QUE CE CONTROLE ATTRAPE, ET QUE RIEN D'AUTRE N'ATTRAPE : le relief en MIROIR.
Les lignes du .vchm vont du nord vers le sud (cf. l'en-tete de
lidar_to_heightmap.py). Se tromper de sens produit un terrain parfaitement
plausible - meme denivele, memes pentes, meme histogramme - mais retourne,
d'autant plus indetectable qu'il n'y a pas encore d'orthophoto a plaquer dessus.
Les sondes sont donc placees ASYMETRIQUEMENT : sur cette dalle les quatre bords
different de plusieurs centaines de metres, donc une inversion nord/sud creuse
un ecart enorme au lieu de passer inapercue.
Affiche aussi la conversion monde moteur <-> Lambert 93 que fait
Heightmap::toProjected, pour verifier a la main les coordonnees journalisees par
le jeu au demarrage.
"""
from __future__ import annotations
import os
import struct
import sys
import numpy as np
try:
import laspy
except ImportError:
sys.exit('laspy est absent : python -m pip install "laspy[lazrs]" numpy')
HEADER_SIZE = 120
def read_vchm(path):
with open(path, "rb") as f:
header = f.read(HEADER_SIZE)
if len(header) != HEADER_SIZE or header[:4] != b"VCHM":
sys.exit(f"{path} n'est pas un fichier .vchm.")
(magic, version, nx, nz, spacing, _reserved,
origin_e, origin_n, hmin, hmax, epsg, flags) = struct.unpack_from(
"<4sIIIfI dd ffII", header, 0)
label = header[56:120].split(b"\0", 1)[0].decode("ascii", "replace")
heights = np.frombuffer(f.read(), dtype="<f4")
if heights.size != nx * nz:
sys.exit(f"{path} : {heights.size} altitudes pour {nx}x{nz} attendues.")
return {
"version": version, "nx": nx, "nz": nz, "spacing": spacing,
"origin_e": origin_e, "origin_n": origin_n, "min": hmin, "max": hmax,
"epsg": epsg, "flags": flags, "label": label,
"grid": heights.reshape(nz, nx),
}
def main():
if len(sys.argv) != 3:
sys.exit(__doc__.strip())
vchm_path, laz_path = sys.argv[1], sys.argv[2]
m = read_vchm(vchm_path)
nx, nz, cell = m["nx"], m["nz"], m["spacing"]
grid = m["grid"]
print(f"Fichier : {os.path.basename(vchm_path)}")
print(f" label : {m['label']}")
print(f" version {m['version']}, {nx} x {nz} echantillons, pas {cell} m, "
f"EPSG:{m['epsg']}, flags {m['flags']}")
print(f" origine (ix=0, iz=0) : E {m['origin_e']:.1f} N {m['origin_n']:.1f} "
f"(coin nord-ouest)")
print(f" bornes en-tete {m['min']:.2f} .. {m['max']:.2f} m | "
f"donnees {grid.min():.2f} .. {grid.max():.2f} m")
assert abs(m["min"] - grid.min()) < 0.01 and abs(m["max"] - grid.max()) < 0.01, \
"les bornes de l'en-tete ne correspondent pas aux donnees"
half = 0.5 * (nx - 1) * cell
print(f"\nRepere moteur : terrain centre sur l'origine, "
f"X et Z dans [{-half:.0f}, {half:.0f}]")
print(" ix croissant -> EST (+X) iz croissant -> SUD (+Z)")
# --- Points de sonde, volontairement asymetriques ----------------------
q = (nx - 1) // 4
c = (nx - 1) // 2
probes = [
("centre", c, c),
("nord", c, q),
("sud", c, 3 * q),
("ouest", q, c),
("est", 3 * q, c),
("nord-ouest", q, q),
("sud-est", 3 * q, 3 * q),
("coin NO", 2, 2),
("coin SE", nx - 3, nz - 3),
]
print(f"\nLecture du nuage brut {os.path.basename(laz_path)} (classe 2)...")
xs, ys, zs = [], [], []
with laspy.open(laz_path) as reader:
for chunk in reader.chunk_iterator(4_000_000):
keep = np.asarray(chunk.classification) == 2
if keep.any():
xs.append(np.asarray(chunk.x)[keep])
ys.append(np.asarray(chunk.y)[keep])
zs.append(np.asarray(chunk.z)[keep])
x = np.concatenate(xs); y = np.concatenate(ys); z = np.concatenate(zs)
print(f" {x.size:,} points sol")
print(f"\n{'sonde':<12} {'ix':>5} {'iz':>5} {'monde X':>9} {'monde Z':>9} "
f"{'E (L93)':>11} {'N (L93)':>11} {'.vchm':>9} {'brut':>9} {'ecart':>7} {'n':>5}")
print("-" * 106)
worst = 0.0
checked = 0
for name, ix, iz in probes:
world_x = -half + ix * cell
world_z = -half + iz * cell
# Exactement ce que fait Heightmap::toProjected.
east = m["origin_e"] + (world_x + half)
north = m["origin_n"] - (world_z + half)
stored = float(grid[iz, ix])
# Mediane des points bruts appartenant au noeud : c'est la DEFINITION du
# noeud - la demi-cellule [E - c/2, E + c/2[ - rejouee ici depuis le
# nuage, sans rien emprunter au convertisseur. L'intervalle est
# semi-ouvert des deux cotes, comme la regle d'arrondi "moitie vers le
# haut" employee la-bas : un point pile sur la frontiere doit tomber du
# meme cote dans les deux calculs, faute de quoi les deux medianes
# different legerement et le controle accuse a tort le convertisseur.
r = 0.5 * cell
near = ((x - east >= -r) & (x - east < r) &
(y - north >= -r) & (y - north < r))
count = int(near.sum())
if count == 0:
print(f"{name:<12} {ix:5d} {iz:5d} {world_x:9.1f} {world_z:9.1f} "
f"{east:11.1f} {north:11.1f} {stored:9.2f} {'(trou)':>9} "
f"{'-':>7} {0:5d}")
continue
raw = float(np.median(z[near]))
delta = stored - raw
worst = max(worst, abs(delta))
checked += 1
print(f"{name:<12} {ix:5d} {iz:5d} {world_x:9.1f} {world_z:9.1f} "
f"{east:11.1f} {north:11.1f} {stored:9.2f} {raw:9.2f} "
f"{delta:+7.3f} {count:5d}")
# --- Test d'orientation, sur un large echantillon de noeuds -------------
# Comparer la moyenne d'une BANDE de la grille a celle des points bruts de la
# meme bande serait tentant mais FAUX : la grille est ponderee par la
# surface, alors que le nuage est ponderee par les points, dont la densite
# s'effondre sous le couvert forestier. Sur cette dalle l'ecart atteint 30 m
# sans qu'aucune erreur ne soit en cause.
#
# On generalise donc la comparaison PAR NOEUD, la seule qui compare deux fois
# la meme chose, et on la rejoue contre les deux symetriques possibles :
# - lignes inversees -> le relief serait retourne nord/sud ;
# - colonnes inversees -> retourne est/ouest.
# Une orientation correcte donne un ecart direct nul et des ecarts miroir
# enormes. C'est ce contraste qui fait la preuve, pas la valeur absolue.
print("\nControle d'orientation sur un large echantillon de noeuds :")
rng = np.random.default_rng(20260816)
sample = 600
sample_ix = rng.integers(0, nx, sample)
sample_iz = rng.integers(0, nz, sample)
direct, flip_ns, flip_ew, used = [], [], [], 0
r = 0.5 * cell
for ix, iz in zip(sample_ix.tolist(), sample_iz.tolist()):
east = m["origin_e"] + ix * cell
north = m["origin_n"] - iz * cell
near = ((x - east >= -r) & (x - east < r) &
(y - north >= -r) & (y - north < r))
if not near.any():
continue
raw = float(np.median(z[near]))
used += 1
direct.append(abs(float(grid[iz, ix]) - raw))
flip_ns.append(abs(float(grid[nz - 1 - iz, ix]) - raw))
flip_ew.append(abs(float(grid[iz, nx - 1 - ix]) - raw))
direct = np.array(direct); flip_ns = np.array(flip_ns); flip_ew = np.array(flip_ew)
# Quelques noeuds PEUVENT s'ecarter legitimement : ce sont ceux que le filtre
# de pics a remplaces par la mediane de leur voisinage, donc justement ceux
# ou la valeur stockee ne DOIT pas etre celle du nuage brut. Ils sont de
# l'ordre de 1 sur 100 000, donc invisibles sur 600 tirages, mais on compte
# les depassements plutot que de juger sur le seul maximum.
outliers = int((direct > 0.01).sum())
print(f" {used} noeuds mesures sur {sample} tires")
print(f" lecture DIRECTE : ecart moyen {direct.mean():8.4f} m, "
f"max {direct.max():8.4f} m, {outliers} noeud(s) au-dessus de 1 cm")
print(f" si les lignes etaient inversees (nord/sud) : ecart moyen "
f"{flip_ns.mean():8.3f} m")
print(f" si les colonnes etaient inversees (est/ouest) : ecart moyen "
f"{flip_ew.mean():8.3f} m")
faithful = direct.mean() < 0.001 and outliers <= 2
discriminating = flip_ns.mean() > 10.0 and flip_ew.mean() > 10.0
ok_orientation = faithful and discriminating
if ok_orientation:
print(" -> lecture directe exacte, symetriques tres fausses : "
"orientation CORRECTE et discriminee.")
elif not faithful:
print(" -> la lecture directe ne retrouve pas le nuage : "
"indexation ou geo-referencement errone.")
else:
print(" -> le terrain est trop symetrique pour que ce test discrimine "
"quoi que ce soit ; changer de dalle.")
print(f"\nEcart maximal sur les {checked} sondes nommees : {worst:.3f} m")
ok = ok_orientation and worst < 0.05 and checked >= 5
print("[OK] Le fichier decrit bien le nuage d'origine." if ok
else "[ECHEC] Voir ci-dessus.")
return 0 if ok else 1
if __name__ == "__main__":
sys.exit(main())