Fichiers
2026-10-11 01:54:18 +02:00

390 lignes
17 KiB
Python

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