Premier commit

Cette révision appartient à :
Théo Gastinel a révisé 2026-10-11 01:54:18 +02:00
révision 84a72fe30c
200 fichiers modifiés
+61602

Aucun fichier ne correspond à votre recherche

+328
Voir le fichier
@@ -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())
+159
Voir le fichier
@@ -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%
+360
Voir le fichier
@@ -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())
+227
Voir le fichier
@@ -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())
+37
Voir le fichier
@@ -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
+334
Voir le fichier
@@ -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())
+354
Voir le fichier
@@ -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())
+433
Voir le fichier
@@ -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()
+185
Voir le fichier
@@ -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()
+12
Voir le fichier
@@ -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)"
+231
Voir le fichier
@@ -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())
+530
Voir le fichier
@@ -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())
+389
Voir le fichier
@@ -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())
+150
Voir le fichier
@@ -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
+186
Voir le fichier
@@ -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 }
+103
Voir le fichier
@@ -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 }
+124
Voir le fichier
@@ -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
+215
Voir le fichier
@@ -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%
+2526
Voir le fichier
Diff désactivé car ce fichier est trop long. Voir la Diff
+114
Voir le fichier
@@ -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
+108
Voir le fichier
@@ -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."
+168
Voir le fichier
@@ -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 }
+125
Voir le fichier
@@ -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
+163
Voir le fichier
@@ -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