#!/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=" 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())