Phase 30 (1/n) : build Linux, banc de mesure des ressources, plan
- Portabilite GCC/Clang : les constructeurs a argument par defaut `= {}`
sur une struct imbriquee (Heightmap, TerrainQuadtree, TerrainStreamer)
deviennent des surcharges qui deleguent (CWG 1397, refuse hors MSVC).
GLFW_INCLUDE_NONE evite d'exiger <GL/gl.h> sous Linux.
- Comptabilite de la memoire GPU : toute allocation passe par
VulkanContext::allocateMemory / freeMemory (octets vivants, pics, blocs,
appels vkAllocateMemory). RAM du processus lue au systeme
(core/ProcessMemory). Bilan "Ressources (PHASE 30)" au chargement,
toutes les 10 s et en fin de partie.
- Outils de banc : --quit-after=S (fermeture propre), --freeze-anim
(images comparables au pixel), tools/make_bench_zone.py (zone proxy
5001x5001 a la vraie echelle quand les donnees LiDAR sont absentes).
- NOTES-PHASE30.md : mesure de reference, revue du noyau Vulkan, plan.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MG5dK27RsN97DDm7CQRhx2
Cette révision appartient à :
17 fichiers modifiés
+767
-59
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,249 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
make_bench_zone.py — fabrique une zone PROXY de 25 km2 pour MESURER le moteur
|
||||
sur une machine qui n'a pas les donnees LiDAR (session cloud, CI, nouveau poste).
|
||||
|
||||
PHASE 30. Les dalles LiDAR (data/lidar, plusieurs Go) et les .vchm qui en sont
|
||||
tires ne sont pas versionnes ; seule l'orthophoto vercora_zone_ortho.vcto l'est.
|
||||
Sans terrain de zone, le jeu retombe sur le terrain synthetique 128x128 : un
|
||||
banc de mesure n'y exerce ni le streaming de 8 000 noeuds, ni la vegetation a
|
||||
l'echelle, ni rien de ce qui pese reellement en memoire.
|
||||
|
||||
Ce script ecrit, dans assets/terrain/ (ignore par git, *.vchm) :
|
||||
vercora_zone_1m.vchm 5001 x 5001 au pas de 1 m
|
||||
vercora_zone_canopy.vchm couvert 0..1, 1001 x 1001 au pas de 5 m
|
||||
vercora_zone_canopy_height.vchm hauteur de canopee (m)
|
||||
vercora_zone_canopy_lowveg.vchm fraction de vegetation basse (F3)
|
||||
vercora_zone_canopy_lowveg_height.vchm hauteur de vegetation basse (m)
|
||||
|
||||
CE QUI EST VRAI ET CE QUI NE L'EST PAS, sans detour :
|
||||
- L'EMPRISE, la RESOLUTION, la georeference et la plage d'altitudes
|
||||
(1029-2285 m) sont celles de la vraie zone : le quadtree, le streaming,
|
||||
l'orthophoto (qui s'y applique, orthoMatchesTerrain passe) et tous les
|
||||
budgets memoire travaillent donc a la vraie echelle.
|
||||
- Le RELIEF est un bruit fractal (fBm + cretes, la recette de
|
||||
Heightmap::Params), pas le Vercors.
|
||||
- Le COUVERT est tire de la VRAIE orthophoto (indice de vert sur le niveau de
|
||||
mipmap 2048 x 2048) : les arbres poussent la ou la photo montre de la foret,
|
||||
mais sur un relief qui n'est pas le sien.
|
||||
Les chiffres de MEMOIRE et de COUT obtenus sur cette zone sont donc
|
||||
representatifs a l'ordre de grandeur et comparables ENTRE EUX (avant / apres
|
||||
une optimisation) ; ils ne remplacent pas une mesure sur les vraies donnees.
|
||||
|
||||
python tools/make_bench_zone.py # ecrit dans assets/terrain/
|
||||
python tools/make_bench_zone.py --force # ecrase des fichiers existants
|
||||
|
||||
Refuse d'ecraser un fichier existant sans --force : sur la machine de
|
||||
developpement, ces noms sont ceux des VRAIES donnees.
|
||||
|
||||
Dependances : numpy.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
import numpy as np
|
||||
|
||||
ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
TERRAIN_DIR = os.path.join(ROOT, "assets", "terrain")
|
||||
ORTHO = os.path.join(TERRAIN_DIR, "vercora_zone_ortho.vcto")
|
||||
|
||||
# Emprise de la vraie zone (en-tete de vercora_zone_ortho.vcto).
|
||||
ORIGIN_EAST = 899000.0
|
||||
ORIGIN_NORTH = 6440000.0
|
||||
EXTENT_M = 5000.0
|
||||
EPSG = 2154
|
||||
ALT_MIN = 1029.0
|
||||
ALT_MAX = 2285.0
|
||||
SEED = 20261013
|
||||
|
||||
|
||||
def write_vchm(path: str, grid: np.ndarray, spacing: float, label: str,
|
||||
absolute: bool) -> None:
|
||||
"""Ecrit un .vchm version 1 (format : src/assets/TerrainFile.hpp)."""
|
||||
grid = np.ascontiguousarray(grid, dtype="<f4")
|
||||
n = grid.shape[0]
|
||||
assert grid.shape == (n, n)
|
||||
header = bytearray(120)
|
||||
header[0:4] = b"VCHM"
|
||||
struct.pack_into("<IIIf", header, 4, 1, n, n, spacing)
|
||||
struct.pack_into("<dd", header, 24, ORIGIN_EAST, ORIGIN_NORTH)
|
||||
struct.pack_into("<ffII", header, 40, float(grid.min()), float(grid.max()),
|
||||
EPSG, 1 if absolute else 0)
|
||||
raw = label.encode("ascii")[:64]
|
||||
header[56:56 + len(raw)] = raw
|
||||
with open(path, "wb") as f:
|
||||
f.write(header)
|
||||
f.write(grid.tobytes())
|
||||
|
||||
|
||||
def smooth(t: np.ndarray) -> np.ndarray:
|
||||
return t * t * (3.0 - 2.0 * t)
|
||||
|
||||
|
||||
def value_noise(n: int, cells: int, rng: np.random.Generator) -> np.ndarray:
|
||||
"""Bruit de valeur n x n a `cells` cellules par cote, interpolation
|
||||
separable (d'abord le long de X pour chaque ligne du reseau, puis le long
|
||||
de Z) : 3 operations par echantillon au lieu de 4 lectures + 3 lerps."""
|
||||
lattice = rng.random((cells + 2, cells + 2), dtype=np.float32)
|
||||
x = np.linspace(0.0, cells, n, dtype=np.float64)
|
||||
i0 = np.minimum(np.floor(x).astype(np.int64), cells)
|
||||
t = smooth((x - i0).astype(np.float32))
|
||||
along_x = lattice[:, i0] * (1.0 - t) + lattice[:, i0 + 1] * t # (cells+2, n)
|
||||
return along_x[i0, :] * (1.0 - t)[:, None] + along_x[i0 + 1, :] * t[:, None]
|
||||
|
||||
|
||||
def fbm(n: int, base: int, octaves: int, ridged: bool, rng) -> np.ndarray:
|
||||
total = np.zeros((n, n), dtype=np.float32)
|
||||
norm = 0.0
|
||||
amplitude = 1.0
|
||||
cells = base
|
||||
for _ in range(octaves):
|
||||
octave = value_noise(n, cells, rng)
|
||||
if ridged:
|
||||
octave = 1.0 - np.abs(2.0 * octave - 1.0)
|
||||
total += amplitude * octave
|
||||
norm += amplitude
|
||||
amplitude *= 0.5
|
||||
cells *= 2
|
||||
return total / norm
|
||||
|
||||
|
||||
def make_relief(n: int) -> np.ndarray:
|
||||
rng = np.random.default_rng(SEED)
|
||||
soft = fbm(n, 3, 9, False, rng) ** 1.4
|
||||
ridge = fbm(n, 3, 9, True, rng)
|
||||
shaped = soft + (ridge * ridge - soft) * 0.6
|
||||
# Barres rocheuses facon Vercors : une marche raide la ou un bruit tres
|
||||
# large franchit un seuil. Sans elles le relief n'offrirait aucune paroi
|
||||
# d'escalade (pente >= 0,84) ni de pierrier (0,60-0,84).
|
||||
band = value_noise(n, 4, rng)
|
||||
cliff = smooth(np.clip((band - 0.55) / 0.02, 0.0, 1.0))
|
||||
shaped = shaped + 0.12 * cliff
|
||||
lo, hi = float(shaped.min()), float(shaped.max())
|
||||
return (ALT_MIN + (shaped - lo) / (hi - lo) * (ALT_MAX - ALT_MIN)).astype(np.float32)
|
||||
|
||||
|
||||
def decode_bc1_level(path: str, level: int) -> np.ndarray:
|
||||
"""Decode le niveau `level` d'un .vcto BC1 en RGB float [0,1]."""
|
||||
with open(path, "rb") as f:
|
||||
data = f.read()
|
||||
if data[:4] != b"VCTO":
|
||||
raise SystemExit(f"{path} n'est pas un .vcto")
|
||||
width, height, mips, fmt = struct.unpack_from("<IIII", data, 8)
|
||||
if fmt != 1:
|
||||
raise SystemExit("orthophoto attendue en BC1")
|
||||
offset = 128
|
||||
for k in range(level):
|
||||
w, h = max(1, width >> k), max(1, height >> k)
|
||||
offset += ((w + 3) // 4) * ((h + 3) // 4) * 8
|
||||
w, h = max(1, width >> level), max(1, height >> level)
|
||||
bx, by = (w + 3) // 4, (h + 3) // 4
|
||||
blocks = np.frombuffer(data, dtype="<u2", count=bx * by * 4, offset=offset)
|
||||
blocks = blocks.reshape(by, bx, 4)
|
||||
c0 = blocks[..., 0].astype(np.uint32)
|
||||
c1 = blocks[..., 1].astype(np.uint32)
|
||||
bits = blocks[..., 2].astype(np.uint32) | (blocks[..., 3].astype(np.uint32) << 16)
|
||||
|
||||
def rgb565(c):
|
||||
r = ((c >> 11) & 31) / 31.0
|
||||
g = ((c >> 5) & 63) / 63.0
|
||||
b = (c & 31) / 31.0
|
||||
return np.stack([r, g, b], axis=-1)
|
||||
|
||||
p0, p1 = rgb565(c0), rgb565(c1)
|
||||
four = (c0 > c1)[..., None]
|
||||
p2 = np.where(four, (2 * p0 + p1) / 3, (p0 + p1) / 2)
|
||||
p3 = np.where(four, (p0 + 2 * p1) / 3, 0.0)
|
||||
palette = np.stack([p0, p1, p2, p3], axis=2) # (by, bx, 4, 3)
|
||||
out = np.zeros((by * 4, bx * 4, 3), dtype=np.float32)
|
||||
for py in range(4):
|
||||
for px in range(4):
|
||||
idx = (bits >> (2 * (py * 4 + px))) & 3
|
||||
texel = np.take_along_axis(palette, idx[..., None, None].repeat(3, -1),
|
||||
axis=2)[:, :, 0, :]
|
||||
out[py::4, px::4, :] = texel
|
||||
return out[:h, :w]
|
||||
|
||||
|
||||
def resample(image: np.ndarray, n: int) -> np.ndarray:
|
||||
"""Echantillonne l'image (rangee du nord au sud) aux n x n points de grille
|
||||
(coins compris), par moyenne d'une fenetre 3 x 3 autour du texel."""
|
||||
h, w = image.shape[:2]
|
||||
coords = np.linspace(0.0, 1.0, n)
|
||||
ys = np.clip(np.round(coords * (h - 1)).astype(np.int64), 1, h - 2)
|
||||
xs = np.clip(np.round(coords * (w - 1)).astype(np.int64), 1, w - 2)
|
||||
acc = np.zeros((n, n) + image.shape[2:], dtype=np.float32)
|
||||
for dy in (-1, 0, 1):
|
||||
for dx in (-1, 0, 1):
|
||||
acc += image[(ys + dy)[:, None], (xs + dx)[None, :]]
|
||||
return acc / 9.0
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[1])
|
||||
parser.add_argument("--force", action="store_true",
|
||||
help="ecraser des fichiers existants")
|
||||
args = parser.parse_args()
|
||||
|
||||
names = {
|
||||
"terrain": "vercora_zone_1m.vchm",
|
||||
"cover": "vercora_zone_canopy.vchm",
|
||||
"height": "vercora_zone_canopy_height.vchm",
|
||||
"lowveg": "vercora_zone_canopy_lowveg.vchm",
|
||||
"lowveg_height": "vercora_zone_canopy_lowveg_height.vchm",
|
||||
}
|
||||
paths = {k: os.path.join(TERRAIN_DIR, v) for k, v in names.items()}
|
||||
existing = [p for p in paths.values() if os.path.exists(p)]
|
||||
if existing and not args.force:
|
||||
print("Refus : ces fichiers existent deja (vraies donnees ?) :")
|
||||
for p in existing:
|
||||
print(" " + p)
|
||||
print("Relancer avec --force pour les ecraser.")
|
||||
return 1
|
||||
if not os.path.exists(ORTHO):
|
||||
print(f"Orthophoto introuvable : {ORTHO}")
|
||||
return 1
|
||||
|
||||
t0 = time.time()
|
||||
relief = make_relief(5001)
|
||||
write_vchm(paths["terrain"], relief, 1.0, "vercora_zone PROXY bench (relief fBm)", True)
|
||||
print(f"terrain : {paths['terrain']} ({relief.min():.1f} .. {relief.max():.1f} m, "
|
||||
f"{time.time() - t0:.1f} s)")
|
||||
|
||||
rgb = decode_bc1_level(ORTHO, 2) # 2048 x 2048, 2,44 m/texel
|
||||
rgb5 = resample(rgb, 1001)
|
||||
r, g, b = rgb5[..., 0], rgb5[..., 1], rgb5[..., 2]
|
||||
lum = (r + g + b) / 3.0
|
||||
exg = 2.0 * g - r - b
|
||||
# Foret = sombre ET verte ; prairie = verte mais claire ; roche = grise.
|
||||
green = np.clip(exg / 0.06, 0.0, 1.0)
|
||||
dark = np.clip((0.45 - lum) / 0.18, 0.0, 1.0)
|
||||
cover = np.clip(green * dark * 1.6, 0.0, 1.0).astype(np.float32)
|
||||
rng = np.random.default_rng(SEED + 1)
|
||||
tall = 14.0 + 16.0 * value_noise(1001, 40, rng)
|
||||
canopy = np.where(cover > 0.15, tall * np.clip(cover * 1.5, 0.3, 1.0), 0.0)
|
||||
shrub = np.clip(green * (1.0 - dark) * 0.35 + cover * (1.0 - cover) * 0.5, 0.0, 0.6)
|
||||
lowveg = shrub.astype(np.float32)
|
||||
lowveg_h = np.where(lowveg > 0.05, 0.6 + 3.6 * value_noise(1001, 60, rng), 0.0)
|
||||
|
||||
write_vchm(paths["cover"], cover, 5.0, "vercora_zone PROXY couvert (ortho)", False)
|
||||
write_vchm(paths["height"], canopy.astype(np.float32), 5.0,
|
||||
"vercora_zone PROXY canopee", False)
|
||||
write_vchm(paths["lowveg"], lowveg, 5.0, "vercora_zone PROXY vegetation basse", False)
|
||||
write_vchm(paths["lowveg_height"], lowveg_h.astype(np.float32), 5.0,
|
||||
"vercora_zone PROXY h vegetation basse", False)
|
||||
print(f"couvert : moyenne {cover.mean():.3f}, cellules > 0,5 : "
|
||||
f"{(cover > 0.5).mean() * 100:.1f} % ; F3 moyenne {lowveg.mean():.3f}")
|
||||
print(f"total {time.time() - t0:.1f} s")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur