Premier commit
Cette révision appartient à :
révision
84a72fe30c
200 fichiers modifiés
+61602
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,328 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
assemble_terrain.py — raccorde N heightmaps .vchm voisines en UN seul terrain.
|
||||
|
||||
PHASE 9. La Phase 7 avait valide le pipeline sur une dalle isolee ; c'est ici que
|
||||
se joue ce que ses deux bugs d'arrondi auraient casse en silence (arrondi
|
||||
bancaire, intervalle semi-ouvert inverse sur l'axe nord). Rien n'est suppose :
|
||||
chaque dalle est placee par son GEOREFERENCEMENT (originEast/originNorth lus dans
|
||||
son en-tete), jamais par son ordre dans la ligne de commande ou son nom.
|
||||
|
||||
python tools/assemble_terrain.py assets/terrain/LHD_*_1m.vchm \
|
||||
-o assets/terrain/vercora_zone_1m.vchm --label vercora_zone_5x5
|
||||
|
||||
Options :
|
||||
--label L nom inscrit dans l'en-tete du fichier produit
|
||||
--allow-gaps accepter une grille incomplete (trous combles par voisinage)
|
||||
--quiet-seams n'afficher que le bilan des jointures, pas le detail
|
||||
|
||||
LE NOEUD PARTAGE — le point non evident de tout l'assemblage. Les echantillons
|
||||
sont sur les NOEUDS : une dalle de 1 km au pas de 1 m fait 1001 echantillons, de
|
||||
X=899000 a X=900000 INCLUS. La dalle voisine commence a X=900000, elle aussi
|
||||
inclus. La colonne X=900000 existe donc DANS LES DEUX, et 5 dalles alignees font
|
||||
5*1001-4 = 5001 echantillons, pas 5005.
|
||||
|
||||
Concatener betement produirait 5005 colonnes : le terrain serait 4 m trop large
|
||||
et decalerait tout ce qui est a l'est d'une jointure. C'est precisement la
|
||||
"duplication de ligne/colonne a la jointure" a ne pas commettre.
|
||||
|
||||
Mais ces deux valeurs partagees ne sont PAS identiques, et c'est normal : le
|
||||
noeud X=900000 agrege les points de [899999.5, 900000.5[. La dalle ouest n'en
|
||||
voit que la moitie gauche, la dalle est que la moitie droite. Chacune calcule
|
||||
donc une mediane sur la moitie des points. L'ecart entre les deux est une mesure
|
||||
DIRECTE de la coherence du raccord — c'est le chiffre que ce script rapporte, et
|
||||
il doit rester de l'ordre du bruit de mesure (centimetres), pas du metre. La
|
||||
valeur retenue est leur MOYENNE.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
MAGIC = b"VCHM"
|
||||
VERSION = 1
|
||||
HEADER_SIZE = 120
|
||||
LABEL_SIZE = 64
|
||||
FLAG_ABSOLUTE_ALTITUDE = 1 << 0
|
||||
|
||||
|
||||
def read_vchm(path: str):
|
||||
with open(path, "rb") as f:
|
||||
header = f.read(HEADER_SIZE)
|
||||
if len(header) != HEADER_SIZE or header[:4] != MAGIC:
|
||||
sys.exit(f"{path} : ce n'est pas un fichier .vchm")
|
||||
version = struct.unpack_from("<I", header, 4)[0]
|
||||
if version != VERSION:
|
||||
sys.exit(f"{path} : version {version} inconnue")
|
||||
samples_x = struct.unpack_from("<I", header, 8)[0]
|
||||
samples_z = struct.unpack_from("<I", header, 12)[0]
|
||||
spacing = struct.unpack_from("<f", header, 16)[0]
|
||||
origin_east = struct.unpack_from("<d", header, 24)[0]
|
||||
origin_north = struct.unpack_from("<d", header, 32)[0]
|
||||
epsg = struct.unpack_from("<I", header, 48)[0]
|
||||
flags = struct.unpack_from("<I", header, 52)[0]
|
||||
label = header[56:56 + LABEL_SIZE].split(b"\x00")[0].decode("utf-8", "replace")
|
||||
|
||||
count = samples_x * samples_z
|
||||
data = f.read(count * 4)
|
||||
if len(data) != count * 4:
|
||||
sys.exit(f"{path} : fichier tronque")
|
||||
heights = np.frombuffer(data, dtype="<f4").reshape(samples_z, samples_x)
|
||||
|
||||
return {
|
||||
"path": path, "nx": samples_x, "nz": samples_z, "spacing": spacing,
|
||||
"east": origin_east, "north": origin_north, "epsg": epsg,
|
||||
"flags": flags, "label": label, "heights": heights,
|
||||
}
|
||||
|
||||
|
||||
def write_vchm(path, heights, spacing, origin_east, origin_north, label, epsg, flags):
|
||||
nz, nx = heights.shape
|
||||
header = bytearray(HEADER_SIZE)
|
||||
header[0:4] = MAGIC
|
||||
struct.pack_into("<I", header, 4, VERSION)
|
||||
struct.pack_into("<I", header, 8, nx)
|
||||
struct.pack_into("<I", header, 12, nz)
|
||||
struct.pack_into("<f", header, 16, float(spacing))
|
||||
struct.pack_into("<I", header, 20, 0)
|
||||
struct.pack_into("<d", header, 24, float(origin_east))
|
||||
struct.pack_into("<d", header, 32, float(origin_north))
|
||||
struct.pack_into("<f", header, 40, float(np.nanmin(heights)))
|
||||
struct.pack_into("<f", header, 44, float(np.nanmax(heights)))
|
||||
struct.pack_into("<I", header, 48, int(epsg))
|
||||
struct.pack_into("<I", header, 52, int(flags))
|
||||
encoded = label.encode("utf-8")[:LABEL_SIZE - 1]
|
||||
header[56:56 + len(encoded)] = encoded
|
||||
|
||||
with open(path, "wb") as f:
|
||||
f.write(header)
|
||||
f.write(np.ascontiguousarray(heights, dtype="<f4").tobytes())
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Raccorde N heightmaps .vchm voisines en un seul terrain.")
|
||||
parser.add_argument("inputs", nargs="+")
|
||||
parser.add_argument("-o", "--output", required=True)
|
||||
parser.add_argument("--label", default="")
|
||||
parser.add_argument("--allow-gaps", action="store_true")
|
||||
parser.add_argument("--quiet-seams", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
tiles = [read_vchm(p) for p in args.inputs]
|
||||
print(f"Entree : {len(tiles)} dalle(s)")
|
||||
|
||||
# --- Coherence globale ---------------------------------------------------
|
||||
spacing = tiles[0]["spacing"]
|
||||
epsg = tiles[0]["epsg"]
|
||||
flags = tiles[0]["flags"]
|
||||
for t in tiles:
|
||||
if abs(t["spacing"] - spacing) > 1e-6:
|
||||
sys.exit(f"{t['path']} : pas de {t['spacing']} m, attendu {spacing} m. "
|
||||
f"Toutes les dalles doivent avoir la meme resolution.")
|
||||
if t["epsg"] != epsg:
|
||||
sys.exit(f"{t['path']} : EPSG {t['epsg']}, attendu {epsg}.")
|
||||
if t["flags"] != flags:
|
||||
sys.exit(f"{t['path']} : flags {t['flags']}, attendu {flags} "
|
||||
f"(melange d'altitudes absolues et relatives ?)")
|
||||
|
||||
# --- Reseau global : chaque dalle placee par son georeferencement ---------
|
||||
global_east = min(t["east"] for t in tiles)
|
||||
global_north = max(t["north"] for t in tiles)
|
||||
|
||||
for t in tiles:
|
||||
# Decalage en NOEUDS depuis le coin nord-ouest global. L'axe nord
|
||||
# DESCEND quand iz monte (lignes stockees du nord vers le sud), d'ou le
|
||||
# sens oppose des deux expressions.
|
||||
offset_x = (t["east"] - global_east) / spacing
|
||||
offset_z = (global_north - t["north"]) / spacing
|
||||
# Une dalle qui ne tombe pas sur le reseau (decalage non entier) rendrait
|
||||
# tout l'assemblage faux d'une fraction de cellule, sans rien casser de
|
||||
# visible : on refuse.
|
||||
if abs(offset_x - round(offset_x)) > 1e-6 or abs(offset_z - round(offset_z)) > 1e-6:
|
||||
sys.exit(f"{t['path']} : origine (E {t['east']}, N {t['north']}) hors "
|
||||
f"du reseau au pas de {spacing} m "
|
||||
f"(decalage {offset_x}, {offset_z} noeuds).")
|
||||
t["ox"] = int(round(offset_x))
|
||||
t["oz"] = int(round(offset_z))
|
||||
|
||||
total_nx = max(t["ox"] + t["nx"] for t in tiles)
|
||||
total_nz = max(t["oz"] + t["nz"] for t in tiles)
|
||||
|
||||
print(f" pas {spacing} m, EPSG {epsg}")
|
||||
print(f" coin nord-ouest global : E {global_east:.0f}, N {global_north:.0f}")
|
||||
print(f" grille assemblee : {total_nx} x {total_nz} echantillons "
|
||||
f"({(total_nx - 1) * spacing:.0f} x {(total_nz - 1) * spacing:.0f} m)")
|
||||
|
||||
naive = sum(t["nx"] for t in tiles if t["oz"] == 0)
|
||||
if naive and naive != total_nx:
|
||||
print(f" (une concatenation naive aurait donne {naive} colonnes : "
|
||||
f"les {naive - total_nx} noeuds de bord sont PARTAGES, pas dupliques)")
|
||||
|
||||
# --- Report ---------------------------------------------------------------
|
||||
accumulator = np.zeros((total_nz, total_nx), dtype=np.float64)
|
||||
contributions = np.zeros((total_nz, total_nx), dtype=np.int32)
|
||||
|
||||
for t in tiles:
|
||||
z0, x0 = t["oz"], t["ox"]
|
||||
view = t["heights"].astype(np.float64)
|
||||
if not np.isfinite(view).all():
|
||||
sys.exit(f"{t['path']} : contient des valeurs non finies (NaN/inf). "
|
||||
f"Le convertisseur aurait du les boucher.")
|
||||
accumulator[z0:z0 + t["nz"], x0:x0 + t["nx"]] += view
|
||||
contributions[z0:z0 + t["nz"], x0:x0 + t["nx"]] += 1
|
||||
|
||||
covered = contributions > 0
|
||||
missing = int((~covered).sum())
|
||||
if missing:
|
||||
message = (f"{missing} noeud(s) ({100.0 * missing / covered.size:.2f} %) "
|
||||
f"ne sont couverts par aucune dalle")
|
||||
if not args.allow_gaps:
|
||||
sys.exit(f" ERREUR : {message}. La grille de dalles est incomplete. "
|
||||
f"Utiliser --allow-gaps pour passer outre.")
|
||||
print(f" ATTENTION : {message} — combles par voisinage.")
|
||||
|
||||
with np.errstate(invalid="ignore"):
|
||||
heights = accumulator / np.maximum(contributions, 1)
|
||||
heights[~covered] = np.nan
|
||||
|
||||
# --- LE CONTROLE : ecart entre les deux versions d'un noeud partage -------
|
||||
shared = contributions > 1
|
||||
shared_count = int(shared.sum())
|
||||
print(f"\nJointures : {shared_count:,} noeud(s) partage(s) par "
|
||||
f"{contributions.max()} dalles au plus")
|
||||
|
||||
worst_overall = 0.0
|
||||
if shared_count:
|
||||
# Pour chaque paire de dalles qui se recouvrent, mesurer l'ecart entre
|
||||
# ce que chacune dit du meme point du sol. C'est la mesure directe de la
|
||||
# coherence du raccord : elle ne peut pas etre "compensee" par le
|
||||
# placement, puisqu'elle compare deux valeurs a la MEME position.
|
||||
seams = []
|
||||
for i, a in enumerate(tiles):
|
||||
for b in tiles[i + 1:]:
|
||||
x0 = max(a["ox"], b["ox"])
|
||||
x1 = min(a["ox"] + a["nx"], b["ox"] + b["nx"])
|
||||
z0 = max(a["oz"], b["oz"])
|
||||
z1 = min(a["oz"] + a["nz"], b["oz"] + b["nz"])
|
||||
if x1 <= x0 or z1 <= z0:
|
||||
continue
|
||||
va = a["heights"][z0 - a["oz"]:z1 - a["oz"],
|
||||
x0 - a["ox"]:x1 - a["ox"]].astype(np.float64)
|
||||
vb = b["heights"][z0 - b["oz"]:z1 - b["oz"],
|
||||
x0 - b["ox"]:x1 - b["ox"]].astype(np.float64)
|
||||
delta = np.abs(va - vb)
|
||||
kind = ("colonne" if (x1 - x0) == 1 else
|
||||
"ligne" if (z1 - z0) == 1 else "bloc")
|
||||
seams.append((a["label"] or os.path.basename(a["path"]),
|
||||
b["label"] or os.path.basename(b["path"]),
|
||||
kind, delta.size, float(delta.mean()),
|
||||
float(np.median(delta)), float(delta.max())))
|
||||
worst_overall = max(worst_overall, float(delta.max()))
|
||||
|
||||
seams.sort(key=lambda s: -s[6])
|
||||
if not args.quiet_seams:
|
||||
print(f" {'dalle A':<20s} {'dalle B':<20s} {'type':<8s} "
|
||||
f"{'noeuds':>7s} {'moyen':>8s} {'median':>8s} {'max':>8s}")
|
||||
for a, b, kind, n, mean, med, mx in seams:
|
||||
print(f" {a[:20]:<20s} {b[:20]:<20s} {kind:<8s} {n:>7,} "
|
||||
f"{mean:>7.3f}m {med:>7.3f}m {mx:>7.3f}m")
|
||||
|
||||
all_delta = np.concatenate([np.array([s[4]]) for s in seams])
|
||||
print(f" ecart moyen sur l'ensemble des jointures : "
|
||||
f"{all_delta.mean():.3f} m, pire ecart ponctuel : {worst_overall:.3f} m")
|
||||
|
||||
# --- Continuite mesuree sur le produit fini ------------------------------
|
||||
# Test independant du placement : le long d'une jointure, la difference
|
||||
# entre deux colonnes voisines doit ressembler a celle qu'on observe
|
||||
# PARTOUT ailleurs. Un decalage d'un metre la rendrait anormalement GRANDE ;
|
||||
# une colonne dupliquee la rendrait anormalement PETITE (deux colonnes
|
||||
# identiques = pente nulle). Les deux defauts sont donc attrapes, et par une
|
||||
# mesure faite sur le fichier final, sans rien savoir des dalles d'origine.
|
||||
print("\nContinuite du terrain assemble (gradient aux jointures vs partout) :")
|
||||
finite = np.isfinite(heights)
|
||||
grad_x = np.abs(np.diff(heights, axis=1))
|
||||
grad_z = np.abs(np.diff(heights, axis=0))
|
||||
reference_x = float(np.nanmedian(grad_x))
|
||||
reference_z = float(np.nanmedian(grad_z))
|
||||
print(f" reference : pente mediane est-ouest {reference_x:.3f} m/m, "
|
||||
f"nord-sud {reference_z:.3f} m/m")
|
||||
|
||||
seam_columns = sorted({t["ox"] for t in tiles if t["ox"] > 0})
|
||||
seam_rows = sorted({t["oz"] for t in tiles if t["oz"] > 0})
|
||||
anomalies = 0
|
||||
|
||||
for column in seam_columns:
|
||||
# Le raccord se joue entre les colonnes column-1 et column+1 autour du
|
||||
# noeud partage `column` : on regarde les deux transitions qui l'encadrent.
|
||||
left = float(np.nanmedian(grad_x[:, column - 1]))
|
||||
right = float(np.nanmedian(grad_x[:, column]))
|
||||
flag = ""
|
||||
for value in (left, right):
|
||||
if reference_x > 0 and (value > 6.0 * reference_x or value < reference_x / 6.0):
|
||||
flag = " <-- ANOMALIE"
|
||||
anomalies += 1
|
||||
print(f" jointure verticale x={column:>5d} : "
|
||||
f"{left:.3f} / {right:.3f} m/m{flag}")
|
||||
|
||||
for row in seam_rows:
|
||||
top = float(np.nanmedian(grad_z[row - 1, :]))
|
||||
bottom = float(np.nanmedian(grad_z[row, :]))
|
||||
flag = ""
|
||||
for value in (top, bottom):
|
||||
if reference_z > 0 and (value > 6.0 * reference_z or value < reference_z / 6.0):
|
||||
flag = " <-- ANOMALIE"
|
||||
anomalies += 1
|
||||
print(f" jointure horizontale z={row:>5d} : "
|
||||
f"{top:.3f} / {bottom:.3f} m/m{flag}")
|
||||
|
||||
if anomalies:
|
||||
print(f" {anomalies} ANOMALIE(S) : une jointure ne se comporte pas comme "
|
||||
f"le reste du terrain (decalage ou duplication).")
|
||||
elif seam_columns or seam_rows:
|
||||
print(" OK — aucune jointure ne se distingue du relief environnant.")
|
||||
|
||||
# --- Ecriture -------------------------------------------------------------
|
||||
if missing:
|
||||
# Meme dilatation que le convertisseur, pour ne jamais livrer de NaN.
|
||||
from math import inf
|
||||
passes = 0
|
||||
while not np.isfinite(heights).all() and passes < 512:
|
||||
passes += 1
|
||||
filled = np.where(np.isfinite(heights), heights, 0.0)
|
||||
valid = np.isfinite(heights).astype(np.float64)
|
||||
total = np.zeros_like(filled)
|
||||
weight = np.zeros_like(valid)
|
||||
for dz, dx in ((-1, 0), (1, 0), (0, -1), (0, 1)):
|
||||
total += np.roll(np.roll(filled, dz, 0), dx, 1)
|
||||
weight += np.roll(np.roll(valid, dz, 0), dx, 1)
|
||||
candidate = np.where(weight > 0, total / np.maximum(weight, 1), np.nan)
|
||||
heights = np.where(np.isfinite(heights), heights, candidate)
|
||||
print(f" trous combles en {passes} passes")
|
||||
|
||||
if not np.isfinite(heights).all():
|
||||
sys.exit("ERREUR : des valeurs non finies subsistent, refus d'ecrire.")
|
||||
|
||||
label = args.label or f"assemblage {len(tiles)} dalles"
|
||||
write_vchm(args.output, heights.astype(np.float32), spacing,
|
||||
global_east, global_north, label, epsg, flags)
|
||||
written = os.path.getsize(args.output)
|
||||
|
||||
print(f"\nSortie : {args.output} ({written / (1 << 20):.1f} Mo)")
|
||||
print(f" {total_nx} x {total_nz} echantillons, pas {spacing} m")
|
||||
print(f" origine (echantillon 0,0 = coin NORD-OUEST) : "
|
||||
f"E {global_east:.0f}, N {global_north:.0f} [EPSG:{epsg}]")
|
||||
print(f" altitudes : {np.nanmin(heights):.2f} .. {np.nanmax(heights):.2f} m "
|
||||
f"(denivele {np.nanmax(heights) - np.nanmin(heights):.2f} m)")
|
||||
|
||||
return 1 if anomalies else 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,159 @@
|
||||
@echo off
|
||||
rem ===========================================================================
|
||||
rem Build complet de Vercora (configuration + compilation).
|
||||
rem ===========================================================================
|
||||
rem CMake et Ninja AUTONOMES + generateur Ninja, volontairement. Raison :
|
||||
rem
|
||||
rem L'installation Visual Studio 18 Community de cette machine est
|
||||
rem PARTIELLEMENT CORROMPUE : 1695 fichiers sur 9692 examines sont remplis de
|
||||
rem zeros binaires au lieu de leur contenu (constate le 2026-08-15).
|
||||
rem - CMake livre avec VS : 1590 fichiers sur 4103 detruits, dont des modules
|
||||
rem indispensables comme CMakeDetermineSystem.cmake -> inutilisable.
|
||||
rem - Ninja livre avec VS : binaire entierement a zero -> inutilisable.
|
||||
rem - MSBuild : 105 fichiers detruits, dont Linux.TargetNames.props, ce qui
|
||||
rem fait echouer TOUT projet C++ (MSB4024) et donc le generateur
|
||||
rem "Visual Studio 18 2026" des la configuration.
|
||||
rem
|
||||
rem En revanche le COMPILATEUR est intact : 0 fichier corrompu dans
|
||||
rem VC\Tools\MSVC\...\bin, \include et \lib. cl.exe, ses en-tetes et ses libs
|
||||
rem fonctionnent. C'est pour ca qu'on garde vcvars64 de VS pour l'environnement
|
||||
rem de compilation, mais qu'on prend CMake et Ninja ailleurs.
|
||||
rem
|
||||
rem Correctif machine recommande : "Reparer" depuis Visual Studio Installer, et
|
||||
rem verifier la sante du disque - une corruption massive et silencieuse de ce
|
||||
rem type vient generalement du stockage ou d'un arret brutal.
|
||||
rem
|
||||
rem Usage : tools\build.bat [Debug|Release] (defaut : Debug)
|
||||
rem
|
||||
rem Debug est le defaut a dessein : c'est la configuration qui definit
|
||||
rem VERCORA_DEBUG, donc la seule ou les COUCHES DE VALIDATION Vulkan sont
|
||||
rem actives (voir CMakeLists.txt et VulkanContext.cpp).
|
||||
rem ===========================================================================
|
||||
|
||||
setlocal
|
||||
|
||||
set "CONFIG=%~1"
|
||||
if "%CONFIG%"=="" set "CONFIG=Debug"
|
||||
|
||||
set "VS=C:\Program Files\Microsoft Visual Studio\18\Community"
|
||||
set "VCVARS=%VS%\VC\Auxiliary\Build\vcvars64.bat"
|
||||
|
||||
rem CMake et Ninja autonomes (winget : Kitware.CMake, Ninja-build.Ninja), et NON
|
||||
rem ceux de Visual Studio, qui sont corrompus sur cette machine - voir l'en-tete.
|
||||
set "CMAKE=C:\Program Files\CMake\bin\cmake.exe"
|
||||
set "NINJA=%LOCALAPPDATA%\Microsoft\WinGet\Packages\Ninja-build.Ninja_Microsoft.Winget.Source_8wekyb3d8bbwe\ninja.exe"
|
||||
|
||||
if not exist "%VCVARS%" (
|
||||
echo [ERREUR] vcvars64.bat introuvable : "%VCVARS%"
|
||||
exit /b 1
|
||||
)
|
||||
if not exist "%CMAKE%" (
|
||||
echo [ERREUR] cmake.exe introuvable : "%CMAKE%"
|
||||
echo Installer avec : winget install --id Kitware.CMake
|
||||
exit /b 1
|
||||
)
|
||||
if not exist "%NINJA%" (
|
||||
echo [ERREUR] ninja.exe introuvable : "%NINJA%"
|
||||
echo Installer avec : winget install --id Ninja-build.Ninja
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
call "%VCVARS%" >nul 2>&1
|
||||
|
||||
rem --- Prechauffage de rc.exe --------------------------------------------
|
||||
rem Sur cette machine, la PREMIERE execution de rc.exe (compilateur de
|
||||
rem ressources du Windows SDK) apres un moment d'inactivite echoue avec le code
|
||||
rem -1 et AUCUNE sortie ; les suivantes passent. Mesure : 1 echec suivi de 7
|
||||
rem succes sur 8 essais consecutifs. C'est la signature d'un antivirus temps
|
||||
rem reel qui bloque la creation du processus le temps d'analyser le binaire.
|
||||
rem
|
||||
rem CMake appelle rc.exe pour embarquer le manifeste a chaque edition de liens :
|
||||
rem sans ce prechauffage, la configuration ou le build echouent au hasard, avec
|
||||
rem un message trompeur du genre "le compilateur ne peut pas compiler un
|
||||
rem programme simple".
|
||||
rem
|
||||
rem Correctif machine (a faire par l'utilisateur, cote securite - pas par ce
|
||||
rem script) : ajouter une exclusion Windows Defender sur le dossier du Windows
|
||||
rem Kit, ou sur le dossier de build.
|
||||
rem Plusieurs appels, et pas un seul : un prechauffage unique s'est revele
|
||||
rem insuffisant (une configuration propre a encore echoue une fois sur deux).
|
||||
rem Ces appels sont instantanes et leur code de retour est sans importance - le
|
||||
rem but est uniquement que le binaire soit deja analyse et en cache quand CMake
|
||||
rem s'en servira pour de bon.
|
||||
for %%R in ("%WindowsSdkVerBinPath%x64\rc.exe") do if exist %%R (
|
||||
%%R /? >nul 2>&1
|
||||
%%R /? >nul 2>&1
|
||||
%%R /? >nul 2>&1
|
||||
)
|
||||
|
||||
rem --- Vulkan SDK ------------------------------------------------------------
|
||||
rem find_package(Vulkan) s'appuie sur la variable VULKAN_SDK. L'installateur
|
||||
rem LunarG la pose au niveau MACHINE, mais un shell deja ouvert avant
|
||||
rem l'installation ne la voit pas. On la recupere donc explicitement : d'abord
|
||||
rem l'environnement, puis le registre, puis le dossier d'installation par defaut.
|
||||
if not defined VULKAN_SDK (
|
||||
for /f "tokens=2,*" %%A in ('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v VULKAN_SDK 2^>nul ^| find "VULKAN_SDK"') do set "VULKAN_SDK=%%B"
|
||||
)
|
||||
if not defined VULKAN_SDK (
|
||||
for /f "delims=" %%D in ('dir /b /ad /o-n "C:\VulkanSDK" 2^>nul') do (
|
||||
if not defined VULKAN_SDK set "VULKAN_SDK=C:\VulkanSDK\%%D"
|
||||
)
|
||||
)
|
||||
if not defined VULKAN_SDK (
|
||||
echo [ERREUR] SDK Vulkan introuvable. Installer avec :
|
||||
echo winget install --id KhronosGroup.VulkanSDK
|
||||
exit /b 1
|
||||
)
|
||||
if not exist "%VULKAN_SDK%\Include\vulkan\vulkan.h" (
|
||||
echo [ERREUR] VULKAN_SDK pointe sur "%VULKAN_SDK%" mais Include\vulkan\vulkan.h y est absent.
|
||||
exit /b 1
|
||||
)
|
||||
echo Vulkan SDK : %VULKAN_SDK%
|
||||
|
||||
set "ROOT=%~dp0.."
|
||||
pushd "%ROOT%"
|
||||
|
||||
rem FETCHCONTENT_FULLY_DISCONNECTED=ON : interdit tout acces reseau. GLFW, GLM et
|
||||
rem tinyobjloader sont deja en cache dans external\, il n'y a rien a
|
||||
rem retelecharger. Si cette option fait echouer la configuration, c'est que le
|
||||
rem cache est reellement inutilisable - et seulement dans ce cas il faudra la
|
||||
rem retirer pour laisser FetchContent refaire son travail.
|
||||
call :configure
|
||||
if errorlevel 1 (
|
||||
rem Une seule reprise, et uniquement pour ce cas precis : l'antivirus peut
|
||||
rem encore bloquer rc.exe pendant le test du compilateur, ce qui fait echouer
|
||||
rem la configuration avec un message trompeur ("le compilateur ne peut pas
|
||||
rem compiler un programme simple"). Une vraie erreur de projet, elle,
|
||||
rem echouerait aussi a la seconde tentative.
|
||||
echo.
|
||||
echo [ATTENTION] Configuration echouee, nouvelle tentative ^(rc.exe est
|
||||
echo probablement encore analyse par l'antivirus^)...
|
||||
rmdir /s /q build 2>nul
|
||||
call :configure
|
||||
if errorlevel 1 (
|
||||
echo.
|
||||
echo [ECHEC] Configuration CMake ^(deux tentatives^).
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
)
|
||||
|
||||
"%CMAKE%" --build build
|
||||
if errorlevel 1 (
|
||||
echo.
|
||||
echo [ECHEC] Compilation.
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [OK] Build %CONFIG% termine : %ROOT%\build\vercora.exe
|
||||
popd
|
||||
exit /b 0
|
||||
|
||||
:configure
|
||||
"%CMAKE%" -S . -B build -G Ninja ^
|
||||
-DCMAKE_MAKE_PROGRAM="%NINJA%" ^
|
||||
-DCMAKE_BUILD_TYPE=%CONFIG% ^
|
||||
-DFETCHCONTENT_FULLY_DISCONNECTED=ON
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,360 @@
|
||||
#!/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())
|
||||
@@ -0,0 +1,227 @@
|
||||
#!/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())
|
||||
@@ -0,0 +1,37 @@
|
||||
$dest = "C:\Users\theog\Desktop\Vercora.Beta"
|
||||
if (-not (Test-Path $dest)) {
|
||||
New-Item -ItemType Directory -Path $dest -Force | Out-Null
|
||||
}
|
||||
|
||||
Copy-Item -Path "build\vercora.exe" -Destination $dest -Force
|
||||
Copy-Item -Path "dist\VercoraDemo\*.dll" -Destination $dest -Force
|
||||
Copy-Item -Path "build\shaders" -Destination $dest -Recurse -Force
|
||||
Copy-Item -Path "dist\VercoraDemo\assets" -Destination $dest -Recurse -Force
|
||||
|
||||
$batContent = @"
|
||||
@echo off
|
||||
cd /d "%~dp0"
|
||||
start "" "vercora.exe" --demo
|
||||
"@
|
||||
Set-Content -Path "$dest\Lancer_Demo.bat" -Value $batContent -Encoding ASCII
|
||||
|
||||
$readmeContent = @"
|
||||
Vercora - DEMO (Exploration & Vol libre)
|
||||
========================================
|
||||
|
||||
Pour lancer la demo : double-cliquez sur Lancer_Demo.bat ou vercora.exe.
|
||||
|
||||
Commandes :
|
||||
- Clic droit maintenu + Souris : Regarder autour de soi / orienter la vue
|
||||
- Touches Z, Q, S, D (ou W, A, S, D) : Se deplacer
|
||||
- Touche F : Basculer entre Marche et Vol libre
|
||||
- Touche O : Basculer entre l'orthophoto aerienne et la coloration procedurale
|
||||
- Fermer : Croix de la fenetre ou Alt+F4
|
||||
|
||||
Cette version demo se concentre sur l'exploration du massif (25 km2 LiDAR)
|
||||
en marche et vol libre, sans les activites complexes ni survie.
|
||||
"@
|
||||
Set-Content -Path "$dest\LisezMoi.txt" -Value $readmeContent -Encoding UTF8
|
||||
|
||||
Write-Host "Deploiement termine dans $dest :"
|
||||
Get-ChildItem -Path $dest
|
||||
@@ -0,0 +1,334 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
fetch_dalles.py — telecharge un lot de dalles LiDAR HD IGN decrites par un JSON.
|
||||
|
||||
PHASE 9. La Phase 7 avait telecharge UNE dalle a la main ; ici il y en a 25, et
|
||||
un telechargement de plusieurs gigaoctets qui echoue a la 23e sans rien dire
|
||||
serait le pire resultat possible. D'ou : taille totale connue AVANT de commencer,
|
||||
reprise sur octets deja recus, reessais avec attente croissante, et un bilan
|
||||
final qui NOMME ce qui a echoue au lieu de s'arreter en silence.
|
||||
|
||||
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar
|
||||
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --only 0899-6440 0900-6440
|
||||
python tools/fetch_dalles.py vercora_dalles.json -o data/lidar --dry-run
|
||||
|
||||
Options :
|
||||
--only C [C ...] ne traiter que ces dalles (coordonnees_NW, ex. 0899-6440)
|
||||
--dry-run interroge les tailles et affiche le bilan, sans rien ecrire
|
||||
--retries N tentatives par dalle (defaut 4)
|
||||
--margin-go N marge de disque libre exigee en plus du lot (defaut 5)
|
||||
|
||||
FORMAT D'ENTREE attendu (celui exporte depuis data.geopf.fr) : un objet dont
|
||||
chaque valeur porte "url" et "metadata", cette derniere etant une CHAINE de JSON
|
||||
a re-parser (l'IGN imbrique du JSON dans du JSON) contenant au moins
|
||||
"coordonnees_NW" ("0899-6440" = coin nord-ouest en km Lambert 93) et
|
||||
"nombre_points".
|
||||
|
||||
REPRISE : un fichier deja present et complet (taille == Content-Length) est
|
||||
saute, pas retelecharge. Un fichier partiel est repris par requete Range si le
|
||||
serveur l'accepte, sinon reparti de zero. C'est ce qui rend le script rejouable
|
||||
apres une coupure sans repayer les gigaoctets deja recus.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
USER_AGENT = "Vercora/0.9 (+projet de jeu personnel; laspy pipeline)"
|
||||
TIMEOUT = 60
|
||||
CHUNK = 1 << 20 # 1 Mo
|
||||
|
||||
|
||||
def human(n: float) -> str:
|
||||
for unit in ("o", "Ko", "Mo", "Go"):
|
||||
if abs(n) < 1024 or unit == "Go":
|
||||
return f"{n:.1f} {unit}" if unit != "o" else f"{int(n)} o"
|
||||
n /= 1024.0
|
||||
return f"{n:.1f} Go"
|
||||
|
||||
|
||||
def human_time(seconds: float) -> str:
|
||||
seconds = int(seconds)
|
||||
if seconds < 60:
|
||||
return f"{seconds} s"
|
||||
if seconds < 3600:
|
||||
return f"{seconds // 60} min {seconds % 60:02d} s"
|
||||
return f"{seconds // 3600} h {(seconds % 3600) // 60:02d} min"
|
||||
|
||||
|
||||
def load_manifest(path: str, only: list[str] | None):
|
||||
"""Retourne [(coord, nom, url, nombre_points)] trie du nord-ouest au sud-est."""
|
||||
with open(path, "r", encoding="utf-8") as f:
|
||||
raw = json.load(f)
|
||||
|
||||
entries = []
|
||||
for name, item in raw.items():
|
||||
url = item["url"]
|
||||
# L'IGN imbrique le bloc de metadonnees comme une CHAINE de JSON.
|
||||
meta = item["metadata"]
|
||||
if isinstance(meta, str):
|
||||
meta = json.loads(meta)
|
||||
coord = meta["coordonnees_NW"]
|
||||
entries.append((coord, name, url, int(meta.get("nombre_points", 0))))
|
||||
|
||||
if only:
|
||||
wanted = set(only)
|
||||
kept = [e for e in entries if e[0] in wanted]
|
||||
missing = wanted - {e[0] for e in kept}
|
||||
if missing:
|
||||
sys.exit(f"--only : dalle(s) absente(s) du manifeste : "
|
||||
f"{', '.join(sorted(missing))}")
|
||||
entries = kept
|
||||
|
||||
# Nord-ouest -> sud-est : X croissant, Y DECROISSANT (le nord est en haut).
|
||||
def key(e):
|
||||
x, y = e[0].split("-")
|
||||
return (-int(y), int(x))
|
||||
|
||||
entries.sort(key=key)
|
||||
return entries
|
||||
|
||||
|
||||
def remote_size(url: str) -> int | None:
|
||||
"""Content-Length sans telecharger le corps. None si le serveur se tait."""
|
||||
request = urllib.request.Request(url, method="HEAD",
|
||||
headers={"User-Agent": USER_AGENT})
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
|
||||
length = response.headers.get("Content-Length")
|
||||
return int(length) if length is not None else None
|
||||
except (urllib.error.URLError, ValueError, TimeoutError):
|
||||
return None
|
||||
|
||||
|
||||
def download_one(url: str, destination: str, expected: int | None,
|
||||
retries: int, index: int, total: int, label: str) -> tuple[bool, str]:
|
||||
"""Telecharge avec reprise et reessais. Retourne (succes, message)."""
|
||||
temporary = destination + ".part"
|
||||
|
||||
for attempt in range(1, retries + 1):
|
||||
have = os.path.getsize(temporary) if os.path.exists(temporary) else 0
|
||||
|
||||
if expected is not None and have == expected:
|
||||
os.replace(temporary, destination)
|
||||
return True, "deja complet (.part)"
|
||||
if expected is not None and have > expected:
|
||||
# Fichier partiel incoherent (manifeste change, disque corrompu) :
|
||||
# mieux vaut repartir que concatener n'importe quoi.
|
||||
os.remove(temporary)
|
||||
have = 0
|
||||
|
||||
headers = {"User-Agent": USER_AGENT}
|
||||
if have > 0:
|
||||
headers["Range"] = f"bytes={have}-"
|
||||
|
||||
try:
|
||||
request = urllib.request.Request(url, headers=headers)
|
||||
with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
|
||||
# 200 sur une requete Range = le serveur ignore la reprise et
|
||||
# renvoie tout : il faut alors reecrire depuis le debut, sinon
|
||||
# on colle le fichier entier a la suite du morceau deja recu.
|
||||
resuming = (response.status == 206)
|
||||
if have > 0 and not resuming:
|
||||
have = 0
|
||||
|
||||
mode = "ab" if resuming and have > 0 else "wb"
|
||||
started = time.time()
|
||||
last_print = 0.0
|
||||
received = have
|
||||
|
||||
with open(temporary, mode) as f:
|
||||
while True:
|
||||
chunk = response.read(CHUNK)
|
||||
if not chunk:
|
||||
break
|
||||
f.write(chunk)
|
||||
received += len(chunk)
|
||||
|
||||
now = time.time()
|
||||
if now - last_print >= 0.5:
|
||||
last_print = now
|
||||
elapsed = max(now - started, 1e-6)
|
||||
speed = (received - have) / elapsed
|
||||
if expected:
|
||||
pct = 100.0 * received / expected
|
||||
eta = ((expected - received) / speed
|
||||
if speed > 0 else 0)
|
||||
bar_width = 24
|
||||
filled = int(bar_width * received / expected)
|
||||
bar = "#" * filled + "." * (bar_width - filled)
|
||||
sys.stdout.write(
|
||||
f"\r [{index}/{total}] {label} "
|
||||
f"[{bar}] {pct:5.1f}% "
|
||||
f"{human(received)}/{human(expected)} "
|
||||
f"{human(speed)}/s reste {human_time(eta)} ")
|
||||
else:
|
||||
sys.stdout.write(
|
||||
f"\r [{index}/{total}] {label} "
|
||||
f"{human(received)} {human(speed)}/s ")
|
||||
sys.stdout.flush()
|
||||
|
||||
sys.stdout.write("\r" + " " * 100 + "\r")
|
||||
sys.stdout.flush()
|
||||
|
||||
size = os.path.getsize(temporary)
|
||||
if expected is not None and size != expected:
|
||||
raise IOError(f"taille finale {size} != attendu {expected}")
|
||||
|
||||
# Un .laz commence par "LASF" : un HTML d'erreur enregistre sous le
|
||||
# bon nom passerait sinon inapercu jusqu'a la conversion.
|
||||
with open(temporary, "rb") as f:
|
||||
magic = f.read(4)
|
||||
if magic != b"LASF":
|
||||
raise IOError(f"en-tete inattendu {magic!r} (pas un LAS/LAZ)")
|
||||
|
||||
os.replace(temporary, destination)
|
||||
elapsed = time.time() - started
|
||||
return True, f"{human(size)} en {human_time(elapsed)}"
|
||||
|
||||
except (urllib.error.URLError, IOError, TimeoutError, OSError) as error:
|
||||
sys.stdout.write("\r" + " " * 100 + "\r")
|
||||
sys.stdout.flush()
|
||||
if attempt >= retries:
|
||||
return False, f"{type(error).__name__}: {error}"
|
||||
wait = min(2 ** attempt, 30)
|
||||
print(f" [{index}/{total}] {label} : echec ({error}), "
|
||||
f"nouvelle tentative {attempt + 1}/{retries} dans {wait} s")
|
||||
time.sleep(wait)
|
||||
|
||||
return False, "tentatives epuisees"
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Telecharge les dalles LiDAR HD decrites par un manifeste JSON.")
|
||||
parser.add_argument("manifest")
|
||||
parser.add_argument("-o", "--output", default="data/lidar")
|
||||
parser.add_argument("--only", nargs="+", default=None)
|
||||
parser.add_argument("--dry-run", action="store_true")
|
||||
parser.add_argument("--retries", type=int, default=4)
|
||||
parser.add_argument("--margin-go", type=float, default=5.0)
|
||||
args = parser.parse_args()
|
||||
|
||||
entries = load_manifest(args.manifest, args.only)
|
||||
print(f"Manifeste : {args.manifest} -> {len(entries)} dalle(s)")
|
||||
|
||||
coords = [e[0] for e in entries]
|
||||
xs = sorted({int(c.split("-")[0]) for c in coords})
|
||||
ys = sorted({int(c.split("-")[1]) for c in coords})
|
||||
print(f" emprise (coins NO) : X {xs[0]}..{xs[-1]} km, Y {ys[0]}..{ys[-1]} km "
|
||||
f"({len(xs)} x {len(ys)} dalles)")
|
||||
print(f" points annonces : {sum(e[3] for e in entries):,}")
|
||||
|
||||
os.makedirs(args.output, exist_ok=True)
|
||||
|
||||
# --- Tailles reelles AVANT de telecharger quoi que ce soit ---------------
|
||||
print(f"\nInterrogation des tailles ({len(entries)} requetes HEAD)...")
|
||||
sizes: dict[str, int | None] = {}
|
||||
unknown = 0
|
||||
for index, (coord, name, url, points) in enumerate(entries, 1):
|
||||
size = remote_size(url)
|
||||
sizes[coord] = size
|
||||
if size is None:
|
||||
unknown += 1
|
||||
sys.stdout.write(f"\r {index}/{len(entries)} ")
|
||||
sys.stdout.flush()
|
||||
print("\r" + " " * 40 + "\r", end="")
|
||||
|
||||
known = [s for s in sizes.values() if s is not None]
|
||||
total_known = sum(known)
|
||||
if unknown and known:
|
||||
# Estimation pour les manquantes, a partir de la moyenne des connues.
|
||||
average = total_known / len(known)
|
||||
estimated_total = total_known + unknown * average
|
||||
else:
|
||||
estimated_total = total_known
|
||||
|
||||
print(f" taille totale : {human(total_known)}"
|
||||
+ (f" (+{unknown} dalle(s) de taille inconnue, "
|
||||
f"estimation totale {human(estimated_total)})" if unknown else ""))
|
||||
|
||||
already = 0
|
||||
todo = []
|
||||
for coord, name, url, points in entries:
|
||||
destination = os.path.join(args.output, os.path.basename(url))
|
||||
size = sizes[coord]
|
||||
if os.path.exists(destination) and (size is None
|
||||
or os.path.getsize(destination) == size):
|
||||
already += os.path.getsize(destination)
|
||||
continue
|
||||
todo.append((coord, name, url, destination, size))
|
||||
|
||||
partial = sum(os.path.getsize(t[3] + ".part")
|
||||
for t in todo if os.path.exists(t[3] + ".part"))
|
||||
remaining = max(estimated_total - already - partial, 0)
|
||||
|
||||
print(f" deja sur disque : {human(already)}"
|
||||
+ (f" (+{human(partial)} de fragments repris)" if partial else ""))
|
||||
print(f" a telecharger : {human(remaining)} ({len(todo)} dalle(s))")
|
||||
|
||||
# --- Verification du disque ---------------------------------------------
|
||||
free = shutil.disk_usage(os.path.abspath(args.output)).free
|
||||
needed = remaining + args.margin_go * (1 << 30)
|
||||
print(f"\nDisque : {human(free)} libres, besoin {human(remaining)} "
|
||||
f"+ {args.margin_go:g} Go de marge = {human(needed)}")
|
||||
if free < needed:
|
||||
print(" INSUFFISANT — rien n'a ete telecharge.", file=sys.stderr)
|
||||
return 2
|
||||
print(" OK")
|
||||
|
||||
if args.dry_run:
|
||||
print("\n--dry-run : rien n'a ete telecharge.")
|
||||
return 0
|
||||
if not todo:
|
||||
print("\nToutes les dalles sont deja presentes. Rien a faire.")
|
||||
return 0
|
||||
|
||||
# --- Telechargement ------------------------------------------------------
|
||||
print(f"\nTelechargement de {len(todo)} dalle(s) vers {args.output}/\n")
|
||||
started = time.time()
|
||||
failures = []
|
||||
done_bytes = 0
|
||||
|
||||
for index, (coord, name, url, destination, size) in enumerate(todo, 1):
|
||||
ok, message = download_one(url, destination, size, args.retries,
|
||||
index, len(todo), coord)
|
||||
if ok:
|
||||
done_bytes += os.path.getsize(destination)
|
||||
elapsed = time.time() - started
|
||||
speed = done_bytes / elapsed if elapsed > 0 else 0
|
||||
left = max(remaining - done_bytes, 0)
|
||||
eta = left / speed if speed > 0 else 0
|
||||
print(f" [{index}/{len(todo)}] {coord} OK {message}"
|
||||
f" | lot : {100.0 * index / len(todo):.0f}%, "
|
||||
f"reste ~{human_time(eta)}")
|
||||
else:
|
||||
failures.append((coord, message))
|
||||
print(f" [{index}/{len(todo)}] {coord} ECHEC {message}")
|
||||
|
||||
elapsed = time.time() - started
|
||||
print(f"\nTermine en {human_time(elapsed)} — "
|
||||
f"{len(todo) - len(failures)}/{len(todo)} reussie(s), "
|
||||
f"{human(done_bytes)} recus"
|
||||
+ (f", {human(done_bytes / elapsed)}/s de moyenne" if elapsed > 0 else ""))
|
||||
|
||||
if failures:
|
||||
print(f"\n{len(failures)} ECHEC(S) — relancer la meme commande reprendra "
|
||||
f"ces dalles la ou elles en sont :")
|
||||
for coord, message in failures:
|
||||
print(f" {coord} : {message}")
|
||||
return 1
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,354 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
fetch_ortho.py — telecharge la BD ORTHO de l'IGN sur l'emprise d'un terrain .vchm.
|
||||
|
||||
PHASE 11. Le terrain LiDAR ne porte QUE de la geometrie : aucune couleur. Ce
|
||||
script va chercher la photo aerienne reelle qui recouvre exactement la meme
|
||||
emprise, par le service WMS raster de la Geoplateforme (data.geopf.fr), couche
|
||||
HR.ORTHOIMAGERY.ORTHOPHOTOS ("Ortho 20 cm", BD ORTHO V3, licence Etalab).
|
||||
|
||||
python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm -o data/ortho
|
||||
python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm -o data/ortho --res 0.2
|
||||
python tools/fetch_ortho.py assets/terrain/vercora_zone_1m.vchm --dry-run
|
||||
|
||||
POURQUOI L'EMPRISE EST LUE DANS LE .vchm ET NON PASSEE EN ARGUMENT. C'est le
|
||||
seul moyen d'etre certain que la texture recouvre le terrain au metre pres. Une
|
||||
bbox recopiee a la main dans une ligne de commande derive au premier changement
|
||||
de zone, et une orthophoto decalee de quelques metres est exactement le genre de
|
||||
defaut qu'on ne voit pas sur une capture d'ecran mais qui met les arbres a cote
|
||||
des arbres. L'en-tete .vchm donne l'origine (noeud ix=0, iz=0 = coin NORD-OUEST),
|
||||
le pas et le nombre d'echantillons : l'emprise en decoule sans ambiguite.
|
||||
|
||||
E0 = originEast E1 = originEast + (samplesX - 1) * spacing
|
||||
N1 = originNorth N0 = originNorth - (samplesZ - 1) * spacing
|
||||
|
||||
Attention a la difference de NATURE entre les deux jeux de donnees, qui est la
|
||||
seule vraie subtilite de l'alignement :
|
||||
- la heightmap est un semis de NOEUDS ; le noeud ix=0 est exactement a E0 ;
|
||||
- l'orthophoto est une grille de PIXELS-SURFACES ; le pixel 0 COUVRE
|
||||
[E0, E0+res] et son centre est a E0 + res/2.
|
||||
La bbox demandee au WMS est donc bien [E0, E1] x [N0, N1] : l'image couvre
|
||||
exactement le carre delimite par les noeuds extremes du terrain, bord a bord.
|
||||
Le demi-texel de decalage residuel entre "bord de l'image" et "centre du premier
|
||||
texel" est assume et documente dans NOTES-PHASE11.md (il vaut res/2, soit 25 cm
|
||||
au pas de 50 cm, tres en dessous de la precision de la BD ORTHO elle-meme).
|
||||
|
||||
ORDRE DES AXES. Le service ne parle QUE WMS 1.3.0 (une requete 1.1.1 est
|
||||
rejetee : VersionNegotiationFailed). En 1.3.0 l'ordre des axes depend du CRS, ce
|
||||
qui est la source d'erreur classique. Verifie sur ce serveur, pas suppose :
|
||||
BBOX=minEast,minNorth,maxEast,maxNorth renvoie l'image attendue, tandis que
|
||||
l'ordre inverse renvoie une image BLANCHE UNIFORME. Le controle est reproduit a
|
||||
chaque execution par --self-test.
|
||||
|
||||
DECOUPAGE. MaxWidth/MaxHeight annonces par GetCapabilities valent 5010 px : une
|
||||
requete unique sur 5 km a 50 cm (10 000 px) est donc impossible. Les tuiles font
|
||||
par defaut 1000 m de cote, ce qui aligne le decoupage sur celui des dalles LiDAR
|
||||
(meme grille kilometrique Lambert 93) et donne 2000 px par tuile a 50 cm — deux
|
||||
fois moins que la limite, avec de la marge pour --res 0.2 (5000 px, juste sous
|
||||
la limite).
|
||||
|
||||
REPRISE : une tuile deja presente et lisible est sautee. Un telechargement
|
||||
interrompu ne laisse pas de fichier tronque (ecriture dans un .part renomme
|
||||
seulement une fois l'image validee par Pillow).
|
||||
|
||||
Dependances : Pillow.
|
||||
python -m pip install Pillow
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import io
|
||||
import os
|
||||
import shutil
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
try:
|
||||
from PIL import Image
|
||||
except ImportError:
|
||||
sys.exit("Pillow est requis : python -m pip install Pillow")
|
||||
|
||||
WMS_URL = "https://data.geopf.fr/wms-r/wms"
|
||||
LAYER = "HR.ORTHOIMAGERY.ORTHOPHOTOS"
|
||||
USER_AGENT = "Vercora/0.11 (+projet de jeu personnel; habillage terrain)"
|
||||
TIMEOUT = 120
|
||||
WMS_MAX_PIXELS = 5010 # annonce par GetCapabilities
|
||||
|
||||
# Pillow refuse par defaut les images de plus de ~89 Mpx (garde anti-bombe).
|
||||
# Nos tuiles restent tres en dessous, mais l'assemblage aval, lui, ne l'est pas :
|
||||
# on releve la limite ici pour que les deux outils se comportent pareil.
|
||||
Image.MAX_IMAGE_PIXELS = None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Emprise
|
||||
# ---------------------------------------------------------------------------
|
||||
class Extent:
|
||||
"""Emprise Lambert 93 d'un terrain, lue dans l'en-tete .vchm."""
|
||||
|
||||
def __init__(self, path: str):
|
||||
with open(path, "rb") as f:
|
||||
head = f.read(120)
|
||||
if len(head) < 120 or head[:4] != b"VCHM":
|
||||
raise ValueError(f"{path} : ce n'est pas un fichier .vchm (magie absente).")
|
||||
(_magic, version, samples_x, samples_z, spacing, _reserved,
|
||||
origin_e, origin_n, self.min_h, self.max_h,
|
||||
self.epsg, _flags) = struct.unpack_from("<4sIIIfIddffII", head, 0)
|
||||
if version != 1:
|
||||
raise ValueError(f"{path} : version {version} non geree (attendu 1).")
|
||||
if self.epsg != 2154:
|
||||
raise ValueError(
|
||||
f"{path} : EPSG {self.epsg}. Seul le Lambert 93 (2154) est gere ; "
|
||||
"un terrain synthetique (epsg 0) n'a pas d'emprise reelle a "
|
||||
"photographier.")
|
||||
self.label = head[56:120].split(b"\0")[0].decode("utf-8", "replace")
|
||||
self.samples_x = samples_x
|
||||
self.samples_z = samples_z
|
||||
self.spacing = spacing
|
||||
# Coin nord-ouest = noeud (0, 0).
|
||||
self.east_min = origin_e
|
||||
self.north_max = origin_n
|
||||
self.east_max = origin_e + (samples_x - 1) * spacing
|
||||
self.north_min = origin_n - (samples_z - 1) * spacing
|
||||
|
||||
@property
|
||||
def width_m(self) -> float:
|
||||
return self.east_max - self.east_min
|
||||
|
||||
@property
|
||||
def height_m(self) -> float:
|
||||
return self.north_max - self.north_min
|
||||
|
||||
def describe(self) -> str:
|
||||
return (f"{self.label} : {self.samples_x}x{self.samples_z} au pas de "
|
||||
f"{self.spacing:g} m\n"
|
||||
f" emprise Lambert 93 E {self.east_min:.0f} .. {self.east_max:.0f}"
|
||||
f" N {self.north_min:.0f} .. {self.north_max:.0f}"
|
||||
f" ({self.width_m:.0f} x {self.height_m:.0f} m)")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# WMS
|
||||
# ---------------------------------------------------------------------------
|
||||
def getmap_url(e0: float, n0: float, e1: float, n1: float,
|
||||
width: int, height: int, fmt: str) -> str:
|
||||
"""URL GetMap. BBOX en ordre EST,NORD — verifie sur ce serveur, voir l'en-tete."""
|
||||
params = {
|
||||
"SERVICE": "WMS",
|
||||
"VERSION": "1.3.0",
|
||||
"REQUEST": "GetMap",
|
||||
"LAYERS": LAYER,
|
||||
"STYLES": "",
|
||||
"CRS": "EPSG:2154",
|
||||
"BBOX": f"{e0:.3f},{n0:.3f},{e1:.3f},{n1:.3f}",
|
||||
"WIDTH": str(width),
|
||||
"HEIGHT": str(height),
|
||||
"FORMAT": fmt,
|
||||
}
|
||||
return WMS_URL + "?" + urllib.parse.urlencode(params)
|
||||
|
||||
|
||||
def http_get(url: str) -> bytes:
|
||||
request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
|
||||
with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
|
||||
return response.read()
|
||||
|
||||
|
||||
def self_test() -> bool:
|
||||
"""Re-verifie l'ordre des axes. Un serveur qui changerait d'avis se voit ici,
|
||||
pas trois heures plus tard sur une texture en miroir."""
|
||||
e0, n0 = 899000.0, 6435000.0
|
||||
side = 512.0
|
||||
try:
|
||||
good = Image.open(io.BytesIO(http_get(
|
||||
getmap_url(e0, n0, e0 + side, n0 + side, 256, 256, "image/png")))).convert("RGB")
|
||||
swapped = Image.open(io.BytesIO(http_get(
|
||||
getmap_url(n0, e0, n0 + side, e0 + side, 256, 256, "image/png")))).convert("RGB")
|
||||
except (urllib.error.URLError, OSError, ValueError) as error:
|
||||
print(f" [self-test] injoignable ({error}) — controle non concluant.")
|
||||
return False
|
||||
|
||||
def is_blank(image) -> bool:
|
||||
lo, hi = image.convert("L").getextrema()
|
||||
return lo == hi
|
||||
|
||||
if is_blank(good):
|
||||
print(" [self-test] ECHEC : l'ordre EST,NORD renvoie une image uniforme.")
|
||||
return False
|
||||
if not is_blank(swapped):
|
||||
print(" [self-test] AVERTISSEMENT : l'ordre NORD,EST renvoie aussi une "
|
||||
"image non uniforme ; le controle ne discrimine plus.")
|
||||
return False
|
||||
print(" [self-test] ordre des axes EST,NORD confirme "
|
||||
"(l'ordre inverse renvoie du blanc uniforme).")
|
||||
return True
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Telechargement
|
||||
# ---------------------------------------------------------------------------
|
||||
def tile_name(e0: int, n0: int, px: int, ext: str) -> str:
|
||||
return f"ortho_{e0:07d}_{n0:07d}_{px}px.{ext}"
|
||||
|
||||
|
||||
def download_tile(url: str, destination: str, retries: int) -> tuple[bool, str]:
|
||||
"""Telecharge et VALIDE une tuile. L'ecriture passe par un .part : un fichier
|
||||
final present est donc toujours une image complete et decodable."""
|
||||
partial = destination + ".part"
|
||||
delay = 2.0
|
||||
for attempt in range(1, retries + 1):
|
||||
try:
|
||||
data = http_get(url)
|
||||
if data[:1] == b"<":
|
||||
# Le WMS signale ses erreurs par un ServiceExceptionReport XML
|
||||
# renvoye avec un code 200 : sans ce test, on ecrirait le message
|
||||
# d'erreur dans un fichier .jpg.
|
||||
message = data[:300].decode("utf-8", "replace")
|
||||
return False, f"reponse XML du service : {message}"
|
||||
image = Image.open(io.BytesIO(data))
|
||||
image.verify() # leve si le flux est tronque
|
||||
with open(partial, "wb") as f:
|
||||
f.write(data)
|
||||
os.replace(partial, destination)
|
||||
return True, f"{len(data) / 1024.0:.0f} Ko"
|
||||
except (urllib.error.URLError, OSError, ValueError, TimeoutError) as error:
|
||||
if attempt == retries:
|
||||
return False, f"{type(error).__name__}: {error}"
|
||||
time.sleep(delay)
|
||||
delay *= 2.0
|
||||
return False, "epuise"
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Telecharge la BD ORTHO IGN sur l'emprise d'un terrain .vchm.")
|
||||
parser.add_argument("terrain", help="fichier .vchm dont on reprend l'emprise")
|
||||
parser.add_argument("-o", "--output", default="data/ortho",
|
||||
help="repertoire des tuiles (defaut : data/ortho)")
|
||||
parser.add_argument("--res", type=float, default=0.5,
|
||||
help="resolution au sol en metres/pixel (defaut 0,5 ; "
|
||||
"la source native est a 0,2)")
|
||||
parser.add_argument("--tile-m", type=float, default=1000.0,
|
||||
help="cote d'une tuile en metres (defaut 1000, soit la "
|
||||
"grille kilometrique des dalles LiDAR)")
|
||||
parser.add_argument("--format", default="jpeg", choices=("jpeg", "png"),
|
||||
help="format demande au WMS (defaut jpeg : la BD ORTHO "
|
||||
"est elle-meme une photo, le png ne restitue rien "
|
||||
"de plus et pese 6 fois plus)")
|
||||
parser.add_argument("--retries", type=int, default=4)
|
||||
parser.add_argument("--dry-run", action="store_true",
|
||||
help="affiche le plan et la place necessaire, sans rien ecrire")
|
||||
parser.add_argument("--margin-go", type=float, default=2.0,
|
||||
help="marge de disque libre exigee en plus du lot")
|
||||
parser.add_argument("--no-self-test", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
try:
|
||||
extent = Extent(args.terrain)
|
||||
except (OSError, ValueError) as error:
|
||||
return int(bool(sys.stderr.write(f"{error}\n"))) or 2
|
||||
|
||||
print("BD ORTHO IGN — couche " + LAYER)
|
||||
print(extent.describe())
|
||||
|
||||
if args.res <= 0:
|
||||
sys.exit("--res doit etre strictement positif.")
|
||||
|
||||
tile_px = int(round(args.tile_m / args.res))
|
||||
if tile_px > WMS_MAX_PIXELS:
|
||||
sys.exit(f"--tile-m {args.tile_m:g} a --res {args.res:g} demande "
|
||||
f"{tile_px} px par tuile, au-dela de la limite du service "
|
||||
f"({WMS_MAX_PIXELS}). Reduire --tile-m.")
|
||||
|
||||
cols = int(round(extent.width_m / args.tile_m))
|
||||
rows = int(round(extent.height_m / args.tile_m))
|
||||
if abs(cols * args.tile_m - extent.width_m) > 1e-6 or \
|
||||
abs(rows * args.tile_m - extent.height_m) > 1e-6:
|
||||
sys.exit(f"L'emprise ({extent.width_m:g} x {extent.height_m:g} m) n'est pas "
|
||||
f"un multiple entier de --tile-m {args.tile_m:g}. Choisir un cote "
|
||||
"de tuile qui la divise, sinon les tuiles deborderaient ou "
|
||||
"laisseraient une bande non couverte.")
|
||||
|
||||
total_px = (cols * tile_px, rows * tile_px)
|
||||
print(f" decoupage : {cols} x {rows} = {cols * rows} tuiles de {tile_px} px "
|
||||
f"({args.tile_m:g} m a {args.res:g} m/px)")
|
||||
print(f" mosaique complete : {total_px[0]} x {total_px[1]} px "
|
||||
f"= {total_px[0] * total_px[1] / 1e6:.1f} Mpx")
|
||||
|
||||
if not args.no_self_test and not args.dry_run:
|
||||
self_test()
|
||||
|
||||
# Estimation de place : une tuile de BD ORTHO en jpeg qualite service pese
|
||||
# de l'ordre de 0,25 octet par pixel (mesure sur les premieres tuiles). On
|
||||
# majore volontairement.
|
||||
bytes_per_px = 0.5 if args.format == "jpeg" else 2.0
|
||||
estimate = total_px[0] * total_px[1] * bytes_per_px
|
||||
print(f" place estimee : {estimate / 1e6:.0f} Mo (majoree)")
|
||||
|
||||
if args.dry_run:
|
||||
print("\n--dry-run : rien n'a ete ecrit.")
|
||||
return 0
|
||||
|
||||
os.makedirs(args.output, exist_ok=True)
|
||||
free = shutil.disk_usage(args.output).free
|
||||
needed = estimate + args.margin_go * 1e9
|
||||
print(f" disque libre : {free / 1e9:.1f} Go "
|
||||
f"(exige : {needed / 1e9:.1f} Go avec la marge)")
|
||||
if free < needed:
|
||||
sys.exit("Place insuffisante — telechargement non demarre.")
|
||||
|
||||
ext = "jpg" if args.format == "jpeg" else "png"
|
||||
todo = []
|
||||
skipped = 0
|
||||
for row in range(rows):
|
||||
for col in range(cols):
|
||||
e0 = extent.east_min + col * args.tile_m
|
||||
n0 = extent.north_min + row * args.tile_m
|
||||
destination = os.path.join(args.output, tile_name(int(e0), int(n0), tile_px, ext))
|
||||
if os.path.exists(destination) and os.path.getsize(destination) > 0:
|
||||
skipped += 1
|
||||
continue
|
||||
url = getmap_url(e0, n0, e0 + args.tile_m, n0 + args.tile_m,
|
||||
tile_px, tile_px, "image/" + args.format)
|
||||
todo.append((e0, n0, url, destination))
|
||||
|
||||
print(f"\n{len(todo)} tuile(s) a telecharger, {skipped} deja presente(s).")
|
||||
if not todo:
|
||||
print("Rien a faire.")
|
||||
return 0
|
||||
|
||||
started = time.time()
|
||||
failures = []
|
||||
written = 0
|
||||
for index, (e0, n0, url, destination) in enumerate(todo, 1):
|
||||
label = f"E{int(e0)} N{int(n0)}"
|
||||
print(f" [{index}/{len(todo)}] {label} ... ", end="", flush=True)
|
||||
ok, message = download_tile(url, destination, args.retries)
|
||||
if ok:
|
||||
written += os.path.getsize(destination)
|
||||
print(message)
|
||||
else:
|
||||
failures.append((label, message))
|
||||
print("ECHEC — " + message)
|
||||
|
||||
elapsed = time.time() - started
|
||||
print(f"\nTermine en {elapsed:.0f} s — {written / 1e6:.1f} Mo ecrits "
|
||||
f"({written / 1e6 / max(elapsed, 1e-3):.1f} Mo/s).")
|
||||
if failures:
|
||||
print(f"{len(failures)} echec(s) :")
|
||||
for label, message in failures:
|
||||
print(f" {label} : {message}")
|
||||
print("Relancer la meme commande : les tuiles deja recues sont sautees.")
|
||||
return 1
|
||||
print(f"Couverture complete : {cols * rows} tuiles dans {args.output}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,433 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
find_climb_walls.py — reperage des PAROIS grimpables dans une dalle .vchm.
|
||||
|
||||
python tools/find_climb_walls.py assets/terrain/LHD_0903_6439_1m.vchm
|
||||
python tools/find_climb_walls.py DALLE.vchm --half-base 2 --threshold 1.0
|
||||
|
||||
Pourquoi cet outil existe (Phase 14, escalade).
|
||||
|
||||
Le seuil de pente a partir duquel une zone est une PAROI et non un versant raide
|
||||
ne peut pas etre pose a priori : il faut savoir ce que le terrain reel contient
|
||||
reellement. Le meme piege qu'en Phase 13 (velo) est present ici, en pire - un
|
||||
DTM LiDAR a 1 m porte du bruit decimetrique, donc lire la pente sur une base
|
||||
d'un metre fabrique des "parois" partout ou il n'y a qu'un caillou. La pente est
|
||||
donc lue par differences finies CENTREES sur une demi-base reglable, exactement
|
||||
comme world/Bike (BikeParams::slopeSampleStep), et la valeur par defaut est la
|
||||
meme : 2 m, soit une base de 4 m.
|
||||
|
||||
Ce que le script produit :
|
||||
1. la DISTRIBUTION des pentes de la dalle, qui dit si un seuil separe vraiment
|
||||
deux populations ou s'il coupe au milieu d'un continuum ;
|
||||
2. les meilleures PAROIS CANDIDATES, c'est-a-dire les zones qui reunissent les
|
||||
trois conditions qu'une paroi doit remplir pour etre jouable :
|
||||
- pente soutenue au-dessus du seuil sur toute la zone (pas un pixel isole),
|
||||
- denivele suffisant pour que grimper ait un sens,
|
||||
- du terrain MARCHABLE au pied, sinon on ne peut pas y arriver.
|
||||
3. pour chaque candidate, les coordonnees Lambert 93 ET les coordonnees du
|
||||
monde moteur (terrain centre sur l'origine, cf. Heightmap), donc directement
|
||||
utilisables avec --start=est,nord.
|
||||
|
||||
Le georeferencement est lu dans l'en-tete du fichier, jamais recopie a la main
|
||||
(meme regle qu'en Phase 11 pour l'orthophoto).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
|
||||
HEADER_SIZE = 120
|
||||
|
||||
|
||||
def read_vchm(path):
|
||||
"""Relit un .vchm. Format identique a tools/check_terrain_file.py."""
|
||||
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": float(spacing),
|
||||
"origin_e": origin_e, "origin_n": origin_n, "min": hmin, "max": hmax,
|
||||
"epsg": epsg, "flags": flags, "label": label,
|
||||
# grid[iz, ix] : ix croissant vers l'EST, iz croissant vers le SUD.
|
||||
"grid": heights.reshape(nz, nx).astype(np.float64),
|
||||
}
|
||||
|
||||
|
||||
def slope_field(grid, cell, half_base_m):
|
||||
"""Pente (magnitude du gradient, en rise par metre horizontal).
|
||||
|
||||
Differences finies CENTREES sur +/- half_base_m, comme Bike::terrainGradient.
|
||||
Une difference AVANT donnerait une pente differente selon le sens de lecture
|
||||
sur le meme versant ; une difference centree est symetrique.
|
||||
|
||||
Le decalage est exprime en ECHANTILLONS, donc half_base_m doit etre un
|
||||
multiple du pas de la grille - sinon on interpolerait, ce qui lisserait une
|
||||
seconde fois et melangerait deux effets.
|
||||
"""
|
||||
step = int(round(half_base_m / cell))
|
||||
if step < 1:
|
||||
sys.exit(f"--half-base {half_base_m} m est plus petit que le pas de "
|
||||
f"la grille ({cell} m).")
|
||||
if abs(step * cell - half_base_m) > 1e-6:
|
||||
sys.exit(f"--half-base {half_base_m} m n'est pas un multiple du pas "
|
||||
f"({cell} m) : on interpolerait, donc on lisserait deux fois.")
|
||||
|
||||
base = 2.0 * step * cell
|
||||
# np.roll ferait passer le bord oppose ; on travaille donc sur l'INTERIEUR et
|
||||
# on marque le bord comme non evaluable (NaN), plutot que d'y inventer une
|
||||
# pente. Une paroi collee au bord de dalle n'est de toute facon pas jouable.
|
||||
dh_dx = np.full(grid.shape, np.nan)
|
||||
dh_dz = np.full(grid.shape, np.nan)
|
||||
dh_dx[:, step:-step] = (grid[:, 2 * step:] - grid[:, :-2 * step]) / base
|
||||
dh_dz[step:-step, :] = (grid[2 * step:, :] - grid[:-2 * step, :]) / base
|
||||
return np.hypot(dh_dx, dh_dz)
|
||||
|
||||
|
||||
def describe_distribution(slope, threshold):
|
||||
"""La distribution des pentes, qui dit si le seuil separe deux populations."""
|
||||
valid = slope[np.isfinite(slope)]
|
||||
print("\n--- Distribution des pentes de la dalle ---")
|
||||
print(f" echantillons evaluables : {valid.size}")
|
||||
for q in (50, 75, 90, 95, 99, 99.9):
|
||||
v = np.percentile(valid, q)
|
||||
print(f" p{q:<5} {100.0 * v:8.1f} % ({np.degrees(np.arctan(v)):5.1f} deg)")
|
||||
print(f" max {100.0 * valid.max():8.1f} % "
|
||||
f"({np.degrees(np.arctan(valid.max())):5.1f} deg)")
|
||||
|
||||
print("\n Part de la dalle au-dessus de quelques seuils candidats :")
|
||||
for t in (0.30, 0.50, 0.70, 1.00, 1.50, 2.00, 3.00):
|
||||
share = 100.0 * float(np.count_nonzero(valid >= t)) / valid.size
|
||||
mark = " <== seuil retenu" if abs(t - threshold) < 1e-9 else ""
|
||||
print(f" >= {100.0 * t:6.0f} % ({np.degrees(np.arctan(t)):4.1f} deg) : "
|
||||
f"{share:6.2f} % de la dalle{mark}")
|
||||
|
||||
|
||||
def find_walls(m, slope, threshold, patch_m, walkable, min_relief, top_n,
|
||||
min_foot=0.0, max_relief=1e9, rank_by="relief"):
|
||||
"""Cherche les meilleures parois candidates.
|
||||
|
||||
Balayage par PATCHS carres de patch_m metres de cote, pas d'un demi-patch.
|
||||
Un patch est retenu s'il reunit les trois conditions d'une paroi jouable :
|
||||
|
||||
- couverture : une part dominante du patch depasse le seuil de pente. Un
|
||||
seul pixel raide au milieu d'un pierrier n'est pas une paroi ;
|
||||
- denivele : le patch monte d'au moins min_relief metres, sinon grimper
|
||||
n'a pas de sens ;
|
||||
- PIED MARCHABLE : il existe, dans l'anneau qui entoure le patch, du
|
||||
terrain sous le seuil de marche. C'est la condition qu'on oublie et qui
|
||||
rend une paroi injouable : une falaise dont le pied est lui-meme une
|
||||
falaise ne s'atteint pas a pied.
|
||||
"""
|
||||
cell = m["spacing"]
|
||||
nx, nz = m["nx"], m["nz"]
|
||||
grid = m["grid"]
|
||||
patch = max(2, int(round(patch_m / cell)))
|
||||
stride = max(1, patch // 2)
|
||||
|
||||
candidates = []
|
||||
for iz in range(0, nz - patch, stride):
|
||||
for ix in range(0, nx - patch, stride):
|
||||
sub = slope[iz:iz + patch, ix:ix + patch]
|
||||
if not np.all(np.isfinite(sub)):
|
||||
continue # touche le bord non evaluable
|
||||
|
||||
covered = float(np.count_nonzero(sub >= threshold)) / sub.size
|
||||
if covered < 0.80:
|
||||
continue
|
||||
|
||||
hsub = grid[iz:iz + patch, ix:ix + patch]
|
||||
relief = float(hsub.max() - hsub.min())
|
||||
if relief < min_relief or relief > max_relief:
|
||||
continue
|
||||
|
||||
# Anneau de 10 m autour du patch : y a-t-il de quoi poser les pieds ?
|
||||
pad = max(1, int(round(10.0 / cell)))
|
||||
z0, z1 = max(0, iz - pad), min(nz, iz + patch + pad)
|
||||
x0, x1 = max(0, ix - pad), min(nx, ix + patch + pad)
|
||||
ring = slope[z0:z1, x0:x1]
|
||||
ring_ok = np.isfinite(ring) & (ring <= walkable)
|
||||
foot = float(np.count_nonzero(ring_ok)) / max(1, ring.size)
|
||||
if foot <= min_foot:
|
||||
continue
|
||||
|
||||
candidates.append({
|
||||
"ix": ix, "iz": iz, "patch": patch,
|
||||
"covered": covered, "relief": relief, "foot": foot,
|
||||
"median_slope": float(np.median(sub)),
|
||||
"hmin": float(hsub.min()), "hmax": float(hsub.max()),
|
||||
})
|
||||
|
||||
# Classement. Deux criteres, et le choix n'est PAS cosmetique :
|
||||
# - "relief" trouve les parois les plus spectaculaires. Sur ce massif elles
|
||||
# sont toutes injouables : 250 m de haut et 0 % de pied marchable, on ne
|
||||
# peut meme pas les atteindre a pied ;
|
||||
# - "foot" trouve les parois qu'on peut REELLEMENT aborder. C'est ce qu'il
|
||||
# faut pour poser un scenario de test, et c'est le classement qui a servi
|
||||
# a choisir la paroi de reference de la Phase 14.
|
||||
if rank_by == "foot":
|
||||
candidates.sort(key=lambda c: (c["foot"], c["relief"]), reverse=True)
|
||||
else:
|
||||
candidates.sort(key=lambda c: (c["relief"], c["median_slope"]), reverse=True)
|
||||
|
||||
# On evite de rendre dix fois la meme falaise : deux candidates dont les
|
||||
# centres sont a moins d'un patch l'une de l'autre sont la meme paroi.
|
||||
kept = []
|
||||
for c in candidates:
|
||||
cx, cz = c["ix"] + c["patch"] / 2, c["iz"] + c["patch"] / 2
|
||||
if any(abs(cx - k["ix"] - k["patch"] / 2) < patch and
|
||||
abs(cz - k["iz"] - k["patch"] / 2) < patch for k in kept):
|
||||
continue
|
||||
kept.append(c)
|
||||
if len(kept) >= top_n:
|
||||
break
|
||||
return kept
|
||||
|
||||
|
||||
|
||||
def find_routes(m, slope, threshold, walkable, top_n, min_rise, max_rise):
|
||||
"""Cherche des VOIES : un pied marchable, un cap, et de la paroi au-dessus.
|
||||
|
||||
Pourquoi ce mode existe en plus de find_walls. find_walls repond a "ou y
|
||||
a-t-il de la paroi ?", ce qui ne suffit pas a poser un scenario jouable : il
|
||||
faut aussi savoir PAR OU on l'aborde. C'est la lecon de la Phase 13, ou le
|
||||
scenario velo a echoue trois fois avant qu'on evalue la pente LE LONG DE
|
||||
CHAQUE CAP - "faire demi-tour ne redonne pas la pente inverse", le terrain de
|
||||
l'autre cote d'un point est un AUTRE terrain.
|
||||
|
||||
Pour chaque point de depart marchable et chacun des 16 caps, on remonte le
|
||||
terrain pas a pas et on mesure :
|
||||
- la hauteur reellement gagnee avant que ca ne s'aplatisse,
|
||||
- la part du trajet qui est au-dessus du seuil de paroi.
|
||||
Une bonne voie monte franchement ET est majoritairement de la paroi ; un
|
||||
simple versant raide monte aussi, mais sans jamais depasser le seuil.
|
||||
"""
|
||||
cell = m["spacing"]
|
||||
nx, nz = m["nx"], m["nz"]
|
||||
grid = m["grid"]
|
||||
half = 0.5 * (nx - 1) * cell
|
||||
|
||||
def h_at(wx, wz):
|
||||
ix = int(round((wx + half) / cell))
|
||||
iz = int(round((wz + half) / cell))
|
||||
return grid[min(max(iz, 0), nz - 1), min(max(ix, 0), nx - 1)]
|
||||
|
||||
def slope_at(wx, wz):
|
||||
ix = int(round((wx + half) / cell))
|
||||
iz = int(round((wz + half) / cell))
|
||||
v = slope[min(max(iz, 0), nz - 1), min(max(ix, 0), nx - 1)]
|
||||
return v if np.isfinite(v) else 0.0
|
||||
|
||||
headings = [i * 22.5 for i in range(16)]
|
||||
routes = []
|
||||
# Pas de 10 m sur la grille des departs : on cherche un point de depart, pas
|
||||
# a cartographier la dalle au metre pres.
|
||||
span = int(0.5 * (nx - 1) * cell) - 60
|
||||
for wz in range(-span, span, 10):
|
||||
for wx in range(-span, span, 10):
|
||||
if slope_at(wx, wz) > walkable:
|
||||
continue # on ne part que de terrain ou l'on tient debout
|
||||
for heading in headings:
|
||||
rad = np.radians(heading)
|
||||
dx, dz = np.cos(rad), np.sin(rad)
|
||||
x, z = float(wx), float(wz)
|
||||
y0 = h_at(x, z)
|
||||
wall_steps = 0
|
||||
steps = 0
|
||||
# On avance de 1 m tant que ca monte ; des que ca redescend ou
|
||||
# que ca s'aplatit durablement, la voie est finie.
|
||||
flat_run = 0
|
||||
while steps < 120:
|
||||
x += dx
|
||||
z += dz
|
||||
steps += 1
|
||||
if slope_at(x, z) >= threshold:
|
||||
wall_steps += 1
|
||||
flat_run = 0
|
||||
else:
|
||||
flat_run += 1
|
||||
if flat_run > 6:
|
||||
break
|
||||
if h_at(x, z) < y0:
|
||||
break
|
||||
rise = h_at(x, z) - y0
|
||||
if rise < min_rise or rise > max_rise:
|
||||
continue
|
||||
wall_share = wall_steps / max(1, steps)
|
||||
if wall_share < 0.60:
|
||||
continue
|
||||
routes.append({
|
||||
"wx": wx, "wz": wz, "heading": heading, "rise": rise,
|
||||
"wall_share": wall_share, "steps": steps,
|
||||
"y0": y0, "y1": h_at(x, z),
|
||||
})
|
||||
|
||||
routes.sort(key=lambda r: (r["wall_share"], r["rise"]), reverse=True)
|
||||
kept = []
|
||||
for r in routes:
|
||||
if any(abs(r["wx"] - k["wx"]) < 40 and abs(r["wz"] - k["wz"]) < 40 for k in kept):
|
||||
continue
|
||||
kept.append(r)
|
||||
if len(kept) >= top_n:
|
||||
break
|
||||
|
||||
print()
|
||||
print("--- Voies d'escalade (pied marchable + paroi au-dessus) ---")
|
||||
if not kept:
|
||||
print(" Aucune.")
|
||||
return
|
||||
for rank, r in enumerate(kept, 1):
|
||||
east = m["origin_e"] + (r["wx"] + half)
|
||||
north = m["origin_n"] - (r["wz"] + half)
|
||||
print()
|
||||
print(f" #{rank} depart monde x {r['wx']:+7.1f} z {r['wz']:+7.1f} "
|
||||
f"(E {east:.0f} N {north:.0f})")
|
||||
print(f" cap {r['heading']:5.1f} deg, {r['rise']:.1f} m gagnes sur "
|
||||
f"{r['steps']} m de trajet")
|
||||
print(f" {100.0 * r['wall_share']:.0f} % du trajet est au-dessus du "
|
||||
f"seuil de paroi")
|
||||
print(f" altitudes {r['y0']:.1f} -> {r['y1']:.1f} m, pente au depart "
|
||||
f"{100.0 * slope_at(r['wx'], r['wz']):.0f} %")
|
||||
|
||||
|
||||
def report_walls(m, kept, threshold, walkable):
|
||||
cell = m["spacing"]
|
||||
nx, nz = m["nx"], m["nz"]
|
||||
half = 0.5 * (nx - 1) * cell
|
||||
|
||||
print(f"\n--- Parois candidates (seuil {100.0 * threshold:.0f} %, "
|
||||
f"marchable <= {100.0 * walkable:.0f} %) ---")
|
||||
if not kept:
|
||||
print(" Aucune. Assouplir --threshold, --patch ou --min-relief.")
|
||||
return
|
||||
|
||||
for rank, c in enumerate(kept, 1):
|
||||
cx = c["ix"] + c["patch"] / 2.0
|
||||
cz = c["iz"] + c["patch"] / 2.0
|
||||
# Lambert 93 : ix croissant vers l'est, iz croissant vers le SUD.
|
||||
east = m["origin_e"] + cx * cell
|
||||
north = m["origin_n"] - cz * cell
|
||||
# Monde moteur : terrain centre sur l'origine (cf. Heightmap).
|
||||
wx = cx * cell - half
|
||||
wz = cz * cell - half
|
||||
print(f"\n #{rank} E {east:9.1f} N {north:10.1f} "
|
||||
f"(monde moteur x {wx:+8.1f} z {wz:+8.1f})")
|
||||
print(f" pente mediane {100.0 * c['median_slope']:7.1f} % "
|
||||
f"({np.degrees(np.arctan(c['median_slope'])):.1f} deg), "
|
||||
f"{100.0 * c['covered']:.0f} % du patch au-dessus du seuil")
|
||||
print(f" altitudes {c['hmin']:.1f} .. {c['hmax']:.1f} m "
|
||||
f"=> {c['relief']:.1f} m de denivele sur "
|
||||
f"{c['patch'] * cell:.0f} m de cote")
|
||||
print(f" pied marchable : {100.0 * c['foot']:.0f} % de l'anneau "
|
||||
f"a 10 m est sous {100.0 * walkable:.0f} % de pente")
|
||||
|
||||
|
||||
def profile_at(m, slope, east, north, half_base_m):
|
||||
"""Detail d'un point precis, en Lambert 93. Sert a verifier une coordonnee
|
||||
citee dans les notes plutot qu'a la croire sur parole."""
|
||||
cell = m["spacing"]
|
||||
ix = int(round((east - m["origin_e"]) / cell))
|
||||
iz = int(round((m["origin_n"] - north) / cell))
|
||||
if not (0 <= ix < m["nx"] and 0 <= iz < m["nz"]):
|
||||
print(f"\n--- Sonde E {east} N {north} : HORS de cette dalle ---")
|
||||
return
|
||||
|
||||
print(f"\n--- Sonde E {east:.0f} N {north:.0f} "
|
||||
f"(ix {ix}, iz {iz}, base {2 * half_base_m:.0f} m) ---")
|
||||
print(f" altitude {m['grid'][iz, ix]:.2f} m")
|
||||
s = slope[iz, ix]
|
||||
if np.isfinite(s):
|
||||
print(f" pente locale {100.0 * s:.1f} % "
|
||||
f"({np.degrees(np.arctan(s)):.1f} deg)")
|
||||
# Voisinage de 40 m : une paroi se juge sur son emprise, pas sur un point.
|
||||
pad = int(round(20.0 / cell))
|
||||
z0, z1 = max(0, iz - pad), min(m["nz"], iz + pad + 1)
|
||||
x0, x1 = max(0, ix - pad), min(m["nx"], ix + pad + 1)
|
||||
sub = slope[z0:z1, x0:x1]
|
||||
hsub = m["grid"][z0:z1, x0:x1]
|
||||
valid = sub[np.isfinite(sub)]
|
||||
if valid.size:
|
||||
print(f" voisinage 40 x 40 m : pente mediane {100.0 * np.median(valid):.1f} %, "
|
||||
f"max {100.0 * valid.max():.1f} %")
|
||||
print(f" altitudes {hsub.min():.1f} .. {hsub.max():.1f} m "
|
||||
f"({hsub.max() - hsub.min():.1f} m de denivele)")
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser(description=__doc__,
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
p.add_argument("vchm", help="dalle ou terrain assemble .vchm")
|
||||
p.add_argument("--half-base", type=float, default=2.0,
|
||||
help="demi-base des differences centrees, en m (defaut 2, "
|
||||
"comme BikeParams::slopeSampleStep)")
|
||||
p.add_argument("--threshold", type=float, default=1.00,
|
||||
help="seuil de PAROI en rise/run (defaut 1.00 = 45 deg)")
|
||||
p.add_argument("--walkable", type=float, default=0.60,
|
||||
help="pente au-dessus de laquelle on ne marche plus "
|
||||
"(defaut 0.60 = 31 deg), pour juger le pied de paroi")
|
||||
p.add_argument("--patch", type=float, default=20.0,
|
||||
help="cote du patch analyse, en m (defaut 20)")
|
||||
p.add_argument("--min-relief", type=float, default=15.0,
|
||||
help="denivele minimal d'un patch pour etre une paroi (m)")
|
||||
p.add_argument("--top", type=int, default=5, help="nombre de candidates")
|
||||
p.add_argument("--min-foot", type=float, default=0.0,
|
||||
help="part MINIMALE de l'anneau qui doit etre marchable, dans "
|
||||
"[0, 1]. C'est le filtre de REACHABILITE : sans lui on ne "
|
||||
"trouve que des falaises qu'on ne peut pas aborder a pied.")
|
||||
p.add_argument("--max-relief", type=float, default=1e9,
|
||||
help="denivele MAXIMAL d'un patch, en m. Une paroi de 250 m ne "
|
||||
"se grimpe pas avec une jauge d'energie de premiere session.")
|
||||
p.add_argument("--rank", choices=("relief", "foot"), default="relief",
|
||||
help="critere de classement (defaut relief ; 'foot' privilegie "
|
||||
"les parois reellement abordables)")
|
||||
p.add_argument("--probe", nargs=2, type=float, metavar=("EST", "NORD"),
|
||||
help="detaille un point Lambert 93 precis")
|
||||
p.add_argument("--routes", action="store_true",
|
||||
help="cherche des VOIES (pied marchable + cap + paroi au-dessus) "
|
||||
"au lieu de simples zones de paroi. C'est ce mode qui donne "
|
||||
"un point de depart jouable.")
|
||||
args = p.parse_args()
|
||||
|
||||
m = read_vchm(args.vchm)
|
||||
print(f"Fichier : {os.path.basename(args.vchm)}")
|
||||
print(f" label : {m['label']}")
|
||||
print(f" {m['nx']} x {m['nz']} echantillons, pas {m['spacing']} m, EPSG:{m['epsg']}")
|
||||
print(f" origine (coin nord-ouest) : E {m['origin_e']:.1f} N {m['origin_n']:.1f}")
|
||||
print(f" altitudes {m['grid'].min():.1f} .. {m['grid'].max():.1f} m")
|
||||
|
||||
slope = slope_field(m["grid"], m["spacing"], args.half_base)
|
||||
print(f"\n Pente lue par differences centrees sur une base de "
|
||||
f"{2 * args.half_base:.0f} m.")
|
||||
|
||||
describe_distribution(slope, args.threshold)
|
||||
|
||||
if args.probe:
|
||||
profile_at(m, slope, args.probe[0], args.probe[1], args.half_base)
|
||||
|
||||
if args.routes:
|
||||
find_routes(m, slope, args.threshold, args.walkable, args.top,
|
||||
args.min_relief, args.max_relief)
|
||||
return
|
||||
|
||||
kept = find_walls(m, slope, args.threshold, args.patch, args.walkable,
|
||||
args.min_relief, args.top, args.min_foot, args.max_relief,
|
||||
args.rank)
|
||||
report_walls(m, kept, args.threshold, args.walkable)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,185 @@
|
||||
# ---------------------------------------------------------------------------
|
||||
# Generateur d'assets .obj de test pour la Phase 3 (loader de mesh).
|
||||
#
|
||||
# Produit deux fichiers dans assets/ , volontairement minuscules (quelques Ko) :
|
||||
#
|
||||
# icosphere.obj - icosphere subdivisee 1 fois : 42 sommets / 80 triangles,
|
||||
# normales LISSES (normale = position normalisee) + UV
|
||||
# spheriques. Teste le cas "beaucoup de faces, normales et
|
||||
# UV presents, indices v/vt/vn identiques".
|
||||
#
|
||||
# octahedron.obj - octaedre a facettes PLATES : 6 positions seulement mais 8
|
||||
# normales distinctes. Chaque position est donc reutilisee
|
||||
# par plusieurs faces avec des normales differentes -> teste
|
||||
# la deduplication du loader sur le triplet (v, vt, vn),
|
||||
# cas que l'icosphere ne couvre pas.
|
||||
#
|
||||
# Usage : powershell -ExecutionPolicy Bypass -File tools\gen_test_meshes.ps1
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
$assetsDir = Join-Path (Split-Path -Parent $PSScriptRoot) 'assets'
|
||||
if (-not (Test-Path $assetsDir)) {
|
||||
New-Item -ItemType Directory -Path $assetsDir | Out-Null
|
||||
}
|
||||
|
||||
# Culture invariante : sur une machine en locale FR, "{0:F6}" produirait des
|
||||
# virgules decimales, illisibles pour un parseur .obj.
|
||||
$inv = [System.Globalization.CultureInfo]::InvariantCulture
|
||||
function Fmt([double]$v) { return $v.ToString('F6', $inv) }
|
||||
|
||||
function Write-ObjFile([string]$path, [string[]]$lines) {
|
||||
# UTF8 sans BOM : un BOM en tete de fichier n'est pas garanti d'etre tolere
|
||||
# par tous les parseurs .obj.
|
||||
$enc = New-Object System.Text.UTF8Encoding($false)
|
||||
[System.IO.File]::WriteAllLines($path, $lines, $enc)
|
||||
Write-Host ("Ecrit : {0} ({1} lignes)" -f $path, $lines.Count)
|
||||
}
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 1. Icosphere (icosaedre + 1 subdivision, projetee sur la sphere unite)
|
||||
# ---------------------------------------------------------------------------
|
||||
$positions = New-Object System.Collections.ArrayList
|
||||
$midCache = @{} # cle "i_j" -> index du milieu deja cree
|
||||
|
||||
function Add-Normalized([double]$x, [double]$y, [double]$z) {
|
||||
$len = [math]::Sqrt($x * $x + $y * $y + $z * $z)
|
||||
# Parentheses obligatoires autour de chaque element : dans un @(...), la
|
||||
# virgule de PowerShell est PLUS prioritaire que les operateurs arithmetiques,
|
||||
# donc "@($x / $len, $y / $len)" se lirait "$x / ($len, $y) / $len".
|
||||
[void]$positions.Add(@(($x / $len), ($y / $len), ($z / $len)))
|
||||
return $positions.Count - 1
|
||||
}
|
||||
|
||||
# Milieu de l'arete (a,b), projete sur la sphere. Mis en cache pour que les
|
||||
# deux triangles partageant l'arete reutilisent le meme sommet (mesh soude).
|
||||
function Get-Midpoint([int]$a, [int]$b) {
|
||||
$key = if ($a -lt $b) { "$($a)_$($b)" } else { "$($b)_$($a)" }
|
||||
if ($midCache.ContainsKey($key)) { return $midCache[$key] }
|
||||
|
||||
$pa = $positions[$a]
|
||||
$pb = $positions[$b]
|
||||
$idx = Add-Normalized (($pa[0] + $pb[0]) / 2) (($pa[1] + $pb[1]) / 2) (($pa[2] + $pb[2]) / 2)
|
||||
$midCache[$key] = $idx
|
||||
return $idx
|
||||
}
|
||||
|
||||
# Nombre d'or : les 12 sommets de l'icosaedre sont 3 rectangles d'or orthogonaux.
|
||||
$t = (1.0 + [math]::Sqrt(5.0)) / 2.0
|
||||
|
||||
$icoVerts = @(
|
||||
@(-1, $t, 0), @( 1, $t, 0), @(-1, -$t, 0), @( 1, -$t, 0),
|
||||
@( 0, -1, $t), @( 0, 1, $t), @( 0, -1, -$t), @( 0, 1, -$t),
|
||||
@( $t, 0, -1), @( $t, 0, 1), @(-$t, 0, -1), @(-$t, 0, 1)
|
||||
)
|
||||
foreach ($v in $icoVerts) {
|
||||
# Variables intermediaires : "[double]$v[0]" se lit "([double]$v)[0]" en
|
||||
# PowerShell, ce qui casserait le cast.
|
||||
$vx = [double]$v[0]
|
||||
$vy = [double]$v[1]
|
||||
$vz = [double]$v[2]
|
||||
[void](Add-Normalized $vx $vy $vz)
|
||||
}
|
||||
|
||||
# 20 faces de l'icosaedre, enroulement anti-horaire vu de l'exterieur.
|
||||
$faces = @(
|
||||
@(0, 11, 5), @(0, 5, 1), @(0, 1, 7), @(0, 7, 10), @(0, 10, 11),
|
||||
@(1, 5, 9), @(5, 11, 4), @(11, 10, 2), @(10, 7, 6), @(7, 1, 8),
|
||||
@(3, 9, 4), @(3, 4, 2), @(3, 2, 6), @(3, 6, 8), @(3, 8, 9),
|
||||
@(4, 9, 5), @(2, 4, 11), @(6, 2, 10), @(8, 6, 7), @(9, 8, 1)
|
||||
)
|
||||
|
||||
# Une passe de subdivision : chaque triangle -> 4 triangles.
|
||||
$subdivided = New-Object System.Collections.ArrayList
|
||||
foreach ($f in $faces) {
|
||||
$a = Get-Midpoint $f[0] $f[1]
|
||||
$b = Get-Midpoint $f[1] $f[2]
|
||||
$c = Get-Midpoint $f[2] $f[0]
|
||||
[void]$subdivided.Add(@($f[0], $a, $c))
|
||||
[void]$subdivided.Add(@($f[1], $b, $a))
|
||||
[void]$subdivided.Add(@($f[2], $c, $b))
|
||||
[void]$subdivided.Add(@($a, $b, $c))
|
||||
}
|
||||
|
||||
$lines = New-Object System.Collections.ArrayList
|
||||
[void]$lines.Add('# Vercora - asset de test Phase 3 : icosphere (1 subdivision)')
|
||||
[void]$lines.Add(('# {0} sommets, {1} triangles, normales lissees + UV spheriques' -f $positions.Count, $subdivided.Count))
|
||||
[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main')
|
||||
[void]$lines.Add('o Icosphere')
|
||||
|
||||
# Note : la chaine est construite dans une variable avant l'appel a .Add().
|
||||
# Dans les parentheses d'un appel de methode .NET, la virgule separe les
|
||||
# ARGUMENTS de la methode : ecrire .Add('{0} {1}' -f $a, $b) appellerait
|
||||
# Add() avec 2 arguments au lieu de formater 2 valeurs.
|
||||
foreach ($p in $positions) {
|
||||
$line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
# Sphere unite centree sur l'origine : la normale d'un sommet EST sa position.
|
||||
foreach ($p in $positions) {
|
||||
$line = 'vn {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
# Mapping equirectangulaire (longitude/latitude). Pas encore utilise par le
|
||||
# shader, mais present pour verifier que le loader lit bien les UV.
|
||||
foreach ($p in $positions) {
|
||||
$u = 0.5 + [math]::Atan2($p[2], $p[0]) / (2.0 * [math]::PI)
|
||||
$vv = 0.5 - [math]::Asin([math]::Max(-1.0, [math]::Min(1.0, $p[1]))) / [math]::PI
|
||||
$line = 'vt {0} {1}' -f (Fmt $u), (Fmt $vv)
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
foreach ($f in $subdivided) {
|
||||
$i = $f[0] + 1; $j = $f[1] + 1; $k = $f[2] + 1
|
||||
[void]$lines.Add("f $i/$i/$i $j/$j/$j $k/$k/$k")
|
||||
}
|
||||
|
||||
Write-ObjFile (Join-Path $assetsDir 'icosphere.obj') $lines.ToArray()
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# 2. Octaedre a facettes plates
|
||||
# ---------------------------------------------------------------------------
|
||||
# 6 positions (les pointes sur les axes), 8 faces triangulaires. La normale de
|
||||
# chaque face est (+/-1, +/-1, +/-1) normalisee : les 3 sommets d'une face
|
||||
# partagent SA normale, et chaque position apparait dans 4 faces avec 4
|
||||
# normales differentes.
|
||||
$octPos = @(
|
||||
@( 1, 0, 0), @(-1, 0, 0), # 1, 2 : +X, -X
|
||||
@( 0, 1, 0), @( 0,-1, 0), # 3, 4 : +Y, -Y
|
||||
@( 0, 0, 1), @( 0, 0,-1) # 5, 6 : +Z, -Z
|
||||
)
|
||||
# Chaque face : les 3 positions (indices .obj 1-based) + le signe de sa normale.
|
||||
$octFaces = @(
|
||||
@(1, 3, 5, 1, 1, 1), @(3, 2, 5, -1, 1, 1),
|
||||
@(2, 4, 5, -1, -1, 1), @(4, 1, 5, 1, -1, 1),
|
||||
@(3, 1, 6, 1, 1, -1), @(2, 3, 6, -1, 1, -1),
|
||||
@(4, 2, 6, -1, -1, -1), @(1, 4, 6, 1, -1, -1)
|
||||
)
|
||||
|
||||
$lines = New-Object System.Collections.ArrayList
|
||||
[void]$lines.Add('# Vercora - asset de test Phase 3 : octaedre a facettes plates')
|
||||
[void]$lines.Add('# 6 positions / 8 normales distinctes / 8 triangles')
|
||||
[void]$lines.Add('# Chaque position est reutilisee avec plusieurs normales : teste la')
|
||||
[void]$lines.Add('# deduplication du loader sur le triplet (position, uv, normale).')
|
||||
[void]$lines.Add('# Genere par tools/gen_test_meshes.ps1 - ne pas editer a la main')
|
||||
[void]$lines.Add('o OctahedronFlat')
|
||||
|
||||
foreach ($p in $octPos) {
|
||||
$line = 'v {0} {1} {2}' -f (Fmt $p[0]), (Fmt $p[1]), (Fmt $p[2])
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
$invSqrt3 = 1.0 / [math]::Sqrt(3.0)
|
||||
foreach ($f in $octFaces) {
|
||||
$line = 'vn {0} {1} {2}' -f (Fmt ($f[3] * $invSqrt3)), (Fmt ($f[4] * $invSqrt3)), (Fmt ($f[5] * $invSqrt3))
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
# Pas de 'vt' ici : verifie aussi que le loader accepte un .obj SANS UV
|
||||
# (format "f v//vn").
|
||||
$n = 0
|
||||
foreach ($f in $octFaces) {
|
||||
$n++
|
||||
$line = 'f {0}//{3} {1}//{3} {2}//{3}' -f $f[0], $f[1], $f[2], $n
|
||||
[void]$lines.Add($line)
|
||||
}
|
||||
|
||||
Write-ObjFile (Join-Path $assetsDir 'octahedron.obj') $lines.ToArray()
|
||||
@@ -0,0 +1,12 @@
|
||||
# Script pour lancer Vercora et amener la fenetre au premier plan
|
||||
$buildDir = "$PSScriptRoot\..\build"
|
||||
$exePath = "$buildDir\vercora.exe"
|
||||
|
||||
# Arreter toute instance preexistante
|
||||
Get-Process -Name vercora -ErrorAction SilentlyContinue | Stop-Process -Force
|
||||
Start-Sleep -Milliseconds 300
|
||||
|
||||
# Demarrer le processus
|
||||
$p = Start-Process -FilePath $exePath -ArgumentList "--demo" -WorkingDirectory "$PSScriptRoot\.." -PassThru
|
||||
|
||||
Write-Host "Vercora lance avec le PID $($p.Id)"
|
||||
@@ -0,0 +1,231 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
lidar_to_canopy.py — extrait des dalles LiDAR HD une CARTE DE COUVERT FORESTIER.
|
||||
|
||||
PHASE 11, tache 2. Jusqu'ici les arbres etaient semes par tirage-rejet uniforme
|
||||
(pente + espacement) sur une zone de test de quelques dizaines de metres. A
|
||||
l'echelle des 25 km2 reels, semer uniformement donnerait des arbres sur les
|
||||
lapiaz, sur les eboulis et au milieu des pistes de ski — c'est-a-dire un paysage
|
||||
faux, alors que la donnee qui dit ou sont VRAIMENT les arbres est deja sur le
|
||||
disque : les nuages LiDAR sont CLASSIFIES.
|
||||
|
||||
python tools/lidar_to_canopy.py data/lidar -o assets/terrain/vercora_zone_canopy.vchm \\
|
||||
--extent assets/terrain/vercora_zone_1m.vchm
|
||||
|
||||
CE QUE DIT LA CLASSIFICATION (norme ASPRS, verifie sur ces dalles) :
|
||||
2 = sol ~90 % 3 = vegetation basse ~1,9 %
|
||||
4 = vegetation moyenne ~0,7 % 5 = vegetation haute ~4,7 %
|
||||
1 = non classe ~2,8 % 6 = bati, 64 = bruit
|
||||
|
||||
DEUX GRANDEURS SONT PRODUITES, dans deux fichiers :
|
||||
- le COUVERT (--out) : part des retours de vegetation (classes 3, 4 et 5) parmi
|
||||
tous les retours valides de la cellule. C'est une fraction entre 0 et 1, donc
|
||||
insensible a la densite de vol, contrairement a un simple comptage.
|
||||
- la HAUTEUR DE CANOPEE (--out-height) : altitude du plus haut retour de classe
|
||||
5 moins l'altitude du plus bas retour de sol, dans la meme cellule. C'est la
|
||||
hauteur du plus grand arbre de la cellule, en metres.
|
||||
Le jeu se sert du premier pour savoir OU semer, du second pour savoir QUELLE
|
||||
TAILLE donner aux arbres — deux questions distinctes que la meme carte ne peut
|
||||
pas trancher.
|
||||
|
||||
LE MAXIMUM PLUTOT QU'UN PERCENTILE. Un percentile de hauteur demanderait de
|
||||
conserver tous les points d'une cellule ; le maximum se calcule en un seul
|
||||
passage, sans rien stocker. Sur des cellules de 5 m il designe le plus grand
|
||||
arbre de la cellule, ce qui est exactement la grandeur voulue. Contrepartie
|
||||
assumee : un point aberrant non filtre (classe 64) gonflerait la valeur, d'ou
|
||||
l'exclusion explicite du bruit et l'ecretage a --max-height.
|
||||
|
||||
FORMAT DE SORTIE : le meme .vchm que le terrain (voir tools/lidar_to_heightmap.py).
|
||||
C'est volontaire et ce n'est pas un abus : un .vchm est une GRILLE DE FLOTTANTS
|
||||
GEOREFERENCEE, et rien dans le format n'impose que le flottant soit une altitude.
|
||||
Le moteur relit donc ces cartes avec loadTerrainFile() sans une ligne de code
|
||||
nouvelle, et obtient gratuitement l'interpolation bilineaire de heightAt() et la
|
||||
conversion monde <-> Lambert 93. La grille produite a EXACTEMENT la meme origine
|
||||
et la meme emprise que le terrain, seul son pas differe : un point du monde s'y
|
||||
lit donc avec la meme formule, sans decalage a corriger.
|
||||
|
||||
Dependances : laspy + lazrs + numpy.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
try:
|
||||
import numpy as np
|
||||
import laspy
|
||||
except ImportError:
|
||||
sys.exit('laspy et numpy sont requis : python -m pip install "laspy[lazrs]" numpy')
|
||||
|
||||
HEADER_SIZE = 120
|
||||
CHUNK = 4_000_000
|
||||
|
||||
CLASS_GROUND = 2
|
||||
CLASSES_VEGETATION = (3, 4, 5)
|
||||
CLASS_HIGH_VEGETATION = 5
|
||||
# Classes a EXCLURE du denominateur : ce ne sont pas des retours de surface.
|
||||
CLASSES_REJECTED = (7, 18, 64, 65, 66)
|
||||
|
||||
|
||||
def read_extent(path: str):
|
||||
"""(originEast, originNorth, samples, spacing) d'un .vchm de reference."""
|
||||
with open(path, "rb") as f:
|
||||
head = f.read(HEADER_SIZE)
|
||||
if len(head) < HEADER_SIZE or head[:4] != b"VCHM":
|
||||
sys.exit(f"{path} n'est pas un fichier .vchm.")
|
||||
_m, _v, sx, sz, spacing, _r, origin_e, origin_n = struct.unpack_from("<4sIIIfIdd", head, 0)
|
||||
if sx != sz:
|
||||
sys.exit(f"{path} : grille non carree ({sx}x{sz}), non gere.")
|
||||
return origin_e, origin_n, sx, spacing
|
||||
|
||||
|
||||
def write_vchm(path: str, grid: np.ndarray, spacing: float,
|
||||
origin_e: float, origin_n: float, label: str) -> None:
|
||||
samples = grid.shape[0]
|
||||
header = bytearray(HEADER_SIZE)
|
||||
struct.pack_into("<4sIIIfI", header, 0, b"VCHM", 1, samples, samples, spacing, 0)
|
||||
struct.pack_into("<dd", header, 24, origin_e, origin_n)
|
||||
struct.pack_into("<ff", header, 40, float(grid.min()), float(grid.max()))
|
||||
# epsg 2154, flags 0 : ce ne sont PAS des altitudes absolues, et le dire evite
|
||||
# qu'un outil de controle croise ces valeurs avec un modele de terrain.
|
||||
struct.pack_into("<II", header, 48, 2154, 0)
|
||||
encoded = label.encode("utf-8")[:63]
|
||||
header[56:56 + len(encoded)] = encoded
|
||||
with open(path, "wb") as f:
|
||||
f.write(header)
|
||||
f.write(grid.astype(np.float32).tobytes())
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Carte de couvert forestier et de hauteur de canopee depuis le LiDAR.")
|
||||
parser.add_argument("lidar_dir", help="repertoire des dalles .copc.laz")
|
||||
parser.add_argument("--extent", required=True,
|
||||
help="terrain .vchm dont on reprend origine et emprise")
|
||||
parser.add_argument("-o", "--out", required=True, help=".vchm de couvert (0..1)")
|
||||
parser.add_argument("--out-height", default=None,
|
||||
help=".vchm de hauteur de canopee (m). Par defaut, "
|
||||
"le nom de --out avec _height avant l'extension.")
|
||||
parser.add_argument("--cell", type=float, default=5.0,
|
||||
help="pas de la grille produite, en metres (defaut 5)")
|
||||
parser.add_argument("--max-height", type=float, default=45.0,
|
||||
help="ecretage de la hauteur de canopee (defaut 45 m)")
|
||||
args = parser.parse_args()
|
||||
|
||||
origin_e, origin_n, terrain_samples, terrain_spacing = read_extent(args.extent)
|
||||
span = (terrain_samples - 1) * terrain_spacing
|
||||
if abs(span / args.cell - round(span / args.cell)) > 1e-9:
|
||||
sys.exit(f"L'emprise ({span:g} m) n'est pas un multiple de --cell {args.cell:g}.")
|
||||
|
||||
samples = int(round(span / args.cell)) + 1
|
||||
east_max = origin_e + span
|
||||
north_min = origin_n - span
|
||||
print(f"Reference : {args.extent}")
|
||||
print(f" emprise E {origin_e:.0f}..{east_max:.0f} N {north_min:.0f}..{origin_n:.0f}")
|
||||
print(f" grille produite : {samples}x{samples} au pas de {args.cell:g} m")
|
||||
|
||||
# Un accumulateur par grandeur. Les noeuds sont les CENTRES des cellules
|
||||
# d'agregation : c'est ce qui permet a la grille produite d'avoir exactement
|
||||
# la meme origine et la meme emprise que le terrain, donc de se lire avec la
|
||||
# meme formule monde <-> grille, sans demi-cellule a corriger quelque part.
|
||||
total_count = np.zeros((samples, samples), dtype=np.int32)
|
||||
veg_count = np.zeros((samples, samples), dtype=np.int32)
|
||||
high_max = np.full((samples, samples), -np.inf, dtype=np.float32)
|
||||
ground_min = np.full((samples, samples), np.inf, dtype=np.float32)
|
||||
|
||||
tiles = sorted(glob.glob(os.path.join(args.lidar_dir, "*.laz")))
|
||||
if not tiles:
|
||||
sys.exit(f"Aucune dalle .laz dans {args.lidar_dir}.")
|
||||
print(f"\n{len(tiles)} dalle(s) a depouiller.")
|
||||
|
||||
started = time.time()
|
||||
for index, path in enumerate(tiles, 1):
|
||||
name = os.path.basename(path)
|
||||
tile_started = time.time()
|
||||
kept = 0
|
||||
with laspy.open(path) as reader:
|
||||
for chunk in reader.chunk_iterator(CHUNK):
|
||||
cls = np.asarray(chunk.classification)
|
||||
valid = ~np.isin(cls, CLASSES_REJECTED)
|
||||
if not valid.any():
|
||||
continue
|
||||
cls = cls[valid]
|
||||
x = np.asarray(chunk.x)[valid]
|
||||
y = np.asarray(chunk.y)[valid]
|
||||
z = np.asarray(chunk.z)[valid].astype(np.float32)
|
||||
|
||||
# Indices de noeud : ARRONDI (et non partie entiere), puisque le
|
||||
# noeud est le centre de sa cellule. iz croit vers le SUD, comme
|
||||
# dans le .vchm du terrain.
|
||||
ix = np.rint((x - origin_e) / args.cell).astype(np.int64)
|
||||
iz = np.rint((origin_n - y) / args.cell).astype(np.int64)
|
||||
inside = (ix >= 0) & (ix < samples) & (iz >= 0) & (iz < samples)
|
||||
if not inside.any():
|
||||
continue
|
||||
ix, iz, cls, z = ix[inside], iz[inside], cls[inside], z[inside]
|
||||
flat = iz * samples + ix
|
||||
kept += flat.size
|
||||
|
||||
np.add.at(total_count.reshape(-1), flat, 1)
|
||||
|
||||
veg = np.isin(cls, CLASSES_VEGETATION)
|
||||
if veg.any():
|
||||
np.add.at(veg_count.reshape(-1), flat[veg], 1)
|
||||
|
||||
high = cls == CLASS_HIGH_VEGETATION
|
||||
if high.any():
|
||||
np.maximum.at(high_max.reshape(-1), flat[high], z[high])
|
||||
|
||||
ground = cls == CLASS_GROUND
|
||||
if ground.any():
|
||||
np.minimum.at(ground_min.reshape(-1), flat[ground], z[ground])
|
||||
|
||||
print(f" [{index}/{len(tiles)}] {name} : {kept:,} points retenus "
|
||||
f"en {time.time() - tile_started:.1f} s")
|
||||
|
||||
# --- Couvert ------------------------------------------------------------
|
||||
# Une cellule sans aucun retour (hors emprise du vol, ou trou de donnees)
|
||||
# reste a zero : mieux vaut ne pas y semer d'arbre que d'en inventer.
|
||||
cover = np.zeros((samples, samples), dtype=np.float32)
|
||||
seen = total_count > 0
|
||||
cover[seen] = veg_count[seen].astype(np.float32) / total_count[seen]
|
||||
|
||||
# --- Hauteur de canopee -------------------------------------------------
|
||||
height = np.zeros((samples, samples), dtype=np.float32)
|
||||
usable = np.isfinite(high_max) & np.isfinite(ground_min)
|
||||
height[usable] = high_max[usable] - ground_min[usable]
|
||||
np.clip(height, 0.0, args.max_height, out=height)
|
||||
|
||||
out_height = args.out_height
|
||||
if out_height is None:
|
||||
stem, extension = os.path.splitext(args.out)
|
||||
out_height = stem + "_height" + extension
|
||||
|
||||
for path, grid, label in ((args.out, cover, "couvert_vegetal"),
|
||||
(out_height, height, "hauteur_canopee")):
|
||||
os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
|
||||
write_vchm(path, grid, args.cell, origin_e, origin_n, label)
|
||||
|
||||
covered = float((cover > 0.15).mean())
|
||||
wooded = float((height >= 3.0).mean())
|
||||
print(f"\nEcrit : {args.out}")
|
||||
print(f" couvert : moyenne {cover.mean():.3f}, max {cover.max():.3f} ; "
|
||||
f"{100 * covered:.1f} % des cellules au-dessus de 0,15")
|
||||
print(f"Ecrit : {out_height}")
|
||||
print(f" canopee : moyenne des cellules boisees "
|
||||
f"{height[height >= 3.0].mean() if wooded else 0:.1f} m, "
|
||||
f"max {height.max():.1f} m ; {100 * wooded:.1f} % de cellules a 3 m ou plus")
|
||||
print(f" cellules sans aucun retour : {100 * float((~seen).mean()):.2f} %")
|
||||
print(f" en {time.time() - started:.0f} s")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,530 @@
|
||||
#!/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())
|
||||
@@ -0,0 +1,389 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
make_ortho_texture.py — assemble les tuiles BD ORTHO en une texture .vcto prete
|
||||
a etre envoyee au GPU : mosaique, chaine de mipmaps, compression BC1.
|
||||
|
||||
PHASE 11. Pendant du couple fetch_dalles.py / assemble_terrain.py de la Phase 9 :
|
||||
le telechargement et la MISE EN FORME sont deux outils separes, parce qu'on
|
||||
re-encode bien plus souvent qu'on ne retelecharge.
|
||||
|
||||
python tools/make_ortho_texture.py assets/terrain/vercora_zone_1m.vchm \
|
||||
-i data/ortho -o assets/terrain/vercora_zone_ortho.vcto
|
||||
python tools/make_ortho_texture.py ... --size 4096 --format rgba
|
||||
|
||||
POURQUOI TOUT EST PRECALCULE ICI, MIPMAPS COMPRISES. Le chemin habituel cote
|
||||
moteur (generer les mipmaps sur le GPU par vkCmdBlitImage) est INAPPLICABLE a une
|
||||
texture compressee : on ne peut pas filtrer des blocs BC1. Il faudrait donc soit
|
||||
renoncer a la compression, soit reduire puis compresser chaque niveau — c'est
|
||||
exactement ce que fait ce script. Le moteur, lui, se contente de recopier des
|
||||
octets deja prets, ce qui rend son code de chargement plus simple, pas moins.
|
||||
|
||||
POURQUOI BC1. La zone fait 5 x 5 km. A 8192 px de cote (0,61 m/texel) :
|
||||
- en RGBA8 non compresse : 268 Mo, plus 89 Mo de mipmaps ;
|
||||
- en BC1 (6:1, blocs de 4x4 sur 8 octets) : 33 Mo, plus 11 Mo de mipmaps.
|
||||
Sur le GPU integre de cette machine, dont la memoire est prise sur la RAM
|
||||
systeme et dont la Phase 10 avait ramene l'empreinte totale a 246 Mo, la
|
||||
difference n'est pas cosmetique. BC1 est disponible sur tout GPU de bureau
|
||||
(feature Vulkan textureCompressionBC) ; le moteur le VERIFIE et refuse de charger
|
||||
une texture BC1 sur un GPU qui ne la gere pas, plutot que d'afficher n'importe
|
||||
quoi. --format rgba reste disponible comme repli.
|
||||
|
||||
QUALITE DE L'ENCODAGE. BC1 est destructif. Le script mesure et AFFICHE le PSNR
|
||||
du niveau 0 apres aller-retour : sur de la photo aerienne (contenu a haute
|
||||
frequence, sans grands aplats degrades) on attend environ 35 dB, ce qui est
|
||||
visuellement indiscernable a la distance ou le terrain est regarde. Un chiffre
|
||||
nettement plus bas serait le signe d'un defaut d'encodage, pas d'une limite du
|
||||
format — d'ou son affichage systematique plutot qu'une confiance aveugle.
|
||||
|
||||
FORMAT .vcto ("Vercora TexturE Ortho"), petit-boutiste, en-tete de 128 octets :
|
||||
|
||||
0 "VCTO" magie
|
||||
4 uint32 version = 1
|
||||
8 uint32 width largeur du niveau 0
|
||||
12 uint32 height
|
||||
16 uint32 mipLevels niveaux stockes, du plus grand au plus petit
|
||||
20 uint32 format 0 = RGBA8 brut, 1 = BC1 (RGB, blocs de 8 octets)
|
||||
24 float64 eastMin \
|
||||
32 float64 northMin | emprise Lambert 93 COUVERTE par l'image,
|
||||
40 float64 eastMax | bord a bord (et non centres de texels)
|
||||
48 float64 northMax /
|
||||
56 uint32 epsg 2154
|
||||
60 uint32 flags reserve
|
||||
64 char[64] label
|
||||
128 donnees des mipmaps, consecutives, sans remplissage
|
||||
|
||||
L'emprise est recopiee dans l'en-tete pour que le moteur puisse VERIFIER qu'elle
|
||||
correspond a celle de la heightmap chargee, au lieu de supposer que l'utilisateur
|
||||
a associe les bons fichiers. Une texture d'une autre zone est refusee au
|
||||
chargement avec un message explicite.
|
||||
|
||||
Dependances : Pillow, numpy.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
try:
|
||||
import numpy as np
|
||||
from PIL import Image
|
||||
except ImportError:
|
||||
sys.exit("Pillow et numpy sont requis : python -m pip install Pillow numpy")
|
||||
|
||||
Image.MAX_IMAGE_PIXELS = None
|
||||
|
||||
FORMAT_RGBA8 = 0
|
||||
FORMAT_BC1 = 1
|
||||
HEADER_SIZE = 128
|
||||
TILE_RE = re.compile(r"ortho_(\d+)_(\d+)_(\d+)px\.(jpg|png)$", re.IGNORECASE)
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
from fetch_ortho import Extent # noqa: E402 (meme definition d'emprise, pas de copie)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Compression BC1
|
||||
# ---------------------------------------------------------------------------
|
||||
def _pack565(rgb: np.ndarray) -> np.ndarray:
|
||||
"""(N,3) uint8 -> (N,) uint16 au format RGB565."""
|
||||
r = (rgb[:, 0].astype(np.uint16) >> 3) << 11
|
||||
g = (rgb[:, 1].astype(np.uint16) >> 2) << 5
|
||||
b = (rgb[:, 2].astype(np.uint16) >> 3)
|
||||
return (r | g | b).astype(np.uint16)
|
||||
|
||||
|
||||
def _unpack565(packed: np.ndarray) -> np.ndarray:
|
||||
"""(N,) uint16 -> (N,3) uint8 : la couleur REELLEMENT vue par le GPU.
|
||||
|
||||
La replication des bits de poids fort dans les bits perdus (r5<<3 | r5>>2)
|
||||
n'est pas une coquetterie : c'est ce que fait le materiel, et choisir les
|
||||
indices contre une autre valeur que celle-la ferait diverger l'encodeur du
|
||||
decodeur sur les couleurs extremes.
|
||||
"""
|
||||
p = packed.astype(np.uint32)
|
||||
r5 = (p >> 11) & 0x1F
|
||||
g6 = (p >> 5) & 0x3F
|
||||
b5 = p & 0x1F
|
||||
r = (r5 << 3) | (r5 >> 2)
|
||||
g = (g6 << 2) | (g6 >> 4)
|
||||
b = (b5 << 3) | (b5 >> 2)
|
||||
return np.stack([r, g, b], axis=1).astype(np.uint8)
|
||||
|
||||
|
||||
def encode_bc1(image: np.ndarray, chunk_blocks: int = 1 << 18) -> bytes:
|
||||
"""image (H,W,3) uint8, H et W multiples de 4 -> octets BC1.
|
||||
|
||||
Methode dite de la BOITE ENGLOBANTE avec retrait (le chemin rapide de
|
||||
stb_dxt) : les deux extremites de la palette sont les coins min/max du pave
|
||||
des couleurs du bloc, rentres d'un seizieme de leur ecart. Le retrait compte
|
||||
— sans lui les deux couleurs interpolees de la palette sont systematiquement
|
||||
trop rapprochees des extremes et les blocs bruites se delavent.
|
||||
|
||||
Le traitement est decoupe en paquets de blocs : la matrice des distances
|
||||
(blocs x 16 pixels x 4 couleurs) pese sinon plus d'un gigaoctet sur une
|
||||
texture de 8192 px.
|
||||
"""
|
||||
height, width, _ = image.shape
|
||||
assert height % 4 == 0 and width % 4 == 0
|
||||
|
||||
# (H,W,3) -> (nblocks, 16, 3), les 16 pixels d'un bloc dans l'ordre BC1
|
||||
# (ligne par ligne, de gauche a droite).
|
||||
blocks = (image.reshape(height // 4, 4, width // 4, 4, 3)
|
||||
.transpose(0, 2, 1, 3, 4)
|
||||
.reshape(-1, 16, 3))
|
||||
total = blocks.shape[0]
|
||||
out = np.empty(total * 8, dtype=np.uint8)
|
||||
|
||||
for start in range(0, total, chunk_blocks):
|
||||
chunk = blocks[start:start + chunk_blocks].astype(np.int16)
|
||||
n = chunk.shape[0]
|
||||
|
||||
lo = chunk.min(axis=1)
|
||||
hi = chunk.max(axis=1)
|
||||
inset = (hi - lo) >> 4
|
||||
lo = np.clip(lo + inset, 0, 255).astype(np.uint8)
|
||||
hi = np.clip(hi - inset, 0, 255).astype(np.uint8)
|
||||
|
||||
packed_hi = _pack565(hi)
|
||||
packed_lo = _pack565(lo)
|
||||
|
||||
# BC1 n'entre en mode 4 couleurs que si c0 > c1 (strictement). On force
|
||||
# donc l'ordre ; l'egalite designe un bloc uni, dont tous les indices
|
||||
# tomberont naturellement sur 0.
|
||||
c0 = np.maximum(packed_hi, packed_lo)
|
||||
c1 = np.minimum(packed_hi, packed_lo)
|
||||
|
||||
e0 = _unpack565(c0).astype(np.int16)
|
||||
e1 = _unpack565(c1).astype(np.int16)
|
||||
|
||||
palette = np.empty((n, 4, 3), dtype=np.int16)
|
||||
palette[:, 0] = e0
|
||||
palette[:, 1] = e1
|
||||
palette[:, 2] = (2 * e0 + e1) // 3
|
||||
palette[:, 3] = (e0 + 2 * e1) // 3
|
||||
|
||||
# (n,16,1,3) - (n,1,4,3) -> (n,16,4)
|
||||
# int32 OBLIGATOIRE : une distance au carre monte a 3 x 255^2 = 195 075,
|
||||
# tres au-dela des 32 767 d'un int16. En int16 l'accumulation deborde en
|
||||
# silence, l'argmin choisit une couleur au hasard, et le PSNR tombe de
|
||||
# ~36 a ~22 dB sans qu'aucune erreur ne soit levee.
|
||||
diff = (chunk[:, :, None, :].astype(np.int32)
|
||||
- palette[:, None, :, :].astype(np.int32))
|
||||
distance = np.einsum("nikc,nikc->nik", diff, diff)
|
||||
indices = distance.argmin(axis=2).astype(np.uint32) # (n,16)
|
||||
|
||||
# Le pixel 0 occupe les bits de poids faible du mot d'indices.
|
||||
shifts = (2 * np.arange(16, dtype=np.uint32))[None, :]
|
||||
packed_indices = np.bitwise_or.reduce(indices << shifts, axis=1)
|
||||
|
||||
block_bytes = np.empty((n, 8), dtype=np.uint8)
|
||||
block_bytes[:, 0] = c0 & 0xFF
|
||||
block_bytes[:, 1] = c0 >> 8
|
||||
block_bytes[:, 2] = c1 & 0xFF
|
||||
block_bytes[:, 3] = c1 >> 8
|
||||
block_bytes[:, 4] = packed_indices & 0xFF
|
||||
block_bytes[:, 5] = (packed_indices >> 8) & 0xFF
|
||||
block_bytes[:, 6] = (packed_indices >> 16) & 0xFF
|
||||
block_bytes[:, 7] = (packed_indices >> 24) & 0xFF
|
||||
|
||||
out[start * 8:(start + n) * 8] = block_bytes.reshape(-1)
|
||||
|
||||
return out.tobytes()
|
||||
|
||||
|
||||
def decode_bc1(data: bytes, width: int, height: int) -> np.ndarray:
|
||||
"""Decodeur de controle, utilise uniquement pour mesurer le PSNR.
|
||||
|
||||
Ecrit INDEPENDAMMENT de l'encodeur (il repart des octets produits, comme le
|
||||
ferait le GPU) : c'est ce qui lui permet d'attraper une erreur d'ordre des
|
||||
bits ou d'endianness, qu'un simple aller-retour interne masquerait.
|
||||
"""
|
||||
raw = np.frombuffer(data, dtype=np.uint8).reshape(-1, 8)
|
||||
c0 = raw[:, 0].astype(np.uint16) | (raw[:, 1].astype(np.uint16) << 8)
|
||||
c1 = raw[:, 2].astype(np.uint16) | (raw[:, 3].astype(np.uint16) << 8)
|
||||
bits = (raw[:, 4].astype(np.uint32) | (raw[:, 5].astype(np.uint32) << 8) |
|
||||
(raw[:, 6].astype(np.uint32) << 16) | (raw[:, 7].astype(np.uint32) << 24))
|
||||
|
||||
e0 = _unpack565(c0).astype(np.int16)
|
||||
e1 = _unpack565(c1).astype(np.int16)
|
||||
n = raw.shape[0]
|
||||
palette = np.empty((n, 4, 3), dtype=np.int16)
|
||||
palette[:, 0] = e0
|
||||
palette[:, 1] = e1
|
||||
four = (c0 > c1)[:, None]
|
||||
palette[:, 2] = np.where(four, (2 * e0 + e1) // 3, (e0 + e1) // 2)
|
||||
palette[:, 3] = np.where(four, (e0 + 2 * e1) // 3, 0)
|
||||
|
||||
shifts = (2 * np.arange(16, dtype=np.uint32))[None, :]
|
||||
indices = (bits[:, None] >> shifts) & 0x3
|
||||
pixels = np.take_along_axis(palette, indices[:, :, None].astype(np.intp), axis=1)
|
||||
|
||||
return (pixels.reshape(height // 4, width // 4, 4, 4, 3)
|
||||
.transpose(0, 2, 1, 3, 4)
|
||||
.reshape(height, width, 3)).astype(np.uint8)
|
||||
|
||||
|
||||
def psnr(a: np.ndarray, b: np.ndarray) -> float:
|
||||
mse = np.mean((a.astype(np.float64) - b.astype(np.float64)) ** 2)
|
||||
if mse <= 0.0:
|
||||
return float("inf")
|
||||
return 10.0 * np.log10(255.0 * 255.0 / mse)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Mosaique
|
||||
# ---------------------------------------------------------------------------
|
||||
def build_mosaic(tile_dir: str, extent: Extent) -> tuple[Image.Image, float]:
|
||||
"""Recolle les tuiles telechargees. Renvoie (image, metres par pixel).
|
||||
|
||||
Les tuiles sont placees par leurs COORDONNEES, lues dans leur nom de
|
||||
fichier, et non par ordre alphabetique : c'est ce qui garantit que le nord
|
||||
est en haut. Une tuile manquante est une erreur franche — une mosaique
|
||||
trouee produirait une texture noire par endroits, defaut qu'on ne
|
||||
remarquerait qu'en jeu, longtemps apres.
|
||||
"""
|
||||
tiles = {}
|
||||
tile_px = None
|
||||
for path in glob.glob(os.path.join(tile_dir, "ortho_*px.*")):
|
||||
match = TILE_RE.search(os.path.basename(path))
|
||||
if not match:
|
||||
continue
|
||||
east, north, px = int(match.group(1)), int(match.group(2)), int(match.group(3))
|
||||
if tile_px is None:
|
||||
tile_px = px
|
||||
elif px != tile_px:
|
||||
sys.exit(f"{tile_dir} contient des tuiles de tailles differentes "
|
||||
f"({tile_px} et {px} px). Vider le repertoire et retelecharger.")
|
||||
tiles[(east, north)] = path
|
||||
|
||||
if not tiles:
|
||||
sys.exit(f"Aucune tuile ortho_*px.* dans {tile_dir}. "
|
||||
"Lancer d'abord tools/fetch_ortho.py.")
|
||||
|
||||
easts = sorted({e for e, _ in tiles})
|
||||
norths = sorted({n for _, n in tiles})
|
||||
tile_m = (easts[1] - easts[0]) if len(easts) > 1 else int(extent.width_m)
|
||||
cols, rows = len(easts), len(norths)
|
||||
|
||||
expected_cols = int(round(extent.width_m / tile_m))
|
||||
expected_rows = int(round(extent.height_m / tile_m))
|
||||
if cols != expected_cols or rows != expected_rows or len(tiles) != cols * rows:
|
||||
sys.exit(f"Couverture incomplete : {len(tiles)} tuiles pour une grille "
|
||||
f"{expected_cols}x{expected_rows} attendue. Relancer fetch_ortho.py.")
|
||||
|
||||
mosaic = Image.new("RGB", (cols * tile_px, rows * tile_px))
|
||||
for column, east in enumerate(easts):
|
||||
for row, north in enumerate(norths):
|
||||
# Les nords CROISSENT vers le haut, les lignes d'image vers le bas :
|
||||
# d'ou l'inversion. C'est le seul endroit ou le sens du nord est
|
||||
# decide, et c'est exactement l'erreur que la Phase 9 ne pouvait pas
|
||||
# detecter faute d'orthophoto.
|
||||
y = (rows - 1 - row) * tile_px
|
||||
with Image.open(tiles[(east, north)]) as tile:
|
||||
mosaic.paste(tile.convert("RGB"), (column * tile_px, y))
|
||||
|
||||
return mosaic, tile_m / float(tile_px)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Assemble les tuiles BD ORTHO en texture .vcto (mipmaps + BC1).")
|
||||
parser.add_argument("terrain", help="fichier .vchm dont on reprend l'emprise")
|
||||
parser.add_argument("-i", "--input", default="data/ortho", help="repertoire des tuiles")
|
||||
parser.add_argument("-o", "--output", required=True, help="fichier .vcto a ecrire")
|
||||
parser.add_argument("--size", type=int, default=8192,
|
||||
help="cote de la texture GPU, en texels (defaut 8192). "
|
||||
"Doit etre une puissance de deux et un multiple de 4.")
|
||||
parser.add_argument("--format", default="bc1", choices=("bc1", "rgba"))
|
||||
parser.add_argument("--no-psnr", action="store_true",
|
||||
help="saute la mesure de qualite (elle double la duree)")
|
||||
args = parser.parse_args()
|
||||
|
||||
if args.size & (args.size - 1) or args.size < 4:
|
||||
sys.exit("--size doit etre une puissance de deux >= 4.")
|
||||
|
||||
extent = Extent(args.terrain)
|
||||
print(extent.describe())
|
||||
|
||||
started = time.time()
|
||||
print(f"\nAssemblage depuis {args.input} ...")
|
||||
mosaic, source_res = build_mosaic(args.input, extent)
|
||||
print(f" mosaique {mosaic.size[0]} x {mosaic.size[1]} px "
|
||||
f"a {source_res:g} m/texel")
|
||||
|
||||
if mosaic.size[0] != args.size:
|
||||
print(f" redimensionnement -> {args.size} x {args.size} "
|
||||
f"({extent.width_m / args.size:.2f} m/texel) [Lanczos]")
|
||||
mosaic = mosaic.resize((args.size, args.size), Image.LANCZOS)
|
||||
|
||||
# Chaine de mipmaps complete, jusqu'au texel unique. Chaque niveau est reduit
|
||||
# depuis le PRECEDENT (et non depuis le niveau 0) : c'est la definition d'une
|
||||
# mipmap, et c'est deux fois moins de travail.
|
||||
levels = []
|
||||
current = mosaic
|
||||
while True:
|
||||
levels.append(current)
|
||||
if current.size[0] == 1 and current.size[1] == 1:
|
||||
break
|
||||
current = current.resize((max(1, current.size[0] // 2),
|
||||
max(1, current.size[1] // 2)), Image.LANCZOS)
|
||||
print(f" {len(levels)} niveaux de mipmap ({levels[0].size[0]} -> 1)")
|
||||
|
||||
fmt = FORMAT_BC1 if args.format == "bc1" else FORMAT_RGBA8
|
||||
payload = bytearray()
|
||||
for level, image in enumerate(levels):
|
||||
width, height = image.size
|
||||
if fmt == FORMAT_RGBA8:
|
||||
payload += image.convert("RGBA").tobytes()
|
||||
continue
|
||||
# BC1 travaille par blocs de 4x4 : les derniers niveaux (2x2, 1x1) sont
|
||||
# completes par replication du bord, ce qui est ce que produit n'importe
|
||||
# quel compresseur et ce que le GPU attend (l'image reste declaree a sa
|
||||
# taille reelle, le materiel ignore les texels de remplissage).
|
||||
array = np.asarray(image.convert("RGB"))
|
||||
pad_h = (-height) % 4
|
||||
pad_w = (-width) % 4
|
||||
if pad_h or pad_w:
|
||||
array = np.pad(array, ((0, pad_h), (0, pad_w), (0, 0)), mode="edge")
|
||||
encoded = encode_bc1(array)
|
||||
payload += encoded
|
||||
if level == 0 and not args.no_psnr:
|
||||
decoded = decode_bc1(encoded, array.shape[1], array.shape[0])
|
||||
quality = psnr(array, decoded)
|
||||
verdict = "bon" if quality >= 33.0 else "FAIBLE - a verifier"
|
||||
print(f" qualite BC1 du niveau 0 : PSNR {quality:.1f} dB ({verdict})")
|
||||
|
||||
header = bytearray(HEADER_SIZE)
|
||||
struct.pack_into("<4sIIIII", header, 0, b"VCTO", 1,
|
||||
levels[0].size[0], levels[0].size[1], len(levels), fmt)
|
||||
struct.pack_into("<dddd", header, 24,
|
||||
extent.east_min, extent.north_min, extent.east_max, extent.north_max)
|
||||
struct.pack_into("<II", header, 56, extent.epsg, 0)
|
||||
label = (extent.label + "_ortho").encode("utf-8")[:63]
|
||||
header[64:64 + len(label)] = label
|
||||
|
||||
os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
|
||||
with open(args.output, "wb") as f:
|
||||
f.write(header)
|
||||
f.write(payload)
|
||||
|
||||
size_mo = (HEADER_SIZE + len(payload)) / 1e6
|
||||
print(f"\nEcrit : {args.output}")
|
||||
print(f" {args.size} x {args.size}, {len(levels)} mipmaps, "
|
||||
f"format {'BC1' if fmt == FORMAT_BC1 else 'RGBA8'}, {size_mo:.1f} Mo")
|
||||
print(f" {extent.width_m / args.size:.2f} m/texel "
|
||||
f"(source BD ORTHO a {source_res:g} m/texel)")
|
||||
print(f" en {time.time() - started:.0f} s")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,150 @@
|
||||
# measure_terrain.ps1 - mesure FPS et memoire d'une scene, sans toucher au moteur.
|
||||
#
|
||||
# PHASE 9. La Phase 7 relevait ses chiffres a la main (848 FPS, 185 Mo). A
|
||||
# l'echelle de 25 km2 il faut comparer plusieurs scenes entre elles, donc une
|
||||
# mesure reproductible :
|
||||
#
|
||||
# powershell -File tools\measure_terrain.ps1 -Scene assets\terrain\LHD_0907_6440_1m.vchm
|
||||
# powershell -File tools\measure_terrain.ps1 -Scene terrain -Seconds 20
|
||||
#
|
||||
# Le FPS est lu dans le TITRE de la fenetre (le moteur l'y ecrit deja) et la
|
||||
# memoire via PeakWorkingSet64 : rien n'est ajoute au jeu pour l'occasion, donc
|
||||
# la mesure porte sur exactement le binaire qui tourne en vrai.
|
||||
#
|
||||
# Les premieres secondes sont IGNOREES (chargement, premiers frames, montee en
|
||||
# regime du pilote) : sans cela la moyenne d'une grosse scene est tiree vers le
|
||||
# bas par son propre chargement, et la comparaison entre scenes n'a plus de sens.
|
||||
#
|
||||
# Sortie : lignes "MESURE ..." faciles a relire, et code de sortie non nul si le
|
||||
# jeu n'a pas demarre ou n'est pas sorti proprement.
|
||||
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][string]$Scene,
|
||||
[int]$Seconds = 15,
|
||||
[int]$WarmupSeconds = 5,
|
||||
# PHASE 10 : options supplementaires passees telles quelles au jeu, pour
|
||||
# mesurer la MEME scene avec et sans le systeme de LOD (--no-lod). Sans ce
|
||||
# parametre il faudrait deux scripts, ou recompiler entre les deux mesures -
|
||||
# et la comparaison ne porterait plus sur le meme binaire.
|
||||
[string[]]$GameArgs = @()
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" }
|
||||
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Text;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32M {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
[DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowTextW(IntPtr h, StringBuilder s, int n);
|
||||
}
|
||||
"@
|
||||
$WM_CLOSE = 0x0010
|
||||
|
||||
Write-Host ("=== Mesure : {0} {1}===" -f $Scene, ($(if ($GameArgs.Count) { ($GameArgs -join ' ') + ' ' } else { '' })))
|
||||
|
||||
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
||||
$psi.FileName = $exe
|
||||
$psi.Arguments = (@('"' + $Scene + '"') + $GameArgs) -join ' '
|
||||
$psi.WorkingDirectory = $root
|
||||
$psi.UseShellExecute = $false
|
||||
$psi.RedirectStandardOutput = $true
|
||||
$psi.RedirectStandardError = $true
|
||||
|
||||
$loadStart = Get-Date
|
||||
$proc = [System.Diagnostics.Process]::Start($psi)
|
||||
|
||||
$outSb = New-Object System.Text.StringBuilder
|
||||
$errSb = New-Object System.Text.StringBuilder
|
||||
$handlers = @(
|
||||
(Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $outSb),
|
||||
(Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $errSb)
|
||||
)
|
||||
$proc.BeginOutputReadLine()
|
||||
$proc.BeginErrorReadLine()
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 600 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) {
|
||||
$proc.WaitForExit()
|
||||
Start-Sleep -Milliseconds 300
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
Write-Host ($outSb.ToString() + $errSb.ToString())
|
||||
Write-Host "[ECHEC] Pas de fenetre (HasExited=$($proc.HasExited), code=$($proc.ExitCode))."
|
||||
exit 1
|
||||
}
|
||||
$loadSeconds = ((Get-Date) - $loadStart).TotalSeconds
|
||||
Write-Host ("MESURE chargement : {0:N1} s (lancement -> fenetre affichee)" -f $loadSeconds)
|
||||
|
||||
Start-Sleep -Seconds $WarmupSeconds
|
||||
|
||||
$samples = New-Object System.Collections.ArrayList
|
||||
$sb = New-Object System.Text.StringBuilder 512
|
||||
$deadline = (Get-Date).AddSeconds($Seconds)
|
||||
while ((Get-Date) -lt $deadline) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
[void]$sb.Clear()
|
||||
[void][W32M]::GetWindowTextW($hwnd, $sb, 512)
|
||||
$title = $sb.ToString()
|
||||
if ($title -match '(\d+)\s*FPS') { [void]$samples.Add([int]$Matches[1]) }
|
||||
Start-Sleep -Milliseconds 250
|
||||
}
|
||||
|
||||
$proc.Refresh()
|
||||
$peakMb = [math]::Round($proc.PeakWorkingSet64 / 1MB, 1)
|
||||
$workingMb = [math]::Round($proc.WorkingSet64 / 1MB, 1)
|
||||
|
||||
if ($samples.Count -gt 0) {
|
||||
$sorted = $samples | Sort-Object
|
||||
$median = $sorted[[int]($sorted.Count / 2)]
|
||||
$stats = $samples | Measure-Object -Average -Minimum -Maximum
|
||||
Write-Host ("MESURE FPS : median {0}, moyen {1:N0}, min {2}, max {3} ({4} releves)" -f `
|
||||
$median, $stats.Average, $stats.Minimum, $stats.Maximum, $samples.Count)
|
||||
} else {
|
||||
Write-Host "MESURE FPS : aucun releve (titre sans FPS ?)"
|
||||
}
|
||||
Write-Host ("MESURE memoire : pic {0} Mo, courant {1} Mo (processus, RAM systeme)" -f $peakMb, $workingMb)
|
||||
|
||||
[void][W32M]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) {
|
||||
Write-Host "[ECHEC] Pas de sortie 30 s apres WM_CLOSE."
|
||||
$proc.Kill(); $proc.WaitForExit()
|
||||
$code = 1
|
||||
} else {
|
||||
$code = $proc.ExitCode
|
||||
}
|
||||
$proc.WaitForExit()
|
||||
Start-Sleep -Milliseconds 400
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
|
||||
$text = $outSb.ToString() + $errSb.ToString()
|
||||
$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' })
|
||||
|
||||
# Zero erreur de validation Vulkan est une contrainte de chaque etape, pas
|
||||
# seulement du harnais complet : on la verifie donc aussi ici.
|
||||
$validation = @($lines | Where-Object { $_ -match '\[Validation\]' })
|
||||
$errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' })
|
||||
Write-Host ("MESURE validation Vulkan: {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f `
|
||||
$validation.Count, $errors.Count)
|
||||
foreach ($l in ($validation + $errors) | Select-Object -First 12) { Write-Host " $l" }
|
||||
|
||||
$interesting = @($lines | Where-Object { $_ -match 'Terrain|echantillon|sommets|triangles|Lambert|denivele|Quadtree|tuiles' })
|
||||
foreach ($l in $interesting | Select-Object -First 12) { Write-Host " | $l" }
|
||||
|
||||
Write-Host ("MESURE code de sortie : {0}" -f $code)
|
||||
if ($validation.Count -gt 0 -or $errors.Count -gt 0 -or $code -ne 0) { exit 1 }
|
||||
exit 0
|
||||
@@ -0,0 +1,186 @@
|
||||
# ===========================================================================
|
||||
# PHASE 27 - Mesure de cout ENTRELACEE, avec temoin de sante machine.
|
||||
# ===========================================================================
|
||||
# Ce script applique les trois lecons de mesure du projet, et n'existe que pour
|
||||
# ne plus avoir a s'en souvenir a la main :
|
||||
#
|
||||
# 1. Conditions ENTRELACEES, jamais en blocs (MEMORY : "Mesurer en blocs
|
||||
# fabrique un effet"). Chaque tour joue A puis B, le tour suivant B puis A :
|
||||
# une derive lente de la machine (thermique, tache de fond) se repartit sur
|
||||
# les deux conditions au lieu de s'imputer a l'une.
|
||||
# 2. Un POSTE TEMOIN qui ne peut pas avoir bouge : le semis de l'herbe
|
||||
# (gatherGrass, CPU). Aucune des deux conditions ne touche au CPU de
|
||||
# l'herbe ; s'il varie de plus de 15 % entre A et B, c'est la machine qui a
|
||||
# change, et la comparaison est declaree SUSPECTE.
|
||||
# 3. SANTE MACHINE par run : le temps CPU consomme par TOUS LES AUTRES
|
||||
# processus pendant le run, et le nombre d'images rendues. Un run ou les
|
||||
# autres processus ont pris plus d'UN coeur en moyenne, ou qui a
|
||||
# rendu moins de 20 images/s, est NON CONCLUANT - jamais vert (MEMORY :
|
||||
# "Temoin de sante machine dans le harnais").
|
||||
#
|
||||
# Les conditions sont des PAIRES A/B dont B est le temoin ETROIT de ce que la
|
||||
# Phase 27 a ajoute (--no-weather-visuals, --no-ground-detail) : la difference
|
||||
# A - B est le cout de cet ajout et de rien d'autre.
|
||||
#
|
||||
# Usage :
|
||||
# powershell -File tools\profile_phase27.ps1 -Scenario pluie -Rounds 3 -Config Release
|
||||
# Scenarios : survol, pluie, sol, beau.
|
||||
# ===========================================================================
|
||||
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][ValidateSet("survol", "survolbeau", "pluie", "sol", "marche", "beau")][string]$Scenario,
|
||||
[int]$Rounds = 3,
|
||||
[int]$Seconds = 25,
|
||||
[string]$Config = "?",
|
||||
[string]$Scene = "assets\terrain\vercora_zone_1m.vchm",
|
||||
[string]$OutCsv = "build\phase27\profil.csv"
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
$scenePath = Join-Path $root $Scene
|
||||
$csv = Join-Path $root $OutCsv
|
||||
New-Item -ItemType Directory -Force -Path (Split-Path -Parent $csv) | Out-Null
|
||||
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32M {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
}
|
||||
"@
|
||||
|
||||
$alpage = @("--start=900500,6439000", "--time-scale=0", "--lock-input")
|
||||
switch ($Scenario) {
|
||||
# Survol de streaming, comme l'audit (900 m/s, 120 m), un jour de PLUIE :
|
||||
# tout le contenu de la Phase 27 qui peut couter y est actif. B = Phase 26.
|
||||
"survol" { $common = @("--flythrough=900", "--day=8", "--hour=13", "--time-scale=0", "--lock-input")
|
||||
$A = @(); $B = @("--no-weather-visuals", "--no-ground-detail") }
|
||||
# Meme survol par BEAU temps : separe le cout de la pluie (absente ici) de
|
||||
# celui des shaders modifies (brouillard nul, micro-relief hors portee).
|
||||
"survolbeau" { $common = @("--flythrough=900", "--day=12", "--hour=13", "--time-scale=0", "--lock-input")
|
||||
$A = @(); $B = @("--no-weather-visuals", "--no-ground-detail") }
|
||||
# Vue fixe sous la pluie : cout de la meteo visible (passe de pluie plein
|
||||
# ecran + brouillard + sol mouille).
|
||||
"pluie" { $common = $alpage + @("--look=-90,-8", "--day=8", "--hour=13")
|
||||
$A = @(); $B = @("--no-weather-visuals") }
|
||||
# Vue fixe au ras du sol : cout du micro-relief, la ou il couvre le plus
|
||||
# de pixels.
|
||||
"sol" { $common = $alpage + @("--look=-90,-50", "--day=12", "--hour=13")
|
||||
$A = @(); $B = @("--no-ground-detail") }
|
||||
# Vue de MARCHE (regard a l'horizon, -8 deg) : cout REALISTE du
|
||||
# micro-relief, qui n'y couvre que le bas de l'ecran.
|
||||
"marche" { $common = $alpage + @("--look=-90,-8", "--day=12", "--hour=13")
|
||||
$A = @(); $B = @("--no-ground-detail") }
|
||||
# Vue fixe par beau temps : la meteo visible doit y couter ~0 (pas de
|
||||
# pluie, pas de brouillard). Controle negatif de la mesure "pluie".
|
||||
"beau" { $common = $alpage + @("--look=-90,-8", "--day=12", "--hour=13")
|
||||
$A = @(); $B = @("--no-weather-visuals") }
|
||||
}
|
||||
|
||||
$cores = [Environment]::ProcessorCount
|
||||
|
||||
# Charge totale de la machine, en % de TOUS les coeurs (compteur formate de
|
||||
# Windows, deja moyenne sur l'intervalle d'echantillonnage).
|
||||
#
|
||||
# PREMIERE VERSION ABANDONNEE, et la raison vaut d'etre ecrite : elle sommait
|
||||
# TotalProcessorTime sur Get-Process au debut et a la fin du run. Un processus
|
||||
# NE pendant le run y entre avec toute sa vie, un processus qui refuse l'acces
|
||||
# au debut et l'accorde a la fin aussi : l'essai a rendu "318 910 % d'un
|
||||
# coeur". Un temoin de sante qui ment est pire que pas de temoin.
|
||||
function Get-TotalLoadPercent {
|
||||
return [double](Get-CimInstance Win32_PerfFormattedData_PerfOS_Processor -Filter "Name='_Total'").PercentProcessorTime
|
||||
}
|
||||
|
||||
function Invoke-Run([string]$label, [string[]]$extra) {
|
||||
$stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue
|
||||
if ($stale) { $stale | Stop-Process -Force; Start-Sleep -Milliseconds 800 }
|
||||
|
||||
$log = Join-Path (Split-Path -Parent $csv) ("run_{0}_{1}_{2}.log" -f $Scenario, $label, [DateTime]::Now.ToString("HHmmss"))
|
||||
$gameArgs = @("`"$scenePath`"") + $common + @($extra | Where-Object { $_ })
|
||||
$t0 = [DateTime]::Now
|
||||
$proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root `
|
||||
-RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) { throw "pas de fenetre ($label)" }
|
||||
# Sante machine : charge totale echantillonnee pendant le run, moins ce que
|
||||
# vercora lui-meme a consomme sur la meme fenetre de temps.
|
||||
$proc.Refresh()
|
||||
$gameCpu0 = $proc.TotalProcessorTime.TotalSeconds
|
||||
$s0 = [DateTime]::Now
|
||||
$loads = @()
|
||||
while (([DateTime]::Now - $s0).TotalSeconds -lt $Seconds) {
|
||||
Start-Sleep -Milliseconds 1500
|
||||
$loads += Get-TotalLoadPercent
|
||||
}
|
||||
$proc.Refresh()
|
||||
$sampleWall = ([DateTime]::Now - $s0).TotalSeconds
|
||||
$gameCorePct = 100.0 * ($proc.TotalProcessorTime.TotalSeconds - $gameCpu0) / $sampleWall
|
||||
$totalCorePct = ($loads | Measure-Object -Average).Average * $cores
|
||||
$others = [math]::Max(0.0, $totalCorePct - $gameCorePct) # en % d'UN coeur
|
||||
[void][W32M]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit() }
|
||||
|
||||
$text = Get-Content $log -Raw
|
||||
$cost = [regex]::Match($text, "Cout par image \(PHASE 19\) : (\d+) images - streaming terrain ([\d.]+) us, arbres ([\d.]+) us, herbe ([\d.]+) us, plantes a fibres ([\d.]+) us, tronc de vision ([\d.]+) us, drawFrame ([\d.]+) us, visuels meteo ([\d.]+) us")
|
||||
$cad = [regex]::Match($text, "Cadence de boucle \(PHASE 27\) : (\d+) images en ([\d.]+) s, soit ([\d.]+) images/s, ([\d.]+) us par image")
|
||||
$validation = ([regex]::Matches($text, "\[Validation\]")).Count
|
||||
if (-not $cost.Success -or -not $cad.Success) { throw "bilan absent du journal ($label) : $log" }
|
||||
|
||||
$fps = [double]$cad.Groups[3].Value
|
||||
$verdict = "OK"
|
||||
# Seuil : un coeur entier (100 %) sur les 20 de la machine. Un bureau vivant
|
||||
# (messagerie, navigateur integre, pilotes) tourne a 25-35 % d'un coeur au
|
||||
# repos sur ce poste - mesure au premier essai de ce script. Un seuil plus
|
||||
# bas rejetterait tous les runs sans rien proteger ; au-dela d'un coeur, une
|
||||
# vraie tache concurrente (compilation, indexation, un vercora orphelin)
|
||||
# est en cours et le run n'est pas comparable.
|
||||
if ($others -gt 100.0) { $verdict = "NON CONCLUANT (autres processus {0:N0} % d'un coeur)" -f $others }
|
||||
elseif ($fps -lt 20.0) { $verdict = "NON CONCLUANT (n'a pas pu rendre : {0:N1} img/s)" -f $fps }
|
||||
|
||||
$row = [pscustomobject]@{
|
||||
Config = $Config; Scenario = $Scenario; Condition = $label
|
||||
ImgParS = $fps; UsParImage = [double]$cad.Groups[4].Value
|
||||
Streaming = [double]$cost.Groups[2].Value; Arbres = [double]$cost.Groups[3].Value
|
||||
Herbe = [double]$cost.Groups[4].Value; Fibres = [double]$cost.Groups[5].Value
|
||||
Frustum = [double]$cost.Groups[6].Value; DrawFrame = [double]$cost.Groups[7].Value
|
||||
MeteoCpu = [double]$cost.Groups[8].Value
|
||||
AutresPctCoeur = [math]::Round($others, 1); Validation = $validation; Verdict = $verdict
|
||||
}
|
||||
$row | Export-Csv -Path $csv -Append -NoTypeInformation -Encoding UTF8
|
||||
Write-Host ("{0,-8} {1,-2} {2,7:N1} img/s {3,8:N1} us/img drawFrame {4,8:N1} herbe {5,6:N1} meteoCPU {6,5:N2} autres {7,5:N1}% valid {8} {9}" -f `
|
||||
$Scenario, $label, $fps, $row.UsParImage, $row.DrawFrame, $row.Herbe, $row.MeteoCpu, $others, $validation, $verdict)
|
||||
return $row
|
||||
}
|
||||
|
||||
Write-Host "=== $Scenario ($Config) : $Rounds tours A/B entrelaces, $Seconds s par run, $cores coeurs logiques ==="
|
||||
$rows = @()
|
||||
for ($r = 1; $r -le $Rounds; $r++) {
|
||||
$order = if ($r % 2 -eq 1) { @("A", "B") } else { @("B", "A") }
|
||||
foreach ($c in $order) {
|
||||
$extra = if ($c -eq "A") { $A } else { $B }
|
||||
$rows += Invoke-Run $c $extra
|
||||
}
|
||||
}
|
||||
|
||||
$ok = $rows | Where-Object { $_.Verdict -eq "OK" }
|
||||
$a = $ok | Where-Object { $_.Condition -eq "A" }
|
||||
$b = $ok | Where-Object { $_.Condition -eq "B" }
|
||||
function Med($xs) { $s = @($xs | Sort-Object); if ($s.Count -eq 0) { return [double]::NaN }; return $s[[int][math]::Floor(($s.Count - 1) / 2)] }
|
||||
if ($a.Count -gt 0 -and $b.Count -gt 0) {
|
||||
$usA = Med ($a | ForEach-Object { $_.UsParImage }); $usB = Med ($b | ForEach-Object { $_.UsParImage })
|
||||
$hA = Med ($a | ForEach-Object { $_.Herbe }); $hB = Med ($b | ForEach-Object { $_.Herbe })
|
||||
$temoin = if ($hB -gt 0) { [math]::Abs($hA - $hB) / $hB } else { 0 }
|
||||
Write-Host ("MEDIANES A {0:N1} us/img B {1:N1} us/img A-B = {2:N1} us/img ({3:+0.0;-0.0} %)" -f $usA, $usB, ($usA - $usB), (100 * ($usA - $usB) / $usB))
|
||||
Write-Host ("POSTE TEMOIN (herbe, CPU) A {0:N1} us B {1:N1} us ecart {2:N1} % -> {3}" -f $hA, $hB, (100 * $temoin), $(if ($temoin -gt 0.15) { "SUSPECT : la machine a change entre A et B" } else { "stable" }))
|
||||
} else {
|
||||
Write-Host "PAS DE CONCLUSION : pas assez de runs OK dans les deux conditions."
|
||||
}
|
||||
if (($rows | Measure-Object -Property Validation -Sum).Sum -gt 0) { Write-Host "[ECHEC] messages de validation Vulkan presents"; exit 3 }
|
||||
@@ -0,0 +1,103 @@
|
||||
# ===========================================================================
|
||||
# PHASE 29 (Agent 2) - cout des rochers : A = jeu normal, B = --no-rocks.
|
||||
# Derive de profile_phase27.ps1 (memes lecons : A/B ENTRELACES, sante machine),
|
||||
# avec deux differences :
|
||||
# - arret UNIQUEMENT par PID exact (WM_CLOSE puis Kill du PID lance) ; aucun
|
||||
# Stop-Process par nom, et refus de demarrer si un vercora tourne deja ;
|
||||
# - RAM : working set et pic de working set du processus, lus juste avant la
|
||||
# fermeture.
|
||||
# Usage : powershell -File tools\profile_phase29.ps1 -View alpage -Rounds 3
|
||||
# Vues : alpage (zone de reference de la Phase 27, 900500,6439000, regard -8)
|
||||
# pierrier (903452,6439601 : echantillon 4 de NOTES-PHASE29-DESIGN.md)
|
||||
# ===========================================================================
|
||||
param(
|
||||
[ValidateSet("alpage", "pierrier", "buissons")][string]$View = "alpage",
|
||||
# Agent 3 : option temoin de la condition B (--no-rocks par defaut, --no-bushes pour les buissons).
|
||||
[string]$Toggle = "--no-rocks",
|
||||
[int]$Rounds = 3,
|
||||
[int]$Seconds = 25,
|
||||
[string]$OutCsv = "build\phase29\profil.csv"
|
||||
)
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
$scenePath = Join-Path $root "assets\terrain\vercora_zone_1m.vchm"
|
||||
$csv = Join-Path $root $OutCsv
|
||||
New-Item -ItemType Directory -Force -Path (Split-Path -Parent $csv) | Out-Null
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32P29 {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
}
|
||||
"@
|
||||
$start = switch ($View) { "alpage" { "--start=900500,6439000" } "pierrier" { "--start=903452,6439601" } "buissons" { "--start=901160,6436275" } }
|
||||
$common = @($start, "--look=-90,-8", "--day=12", "--hour=13", "--time-scale=0", "--lock-input")
|
||||
$cores = [Environment]::ProcessorCount
|
||||
|
||||
function Invoke-Run([string]$label, [string[]]$extra) {
|
||||
if (Get-Process -Name "vercora" -ErrorAction SilentlyContinue) { throw "un vercora tourne deja : refus de mesurer" }
|
||||
$log = Join-Path (Split-Path -Parent $csv) ("run_{0}_{1}_{2}.log" -f $View, $label, [DateTime]::Now.ToString("HHmmss"))
|
||||
$gameArgs = @("`"$scenePath`"") + $common + @($extra | Where-Object { $_ })
|
||||
$proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root `
|
||||
-RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh(); if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) { throw "pas de fenetre ($label)" }
|
||||
$proc.Refresh(); $cpu0 = $proc.TotalProcessorTime.TotalSeconds; $s0 = [DateTime]::Now
|
||||
$loads = @()
|
||||
while (([DateTime]::Now - $s0).TotalSeconds -lt $Seconds) {
|
||||
Start-Sleep -Milliseconds 1500
|
||||
$loads += [double](Get-CimInstance Win32_PerfFormattedData_PerfOS_Processor -Filter "Name='_Total'").PercentProcessorTime
|
||||
}
|
||||
$proc.Refresh()
|
||||
$wall = ([DateTime]::Now - $s0).TotalSeconds
|
||||
$others = [math]::Max(0.0, ($loads | Measure-Object -Average).Average * $cores - 100.0 * ($proc.TotalProcessorTime.TotalSeconds - $cpu0) / $wall)
|
||||
$wsMb = $proc.WorkingSet64 / 1MB; $peakMb = $proc.PeakWorkingSet64 / 1MB; $privMb = $proc.PrivateMemorySize64 / 1MB
|
||||
[void][W32P29]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) { Stop-Process -Id $proc.Id -Force; $proc.WaitForExit() }
|
||||
$text = Get-Content $log -Raw
|
||||
$cad = [regex]::Match($text, "Cadence de boucle \(PHASE 27\) : (\d+) images en ([\d.]+) s, soit ([\d.]+) images/s, ([\d.]+) us par image")
|
||||
$rk = [regex]::Match($text, "semis ([\d.]+) us par image ; derniere image (\d+) gros blocs, (\d+) rochers, (\d+) plaques")
|
||||
$bu = [regex]::Match($text, "Buissons \(PHASE 29\) : semis ([\d.]+) us par image ; derniere image (\d+) buissons, (\d+) petits arbres")
|
||||
$validation = ([regex]::Matches($text, "\[Validation\]")).Count
|
||||
if (-not $cad.Success) { throw "bilan absent ($label) : $log" }
|
||||
$fps = [double]$cad.Groups[3].Value
|
||||
$verdict = if ($others -gt 100.0) { "NON CONCLUANT (autres {0:N0} %)" -f $others } else { "OK" }
|
||||
$row = [pscustomobject]@{
|
||||
View = $View; Condition = $label; ImgParS = $fps; UsParImage = [double]$cad.Groups[4].Value
|
||||
RochersUs = $(if ($rk.Success) { [double]$rk.Groups[1].Value } else { 0 })
|
||||
Blocs = $(if ($rk.Success) { [int]$rk.Groups[2].Value } else { 0 })
|
||||
Rochers = $(if ($rk.Success) { [int]$rk.Groups[3].Value } else { 0 })
|
||||
Plaques = $(if ($rk.Success) { [int]$rk.Groups[4].Value } else { 0 })
|
||||
WsMo = [math]::Round($wsMb, 1); PicMo = [math]::Round($peakMb, 1); PriveMo = [math]::Round($privMb, 1)
|
||||
BuissonsUs = $(if ($bu.Success) { [double]$bu.Groups[1].Value } else { 0 })
|
||||
Buissons = $(if ($bu.Success) { [int]$bu.Groups[2].Value } else { 0 })
|
||||
PetitsArbres = $(if ($bu.Success) { [int]$bu.Groups[3].Value } else { 0 })
|
||||
AutresPctCoeur = [math]::Round($others, 1); Validation = $validation; Verdict = $verdict
|
||||
}
|
||||
$row | Export-Csv -Path $csv -Append -NoTypeInformation -Encoding UTF8
|
||||
if ($bu.Success) { Write-Host (" buissons {0:N1} us, {1} buissons, {2} petits arbres" -f $row.BuissonsUs, $row.Buissons, $row.PetitsArbres) }
|
||||
Write-Host ("{0,-8} {1} {2,7:N1} img/s {3,8:N1} us/img rochers {4,6:N1} us ({5}/{6}/{7}) WS {8:N0} Mo pic {9:N0} autres {10:N0}% valid {11} {12}" -f `
|
||||
$View, $label, $fps, $row.UsParImage, $row.RochersUs, $row.Blocs, $row.Rochers, $row.Plaques, $wsMb, $peakMb, $others, $validation, $verdict)
|
||||
return $row
|
||||
}
|
||||
|
||||
$rows = @()
|
||||
for ($r = 1; $r -le $Rounds; $r++) {
|
||||
$order = if ($r % 2 -eq 1) { @("A", "B") } else { @("B", "A") }
|
||||
foreach ($c in $order) { $rows += Invoke-Run $c $(if ($c -eq "A") { @() } else { @($Toggle) }) }
|
||||
}
|
||||
function Med($xs) { $s = @($xs | Sort-Object); if ($s.Count -eq 0) { return [double]::NaN }; return $s[[int][math]::Floor(($s.Count - 1) / 2)] }
|
||||
$ok = $rows | Where-Object { $_.Verdict -eq "OK" }
|
||||
foreach ($c in "A", "B") {
|
||||
$x = $ok | Where-Object { $_.Condition -eq $c }
|
||||
Write-Host ("MEDIANE {0} : {1:N1} img/s, {2:N1} us/img, WS {3:N0} Mo, pic {4:N0} Mo (min/max img/s {5:N1}/{6:N1})" -f $c,
|
||||
(Med ($x | % { $_.ImgParS })), (Med ($x | % { $_.UsParImage })), (Med ($x | % { $_.WsMo })), (Med ($x | % { $_.PicMo })),
|
||||
(($x | Measure-Object ImgParS -Minimum).Minimum), (($x | Measure-Object ImgParS -Maximum).Maximum))
|
||||
}
|
||||
if (($rows | Measure-Object -Property Validation -Sum).Sum -gt 0) { Write-Host "[ECHEC] messages de validation Vulkan"; exit 3 }
|
||||
@@ -0,0 +1,124 @@
|
||||
# profile_tiles.ps1 - releve le PROFIL DE CONSTRUCTION DES TUILES sur un survol.
|
||||
#
|
||||
# PHASE 19. La Phase 18 a montre que le chronometrage cumule de
|
||||
# TerrainStreamer::buildProfile() est BEAUCOUP plus stable que le FPS lu dans le
|
||||
# titre de la fenetre (moins de 0,5 % d'ecart entre deux passages, contre ~15 %
|
||||
# pour le FPS - voir MEMORY.md). C'est donc lui, et non le FPS, qui doit servir a
|
||||
# juger une optimisation du chemin de streaming.
|
||||
#
|
||||
# La Phase 18 relevait ces lignes a la main dans la sortie du jeu. Ce script les
|
||||
# extrait, ce qui rend le releve reproductible et comparable d'une phase a
|
||||
# l'autre - exactement ce que measure_terrain.ps1 a fait pour le FPS en Phase 9.
|
||||
#
|
||||
# Usage :
|
||||
# powershell -File tools\profile_tiles.ps1 -Scene terrain -Seconds 45 `
|
||||
# -GameArgs @('--flythrough=900','--no-grass')
|
||||
#
|
||||
# Le jeu est ferme par WM_CLOSE, ce qui est indispensable : le bilan est
|
||||
# journalise A LA DESTRUCTION du TerrainStreamer. Un processus tue n'ecrit rien.
|
||||
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][string]$Scene,
|
||||
[int]$Seconds = 45,
|
||||
[string[]]$GameArgs = @(),
|
||||
# Repetitions du meme run. La Phase 18 en faisait deux systematiquement pour
|
||||
# pouvoir affirmer la stabilite du chiffre plutot que de la supposer.
|
||||
[int]$Runs = 1
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" }
|
||||
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32P {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
}
|
||||
"@
|
||||
$WM_CLOSE = 0x0010
|
||||
|
||||
for ($run = 1; $run -le $Runs; $run++) {
|
||||
Write-Host ("=== Profil tuiles : {0} {1}(passage {2}/{3}) ===" -f `
|
||||
$Scene, $(if ($GameArgs.Count) { ($GameArgs -join ' ') + ' ' } else { '' }), $run, $Runs)
|
||||
|
||||
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
||||
$psi.FileName = $exe
|
||||
$psi.Arguments = (@('"' + $Scene + '"') + $GameArgs) -join ' '
|
||||
$psi.WorkingDirectory = $root
|
||||
$psi.UseShellExecute = $false
|
||||
$psi.RedirectStandardOutput = $true
|
||||
$psi.RedirectStandardError = $true
|
||||
|
||||
$proc = [System.Diagnostics.Process]::Start($psi)
|
||||
$outSb = New-Object System.Text.StringBuilder
|
||||
$handlers = @(
|
||||
(Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $outSb),
|
||||
(Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $outSb)
|
||||
)
|
||||
$proc.BeginOutputReadLine()
|
||||
$proc.BeginErrorReadLine()
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 600 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) {
|
||||
$proc.WaitForExit()
|
||||
Start-Sleep -Milliseconds 300
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
Write-Host $outSb.ToString()
|
||||
Write-Host "[ECHEC] Pas de fenetre."
|
||||
exit 1
|
||||
}
|
||||
|
||||
Start-Sleep -Seconds $Seconds
|
||||
|
||||
$proc.Refresh()
|
||||
$peakMb = [math]::Round($proc.PeakWorkingSet64 / 1MB, 1)
|
||||
[void][W32P]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(60000)) {
|
||||
Write-Host "[ECHEC] Pas de sortie 60 s apres WM_CLOSE."
|
||||
$proc.Kill(); $proc.WaitForExit()
|
||||
$code = 1
|
||||
} else {
|
||||
$code = $proc.ExitCode
|
||||
}
|
||||
Start-Sleep -Milliseconds 400
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
|
||||
$text = $outSb.ToString()
|
||||
$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' })
|
||||
|
||||
# Une meme ligne peut satisfaire plusieurs motifs (le bilan de construction
|
||||
# porte aussi le bilan de parallelisme) : on deduplique, sinon le releve
|
||||
# affiche deux fois le meme chiffre, ce qui invite a le lire deux fois.
|
||||
$shown = @{}
|
||||
foreach ($pattern in @('Construction de tuiles',
|
||||
'Trous de streaming',
|
||||
'Streaming terrain : pics',
|
||||
'Cout par image')) {
|
||||
foreach ($l in ($lines | Where-Object { $_ -match $pattern })) {
|
||||
if (-not $shown.ContainsKey($l)) { $shown[$l] = $true; Write-Host " | $l" }
|
||||
}
|
||||
}
|
||||
|
||||
$validation = @($lines | Where-Object { $_ -match '\[Validation\]' })
|
||||
$errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' })
|
||||
Write-Host (" validation Vulkan : {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f `
|
||||
$validation.Count, $errors.Count)
|
||||
foreach ($l in ($validation + $errors) | Select-Object -First 12) { Write-Host " $l" }
|
||||
Write-Host (" pic memoire : {0} Mo, code de sortie : {1}" -f $peakMb, $code)
|
||||
|
||||
if ($validation.Count -gt 0 -or $code -ne 0) { exit 1 }
|
||||
}
|
||||
exit 0
|
||||
@@ -0,0 +1,215 @@
|
||||
@echo off
|
||||
rem ===========================================================================
|
||||
rem Harnais de tests HEADLESS de la logique de jeu (aucun GPU, aucun Vulkan).
|
||||
rem ===========================================================================
|
||||
rem Pourquoi ce script existe alors que le projet a deja un CMakeLists :
|
||||
rem find_package(Vulkan REQUIRED) fait echouer la CONFIGURATION du projet
|
||||
rem entier quand le SDK Vulkan n'est pas installe sur la machine. Or toute la
|
||||
rem logique de jeu (src/world, src/assets, src/core hors Window) ne depend que
|
||||
rem de GLM. Ce script la compile donc seule, directement avec cl.exe, ce qui
|
||||
rem permet de tester le gameplay meme sans SDK ni carte graphique.
|
||||
rem
|
||||
rem Ce n'est PAS un substitut au build normal : il ne verifie ni le rendu, ni les
|
||||
rem couches de validation Vulkan. Le build de reference reste CMake + cmake
|
||||
rem --build sur le CMakeLists de la racine.
|
||||
rem
|
||||
rem Usage : tools\run_logic_tests.bat
|
||||
rem Sortie : build-tests\logic_tests.exe (code de retour 0 = tout passe)
|
||||
rem ===========================================================================
|
||||
|
||||
setlocal
|
||||
|
||||
rem --- Environnement compilateur ---------------------------------------------
|
||||
rem VS 18 Community. Adapter ce chemin si l'edition installee change ; le script
|
||||
rem echoue clairement plutot que de compiler avec un compilateur inattendu.
|
||||
set "VCVARS=C:\Program Files\Microsoft Visual Studio\18\Community\VC\Auxiliary\Build\vcvars64.bat"
|
||||
if not exist "%VCVARS%" (
|
||||
echo [ERREUR] vcvars64.bat introuvable : "%VCVARS%"
|
||||
echo Adapter VCVARS dans tools\run_logic_tests.bat.
|
||||
exit /b 1
|
||||
)
|
||||
call "%VCVARS%" >nul 2>&1
|
||||
|
||||
rem --- Racine du projet (le script vit dans tools\) ---------------------------
|
||||
set "ROOT=%~dp0.."
|
||||
pushd "%ROOT%"
|
||||
|
||||
rem GLM est deja en cache dans external\ (recupere par FetchContent lors d'un
|
||||
rem build CMake anterieur) : aucun telechargement n'est necessaire ici.
|
||||
set "GLM_DIR=%ROOT%\external\glm-src"
|
||||
if not exist "%GLM_DIR%\glm\glm.hpp" (
|
||||
echo [ERREUR] GLM introuvable dans "%GLM_DIR%".
|
||||
echo Lancer une fois le build CMake complet pour peupler external\.
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
rem GLFW aussi est deja en cache : ses headers permettent de compiler Window.hpp,
|
||||
rem donc core/Camera.cpp, ou vit la resolution des collisions.
|
||||
set "GLFW_DIR=%ROOT%\external\glfw-src\include"
|
||||
if not exist "%GLFW_DIR%\GLFW\glfw3.h" (
|
||||
echo [ERREUR] GLFW introuvable dans "%GLFW_DIR%".
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
rem Vulkan SDK : necessaire uniquement aux verifications de syntaxe ci-dessous
|
||||
rem (Camera.cpp et main.cpp incluent des en-tetes Vulkan). Jusqu'au 2026-08-15 un
|
||||
rem shim maison sous tests\shim\ remplacait ces declarations, faute de SDK
|
||||
rem installe ; le SDK etant de retour, on utilise les VRAIS en-tetes et le shim a
|
||||
rem ete supprime. Les tests d'execution, eux, n'ont jamais eu besoin de Vulkan.
|
||||
if not defined VULKAN_SDK (
|
||||
for /f "tokens=2,*" %%A in ('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v VULKAN_SDK 2^>nul ^| find "VULKAN_SDK"') do set "VULKAN_SDK=%%B"
|
||||
)
|
||||
if not exist "%VULKAN_SDK%\Include\vulkan\vulkan.h" (
|
||||
echo [ERREUR] SDK Vulkan introuvable ^(VULKAN_SDK="%VULKAN_SDK%"^).
|
||||
echo winget install --id KhronosGroup.VulkanSDK
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
if not exist "build-tests" mkdir "build-tests"
|
||||
|
||||
rem --- Etape 1 : verification de SYNTAXE -------------------------------------
|
||||
rem Trois unites qui ne peuvent pas entrer dans l'executable de test mais dont on
|
||||
rem veut au moins garantir qu'elles compilent (/Zs = syntaxe seule, aucun code
|
||||
rem genere) :
|
||||
rem - Camera.cpp heberge la resolution des collisions, mais inclut Window.hpp
|
||||
rem donc GLFW donc <vulkan/vulkan.h>.
|
||||
rem - ObjLoader.cpp ne depend plus de Vulkan depuis que le format de sommet a
|
||||
rem ete sorti de Vertex.hpp (voir VertexFormat.hpp). Le verifier ici est ce
|
||||
rem qui empeche cette separation de se redegrader sans qu'on s'en apercoive.
|
||||
rem - main.cpp est le point ou tout le gameplay est cable au Renderer : c'est
|
||||
rem le fichier le plus expose a une faute de frappe, et le seul qu'aucun test
|
||||
rem d'execution ne couvre.
|
||||
rem
|
||||
rem TerrainStreamer.cpp (Phase 10) est verifie en SYNTAXE seulement : il pilote le
|
||||
rem Renderer, donc Vulkan. Le quadtree lui-meme (TerrainQuadtree.cpp) et le
|
||||
rem maillage par tuile (TerrainNodeMesh.cpp), eux, ne dependent que de GLM et sont
|
||||
rem compiles ET executes dans les tests ci-dessous - c'est la meme separation qui
|
||||
rem avait permis de tester la Phase 7 sans GPU.
|
||||
rem
|
||||
rem TerrainMesh.cpp etait ici jusqu'a la Phase 7 ; il est desormais COMPILE ET
|
||||
rem LIE dans l'executable de test, ou les tests de heightmap l'exercent
|
||||
rem reellement. Une verification de syntaxe serait redondante et plus faible.
|
||||
echo [1/2] Verification de syntaxe
|
||||
cl /nologo /std:c++20 /EHsc /W4 /Zs ^
|
||||
/DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^
|
||||
/I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^
|
||||
"src\core\Camera.cpp"
|
||||
if errorlevel 1 goto :syntax_failed
|
||||
|
||||
rem PHASE 15 : ObjLoader.cpp etait ici en verification de SYNTAXE seulement. Il
|
||||
rem est desormais COMPILE ET LIE dans l'executable de test, parce que
|
||||
rem editor\AssetCatalog.cpp l'appelle pour charger les modeles du dossier
|
||||
rem d'assets - et que le scan du catalogue est justement l'une des choses que ces
|
||||
rem tests exercent. Une verification de syntaxe serait redondante et plus faible,
|
||||
rem exactement comme pour TerrainMesh.cpp depuis la Phase 7.
|
||||
|
||||
rem SHADERS_OUTPUT_DIR et ASSETS_DIR sont normalement fournis par CMake. Des
|
||||
rem valeurs bidon suffisent : on ne verifie ici que la syntaxe, aucun chemin
|
||||
rem n'est ouvert.
|
||||
cl /nologo /std:c++20 /EHsc /W4 /Zs ^
|
||||
/DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^
|
||||
/I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^
|
||||
"src\renderer\TerrainStreamer.cpp"
|
||||
if errorlevel 1 goto :syntax_failed
|
||||
|
||||
rem PHASE 11 : Texture.cpp cree des images Vulkan, donc verification de
|
||||
rem SYNTAXE seulement, comme TerrainStreamer.cpp juste au-dessus. Le CHARGEUR
|
||||
rem du format (TextureFile.cpp), lui, ne depend que de la bibliotheque
|
||||
rem standard : il est compile ET EXECUTE dans les tests plus bas.
|
||||
cl /nologo /std:c++20 /EHsc /W4 /Zs ^
|
||||
/DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^
|
||||
/I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%VULKAN_SDK%\Include" ^
|
||||
"src\renderer\Texture.cpp"
|
||||
if errorlevel 1 goto :syntax_failed
|
||||
|
||||
cl /nologo /std:c++20 /EHsc /W4 /Zs ^
|
||||
/DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE /DGLFW_INCLUDE_VULKAN ^
|
||||
/DSHADERS_OUTPUT_DIR=\"shim\" /DASSETS_DIR=\"shim\" ^
|
||||
/I "src" /I "%GLM_DIR%" /I "%GLFW_DIR%" /I "%ROOT%\external\tinyobjloader-src" ^
|
||||
/I "%VULKAN_SDK%\Include" ^
|
||||
"src\main.cpp"
|
||||
if errorlevel 1 goto :syntax_failed
|
||||
|
||||
goto :syntax_ok
|
||||
|
||||
:syntax_failed
|
||||
echo.
|
||||
echo [ECHEC] Verification de syntaxe.
|
||||
popd
|
||||
exit /b 1
|
||||
|
||||
:syntax_ok
|
||||
|
||||
rem --- Etape 2 : compilation et execution des tests ---------------------------
|
||||
echo [2/2] Compilation et execution des tests
|
||||
rem /W4 : on veut voir les avertissements sur du code neuf.
|
||||
rem GLM_FORCE_* : memes definitions que la cible vercora, pour que la logique
|
||||
rem testee soit bit a bit celle qui tournera dans le jeu.
|
||||
rem ASSETS_DIR : meme definition que la cible CMake, pour que les tests puissent
|
||||
rem retrouver la dalle LiDAR reelle si elle a ete produite. Son absence n'est pas
|
||||
rem une erreur - le bloc de tests correspondant s'ignore de lui-meme.
|
||||
cl /nologo /std:c++20 /EHsc /W4 /Zi ^
|
||||
/DGLM_FORCE_RADIANS /DGLM_FORCE_DEPTH_ZERO_TO_ONE ^
|
||||
/DASSETS_DIR="\"%ROOT:\=/%/assets\"" ^
|
||||
/I "src" /I "%GLM_DIR%" /I "%ROOT%\external\tinyobjloader-src" ^
|
||||
/Fo"build-tests\\" /Fd"build-tests\logic_tests.pdb" /Fe"build-tests\logic_tests.exe" ^
|
||||
"tests\logic_tests.cpp" ^
|
||||
"src\assets\Heightmap.cpp" ^
|
||||
"src\assets\TerrainFile.cpp" ^
|
||||
"src\renderer\TerrainMesh.cpp" ^
|
||||
"src\world\TreeMesh.cpp" ^
|
||||
"src\world\StoneMesh.cpp" ^
|
||||
"src\world\Tree.cpp" ^
|
||||
"src\world\Ground.cpp" ^
|
||||
"src\world\Knapping.cpp" ^
|
||||
"src\world\Crafting.cpp" ^
|
||||
"src\world\CraftMesh.cpp" ^
|
||||
"src\world\Forest.cpp" ^
|
||||
"src\world\Habitat.cpp" ^
|
||||
"src\world\Wildlife.cpp" ^
|
||||
"src\world\AnimalMesh.cpp" ^
|
||||
"src\world\Paraglider.cpp" ^
|
||||
"src\world\Bike.cpp" ^
|
||||
"src\world\Climber.cpp" ^
|
||||
"src\world\Needs.cpp" ^
|
||||
"src\world\Weather.cpp" ^
|
||||
"src\world\WaterSource.cpp" ^
|
||||
"src\world\Deposits.cpp" ^
|
||||
"src\world\Resin.cpp" ^
|
||||
"src\world\TreeSpecies.cpp" ^
|
||||
"src\world\FiberPlants.cpp" ^
|
||||
"src\world\Rocks.cpp" ^
|
||||
"src\world\RockMesh.cpp" ^
|
||||
"src\world\Bushes.cpp" ^
|
||||
"src\world\BushMesh.cpp" ^
|
||||
"src\world\HarvestMesh.cpp" ^
|
||||
"src\world\TerrainQuadtree.cpp" ^
|
||||
"src\world\Vegetation.cpp" ^
|
||||
"src\world\GrassMesh.cpp" ^
|
||||
"src\assets\TextureFile.cpp" ^
|
||||
"src\assets\DetailNoise.cpp" ^
|
||||
"src\renderer\TerrainNodeMesh.cpp" ^
|
||||
"src\assets\ObjLoader.cpp" ^
|
||||
"src\editor\EditorAssets.cpp" ^
|
||||
"src\editor\AssetCatalog.cpp" ^
|
||||
"src\editor\EditorScene.cpp" ^
|
||||
"src\editor\EditorController.cpp" ^
|
||||
"src\editor\SceneFile.cpp"
|
||||
|
||||
if errorlevel 1 (
|
||||
echo.
|
||||
echo [ECHEC] Compilation des tests.
|
||||
popd
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo.
|
||||
"build-tests\logic_tests.exe"
|
||||
set "RC=%ERRORLEVEL%"
|
||||
popd
|
||||
exit /b %RC%
|
||||
|
||||
|
||||
Diff désactivé car ce fichier est trop long.
Voir la Diff
@@ -0,0 +1,114 @@
|
||||
# screenshot_scene.ps1 - lance une scene, capture la fenetre, ferme proprement.
|
||||
#
|
||||
# PHASE 10. Raison d'etre : un bug de frustum culling ou de selection de LOD se
|
||||
# traduit par un EXCELLENT chiffre de FPS - on ne dessine plus rien. Les mesures
|
||||
# de measure_terrain.ps1 ne peuvent donc pas, a elles seules, valider le systeme
|
||||
# de tuiles ; il faut regarder l'image. Ce script produit ce regard sans voler la
|
||||
# souris ni le clavier de l'utilisateur.
|
||||
#
|
||||
# powershell -File tools\screenshot_scene.ps1 -Scene assets\terrain\vercora_zone_1m.vchm -Out build\zone.png
|
||||
# powershell -File tools\screenshot_scene.ps1 -Scene terrain -GameArgs --no-lod -Out build\ref.png
|
||||
#
|
||||
# La capture passe par PrintWindow avec PW_RENDERFULLCONTENT (drapeau 2) : sans
|
||||
# lui, une fenetre rendue par le GPU (Vulkan, DirectX) ressort NOIRE, la fenetre
|
||||
# ne possedant pas de contenu GDI a recopier.
|
||||
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][string]$Scene,
|
||||
[Parameter(Mandatory = $true)][string]$Out,
|
||||
[string[]]$GameArgs = @(),
|
||||
# Secondes d'attente avant la capture : le temps que la scene charge et que
|
||||
# le streaming ait servi les premieres tuiles.
|
||||
[int]$SettleSeconds = 6,
|
||||
# PHASE 11. Par defaut le jeu est lance avec --lock-input : la camera ignore
|
||||
# alors le clavier et la souris SYSTEME.
|
||||
#
|
||||
# Sans ce verrou, deux executions du MEME script ne cadrent pas la meme
|
||||
# chose : GLFW lit le vrai curseur (il ne voit pas les messages postes, cf.
|
||||
# l'en-tete de run_vulkan_check.ps1), donc toute manipulation de la machine
|
||||
# pendant la pose reoriente la camera. Constate directement : deux
|
||||
# executions consecutives ont donne yaw -90 et yaw -50, soit deux images qui
|
||||
# different sur 65 % de leurs pixels - ce qui prive de toute valeur une
|
||||
# comparaison avant/apres.
|
||||
#
|
||||
# -FreeInput redonne la main a l'utilisateur, pour une capture pilotee.
|
||||
[switch]$FreeInput
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" }
|
||||
|
||||
Add-Type -AssemblyName System.Drawing
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32S {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
[DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags);
|
||||
[DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r);
|
||||
[StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; }
|
||||
}
|
||||
"@
|
||||
$WM_CLOSE = 0x0010
|
||||
$PW_RENDERFULLCONTENT = 2
|
||||
|
||||
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
||||
$psi.FileName = $exe
|
||||
$lockArgs = if ($FreeInput) { @() } else { @('--lock-input') }
|
||||
$psi.Arguments = (@('"' + $Scene + '"') + $GameArgs + $lockArgs) -join ' '
|
||||
$psi.WorkingDirectory = $root
|
||||
$psi.UseShellExecute = $false
|
||||
|
||||
$proc = [System.Diagnostics.Process]::Start($psi)
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) {
|
||||
Write-Host "[ECHEC] Pas de fenetre."
|
||||
if (-not $proc.HasExited) { $proc.Kill() }
|
||||
exit 1
|
||||
}
|
||||
|
||||
Start-Sleep -Seconds $SettleSeconds
|
||||
|
||||
$rect = New-Object W32S+RECT
|
||||
[void][W32S]::GetClientRect($hwnd, [ref]$rect)
|
||||
$w = $rect.R - $rect.L
|
||||
$h = $rect.B - $rect.T
|
||||
|
||||
$bmp = New-Object System.Drawing.Bitmap $w, $h
|
||||
$gfx = [System.Drawing.Graphics]::FromImage($bmp)
|
||||
$dc = $gfx.GetHdc()
|
||||
[void][W32S]::PrintWindow($hwnd, $dc, $PW_RENDERFULLCONTENT)
|
||||
$gfx.ReleaseHdc($dc)
|
||||
$gfx.Dispose()
|
||||
|
||||
$outPath = if ([System.IO.Path]::IsPathRooted($Out)) { $Out } else { Join-Path $root $Out }
|
||||
New-Item -ItemType Directory -Force -Path (Split-Path -Parent $outPath) | Out-Null
|
||||
$bmp.Save($outPath, [System.Drawing.Imaging.ImageFormat]::Png)
|
||||
|
||||
# Proportion de pixels "ciel" : un terrain qui aurait disparu (culling casse,
|
||||
# tuiles jamais construites) donnerait une image quasi entierement de la couleur
|
||||
# d'effacement. C'est un controle grossier mais automatique, qui complete l'oeil.
|
||||
$sky = 0
|
||||
for ($y = 0; $y -lt $h; $y += 8) {
|
||||
for ($x = 0; $x -lt $w; $x += 8) {
|
||||
$p = $bmp.GetPixel($x, $y)
|
||||
if ($p.B -gt $p.G -and $p.B -gt 150) { $sky++ }
|
||||
}
|
||||
}
|
||||
$total = [math]::Ceiling($h / 8) * [math]::Ceiling($w / 8)
|
||||
$bmp.Dispose()
|
||||
|
||||
Write-Host ("CAPTURE {0} ({1}x{2}), ciel estime {3:N1} %" -f $outPath, $w, $h, (100.0 * $sky / $total))
|
||||
|
||||
[void][W32S]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit(); exit 1 }
|
||||
exit $proc.ExitCode
|
||||
@@ -0,0 +1,108 @@
|
||||
# ===========================================================================
|
||||
# PHASE 23 - Captures du cycle jour/nuit et du contraste adret/ubac.
|
||||
# ===========================================================================
|
||||
# Produit une SERIE d'images de la MEME vue a des heures de jeu differentes.
|
||||
# C'est la verification visuelle du cycle : la direction et l'intensite de la
|
||||
# lumiere doivent suivre l'heure, et rien d'autre ne doit bouger.
|
||||
#
|
||||
# CE QUI REND CES CAPTURES COMPARABLES, et c'est tout l'interet du script :
|
||||
#
|
||||
# --lock-input (pose par screenshot_scene.ps1) fige la camera. Sans lui,
|
||||
# deux executions du meme script cadrent deux choses
|
||||
# differentes - constate en Phase 11, 65 % des pixels.
|
||||
# --look= epingle le cadrage. --lock-input SEUL NE SUFFIT PAS : trois
|
||||
# captures de la meme scene ont donne 38,2 / 38,3 / 32,9 % de
|
||||
# ciel, donc trois vues. Lecon de la Phase 12.
|
||||
# --start= epingle la position.
|
||||
# --hour= epingle l'instant de jeu (Phase 23).
|
||||
# --time-scale=0 GELE l'horloge, pour que les secondes de mise en place de la
|
||||
# capture ne deplacent pas le soleil. C'est le pendant exact
|
||||
# de --lock-input pour le TEMPS, et sans lui le cycle
|
||||
# jour/nuit rendait toute capture non reproductible.
|
||||
#
|
||||
# Le systeme meteo est deterministe a seed fixe (voir world/Weather.hpp), donc
|
||||
# deux executions de ce script a la meme heure doivent rendre la MEME image, au
|
||||
# bruit de rasterisation pres.
|
||||
#
|
||||
# Usage :
|
||||
# powershell -File tools\shot_daynight.ps1
|
||||
# powershell -File tools\shot_daynight.ps1 -Hours 6,12,18,22 -OutDir build\cycle
|
||||
# ===========================================================================
|
||||
|
||||
param(
|
||||
# Heures de jeu a capturer. Par defaut : nuit, aube, matin, midi, soir,
|
||||
# crepuscule - les six moments ou la lumiere est franchement differente.
|
||||
[double[]]$Hours = @(3, 6.5, 9, 13, 18, 21),
|
||||
|
||||
[string]$OutDir = "build\daynight",
|
||||
|
||||
# Vue de reference. Position et cadrage EPINGLES, voir l'en-tete.
|
||||
# Par defaut : l'alpage de la Phase 18 (E 900500 / N 6439000), qui est la
|
||||
# seule vue du projet dont on sache ce qu'elle contient (124 touffes
|
||||
# d'herbe comptees), donc la seule ou une difference se lise.
|
||||
[string]$Start = "900500,6439000",
|
||||
[string]$Look = "-90,-8",
|
||||
|
||||
[string]$Scene = "assets\terrain\vercora_zone_1m.vchm",
|
||||
|
||||
[int]$SettleSeconds = 8
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$shot = Join-Path $PSScriptRoot "screenshot_scene.ps1"
|
||||
$scenePath = Join-Path $root $Scene
|
||||
|
||||
if (-not (Test-Path $scenePath)) {
|
||||
Write-Host "[ERREUR] Scene introuvable : $scenePath"
|
||||
Write-Host " Produire la zone assemblee, ou passer -Scene."
|
||||
exit 1
|
||||
}
|
||||
|
||||
$outRoot = Join-Path $root $OutDir
|
||||
New-Item -ItemType Directory -Force -Path $outRoot | Out-Null
|
||||
|
||||
# Un vercora.exe orphelin fabrique de faux plantages ET de faux ralentissements
|
||||
# (lecon de la Phase 19). On nettoie avant, pas apres.
|
||||
$stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue
|
||||
if ($stale) {
|
||||
Write-Host "[ATTENTION] $($stale.Count) vercora.exe orphelin(s) : arret avant capture."
|
||||
$stale | Stop-Process -Force
|
||||
Start-Sleep -Milliseconds 500
|
||||
}
|
||||
|
||||
Write-Host ""
|
||||
Write-Host "Cycle jour/nuit : $($Hours.Count) captures de la meme vue"
|
||||
Write-Host " position $Start, cadrage $Look, horloge GELEE"
|
||||
Write-Host ""
|
||||
|
||||
foreach ($hour in $Hours) {
|
||||
# Nom de fichier trie a l'oeil ET par le systeme : "h06.5" plutot que "6.5".
|
||||
$label = ("h{0:00.0}" -f $hour).Replace(",", ".")
|
||||
$out = Join-Path $outRoot "$label.png"
|
||||
|
||||
Write-Host "--- $label ---"
|
||||
# Appel EN PROCESSUS (& $shot) et non `powershell -File $shot`. La raison
|
||||
# n'est pas cosmetique : `-File` aplatit les arguments en ligne de commande,
|
||||
# et PowerShell relit alors "--look=-90,-8" comme un NOM DE PARAMETRE a cause
|
||||
# de son tiret initial. En processus, le tableau reste un tableau et chaque
|
||||
# element reste une chaine.
|
||||
& $shot `
|
||||
-Scene $scenePath `
|
||||
-Out $out `
|
||||
-SettleSeconds $SettleSeconds `
|
||||
-GameArgs @("--start=$Start", "--look=$Look",
|
||||
("--hour={0}" -f $hour.ToString([System.Globalization.CultureInfo]::InvariantCulture)),
|
||||
"--time-scale=0")
|
||||
|
||||
if (-not (Test-Path $out)) {
|
||||
Write-Host "[ECHEC] pas d'image produite pour $label"
|
||||
exit 1
|
||||
}
|
||||
}
|
||||
|
||||
Write-Host ""
|
||||
Write-Host "[OK] $($Hours.Count) captures dans $outRoot"
|
||||
Write-Host " Les comparer a l'oeil : seule la LUMIERE doit changer d'une"
|
||||
Write-Host " image a l'autre. Un relief, une vegetation ou un cadrage qui"
|
||||
Write-Host " bougent signalent une capture non epinglee, pas un cycle."
|
||||
@@ -0,0 +1,168 @@
|
||||
# ===========================================================================
|
||||
# shot_editor.ps1 - capture d'ecran du MODE EDITEUR (Phase 15).
|
||||
# ===========================================================================
|
||||
# Pourquoi ce script existe a cote de screenshot_scene.ps1 : l'editeur a trois
|
||||
# etats VISUELS qu'aucune autre trace ne peut prouver.
|
||||
#
|
||||
# * l'objet POSE, rendu comme n'importe quel objet du monde ;
|
||||
# * le FANTOME, teinte en cyan, qui suit la visee et n'est pas encore pose ;
|
||||
# * l'objet SELECTIONNE, teinte en ambre.
|
||||
#
|
||||
# Les trois passent par le MEME mesh et le meme pipeline : seule la teinte de
|
||||
# temoin poussee en push constant les distingue (voir shaders/cube.frag). Un
|
||||
# journal ne peut donc pas dire si elle s'applique - il faut regarder l'image.
|
||||
# C'est la meme raison qui avait motive screenshot_scene.ps1 en Phase 10 : un
|
||||
# culling casse produit d'excellents FPS, et seule une capture le montre.
|
||||
#
|
||||
# screenshot_scene.ps1 ne suffit pas parce qu'il ne PILOTE rien : il lance,
|
||||
# attend, capture. Or selectionner un objet demande d'appuyer sur une touche.
|
||||
#
|
||||
# Comme partout dans ce projet, les touches sont envoyees par PostMessage avec
|
||||
# leur SCANCODE (jeu de codes 1) et non leur code virtuel : MapVirtualKey traduit
|
||||
# selon la disposition clavier active, alors que GLFW raisonne en positions
|
||||
# physiques - voir l'en-tete de run_vulkan_check.ps1 pour le detail du piege.
|
||||
#
|
||||
# powershell -File tools\shot_editor.ps1
|
||||
# powershell -File tools\shot_editor.ps1 -Out build\editeur.png -Select
|
||||
#
|
||||
# ATTENTION : la camera est verrouillee (--lock-input). Sans ce verrou, la souris
|
||||
# SYSTEME reoriente la vue pendant la pose et deux captures du meme script ne
|
||||
# cadrent pas la meme chose (constate en Phase 11). --start et --look determinent
|
||||
# donc entierement l'image.
|
||||
# ===========================================================================
|
||||
|
||||
param(
|
||||
[string]$Scene = "assets\terrain\LHD_0907_6440_1m.vchm",
|
||||
[string]$SceneFile = "assets\scenes\demo_phase15.vcsc",
|
||||
[string]$Start = "--start=907500,6439500",
|
||||
[string]$Look = "--look=-90,-8",
|
||||
[string]$Out = "build\p15_editeur.png",
|
||||
# Selectionne l'objet vise avant de capturer : montre la teinte AMBRE en plus
|
||||
# de la teinte cyan du fantome.
|
||||
[switch]$Select,
|
||||
[int]$SettleSeconds = 6
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe (lancer tools\build.bat)" }
|
||||
|
||||
Add-Type -AssemblyName System.Drawing
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32E {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
[DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags);
|
||||
[DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r);
|
||||
[StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; }
|
||||
}
|
||||
"@
|
||||
$WM_KEYDOWN = 0x0100
|
||||
$WM_KEYUP = 0x0101
|
||||
$WM_CLOSE = 0x0010
|
||||
# PW_RENDERFULLCONTENT : sans lui, une fenetre rendue par le GPU ressort NOIRE.
|
||||
$PW_RENDERFULLCONTENT = 2
|
||||
|
||||
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
||||
$psi.FileName = $exe
|
||||
$psi.Arguments = (@('"' + $Scene + '"',
|
||||
'"--editor"',
|
||||
'"--lock-input"',
|
||||
'"--no-vegetation"',
|
||||
'"' + $Start + '"',
|
||||
'"' + $Look + '"',
|
||||
'"--scene=' + $SceneFile + '"') -join ' ')
|
||||
$psi.WorkingDirectory = $root
|
||||
$psi.UseShellExecute = $false
|
||||
$psi.RedirectStandardOutput = $true
|
||||
$psi.RedirectStandardError = $true
|
||||
$proc = [System.Diagnostics.Process]::Start($psi)
|
||||
|
||||
$outSb = New-Object System.Text.StringBuilder
|
||||
$errSb = New-Object System.Text.StringBuilder
|
||||
$handlers = @(
|
||||
(Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $outSb),
|
||||
(Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $errSb)
|
||||
)
|
||||
$proc.BeginOutputReadLine()
|
||||
$proc.BeginErrorReadLine()
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 150 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) { throw "Pas de fenetre (HasExited=$($proc.HasExited))." }
|
||||
|
||||
Start-Sleep -Seconds $SettleSeconds
|
||||
|
||||
function Tap([int]$sc, [bool]$ext = $false, [int]$holdMs = 90) {
|
||||
# Le bit 24 du lParam est le drapeau "touche etendue" : GLFW indexe sa table
|
||||
# de scancodes par (scancode | 0x100) pour ces touches-la, donc l'oublier
|
||||
# designerait une touche du pave numerique au lieu de SUPPR, INSER ou d'une
|
||||
# fleche.
|
||||
$down = 1 -bor ($sc -shl 16)
|
||||
if ($ext) { $down = $down -bor (1 -shl 24) }
|
||||
$up = $down -bor (1 -shl 30) -bor (1 -shl 31)
|
||||
[void][W32E]::PostMessage($hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr]$down)
|
||||
Start-Sleep -Milliseconds $holdMs
|
||||
[void][W32E]::PostMessage($hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr]$up)
|
||||
Start-Sleep -Milliseconds 250
|
||||
}
|
||||
|
||||
if ($Select) {
|
||||
# Pour montrer la teinte AMBRE il faut un objet selectionne, donc un objet
|
||||
# sous le reticule. Plutot que de dependre du cadrage - un objet deja pose
|
||||
# n'est pas forcement dans l'axe - on en POSE un a la visee, puis on le
|
||||
# selectionne : ca marche depuis n'importe quel point de vue.
|
||||
#
|
||||
# Entre les deux, on arme un asset MINCE (le poteau, rang 5). Sinon le
|
||||
# fantome cyan, pose exactement au meme endroit, recouvrirait entierement
|
||||
# l'objet ambre qu'on cherche justement a montrer.
|
||||
Tap 0x52 $true # INSER : poser au point vise
|
||||
Start-Sleep -Milliseconds 300
|
||||
Tap 0x06 # 5 : armer le poteau
|
||||
Tap 0x12 # E : selectionner l'objet vise
|
||||
Start-Sleep -Milliseconds 500
|
||||
}
|
||||
|
||||
# --- Capture ---------------------------------------------------------------
|
||||
$rect = New-Object W32E+RECT
|
||||
[void][W32E]::GetClientRect($hwnd, [ref]$rect)
|
||||
$width = $rect.R - $rect.L
|
||||
$height = $rect.B - $rect.T
|
||||
$bitmap = New-Object System.Drawing.Bitmap($width, $height)
|
||||
$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
|
||||
$dc = $graphics.GetHdc()
|
||||
[void][W32E]::PrintWindow($hwnd, $dc, $PW_RENDERFULLCONTENT)
|
||||
$graphics.ReleaseHdc($dc)
|
||||
$graphics.Dispose()
|
||||
|
||||
$outPath = if ([System.IO.Path]::IsPathRooted($Out)) { $Out } else { Join-Path $root $Out }
|
||||
$outDir = Split-Path -Parent $outPath
|
||||
if ($outDir -and -not (Test-Path $outDir)) { New-Item -ItemType Directory -Path $outDir | Out-Null }
|
||||
$bitmap.Save($outPath, [System.Drawing.Imaging.ImageFormat]::Png)
|
||||
$bitmap.Dispose()
|
||||
Write-Host "CAPTURE $outPath ($width x $height)"
|
||||
|
||||
[void][W32E]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(20000)) { $proc.Kill(); $proc.WaitForExit() }
|
||||
$proc.WaitForExit()
|
||||
Start-Sleep -Milliseconds 400
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
|
||||
$text = $outSb.ToString() + $errSb.ToString()
|
||||
$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' })
|
||||
$validation = @($lines | Where-Object { $_ -match '\[Validation\]' }).Count
|
||||
$lines | Where-Object { $_ -match 'objet\(s\) charges|asset\(s\) au catalogue|selection de|Editeur : pinceau' } |
|
||||
Select-Object -Last 4 | ForEach-Object { Write-Host $_ }
|
||||
Write-Host "Messages de validation : $validation ; code de sortie : $($proc.ExitCode)"
|
||||
if ($validation -ne 0 -or $proc.ExitCode -ne 0) { exit 1 }
|
||||
@@ -0,0 +1,125 @@
|
||||
# ===========================================================================
|
||||
# PHASE 27 - Captures epinglees de la meteo visible et du micro-relief.
|
||||
# ===========================================================================
|
||||
# Meme discipline que shot_daynight.ps1 (--lock-input + --look + --start +
|
||||
# --hour + --time-scale=0), plus --day : sans lui, --hour ne choisit que l'heure
|
||||
# du JOUR 0, qui ne contient aucune perturbation - donc aucune pluie a montrer.
|
||||
#
|
||||
# Les instants par defaut ont ete CHOISIS dans le calendrier deterministe
|
||||
# (seed fixe), pas au hasard ; voir NOTES-PHASE27.md, section "Instants de
|
||||
# reference" :
|
||||
# j12 13 h : nebulosite 0,14, pas de pluie (grand beau)
|
||||
# j0 13 h : nebulosite 0,54, pas de pluie (mi-couvert)
|
||||
# j8 13 h : nebulosite 0,95, 4,9 mm/h (pluie franche)
|
||||
# j8 22 h : pluie de nuit
|
||||
# j169 9 h 15 : neige, 7 mm/h equivalents, -3 C a l'altitude de l'alpage
|
||||
#
|
||||
# Difference avec screenshot_scene.ps1 : la sortie du jeu est JOURNALISEE dans
|
||||
# un fichier a cote de l'image (Start-Process -RedirectStandardOutput). C'est ce
|
||||
# qui permet de compter les messages [Validation] et de relire la ligne meteo
|
||||
# de chaque capture - une capture dont on ne sait pas quel temps il faisait ne
|
||||
# prouve rien.
|
||||
#
|
||||
# Usage :
|
||||
# powershell -File tools\shot_weather.ps1 -OutDir build\phase27\avant
|
||||
# powershell -File tools\shot_weather.ps1 -OutDir build\phase27\apres -Only meteo
|
||||
# ===========================================================================
|
||||
|
||||
param(
|
||||
[string]$OutDir = "build\phase27\captures",
|
||||
[string]$Scene = "assets\terrain\vercora_zone_1m.vchm",
|
||||
# "tout", "meteo" ou "sol".
|
||||
[string]$Only = "tout",
|
||||
[int]$SettleSeconds = 10,
|
||||
# Arguments supplementaires passes a TOUTES les captures (ex. un temoin
|
||||
# --no-weather-visuals).
|
||||
[string[]]$Extra = @()
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
$scenePath = Join-Path $root $Scene
|
||||
$outRoot = Join-Path $root $OutDir
|
||||
New-Item -ItemType Directory -Force -Path $outRoot | Out-Null
|
||||
|
||||
Add-Type -AssemblyName System.Drawing
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32W {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
[DllImport("user32.dll")] public static extern bool PrintWindow(IntPtr h, IntPtr dc, uint flags);
|
||||
[DllImport("user32.dll")] public static extern bool GetClientRect(IntPtr h, out RECT r);
|
||||
[StructLayout(LayoutKind.Sequential)] public struct RECT { public int L, T, R, B; }
|
||||
}
|
||||
"@
|
||||
|
||||
# Vue de reference de l'alpage (Phase 18, 124 touffes comptees), et deux
|
||||
# variantes du MEME point pour le sol : au ras (regard plonge) et au loin.
|
||||
$alpage = "900500,6439000"
|
||||
$shots = @(
|
||||
@{ n = "meteo_j12_13h_beau"; d = 12; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" },
|
||||
@{ n = "meteo_j00_13h_micouv"; d = 0; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" },
|
||||
@{ n = "meteo_j08_13h_pluie"; d = 8; h = 13; s = $alpage; l = "-90,-8"; k = "meteo" },
|
||||
@{ n = "meteo_j08_22h_pluienuit"; d = 8; h = 22; s = $alpage; l = "-90,-8"; k = "meteo" },
|
||||
@{ n = "meteo_j169_0915_neige"; d = 169; h = 9.25; s = $alpage; l = "-90,-8"; k = "meteo" },
|
||||
@{ n = "sol_ras_j12_13h"; d = 12; h = 13; s = $alpage; l = "-90,-50"; k = "sol" },
|
||||
@{ n = "sol_loin_j12_13h"; d = 12; h = 13; s = $alpage; l = "-90,-2"; k = "sol" }
|
||||
)
|
||||
|
||||
$validationTotal = 0
|
||||
foreach ($shot in $shots) {
|
||||
if ($Only -ne "tout" -and $Only -ne $shot.k) { continue }
|
||||
|
||||
$stale = Get-Process -Name "vercora" -ErrorAction SilentlyContinue
|
||||
if ($stale) { $stale | Stop-Process -Force; Start-Sleep -Milliseconds 500 }
|
||||
|
||||
$png = Join-Path $outRoot "$($shot.n).png"
|
||||
$log = Join-Path $outRoot "$($shot.n).log"
|
||||
$gameArgs = @("`"$scenePath`"", "--start=$($shot.s)", "--look=$($shot.l)",
|
||||
"--day=$($shot.d)", ("--hour=" + ([double]$shot.h).ToString([System.Globalization.CultureInfo]::InvariantCulture)), "--time-scale=0",
|
||||
"--lock-input") + $Extra
|
||||
|
||||
$proc = Start-Process -FilePath $exe -ArgumentList $gameArgs -WorkingDirectory $root `
|
||||
-RedirectStandardOutput $log -RedirectStandardError "$log.err" -PassThru
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 900 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) {
|
||||
Write-Host "[ECHEC] $($shot.n) : pas de fenetre."
|
||||
if (-not $proc.HasExited) { $proc.Kill() }
|
||||
exit 1
|
||||
}
|
||||
Start-Sleep -Seconds $SettleSeconds
|
||||
|
||||
$rect = New-Object W32W+RECT
|
||||
[void][W32W]::GetClientRect($hwnd, [ref]$rect)
|
||||
$w = $rect.R - $rect.L; $h = $rect.B - $rect.T
|
||||
$bmp = New-Object System.Drawing.Bitmap $w, $h
|
||||
$gfx = [System.Drawing.Graphics]::FromImage($bmp)
|
||||
$dc = $gfx.GetHdc()
|
||||
[void][W32W]::PrintWindow($hwnd, $dc, 2)
|
||||
$gfx.ReleaseHdc($dc); $gfx.Dispose()
|
||||
$bmp.Save($png, [System.Drawing.Imaging.ImageFormat]::Png)
|
||||
$bmp.Dispose()
|
||||
|
||||
[void][W32W]::PostMessage($hwnd, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) { $proc.Kill(); $proc.WaitForExit() }
|
||||
|
||||
$text = (Get-Content $log -Raw) + (Get-Content "$log.err" -Raw -ErrorAction SilentlyContinue)
|
||||
$validation = ([regex]::Matches($text, "\[Validation\]")).Count
|
||||
$validationTotal += $validation
|
||||
$meteo = ($text -split "`n" | Select-String "Visuels meteo" | Select-Object -Last 1)
|
||||
Write-Host ("{0,-26} validation={1} {2}" -f $shot.n, $validation, $meteo)
|
||||
}
|
||||
|
||||
Write-Host ""
|
||||
Write-Host "[FIN] messages [Validation] cumules : $validationTotal"
|
||||
if ($validationTotal -gt 0) { exit 3 }
|
||||
exit 0
|
||||
@@ -0,0 +1,163 @@
|
||||
# traverse_terrain.ps1 - traverse un terrain assemble en marchant, et surveille
|
||||
# ce qui se passe AUX FRONTIERES entre anciennes dalles.
|
||||
#
|
||||
# PHASE 9. Complement de tools\measure_terrain.ps1 (qui mesure a l'arret) : ici
|
||||
# la camera MARCHE, pour repondre a la question " la camera peut-elle se deplacer
|
||||
# sur toute la zone sans probleme aux frontieres ". Un raccord defectueux se
|
||||
# manifesterait par une chute de FPS localisee, un message de validation, une
|
||||
# chute a travers le sol ou un plantage - donc par autre chose qu'un chiffre
|
||||
# moyen.
|
||||
#
|
||||
# powershell -File tools\traverse_terrain.ps1 -Scene assets\terrain\vercora_zone_2m.vchm
|
||||
# powershell -File tools\traverse_terrain.ps1 -Scene ... -Distance 1200
|
||||
#
|
||||
# Le terrain est CENTRE sur l'origine : sur une grille de 5 km, la camera demarre
|
||||
# au milieu de la dalle centrale et les frontieres d'anciennes dalles tombent a
|
||||
# 500 m et 1500 m de part et d'autre, sur les deux axes. Marcher 700 m dans une
|
||||
# direction en franchit donc au moins une, quelle que soit la direction.
|
||||
#
|
||||
# LIMITE ASSUMEE, la meme qu'en Phase 7/8 : la souris ne peut pas etre pilotee
|
||||
# (GLFW lit le curseur SYSTEME, pas les messages postes), donc la camera ne
|
||||
# tourne jamais et la position n'est connue qu'A L'ESTIME (vitesse x temps).
|
||||
# A bas FPS le jeu consomme les touches plus grossierement, donc la distance
|
||||
# reellement parcourue est un ORDRE DE GRANDEUR, pas une mesure. Ce test prouve
|
||||
# qu'on traverse sans incident, il ne mesure pas ou l'on arrive.
|
||||
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][string]$Scene,
|
||||
[double]$Distance = 700.0,
|
||||
[double]$Speed = 14.0
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$root = Split-Path -Parent $PSScriptRoot
|
||||
$exe = Join-Path $root "build\vercora.exe"
|
||||
if (-not (Test-Path $exe)) { throw "vercora.exe introuvable : $exe" }
|
||||
|
||||
Add-Type @"
|
||||
using System;
|
||||
using System.Text;
|
||||
using System.Runtime.InteropServices;
|
||||
public class W32T {
|
||||
[DllImport("user32.dll")] public static extern bool PostMessage(IntPtr h, uint m, IntPtr w, IntPtr l);
|
||||
[DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowTextW(IntPtr h, StringBuilder s, int n);
|
||||
}
|
||||
"@
|
||||
$WM_KEYDOWN = 0x0100; $WM_KEYUP = 0x0101; $WM_CLOSE = 0x0010
|
||||
$SC = @{ W = 0x11; A = 0x1E; S = 0x1F; D = 0x20 }
|
||||
|
||||
Write-Host "=== Traversee : $Scene ($Distance m par direction) ==="
|
||||
|
||||
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
||||
$psi.FileName = $exe
|
||||
$psi.Arguments = '"' + $Scene + '"'
|
||||
$psi.WorkingDirectory = $root
|
||||
$psi.UseShellExecute = $false
|
||||
$psi.RedirectStandardOutput = $true
|
||||
$psi.RedirectStandardError = $true
|
||||
$proc = [System.Diagnostics.Process]::Start($psi)
|
||||
|
||||
$outSb = New-Object System.Text.StringBuilder
|
||||
$errSb = New-Object System.Text.StringBuilder
|
||||
$handlers = @(
|
||||
(Register-ObjectEvent -InputObject $proc -EventName OutputDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $outSb),
|
||||
(Register-ObjectEvent -InputObject $proc -EventName ErrorDataReceived -Action {
|
||||
if ($null -ne $EventArgs.Data) { [void]$Event.MessageData.AppendLine($EventArgs.Data) }
|
||||
} -MessageData $errSb)
|
||||
)
|
||||
$proc.BeginOutputReadLine()
|
||||
$proc.BeginErrorReadLine()
|
||||
|
||||
$hwnd = [IntPtr]::Zero
|
||||
for ($i = 0; $i -lt 600 -and $hwnd -eq [IntPtr]::Zero; $i++) {
|
||||
$proc.Refresh()
|
||||
if ($proc.HasExited) { break }
|
||||
if ($proc.MainWindowHandle -ne [IntPtr]::Zero) { $hwnd = $proc.MainWindowHandle }
|
||||
Start-Sleep -Milliseconds 100
|
||||
}
|
||||
if ($hwnd -eq [IntPtr]::Zero) {
|
||||
$proc.WaitForExit(); Start-Sleep -Milliseconds 300
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
Write-Host ($outSb.ToString() + $errSb.ToString())
|
||||
Write-Host "[ECHEC] Pas de fenetre."
|
||||
exit 1
|
||||
}
|
||||
Start-Sleep -Seconds 3
|
||||
|
||||
$sb = New-Object System.Text.StringBuilder 512
|
||||
function Read-Fps() {
|
||||
[void]$sb.Clear()
|
||||
[void][W32T]::GetWindowTextW($hwnd, $sb, 512)
|
||||
if ($sb.ToString() -match '(\d+)\s*FPS') { return [int]$Matches[1] }
|
||||
return -1
|
||||
}
|
||||
|
||||
# Marche en maintenant la touche, en relevant le FPS EN COURS DE ROUTE : c'est
|
||||
# le minimum instantane qui trahirait un accroc a une frontiere, pas la moyenne.
|
||||
function Walk([string]$name, [int]$sc, [double]$distance) {
|
||||
$ms = [int](1000.0 * $distance / $Speed)
|
||||
[void][W32T]::PostMessage($hwnd, $WM_KEYDOWN, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16)))
|
||||
$samples = New-Object System.Collections.ArrayList
|
||||
$deadline = (Get-Date).AddMilliseconds($ms)
|
||||
while ((Get-Date) -lt $deadline) {
|
||||
if ($proc.HasExited) { break }
|
||||
$f = Read-Fps
|
||||
if ($f -ge 0) { [void]$samples.Add($f) }
|
||||
Start-Sleep -Milliseconds 250
|
||||
}
|
||||
[void][W32T]::PostMessage($hwnd, $WM_KEYUP, [IntPtr]0, [IntPtr](1 -bor ($sc -shl 16) -bor (1 -shl 30) -bor (1 -shl 31)))
|
||||
Start-Sleep -Milliseconds 200
|
||||
|
||||
if ($proc.HasExited) {
|
||||
Write-Host (" {0,-22} LE JEU S'EST ARRETE PENDANT LA MARCHE (code {1})" -f $name, $proc.ExitCode)
|
||||
return $false
|
||||
}
|
||||
if ($samples.Count -eq 0) {
|
||||
Write-Host (" {0,-22} aucun releve de FPS" -f $name)
|
||||
return $true
|
||||
}
|
||||
$stats = $samples | Measure-Object -Average -Minimum -Maximum
|
||||
Write-Host (" {0,-22} {1,4:N0} m parcourus | FPS moyen {2,4:N0}, min {3,4}, max {4,4} ({5} releves)" -f `
|
||||
$name, $distance, $stats.Average, $stats.Minimum, $stats.Maximum, $samples.Count)
|
||||
return $true
|
||||
}
|
||||
|
||||
$ok = $true
|
||||
Write-Host "Marche (la camera ne tourne pas : W=nord, S=sud, D=est, A=ouest)"
|
||||
$ok = (Walk "nord (franchit -Z)" $SC.W $Distance) -and $ok
|
||||
$ok = (Walk "sud (retour + au-dela)" $SC.S (2 * $Distance)) -and $ok
|
||||
$ok = (Walk "nord (retour au centre)" $SC.W $Distance) -and $ok
|
||||
$ok = (Walk "est (franchit +X)" $SC.D $Distance) -and $ok
|
||||
$ok = (Walk "ouest(retour + au-dela)" $SC.A (2 * $Distance)) -and $ok
|
||||
$ok = (Walk "est (retour au centre)" $SC.D $Distance) -and $ok
|
||||
|
||||
if (-not $proc.HasExited) {
|
||||
[void][W32T]::PostMessage($hwnd, $WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero)
|
||||
if (-not $proc.WaitForExit(30000)) {
|
||||
Write-Host "[ECHEC] Pas de sortie 30 s apres WM_CLOSE."
|
||||
$proc.Kill(); $proc.WaitForExit(); $ok = $false
|
||||
}
|
||||
}
|
||||
$proc.WaitForExit()
|
||||
$code = $proc.ExitCode
|
||||
Start-Sleep -Milliseconds 400
|
||||
foreach ($h in $handlers) { Unregister-Event -SourceIdentifier $h.Name -ErrorAction SilentlyContinue }
|
||||
|
||||
$text = $outSb.ToString() + $errSb.ToString()
|
||||
$lines = @($text -split "`r?`n" | Where-Object { $_ -ne '' })
|
||||
$validation = @($lines | Where-Object { $_ -match '\[Validation\]' })
|
||||
$errors = @($lines | Where-Object { $_ -match '\[ERROR\]|\[WARN\]' })
|
||||
|
||||
Write-Host ("TRAVERSEE validation : {0} message(s) [Validation], {1} [ERROR]/[WARN]" -f `
|
||||
$validation.Count, $errors.Count)
|
||||
foreach ($l in ($validation + $errors) | Select-Object -First 10) { Write-Host " $l" }
|
||||
Write-Host ("TRAVERSEE code de sortie: {0}" -f $code)
|
||||
|
||||
if (-not $ok -or $validation.Count -gt 0 -or $errors.Count -gt 0 -or $code -ne 0) {
|
||||
Write-Host "TRAVERSEE : ECHEC"
|
||||
exit 1
|
||||
}
|
||||
Write-Host "TRAVERSEE : OK - aucune anomalie en franchissant les frontieres."
|
||||
exit 0
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur