Fichiers
vercora/tools/fetch_ortho.py
T
2026-10-11 01:54:18 +02:00

355 lignes
15 KiB
Python

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