| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| 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 |
| R = TILE * SS |
|
|
| |
| _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()) |
|
|
|
|
| |
| 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 = [ |
| (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 |
|
|
|
|
| |
| |
| |
| 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"] |
|
|
|
|
| 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)) |
|
|
|
|
| |
| 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) |
|
|
|
|
| |
| |
| |
| 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) |
|
|
|
|
| |
| |
| |
| 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])) |
| 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": |
| 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) |
| 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 |
|
|
| |
| 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 |
|
|
| |
| 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) |
|
|
| |
| 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)))) |
|
|
| |
| 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) |
|
|
| |
| 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") |
|
|
| |
| 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))) |
|
|
| |
| 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) |
|
|
| |
| 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: |
| 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"]) |
|
|
| |
| 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)))) |
|
|
| |
| im = im.resize((TILE, TILE), Image.LANCZOS if rng.random() < .5 else Image.BOX) |
|
|
| |
| 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()} |
|
|
|
|
| |
| |
| |
| 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) |
| |
| 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] |
| 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) |
| 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: |
| x0 = bs.x0 + bi * bs.b + rng.random() * (bs.b - ext) |
| y1 = bs.y0 + bj * bs.b + ext + rng.random() * (bs.b - ext) |
| else: |
| 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)} |
|
|
|
|
| |
| |
| |
| 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), |
| } |
|
|
|
|
| |
| |
| |
| 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 |
|
|
