361 lignes
15 KiB
Python
361 lignes
15 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
check_seams.py — controle croise d'un terrain ASSEMBLE contre les nuages bruts,
|
|
le long de TOUTES les frontieres entre dalles.
|
|
|
|
python tools/check_seams.py assets/terrain/vercora_zone_1m.vchm data/lidar/*.laz
|
|
|
|
Pendant de tools/check_terrain_file.py (une dalle, sondes nommees) pour le cas
|
|
multi-dalles. Meme principe, et c'est ce qui en fait une preuve : on relit le
|
|
.vchm produit et on le confronte aux points SOL BRUTS des .laz, sans rien
|
|
partager avec assemble_terrain.py ni avec lidar_to_heightmap.py. Une erreur
|
|
d'indexation dans l'un ne peut donc pas se compenser dans l'autre.
|
|
|
|
CE QUI EST VERIFIE, ET POURQUOI C'EST LE SUJET DE LA PHASE 9
|
|
|
|
1. JUSTESSE — a chaque sonde placee sur une jointure, l'altitude assemblee doit
|
|
valoir la mediane des points sol reels du voisinage, points pris dans les DEUX
|
|
dalles voisines indifferemment.
|
|
|
|
2. ALIGNEMENT (le controle decisif) — la meme comparaison est refaite en
|
|
DECALANT la lecture d'un noeud vers l'est, l'ouest, le nord et le sud. Un
|
|
assemblage decale d'une colonne resterait plausible sur du relief doux : c'est
|
|
le CONTRASTE entre la lecture directe et les quatre lectures decalees qui
|
|
prouve l'alignement, exactement comme le test nord/sud de la Phase 7. Si un
|
|
decalage colle aussi bien que la lecture directe, la sonde ne prouve rien et
|
|
c'est signale.
|
|
|
|
3. TEMOINS — les memes mesures sur des sondes prises LOIN de toute jointure. Si
|
|
l'ecart aux jointures ressemble a l'ecart des temoins, le raccord n'introduit
|
|
aucune degradation. C'est la comparaison qui compte, pas la valeur absolue :
|
|
sous couvert forestier dense, meme au milieu d'une dalle, l'ecart n'est jamais
|
|
nul.
|
|
|
|
Les frontieres sont deduites des NOMS des .laz (nomenclature IGN
|
|
LHD_FXX_<Xkm>_<Ykm>_...), pas de la maniere dont le terrain a ete assemble.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
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
|
|
GROUND_CLASS = 2
|
|
|
|
|
|
def read_vchm(path):
|
|
with open(path, "rb") as f:
|
|
header = f.read(HEADER_SIZE)
|
|
if header[:4] != b"VCHM":
|
|
sys.exit(f"{path} : ce n'est pas un .vchm")
|
|
nx = struct.unpack_from("<I", header, 8)[0]
|
|
nz = struct.unpack_from("<I", header, 12)[0]
|
|
spacing = struct.unpack_from("<f", header, 16)[0]
|
|
east = struct.unpack_from("<d", header, 24)[0]
|
|
north = struct.unpack_from("<d", header, 32)[0]
|
|
epsg = struct.unpack_from("<I", header, 48)[0]
|
|
label = header[56:120].split(b"\x00")[0].decode("utf-8", "replace")
|
|
grid = np.frombuffer(f.read(nx * nz * 4), dtype="<f4").reshape(nz, nx)
|
|
return dict(nx=nx, nz=nz, spacing=float(spacing), east=east, north=north,
|
|
epsg=epsg, label=label, grid=grid)
|
|
|
|
|
|
def tile_bounds(path):
|
|
"""(x_min, y_min, x_max, y_max) nominal d'une dalle, lu dans son nom."""
|
|
parts = os.path.basename(path).split("_")
|
|
for i in range(len(parts) - 1):
|
|
a, b = parts[i], parts[i + 1]
|
|
if a.isdigit() and b.isdigit() and len(a) == 4 and len(b) == 4:
|
|
x = int(a) * 1000
|
|
y = int(b) * 1000
|
|
return (x, y - 1000, x + 1000, y)
|
|
return None
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(
|
|
description="Verifie les jointures d'un terrain assemble contre les nuages bruts.")
|
|
parser.add_argument("vchm")
|
|
parser.add_argument("laz", nargs="+")
|
|
parser.add_argument("--step", type=float, default=25.0,
|
|
help="espacement des sondes le long d'une jointure, en m "
|
|
"(defaut 25)")
|
|
parser.add_argument("--min-points", type=int, default=4,
|
|
help="points sol minimum pour qu'une sonde compte (defaut 4)")
|
|
parser.add_argument("--tolerance", type=float, default=0.50,
|
|
help="ecart median tolere aux jointures, en m (defaut 0.50)")
|
|
args = parser.parse_args()
|
|
|
|
m = read_vchm(args.vchm)
|
|
nx, nz, cell = m["nx"], m["nz"], m["spacing"]
|
|
grid = m["grid"].astype(np.float64)
|
|
east0, north0 = m["east"], m["north"]
|
|
|
|
print(f"Terrain : {os.path.basename(args.vchm)} ('{m['label']}')")
|
|
print(f" {nx} x {nz} echantillons, pas {cell} m, EPSG:{m['epsg']}")
|
|
print(f" coin nord-ouest : E {east0:.0f}, N {north0:.0f}")
|
|
print(f" emprise : E {east0:.0f}..{east0 + (nx - 1) * cell:.0f}, "
|
|
f"N {north0 - (nz - 1) * cell:.0f}..{north0:.0f}")
|
|
|
|
bounds = {}
|
|
for path in args.laz:
|
|
b = tile_bounds(path)
|
|
if b is None:
|
|
print(f" ATTENTION : nom non reconnu, dalle ignoree : "
|
|
f"{os.path.basename(path)}")
|
|
continue
|
|
bounds[path] = b
|
|
|
|
if not bounds:
|
|
sys.exit("Aucune dalle exploitable.")
|
|
|
|
xs = sorted({b[0] for b in bounds.values()})
|
|
ys = sorted({b[3] for b in bounds.values()})
|
|
print(f" {len(bounds)} dalle(s), grille {len(xs)} x {len(ys)}")
|
|
|
|
# --- Frontieres interieures ---------------------------------------------
|
|
# Une frontiere verticale existe a chaque X de debut de dalle qui n'est pas
|
|
# le bord ouest du terrain ; idem au sud pour les horizontales.
|
|
seam_x = [x for x in xs if x > min(xs)]
|
|
seam_y = [y - 1000 for y in ys if y - 1000 > min(b[1] for b in bounds.values())]
|
|
|
|
print(f" frontieres interieures : {len(seam_x)} verticale(s) "
|
|
f"{[f'E{v}' for v in seam_x]}, {len(seam_y)} horizontale(s) "
|
|
f"{[f'N{v}' for v in seam_y]}")
|
|
|
|
if not seam_x and not seam_y:
|
|
print("\nAucune frontiere interieure : rien a verifier.")
|
|
return 0
|
|
|
|
# --- Sondes ---------------------------------------------------------------
|
|
# Chaque sonde est un NOEUD de la grille, repere par ses coordonnees
|
|
# Lambert 93. On evite les 2 noeuds extremes de chaque jointure (les coins du
|
|
# terrain n'ont pas de voisinage complet).
|
|
e_min, e_max = east0, east0 + (nx - 1) * cell
|
|
n_min, n_max = north0 - (nz - 1) * cell, north0
|
|
|
|
probes = [] # (categorie, E, N)
|
|
for sx in seam_x:
|
|
n = n_min + args.step
|
|
while n <= n_max - args.step:
|
|
probes.append((f"V E{sx}", float(sx), float(round(n))))
|
|
n += args.step
|
|
for sy in seam_y:
|
|
e = e_min + args.step
|
|
while e <= e_max - args.step:
|
|
probes.append((f"H N{sy}", float(round(e)), float(sy)))
|
|
e += args.step
|
|
|
|
# Temoins : loin de toute jointure (au moins 100 m), semis regulier decale
|
|
# pour ne jamais retomber sur une frontiere.
|
|
controls = 0
|
|
e = e_min + 137.0
|
|
while e <= e_max - 137.0:
|
|
n = n_min + 211.0
|
|
while n <= n_max - 211.0:
|
|
far_x = all(abs(e - sx) > 100 for sx in seam_x) if seam_x else True
|
|
far_y = all(abs(n - sy) > 100 for sy in seam_y) if seam_y else True
|
|
if far_x and far_y:
|
|
probes.append(("temoin", float(round(e)), float(round(n))))
|
|
controls += 1
|
|
n += 500.0
|
|
e += 500.0
|
|
|
|
print(f" sondes : {len(probes) - controls} sur jointure, {controls} temoins "
|
|
f"(pas de {args.step:g} m)")
|
|
|
|
# Index de grille de chaque sonde (meme regle d'affectation que le
|
|
# convertisseur : plus proche noeud, floor(t + 0.5)).
|
|
probe_ix = np.array([int(np.floor((p[1] - east0) / cell + 0.5)) for p in probes])
|
|
probe_iz = np.array([int(np.floor((north0 - p[2]) / cell + 0.5)) for p in probes])
|
|
|
|
inside = (probe_ix >= 1) & (probe_ix < nx - 1) & (probe_iz >= 1) & (probe_iz < nz - 1)
|
|
|
|
# Le croisement de deux jointures est engendre une fois par chacune : on ne
|
|
# garde qu'une sonde par noeud (la premiere, donc la jointure verticale).
|
|
seen: set[tuple[int, int]] = set()
|
|
unique = []
|
|
for index, keep in enumerate(inside):
|
|
node = (int(probe_ix[index]), int(probe_iz[index]))
|
|
if keep and node not in seen:
|
|
seen.add(node)
|
|
unique.append(index)
|
|
unique = np.asarray(unique, dtype=np.int64)
|
|
|
|
duplicates = int(inside.sum()) - len(unique)
|
|
if duplicates:
|
|
print(f" ({duplicates} sonde(s) en double au croisement de deux "
|
|
f"jointures, dedoublonnee(s))")
|
|
|
|
probes = [probes[i] for i in unique]
|
|
probe_ix, probe_iz = probe_ix[unique], probe_iz[unique]
|
|
count = len(probes)
|
|
|
|
# --- Collecte des points sol bruts autour de chaque sonde ----------------
|
|
# Une passe par .laz, en flux : chaque point est rattache au noeud le plus
|
|
# proche, et on ne garde que ceux qui tombent sur une sonde. Les points d'une
|
|
# sonde placee sur une jointure viennent donc des DEUX dalles voisines, ce
|
|
# qui est exactement le voisinage que le noeud partage devrait decrire.
|
|
keys = probe_ix.astype(np.int64) * np.int64(1 << 20) + probe_iz.astype(np.int64)
|
|
order = np.argsort(keys)
|
|
sorted_keys = keys[order]
|
|
if len(np.unique(sorted_keys)) != len(sorted_keys):
|
|
sys.exit("Sondes en double : ajuster --step.")
|
|
|
|
buckets: list[list[np.ndarray]] = [[] for _ in range(count)]
|
|
|
|
print(f"\nLecture des nuages bruts (classe {GROUND_CLASS})...")
|
|
for index, path in enumerate(sorted(bounds), 1):
|
|
total = 0
|
|
with laspy.open(path) as reader:
|
|
for chunk in reader.chunk_iterator(4_000_000):
|
|
keep = np.asarray(chunk.classification) == GROUND_CLASS
|
|
if not keep.any():
|
|
continue
|
|
px = np.asarray(chunk.x)[keep]
|
|
py = np.asarray(chunk.y)[keep]
|
|
pz = np.asarray(chunk.z)[keep]
|
|
|
|
ix = np.floor((px - east0) / cell + 0.5).astype(np.int64)
|
|
iz = np.floor((north0 - py) / cell + 0.5).astype(np.int64)
|
|
key = ix * np.int64(1 << 20) + iz
|
|
|
|
position = np.searchsorted(sorted_keys, key)
|
|
position[position >= len(sorted_keys)] = 0
|
|
hit = sorted_keys[position] == key
|
|
if not hit.any():
|
|
continue
|
|
for slot, value in zip(position[hit], pz[hit]):
|
|
buckets[order[slot]].append(value)
|
|
total += int(hit.sum())
|
|
|
|
sys.stdout.write(f"\r {index}/{len(bounds)} {os.path.basename(path)[:44]:<44s} "
|
|
f"{total:>7,} point(s) retenus ")
|
|
sys.stdout.flush()
|
|
print("\r" + " " * 90 + "\r", end="")
|
|
|
|
# --- Comparaison ----------------------------------------------------------
|
|
shifts = {"direct": (0, 0), "est +1": (1, 0), "ouest -1": (-1, 0),
|
|
"sud +1": (0, 1), "nord -1": (0, -1)}
|
|
errors: dict[str, dict[str, list[float]]] = {
|
|
name: {"jointure": [], "temoin": []} for name in shifts}
|
|
|
|
weak = 0
|
|
used = 0
|
|
per_seam: dict[str, list[float]] = {}
|
|
|
|
for i, (category, e, n) in enumerate(probes):
|
|
values = buckets[i]
|
|
if len(values) < args.min_points:
|
|
weak += 1
|
|
continue
|
|
reference = float(np.median(np.asarray(values, dtype=np.float64)))
|
|
used += 1
|
|
group = "temoin" if category == "temoin" else "jointure"
|
|
|
|
for name, (dx, dz) in shifts.items():
|
|
jx, jz = probe_ix[i] + dx, probe_iz[i] + dz
|
|
errors[name][group].append(abs(float(grid[jz, jx]) - reference))
|
|
|
|
if group == "jointure":
|
|
per_seam.setdefault(category, []).append(
|
|
abs(float(grid[probe_iz[i], probe_ix[i]]) - reference))
|
|
|
|
print(f"Sondes exploitables : {used}/{count} "
|
|
f"({weak} rejetee(s) faute de points sol — zone sous couvert ou hors dalle)")
|
|
|
|
if not used:
|
|
sys.exit("Aucune sonde exploitable : verifier que les .laz couvrent bien "
|
|
"l'emprise du terrain.")
|
|
|
|
# 1 + 2 : justesse et alignement, par le contraste
|
|
print(f"\n{'lecture':<12} {'jointures: median':>18} {'max':>9} "
|
|
f"{'| temoins: median':>20} {'max':>9}")
|
|
print("-" * 72)
|
|
direct_seam = None
|
|
for name in shifts:
|
|
seam_values = errors[name]["jointure"]
|
|
control_values = errors[name]["temoin"]
|
|
seam_median = float(np.median(seam_values)) if seam_values else float("nan")
|
|
seam_max = float(np.max(seam_values)) if seam_values else float("nan")
|
|
control_median = float(np.median(control_values)) if control_values else float("nan")
|
|
control_max = float(np.max(control_values)) if control_values else float("nan")
|
|
if name == "direct":
|
|
direct_seam = seam_median
|
|
mark = " <- lecture reelle" if name == "direct" else ""
|
|
print(f"{name:<12} {seam_median:>17.3f}m {seam_max:>8.3f}m "
|
|
f"{control_median:>19.3f}m {control_max:>8.3f}m{mark}")
|
|
|
|
# 3 : detail par frontiere — aucune ne doit se distinguer des autres
|
|
print(f"\nDetail par frontiere ({'V' } = verticale, 'H' = horizontale) :")
|
|
print(f" {'frontiere':<14} {'sondes':>7} {'median':>9} {'moyen':>9} {'max':>9}")
|
|
worst_seam = 0.0
|
|
for name in sorted(per_seam):
|
|
values = np.asarray(per_seam[name])
|
|
worst_seam = max(worst_seam, float(np.median(values)))
|
|
print(f" {name:<14} {values.size:>7} {np.median(values):>8.3f}m "
|
|
f"{values.mean():>8.3f}m {values.max():>8.3f}m")
|
|
|
|
# --- Verdict --------------------------------------------------------------
|
|
print()
|
|
failures = []
|
|
|
|
shifted = [float(np.median(errors[name]["jointure"]))
|
|
for name in shifts if name != "direct"]
|
|
best_shift = min(shifted)
|
|
if direct_seam is None or not (direct_seam < best_shift):
|
|
failures.append(
|
|
f"ALIGNEMENT : la lecture directe ({direct_seam:.3f} m) n'est pas "
|
|
f"meilleure que le meilleur decalage ({best_shift:.3f} m). "
|
|
f"L'assemblage est probablement decale d'un noeud.")
|
|
else:
|
|
ratio = best_shift / direct_seam if direct_seam > 0 else float("inf")
|
|
print(f"ALIGNEMENT OK : lecture directe {direct_seam:.3f} m contre "
|
|
f"{best_shift:.3f} m pour le meilleur decalage "
|
|
f"(x{ratio:.1f}). Le contraste prouve que les jointures tombent "
|
|
f"exactement sur le bon noeud.")
|
|
|
|
if worst_seam > args.tolerance:
|
|
failures.append(f"JUSTESSE : une frontiere depasse la tolerance "
|
|
f"({worst_seam:.3f} m > {args.tolerance:.2f} m).")
|
|
else:
|
|
print(f"JUSTESSE OK : toutes les frontieres sous {args.tolerance:.2f} m "
|
|
f"(pire mediane {worst_seam:.3f} m).")
|
|
|
|
control_median = float(np.median(errors["direct"]["temoin"])) \
|
|
if errors["direct"]["temoin"] else float("nan")
|
|
if np.isfinite(control_median):
|
|
if direct_seam > max(3.0 * control_median, control_median + 0.30):
|
|
failures.append(
|
|
f"DEGRADATION : l'ecart aux jointures ({direct_seam:.3f} m) est "
|
|
f"nettement pire qu'en plein milieu de dalle "
|
|
f"({control_median:.3f} m).")
|
|
else:
|
|
print(f"NON-DEGRADATION OK : jointures {direct_seam:.3f} m vs "
|
|
f"plein milieu de dalle {control_median:.3f} m — le raccord "
|
|
f"n'est pas moins fidele que le reste du terrain.")
|
|
|
|
if failures:
|
|
print()
|
|
for f in failures:
|
|
print(f" ECHEC — {f}")
|
|
return 1
|
|
|
|
print("\nToutes les frontieres sont conformes.")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|