# ===================================================================================== # GEOCARTO : sources vectorielles -> tuiles (scan réaliste, instances, failles) # - tuiles RÉELLES : scan GMNA + vecteurs USGS alignés # - tuiles SYNTHÉTIQUES : la carte est "imprimée" à partir des polygones, dans le style # d'une vraie carte géologique (couleurs chronostratigraphiques, motifs, contacts, # failles à dents, étiquettes, mer, graticule, rivières...) puis "scannée". # Vérité terrain commune : # inst : uint16, 0 = pas de polygone (mer / hors carte), 1..N = composantes connexes # d'une MÊME unité (deux polygones voisins de la même unité = une seule instance, # car aucune limite n'est visible entre eux sur la carte) # faults : uint8 {0,1}, tracé des failles (1 px) # ===================================================================================== import io, json, math, re, zlib, colorsys from functools import lru_cache from pathlib import Path import numpy as np import pandas as pd import geopandas as gpd import matplotlib from shapely.geometry import box from shapely.validation import make_valid from rasterio.features import rasterize from rasterio.transform import from_origin from scipy import ndimage as ndi from skimage.measure import label as cc_label, find_contours from PIL import Image, ImageDraw, ImageFont TILE, SS = 512, 2 # tuile finale 512 px, rendu interne sur-échantillonné x2 (anti-crénelage) R = TILE * SS # ------------------------------------------------------------------ polices _FD = Path(matplotlib.get_data_path()) / "fonts" / "ttf" FONTS = { "sans": "DejaVuSans.ttf", "bold": "DejaVuSans-Bold.ttf", "ital": "DejaVuSans-Oblique.ttf", "bital": "DejaVuSans-BoldOblique.ttf", "serif": "DejaVuSerif.ttf", "serifi": "DejaVuSerif-Italic.ttf", "serifb": "DejaVuSerif-Bold.ttf", "cond": "DejaVuSansMono.ttf", } @lru_cache(maxsize=256) def font(name, size): try: return ImageFont.truetype(str(_FD / FONTS[name]), int(size)) except Exception: return ImageFont.load_default() def _seed(*parts): return zlib.crc32("|".join(map(str, parts)).encode()) # ------------------------------------------------------------------ couleurs (charte chronostratigraphique CGMW/ICS) AGE_COLORS = [ (r"holocene|recent", (254, 242, 224)), (r"pleistocene", (255, 242, 174)), (r"quaternary|kvart", (249, 249, 127)), (r"pliocene", (255, 255, 153)), (r"miocene", (255, 255, 0)), (r"neogene", (255, 230, 25)), (r"oligocene", (254, 192, 122)), (r"pal(a)?eocene", (253, 167, 95)), (r"eocene", (253, 180, 108)), (r"pal(a)?eogene", (253, 154, 82)), (r"tertiary", (255, 200, 60)), (r"c(a)?enozoic", (242, 249, 29)), (r"cretaceous", (127, 198, 78)), (r"jurassic", (52, 178, 201)), (r"triassic", (129, 43, 146)), (r"mesozoic", (103, 197, 202)), (r"permian", (240, 64, 40)), (r"carboniferous|pennsylvanian|mississippian", (103, 165, 153)), (r"devonian", (203, 140, 55)), (r"silurian", (179, 225, 182)), (r"ordovician", (0, 146, 112)), (r"cambrian", (127, 160, 86)), (r"pal(a)?eozoic", (153, 192, 141)), (r"ediacaran|cryogenian|tonian|neoproterozoic|late proterozoic", (254, 179, 66)), (r"mesoproterozoic|middle proterozoic", (253, 180, 98)), (r"pal(a)?eoproterozoic|early proterozoic", (247, 67, 112)), (r"proterozoic", (247, 53, 99)), (r"archean|archaean", (240, 4, 127)), (r"precambrian", (247, 67, 112)), ] LITHO_COLORS = [ # quand l'âge est inconnu (ex. GEO-LiM) : carte lithologique (r"water|lake", (190, 225, 245)), (r"\bice\b|glacier", (236, 246, 252)), (r"peat", (170, 140, 100)), (r"gypsum|evaporite", (250, 200, 230)), (r"pure carbonate", (140, 195, 235)), (r"carbonate|limestone|dolom", (175, 215, 225)), (r"sandstone", (250, 222, 150)), (r"claystone|shale|mudstone|clay", (215, 195, 160)), (r"acid|granit|felsic", (240, 120, 140)), (r"intermediate", (235, 160, 180)), (r"mafic|basalt", (90, 150, 100)), (r"metamorph|schist|gneiss", (190, 160, 215)), (r"alluvi|sediment", (255, 240, 170)), ] PLUTONIC = re.compile(r"plutonic|intrusive|granit|tonalit|diorit|gabbro|syenit|monzon|batholith|granodior|pluton", re.I) VOLCANIC = re.compile(r"volcanic|basalt|andesit|rhyolit|tuff|lava|ignimbr|trachy|pyroclast", re.I) METAMORPH = re.compile(r"metamorph|schist|gneiss|crystalline|quartzite|marble|migmat|amphibolit|slate|phyllit", re.I) UNCONSOL = re.compile(r"alluvi|unconsolidated|sand dune|colluv|aeolian|eolian|surficial|regolith|playa|dune", re.I) def _match(table, text): t = (text or "").lower() for pat, rgb in table: if re.search(pat, t): return np.array(rgb, np.float32) return None def _mix(a, b, w): return a * (1 - w) + np.asarray(b, np.float32) * w def base_color(age, lith): """Couleur de légende 'officielle' d'une unité : âge (charte CGMW), modulée par la lithologie.""" age = age if isinstance(age, str) else "" lith = lith if isinstance(lith, str) else "" c = _match(AGE_COLORS, age) if c is None: c = _match(LITHO_COLORS, lith) if c is None: h = (_seed(age, lith) % 1000) / 1000 c = np.array(colorsys.hsv_to_rgb(h, 0.45, 0.9), np.float32) * 255 if re.search(r"\bice\b|glacier", lith, re.I): return np.array((236, 246, 252), np.float32) if PLUTONIC.search(lith): c = _mix(c, (232, 50, 110), 0.5) elif METAMORPH.search(lith): c = _mix(c, (165, 120, 185), 0.35) return c def pattern_pref(lith): lith = lith if isinstance(lith, str) else "" if VOLCANIC.search(lith): return "v" if UNCONSOL.search(lith): return "dots" if PLUTONIC.search(lith): return "cross" return None # ===================================================================================== # SOURCES # ===================================================================================== class Source: """Unités (polygones + uid), table des unités, failles, CRS métrique, plage d'échelles.""" def __init__(self, name, continent, units, tab, faults, px_range, min_land=0.55): self.name, self.continent = name, continent self.units, self.tab, self.faults = units, tab, faults self.px_range, self.min_land = px_range, min_land self.crs = units.crs _ = units.sindex if faults is not None and len(faults): _ = faults.sindex self.lut_rgb = np.zeros((int(tab.index.max()) + 1, 3), np.float32) for uid, r in tab.iterrows(): self.lut_rgb[uid] = r.rgb self.codes = tab["code"].to_dict() self.pref = tab["pref"].to_dict() def unit_meta(self, uid): r = self.tab.loc[uid] return {"unit": str(r.code), "age": str(r.age or ""), "lithology": str(r.lith or "")[:120]} def _clean(g, crs, simplify_m=0.0): g = g[g.geometry.notnull() & ~g.geometry.is_empty].to_crs(crs) g["geometry"] = g.geometry.apply(lambda x: x if x.is_valid else make_valid(x)) if simplify_m: g["geometry"] = g.geometry.simplify(simplify_m, preserve_topology=True) g = g[~g.geometry.is_empty & g.geom_type.isin(["Polygon", "MultiPolygon", "GeometryCollection"])] return g.reset_index(drop=True) def _read(path, **kw): for mode in ("fix", "ignore"): try: return gpd.read_file(path, on_invalid=mode, **kw) except Exception: pass return gpd.read_file(path, **kw) def build_units(g, key, code, age, lith, order=None): """Attribue un uid par unité (clé) et construit la table des unités.""" g = g.copy() g["_key"] = g[key].astype(str).fillna("?") keys = pd.Index(sorted(g["_key"].unique())) g["uid"] = keys.get_indexer(g["_key"]) + 1 g["order"] = order if order is not None else 0 first = g.drop_duplicates("uid").set_index("uid").sort_index() tab = pd.DataFrame(index=first.index) tab["code"] = (first[code] if code in first else first["_key"]).fillna("").astype(str).str.slice(0, 10) tab["age"] = (first[age] if isinstance(age, str) else age(first)).fillna("").astype(str) tab["lith"] = (first[lith] if isinstance(lith, str) else lith(first)).fillna("").astype(str) tab["rgb"] = [base_color(a, l) for a, l in zip(tab.age, tab.lith)] tab["pref"] = [pattern_pref(l) for l in tab.lith] return g[["uid", "order", "geometry"]], tab def load_gmna(units_shp, faults_shp, crs): u = _clean(_read(units_shp), crs) agef = lambda d: d["MIN_AGE"].fillna("").astype(str) + " / " + d["MAX_AGE"].fillna("").astype(str) lithf = lambda d: d["ROCKTYPE"].fillna("").astype(str) + " " + d["LITHOLOGY"].fillna("").astype(str) units, tab = build_units(u, "UNIT_ABBRE", "UNIT_ABBRE", agef, lithf) f = _read(faults_shp).to_crs(crs) f = f[f.geometry.notnull()].reset_index(drop=True) f["kind"] = "generic" f["concealed"] = False return Source("GMNA", "North America", units, tab, f[["kind", "concealed", "geometry"]], (300, 600)) def load_geolim(gpkg, simplify_m=40): g = _clean(gpd.read_file(gpkg), "EPSG:3035", simplify_m) abbr = {"mix carbonate rocks": "Cm", "sandstone": "Ss", "claystone": "Cl", "pure carbonate rocks": "Cp", "acid rocks": "γ", "mafic rocks": "β", "peat": "Pt", "water": "", "metamorphic rocks": "M", "intermediate rocks": "δ", "gypsum evaporite": "Ev"} g["code"] = g["litho_irpi"].map(abbr).fillna("?") units, tab = build_units(g, "litho_irpi", "code", lambda d: pd.Series("", index=d.index), "litho_irpi") return Source("GEO-LiM", "Europe", units, tab, None, (90, 420)) def load_ethiopia(shp, simplify_m=40): g = _clean(_read(shp), "EPSG:32637", simplify_m) agef = lambda d: (d["ODD2_od"].fillna("").astype(str) + " " + d["UTVAR2_od"].fillna("").astype(str) + " " + d["ERA2_od"].fillna("").astype(str) + " " + d["ERA1_do"].fillna("").astype(str)) lithf = lambda d: d["HOR_TYP"].fillna("").astype(str) + " " + d["HOR_KARTO"].fillna("").astype(str) g["code"] = g["legend_loo"].fillna(g["IDX"]).astype(str) units, tab = build_units(g, "N_LEG_ID", "code", agef, lithf) return Source("UNESCO-Ethiopia", "Africa", units, tab, None, (90, 420)) GA_LAYERS = ["Pre_Neoproterozoic", "Neoproterozoic", "Paleozoic", "Mesozoic", "Cenozoic"] # du plus vieux au plus jeune def load_australia(folder, simplify_m=60): """Couches par ère EMPILÉES : on dessine la plus jeune par-dessus (ordre de peinture).""" folder = Path(folder) parts, flts = [], [] for i, era in enumerate(GA_LAYERS): p = folder / f"{era}GeologicalUnitPolygons1M.shp" if p.exists(): g = _clean(_read(p, columns=["MAPSYMBOL", "PLOTSYMBOL", "GEOLHIST", "LITHOLOGY"]), "EPSG:3577", simplify_m) g["order"] = i parts.append(g) q = folder / f"{era}ShearDisplacementLines1M.shp" if q.exists(): f = _read(q, columns=["EXPOSURE", "MVTTYPE"]).to_crs("EPSG:3577") f["geometry"] = f.geometry.simplify(simplify_m) flts.append(f) g = pd.concat(parts, ignore_index=True) units, tab = build_units(g, "MAPSYMBOL", "MAPSYMBOL", "GEOLHIST", "LITHOLOGY", order=g["order"].values) f = pd.concat(flts, ignore_index=True) f = f[f.geometry.notnull() & ~f.geometry.is_empty].reset_index(drop=True) mv = f["MVTTYPE"].fillna("").str.lower() f["kind"] = np.where(mv.str.contains("thrust|reverse"), "thrust", np.where(mv.str.contains("normal"), "normal", "generic")) f["concealed"] = f["EXPOSURE"].fillna("").str.lower().str.contains("conceal|inferred|buried") return Source("GA-Australia", "Oceania", units, tab, gpd.GeoDataFrame(f[["kind", "concealed"]], geometry=f.geometry, crs=f.crs), (100, 450)) # Codes de lignes des cartes d'état USGS OF 2005-1305 (métadonnées CAmetadata.txt) ARC_FAULT = {4, 5, 10, 11, 30, 31, 32, 52, 53, 57, 58, 87, 88, 89, 90, 91, 92, 100, 109, 113, 114, 115, 116} ARC_THRUST, ARC_NORMAL = {10, 11, 53}, {4, 5, 52} ARC_CONCEALED = {32, 52, 53, 57, 58, 90, 92, 100, 115, 116} def load_usgs_state(poly_shp, arc_shp, name, simplify_m=30): g = _clean(_read(poly_shp), "EPSG:5070", simplify_m) g = g[~g["ORIG_LABEL"].astype(str).str.lower().isin(["water", "h2o"])].reset_index(drop=True) units, tab = build_units(g, "ORIG_LABEL", "ORIG_LABEL", "UNIT_AGE", lambda d: d["ROCKTYPE1"].fillna("").astype(str) + " " + d["ROCKTYPE2"].fillna("").astype(str)) a = _read(arc_shp, columns=["ARC_CODE"]).to_crs("EPSG:5070") a = a[a["ARC_CODE"].isin(ARC_FAULT)].reset_index(drop=True) a["kind"] = np.where(a.ARC_CODE.isin(ARC_THRUST), "thrust", np.where(a.ARC_CODE.isin(ARC_NORMAL), "normal", "generic")) a["concealed"] = a.ARC_CODE.isin(ARC_CONCEALED) return Source(name, "North America", units, tab, a[["kind", "concealed", "geometry"]], (80, 380), min_land=0.8) # ===================================================================================== # RASTERISATION D'UNE FENÊTRE # ===================================================================================== def raster_units(src, x0, y1, px, n): """Carte des uid (n x n) d'une fenêtre ; ordre de peinture respecté (jeune par-dessus).""" tr = from_origin(x0, y1, px, px) win = box(x0, y1 - n * px, x0 + n * px, y1) idx = src.units.sindex.query(win, predicate="intersects") if len(idx) == 0: return np.zeros((n, n), np.int32), win sel = src.units.iloc[idx] if sel["order"].nunique() > 1: sel = sel.sort_values("order", kind="stable") U = rasterize(zip(sel.geometry.values, sel.uid.values), out_shape=(n, n), transform=tr, fill=0, dtype="int32") return U, win def fault_lines_px(src, win, x0, y1, px, rng=None): """Failles de la fenêtre en coordonnées pixel (à l'échelle px).""" out = [] if src.faults is None or not len(src.faults): return out f = src.faults.iloc[src.faults.sindex.query(win.buffer(px * 4), predicate="intersects")] for geom, kind, conc in zip(f.geometry.values, f["kind"].values, f["concealed"].values): geom = geom.intersection(win.buffer(px * 4)) for line in getattr(geom, "geoms", [geom]): if line.geom_type != "LineString" or line.length < px: continue xy = np.asarray(line.coords)[:, :2] out.append(((xy[:, 0] - x0) / px, (y1 - xy[:, 1]) / px, kind, bool(conc))) return out def instances(U): """Composantes connexes d'une même unité -> instances (0 = vide).""" inst = cc_label(U, background=0, connectivity=1).astype(np.int32) return inst def faults_gt(lines, scale=1.0, n=TILE): img = Image.new("L", (n, n), 0) d = ImageDraw.Draw(img) for xs, ys, _, _ in lines: pts = list(zip(xs * scale, ys * scale)) if len(pts) > 1: d.line(pts, fill=1, width=1) return np.asarray(img, np.uint8) # ===================================================================================== # RENDU "CARTE GÉOLOGIQUE IMPRIMÉE" # ===================================================================================== SEA_WORDS = ["PACIFIC OCEAN", "ATLANTIC OCEAN", "SEA", "GULF", "BAY", "BASIN", "LAKE", "STRAIT", "OCEAN", "INDIAN OCEAN", "CORAL SEA", "MER", "GOLFE", "LAC", "SOUND", "CHANNEL", "TROUGH", "ABYSSAL PLAIN"] LAND_WORDS = ["MOUNTAINS", "PLATEAU", "RANGE", "BASIN", "SHIELD", "PLAIN", "DESERT", "VALLEY", "HIGHLANDS", "MASSIF"] SYL = ["ka", "ri", "mo", "ton", "ber", "ville", "lin", "sa", "na", "port", "ford", "dor", "ve", "la", "mar", "zan", "gu", "el", "ash", "wa", "bur", "go", "ta", "ne", "kel", "an", "os", "ru", "mi", "hol"] def _rname(rng, k=None): k = k or rng.integers(2, 4) return "".join(rng.choice(SYL) for _ in range(k)).capitalize() def edition(rng): """Style d'une 'édition' de carte (tiré à chaque tuile).""" e = {} e["palette"] = "legend" if rng.random() < 0.8 else "random" e["light"] = rng.uniform(0.0, 0.4) e["sat"] = rng.uniform(0.7, 1.1) e["hue"] = rng.uniform(-0.03, 0.03) e["jit"] = rng.uniform(0.01, 0.06) e["sea"] = [(228, 229, 238), (214, 233, 245), (255, 255, 255), (236, 240, 232), (200, 222, 240)][rng.integers(5)] e["contacts"] = rng.random() > 0.06 e["c_w"] = int(rng.choice([1, 2, 2, 2, 3])) # en px internes (x2) e["c_col"] = tuple(int(v) for v in rng.integers(20, 80, 3)) e["c_dash"] = rng.uniform(0, 0.15) e["coast"] = rng.random() < 0.85 e["coast_col"] = (int(rng.integers(40, 110)), int(rng.integers(140, 190)), int(rng.integers(200, 240))) e["f_w"] = int(rng.choice([3, 4, 5, 6])) e["f_col"] = (0, 0, 0) if rng.random() < 0.75 else ((int(rng.integers(150, 220)), 0, 0) if rng.random() < .7 else (60, 60, 60)) e["pattern_p"] = rng.uniform(0.05, 0.35) e["label_p"] = rng.uniform(0.3, 0.95) if rng.random() < 0.9 else 0.0 e["label_font"] = rng.choice(["sans", "sans", "bold", "serif", "ital"]) e["label_size"] = rng.uniform(11, 22) e["label_col"] = tuple(int(v) for v in rng.integers(0, 70, 3)) e["scan"] = rng.random() < 0.35 return e def _palette(src, uids, e, rng, ed_seed): lut = {} if e["palette"] == "random": # couleurs bien séparées, attribuées au hasard (le réseau n'apprend pas "couleur = unité") n = max(len(uids), 1) style = rng.choice(["pastel", "vif", "moyen"]) s_lo, s_hi, v_lo, v_hi = {"pastel": (0.25, 0.45, 0.85, 0.97), "vif": (0.5, 0.75, 0.8, 0.95), "moyen": (0.35, 0.65, 0.65, 0.9)}[style] off = rng.random() hues = [(off + i / n) % 1.0 for i in range(n)] rng.shuffle(hues) for i, (u, h) in enumerate(zip(uids, hues)): v = v_hi if i % 2 == 0 else v_lo lut[u] = np.array(colorsys.hsv_to_rgb(h, rng.uniform(s_lo, s_hi), v), np.float32) * 255 return lut for u in uids: r = np.random.default_rng(_seed(ed_seed, src.name, u)) h, s, v = colorsys.rgb_to_hsv(*(src.lut_rgb[u] / 255)) h = (h + e["hue"] + r.normal(0, e["jit"] * 0.5)) % 1 s = np.clip(s * e["sat"] * r.uniform(1 - e["jit"] * 3, 1 + e["jit"] * 2), 0, 1) v = np.clip(v * r.uniform(1 - e["jit"] * 2, 1 + e["jit"]), 0, 1) c = np.array(colorsys.hsv_to_rgb(h, s, v), np.float32) * 255 lut[u] = _mix(c, (255, 255, 255), np.clip(e["light"] + r.normal(0, 0.05), 0, 0.7)) return lut def _glyph_tile(kind, s, rng): """Motif élémentaire (s x s) répété par np.tile -> masque booléen R x R.""" im = Image.new("L", (s, s), 0) d = ImageDraw.Draw(im) c, k = s / 2, s * rng.uniform(0.18, 0.3) if kind == "dots": r = max(1.2, s * rng.uniform(0.07, 0.14)) d.ellipse([c - r, c - r, c + r, c + r], fill=1) elif kind == "v": d.line([(c - k, c - k), (c, c + k), (c + k, c - k)], fill=1, width=2) elif kind == "tri": d.polygon([(c - k, c + k), (c + k, c + k), (c, c - k)], fill=1) elif kind == "cross": d.line([(c - k, c), (c + k, c)], fill=1, width=2) d.line([(c, c - k), (c, c + k)], fill=1, width=2) elif kind == "dash": d.line([(c - k, c), (c + k, c)], fill=1, width=2) m = np.asarray(im, bool) m2 = np.concatenate([m, np.roll(m, s // 2, axis=1)], 0) # rangées décalées full = np.tile(m2, (R // (2 * s) + 2, R // s + 2)) oy, ox = rng.integers(0, 2 * s), rng.integers(0, s) return full[oy:oy + R, ox:ox + R] def _pattern_mask(kind, rng): yy, xx = np.mgrid[:R, :R] if kind == "lines": per, w = rng.integers(14, 30), rng.integers(2, 4) a = rng.choice([np.pi / 4, -np.pi / 4, 0, np.pi / 2, np.pi / 3]) return ((xx * np.cos(a) + yy * np.sin(a)) % per) < w if kind == "grid": per = rng.integers(18, 34) return ((xx % per) < 2) | ((yy % per) < 2) return _glyph_tile(kind, int(rng.integers(14, 30)), rng) def _resample(xs, ys, step): seg = np.hypot(np.diff(xs), np.diff(ys)) L = np.concatenate([[0], np.cumsum(seg)]) if L[-1] < step: return None t = np.arange(0, L[-1], step) return np.interp(t, L, xs), np.interp(t, L, ys) def _draw_fault(d, xs, ys, kind, concealed, w, col, rng, side): pts = list(zip(xs, ys)) if concealed: rs = _resample(xs, ys, 3) if rs is None: return X, Y = rs on, off = (8, 6) if rng.random() < 0.6 else (2, 4) i = 0 while i < len(X) - 1: j = min(i + on, len(X) - 1) d.line(list(zip(X[i:j + 1], Y[i:j + 1])), fill=col, width=max(2, w - 1)) i = j + off else: d.line(pts, fill=col, width=w, joint="curve") if kind in ("thrust", "normal"): rs = _resample(xs, ys, 2) if rs is None: return X, Y = rs gap = int(rng.integers(14, 24)) if kind == "thrust" else int(rng.integers(30, 50)) for i in range(gap // 2, len(X) - 3, gap): tx, ty = X[i + 2] - X[i], Y[i + 2] - Y[i] n = math.hypot(tx, ty) or 1 tx, ty = tx / n, ty / n nx, ny = -ty * side, tx * side h = w * 1.9 if kind == "thrust": d.polygon([(X[i] - tx * h * .7, Y[i] - ty * h * .7), (X[i] + tx * h * .7, Y[i] + ty * h * .7), (X[i] + nx * h * 1.3, Y[i] + ny * h * 1.3)], fill=col) else: ex, ey = X[i] + nx * h * 1.6, Y[i] + ny * h * 1.6 d.line([(X[i], Y[i]), (ex, ey)], fill=col, width=max(2, w // 2)) r = w * 0.8 d.ellipse([ex - r, ey - r, ex + r, ey + r], fill=col) def _random_curve(rng, wiggle=0.12, step=6): side = rng.integers(4) p = rng.uniform(0, R) x, y, a = [(p, 0, np.pi / 2), (R, p, np.pi), (p, R, -np.pi / 2), (0, p, 0)][side] a += rng.uniform(-0.7, 0.7) xs, ys, da = [x], [y], 0.0 for _ in range(4 * R // step): da = 0.85 * da + rng.normal(0, wiggle) a += da * 0.3 x, y = x + step * np.cos(a), y + step * np.sin(a) xs.append(x); ys.append(y) if not (-20 < x < R + 20 and -20 < y < R + 20): break return np.array(xs), np.array(ys) def _dashed(d, xs, ys, col, w, on, off): rs = _resample(xs, ys, 2) if rs is None: return X, Y = rs i = 0 while i < len(X) - 1: j = min(i + on, len(X) - 1) d.line(list(zip(X[i:j + 1], Y[i:j + 1])), fill=col, width=w) i = j + off def _spaced(t): return " ".join(t) if len(t) < 12 else t def render_map(src, U, lines, rng, px_m): """U : uid (R x R) ; lines : failles en px internes. Retourne l'image RGB uint8 (TILE x TILE).""" e = edition(rng) ed_seed = int(rng.integers(1 << 30)) uids = [int(u) for u in np.unique(U) if u > 0] lut = _palette(src, uids, e, rng, ed_seed) LUT = np.zeros((max(uids + [0]) + 1, 3), np.float32) LUT[0] = e["sea"] for u, c in lut.items(): LUT[u] = c img = LUT[U] land = U > 0 # --- motifs (pointillés, hachures, V volcaniques, croix plutoniques, triangles) masks = {} for u in uids: pref = src.pref.get(u) r = np.random.default_rng(_seed(ed_seed, "pat", u)) p = e["pattern_p"] * (2.2 if pref else 1) if r.random() > p: continue kind = pref if (pref and r.random() < 0.7) else r.choice(["dots", "lines", "lines", "v", "tri", "dash", "grid", "cross"]) if kind not in masks: masks[kind] = _pattern_mask(kind, rng) m = (U == u) & masks[kind] if kind == "tri" and r.random() < 0.5: col = np.array([r.integers(180, 240), r.integers(0, 60), r.integers(40, 100)], np.float32) elif r.random() < 0.3: col = np.array([r.integers(120, 180), r.integers(60, 110), r.integers(20, 60)], np.float32) else: col = LUT[u] * r.uniform(0.45, 0.75) img[m] = col # --- contacts géologiques if e["contacts"]: b = np.zeros_like(land) b[:, 1:] |= U[:, 1:] != U[:, :-1] b[1:, :] |= U[1:, :] != U[:-1, :] b &= land | np.roll(land, 1, 0) | np.roll(land, 1, 1) coast = np.zeros_like(land) coast[:, 1:] |= land[:, 1:] != land[:, :-1] coast[1:, :] |= land[1:, :] != land[:-1, :] b &= ~coast if e["c_w"] > 1: b = ndi.binary_dilation(b, iterations=e["c_w"] - 1) if e["c_dash"] > 0.02: dashed_units = [u for u in uids if np.random.default_rng(_seed(ed_seed, "d", u)).random() < e["c_dash"]] if dashed_units: yy, xx = np.mgrid[:R, :R] dz = ndi.binary_dilation(np.isin(U, dashed_units), iterations=2) b &= ~(dz & (((xx + yy) // 10) % 2 == 0)) img[b] = e["c_col"] if e["coast"]: cw = int(rng.integers(2, 5)) img[ndi.binary_dilation(coast, iterations=cw - 1) if cw > 1 else coast] = e["coast_col"] sea_frac = 1 - land.mean() im = Image.fromarray(np.clip(img, 0, 255).astype(np.uint8)) d = ImageDraw.Draw(im) # --- mer : isobathes + grands noms bleus if sea_frac > 0.1 and rng.random() < 0.6: noise = ndi.gaussian_filter(rng.normal(size=(R // 8, R // 8)), rng.uniform(3, 7)) noise = ndi.zoom(noise, 8, order=1) col = (int(rng.integers(90, 160)), int(rng.integers(170, 210)), int(rng.integers(215, 245))) for lev in np.quantile(noise, rng.uniform(0.2, 0.8, rng.integers(1, 4))): for c in find_contours(noise, lev): if len(c) < 30: continue keep = ~land[np.clip(c[:, 0].astype(int), 0, R - 1), np.clip(c[:, 1].astype(int), 0, R - 1)] c = c[keep] if len(c) > 30: _dashed(d, c[:, 1], c[:, 0], col, 2, 10, 6) if rng.random() < .5 else d.line(list(zip(c[:, 1], c[:, 0])), fill=col, width=2) if sea_frac > 0.25 and rng.random() < 0.6: ys, xs = np.nonzero(~land[::16, ::16]) if len(ys): k = rng.integers(len(ys)) t = rng.choice(SEA_WORDS) t = _spaced(t) if rng.random() < .7 else t f = font(rng.choice(["bital", "serifi", "ital"]), rng.uniform(30, 70)) d.text((xs[k] * 16 - rng.uniform(0, 300), ys[k] * 16), t, font=f, fill=(int(rng.integers(20, 80)), int(rng.integers(80, 140)), int(rng.integers(170, 220)))) # --- graticule (méridiens / parallèles) + degrés for _ in range(rng.integers(0, 3)): col = tuple(int(v) for v in (rng.integers(0, 90, 3) if rng.random() < .6 else (rng.integers(150, 210), 120, rng.integers(150, 210)))) a, b2 = rng.uniform(0, R, 2) if rng.random() < 0.5: d.line([(a, 0), (b2, R)], fill=col, width=int(rng.integers(1, 3))) lab_xy = (a + 6, rng.uniform(20, R - 40)) else: d.line([(0, a), (R, b2)], fill=col, width=int(rng.integers(1, 3))) lab_xy = (rng.uniform(20, R - 80), a + 6) if rng.random() < 0.5: d.text(lab_xy, f"{rng.integers(0, 180)}°", font=font("bold", rng.uniform(22, 40)), fill=col) # --- rivières if rng.random() < 0.55: col = (int(rng.integers(60, 130)), int(rng.integers(150, 200)), int(rng.integers(210, 245))) for _ in range(rng.integers(1, 5)): xs, ys = _random_curve(rng, wiggle=0.2, step=5) d.line(list(zip(xs, ys)), fill=col, width=int(rng.integers(2, 4)), joint="curve") # --- frontières politiques (tirets colorés) if rng.random() < 0.35: col = [(200, 120, 200), (170, 110, 60), (150, 90, 170), (230, 150, 60), (120, 120, 120)][rng.integers(5)] xs, ys = _random_curve(rng, wiggle=0.08, step=8) _dashed(d, xs, ys, col, int(rng.integers(4, 9)), int(rng.integers(8, 20)), int(rng.integers(4, 10))) # --- failles for xs, ys, kind, conc in lines: r = np.random.default_rng(_seed(ed_seed, "f", round(float(xs[0]), 1), round(float(ys[0]), 1))) if kind == "generic" and r.random() < 0.15: kind = r.choice(["thrust", "normal"]) _draw_fault(d, xs, ys, kind, conc, e["f_w"], e["f_col"], r, 1 if r.random() < .5 else -1) # --- étiquettes d'unités (au point le plus intérieur de chaque instance, + traits de rappel) if e["label_p"] > 0 and uids: inst = cc_label(U, background=0, connectivity=1) n = inst.max() if n: dist = ndi.distance_transform_edt(inst > 0) idx = np.arange(1, n + 1) pos = ndi.maximum_position(dist, inst, idx) val = ndi.maximum(dist, inst, idx) uid_of = ndi.maximum(U, inst, idx) fs = int(e["label_size"] * SS) f = font(e["label_font"], fs) placed = [] for (py, px), v, u in zip(pos, val, uid_of): if rng.random() > e["label_p"]: continue t = str(src.codes.get(int(u), ""))[:8] if not t or t == "nan": continue if e["label_font"] == "bold" and rng.random() < .3: t = t.upper() tw = d.textlength(t, font=f) if v > fs * 0.8: x, y = px - tw / 2, py - fs / 2 elif v > 3 and rng.random() < 0.35: ang = rng.uniform(0, 2 * np.pi) L = rng.uniform(25, 60) x, y = px + L * np.cos(ang), py + L * np.sin(ang) d.line([(px, py), (x, y + fs / 2)], fill=e["label_col"], width=2) else: continue bb = (x - 2, y - 2, x + tw + 2, y + fs + 2) if any(not (bb[2] < q[0] or bb[0] > q[2] or bb[3] < q[1] or bb[1] > q[3]) for q in placed): continue placed.append(bb) if rng.random() < 0.15: # halo blanc d.text((x, y), t, font=f, fill=e["label_col"], stroke_width=3, stroke_fill=(255, 255, 255)) else: d.text((x, y), t, font=f, fill=e["label_col"]) # --- villes et grands noms de régions (distracteurs) for _ in range(rng.integers(0, 4)): x, y = rng.uniform(20, R - 200), rng.uniform(20, R - 40) d.ellipse([x - 5, y - 5, x + 5, y + 5], fill=(0, 0, 0), outline=(255, 255, 255)) d.text((x + 10, y - 14), _rname(rng), font=font(rng.choice(["sans", "ital"]), rng.uniform(18, 26)), fill=(20, 20, 20)) if rng.random() < 0.15: t = _spaced(rng.choice(LAND_WORDS)) d.text((rng.uniform(0, R / 2), rng.uniform(0, R - 60)), t, font=font("bold", rng.uniform(28, 50)), fill=(int(rng.integers(80, 140)), int(rng.integers(50, 90)), int(rng.integers(20, 60)))) # --- réduction x2 (anti-crénelage d'impression) im = im.resize((TILE, TILE), Image.LANCZOS if rng.random() < .5 else Image.BOX) # --- impression / numérisation if e["scan"]: a = np.asarray(im, np.float32) paper = np.array([rng.uniform(238, 255), rng.uniform(230, 252), rng.uniform(205, 240)], np.float32) / 255 a = a * paper gy, gx = np.mgrid[:TILE, :TILE] / TILE a *= (1 - rng.uniform(0, 0.08) * (rng.uniform(-1, 1) * gx + rng.uniform(-1, 1) * gy))[..., None] a = ndi.gaussian_filter(a, (rng.uniform(0.2, 0.9),) * 2 + (0,)) a = 255 * (np.clip(a, 0, 255) / 255) ** rng.uniform(0.85, 1.15) a += rng.normal(0, rng.uniform(0.5, 4), a.shape) if rng.random() < 0.2: ch = rng.integers(3) a[..., ch] = np.roll(a[..., ch], rng.choice([-1, 1]), axis=rng.integers(2)) im = Image.fromarray(np.clip(a, 0, 255).astype(np.uint8)) q = int(rng.integers(50, 92)) else: q = int(rng.integers(80, 98)) if rng.random() < .5 else None if q: buf = io.BytesIO() im.save(buf, "JPEG", quality=q) im = Image.open(buf).convert("RGB") return np.asarray(im, np.uint8), {k: (v if isinstance(v, (int, float, str, bool)) else str(v)) for k, v in e.items()} # ===================================================================================== # ÉCHANTILLONNAGE SPATIAL (split train / val / test par blocs géographiques) # ===================================================================================== class BlockSplit: def __init__(self, src, block_m, seed, val=0.1, test=0.1, min_land=0.3): x0, y0, x1, y1 = src.units.total_bounds self.x0, self.y0, self.b = x0, y0, block_m nx, ny = int(np.ceil((x1 - x0) / block_m)), int(np.ceil((y1 - y0) / block_m)) rng = np.random.default_rng(seed) # part de terre de chaque bloc, sur un masque grossier (5 km) cell = 5000.0 k = int(round(block_m / cell)) mask = rasterize(((g, 1) for g in src.units.geometry.values), out_shape=(ny * k, nx * k), transform=from_origin(x0, y0 + ny * block_m, cell, cell), fill=0, dtype="uint8") frac = mask.reshape(ny, k, nx, k).mean(axis=(1, 3))[::-1] # ligne 0 = sud land = [(i, j) for i in range(nx) for j in range(ny) if frac[j, i] >= min_land] order = rng.permutation(len(land)) n_val, n_test = max(1, round(val * len(land))), max(1, round(test * len(land))) self.split = {} for k, o in enumerate(order): self.split[land[o]] = "validation" if k < n_val else ("test" if k < n_val + n_test else "train") self.blocks = {s: [b for b, v in self.split.items() if v == s] for s in ("train", "validation", "test")} def window_split(self, x0, y0, x1, y1): i0, i1 = int((x0 - self.x0) // self.b), int((x1 - self.x0) // self.b) j0, j1 = int((y0 - self.y0) // self.b), int((y1 - self.y0) // self.b) s = {self.split.get((i, j), "none") for i in range(i0, i1 + 1) for j in range(j0, j1 + 1)} s.discard("none") return s.pop() if len(s) == 1 else None def synth_tile(src, bs, split, rng, max_tries=60): """Tire une fenêtre entièrement contenue dans des blocs du split demandé, et la rend.""" lo, hi = src.px_range for _ in range(max_tries): hi_eff = min(hi, 0.9 * bs.b / TILE) # la fenêtre doit pouvoir tenir dans un bloc px = float(np.exp(rng.uniform(np.log(min(lo, hi_eff)), np.log(hi_eff)))) ext = TILE * px bi, bj = bs.blocks[split][rng.integers(len(bs.blocks[split]))] if rng.random() < 0.5: # entièrement dans le bloc tiré x0 = bs.x0 + bi * bs.b + rng.random() * (bs.b - ext) y1 = bs.y0 + bj * bs.b + ext + rng.random() * (bs.b - ext) else: # libre (peut déborder sur des blocs du même split) cx = bs.x0 + (bi + rng.random()) * bs.b cy = bs.y0 + (bj + rng.random()) * bs.b x0, y1 = cx - rng.uniform(0.1, 0.9) * ext, cy + rng.uniform(0.1, 0.9) * ext if bs.window_split(x0, y1 - ext, x0 + ext, y1) != split: continue U, win = raster_units(src, x0, y1, px / SS, R) land = (U > 0).mean() if land < src.min_land: continue nu = len(np.unique(U[U > 0])) if nu < 2 or (nu < 4 and rng.random() < 0.6): continue lines = fault_lines_px(src, win, x0, y1, px / SS) rgb, ed = render_map(src, U, lines, rng, px) Uf = U[SS // 2::SS, SS // 2::SS] inst = instances(Uf) flt = faults_gt(lines, 1 / SS) meta = {"bounds": [x0, y1 - ext, x0 + ext, y1], "px_size_m": px, "edition": ed} return rgb, inst, Uf, flt, meta return None def inst_units(src, inst, Uf): """Pour chaque instance : son unité (code, âge, lithologie).""" n = int(inst.max()) if n == 0: return {} uid = ndi.maximum(Uf, inst, np.arange(1, n + 1)).astype(int) return {str(i + 1): src.unit_meta(u) for i, u in enumerate(uid)} # ===================================================================================== # ENCODAGE (format publiable : PNG dans Parquet) # ===================================================================================== def png_bytes(arr, mode=None): buf = io.BytesIO() if arr.dtype == np.uint16 or mode == "I;16": Image.fromarray(arr.astype(np.uint16)).save(buf, "PNG", optimize=False) else: Image.fromarray(arr).save(buf, "PNG", optimize=False) return buf.getvalue() def make_record(tid, source, continent, kind, split, crs, rgb, inst, flt, meta, units): if inst.max() > 65535: raise ValueError("trop d'instances") return { "id": tid, "source": source, "continent": continent, "kind": kind, "split": split, "image": {"bytes": png_bytes(rgb), "path": f"{tid}.png"}, "instances": {"bytes": png_bytes(inst.astype(np.uint16)), "path": f"{tid}_inst.png"}, "faults": {"bytes": png_bytes((flt > 0).astype(np.uint8) * 255), "path": f"{tid}_faults.png"}, "n_instances": int(inst.max()), "land_fraction": float((inst > 0).mean()), "fault_pixels": int((flt > 0).sum()), "px_size_m": float(meta["px_size_m"]), "crs": str(crs), "bounds": [float(v) for v in meta["bounds"]], "units": json.dumps(units, ensure_ascii=False), "render": json.dumps(meta.get("edition", {}), ensure_ascii=False), } # ===================================================================================== # CONSTRUCTION DU DATASET UNIQUE (réel + synthétique, 4 continents) -> Parquet # ===================================================================================== import os, time, multiprocessing as mp import pyarrow as pa import pyarrow.parquet as pq import rasterio from rasterio.windows import Window SPLITS = ("train", "validation", "test") _IMG = pa.struct([("bytes", pa.binary()), ("path", pa.string())]) _FIELDS = [("id", pa.string()), ("source", pa.string()), ("continent", pa.string()), ("kind", pa.string()), ("split", pa.string()), ("image", _IMG), ("instances", _IMG), ("faults", _IMG), ("n_instances", pa.int32()), ("land_fraction", pa.float32()), ("fault_pixels", pa.int32()), ("px_size_m", pa.float32()), ("crs", pa.string()), ("bounds", pa.list_(pa.float64())), ("units", pa.string()), ("render", pa.string())] def arrow_schema(): """Schéma Parquet + métadonnées 'huggingface' (le viewer HF affiche alors les images).""" try: from datasets import Features, Value, Image as HFImage, Sequence f = Features({"id": Value("string"), "source": Value("string"), "continent": Value("string"), "kind": Value("string"), "split": Value("string"), "image": HFImage(), "instances": HFImage(), "faults": HFImage(), "n_instances": Value("int32"), "land_fraction": Value("float32"), "fault_pixels": Value("int32"), "px_size_m": Value("float32"), "crs": Value("string"), "bounds": Sequence(Value("float64")), "units": Value("string"), "render": Value("string")}) return f.arrow_schema except Exception as ex: print("datasets indisponible, schéma sans métadonnées HF :", ex) return pa.schema(_FIELDS) class ShardWriter: def __init__(self, out_dir, shard_rows=500): self.dir = Path(out_dir) / "data" self.dir.mkdir(parents=True, exist_ok=True) self.schema, self.n = arrow_schema(), shard_rows self.buf = {s: [] for s in SPLITS} self.k = {s: 0 for s in SPLITS} self.count = {s: 0 for s in SPLITS} self.index = [] def add(self, rec): s = rec["split"] self.buf[s].append(rec) self.count[s] += 1 self.index.append({k: rec[k] for k in ("id", "source", "continent", "kind", "split", "n_instances", "land_fraction", "fault_pixels", "px_size_m")}) if len(self.buf[s]) >= self.n: self.flush(s) def flush(self, s): if not self.buf[s]: return cols = {name: [r[name] for r in self.buf[s]] for name in self.schema.names} tbl = pa.Table.from_pydict(cols, schema=self.schema) pq.write_table(tbl, self.dir / f"{s}-{self.k[s]:05d}.parquet", compression="zstd") self.k[s] += 1 self.buf[s] = [] def close(self): for s in SPLITS: self.flush(s) df = pd.DataFrame(self.index) df.to_csv(self.dir.parent / "index.csv", index=False) return df def real_tiles(raster_path, src, bs, name, writer, easy_frac=0.2, min_cover=0.5, seed=0): """Tuiles réelles (scan + vecteurs alignés), grille sans recouvrement, split par blocs géographiques.""" t0 = time.time() rng = np.random.default_rng(seed) with rasterio.open(raster_path) as s: cands = [] for r in range(0, s.height - TILE + 1, TILE): for c in range(0, s.width - TILE + 1, TILE): win = Window(c, r, TILE, TILE) x0, y0, x1, y1 = rasterio.windows.bounds(win, s.transform) split = bs.window_split(x0, y0, x1, y1) if split is None: continue rgb = np.transpose(s.read([1, 2, 3], window=win), (1, 2, 0)) if rgb.mean() > 248 or rgb.mean() < 5: continue tr = rasterio.windows.transform(win, s.transform) U, w = raster_units(src, tr.c, tr.f, tr.a, TILE) if (U > 0).mean() < min_cover: continue nu = len(np.unique(U[U > 0])) lines = fault_lines_px(src, w, tr.c, tr.f, tr.a) nf = int(faults_gt(lines, 1.0).sum()) cands.append((r, c, split, nu >= 3 or nf > 30)) rich = [k for k in cands if k[3]] easy = [k for k in cands if not k[3]] n_easy = min(len(easy), int(round(easy_frac / (1 - easy_frac) * len(rich)))) easy = [easy[i] for i in rng.choice(len(easy), n_easy, replace=False)] if n_easy else [] n = {sp: 0 for sp in SPLITS} for r, c, split, _ in rich + easy: win = Window(c, r, TILE, TILE) tr = rasterio.windows.transform(win, s.transform) rgb = np.ascontiguousarray(np.transpose(s.read([1, 2, 3], window=win), (1, 2, 0))) U, w = raster_units(src, tr.c, tr.f, tr.a, TILE) lines = fault_lines_px(src, w, tr.c, tr.f, tr.a) inst, flt = instances(U), faults_gt(lines, 1.0) meta = {"bounds": list(rasterio.windows.bounds(win, s.transform)), "px_size_m": abs(tr.a), "edition": {"raster": Path(raster_path).name, "row": r, "col": c}} writer.add(make_record(f"{name}_r{r}_c{c}", src.name, src.continent, "real", split, src.crs, rgb, inst, flt, meta, inst_units(src, inst, U))) n[split] += 1 print(f" {name} : {sum(n.values())} tuiles réelles {n} en {time.time() - t0:.0f} s", flush=True) return n _SOURCES, _SPLITTERS = {}, {} def _synth_job(job): name, split, i, seed = job src, bs = _SOURCES[name], _SPLITTERS[name] rng = np.random.default_rng(seed) for _ in range(30): res = synth_tile(src, bs, split, rng) if res is not None: rgb, inst, Uf, flt, meta = res tid = f"{src.name}_synth_{split}_{i:05d}" return make_record(tid, src.name, src.continent, "synthetic", split, src.crs, rgb, inst, flt, meta, inst_units(src, inst, Uf)) return None def build_synthetic(sources, splitters, counts, writer, val=0.1, test=0.1, seed=2026, workers=None): _SOURCES.update(sources) _SPLITTERS.update(splitters) jobs = [] for name, n in counts.items(): if name not in sources: continue per = {"validation": int(round(n * val)), "test": int(round(n * test))} per["train"] = n - per["validation"] - per["test"] for split, k in per.items(): jobs += [(name, split, i, _seed(seed, name, split, i)) for i in range(k)] np.random.default_rng(seed).shuffle(jobs) workers = workers or os.cpu_count() t0, done, fail = time.time(), 0, 0 ctx = mp.get_context("fork") with ctx.Pool(workers) as pool: for rec in pool.imap_unordered(_synth_job, jobs, chunksize=4): if rec is None: fail += 1 continue writer.add(rec) done += 1 if done % 250 == 0: el = time.time() - t0 print(f" synthétique : {done}/{len(jobs)} ({el:.0f} s, reste ~{el / done * (len(jobs) - done):.0f} s)", flush=True) print(f" synthétique terminé : {done} tuiles, {fail} échecs, {time.time() - t0:.0f} s", flush=True) def decode(rec): """Ligne Parquet -> (rgb uint8 HxWx3, inst int32 HxW, faults uint8 HxW {0,1}). Utilisé à l'entraînement.""" rgb = np.asarray(Image.open(io.BytesIO(rec["image"]["bytes"])).convert("RGB")) inst = np.asarray(Image.open(io.BytesIO(rec["instances"]["bytes"]))).astype(np.int32) flt = (np.asarray(Image.open(io.BytesIO(rec["faults"]["bytes"]))) > 0).astype(np.uint8) return rgb, inst, flt