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