generation pipeline

code/README.md

@@ -0,0 +1,104 @@
+# `forge_mosaics/` — synthetic bench generation
+
+Turns a painting into a LEGO mosaic whose brick grid is known exactly, then
+fragments, corrupts and scatters it. Every label — instance masks, adjacencies,
+poses — is *derived* from the grid, never hand-annotated.
+
+```
+painting → forge_LAR_2mosaic → mosaic2fragments → features → tools
+           mosaic + grid       fragments + labels  GNN input  publish / QA
+```
+
+Python 3.11+, `pip install -r requirements.txt`. Run everything from the repository root.
+
+```
+forge_mosaics/
+├── forge_LAR_2mosaic/   palette · mosaic · cli · batch · wikiart · remono
+├── mosaic2fragments/    forge_dataset · curriculum · batch · visualize
+├── features/            fragment_features · collate
+└── tools/               hf_upload · hf_export_tars · qa_sample_hf · qa_overlays · qa_contact_sheets
+```
+
+## 1. `forge_LAR_2mosaic/` — painting → LEGO mosaic
+
+Clean-room, pure Python: Lab quantisation onto a LEGO palette, greedy tiling, render
+with grey joints. Outputs `canvas_mosaic_<id>.png` **and** `piece_grid_<id>.json`,
+the exact position and colour of every brick.
+
+| script | role |
+|---|---|
+| `palette.py` | 82 solid LEGO colours, **greys and silvers removed** — the joint detector downstream would take them for joints. Data table, no CLI. |
+| `mosaic.py` | the forge: square crop → Lab quantisation → greedy largest-monochrome-rectangle packing → render. Deterministic. Imported by all the others. |
+| `cli.py` | one image → one mosaic. |
+| `batch.py` | one folder of images → as many mosaics. |
+| `wikiart.py` | streams *N* images from `huggan/wikiart` through the forge, downloading nothing in full. `--max-dominant-frac` rejects near-monochrome paintings, which carry no cut signal. |
+| `remono.py` | re-forges an existing mosaic as **1×1** tiles from its `piece_grid.json`, without re-quantising. The id is kept, so both tilings stay paired. |
+
+```bash
+python3 forge_mosaics/forge_LAR_2mosaic/wikiart.py --n 5000 \
+    --out-dir output/inputs --grid 96 --mode tile --max-dominant-frac 0.55
+```
+
+## 2. `mosaic2fragments/` — mosaic → fragments and labels
+
+Joint detection → union-find over cells → pieces → adjacency graph → region growing
+**along the joints** (no piece is ever cut) → corruption → placement → export.
+
+| script | role |
+|---|---|
+| `forge_dataset.py` | the full pipeline on **one** mosaic; carries every knob: `--n-frag-min/max`, `--frag-distribution {balanced,compact,ultracompact}`, `--erode-px-min/max --holes-min/max --missing-min/max`, `--placement {scatter,explode}`, `--no-rotation`, `--max-area-loss`. |
+| `curriculum.py` | **the usual entry point.** Replays the *same* mosaics under the *same* seeds across the five levels `L0_explode → L4_strong`, so that only input difficulty varies. Parallel (`--jobs`), resumes where it stopped. |
+| `batch.py` | simpler driver: several mosaics or several seeds, no levels. |
+| `visualize.py` | visual checks: `source_yolo.txt` polygons repainted on `source.png`; with `--recob`, what contour encoding dropped as opposed to what corruption removed. |
+
+```bash
+python3 forge_mosaics/mosaic2fragments/curriculum.py \
+    --inputs-glob 'output/inputs/canvas_mosaic_*.png' \
+    --frag-distribution balanced --out output --jobs 6
+```
+
+Each instance is one `mosaic_<id>/` folder:
+
+| file | role |
+|---|---|
+| `source.png` | fragments scattered on a blank ground — segmentation and VLM **input** |
+| `graph_fragments.json` | nodes only, no edge, no pose — GNN **input** |
+| `source_yolo.txt` | one normalised polygon per fragment — segmentation ground truth |
+| `graph_complete.json` | the same nodes **plus** adjacency edges — GNN target |
+| `gt_layout.json` | exact footprint and pose of each fragment — scores the reconstruction |
+| `target.png` | the assembled mosaic |
+| `fragments/frag_XX.png` | one alpha crop per fragment |
+| `degradation.md` | corruption report (empty means clean) |
+
+> Edges are a **label read off the intact grid**, never re-derived from the corrupted
+> geometry: two eroded fragments no longer touch, and their adjacency would be lost —
+> exactly as two real shards no longer fit together.
+
+## 3. `features/` — descriptors and GNN input
+
+**Shared** between synthetic and real: works on a (mask, image) pair and knows nothing
+about LEGO, so the same code applies to a mask from the forge or one detected by YOLO
+on a fresco.
+
+| script | role |
+|---|---|
+| `fragment_features.py` | contour, simplification under an **area-loss budget** (`--max-area-loss`, 1 % — the polygon stays inscribed in the true outline and the vertex count is an *output*), PCA canonicalisation (rotation-invariant descriptor), then per-fragment and per-side geometric and colour features. |
+| `collate.py` | folds a dataset into one `gnn_ready.npz` per instance under **two contracts**: *dense* (padded to `n_max` + validity mask) and *ragged* (concatenated vertices + per-fragment start index, no `n_max`, for a length-agnostic encoder). Also writes `gnn_meta.json`; `--n-max` forces a value shared across datasets. |
+
+```bash
+for L in output/balanced/L*_*; do
+    python3 forge_mosaics/features/collate.py --dataset "$L"
+done
+```
+
+## 4. `tools/` — publishing and quality control
+
+All four Hub scripts take `--repo-id` and assume `huggingface-cli login`.
+
+| script | role |
+|---|---|
+| `hf_upload.py` | pushes a folder to the Hub as a dataset. For small volumes. |
+| `hf_export_tars.py` | for large ones: archives **one `.tar.gz` per level**, uploads it, deletes the local archive before the next (a full dataset exceeds the file count a browsable repo supports; peak disk stays one archive). Resumable. |
+| `qa_sample_hf.py` | samples ~1 % of each published dataset **without downloading the archives**: reads the HTTP stream and cuts the connection once *N* mosaics have gone by. The sample is an archive prefix — unbiased as to content, not as to generation order. |
+| `qa_overlays.py` | on that sample, repaints segmentation polygons and encoding loss, at constant content across levels. |
+| `qa_contact_sheets.py` | `target ǀ source` contact sheets and target-only grids: a bad placement, a degenerate mosaic or a repeated painting shows up at a glance. |

code/features/__init__.py

@@ -0,0 +1,18 @@
+"""Module post-YOLO / pré-GNN — PARTAGÉ entre forge synthétique et chaîne réelle.
+
+- fragment_features : (masque, image) → polygon_n (reco B + PCA), side_features, gnn_input.
+- collate          : dataset → n_max → padding + masque de validité → entrée GNN à dim fixe.
+"""
+from .fragment_features import (
+    extract_polygon,
+    resample_reflex_aware,
+    pca_canonical_rotation,
+    compute_fragment_features,
+)
+
+__all__ = [
+    "extract_polygon",
+    "resample_reflex_aware",
+    "pca_canonical_rotation",
+    "compute_fragment_features",
+]

code/features/collate.py

@@ -0,0 +1,177 @@
+"""Préparation des entrées GNN (post-YOLO / pré-GNN) — DEUX contrats dans le même npz.
+
+`polygon_n_canonical` et `side_features` ont une longueur VARIABLE par nœud
+(`n_sides`). La dimension fixe qu'exige le GNN porte sur l'**EMBEDDING de nœud**,
+pas sur le polygone brut → deux représentations livrées côte à côte :
+
+**(A) pad à n_max + masque** (`polygon_n_canonical`, `side_features`, `valid_mask`)
+— pour un modèle qui consomme des tenseurs denses. `n_max` est calculé sur
+l'ENSEMBLE du dataset. ⚠️ n_max varie par dataset → pas de transfert cross-dataset
+ni vers le réel (RePAIR : contours 403-1457 sommets).
+
+**(B) ragged** (`verts_flat`, `sides_flat`, `node_offsets`) — les MÊMES données
+SANS padding, concaténées sur l'axe des sommets ; le nœud i occupe la tranche
+`[node_offsets[i]:node_offsets[i+1]]`. C'est l'entrée naturelle d'un encodeur
+agnostique à la longueur (PointNet/Deep Sets : MLP partagé par sommet +
+scatter-pooling par segment — `torch_scatter.scatter_max(h, seg_ids)`), qui
+supprime n_max et rend le même modèle transférable LEGO↔réel.
+
+Numpy pur, sans dépendance torch (le wrap torch_geometric se fait côté GNN,
+ex. option A : `x = concat([gnn_input, poly.flatten(), sides.flatten()])`).
+
+Usage :
+    nodes_per_graph = [json.load(open(p))['nodes'] for p in graph_fragments_paths]
+    n_max = compute_n_max(nodes_per_graph)
+    padded = [[pad_node(n, n_max) for n in nodes] for nodes in nodes_per_graph]
+"""
+import argparse
+import glob
+import json
+import os
+
+import numpy as np
+
+
+def compute_n_max(nodes_per_graph):
+    """max(n_sides) sur tous les nœuds de tous les graphes (cible de padding)."""
+    return max((len(n["polygon_n_canonical"])
+                for nodes in nodes_per_graph for n in nodes), default=0)
+
+
+def pad_node(node, n_max):
+    """Renvoie les features du nœud à dimension fixe + masque de validité.
+
+    - gnn_input           : (7,)        inchangé (déjà fixe)
+    - polygon_n_canonical : (n_max, 2)  paddé à 0 au-delà de n_sides
+    - side_features       : (n_max, 5)  paddé à 0 au-delà de n_sides
+    - valid_mask          : (n_max,)    1.0 pour les vrais sommets, 0.0 pour le padding
+    """
+    poly = np.asarray(node["polygon_n_canonical"], dtype=np.float32)
+    sides = np.asarray(node["side_features"], dtype=np.float32)
+    n = len(poly)
+    if n > n_max:
+        raise ValueError(f"n_sides={n} > n_max={n_max} : recalculer n_max sur tout le dataset")
+    poly_p = np.zeros((n_max, 2), dtype=np.float32)
+    poly_p[:n] = poly
+    sides_p = np.zeros((n_max, 5), dtype=np.float32)
+    sides_p[:n] = sides
+    mask = np.zeros(n_max, dtype=np.float32)
+    mask[:n] = 1.0
+    return {
+        "gnn_input": np.asarray(node["gnn_input"], dtype=np.float32),
+        "polygon_n_canonical": poly_p,
+        "side_features": sides_p,
+        "valid_mask": mask,
+    }
+
+
+def write_dataset_readme(dataset_dir, n_max, n_graphs):
+    """README d'arborescence à la racine du dataset (auto-généré par collate)."""
+    name = os.path.basename(os.path.normpath(dataset_dir))
+    txt = f"""# `{name}/` — mosaïques LEGO fragmentées
+
+## Fichiers par mosaïque (`mosaic_<id>/`)
+| Fichier | Rôle |
+|---|---|
+| `target.png` | mosaïque **complète** = cible de reconstruction / contexte VLM |
+| `source.png` | fragments **éclatés** sur fond blanc = **entrée YOLO** (et entrée VLM) |
+| `source_yolo.txt` | **vérité terrain YOLO-Seg** : 1 polygone/fragment, normalisé `[0,1]` (entraîne YOLO avec `source.png`) |
+| `source_yolo_viz.png` | overlay debug des labels (inspection humaine) — *absent par défaut* (opt-in `--debug`) |
+| `pieces.json` | debug pur (pièces LEGO détectées) ; **n'entraîne PAS le YOLO** (c'est `source_yolo.txt`), lu nulle part — *absent par défaut* (opt-in `--debug`) |
+| `graph_fragments.json` | **ENTRÉE GNN** : nœuds (features/fragment), zéro arête, sans `target_info` |
+| `graph_complete.json` | **CIBLE GNN** : mêmes nœuds + `target_info` (leak) + arêtes (mating graph) |
+| `gt_layout.json` | **GT de RECONSTRUCTION** (réponse finale) : footprint exact + pose `(x,y,rot)` de chaque fragment dans `target.png`. Sert à **scorer l'assemblage** (IoU/Q_pos) APRÈS la tête de pose du GNN / le VLM qui place les fragments |
+| `gnn_ready.npz` | entrée GNN, **2 contrats** : (A) dense pad `n_max={n_max}`+masque ; (B) **ragged** `verts_flat`/`sides_flat`+`node_offsets` (sans n_max, pour encodeur agnostique) |
+| `degradation.md` | rapport de dégradation (0 si clean) |
+| `fragments/frag_XX.png` | crop alpha par fragment = **entrée VLM** |
+
+Au niveau dataset : **`gnn_meta.json`** (`n_max={n_max}`, noms de features).
+
+## Schéma d'un nœud (`graph_fragments.json`)
+| Bloc | Contenu | Taille |
+|---|---|---|
+| `node_id` | identifiant stable (référencé par les arêtes) | — |
+| `gnn_input` | `[area, perimeter, R, G, B, bbox_w, bbox_h]` — domaine-agnostique | 7 |
+| `polygon_n_canonical` | contour en repère **PCA canonique** (invariant rotation) | `n_sides`×2 |
+| `side_features` | par côté `[length, angle, R, G, B]` | `n_sides`×5 |
+
+`n_sides` **variable** par nœud → paddé à `n_max={n_max}` + masque dans `gnn_ready.npz`.
+⚠️ **`target_info`** (dans `graph_complete`) = vérité terrain → ne **jamais** donner en entrée.
+
+_Régénéré par `forge_mosaics/mosaic2fragments/{{batch,curriculum}}.py` + `forge_mosaics/features/collate.py`._
+"""
+    open(os.path.join(dataset_dir, "README.md"), "w", encoding="utf-8").write(txt)
+
+
+def build_dataset(dataset_dir, out_name="gnn_ready.npz", n_max=None):
+    """Étape COLLATE (post-YOLO / pré-GNN) : scanne tout le dataset, calcule n_max,
+    pad+masque chaque nœud, et écrit par mosaïque un `gnn_ready.npz` (entrée GNN à
+    dimension fixe) + un `gnn_meta.json` (n_max + schéma). Numpy pur : les amis
+    GNN chargent et wrappent en torch_geometric.Data eux-mêmes (les arêtes/cibles
+    restent dans graph_complete.json)."""
+    mosaics = sorted(glob.glob(os.path.join(dataset_dir, "mosaic_*")))
+    nodes_per = [json.load(open(os.path.join(m, "graph_fragments.json")))["nodes"]
+                 for m in mosaics]
+    observed = compute_n_max(nodes_per)
+    if n_max is None:
+        n_max = observed                     # auto : max du dataset (historique)
+    elif observed > n_max:                   # n_max JOINT imposé → doit couvrir
+        raise ValueError(f"--n-max {n_max} < max observé {observed} : "
+                         "choisir un n_max joint qui couvre ce dataset")
+    for m, nodes in zip(mosaics, nodes_per):
+        if not nodes:
+            continue
+        padded = [pad_node(n, n_max) for n in nodes]
+        # contrat B (ragged) : mêmes données sans padding, concaténées par sommet
+        lens = np.array([len(n["polygon_n_canonical"]) for n in nodes], dtype=np.int64)
+        np.savez(
+            os.path.join(m, out_name),
+            gnn_input=np.stack([p["gnn_input"] for p in padded]),               # (N,7)
+            polygon_n_canonical=np.stack([p["polygon_n_canonical"] for p in padded]),  # (N,n_max,2)
+            side_features=np.stack([p["side_features"] for p in padded]),       # (N,n_max,5)
+            valid_mask=np.stack([p["valid_mask"] for p in padded]),             # (N,n_max)
+            node_id=np.array([n["node_id"] for n in nodes], dtype=np.int64),    # (N,)
+            verts_flat=np.concatenate(                                          # (Σn,2) ragged
+                [np.asarray(n["polygon_n_canonical"], dtype=np.float32) for n in nodes]),
+            sides_flat=np.concatenate(                                          # (Σn,5) ragged
+                [np.asarray(n["side_features"], dtype=np.float32) for n in nodes]),
+            node_offsets=np.concatenate([[0], np.cumsum(lens)]),                # (N+1,)
+        )
+    sample = json.load(open(os.path.join(mosaics[0], "graph_fragments.json")))
+    meta = {
+        "n_max": n_max,
+        "n_max_observed": observed,          # max réel du dataset (≠ n_max si joint imposé)
+        "n_graphs": len(mosaics),
+        "gnn_input_dim": len(sample["gnn_input_feature_names"]),
+        "gnn_input_feature_names": sample["gnn_input_feature_names"],
+        "side_feature_names": sample["side_feature_names"],
+        "note": ("gnn_ready.npz par mosaïque, DEUX contrats : (A) dense = "
+                 "polygon_n_canonical/side_features paddés à n_max + valid_mask ; "
+                 "(B) ragged = verts_flat/sides_flat + node_offsets (nœud i = "
+                 "tranche [offsets[i]:offsets[i+1]]), SANS n_max — pour encodeur "
+                 "agnostique (PointNet/Deep Sets, scatter-pooling par segment). "
+                 "Cibles/arêtes : graph_complete.json. Régénérable via "
+                 "`python3 forge_mosaics/features/collate.py --dataset <dir>`."),
+    }
+    json.dump(meta, open(os.path.join(dataset_dir, "gnn_meta.json"), "w"),
+              indent=2, ensure_ascii=False)
+    write_dataset_readme(dataset_dir, n_max, len(mosaics))
+    return n_max
+
+
+def main():
+    p = argparse.ArgumentParser(description="Collate post-YOLO → tenseurs GNN à dim fixe")
+    p.add_argument("--dataset", required=True, help="dossier dataset (contient mosaic_*/)")
+    p.add_argument("--out-name", default="gnn_ready.npz")
+    p.add_argument("--n-max", type=int, default=None,
+                   help="n_max JOINT imposé (au lieu du max du dataset) : le même sur "
+                        "plusieurs paliers/datasets/le réel → un seul modèle pad+masque "
+                        "cross-datasets. Erreur si < max observé. Repère : RePAIR réel "
+                        "≤291 après reco-B ε=1 %% → 304 couvre LEGO et réel")
+    args = p.parse_args()
+    n_max = build_dataset(args.dataset, args.out_name, n_max=args.n_max)
+    print(f"[collate] {args.dataset} : n_max={n_max} → {args.out_name} par mosaïque + gnn_meta.json")
+
+
+if __name__ == "__main__":
+    main()

code/features/fragment_features.py

@@ -0,0 +1,264 @@
+"""Extraction de features par fragment — module PARTAGÉ (post-YOLO / pré-GNN).
+
+Domaine-agnostique : marche sur n'importe quel masque de fragment (+ image),
+qu'il vienne de la forge synthétique LEGO OU de YOLO sur une mosaïque réelle.
+C'est la garantie d'alignement de schéma entre synthétique et réel : le même
+code produit les mêmes features dans les deux chaînes.
+
+Contenu : contour, resample reflex-aware (reco B, polygon_n ⊆ polygon_raw),
+canonicalisation PCA (invariance en rotation), et features par fragment
+(géométrie + couleur de bord). Aucune dépendance LEGO ici (pas de studs, pas de
+grille) — aucune notion LEGO ici. Les bits LEGO/GT (adjacence grille, n_pieces en
+métadonnée) restent dans la forge.
+"""
+import numpy as np
+import cv2
+
+
+# ============================================================
+# Contour
+# ============================================================
+
+def extract_polygon(mask):
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return np.zeros((0, 2), dtype=np.float32)
+    cnt = max(contours, key=cv2.contourArea)
+    return cnt.reshape(-1, 2).astype(np.float32)
+
+
+# ============================================================
+# Resample reflex-aware (reco B) : polygon_n ⊆ polygon_raw
+# ============================================================
+
+def _polygon_signed_area(P):
+    x, y = P[:, 0], P[:, 1]
+    return 0.5 * float(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1)))
+
+
+def _classify_vertices(P):
+    """Per vertex: +1 convex, -1 reflex (concave), 0 ~collinear."""
+    M = len(P)
+    o = np.sign(_polygon_signed_area(P)) or 1.0
+    kind = np.zeros(M, dtype=int)
+    for i in range(M):
+        a, b, c = P[i - 1], P[i], P[(i + 1) % M]
+        cross = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
+        v = cross * o
+        kind[i] = 0 if abs(v) < 1e-6 else (1 if v > 0 else -1)
+    return kind
+
+
+def _clip_to_polygon(poly_enc, poly_raw):
+    """Safety clamp: intersect the encoded polygon with the real piece so that
+    polygon_n ⊆ polygon_raw is GUARANTEED even on a pathological contour.
+    No-op if shapely is unavailable (reflex-aware alone already gives ~0 gain)."""
+    try:
+        from shapely.geometry import Polygon
+    except Exception:
+        return poly_enc
+    C = Polygon(poly_enc).buffer(0).intersection(Polygon(poly_raw).buffer(0))
+    if C.geom_type == 'Polygon':
+        polys = [C]
+    elif C.geom_type in ('MultiPolygon', 'GeometryCollection'):
+        polys = [g for g in C.geoms if g.geom_type == 'Polygon' and not g.is_empty]
+    else:
+        polys = []
+    if not polys:
+        return poly_enc
+    best = max(polys, key=lambda g: g.area)
+    return np.array(best.exterior.coords[:-1], dtype=np.float32)
+
+
+MAX_AREA_LOSS_DEFAULT = 0.01      # ε : perte d'aire tolérée pour polygon_n (1 %)
+
+
+def resample_reflex_aware(polygon_raw, n_min=0, clip=True,
+                          max_area_loss=MAX_AREA_LOSS_DEFAULT):
+    """Reco B — simplifie le contour en **budgétant la PERTE D'AIRE**, `n` en sortie.
+
+    Garantit `polygon_n ⊆ polygon_raw` : on ne *gagne* jamais d'aire, on en perd
+    (« comme si les coins étaient ébréchés ») → les fragments réassemblés ne se
+    chevauchent jamais, ils laissent des jours (régime physiquement réalisable).
+    Renvoie un polygone de longueur VARIABLE.
+
+    Algorithme = **Visvalingam-Whyatt** (1993) *restreint aux sommets convexes* :
+    on retire itérativement le sommet dont le triangle (préc., lui, suiv.) a la
+    plus petite aire, tant que la perte CUMULÉE reste ≤ `max_area_loss` (fraction
+    de l'aire du polygone). Deux invariants :
+      - **seuls les convexes sont retirables** — retirer un sommet reflex
+        pontifierait une concavité et **re-gagnerait** de l'aire (viole ⊆ raw) ;
+      - les sommets ~colinéaires ont un triangle d'aire nulle → retirés en
+        premier, **gratuitement** (c'est le gros du bruit de contour LEGO).
+
+    ⚠️ **Corrigé le 23/07/2026.** L'implémentation précédente budgétait le NOMBRE
+    de sommets (`n_target` ∈ [16,24]) en amorçant `keep` avec tous les reflex :
+    comme `#reflex` (médiane **58** sur LEGO) ≥ `n_target` dans **100 %** des
+    fragments, la boucle sortait immédiatement et **aucun convexe n'était jamais
+    gardé**. Résultat : perte d'aire médiane **21,4 %** (p95 85,8 %, un quart des
+    fragments perdant >50 % de leur aire) sur la config k=10-15 du dataset 25k,
+    et jusqu'à 99 % à k=2. L'invariant ⊆ raw tenait (pas d'aire fantôme) mais
+    l'AMPLEUR de la perte n'était ni bornée ni mesurée. On budgète désormais la
+    grandeur qui compte (la fidélité), et `n` en découle.
+
+    `n_min` : plancher optionnel sur le nombre de sommets (0 = pas de plancher).
+    Le plancher réel reste **#reflex**, atteint automatiquement.
+    """
+    import heapq
+
+    P = np.asarray(polygon_raw, dtype=np.float32)
+    M = len(P)
+    if M < 4:
+        return P.copy()
+
+    total_area = abs(_polygon_signed_area(P))
+    if total_area <= 0:
+        return P.copy()
+    budget = max_area_loss * total_area
+
+    orient = np.sign(_polygon_signed_area(P)) or 1.0
+    prev = [(i - 1) % M for i in range(M)]
+    nxt = [(i + 1) % M for i in range(M)]
+    alive = [True] * M
+    n_alive = M
+
+    def tri(i):
+        """(aire du triangle retiré, convexe ?) pour le sommet i dans l'état courant."""
+        a, b, c = P[prev[i]], P[i], P[nxt[i]]
+        cross = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])
+        return abs(cross) / 2.0, (cross * orient) >= 0      # ≥ 0 : convexe ou colinéaire
+
+    heap = []
+    for i in range(M):
+        a, cvx = tri(i)
+        if cvx:
+            heapq.heappush(heap, (a, i))
+
+    lost = 0.0
+    while heap and n_alive > 3:
+        a, i = heapq.heappop(heap)
+        if not alive[i]:
+            continue
+        a_now, cvx_now = tri(i)                             # ré-évaluation paresseuse
+        if not cvx_now:                                     # devenu reflex → intouchable
+            continue
+        if a_now > a + 1e-9:                                # coût périmé → re-pousser
+            heapq.heappush(heap, (a_now, i))
+            continue
+        if lost + a_now > budget:                           # budget épuisé
+            break
+        if n_min and n_alive <= n_min:
+            break
+        alive[i] = False
+        n_alive -= 1
+        lost += a_now
+        p, n = prev[i], nxt[i]
+        nxt[p], prev[n] = n, p
+        for j in (p, n):                                    # coûts des voisins modifiés
+            aj, cj = tri(j)
+            if cj and alive[j]:
+                heapq.heappush(heap, (aj, j))
+
+    poly = P[[i for i in range(M) if alive[i]]]
+    if clip:
+        poly = _clip_to_polygon(poly, P)                    # filet de sécurité ⊆ raw
+    return np.asarray(poly, dtype=np.float32)
+
+
+# ============================================================
+# Canonicalisation PCA (invariance en rotation)
+# ============================================================
+
+def pca_canonical_rotation(mask):
+    """Rotation 2×2 amenant le fragment dans son repère PCA canonique (axe
+    principal → x), signe déterministe (skewness du 3e moment sur l'axe majeur).
+
+    Rend la forme INVARIANTE EN ROTATION : un même fragment, à n'importe quelle
+    orientation, donne le même descripteur → plus de fuite d'orientation, et
+    repère-target ≡ repère-source (ce que produirait YOLO). Rotation PURE
+    (det=+1, pas de miroir : la chiralité compte pour le matching). Ambigu pour
+    les formes ~symétriques / ~carrées (axe instable) — limitation acceptée.
+    """
+    ys, xs = np.where(mask > 0)
+    if len(xs) < 3:
+        return np.eye(2, dtype=np.float64)
+    pts = np.stack([xs, ys], axis=1).astype(np.float64)
+    pts -= pts.mean(axis=0)
+    evals, evecs = np.linalg.eigh(pts.T @ pts)
+    u = evecs[:, int(np.argmax(evals))]            # axe principal (unitaire)
+    if float(((pts @ u) ** 3).sum()) < 0:          # désambiguïse le flip 180°
+        u = -u
+    return np.array([[u[0], u[1]], [-u[1], u[0]]], dtype=np.float64)  # u → axe x, det=+1
+
+
+# ============================================================
+# Features par fragment (géométrie canonique + couleur de bord)
+# ============================================================
+
+def _is_joint_pixel(px, target=136, tol=30):
+    r, g, b = int(px[0]), int(px[1]), int(px[2])
+    return (abs(r - target) < tol and abs(g - target) < tol and abs(b - target) < tol
+            and max(r, g, b) - min(r, g, b) < 25)
+
+
+def _sample_inward(p0, p1, centroid, img, offset=6):
+    """Sample piece interior color along a polygon side.
+
+    The naive midpoint + small offset can land on a LEGO joint (gray) — we
+    therefore try a few samples along the side and reject pixels that look like
+    joints, falling back to the median of all samples if everything is gray.
+    (Sur fresque réelle : à enrichir vers un profil de couleur le long du bord.)
+    """
+    samples = []
+    for t in (0.3, 0.5, 0.7):
+        pt = (1 - t) * p0 + t * p1
+        inward = centroid - pt
+        norm = float(np.linalg.norm(inward))
+        if norm < 1e-6:
+            continue
+        inward = inward / norm * offset
+        s = pt + inward
+        sx = int(np.clip(s[0], 0, img.shape[1] - 1))
+        sy = int(np.clip(s[1], 0, img.shape[0] - 1))
+        px = img[sy, sx][:3]
+        samples.append(px)
+    if not samples:
+        cx = int(np.clip(centroid[0], 0, img.shape[1] - 1))
+        cy = int(np.clip(centroid[1], 0, img.shape[0] - 1))
+        return img[cy, cx][:3].tolist()
+    non_joint = [s for s in samples if not _is_joint_pixel(s)]
+    pool = non_joint if non_joint else samples
+    return np.median(np.array(pool), axis=0).astype(int).tolist()
+
+
+def compute_fragment_features(polygon_n, area, mean_color, img, polygon_geom=None):
+    """GÉOMÉTRIE (perimeter, bbox, length, angle) calculée sur `polygon_geom`
+    (repère canonique PCA → invariant en rotation, si fourni) ; COULEUR
+    échantillonnée sur `polygon_n` (repère image, pour indexer les pixels).
+
+    `area` est passé en scalaire (la forge : len(cells)·stud² ; un chemin post-YOLO
+    réel : masque.sum()) → fonction 100 % DOMAINE-AGNOSTIQUE (aucune notion LEGO).
+    cx,cy = centroïde image (GT de position, pas un input)."""
+    geom = polygon_n if polygon_geom is None else np.asarray(polygon_geom, dtype=np.float64)
+    centroid_img = polygon_n.mean(axis=0)
+    cx, cy = float(centroid_img[0]), float(centroid_img[1])
+    closed = np.vstack([geom, geom[0:1]])
+    perimeter = float(np.sqrt(((np.diff(closed, axis=0)) ** 2).sum(axis=1)).sum())
+    bbox_w = float(geom[:, 0].max() - geom[:, 0].min())   # repère canonique
+    bbox_h = float(geom[:, 1].max() - geom[:, 1].min())
+
+    side_features = []
+    n = len(polygon_n)
+    for i in range(n):
+        g0, g1 = geom[i], geom[(i + 1) % n]
+        length = float(np.linalg.norm(g1 - g0))
+        angle = float(np.arctan2(g1[1] - g0[1], g1[0] - g0[0]))   # angle canonique
+        c = _sample_inward(polygon_n[i], polygon_n[(i + 1) % n], centroid_img, img)
+        side_features.append([length, angle, float(c[0]), float(c[1]), float(c[2])])
+
+    global_features = [
+        float(area), perimeter, cx, cy,
+        float(mean_color[0]), float(mean_color[1]), float(mean_color[2]),
+        bbox_w, bbox_h,
+    ]
+    return global_features, side_features

code/forge_LAR_2mosaic/batch.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Forge locale LAR — dossier d'images -> dataset_inputs/canvas_mosaic_XXX.png
++ piece_grid_XXX.json (numérotés, prêts pour `mosaic2fragments/batch.py`).
+
+Exemple :
+    python3 forge_LAR_2mosaic/batch.py --input-dir mes_images --out-dir dataset_inputs \
+        --grid 96 --stud-size 40
+
+Puis la pipeline aval consomme tout :
+    python3 mosaic2fragments/batch.py --inputs dataset_inputs/canvas_mosaic_*.png --out dataset
+"""
+import argparse
+from pathlib import Path
+
+from mosaic import forge_to_files
+
+EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".webp", ".tif", ".tiff", ".gif"}
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Dossier d'images -> mosaïques LEGO + GT.")
+    p.add_argument("--input-dir", required=True, help="dossier d'images sources")
+    p.add_argument("--out-dir", default="dataset_inputs", help="dossier de sortie")
+    p.add_argument("--grid", type=int, default=96, help="studs par côté")
+    p.add_argument("--stud-size", type=int, default=40, help="px par stud (≥40)")
+    p.add_argument("--joint-px", type=int, default=None, help="largeur du joint (défaut ~3)")
+    p.add_argument("--mode", choices=["tile", "plate", "brick", "mono"], default="tile",
+                   help="jeu de pièces LEGO (tile par défaut, max 2×6 ; plate = jusqu'à 4×4/4×10)")
+    p.add_argument("--big-plates", action="store_true",
+                   help="réactive 4×8/4×10 (décochées par défaut sur le site)")
+    p.add_argument("--start-index", type=int, default=0, help="indice de départ du nom")
+    p.add_argument("--max-dominant-frac", type=float, default=None,
+                   help="garde-fou : rejeter une image si une couleur LEGO couvre > cette "
+                        "fraction des cellules (aplats monochromes). None = désactivé")
+    return p.parse_args()
+
+
+def main():
+    a = parse_args()
+    imgs = sorted(p for p in Path(a.input_dir).iterdir()
+                  if p.suffix.lower() in EXTS)
+    if not imgs:
+        raise SystemExit(f"Aucune image dans {a.input_dir} (extensions {sorted(EXTS)})")
+    out = Path(a.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    print(f"{len(imgs)} image(s) -> {out}/")
+    made = rejected = 0
+    for k, src in enumerate(imgs, start=a.start_index):
+        png = out / f"canvas_mosaic_{k:03d}.png"
+        js = out / f"piece_grid_{k:03d}.json"
+        g = forge_to_files(str(src), str(png), str(js),
+                           grid_w=a.grid, grid_h=a.grid,
+                           stud_size=a.stud_size, joint_px=a.joint_px,
+                           mode=a.mode, big_plates=a.big_plates,
+                           max_dominant_frac=a.max_dominant_frac)
+        if g.get("rejected"):                     # garde-fou : aplat monochrome
+            rejected += 1
+            print(f"  [{k:03d}] {src.name:30s} -> REJETÉ (couleur dominante {g['dominant_frac']:.0%})")
+            continue
+        made += 1
+        print(f"  [{k:03d}] {src.name:30s} -> {png.name}  ({g['n_pieces']} pièces)")
+    print(f"Fait : {made} mosaïques (rejetées par garde-fou : {rejected}).")
+    print(f"Ensuite : python3 forge_mosaics/mosaic2fragments/batch.py --inputs {out}/canvas_mosaic_*.png --out dataset")
+
+
+if __name__ == "__main__":
+    main()

code/forge_LAR_2mosaic/cli.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""Forge locale LAR — une image -> canvas_mosaic.png + piece_grid.json.
+
+Exemple :
+    python3 forge_LAR_2mosaic/cli.py --input photo.jpg --out-png out/canvas_mosaic.png \
+        --out-json out/piece_grid.json --grid 96 --stud-size 40
+"""
+import argparse
+from pathlib import Path
+
+from mosaic import forge_to_files
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Image -> mosaïque LEGO (tile/plate/brick) + GT.")
+    p.add_argument("--input", required=True, help="image source (jpg/png/…)")
+    p.add_argument("--out-png", help="chemin du canvas_mosaic.png (défaut : à côté de --input)")
+    p.add_argument("--out-json", help="chemin du piece_grid.json")
+    p.add_argument("--grid", type=int, default=96, help="studs par côté (48/64/96/100/128)")
+    p.add_argument("--stud-size", type=int, default=40, help="px par stud (≥40)")
+    p.add_argument("--joint-px", type=int, default=None, help="largeur du joint (défaut ~3)")
+    p.add_argument("--mode", choices=["tile", "plate", "brick", "mono"], default="tile",
+                   help="jeu de pièces LEGO (tile par défaut ; mono = 1×1 seul, ultracompact)")
+    p.add_argument("--big-plates", action="store_true",
+                   help="réactive 4×8/4×10 (décochées par défaut sur le site)")
+    return p.parse_args()
+
+
+def main():
+    a = parse_args()
+    out_png = a.out_png or str(Path(a.input).with_name("canvas_mosaic.png"))
+    out_json = a.out_json or str(Path(out_png).with_name("piece_grid.json"))
+    grid = forge_to_files(
+        a.input, out_png, out_json,
+        grid_w=a.grid, grid_h=a.grid, stud_size=a.stud_size, joint_px=a.joint_px,
+        mode=a.mode, big_plates=a.big_plates,
+    )
+    print(f"{out_png}  ({grid['grid_width']}×{grid['grid_height']} studs, mode={grid['mode']}, "
+          f"max {grid['max_piece'][0]}×{grid['max_piece'][1]}, "
+          f"{grid['n_pieces']} pièces, joint {grid['joint_width_px']}px)")
+    print(f"{out_json}")
+
+
+if __name__ == "__main__":
+    main()

code/forge_LAR_2mosaic/mosaic.py

@@ -0,0 +1,232 @@
+"""Forge de mosaïques LEGO « variable-tile/plate/brick » — clean-room, Python pur.
+
+Remplace lego-art-remix.com pour notre usage : image quelconque → mosaïque LEGO
+à pièces plates de tailles variables (1×1 … 4×10) avec joints gris, PLUS la
+vérité-terrain exacte des pièces (`piece_grid.json`).
+
+On NE copie aucun code de l'outil source (GPL-3.0) : on réimplémente la logique
+publique (quantif vers palette + packing glouton du plus grand rectangle). Les
+JEUX DE DIMENSIONS et n° de pièce BrickLink par mode sont des FAITS extraits de
+`algo.js` (TILE/PLATE/BRICK_DIMENSIONS_TO_PART_ID). Sortie au FORMAT attendu par
+`mosaic2fragments/forge_dataset.py` (carré, ≥40 px/stud, joints ~RGB(136), palette sans gris).
+
+Pipeline :
+  1. crop carré + downsample area-average à grid×grid (1 couleur/cellule)
+  2. quantif nearest-color en espace Lab vers la palette LEGO (sans gris)
+  3. packing glouton : plus grand rectangle MONOCHROME d'abord (aire ↓, comme le
+     site) ; reste comblé en 1×1
+  4. rendu : pièces plates pleines + joints gris ; export PNG + piece_grid.json
+
+Déterministe (aucun aléa) : même image + mêmes params → même sortie.
+"""
+import json
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+from palette import LEGO_PALETTE, JOINT_COLOR, hex_of
+
+
+# ============================================================
+# Jeux de dimensions LEGO par mode (studs) + n° de pièce BrickLink.
+# Faits extraits de lego-art-remix/app/js/algo.js (clean-room).
+# ============================================================
+
+TILE_DIMS = {                                       # "Variable Tile" (plat, lisse)
+    (1, 1): "3070b", (1, 2): "3069b", (1, 3): "63864", (1, 4): "2431",
+    (1, 6): "6636", (1, 8): "4162", (2, 2): "3068b", (2, 3): "26603",
+    (2, 4): "87079", (2, 6): "69729",
+}
+PLATE_DIMS = {                                      # "Variable Plate" (le + de tailles)
+    (1, 1): "3024", (1, 2): "3023", (1, 3): "3623", (1, 4): "3710",
+    (1, 6): "3666", (1, 8): "3460", (2, 2): "3022", (2, 3): "3021",
+    (2, 4): "3020", (2, 6): "3795", (2, 8): "3034", (4, 4): "3031",
+    (4, 8): "3035", (4, 10): "3030",
+}
+BRICK_DIMS = {                                      # "Variable Brick"
+    (1, 1): "3005", (1, 2): "3004", (1, 3): "3622", (1, 4): "3010",
+    (1, 6): "3009", (1, 8): "3008", (2, 2): "3003", (2, 3): "3002",
+    (2, 4): "3001", (2, 6): "2456", (2, 8): "3007",
+}
+MONO_DIMS = {(1, 1): "3070b"}                       # 1×1 SEUL (mode ultracompact)
+MODE_DIMS = {"tile": TILE_DIMS, "plate": PLATE_DIMS, "brick": BRICK_DIMS, "mono": MONO_DIMS}
+# Le site DÉCOCHE par défaut les plus grosses plates (UI : DEFAULT_DISABLED_DEPTH_PLATES).
+DEFAULT_DISABLED = {(4, 8), (4, 10)}
+
+
+def build_allowed_parts(mode="tile", big_plates=False):
+    """Liste (w, h, part_id) pour le mode donné, 2 orientations, triée comme le
+    site : aire décroissante puis plus petite 1re dimension d'abord (déterministe).
+    `big_plates=True` réactive 4×8/4×10 (décochées par défaut sur le site)."""
+    dims = dict(MODE_DIMS[mode])
+    if not big_plates:
+        for d in DEFAULT_DISABLED:
+            dims.pop(d, None)
+    seen, parts = set(), []
+    for (a, b), pid in dims.items():
+        for w, h in {(a, b), (b, a)}:
+            if (w, h) not in seen:
+                seen.add((w, h))
+                parts.append((w, h, pid))
+    parts.sort(key=lambda p: (p[0] * p[1], -p[0]), reverse=True)
+    return parts
+
+
+# ============================================================
+# Espace couleur : sRGB [0,255] -> CIE Lab (D65)
+# ============================================================
+
+def srgb_to_lab(rgb):
+    """rgb : (..., 3) en [0,255] -> Lab (..., 3). Pur numpy (pas de dépendance)."""
+    c = np.asarray(rgb, dtype=np.float64) / 255.0
+    lin = np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4)
+    r, g, b = lin[..., 0], lin[..., 1], lin[..., 2]
+    x = 0.4124 * r + 0.3576 * g + 0.1805 * b
+    y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+    z = 0.0193 * r + 0.1192 * g + 0.9505 * b
+    x /= 0.95047; z /= 1.08883                      # point blanc D65 (Yn = 1)
+    def f(t):
+        return np.where(t > 0.008856, np.cbrt(t), 7.787 * t + 16.0 / 116.0)
+    fx, fy, fz = f(x), f(y), f(z)
+    return np.stack([116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz)], axis=-1)
+
+
+# ============================================================
+# Étapes 1-2 : image -> grille d'indices de palette
+# ============================================================
+
+def image_to_color_grid(image, grid_w, grid_h):
+    """Crop carré centré + downsample area-average -> (grid_h, grid_w, 3) uint8.
+    `image` : chemin OU objet PIL.Image (utile pour le streaming wikiart)."""
+    im = (image if isinstance(image, Image.Image) else Image.open(image)).convert("RGB")
+    w, h = im.size
+    s = min(w, h)                                   # crop carré centré
+    im = im.crop(((w - s) // 2, (h - s) // 2, (w - s) // 2 + s, (h - s) // 2 + s))
+    im = im.resize((grid_w, grid_h), Image.BOX)     # moyenne par cellule
+    return np.asarray(im, dtype=np.uint8)
+
+
+def quantize_to_palette(color_grid, palette=LEGO_PALETTE):
+    """(H,W,3) -> (H,W) indices de la palette (nearest en Lab)."""
+    pal = np.array(palette, dtype=np.float64)
+    pal_lab = srgb_to_lab(pal)                       # (P,3)
+    cells_lab = srgb_to_lab(color_grid.reshape(-1, 3))  # (H*W,3)
+    d = ((cells_lab[:, None, :] - pal_lab[None, :, :]) ** 2).sum(-1)  # (H*W,P)
+    idx = d.argmin(1).reshape(color_grid.shape[:2])
+    return idx.astype(np.int32)
+
+
+# ============================================================
+# Étape 3 : packing glouton du plus grand rectangle monochrome
+# ============================================================
+
+def pack_variable_tiles(idx_grid, allowed_parts):
+    """Glouton : pose le plus grand rectangle MONOCHROME possible, sans
+    chevauchement, en balayant en row-major ; reste comblé par des 1×1.
+
+    `allowed_parts` : liste (w, h, part_id) déjà triée (aire ↓). Retourne la
+    liste des pièces (col, row, width, height, color_idx, part_id). Chaque pièce
+    est mono-couleur (une pièce LEGO = une couleur) ; deux pièces voisines de même
+    couleur restent séparées par un joint -> deux pièces distinctes en aval.
+    """
+    H, W = idx_grid.shape
+    occupied = np.zeros((H, W), dtype=bool)
+    pieces = []
+    for pw, ph, pid in allowed_parts:
+        if pw > W or ph > H:
+            continue
+        for r in range(H - ph + 1):
+            for c in range(W - pw + 1):
+                if occupied[r:r + ph, c:c + pw].any():
+                    continue
+                block = idx_grid[r:r + ph, c:c + pw]
+                if (block == block[0, 0]).all():
+                    occupied[r:r + ph, c:c + pw] = True
+                    pieces.append((c, r, pw, ph, int(block[0, 0]), pid))
+    # garde-fou : toute cellule restante -> 1×1 (ne devrait pas arriver)
+    unit_pid = next((pid for w, h, pid in allowed_parts if (w, h) == (1, 1)), None)
+    for r, c in np.argwhere(~occupied):
+        pieces.append((int(c), int(r), 1, 1, int(idx_grid[r, c]), unit_pid))
+    return pieces
+
+
+# ============================================================
+# Étape 4 : rendu PNG (pièces plates + joints gris)
+# ============================================================
+
+def render_mosaic(pieces, grid_w, grid_h, stud_size, joint_px, palette=LEGO_PALETTE):
+    """Fond gris (joints) + chaque pièce peinte en retrait de joint_px/2 sur
+    chaque bord -> joint de joint_px px entre pièces voisines. Aucun anti-alias :
+    pixels de pièce = couleur palette exacte, pixels de joint = RGB(136) exact."""
+    H_px, W_px = grid_h * stud_size, grid_w * stud_size
+    img = np.empty((H_px, W_px, 3), dtype=np.uint8)
+    img[:] = JOINT_COLOR
+    li, ri = joint_px - joint_px // 2, joint_px // 2   # ceil / floor -> joint exact
+    for c, r, w, h, ci, _pid in pieces:
+        x0, y0 = c * stud_size + li, r * stud_size + li
+        x1, y1 = (c + w) * stud_size - ri, (r + h) * stud_size - ri
+        img[y0:y1, x0:x1] = palette[ci]
+    return Image.fromarray(img, "RGB")
+
+
+# ============================================================
+# Orchestration
+# ============================================================
+
+def forge_mosaic(image, grid_w=96, grid_h=96, stud_size=40, joint_px=None,
+                 mode="tile", big_plates=False, palette=LEGO_PALETTE, source_name=None,
+                 max_dominant_frac=None):
+    """image (chemin ou PIL.Image) -> (PIL.Image mosaïque, dict piece_grid). mode: tile|plate|brick.
+
+    Garde-fou `max_dominant_frac` (∈ ]0,1]) : si une seule couleur de palette couvre
+    > cette fraction des cellules, l'image est REJETÉE → renvoie `(None, stats)`.
+    Cible : les peintures (souvent impressionnistes) à variations infimes d'une même
+    couleur, qui s'effondrent en un gros aplat monochrome une fois quantifiées (peu de
+    pièces, détection de joints faussée). None par défaut = garde-fou désactivé.
+    """
+    if joint_px is None:
+        joint_px = max(2, round(stud_size * 0.075))    # ~3 px à 40 px/stud
+    allowed = build_allowed_parts(mode, big_plates)
+    color_grid = image_to_color_grid(image, grid_w, grid_h)
+    idx_grid = quantize_to_palette(color_grid, palette)
+    counts = np.bincount(idx_grid.ravel(), minlength=len(palette))
+    dominant_frac = float(counts.max() / idx_grid.size)
+    n_colors = int((counts > 0).sum())
+    if max_dominant_frac is not None and dominant_frac > max_dominant_frac:
+        return None, {"rejected": True, "reason": "dominant_color",
+                      "dominant_frac": dominant_frac, "n_colors": n_colors,
+                      "max_dominant_frac": max_dominant_frac}
+    pieces = pack_variable_tiles(idx_grid, allowed)
+    img = render_mosaic(pieces, grid_w, grid_h, stud_size, joint_px, palette)
+    piece_grid = {
+        "grid_width": grid_w,
+        "grid_height": grid_h,
+        "stud_size_px": stud_size,
+        "joint_width_px": joint_px,
+        "joint_color_rgb": list(JOINT_COLOR),
+        "mode": mode,
+        "max_piece": list(max((p[:2] for p in allowed), key=lambda d: d[0] * d[1])),
+        "source_image": source_name or (Path(image).name if isinstance(image, (str, Path)) else "image"),
+        "dominant_frac": dominant_frac,
+        "n_colors": n_colors,
+        "n_pieces": len(pieces),
+        "n_cells": grid_w * grid_h,
+        "pieces": [
+            {"col": c, "row": r, "width": w, "height": h,
+             "part_id": pid, "color_rgb": list(palette[ci]),
+             "color_hex": hex_of(palette[ci])}
+            for c, r, w, h, ci, pid in pieces
+        ],
+    }
+    return img, piece_grid
+
+
+def forge_to_files(image_path, out_png, out_json, **kw):
+    img, grid = forge_mosaic(image_path, **kw)
+    if img is None:                                   # rejeté par le garde-fou
+        return grid                                   # stats, rien écrit
+    Path(out_png).parent.mkdir(parents=True, exist_ok=True)
+    img.save(out_png)
+    Path(out_json).write_text(json.dumps(grid, indent=2))
+    return grid

code/forge_LAR_2mosaic/palette.py

@@ -0,0 +1,103 @@
+"""Palette LEGO — couleurs solides BrickLink, SANS les gris/argentés.
+
+Les valeurs hex sont des FAITS (couleurs LEGO officielles, non protégeables) ;
+elles ont été extraites de `bricklink-colors.js` (lego-art-remix, GPL-3.0) puis
+filtrées hors-ligne. AUCUN code de l'outil source n'est importé ici (clean-room).
+
+Filtre appliqué : on retire toute couleur « confusable joint », i.e. quasi-grise
+(max-min des canaux < 25) ET d'intensité moyenne (70 ≤ moyenne ≤ 200). C'est la
+fenêtre où le détecteur de joints de `mosaic2fragments/` (gris ~RGB 136 ± 30) ferait un
+faux positif. Blanc (255) et Noir (33) sont conservés (loin de 136).
+"""
+
+# (R, G, B) — 82 couleurs LEGO solides, gris/argent retirés.
+LEGO_PALETTE = [
+    (255, 255, 255),  # White
+    (232, 232, 232),  # Very Light Gray
+    (228, 232, 232),  # Very Light Bluish Gray
+    ( 33,  33,  33),  # Black
+    (106,  14,  21),  # Dark Red
+    (179,   0,   6),  # Red
+    (181,  44,  32),  # Rust
+    (248, 131, 121),  # Coral
+    (244,  92,  64),  # Salmon
+    (255, 222, 220),  # Light Salmon
+    (140, 107, 107),  # Sand Red
+    (137,  53,  29),  # Reddish Brown
+    ( 83,  33,  21),  # Brown
+    ( 51,   0,   0),  # Dark Brown
+    (144, 116,  80),  # Dark Tan
+    (222, 198, 156),  # Tan
+    (254, 204, 176),  # Light Nougat
+    (255, 175, 125),  # Nougat
+    (227, 160,  91),  # Medium Nougat
+    (231, 139,  62),  # Dark Nougat
+    (161, 108,  66),  # Medium Brown
+    (179, 105,  78),  # Fabuland Brown
+    (239, 145,  33),  # Fabuland Orange
+    (230, 136,  29),  # Earth Orange
+    (179,  84,   8),  # Dark Orange
+    (250,  89,  71),  # Neon Orange
+    (255, 126,  20),  # Orange
+    (255, 165,  49),  # Medium Orange
+    (247, 186,  48),  # Bright Light Orange
+    (247, 173,  99),  # Light Orange
+    (230, 192,  93),  # Very Light Orange
+    (221, 152,  46),  # Dark Yellow
+    (247, 209,  23),  # Yellow
+    (243, 224,  85),  # Bright Light Yellow
+    (255, 227, 131),  # Light Yellow
+    (235, 238, 143),  # Light Lime
+    (223, 238, 165),  # Yellowish Green
+    (188, 239, 102),  # Neon Green
+    (189, 198,  24),  # Medium Lime
+    (166, 202,  85),  # Lime
+    (124, 144,  81),  # Olive Green
+    ( 46,  85,  67),  # Dark Green
+    (  0, 100,  46),  # Green
+    ( 16, 203,  49),  # Bright Green
+    ( 98, 245, 142),  # Medium Green
+    (165, 219, 181),  # Light Green
+    (118, 162, 144),  # Sand Green
+    (  0, 138, 128),  # Dark Turquoise
+    ( 49, 181, 202),  # Light Turquoise
+    (181, 211, 214),  # Aqua
+    (204, 255, 255),  # Light Aqua
+    ( 20,  48,  68),  # Dark Blue
+    (  0,  87, 166),  # Blue
+    ( 51, 153, 255),  # Dark Azure
+    ( 66, 192, 251),  # Medium Azure
+    ( 97, 175, 255),  # Medium Blue
+    (107, 173, 214),  # Maersk Blue
+    (159, 195, 233),  # Bright Light Blue
+    (180, 210, 227),  # Light Blue
+    (125, 191, 221),  # Sky Blue
+    ( 90, 113, 132),  # Sand Blue
+    ( 80, 108, 239),  # Blue-Violet
+    ( 32,  50, 176),  # Dark Blue-Violet
+    ( 52,  72, 164),  # Violet
+    (147, 145, 228),  # Medium Violet
+    (201, 202, 226),  # Light Violet
+    ( 95,  38, 131),  # Dark Purple
+    (165,  73, 156),  # Purple
+    (218, 112, 214),  # Light Purple
+    (136,  94, 158),  # Medium Lavender
+    (224, 170, 217),  # Clikits Lavender
+    (177, 140, 191),  # Lavender
+    (181, 125, 165),  # Sand Purple
+    (181,  41,  82),  # Magenta
+    (200, 112, 128),  # Dark Pink
+    (247, 133, 177),  # Medium Dark Pink
+    (255, 187, 255),  # Bright Pink
+    (255, 192, 203),  # Pink
+    (255, 225, 255),  # Light Pink
+    (255, 252,   0),  # Neon Yellow
+    (231, 149,   0),  # Pearl Gold
+    (217, 197, 148),  # Medium Tan
+]
+
+JOINT_COLOR = (136, 136, 136)  # gris des joints — RGB(136) ≈ rendu lego-art-remix
+
+
+def hex_of(rgb):
+    return "#{:02x}{:02x}{:02x}".format(*rgb)

code/forge_LAR_2mosaic/remono.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Re-forge une mosaïque existante en mode MONO (tuiles 1×1) — pour `ultracompact`.
+
+Entrée = le `piece_grid_<uuid>.json` d'une mosaïque déjà forgée (n'importe quel
+mode) : il porte la couleur EXACTE de chaque cellule → on reconstruit la même
+image de mosaïque, mais où chaque cellule est une pièce 1×1 (joints partout).
+Aucune re-quantification (repasser le canvas rendu dans la forge moyennerait les
+joints gris dans les cellules) ; l'uuid est conservé → l'appariement des
+curriculums (même mosaïque de base) reste valable entre variable-tile et mono.
+
+Usage :
+    python3 forge_mosaics/forge_LAR_2mosaic/remono.py \
+        --piece-grids 'output/wikiart_inputs/piece_grid_*.json' \
+        --out-dir output/wikiart_inputs_mono [--limit 100]
+"""
+import argparse
+import glob
+import json
+from pathlib import Path
+
+import numpy as np
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+from mosaic import render_mosaic, MONO_DIMS, JOINT_COLOR  # noqa: E402
+
+
+def mono_from_piece_grid(pg):
+    """piece_grid dict (mode quelconque) -> (PIL.Image mono, piece_grid mono)."""
+    W, H = pg["grid_width"], pg["grid_height"]
+    stud, joint = pg["stud_size_px"], pg["joint_width_px"]
+    # 1) grille de couleurs exacte depuis les pièces (couverture 1× garantie)
+    grid = np.zeros((H, W, 3), dtype=np.uint8)
+    for p in pg["pieces"]:
+        c, r, w, h = p["col"], p["row"], p["width"], p["height"]
+        grid[r:r + h, c:c + w] = p["color_rgb"]
+    # 2) palette locale = couleurs distinctes de CETTE mosaïque (rendu exact)
+    colors = np.unique(grid.reshape(-1, 3), axis=0)
+    lut = {tuple(c): i for i, c in enumerate(colors)}
+    unit_pid = MONO_DIMS[(1, 1)]
+    pieces = [(c, r, 1, 1, lut[tuple(grid[r, c])], unit_pid)
+              for r in range(H) for c in range(W)]
+    img = render_mosaic(pieces, W, H, stud, joint, palette=colors)
+    piece_grid = {
+        **{k: pg[k] for k in ("grid_width", "grid_height", "stud_size_px",
+                              "joint_width_px", "source_image")},
+        "joint_color_rgb": list(JOINT_COLOR),
+        "mode": "mono", "max_piece": [1, 1],
+        "remono_from_mode": pg.get("mode"),
+        "n_pieces": len(pieces), "n_cells": W * H,
+        "pieces": [{"col": c, "row": r, "width": 1, "height": 1, "part_id": pid,
+                    "color_rgb": [int(v) for v in colors[ci]]}
+                   for c, r, _w, _h, ci, pid in pieces],
+    }
+    return img, piece_grid
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--piece-grids", required=True,
+                    help="glob des piece_grid_*.json source")
+    ap.add_argument("--out-dir", required=True)
+    ap.add_argument("--limit", type=int, default=None,
+                    help="ne traiter que les N premiers (ordre trié)")
+    a = ap.parse_args()
+    out = Path(a.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    paths = sorted(glob.glob(a.piece_grids))[: a.limit]
+    for i, jp in enumerate(paths, 1):
+        pg = json.load(open(jp))
+        uid = Path(jp).stem[len("piece_grid_"):]
+        png = out / f"canvas_mosaic_{uid}.png"
+        if png.exists():                                   # resume
+            continue
+        img, mono = mono_from_piece_grid(pg)
+        img.save(png)
+        json.dump(mono, open(out / f"piece_grid_{uid}.json", "w"))
+        if i % 20 == 0 or i == len(paths):
+            print(f"[{i}/{len(paths)}] {uid}")
+    print(f"done → {out}")
+
+
+if __name__ == "__main__":
+    main()

code/forge_LAR_2mosaic/wikiart.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Stream wikiart (HuggingFace) → mosaïques LEGO, SANS télécharger le dataset.
+
+Tire N images de `huggan/wikiart` à la volée et les passe dans la forge locale →
+`dataset_inputs/canvas_mosaic_XXX.png` + `piece_grid_XXX.json` (prêts pour
+`mosaic2fragments`). Aucun téléchargement complet (~1-2 Mo/image en flux).
+
+Exemple :
+    python3 forge_LAR_2mosaic/wikiart.py --n 200 --out-dir dataset_inputs --grid 96 --mode plate
+    python3 mosaic2fragments/batch.py --inputs dataset_inputs/canvas_mosaic_*.png --out dataset_wikiart
+
+Dépendance : `pip install datasets` (HuggingFace). Réseau requis.
+"""
+import argparse
+import json
+import uuid
+from itertools import islice
+from pathlib import Path
+
+from mosaic import forge_mosaic
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="wikiart (streaming) -> mosaïques LEGO + GT.")
+    p.add_argument("--n", type=int, default=200, help="nb de mosaïques à générer")
+    p.add_argument("--skip", type=int, default=0, help="sauter les K premières images du flux")
+    p.add_argument("--out-dir", default="dataset_inputs", help="dossier de sortie")
+    p.add_argument("--grid", type=int, default=96, help="studs par côté")
+    p.add_argument("--stud-size", type=int, default=40, help="px par stud (≥40)")
+    p.add_argument("--joint-px", type=int, default=None, help="largeur du joint (défaut ~3)")
+    p.add_argument("--mode", choices=["tile", "plate", "brick", "mono"], default="tile",
+                   help="mono = tuiles 1×1 seules (pour le curriculum ultracompact)")
+    p.add_argument("--big-plates", action="store_true", help="réactive 4×8/4×10")
+    p.add_argument("--max-dominant-frac", type=float, default=0.55,
+                   help="garde-fou : rejeter une image si une seule couleur LEGO couvre "
+                        "> cette fraction des cellules (impressionnistes → aplats monochromes). "
+                        "1.0 ou plus = désactivé")
+    p.add_argument("--dataset", default="huggan/wikiart",
+                   help="dataset HF en streaming (image attendue dans ex['image'])")
+    return p.parse_args()
+
+
+def main():
+    a = parse_args()
+    from datasets import load_dataset            # import tardif : message clair si absent
+    out = Path(a.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    print(f"streaming {a.dataset} (train) → {a.n} mosaïques "
+          f"(mode={a.mode}, grid={a.grid}, skip={a.skip})…")
+    ds = load_dataset(a.dataset, split="train", streaming=True)
+
+    made = 0
+    rejected = 0                                   # garde-fou couleur dominante
+    for ex in islice(ds, a.skip, None):
+        if made >= a.n:
+            break
+        try:
+            img = ex["image"].convert("RGB")
+        except Exception as e:                   # image illisible / champ manquant
+            print(f"  skip (image illisible): {e}")
+            continue
+        if min(img.size) < a.grid:               # trop petite pour la grille demandée
+            continue
+        uid = str(uuid.uuid4())                   # nom unique, uuid4 canonique (wikiart n'a pas d'ID)
+        try:
+            mos, grid = forge_mosaic(
+                img, grid_w=a.grid, grid_h=a.grid, stud_size=a.stud_size,
+                joint_px=a.joint_px, mode=a.mode, big_plates=a.big_plates,
+                source_name=uid, max_dominant_frac=a.max_dominant_frac)
+        except Exception as e:                   # forge échoue → on saute l'image
+            print(f"  skip (forge: {e})")
+            continue
+        if mos is None:                          # garde-fou : aplat monochrome → rejeté
+            rejected += 1
+            continue
+        mos.save(out / f"canvas_mosaic_{uid}.png")
+        (out / f"piece_grid_{uid}.json").write_text(json.dumps(grid))
+        made += 1
+        if made % 20 == 0:
+            print(f"  {made}/{a.n}… (rejetées par garde-fou : {rejected})")
+    print(f"Fait : {made} mosaïques dans {out}/  (rejetées par garde-fou couleur : {rejected})")
+    print(f"Ensuite : python3 forge_mosaics/mosaic2fragments/batch.py "
+          f"--inputs {out}/canvas_mosaic_*.png --out dataset_wikiart")
+
+
+if __name__ == "__main__":
+    main()

code/mosaic2fragments/batch.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Forge multiple mosaic samples by varying random seeds (and optionally inputs).
+
+For 50 mosaics with a single input image, this produces 50 distinct
+fragmentations of the same target. To grow real diversity, feed different
+canvas_mosaic.png files via --inputs.
+"""
+
+import argparse
+from pathlib import Path
+
+from forge_dataset import forge_one
+from visualize import visualize
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('--inputs', nargs='+', default=['exp1/canvas_mosaic.png'],
+                   help='One or more canvas_mosaic.png paths')
+    p.add_argument('--out', default='dataset',
+                   help='Root output directory (one subfolder per sample)')
+    p.add_argument('--n-samples', type=int, default=5,
+                   help='Total number of mosaic samples to generate')
+    p.add_argument('--seed-start', type=int, default=0)
+    p.add_argument('--n-sides-min', type=int, default=16)
+    p.add_argument('--n-sides-max', type=int, default=24)
+    p.add_argument('--max-area-loss', type=float, default=0.01,
+                   help="reco B — perte d'aire tolérée pour polygon_n (défaut 1%%) ; "
+                        "c'est LE budget, n en découle")
+    p.add_argument('--n-frag-min', type=int, default=10)
+    p.add_argument('--n-frag-max', type=int, default=15)
+    p.add_argument('--canvas-w', type=int, default=3500)
+    p.add_argument('--canvas-h', type=int, default=3500)
+    p.add_argument('--debug', action='store_true',
+                   help='écrit les fichiers DEBUG (pieces.json + source_yolo_viz.png) ; OFF par défaut')
+    p.add_argument('--name-from-input', action='store_true',
+                   help="Nomme le dossier mosaic_<id> d'après le PNG d'entrée "
+                        "(canvas_mosaic_<id>.png) au lieu de mosaic_000 séquentiel "
+                        "→ noms uniques (uuid) préservés en sortie")
+    p.add_argument('--no-rotation', action='store_true',
+                   help='Curriculum L1 : fragments éclatés SANS rotation (translation seule)')
+    p.add_argument('--placement', choices=['scatter', 'explode'], default='scatter',
+                   help='explode = curriculum L0 : vue éclatée (positions relatives gardées)')
+    p.add_argument('--frag-distribution', choices=['balanced', 'compact'], default='balanced',
+                   help='balanced (défaut) ou compact (~rectangulaire, moins de sommets)')
+    p.add_argument('--erode-px-min', type=int, default=0)
+    p.add_argument('--erode-px-max', type=int, default=0)
+    p.add_argument('--holes-min', type=int, default=0)
+    p.add_argument('--holes-max', type=int, default=0)
+    p.add_argument('--missing-min', type=int, default=0)
+    p.add_argument('--missing-max', type=int, default=0)
+    args = p.parse_args()
+    degrade = {
+        'erode_px': (args.erode_px_min, args.erode_px_max),
+        'holes': (args.holes_min, args.holes_max),
+        'missing': (args.missing_min, args.missing_max),
+    }
+
+    out_root = Path(args.out)
+    for i in range(args.n_samples):
+        inp = args.inputs[i % len(args.inputs)]
+        seed = args.seed_start + i
+        if args.name_from_input:
+            stem = Path(inp).stem
+            uid = stem[len('canvas_mosaic_'):] if stem.startswith('canvas_mosaic_') else stem
+            sample_dir = out_root / f'mosaic_{uid}'
+        else:
+            sample_dir = out_root / f'mosaic_{i:03d}'
+        print(f"\n=== sample {i:03d} (seed={seed}, input={inp}) ===")
+        forge_one(
+            target_path=inp,
+            out_dir=sample_dir,
+            n_sides_range=(args.n_sides_min, args.n_sides_max),
+            max_area_loss=args.max_area_loss,
+            n_frag_range=(args.n_frag_min, args.n_frag_max),
+            canvas_size=(args.canvas_w, args.canvas_h),
+            stud_size=None,
+            seed=seed,
+            degrade=degrade,
+            rotate=not args.no_rotation,
+            placement=args.placement,
+            frag_distribution=args.frag_distribution,
+            debug=args.debug,
+        )
+        if args.debug:
+            visualize(sample_dir)
+
+
+if __name__ == '__main__':
+    main()

code/mosaic2fragments/curriculum.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Curriculum de dégradation — génère les 5 paliers L0→L4 dans des sous-dossiers
+`<out>/L0_explode` … `<out>/L4_strong`, depuis UN MÊME jeu de mosaïques de base.
+
+Design **apparié** : même mosaïque + même seed à tous les paliers → la GT
+(fragmentation + arêtes, fixée avant tout tirage de dégradation) est IDENTIQUE
+d'un palier à l'autre ; seule la difficulté de l'INPUT change. → la courbe
+score(difficulté) du GNN se lit à variance faible.
+
+Paliers (ladder monotone) :
+  L0_explode      vue éclatée (positions relatives conservées), sans rotation  ← le + facile
+  L1_translation  scatter aléatoire, sans rotation, aucune dégradation
+  L2_rotation     scatter + rotation, aucune dégradation
+  L3_light        scatter + rotation, dégradation LÉGÈRE (érosion 1-2 px, 0-1 trou)
+  L4_strong       scatter + rotation, dégradation FORTE (érosion 2-6 px, trous, manquants)
+
+⚠️ DAFNE B (distribution de découpe) n'est instrumenté que partiellement, via
+`--frag-distribution` ; DAFNE D (fragments parasites) n'est pas implémenté.
+
+Inputs = mosaïques rendues : soit des `canvas_mosaic_*.png`, soit les `target.png`
+d'un dataset clean existant (target.png = copie de la mosaïque d'entrée).
+
+Exemples :
+    # apparié 1:1 sur les mosaïques wikiart déjà rendues
+    python3 forge_mosaics/mosaic2fragments/curriculum.py \
+        --inputs-glob 'output/wikiart_inputs/canvas_mosaic_*.png' --out output --jobs 6
+
+    # augmenter : 5 fragmentations (seeds) par mosaïque → 500/palier à partir de 100 images
+    python3 forge_mosaics/mosaic2fragments/curriculum.py \
+        --inputs output/wikiart_inputs/canvas_mosaic_*.png --out output --n-per-input 5
+
+Puis collate par palier :
+    for L in output/L?_*; do python3 forge_mosaics/features/collate.py --dataset "$L"; done
+"""
+import argparse
+import glob
+import zlib
+from pathlib import Path
+
+from forge_dataset import forge_one
+from visualize import visualize
+
+# (placement, rotate, érosion px, trous, fragments manquants) par palier.
+#   placement explode = vue éclatée (positions relatives gardées, juste espacées)
+#   placement scatter = placement aléatoire (peut échanger les positions)
+LEVELS = {
+    "L0_explode":     dict(placement="explode", rotate=False, erode=(0, 0), holes=(0, 0), missing=(0, 0)),
+    "L1_translation": dict(placement="scatter", rotate=False, erode=(0, 0), holes=(0, 0), missing=(0, 0)),
+    "L2_rotation":    dict(placement="scatter", rotate=True,  erode=(0, 0), holes=(0, 0), missing=(0, 0)),
+    "L3_light":       dict(placement="scatter", rotate=True,  erode=(1, 2), holes=(0, 1), missing=(0, 0)),
+    "L4_strong":      dict(placement="scatter", rotate=True,  erode=(2, 6), holes=(1, 3), missing=(0, 2)),  # = degraded actuel
+}
+# L5 « knobs poussés » RETIRÉ (saturait : 0.092 vs 0.088 pour L4). Le vrai durcissement
+# passe par l'axe ORTHOGONAL --frag-distribution {voronoi, clusters} (DAFNE B), pas par
+# plus d'érosion. Structure de sortie = output/<frag-distribution>/<palier>/mosaic_*.
+
+FRAG_DISTRIBUTIONS = ["balanced", "compact", "ultracompact", "voronoi", "clusters"]
+
+
+def input_uid(path):
+    """Identifiant stable d'une mosaïque de base (pour apparier les paliers)."""
+    p = Path(path)
+    if p.stem == "target":                       # .../mosaic_<uuid>/target.png
+        name = p.parent.name
+        return name[len("mosaic_"):] if name.startswith("mosaic_") else name
+    if p.stem.startswith("canvas_mosaic_"):       # canvas_mosaic_<id>.png
+        return p.stem[len("canvas_mosaic_"):]
+    return p.stem
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--inputs", nargs="+", default=[],
+                   help="mosaïques de base (canvas_mosaic_*.png ou target.png d'un dataset clean)")
+    p.add_argument("--inputs-glob", default=None,
+                   help="motif glob résolu en interne (robuste pour des milliers d'entrées, "
+                        "évite ARG_MAX) ; ex. 'output/wikiart_inputs/canvas_mosaic_*.png'")
+    p.add_argument("--out", default="output", help="racine → output/<frag-distribution>/<palier>/")
+    p.add_argument("--frag-distribution", choices=FRAG_DISTRIBUTIONS, default="balanced",
+                   help="motif de découpe (axe orthogonal aux paliers). balanced (défaut), "
+                        "compact et ultracompact (= compact sur une mosaïque 1×1, cf. "
+                        "forge_LAR_2mosaic --mode mono) sont implémentés ; voronoi/clusters "
+                        "(DAFNE B, distribution de tailles continue) = à venir")
+    p.add_argument("--n-per-input", type=int, default=1,
+                   help="nb de fragmentations (seeds) par mosaïque de base (augmentation)")
+    p.add_argument("--seed-start", type=int, default=0)
+    p.add_argument("--seed-mode", choices=("uid", "constant"), default="uid",
+                   help="uid (défaut) : seed = crc32(uuid de la mosaïque) + seed-start "
+                        "→ une découpe DIFFÉRENTE par mosaïque. constant : ancien "
+                        "comportement (seed = seed-start pour toutes) — à n'utiliser "
+                        "que pour reproduire un run d'avant le 27/07/2026")
+    p.add_argument("--n-sides-min", type=int, default=16)
+    p.add_argument("--n-sides-max", type=int, default=24)
+    p.add_argument("--n-frag-min", type=int, default=10)
+    p.add_argument("--n-frag-max", type=int, default=15)
+    p.add_argument("--max-area-loss", type=float, default=0.01,
+                   help="reco B — fraction d'aire que polygon_n a le droit de PERDRE "
+                        "vs polygon_raw (défaut 0.01 = 1 %%). C'est LE budget ; le "
+                        "nombre de sommets en découle (correctif 23/07/2026).")
+    p.add_argument("--missing-max", type=int, default=None,
+                   help="plafond du nb de fragments MANQUANTS (DAFNE C) des paliers. "
+                        "DAFNE C est un POURCENTAGE, notre `missing` un COMPTE ABSOLU → "
+                        "défaut = round(0.15·n_frag_max) (~15 %% de k, quel que soit k). "
+                        "À k=10-15 ça donne 2 = le réglage historique exact (run 25k "
+                        "reproductible) ; à k=2/3 → 0 ; k=5 → 1. Passer une valeur pour "
+                        "outrepasser.")
+    p.add_argument("--canvas-w", type=int, default=4096)
+    p.add_argument("--canvas-h", type=int, default=4096)
+    p.add_argument("--levels", nargs="+", default=list(LEVELS),
+                   help=f"sous-ensemble de paliers (défaut : tous → {list(LEVELS)})")
+    p.add_argument("--jobs", type=int, default=1,
+                   help="processus parallèles (1 = série). Forge = CPU-bound, embarrassingly "
+                        "parallel. Sur machine partagée : plafonner (ex. 12 sur 24), pas tous les cœurs")
+    p.add_argument("--debug", action="store_true",
+                   help="écrit les fichiers DEBUG (pieces.json + source_yolo_viz.png), "
+                        "lus nulle part par l'entraînement ; OFF par défaut")
+    return p.parse_args()
+
+
+def _run_task(t):
+    """Worker (1 instance). Top-level → picklable par multiprocessing (spawn macOS).
+
+    ROBUSTESSE (grosses générations) :
+    - **resume** : si l'instance est déjà complète (`degradation.md` = dernier fichier
+      écrit), on la saute → un relancement reprend où ça s'est arrêté.
+    - **tolérance** : toute exception d'une instance est CAPTURÉE et renvoyée comme
+      `FAIL …` au lieu de planter tout le batch (1 mosaïque pourrie ≠ 25 000 perdues).
+    """
+    if (Path(t["dir"]) / "degradation.md").exists():
+        return f"skip  {t['label']}"
+    try:
+        forge_one(
+            target_path=t["inp"], out_dir=t["dir"],
+            n_sides_range=t["n_sides"], n_frag_range=t["n_frag"], canvas_size=t["canvas"],
+            stud_size=None, seed=t["seed"], degrade=t["degrade"],
+            rotate=t["rotate"], placement=t["placement"], frag_distribution=t["frag_distribution"],
+            debug=t["debug"], max_area_loss=t["max_area_loss"],
+        )
+        if t["viz"]:
+            visualize(t["dir"])
+        return t["label"]
+    except Exception as e:
+        return f"FAIL  {t['label']}: {type(e).__name__}: {e}"
+
+
+def main():
+    a = parse_args()
+    if a.frag_distribution in ("voronoi", "clusters"):
+        raise SystemExit(f"--frag-distribution {a.frag_distribution} : pas encore "
+                         "implémenté (DAFNE B à venir ; dispo : balanced, compact)")
+    inputs = list(a.inputs) + (sorted(glob.glob(a.inputs_glob)) if a.inputs_glob else [])
+    if not inputs:
+        raise SystemExit("aucune entrée : fournir --inputs ... ou --inputs-glob 'motif'")
+    out_root = Path(a.out) / a.frag_distribution
+    tasks = []
+    for inp in inputs:
+        uid = input_uid(inp)
+        for s in range(a.n_per_input):
+            # ⚠️ Le seed DOIT dépendre de la mosaïque. Avec un seed constant, en
+            # `mono` (tuiles 1×1) la grille d'adjacence est identique pour toute
+            # image → la fragmentation, déterministe, rendait la MÊME découpe et
+            # les MÊMES poses pour les 5000 mosaïques (bug trouvé le 27/07/2026 :
+            # les 4 datasets mono_compact publiés n'avaient qu'une seule
+            # géométrie). En `poly` le bug était masqué : la découpe suit les
+            # joints de tuiles variables, qui dépendent de l'image.
+            # crc32(uid) ne dépend QUE de la mosaïque → l'appariement reste
+            # exact entre paliers ET entre valeurs de k.
+            seed = (zlib.crc32(uid.encode()) + a.seed_start + s) % (2 ** 31) \
+                if a.seed_mode == "uid" else a.seed_start + s
+            # même seed sur tous les paliers → mosaïque/fragmentation appariée
+            suffix = f"_s{seed}" if a.n_per_input > 1 else ""
+            for level in a.levels:
+                cfg = LEVELS[level]
+                # DAFNE C est un %, `missing` un compte absolu → plafond ~15 % de k.
+                # round(0.15·15)=2 ⟹ identique au réglage historique à k=10-15.
+                cap = a.missing_max if a.missing_max is not None \
+                    else round(0.15 * a.n_frag_max)
+                miss = (min(cfg["missing"][0], cap), min(cfg["missing"][1], cap))
+                tasks.append(dict(
+                    inp=inp, dir=str(out_root / level / f"mosaic_{uid}{suffix}"),
+                    n_sides=(a.n_sides_min, a.n_sides_max),
+                    n_frag=(a.n_frag_min, a.n_frag_max),
+                    canvas=(a.canvas_w, a.canvas_h), seed=seed,
+                    degrade={"erode_px": cfg["erode"], "holes": cfg["holes"], "missing": miss},
+                    rotate=cfg["rotate"], placement=cfg["placement"],
+                    frag_distribution=a.frag_distribution, viz=a.debug, debug=a.debug,
+                    max_area_loss=a.max_area_loss,
+                    label=f"{level} mosaic_{uid}{suffix}"))
+    total = len(tasks)
+    print(f"curriculum [{a.frag_distribution}] : {total} instances → {out_root}/ (jobs={a.jobs})")
+    fails = skips = 0
+
+    def _tally(lab, i):
+        nonlocal fails, skips
+        if lab.startswith("FAIL"):
+            fails += 1
+        elif lab.startswith("skip"):
+            skips += 1
+        if lab.startswith("FAIL") or i % 100 == 0 or i == total:
+            print(f"[{i}/{total}] {lab}")
+
+    if a.jobs <= 1:
+        for i, t in enumerate(tasks, 1):
+            _tally(_run_task(t), i)
+    else:
+        import multiprocessing as mp
+        with mp.Pool(a.jobs) as pool:
+            for i, lab in enumerate(pool.imap_unordered(_run_task, tasks), 1):
+                _tally(lab, i)
+    print(f"\nFait : {total - fails - skips} générées, {skips} sautées (resume), {fails} échecs.")
+    print(f"Collate par palier :\n"
+          f"  for L in {out_root}/L*_*; do python3 forge_mosaics/features/collate.py --dataset \"$L\"; done")
+
+
+if __name__ == "__main__":
+    main()

code/mosaic2fragments/forge_dataset.py

@@ -0,0 +1,1161 @@
+#!/usr/bin/env python3
+"""Forge a LEGO mosaic dataset for YOLO + GNN training.
+
+Inputs: a canvas_mosaic.png produced by ../forge_LAR_2mosaic/ (square, >=40 px per
+stud, grey joints, LEGO palette without greys).
+Outputs (per mosaic, in <out_dir>/mosaic_XXX/):
+    target.png             — copy of the input mosaic
+    source.png             — fragments exploded on a white canvas (YOLO-Seg input)
+    source_yolo.txt        — YOLO-Seg polygons, one line per fragment (THE YOLO ground truth)
+    pieces.json            — detected LEGO pieces (debug only, read nowhere) — opt-in via --debug
+    graph_complete.json    — N nodes (fragment features) + adjacency edges (target)
+    graph_fragments.json   — same N nodes, zero edges (GNN input)
+    gt_layout.json         — exact footprint and pose (x, y, rot) of each fragment
+    degradation.md         — degradation report (empty means clean)
+    fragments/frag_XX.png  — per-fragment alpha crop in target frame
+
+Pipeline:
+    1. Joint detection on the rendered mosaic → LEGO piece layout
+    2. Union-find on cells → pieces (rectangles on the stud grid)
+    3. Piece adjacency graph → region-growing fragmentation (k ∈ [10,15] by default)
+    4. Per-fragment polygon → simplified under an AREA-LOSS budget (--max-area-loss,
+       default 1%), the vertex count being an output, not a target
+    5. Per-fragment features (global) + per-side features
+    6. Fragment adjacency = boundary segments shared between fragments
+    7. Random placement of rotated fragments on a white canvas (axes-aligned + ±5°)
+    8. Polygon export in YOLO-Seg format (normalized)
+"""
+
+import argparse
+import collections
+import heapq
+import json
+import os
+import random
+import sys
+from pathlib import Path
+
+import cv2
+import networkx as nx
+import numpy as np
+from PIL import Image
+
+# Extraction de features = module PARTAGÉ post-YOLO/pré-GNN (features/), importé
+# depuis la racine du repo → forge synthétique et future chaîne YOLO utilisent le
+# MÊME code (alignement de schéma garanti).
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from features.fragment_features import (  # noqa: E402
+    _polygon_signed_area, extract_polygon, resample_reflex_aware,
+    pca_canonical_rotation, compute_fragment_features, MAX_AREA_LOSS_DEFAULT,
+)
+
+
+# ============================================================
+# 1. Joint detection
+# ============================================================
+
+def is_joint_pixel(px, target=136, tol=35):
+    r, g, b = int(px[0]), int(px[1]), int(px[2])
+    if abs(r - target) > tol or abs(g - target) > tol or abs(b - target) > tol:
+        return False
+    if max(r, g, b) - min(r, g, b) > 25:
+        return False
+    return True
+
+
+def _cell_is_gray(img, i, j, stud_size):
+    """True if the interior of cell (i, j) is itself joint-gray (= a gray piece)."""
+    cy = min(j * stud_size + stud_size // 2, img.shape[0] - 1)
+    cx = min(i * stud_size + stud_size // 2, img.shape[1] - 1)
+    return is_joint_pixel(img[cy, cx])
+
+
+def detect_joints(img, stud_size, tolerate_gray=True):
+    """Return joint_v[i, j] (vertical joints) and joint_h[i, j] (horizontal joints).
+
+    joint_v[i, j] = True iff there is a joint between cell (i, j) and (i+1, j).
+    joint_h[i, j] = True iff there is a joint between cell (i, j) and (i, j+1).
+    Convention: i = column index (x-axis), j = row index (y-axis).
+
+    With tolerate_gray=True, a gray boundary is NOT a joint when BOTH adjacent
+    cell interiors are themselves gray — we are inside a gray LEGO piece, not on
+    a real joint. This lets gray pieces stay in the palette. The only
+    unresolvable case is two *different* gray pieces sharing a gray joint (rare,
+    accepted). For mosaics generated without gray pieces this is a strict no-op.
+    """
+    H, W = img.shape[:2]
+    n_cols = W // stud_size
+    n_rows = H // stud_size
+
+    joint_v = np.zeros((n_cols - 1, n_rows), dtype=bool)
+    joint_h = np.zeros((n_cols, n_rows - 1), dtype=bool)
+
+    for i in range(n_cols - 1):
+        x = (i + 1) * stud_size
+        for j in range(n_rows):
+            y_mid = j * stud_size + stud_size // 2
+            samples = [
+                is_joint_pixel(img[j * stud_size + stud_size // 4, x]),
+                is_joint_pixel(img[y_mid, x]),
+                is_joint_pixel(img[j * stud_size + 3 * stud_size // 4, x]),
+            ]
+            is_joint = sum(samples) >= 2
+            if (is_joint and tolerate_gray
+                    and _cell_is_gray(img, i, j, stud_size)
+                    and _cell_is_gray(img, i + 1, j, stud_size)):
+                is_joint = False  # interior of a gray piece, not a joint
+            joint_v[i, j] = is_joint
+
+    for j in range(n_rows - 1):
+        y = (j + 1) * stud_size
+        for i in range(n_cols):
+            x_mid = i * stud_size + stud_size // 2
+            samples = [
+                is_joint_pixel(img[y, i * stud_size + stud_size // 4]),
+                is_joint_pixel(img[y, x_mid]),
+                is_joint_pixel(img[y, i * stud_size + 3 * stud_size // 4]),
+            ]
+            is_joint = sum(samples) >= 2
+            if (is_joint and tolerate_gray
+                    and _cell_is_gray(img, i, j, stud_size)
+                    and _cell_is_gray(img, i, j + 1, stud_size)):
+                is_joint = False
+            joint_h[i, j] = is_joint
+
+    return joint_v, joint_h
+
+
+# ============================================================
+# 2. Piece detection via union-find on cells
+# ============================================================
+
+def detect_pieces(img, stud_size):
+    joint_v, joint_h = detect_joints(img, stud_size)
+    n_cols = joint_v.shape[0] + 1
+    n_rows = joint_h.shape[1] + 1
+
+    parent = {(i, j): (i, j) for i in range(n_cols) for j in range(n_rows)}
+
+    def find(c):
+        while parent[c] != c:
+            parent[c] = parent[parent[c]]
+            c = parent[c]
+        return c
+
+    def union(a, b):
+        ra, rb = find(a), find(b)
+        if ra != rb:
+            parent[ra] = rb
+
+    for i in range(n_cols - 1):
+        for j in range(n_rows):
+            if not joint_v[i, j]:
+                union((i, j), (i + 1, j))
+    for i in range(n_cols):
+        for j in range(n_rows - 1):
+            if not joint_h[i, j]:
+                union((i, j), (i, j + 1))
+
+    groups = collections.defaultdict(list)
+    for c in parent:
+        groups[find(c)].append(c)
+
+    pieces = []
+    for cells in groups.values():
+        cells = sorted(cells)
+        i_min = min(c[0] for c in cells)
+        i_max = max(c[0] for c in cells)
+        j_min = min(c[1] for c in cells)
+        j_max = max(c[1] for c in cells)
+        # Sample interior color from the center of an interior cell
+        ci, cj = cells[len(cells) // 2]
+        cx = ci * stud_size + stud_size // 2
+        cy = cj * stud_size + stud_size // 2
+        color = img[cy, cx][:3].tolist()
+        pieces.append({
+            'cells': cells,
+            'bbox_grid': [i_min, j_min, i_max - i_min + 1, j_max - j_min + 1],
+            'color': [int(c) for c in color],
+        })
+    return pieces
+
+
+# ============================================================
+# 2b. Sanity checks on detected pieces
+# ============================================================
+
+def sanity_check_pieces(pieces, n_cols, n_rows):
+    """Return a list of warning strings if detected pieces look suspicious.
+
+    Checks:
+        - all grid cells are covered exactly once
+        - every piece is rectangular (its cells fill its bbox)
+        - share of 1x1 pieces is not abnormally high (a tell-tale sign of
+          gray-tile false-positive joints, since gray pieces get internally
+          split into 1x1s if joint detection is over-aggressive)
+    """
+    warnings = []
+    total = sum(len(p['cells']) for p in pieces)
+    expected = n_cols * n_rows
+    if total != expected:
+        warnings.append(f"cell coverage: {total} from pieces, expected {expected}")
+
+    seen = set()
+    dup = 0
+    for p in pieces:
+        for c in p['cells']:
+            if c in seen:
+                dup += 1
+            seen.add(c)
+    if dup:
+        warnings.append(f"{dup} cells assigned to multiple pieces")
+
+    non_rect = 0
+    for p in pieces:
+        cells = p['cells']
+        i_min = min(c[0] for c in cells)
+        i_max = max(c[0] for c in cells)
+        j_min = min(c[1] for c in cells)
+        j_max = max(c[1] for c in cells)
+        if len(cells) != (i_max - i_min + 1) * (j_max - j_min + 1):
+            non_rect += 1
+    if non_rect:
+        warnings.append(f"{non_rect}/{len(pieces)} pieces are non-rectangular "
+                        "(joint detection inconsistency)")
+
+    n_1x1 = sum(1 for p in pieces if len(p['cells']) == 1)
+    pct_1x1 = 100.0 * n_1x1 / max(len(pieces), 1)
+    if pct_1x1 > 60.0:
+        warnings.append(
+            f"{pct_1x1:.0f}% of pieces are 1x1 ({n_1x1}/{len(pieces)}). "
+            "Anything above ~60% suggests joint over-detection."
+        )
+
+    # Targeted gray-tile check: a large cluster of 1x1 with a similar near-gray
+    # color is the smoking gun for Light/Dark Bluish Gray false positives.
+    gray_1x1 = []
+    for p in pieces:
+        if len(p['cells']) != 1:
+            continue
+        r, g, b = p['color']
+        if (max(r, g, b) - min(r, g, b) < 25
+                and 80 <= (r + g + b) / 3 <= 200):
+            gray_1x1.append(p)
+    if len(gray_1x1) > 30:
+        warnings.append(
+            f"{len(gray_1x1)} gray-ish 1x1 pieces detected — likely "
+            "Light Bluish Gray / Dark Bluish Gray / Flat Silver / "
+            "Pearl Light Gray / Metallic Silver tiles being mistaken "
+            "for joints. Disable those colors in the palette."
+        )
+    return warnings
+
+
+# ============================================================
+# 3. Piece adjacency graph
+# ============================================================
+
+def build_piece_graph(pieces):
+    cell_to_pid = {}
+    for pid, p in enumerate(pieces):
+        for cell in p['cells']:
+            cell_to_pid[cell] = pid
+
+    g = nx.Graph()
+    for pid in range(len(pieces)):
+        g.add_node(pid)
+    for cell, pid in cell_to_pid.items():
+        i, j = cell
+        for di, dj in [(1, 0), (0, 1)]:
+            neighbor = (i + di, j + dj)
+            if neighbor in cell_to_pid:
+                pid2 = cell_to_pid[neighbor]
+                if pid != pid2:
+                    g.add_edge(pid, pid2)
+    return g
+
+
+# ============================================================
+# 4. Fragmentation by balanced region growing
+# ============================================================
+
+def _bfs_distances(piece_graph, source, dist=None):
+    """Unweighted shortest-path distances from `source` over `piece_graph`.
+    If `dist` is provided, distances are updated only where shorter."""
+    if dist is None:
+        dist = {n: float('inf') for n in piece_graph.nodes}
+    dist[source] = 0
+    queue = collections.deque([source])
+    while queue:
+        u = queue.popleft()
+        for v in piece_graph.neighbors(u):
+            if dist[u] + 1 < dist[v]:
+                dist[v] = dist[u] + 1
+                queue.append(v)
+    return dist
+
+
+def select_seeds_farthest(piece_graph, k):
+    """Farthest-point sampling: each new seed maximises distance to the nearest existing seed."""
+    nodes = list(piece_graph.nodes)
+    first = random.choice(nodes)
+    seeds = [first]
+    dist = _bfs_distances(piece_graph, first)
+    while len(seeds) < k:
+        # Argmax over nodes; ties broken randomly to avoid bias.
+        max_d = max(dist.values())
+        candidates = [n for n, d in dist.items() if d == max_d]
+        nxt = random.choice(candidates)
+        seeds.append(nxt)
+        # Update distance-to-nearest-seed by running BFS from new seed.
+        _bfs_distances(piece_graph, nxt, dist)
+    return seeds
+
+
+def fragment_pieces(piece_graph, k):
+    """Balanced multi-source region growing.
+
+    Seeds are picked via farthest-point sampling (k-center). At each step the
+    currently smallest fragment expands by one queued node — ensuring balanced
+    fragment sizes regardless of local connectivity differences.
+    """
+    nodes = list(piece_graph.nodes)
+    if k >= len(nodes):
+        return {n: i for i, n in enumerate(nodes)}
+
+    seeds = select_seeds_farthest(piece_graph, k)
+    assigned = {s: i for i, s in enumerate(seeds)}
+    frontier = [collections.deque([s]) for s in seeds]
+    sizes = [1] * k
+
+    # Min-heap keyed on (current size, fragment_id) → smallest grows first.
+    # Tie-breaker is fragment_id which is stable.
+    heap = [(1, i) for i in range(k)]
+    heapq.heapify(heap)
+
+    while heap:
+        _, fid = heapq.heappop(heap)
+        if not frontier[fid]:
+            continue
+        current = frontier[fid].popleft()
+        for neighbor in piece_graph.neighbors(current):
+            if neighbor not in assigned:
+                assigned[neighbor] = fid
+                frontier[fid].append(neighbor)
+                sizes[fid] += 1
+        if frontier[fid]:
+            heapq.heappush(heap, (sizes[fid], fid))
+    return assigned
+
+
+def fragment_pieces_compact(piece_graph, pieces, k):
+    """Region growing biaisé COMPACITÉ — `--frag-distribution compact`.
+
+    Comme fragment_pieces, mais à chaque pas le fragment ajoute la pièce-frontière
+    qui **maximise le remplissage de sa bbox** (cellules remplies / aire bbox) →
+    fragments ~rectangulaires, silhouettes régulières, MOINS de coins concaves
+    → `n_max` plus petit. On ne coupe JAMAIS une pièce (les bords suivent les
+    joints) : donc pas de rectangles parfaits à 4 sommets, le signal de bord pour
+    l'appariement GNN survit. **N'altère NI reco-B (⊆ raw) NI le pad+masque** :
+    seule la partition change ; le reste du pipeline est identique à balanced.
+    """
+    nodes = list(piece_graph.nodes)
+    if k >= len(nodes):
+        return {n: i for i, n in enumerate(nodes)}
+
+    # Géométrie par pièce : cellules (set de (i,j)) + périmètre propre (rectangle).
+    pcells = [set(map(tuple, pieces[p]['cells'])) for p in range(len(pieces))]
+    pperim = [2 * (pieces[p]['bbox_grid'][2] + pieces[p]['bbox_grid'][3])
+              for p in range(len(pieces))]
+
+    seeds = select_seeds_farthest(piece_graph, k)
+    assigned = {s: i for i, s in enumerate(seeds)}
+    frag_cells = [set(pcells[s]) for s in seeds]  # cellules par fragment
+    sizes = [1] * k
+    frontier = [set(n for n in piece_graph.neighbors(s) if n not in assigned)
+                for s in seeds]
+
+    heap = [(1, i) for i in range(k)]
+    heapq.heapify(heap)
+    while heap:
+        _, fid = heapq.heappop(heap)
+        cand = [p for p in frontier[fid] if p not in assigned]
+        frontier[fid] = set(cand)
+        if not cand:
+            continue
+        fc = frag_cells[fid]
+
+        def delta_perim(p):
+            # Δpérimètre en ajoutant p = périmètre propre de p − 2×(arêtes partagées
+            # avec le fragment). Remplir une concavité → Δ négatif → bord plus lisse
+            # → moins de coins concaves → reco-B sort moins de sommets.
+            shared = 0
+            for (i, j) in pcells[p]:
+                shared += ((i + 1, j) in fc) + ((i - 1, j) in fc) \
+                        + ((i, j + 1) in fc) + ((i, j - 1) in fc)
+            return (pperim[p] - 2 * shared, -shared, len(pcells[p]))
+
+        best = min(cand, key=delta_perim)         # pièce qui lisse le plus le bord
+        assigned[best] = fid
+        frag_cells[fid] |= pcells[best]
+        sizes[fid] += 1
+        frontier[fid].discard(best)
+        for nb in piece_graph.neighbors(best):
+            if nb not in assigned:
+                frontier[fid].add(nb)
+        heapq.heappush(heap, (sizes[fid], fid))
+
+    # composantes non atteintes (rare : graphe normalement connexe) → rattachées
+    changed = True
+    while changed:
+        changed = False
+        for n in nodes:
+            if n in assigned:
+                continue
+            nbf = [assigned[x] for x in piece_graph.neighbors(n) if x in assigned]
+            if nbf:
+                assigned[n] = nbf[0]
+                changed = True
+    for i, n in enumerate(nodes):                 # tout isolé restant → fragment propre
+        assigned.setdefault(n, k + i)
+    return assigned
+
+
+# ============================================================
+# 5. Fragment polygon and resampling
+# ============================================================
+
+def fragment_mask(fragment_cells, img_shape, stud_size):
+    H, W = img_shape[:2]
+    mask = np.zeros((H, W), dtype=np.uint8)
+    for (i, j) in fragment_cells:
+        x0, y0 = i * stud_size, j * stud_size
+        mask[y0:y0 + stud_size, x0:x0 + stud_size] = 1
+    return mask
+
+
+# extract_polygon, resample_reflex_aware (+ helpers PCA), compute_fragment_features
+# → déplacés dans features/fragment_features.py (module partagé), importés en tête.
+# (resample_polygon équidistant supprimé : remplacé par resample_reflex_aware.)
+
+
+# ============================================================
+# 7. Fragment adjacencies (segments shared between fragments)
+# ============================================================
+
+def compute_fragment_adjacencies(pieces, piece_to_frag, stud_size):
+    cell_to_frag = {}
+    for pid, p in enumerate(pieces):
+        fid = piece_to_frag[pid]
+        for cell in p['cells']:
+            cell_to_frag[cell] = fid
+
+    adj = collections.defaultdict(list)
+    for cell, fid in cell_to_frag.items():
+        i, j = cell
+        right = (i + 1, j)
+        if right in cell_to_frag and cell_to_frag[right] != fid:
+            other = cell_to_frag[right]
+            a, b = min(fid, other), max(fid, other)
+            x = (i + 1) * stud_size
+            adj[(a, b)].append((x, j * stud_size, x, (j + 1) * stud_size))
+        bottom = (i, j + 1)
+        if bottom in cell_to_frag and cell_to_frag[bottom] != fid:
+            other = cell_to_frag[bottom]
+            a, b = min(fid, other), max(fid, other)
+            y = (j + 1) * stud_size
+            adj[(a, b)].append((i * stud_size, y, (i + 1) * stud_size, y))
+    return adj, cell_to_frag
+
+
+def find_outer_fragments_per_side(polygon_n, centroid, frag_id, cell_to_frag,
+                                   stud_size, offset=6, n_samples=7):
+    """For each side of polygon_n, vote over multiple samples along the side
+    to find the most common adjacent fragment (or None if image edge)."""
+    out = []
+    n = len(polygon_n)
+    for i in range(n):
+        p0, p1 = polygon_n[i], polygon_n[(i + 1) % n]
+        votes = collections.Counter()
+        for t in np.linspace(0.15, 0.85, n_samples):
+            sample = (1 - t) * p0 + t * p1
+            outward = sample - centroid
+            norm = float(np.linalg.norm(outward))
+            if norm < 1e-6:
+                continue
+            outer = sample + outward / norm * offset
+            ci, cj = int(outer[0] // stud_size), int(outer[1] // stud_size)
+            if (ci, cj) in cell_to_frag:
+                o = cell_to_frag[(ci, cj)]
+                if o != frag_id:
+                    votes[o] += 1
+        if votes:
+            best, _ = votes.most_common(1)[0]
+            out.append(int(best))
+        else:
+            out.append(None)
+    return out
+
+
+# ============================================================
+# 8. Exploded image: cut + rotate + place
+# ============================================================
+
+def _disk(radius):
+    d = 2 * int(radius) + 1
+    return cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (d, d))
+
+
+def degrade_mask(mask, erode_px=0, n_holes=0, stud_size=40, max_hole_area_frac=0.10):
+    """Degraded copy of a fragment alpha mask — only ever REMOVES material, so
+    degraded ⊆ perfect (keeps the "area never gained" invariant).
+
+    erode_px           : morphological erosion radius in px (boundary wear).
+    n_holes            : interior holes punched (missing tesselae *inside*).
+    max_hole_area_frac : hard cap on TOTAL hole area (default 10% of the
+                         post-erosion fragment area). The n_holes disks share
+                         this budget, so holes never remove more than the cap
+                         (overlaps / boundary clipping only reduce it further).
+    Uses the module RNG (seeded in forge_one) for reproducibility.
+    """
+    m = (mask > 0).astype(np.uint8)
+    if erode_px > 0:
+        m = cv2.erode(m, _disk(erode_px))
+    if n_holes > 0:
+        ys, xs = np.where(m > 0)
+        area = len(xs)
+        if area:
+            budget = max_hole_area_frac * area          # ≤10% of fragment area
+            r = max(1, int(np.sqrt(budget / (n_holes * np.pi))))
+            for _ in range(n_holes):
+                k = random.randint(0, area - 1)
+                cv2.circle(m, (int(xs[k]), int(ys[k])), r, 0, -1)
+    return m
+
+
+def make_fragment_rgba(fragment_cells, target_img, stud_size, mask=None):
+    if mask is None:
+        mask = fragment_mask(fragment_cells, target_img.shape, stud_size)
+    mask = (mask > 0).astype(np.uint8)
+    ys, xs = np.where(mask > 0)
+    y_min, y_max = int(ys.min()), int(ys.max())
+    x_min, x_max = int(xs.min()), int(xs.max())
+    crop = target_img[y_min:y_max + 1, x_min:x_max + 1]
+    crop_mask = mask[y_min:y_max + 1, x_min:x_max + 1]
+    rgba = np.dstack([crop, crop_mask * 255]).astype(np.uint8)
+    return rgba, (x_min, y_min, x_max, y_max)
+
+
+def rotate_rgba(rgba, angle):
+    pil = Image.fromarray(rgba, 'RGBA')
+    rot = pil.rotate(angle, resample=Image.BILINEAR, expand=True)
+    return np.array(rot)
+
+
+def _collides(x, y, alpha, occupied):
+    """True if fragment alpha placed at (x, y) overlaps any occupied mask."""
+    h, w = alpha.shape
+    for (ox, oy, omask) in occupied:
+        oh, ow = omask.shape
+        ix1, iy1 = max(x, ox), max(y, oy)
+        ix2, iy2 = min(x + w, ox + ow), min(y + h, oy + oh)
+        if ix1 >= ix2 or iy1 >= iy2:
+            continue
+        a = alpha[iy1 - y:iy2 - y, ix1 - x:ix2 - x]
+        b = omask[iy1 - oy:iy2 - oy, ix1 - ox:ix2 - ox]
+        if np.logical_and(a, b).any():
+            return True
+    return False
+
+
+def _scan_free_position(alpha, occupied, cw, ch, padding, step):
+    """Deterministic raster scan for the first non-overlapping top-left position.
+    Returns None only if no free spot exists anywhere on the current canvas."""
+    h, w = alpha.shape
+    y = padding
+    while y + h + padding <= ch:
+        x = padding
+        while x + w + padding <= cw:
+            if not _collides(x, y, alpha, occupied):
+                return x, y
+            x += step
+        y += step
+    return None
+
+
+def explode_fragments(fragments_data, target_size, base_factor=1.8, padding=4,
+                      max_factor=4.0, step=0.3):
+    """Placement « vue éclatée » — curriculum L0.
+
+    Chaque fragment GARDE sa position RELATIVE dans la mosaïque, simplement
+    écarté de ses voisins (≈ schéma de montage éclaté). Contrairement au scatter
+    aléatoire (place_fragments), aucun échange de position : un fragment du coin
+    haut-gauche reste en haut-gauche. On dilate les centroïdes-cible par un
+    facteur autour du centre, en l'augmentant jusqu'à supprimer les
+    chevauchements. Renvoie (canvas, placements en ordre d'entrée, taille).
+    """
+    W, H = target_size
+    fac = base_factor
+    while True:
+        cw, ch = int(round(W * fac)), int(round(H * fac))
+        cxt, cyt, cxc, cyc = W / 2.0, H / 2.0, cw / 2.0, ch / 2.0
+        placements, occupied, overlap = [], [], False
+        for f in fragments_data:
+            rgba = f['rgba_rotated']
+            h, w = rgba.shape[:2]
+            alpha = rgba[..., 3] > 0
+            x0, y0, x1, y1 = f['bbox_in_target']
+            x = int(round(cxc + fac * ((x0 + x1) / 2.0 - cxt) - w / 2.0))
+            y = int(round(cyc + fac * ((y0 + y1) / 2.0 - cyt) - h / 2.0))
+            x = max(padding, min(x, cw - w - padding))
+            y = max(padding, min(y, ch - h - padding))
+            if _collides(x, y, alpha, occupied):
+                overlap = True
+            placements.append({'x': x, 'y': y, 'w': w, 'h': h})
+            occupied.append((x, y, alpha))
+        if not overlap or fac >= max_factor:
+            break
+        fac += step
+    canvas = Image.new('RGB', (cw, ch), (255, 255, 255))
+    for f, place in zip(fragments_data, placements):
+        pil = Image.fromarray(f['rgba_rotated'], 'RGBA')
+        canvas.paste(pil, (place['x'], place['y']), pil)
+    return canvas, placements, (cw, ch)
+
+
+def place_fragments(fragments_data, canvas_size, max_tries=200, padding=4):
+    """Scatter fragments on a white canvas WITHOUT overlap.
+
+    Per fragment (largest first): (1) random search, to keep the scattered look;
+    (2) deterministic raster scan — guaranteed to find a free spot if one exists;
+    (3) last resort, grow the canvas downward. Steps 2-3 replace the old
+    "place at random, may overlap" fallback that caused the mosaic_004 overlaps.
+    Returns the (possibly grown) canvas size so the caller normalises YOLO
+    coordinates against the right dimensions.
+    """
+    cw, ch = canvas_size
+    placements_by_id = {}
+    occupied = []  # list of (x, y, alpha_mask)
+
+    # Place larger fragments first to ease packing
+    order = sorted(range(len(fragments_data)),
+                   key=lambda k: -fragments_data[k]['rgba_rotated'].shape[0] *
+                                  fragments_data[k]['rgba_rotated'].shape[1])
+
+    for k in order:
+        rgba = fragments_data[k]['rgba_rotated']
+        h, w = rgba.shape[:2]
+        alpha = rgba[..., 3] > 0
+
+        # Fragment larger than the canvas → grow so it (and the random range) fit.
+        while w + 2 * padding > cw:
+            cw += w
+        while h + 2 * padding > ch:
+            ch += h
+
+        pos = None
+        for _ in range(max_tries):
+            x = random.randint(padding, cw - w - padding)
+            y = random.randint(padding, ch - h - padding)
+            if not _collides(x, y, alpha, occupied):
+                pos = (x, y)
+                break
+
+        if pos is None:
+            # Random search exhausted: deterministic scan is guaranteed to find a
+            # gap if the canvas still has room (mosaic_004 fix).
+            step = max(16, min(h, w) // 2)
+            pos = _scan_free_position(alpha, occupied, cw, ch, padding, step)
+
+        if pos is None:
+            # Canvas genuinely full: add a strip at the bottom and drop it there.
+            pos = (padding, ch + padding)
+            ch += h + 2 * padding
+
+        x, y = pos
+        placements_by_id[k] = {'x': x, 'y': y, 'w': w, 'h': h}
+        occupied.append((x, y, alpha))
+
+    canvas = Image.new('RGB', (cw, ch), (255, 255, 255))
+    placements = []
+    # Paste in original index order (deterministic z-order).
+    for idx, fdata in enumerate(fragments_data):
+        place = placements_by_id[idx]
+        pil = Image.fromarray(fdata['rgba_rotated'], 'RGBA')
+        canvas.paste(pil, (place['x'], place['y']), pil)
+        placements.append(place)
+    return canvas, placements, (cw, ch)
+
+
+# ============================================================
+# 9. YOLO polygon export from rotated alpha
+# ============================================================
+
+def extract_yolo_polygon(rgba_rotated, place_x, place_y, canvas_size, simplify_epsilon=1.5):
+    alpha = (rgba_rotated[..., 3] > 0).astype(np.uint8)
+    contours, _ = cv2.findContours(alpha, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not contours:
+        return None
+    cnt = max(contours, key=cv2.contourArea)
+    if simplify_epsilon > 0:
+        cnt = cv2.approxPolyDP(cnt, simplify_epsilon, True)
+    cnt = cnt.reshape(-1, 2).astype(np.float32)
+    cnt[:, 0] = (cnt[:, 0] + place_x) / canvas_size[0]
+    cnt[:, 1] = (cnt[:, 1] + place_y) / canvas_size[1]
+    return cnt
+
+
+# ============================================================
+# 10. Top-level orchestration
+# ============================================================
+
+def forge_one(target_path, out_dir, n_sides_range, n_frag_range, canvas_size,
+              stud_size, seed, degrade=None, rotate=True, placement='scatter',
+              frag_distribution='balanced', debug=False,
+              max_area_loss=MAX_AREA_LOSS_DEFAULT):
+    if seed is not None:
+        random.seed(seed)
+        np.random.seed(seed)
+
+    degrade = degrade or {}
+    erode_rng = tuple(degrade.get('erode_px', (0, 0)))
+    holes_rng = tuple(degrade.get('holes', (0, 0)))
+    missing_rng = tuple(degrade.get('missing', (0, 0)))  # absolute count [min, max]
+
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    (out_dir / 'fragments').mkdir(exist_ok=True)       # toujours écrit (entrée du VLM)
+
+    pil = Image.open(target_path).convert('RGB')
+    img = np.array(pil)
+    H, W = img.shape[:2]
+    if stud_size is None:
+        # Grille la PLUS FINE valide : plus grand g divisant l'image avec un
+        # stud résultant ≥ 40 px (contrainte projet : ≥40 px/stud). Désambiguïse
+        # les images divisibles par plusieurs tailles (ex. 3840 = 48·80 = 96·40
+        # → grille 96, stud 40) au lieu de retomber sur la grille la plus
+        # grossière. Les mosaïques 1920 restent en grille 48 (stud 40).
+        candidates = [g for g in (48, 50, 64, 96, 100, 128)
+                      if W % g == 0 and H % g == 0 and W // g >= 40]
+        stud_size = W // max(candidates) if candidates else 40
+    print(f"[forge] image {W}x{H}, stud_size={stud_size} → grid {W // stud_size}x{H // stud_size}")
+
+    print("[forge] detecting LEGO pieces…")
+    pieces = detect_pieces(img, stud_size)
+    print(f"[forge]   {len(pieces)} pieces detected")
+
+    n_cols, n_rows = W // stud_size, H // stud_size
+    warnings = sanity_check_pieces(pieces, n_cols, n_rows)
+    for w in warnings:
+        print(f"[warn] {w}")
+
+    piece_graph = build_piece_graph(pieces)
+
+    k = random.randint(n_frag_range[0], n_frag_range[1])
+    print(f"[forge] fragmenting into {k} fragments ({frag_distribution})…")
+    # ultracompact = compact appliqué à des mosaïques 1×1 (mode mono) → la
+    # fragmentation est la MÊME que compact ; "l'ultra" vient de l'input 1×1.
+    if frag_distribution in ('compact', 'ultracompact'):
+        piece_to_frag = fragment_pieces_compact(piece_graph, pieces, k)
+    else:
+        piece_to_frag = fragment_pieces(piece_graph, k)
+    frag_pieces = collections.defaultdict(list)
+    for pid, fid in piece_to_frag.items():
+        frag_pieces[fid].append(pid)
+    actual_k = len(frag_pieces)
+    print(f"[forge]   {actual_k} non-empty fragments")
+
+    adjacencies, cell_to_frag = compute_fragment_adjacencies(pieces, piece_to_frag, stud_size)
+    print(f"[forge]   {len(adjacencies)} fragment-fragment adjacencies")
+
+    print("[forge] extracting polygons & features per fragment…")
+    fragment_data = []
+    sorted_fids = sorted(frag_pieces.keys())
+    fid_to_idx = {fid: idx for idx, fid in enumerate(sorted_fids)}
+
+    for fid in sorted_fids:
+        all_cells = []
+        weighted_color = np.zeros(3, dtype=np.float64)
+        total_cells = 0
+        for pid in frag_pieces[fid]:
+            all_cells.extend(pieces[pid]['cells'])
+            n_cells = len(pieces[pid]['cells'])
+            weighted_color += np.array(pieces[pid]['color'], dtype=np.float64) * n_cells
+            total_cells += n_cells
+        mean_color = (weighted_color / max(total_cells, 1)).tolist()
+
+        mask = fragment_mask(all_cells, img.shape, stud_size)
+        polygon_raw = extract_polygon(mask)          # PERFECT footprint → GT
+        # --- degradation: input only (the GT polygon_raw stays perfect) ---
+        erode_px = random.randint(*erode_rng) if erode_rng[1] > 0 else 0
+        n_holes = random.randint(*holes_rng) if holes_rng[1] > 0 else 0
+        if erode_px or n_holes:
+            mask_in = degrade_mask(mask, erode_px, n_holes, stud_size)
+            polygon_raw_deg = extract_polygon(mask_in)
+            if len(polygon_raw_deg) >= 4:
+                # erosion/holes add rasterisation noise (1px stair-steps) that
+                # would explode #reflex → simplify so reco B keeps n reasonable.
+                eps = max(1.5, stud_size * 0.06)
+                cnt = polygon_raw_deg.reshape(-1, 1, 2).astype(np.float32)
+                polygon_raw_deg = cv2.approxPolyDP(cnt, eps, True).reshape(-1, 2).astype(np.float32)
+            if len(polygon_raw_deg) < 4:             # degradation wiped it → revert
+                mask_in = (mask > 0).astype(np.uint8)
+                polygon_raw_deg = polygon_raw
+        else:
+            mask_in = (mask > 0).astype(np.uint8)
+            polygon_raw_deg = polygon_raw
+
+        # Degradation severity = area lost by the degraded footprint vs the
+        # perfect one (DERIVED metric, not an input knob — cf. reco/06/06).
+        perf_area = abs(_polygon_signed_area(polygon_raw)) if len(polygon_raw) >= 3 else 0.0
+        deg_area = abs(_polygon_signed_area(np.asarray(polygon_raw_deg, dtype=np.float64))) \
+            if len(polygon_raw_deg) >= 3 else 0.0
+        lost_frac = float(1.0 - deg_area / perf_area) if perf_area > 0 else 0.0
+
+        # reco B : budget sur la PERTE D'AIRE (ε), n en sortie. `n_sides_range`
+        # est CONSERVÉ comme plancher optionnel mais n'est plus le budget — cf.
+        # resample_reflex_aware (correctif 23/07/2026).
+        polygon_n = resample_reflex_aware(polygon_raw_deg, n_min=0,
+                                          max_area_loss=max_area_loss)  # INPUT, ⊆ perfect
+        centroid = polygon_n.mean(axis=0)
+        # rotation-invariance : repère canonique PCA (sur le masque observé)
+        R = pca_canonical_rotation(mask_in)
+        polygon_canon = ((polygon_n - centroid) @ R.T).astype(np.float32)
+        pca_angle = float(np.degrees(np.arctan2(R[0, 1], R[0, 0])))  # axe majeur (repère image)
+
+        global_feat, side_feat = compute_fragment_features(
+            polygon_n, float(len(all_cells) * stud_size * stud_size),
+            mean_color, img, polygon_geom=polygon_canon
+        )
+        outer_per_side = find_outer_fragments_per_side(
+            polygon_n, centroid, fid, cell_to_frag, stud_size
+        )
+        # Translate fragment_id → contiguous node index
+        outer_per_side = [fid_to_idx[o] if o is not None and o in fid_to_idx else None
+                          for o in outer_per_side]
+
+        rgba, bbox = make_fragment_rgba(all_cells, img, stud_size, mask=mask_in)
+        # rotate=False → curriculum L1 : fragments éclatés par TRANSLATION seule
+        # (palier le plus facile : YOLO/pose n'a pas à résoudre l'orientation).
+        angle = (random.choice([0, 90, 180, 270]) + random.uniform(-5.0, 5.0)) if rotate else 0.0
+        rgba_rot = rotate_rgba(rgba, angle) if rotate else rgba
+
+        fragment_data.append({
+            'node_id': fid_to_idx[fid],
+            'cells': all_cells,
+            'piece_ids': frag_pieces[fid],
+            'polygon_raw': polygon_raw.tolist(),
+            'polygon_raw_degraded': np.asarray(polygon_raw_deg).tolist(),
+            'degradation_lost_frac': lost_frac,
+            'erode_px': int(erode_px),
+            'n_holes': int(n_holes),
+            'polygon_n': polygon_n.tolist(),
+            'polygon_n_canonical': polygon_canon.tolist(),  # repère PCA (invariant rotation)
+            'pca_angle_deg': pca_angle,
+            'global_features': global_feat,
+            'side_features': side_feat,
+            'mean_color': [float(c) for c in mean_color],
+            'rgba': rgba,
+            'rgba_rotated': rgba_rot,
+            'rotation_angle': float(angle),
+            'bbox_in_target': bbox,
+            'outer_per_side': outer_per_side,
+        })
+
+    # --- missing fragments: removed from the exploded INPUT, kept in the GT ---
+    missing_ids = set()
+    if missing_rng[1] > 0 and len(fragment_data) > 1:
+        n_missing = min(random.randint(missing_rng[0], missing_rng[1]),
+                        len(fragment_data) - 1)  # keep at least one fragment
+        if n_missing > 0:
+            missing_ids = set(random.sample(
+                [f['node_id'] for f in fragment_data], n_missing))
+            print(f"[forge]   {len(missing_ids)} fragment(s) marked missing (input only)")
+    present = [f for f in fragment_data if f['node_id'] not in missing_ids]
+
+    if placement == 'explode':
+        # L0 : vue éclatée (positions relatives conservées, juste espacées)
+        print("[forge] placing fragments (exploded view, relative layout kept)…")
+        canvas, placements, canvas_size = explode_fragments(present, (W, H))
+    else:
+        print(f"[forge] placing fragments on {canvas_size[0]}x{canvas_size[1]} white canvas…")
+        requested_size = canvas_size
+        canvas, placements, canvas_size = place_fragments(present, canvas_size)
+        if canvas_size != requested_size:
+            print(f"[forge]   canvas grown to {canvas_size[0]}x{canvas_size[1]} to fit all fragments")
+    for f, place in zip(present, placements):
+        f['placement'] = place
+
+    print("[forge] extracting YOLO polygons…")
+    yolo_lines = []
+    for fdata, place in zip(present, placements):
+        poly = extract_yolo_polygon(
+            fdata['rgba_rotated'], place['x'], place['y'], canvas_size
+        )
+        if poly is None:
+            continue
+        coords = ' '.join(f'{v:.6f}' for v in poly.flatten())
+        yolo_lines.append(f'0 {coords}')
+
+    print("[forge] writing outputs…")
+    pil.save(out_dir / 'target.png')
+    canvas.save(out_dir / 'source.png')
+    (out_dir / 'source_yolo.txt').write_text('\n'.join(yolo_lines) + '\n')
+
+    # Crops par fragment : toujours écrits (entrée du VLM).
+    for fdata in present:
+        Image.fromarray(fdata['rgba'], 'RGBA').save(
+            out_dir / 'fragments' / f"frag_{fdata['node_id']:02d}.png"
+        )
+    # pieces.json = DEBUG pur (pièces LEGO détectées) : n'entraîne PAS le YOLO (c'est
+    # source_yolo.txt), pas lu par visualize.py, lu NULLE PART → OFF par défaut,
+    # opt-in via --debug (~−0.8 Mo/instance, soit ~20 Go sur 25 000).
+    if debug:
+        pieces_json = [{
+            'cells': p['cells'],
+            'bbox_grid': p['bbox_grid'],
+            'color': p['color'],
+        } for p in pieces]
+        (out_dir / 'pieces.json').write_text(json.dumps(pieces_json, indent=2))
+
+    # Build two node representations:
+    #   - 'gnn_input': features the GNN may legitimately consume (no target-frame
+    #     position leak). polygon_n_canonical = polygon centred at the origin.
+    #   - 'target_info': ground-truth position/orientation, used as supervision
+    #     and for viz. NOT to be fed to the GNN as input.
+    def split_node(f):
+        gf = f['global_features']  # [area, perim, cx, cy, R, G, B, bbox_w, bbox_h]
+        # gnn_input = DOMAINE-AGNOSTIQUE (transférable LEGO→fresque) — aucune feature LEGO-only.
+        gnn_input = [gf[0], gf[1], gf[4], gf[5], gf[6], gf[7], gf[8]]  # area, perim, R, G, B, bbox_w, bbox_h
+        return {
+            'gnn_input': gnn_input,
+            'n_sides': len(f['polygon_n_canonical']),
+            'polygon_n_canonical': f['polygon_n_canonical'],   # repère PCA (invariant rotation)
+            'side_features': f['side_features'],
+            'target_info': {
+                'centroid': [gf[2], gf[3]],
+                'pca_angle_deg': f['pca_angle_deg'],           # orientation retirée de l'input → GT
+                'polygon_n_absolute': f['polygon_n'],
+                'polygon_raw': f['polygon_raw'],
+                'mean_color': f['mean_color'],
+                'n_pieces': len(f['piece_ids']),
+            },
+        }
+
+    mean_lost = (float(np.mean([f['degradation_lost_frac'] for f in fragment_data]))
+                 if fragment_data else 0.0)
+    nodes_full = [{'node_id': f['node_id'], 'missing': f['node_id'] in missing_ids,
+                   **split_node(f)} for f in fragment_data]
+    # graph_fragments = INPUT: missing fragments are not observed → excluded.
+    nodes_input_only = [
+        {k: v for k, v in n.items() if k not in ('target_info', 'missing')}
+        for n in nodes_full if not n['missing']
+    ]
+
+    edges_json = []
+    for (fa, fb), segments in adjacencies.items():
+        a = fid_to_idx[fa]
+        b = fid_to_idx[fb]
+        total_length = float(sum(
+            np.sqrt((s[2] - s[0]) ** 2 + (s[3] - s[1]) ** 2) for s in segments
+        ))
+        angles = [float(np.arctan2(s[3] - s[1], s[2] - s[0])) for s in segments]
+        mean_angle = float(np.mean(angles))
+        a_sides = [i for i, o in enumerate(fragment_data[a]['outer_per_side']) if o == b]
+        b_sides = [i for i, o in enumerate(fragment_data[b]['outer_per_side']) if o == a]
+        edges_json.append({
+            'src': a, 'dst': b,
+            'features': [total_length, mean_angle, float(len(segments))],
+            'src_side_idx': a_sides,
+            'dst_side_idx': b_sides,
+            'polyline_raw': [list(s) for s in segments],
+        })
+
+    common_meta = {
+        'max_area_loss': max_area_loss,          # ε — LE budget de reco B (fidélité)
+        'n_sides_range': list(n_sides_range),    # OBSOLÈTE depuis le 23/07/2026 (info seule)
+        'n_sides_note': ("polygon_n_canonical / side_features ont une longueur "
+                         "VARIABLE par nœud (cf. champ 'n_sides' de chaque nœud). "
+                         "Reco B reflex-aware : polygon_n ⊆ polygon_raw (l'aire "
+                         "n'est jamais gagnée). Plancher dur = nb de sommets "
+                         "concaves. Pour un tenseur fixe côté GNN : padder au max "
+                         "des 'n_sides' du dataset + masque de validité."),
+        'gnn_input_feature_names': ['area', 'perimeter', 'R', 'G', 'B', 'bbox_w', 'bbox_h'],
+        'feature_convention_note': (
+            "gnn_input = features 100 % DOMAINE-AGNOSTIQUES (transférables LEGO→fresque ; "
+            "aucune feature LEGO-only). polygon_n_canonical / side_features ont une longueur "
+            "VARIABLE (n_sides) → côté GNN : padder à n_max + masque (cf. features/collate.py), "
+            "ou set-encoder. area/perimeter/bbox sont en PIXELS (non normalisés) ; "
+            "normaliser avant transfert cross-échelle."),
+        'side_feature_names': ['length', 'angle', 'R', 'G', 'B'],
+        'edge_feature_names': ['shared_length', 'mean_angle', 'n_segments'],
+        'target_info_note': "centroid/polygon_n_absolute/polygon_raw are in the "
+                            "target frame and MUST NOT be fed to the GNN as "
+                            "input — they are supervision targets / metadata.",
+        'degradation': {
+            'erode_px': list(erode_rng),
+            'holes': list(holes_rng),
+            'missing': list(missing_rng),
+            'n_missing': len(missing_ids),
+            'mean_lost_frac': round(mean_lost, 4),   # sévérité moyenne (métrique dérivée)
+            'note': "Dégradation appliquée à l'INPUT seulement ; la GT (arêtes + "
+                    "target_info.polygon_raw perfect) reste sur la partition intacte. "
+                    "mean_lost_frac = aire moyenne perdue (parfait→dégradé), métrique "
+                    "post-hoc de sévérité, pas un paramètre d'entrée.",
+        },
+    }
+
+    graph_complete = dict(common_meta, nodes=nodes_full, edges=edges_json)
+    (out_dir / 'graph_complete.json').write_text(json.dumps(graph_complete, indent=2))
+
+    graph_fragments = dict(common_meta, nodes=nodes_input_only, edges=[])
+    (out_dir / 'graph_fragments.json').write_text(json.dumps(graph_fragments, indent=2))
+
+    # gt_layout.json — ground truth for the RECONSTRUCTION metric (IoU / Q_pos).
+    # Per fragment: its exact footprint in target.png (polygon_raw) + the reco-B
+    # polygon, both in target coords, plus where it sits in the exploded source.
+    # The GNN+pose / VLM prediction is scored against these placed polygons.
+    gt_fragments = []
+    for f in fragment_data:
+        gf = f['global_features']
+        place = f.get('placement')
+        gt_fragments.append({
+            'node_id': f['node_id'],
+            'missing': f['node_id'] in missing_ids,
+            'polygon_raw': f['polygon_raw'],              # PERFECT footprint, target coords
+            'polygon_raw_degraded': f['polygon_raw_degraded'],  # what the model sees (eroded/holed)
+            'degradation_lost_frac': round(f['degradation_lost_frac'], 4),
+            'polygon_n': f['polygon_n'],                  # reco-B polygon, target coords
+            'centroid': [gf[2], gf[3]],
+            'bbox_target': list(f['bbox_in_target']),
+            'area': gf[0],
+            'source_placement': (                         # location in source.png (exploded)
+                {'x': place['x'], 'y': place['y'], 'w': place['w'], 'h': place['h'],
+                 'rotation_deg': f['rotation_angle']}
+                if place is not None else None            # None ⟺ missing fragment
+            ),
+        })
+    gt_layout = {
+        'mosaic': out_dir.name,
+        'target_size': [W, H],
+        'canvas_size': [canvas_size[0], canvas_size[1]],
+        'mean_degradation_lost_frac': round(mean_lost, 4),
+        'note': ("Vérité terrain pour la métrique de RECONSTRUCTION (IoU / Q_pos). "
+                 "polygon_raw = footprint exact du fragment dans target.png ; on y "
+                 "compare la prédiction GNN+pose / VLM (fragment replacé). "
+                 "source_placement = pose du fragment dans source.png (éclaté)."),
+        'fragments': gt_fragments,
+    }
+    (out_dir / 'gt_layout.json').write_text(json.dumps(gt_layout, indent=2))
+
+    # degradation.md — rapport lisible : paramètres tirés + aire perdue par fragment
+    report = [
+        f"# Dégradation — {out_dir.name}", "",
+        "## Configuration (intervalles ; tirage aléatoire par fragment)",
+        f"- Érosion morpho : `{list(erode_rng)}` px",
+        f"- Trous internes : `{list(holes_rng)}` (aire totale plafonnée à 10 % du fragment)",
+        f"- Fragments manquants : `{list(missing_rng)}` → **{len(missing_ids)}** tiré(s)",
+        f"- Reco B — perte d'aire tolérée : `{max_area_loss:.1%}` (ε ; n en sortie, "
+        f"plancher dur = #reflex)", "",
+        "## Par fragment",
+        "| node_id | manquant | érosion px | trous | n sommets | aire perdue % |",
+        "|---:|:---:|---:|---:|---:|---:|",
+    ]
+    for f in fragment_data:
+        report.append(
+            f"| {f['node_id']} | {'oui' if f['node_id'] in missing_ids else '—'} "
+            f"| {f['erode_px']} | {f['n_holes']} | {len(f['polygon_n'])} "
+            f"| {100 * f['degradation_lost_frac']:.1f} |")
+    report += [
+        "", "## Résumé",
+        f"- **Aire moyenne perdue par fragment : {100 * mean_lost:.2f} %**",
+        f"- Fragments manquants : {sorted(missing_ids) if missing_ids else 'aucun'}",
+        f"- Total fragments : {len(fragment_data)} (présents dans l'input : {len(present)})",
+        "",
+    ]
+    (out_dir / 'degradation.md').write_text("\n".join(report))
+
+    print(f"[forge] done → {out_dir}")
+    print(f"        pieces={len(pieces)}  fragments={len(fragment_data)}  "
+          f"adjacencies={len(edges_json)}")
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--input', default='exp1/canvas_mosaic.png',
+                   help='Path to canvas_mosaic.png (target)')
+    p.add_argument('--out', default='dataset/mosaic_001',
+                   help='Output directory')
+    p.add_argument('--seed', type=int, default=42)
+    p.add_argument('--n-sides-min', type=int, default=16,
+                   help='Min target vertex count per fragment (reco B, variable n)')
+    p.add_argument('--n-sides-max', type=int, default=24,
+                   help='Max target vertex count per fragment (floor = #reflex)')
+    p.add_argument('--max-area-loss', type=float, default=MAX_AREA_LOSS_DEFAULT,
+                   help="reco B — fraction d'aire que polygon_n a le droit de PERDRE "
+                        "vs polygon_raw (défaut 0.01 = 1%%). C'est LE budget ; le nombre "
+                        "de sommets en découle. Remplace --n-sides-min/max (23/07/2026)")
+    p.add_argument('--n-frag-min', type=int, default=10)
+    p.add_argument('--n-frag-max', type=int, default=15)
+    p.add_argument('--canvas-w', type=int, default=3500)
+    p.add_argument('--canvas-h', type=int, default=3500)
+    p.add_argument('--stud-size', type=int, default=None,
+                   help='Pixels per stud (auto-detected from image size if omitted)')
+    p.add_argument('--no-rotation', action='store_true',
+                   help='Curriculum L1 : fragments éclatés SANS rotation (translation seule)')
+    p.add_argument('--placement', choices=['scatter', 'explode'], default='scatter',
+                   help="explode = curriculum L0 : vue éclatée (positions relatives "
+                        "gardées, juste espacées) ; scatter = placement aléatoire (défaut)")
+    p.add_argument('--frag-distribution', choices=['balanced', 'compact', 'ultracompact'],
+                   default='balanced',
+                   help="motif de découpe : balanced (BFS, défaut), compact (~rectangulaire), "
+                        "ou ultracompact (= compact, à utiliser sur des mosaïques 1×1 `--mode mono`). "
+                        "voronoi/clusters = à venir")
+    p.add_argument('--debug', action='store_true',
+                   help="écrit aussi pieces.json (debug du détecteur de pièces, lu nulle "
+                        "part) ; OFF par défaut")
+    # --- degradation knobs (curriculum) ; all default OFF → clean reco-B ---
+    p.add_argument('--erode-px-min', type=int, default=0,
+                   help='Min boundary-erosion radius in px (DAFNE E)')
+    p.add_argument('--erode-px-max', type=int, default=0,
+                   help='Max boundary-erosion radius in px (0 = no erosion)')
+    p.add_argument('--holes-min', type=int, default=0,
+                   help='Min interior holes per fragment')
+    p.add_argument('--holes-max', type=int, default=0,
+                   help='Max interior holes per fragment (0 = no holes)')
+    p.add_argument('--missing-min', type=int, default=0,
+                   help='Min number of fragments removed from the input (DAFNE C)')
+    p.add_argument('--missing-max', type=int, default=0,
+                   help='Max number of fragments removed from the input (0 = none)')
+    return p.parse_args()
+
+
+def degrade_from_args(args):
+    return {
+        'erode_px': (args.erode_px_min, args.erode_px_max),
+        'holes': (args.holes_min, args.holes_max),
+        'missing': (args.missing_min, args.missing_max),
+    }
+
+
+def main():
+    args = parse_args()
+    forge_one(
+        target_path=args.input,
+        out_dir=args.out,
+        n_sides_range=(args.n_sides_min, args.n_sides_max),
+        max_area_loss=args.max_area_loss,
+        n_frag_range=(args.n_frag_min, args.n_frag_max),
+        canvas_size=(args.canvas_w, args.canvas_h),
+        stud_size=args.stud_size,
+        seed=args.seed,
+        degrade=degrade_from_args(args),
+        rotate=not args.no_rotation,
+        placement=args.placement,
+        frag_distribution=args.frag_distribution,
+        debug=args.debug,
+    )
+
+
+if __name__ == '__main__':
+    main()

code/mosaic2fragments/visualize.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Quick visualization: overlay YOLO polygons on source.png to check alignment.
+
+Also reports any sanity-check failures (fragment count vs YOLO lines, etc.).
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+
+COLORS = [
+    (231, 76, 60), (52, 152, 219), (241, 196, 15), (46, 204, 113),
+    (155, 89, 182), (52, 73, 94), (230, 126, 34), (26, 188, 156),
+    (192, 57, 43), (41, 128, 185), (243, 156, 18), (39, 174, 96),
+    (142, 68, 173), (44, 62, 80), (211, 84, 0), (22, 160, 133),
+]
+
+
+def visualize(dataset_dir):
+    d = Path(dataset_dir)
+    src = Image.open(d / 'source.png').convert('RGBA')
+    W, H = src.size
+
+    overlay = Image.new('RGBA', src.size, (0, 0, 0, 0))
+    draw = ImageDraw.Draw(overlay)
+
+    with open(d / 'source_yolo.txt') as f:
+        lines = [l.strip() for l in f if l.strip()]
+    print(f"YOLO lines: {len(lines)}")
+
+    for idx, line in enumerate(lines):
+        parts = line.split()
+        cls = parts[0]
+        coords = [float(x) for x in parts[1:]]
+        pts = [(coords[i] * W, coords[i + 1] * H) for i in range(0, len(coords), 2)]
+        color = COLORS[idx % len(COLORS)]
+        draw.polygon(pts, outline=color + (255,), fill=color + (90,))
+
+    out = Image.alpha_composite(src, overlay)
+    out_path = d / 'source_yolo_viz.png'
+    out.convert('RGB').save(out_path)
+    print(f"Wrote {out_path}")
+
+    # Sanity: cross-check with graph_complete.json
+    g = json.loads((d / 'graph_complete.json').read_text())
+    print(f"Graph nodes: {len(g['nodes'])}")
+    print(f"Graph edges: {len(g['edges'])}")
+    sizes = [n['target_info']['n_pieces'] for n in g['nodes']]  # n_pieces (métadonnée GT)
+    print(f"Fragment sizes (n_pieces): min={min(sizes):.0f} max={max(sizes):.0f} "
+          f"mean={np.mean(sizes):.1f}")
+
+
+def visualize_recob(dataset_dir):
+    """Viz des DEUX pertes d'aire, en repère target (depuis `gt_layout.json`).
+
+    Par fragment, trois couches :
+      couleur pâle  = `polygon_raw` (empreinte PARFAITE)
+      hachures GRISES fines       = perte de DÉGRADATION (raw − raw_degraded :
+                                    érosion, trous — voulue, c'est l'input L3/L4)
+      hachures COULEUR marquées   = perte d'ENCODAGE reco-B (raw_degraded −
+                                    polygon_n : budget --max-area-loss, ~ε)
+      trait noir    = `polygon_n` (ce que voit le GNN)
+    NB : `source.png` n'est PAS affecté par la perte d'encodage (vrais pixels
+    découpés par le masque dégradé) — elle n'existe que dans polygon_n.
+    """
+    import cv2
+
+    d = Path(dataset_dir)
+    gl = json.loads((d / 'gt_layout.json').read_text())
+    W, H = gl['target_size']
+    img = np.full((H, W, 3), 255, dtype=np.uint8)
+
+    hatch = np.zeros((H, W), dtype=np.uint8)          # trame diagonale //
+    for c in range(-H, W, 14):
+        cv2.line(hatch, (c, 0), (c + H, H), 1, 2)
+    hatch2 = np.zeros((H, W), dtype=np.uint8)         # trame croisée \\ serrée
+    for c in range(-H, W, 8):
+        cv2.line(hatch2, (c + H, 0), (c, H), 1, 1)
+
+    deg_total = enc_total = raw_total = 0.0
+    for idx, f in enumerate(gl['fragments']):
+        raw = np.array(f['polygon_raw'], dtype=np.int32)
+        deg = np.array(f['polygon_raw_degraded'], dtype=np.int32)
+        enc = np.array(f['polygon_n'], dtype=np.int32)
+        color = COLORS[idx % len(COLORS)]
+        pale = tuple(int(v + (255 - v) * 0.72) for v in color)
+        m = {}
+        for k, poly in (('raw', raw), ('deg', deg), ('enc', enc)):
+            m[k] = np.zeros((H, W), dtype=np.uint8)
+            if len(poly) >= 3:
+                cv2.fillPoly(m[k], [poly], 1)
+        lost_deg = (m['raw'] > 0) & (m['deg'] == 0)   # dégradation (voulue)
+        lost_enc = (m['deg'] > 0) & (m['enc'] == 0)   # encodage reco-B (ε)
+        img[m['raw'] > 0] = pale
+        img[lost_deg & (hatch2 > 0)] = (150, 150, 150)
+        img[lost_enc & (hatch > 0)] = color
+        if len(enc) >= 3:
+            cv2.polylines(img, [enc], True, (0, 0, 0), 2)
+        deg_total += float(lost_deg.sum())
+        enc_total += float(lost_enc.sum())
+        raw_total += float((m['raw'] > 0).sum())
+
+    out_path = d / 'recob_viz.png'
+    Image.fromarray(img).save(out_path)
+    print(f"Wrote {out_path}  (perte dégradation [hachures grises] : "
+          f"{100 * deg_total / max(raw_total, 1):.2f} % ; perte encodage reco-B "
+          f"[hachures couleur] : {100 * enc_total / max(raw_total, 1):.2f} %)")
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument('--dir', default='dataset/mosaic_001')
+    p.add_argument('--recob', action='store_true',
+                   help="écrit aussi recob_viz.png (perte d'encodage reco-B hachurée)")
+    return p.parse_args()
+
+
+if __name__ == '__main__':
+    a = parse_args()
+    visualize(a.dir)
+    if a.recob:
+        visualize_recob(a.dir)

code/requirements.txt

@@ -0,0 +1,9 @@
+# Dependencies (Python 3.11+). Install:
+#   python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
+numpy==2.2.6
+Pillow==12.0.0
+opencv-python==4.13.0.92
+shapely==2.1.2          # optionnel (clip de sécurité reco-B) ; sans lui, fallback gracieux
+networkx==3.5
+datasets==4.3.0         # source d'images wikiart en streaming (forge_LAR_2mosaic/wikiart.py)
+huggingface_hub==1.4.1  # upload de dataset vers le Hub (tools/hf_upload.py)

code/tools/hf_export_tars.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Exporte un dataset curriculum (`<src>/L*/`) vers le HF Hub en **tar.gz par palier**.
+
+Un dataset de 25 000 instances = ~500 k fichiers → un upload browsable est
+impraticable (HF rame/refuse au-delà de ~100 k fichiers). On archive donc CHAQUE
+palier (`L0_explode/`, …) en un seul `.tar.gz`, on l'uploade, puis on **supprime
+l'archive locale** avant de passer au suivant → pic disque ≈ une seule archive.
+
+En bonus on pousse les `gnn_meta.json` (browsables, petits) et, optionnellement,
+on supprime d'anciens dossiers *legacy* du repo.
+
+Prérequis : `huggingface-cli login` (ou HF_TOKEN). `HF_HUB_ENABLE_HF_TRANSFER=1`
+recommandé pour la vitesse.
+
+Exemple :
+    HF_HUB_ENABLE_HF_TRANSFER=1 python3 forge_mosaics/tools/hf_export_tars.py \
+        --src output/poly_balanced/k10-15 --repo-id <user>/<dataset-repo> \
+        --path-in-repo poly_balanced/k10-15 --card /tmp/hf_card.md
+"""
+import argparse
+import os
+import subprocess
+from pathlib import Path
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--src", default="output/balanced", help="dossier contenant les paliers L*/")
+    p.add_argument("--repo-id", required=True)
+    p.add_argument("--path-in-repo", default="balanced", help="préfixe cible dans le repo")
+    p.add_argument("--tmp", default="output/_tars", help="dossier temporaire des archives")
+    p.add_argument("--delete-legacy", nargs="*", default=[],
+                   help="dossiers du repo à supprimer après upload (ex: clean degraded)")
+    p.add_argument("--card", default=None, help="README.md (carte) à pousser à la racine")
+    p.add_argument("--overwrite", action="store_true",
+                   help="ré-uploade même si le tar existe déjà sur le repo (écrase)")
+    p.add_argument("--token", default=None)
+    return p.parse_args()
+
+
+def main():
+    a = parse_args()
+    from huggingface_hub import HfApi
+    api = HfApi(token=a.token)
+    api.create_repo(a.repo_id, repo_type="dataset", exist_ok=True)
+    src = Path(a.src)
+    tmp = Path(a.tmp); tmp.mkdir(parents=True, exist_ok=True)
+    paliers = sorted(d.name for d in src.iterdir() if d.is_dir() and d.name.startswith("L"))
+    print(f"paliers: {paliers}")
+
+    if a.card:
+        api.upload_file(path_or_fileobj=a.card, path_in_repo="README.md",
+                        repo_id=a.repo_id, repo_type="dataset",
+                        commit_message="carte : curriculum 5 paliers (remplace 100mosaics legacy)")
+        print("[card] poussée")
+
+    for L in paliers:                                   # gnn_meta browsables (petits)
+        meta = src / L / "gnn_meta.json"
+        if meta.exists():
+            api.upload_file(path_or_fileobj=str(meta),
+                            path_in_repo=f"{a.path_in_repo}/{L}.gnn_meta.json",
+                            repo_id=a.repo_id, repo_type="dataset",
+                            commit_message=f"meta {L}")
+            print(f"[meta] {L}")
+
+    for L in paliers:                                   # 1 archive par palier
+        repo_path = f"{a.path_in_repo}/{L}.tar.gz"
+        if not a.overwrite and api.file_exists(a.repo_id, repo_path, repo_type="dataset"):
+            print(f"[skip] {L} (déjà sur le repo) — resume")  # relance idempotente
+            continue
+        tar = tmp / f"{L}.tar.gz"
+        print(f"[tar] {L} …", flush=True)
+        # Les tars du 24-26/07/2026 contenaient un AppleDouble `._<fichier>`
+        # (163 o de xattrs macOS) à côté de CHAQUE fichier — bruit inutile dans
+        # un dataset public. Ceinture (COPYFILE_DISABLE) + bretelles
+        # (--no-mac-metadata, bsdtar) ; l'option est retirée si tar la rejette.
+        cmd = ["tar", "--no-mac-metadata", "-czf", str(tar), "-C", str(src), L]
+        env = {**os.environ, "COPYFILE_DISABLE": "1"}
+        if subprocess.run(cmd, env=env).returncode != 0:
+            subprocess.run(["tar", "-czf", str(tar), "-C", str(src), L],
+                           check=True, env=env)
+        gb = tar.stat().st_size / 1e9
+        print(f"[upload] {L} ({gb:.1f} Go) …", flush=True)
+        api.upload_file(path_or_fileobj=str(tar), path_in_repo=repo_path,
+                        repo_id=a.repo_id, repo_type="dataset",
+                        commit_message=f"palier {L} (tar.gz)")
+        tar.unlink()                                    # libère le disque avant le suivant
+        print(f"[done] {L}", flush=True)
+
+    for folder in a.delete_legacy:
+        try:
+            api.delete_folder(path_in_repo=folder, repo_id=a.repo_id, repo_type="dataset",
+                              commit_message=f"retrait legacy {folder}")
+            print(f"[legacy] supprimé : {folder}")
+        except Exception as e:
+            print(f"[legacy] échec {folder}: {e}")
+
+    print(f"EXPORT FINI → https://huggingface.co/datasets/{a.repo_id}")
+
+
+if __name__ == "__main__":
+    main()

code/tools/hf_upload.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Upload d'un dossier vers le HuggingFace Hub comme **dataset** — gratuit.
+
+Le HF Hub héberge gratuitement les datasets (public ou privé, quotas larges).
+C'est la façon recommandée de partager nos données avec les camarades : le CODE
+reste sur GitHub (léger), les DONNÉES (mosaïques, datasets fragmentés) vont sur le
+Hub — au lieu de gonfler le dépôt git.
+
+Prérequis :
+    pip install huggingface_hub
+    huggingface-cli login          # token gratuit : https://huggingface.co/settings/tokens
+    #  (ou export HF_TOKEN=hf_xxx, ou --token hf_xxx)
+
+Exemples :
+    # un dataset fragmenté, public
+    python3 forge_mosaics/tools/hf_upload.py --folder output/mosaics \
+        --repo-id <user>/<dataset-repo>
+
+    # un dataset privé
+    python3 forge_mosaics/tools/hf_upload.py --folder output/dataset \
+        --repo-id <user>/<dataset-repo> --private
+"""
+import argparse
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Upload d'un dossier vers le HF Hub (dataset).")
+    p.add_argument("--folder", required=True, help="dossier local à uploader")
+    p.add_argument("--repo-id", required=True, help="ex: <user>/<dataset-repo>")
+    p.add_argument("--private", action="store_true", help="dataset privé (défaut : public)")
+    p.add_argument("--token", default=None, help="token HF (sinon : huggingface-cli login / HF_TOKEN)")
+    p.add_argument("--commit", default="upload via tools/hf_upload.py", help="message de commit Hub")
+    p.add_argument("--path-in-repo", default=None,
+                   help="sous-dossier cible dans le repo (ex: clean) → plusieurs dossiers dans 1 dataset")
+    p.add_argument("--allow-patterns", nargs="*", default=None,
+                   help="ne pousser que ces motifs (ex: '*.json' '*.png')")
+    return p.parse_args()
+
+
+def main():
+    a = parse_args()
+    from huggingface_hub import HfApi          # import tardif : message clair si absent
+    api = HfApi(token=a.token)
+    api.create_repo(repo_id=a.repo_id, repo_type="dataset",
+                    private=a.private, exist_ok=True)
+    api.upload_folder(folder_path=a.folder, repo_id=a.repo_id, repo_type="dataset",
+                      path_in_repo=a.path_in_repo,
+                      commit_message=a.commit, allow_patterns=a.allow_patterns)
+    print(f"OK → https://huggingface.co/datasets/{a.repo_id}")
+
+
+if __name__ == "__main__":
+    main()

code/tools/qa_contact_sheets.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Planches de contact pour la revue qualitative de l'échantillon `qa_sample_hf.py`.
+
+Deux familles de planches :
+
+* `sheet_<dataset>_<palier>.png` — 50 cellules `target | source` côte à côte
+  (une par mosaïque échantillonnée) : on balaye d'un coup d'œil les erreurs de
+  placement, les mosaïques dégénérées (aplats), la sévérité de la dégradation.
+* `targets_<dataset>.png` — les 50 targets seuls, en grille dense : c'est la vue
+  qui fait sauter aux yeux une **répétition** de peinture.
+
+Chaque cellule porte les 8 premiers caractères de l'uuid → un doublon visuel se
+retrouve dans `manifest.json`.
+"""
+import argparse
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+# les `source.png` de L0_explode montent à 16128² (260 Mpx) → au-delà du garde-fou
+# anti-« decompression bomb » de PIL, qui lèverait DecompressionBombError.
+Image.MAX_IMAGE_PIXELS = None
+
+TH = 190          # côté d'une vignette
+PAD = 6
+LAB = 13          # bande de label sous la cellule
+
+
+def _thumb(p, size=TH):
+    im = Image.open(p).convert("RGB")
+    im.thumbnail((size, size), Image.LANCZOS)
+    bg = Image.new("RGB", (size, size), (245, 245, 245))
+    bg.paste(im, ((size - im.width) // 2, (size - im.height) // 2))
+    return bg
+
+
+def sheet(mosaics, out, title, pair=True, cols=5):
+    """`pair=True` → cellule target|source ; sinon target seul (grille dense)."""
+    cw = TH * 2 + PAD if pair else TH
+    ch = TH + LAB
+    rows = (len(mosaics) + cols - 1) // cols
+    W = cols * (cw + PAD) + PAD
+    H = rows * (ch + PAD) + PAD + 26
+    sh = Image.new("RGB", (W, H), (255, 255, 255))
+    d = ImageDraw.Draw(sh)
+    d.text((PAD, 8), title, fill=(0, 0, 0))
+
+    for i, m in enumerate(sorted(mosaics)):
+        x = PAD + (i % cols) * (cw + PAD)
+        y = 26 + PAD + (i // cols) * (ch + PAD)
+        try:
+            sh.paste(_thumb(m / "target.png"), (x, y))
+            if pair and (m / "source.png").exists():
+                sh.paste(_thumb(m / "source.png"), (x + TH + PAD, y))
+        except (FileNotFoundError, OSError) as e:
+            d.text((x + 4, y + 4), f"ERR {e.__class__.__name__}", fill=(200, 0, 0))
+        d.text((x + 2, y + TH + 1), m.name.replace("mosaic_", "")[:8], fill=(90, 90, 90))
+    out.parent.mkdir(parents=True, exist_ok=True)
+    sh.save(out)
+    return out
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--sample", default="output/qa_sample")
+    p.add_argument("--out", default="output/qa_sheets")
+    a = p.parse_args()
+    root, out = Path(a.sample), Path(a.out)
+
+    paliers = sorted({d.name for d in root.glob("*/*/L*") if d.is_dir()})
+    datasets = sorted({f"{d.parent.name}/{d.name}" for d in root.glob("*/k*") if d.is_dir()})
+
+    for ds in datasets:
+        tag = ds.replace("/", "_")
+        for L in paliers:
+            mos = [m for m in (root / ds / L).iterdir() if m.is_dir()] \
+                if (root / ds / L).is_dir() else []
+            if not mos:
+                continue
+            o = sheet(mos, out / f"sheet_{tag}_{L}.png", f"{ds}  {L}   ({len(mos)} mosaïques — gauche: target / droite: source)")
+            print("[sheet]", o)
+        # vue « répétitions » : targets seuls, pris sur le premier palier dispo
+        for L in paliers:
+            mos = [m for m in (root / ds / L).iterdir() if m.is_dir()] \
+                if (root / ds / L).is_dir() else []
+            if mos:
+                o = sheet(mos, out / f"targets_{tag}.png",
+                          f"{ds} — targets seuls ({len(mos)}) — repérage des répétitions",
+                          pair=False, cols=10)
+                print("[targets]", o)
+                break
+
+
+if __name__ == "__main__":
+    main()

code/tools/qa_overlays.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Overlays de contrôle sur l'échantillon : YOLO-Seg + reco-B.
+
+Pour chaque (dataset, palier) de `output/qa_sample`, prend la **même** mosaïque
+(uuid partagé par tous les paliers → comparaison L0→L4 à contenu constant) et
+écrit dans le dossier de la mosaïque :
+
+* `source_yolo_viz.png` — polygones `source_yolo.txt` repeints sur `source.png`
+  (contrôle : les masques collent-ils aux fragments ? la normalisation par le
+  canvas agrandi est-elle correcte ?)
+* `recob_viz.png` — perte de dégradation (hachures grises) vs perte d'encodage
+  reco-B (hachures couleur), en repère target.
+
+Les copies sont rassemblées à plat dans `--out` pour la revue.
+"""
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+from PIL import Image
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "mosaic2fragments"))
+Image.MAX_IMAGE_PIXELS = None       # L0 monte à 260 Mpx (cf. qa_contact_sheets)
+
+import visualize  # noqa: E402
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--sample", default="output/qa_sample")
+    p.add_argument("--out", default="output/qa_overlays")
+    p.add_argument("--per-cell", type=int, default=1, help="mosaïques par dataset×palier")
+    a = p.parse_args()
+    root, out = Path(a.sample), Path(a.out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    cells = sorted(d for d in root.glob("*/k*/L*") if d.is_dir())
+    for c in cells:
+        tag = "_".join(c.parts[-3:])
+        for m in sorted(d for d in c.iterdir() if d.is_dir())[:a.per_cell]:
+            try:
+                visualize.visualize(m)
+                visualize.visualize_recob(m)
+            except Exception as e:                      # noqa: BLE001
+                print(f"✗ {tag}/{m.name[:14]} : {type(e).__name__}: {e}", flush=True)
+                continue
+            for f, suf in (("source_yolo_viz.png", "yolo"), ("recob_viz.png", "recob")):
+                if (m / f).exists():
+                    shutil.copy(m / f, out / f"{suf}_{tag}_{m.name[7:15]}.png")
+            print(f"✓ {tag}/{m.name[7:15]}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

code/tools/qa_sample_hf.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Échantillonne ~1 % de chaque dataset publié sur le Hub, **sans télécharger les tars**.
+
+Un `.tar.gz` n'est pas seekable : on ne peut pas atteindre un membre au milieu
+sans décompresser tout ce qui précède. On lit donc le flux HTTP au fil de l'eau
+(`tarfile` mode `r|gz`) et on **coupe la connexion** dès que N dossiers
+`mosaic_<uuid>/` ont été vus → on ne transfère que ~N/5000 des octets.
+
+⚠️ Biais assumé : l'échantillon est un *préfixe* de l'archive. Les noms étant des
+uuid4, il est non biaisé vis-à-vis du **contenu** des peintures, mais il suit
+l'ordre de création des dossiers (donc l'ordre de génération).
+
+Les crops `fragments/*.png` sont ignorés (inutiles à la revue visuelle, ~la
+moitié du volume disque).
+"""
+import argparse
+import concurrent.futures as cf
+import io
+import json
+import tarfile
+from pathlib import Path
+
+import requests
+from huggingface_hub import get_token, hf_hub_url
+
+REPO = "<user>/<dataset-repo>"     # défaut ; surchargeable par --repo-id
+DATASETS = [f"{g}/{k}" for g in ("poly_balanced", "mono_compact")
+            for k in ("k02", "k03", "k05", "k10-15")]
+PALIERS = ["L0_explode", "L1_translation", "L2_rotation", "L3_light", "L4_strong"]
+KEEP = {"target.png", "source.png", "source_yolo.txt", "graph_fragments.json",
+        "graph_complete.json", "gt_layout.json", "degradation.md", "gnn_ready.npz"}
+
+
+def sample_one(ds, palier, n, out_root, repo):
+    """Extrait les `n` premières mosaïques de `<ds>/<palier>.tar.gz`. → (dl_bytes, uuids)"""
+    url = hf_hub_url(repo, f"{ds}/{palier}.tar.gz", repo_type="dataset")
+    tok = get_token()
+    hdr = {"Authorization": f"Bearer {tok}"} if tok else {}
+    dest = Path(out_root) / ds / palier
+    dest.mkdir(parents=True, exist_ok=True)
+
+    seen, done = [], False
+    with requests.get(url, headers=hdr, stream=True, timeout=120) as r:
+        r.raise_for_status()
+        raw = r.raw  # urllib3, décompression gzip faite par tarfile
+        counted = _Counter(raw)
+        try:
+            with tarfile.open(fileobj=counted, mode="r|gz") as tf:
+                for m in tf:
+                    parts = m.name.split("/")
+                    # `tar` sous macOS embarque des AppleDouble `._x` (xattrs) : à jeter.
+                    # Et l'archive liste d'abord les 5000 répertoires, PUIS les fichiers
+                    # groupés par mosaïque → on compte les uuid sur les fichiers utiles.
+                    if any(c.startswith("._") for c in parts):
+                        continue
+                    if len(parts) != 3 or not m.isfile() or parts[-1] not in KEEP:
+                        continue
+                    uid = parts[1]
+                    if uid not in seen:
+                        if len(seen) >= n:      # on entre dans la (n+1)-ème → stop
+                            done = True
+                            break
+                        seen.append(uid)
+                    tgt = dest / uid / parts[-1]
+                    tgt.parent.mkdir(parents=True, exist_ok=True)
+                    tgt.write_bytes(tf.extractfile(m).read())
+        except (tarfile.ReadError, OSError) as e:
+            if not done:
+                raise RuntimeError(f"{ds}/{palier}: {e}") from e
+    return counted.n, seen
+
+
+class _Counter(io.RawIOBase):
+    """Wrapper qui compte les octets réellement transférés."""
+
+    def __init__(self, raw):
+        self.raw, self.n = raw, 0
+
+    def read(self, size=-1):
+        b = self.raw.read(size)
+        self.n += len(b)
+        return b
+
+    def readable(self):
+        return True
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--n", type=int, default=50, help="mosaïques par palier (1%% de 5000)")
+    p.add_argument("--out", default="output/qa_sample")
+    p.add_argument("--repo-id", default=REPO)
+    p.add_argument("--jobs", type=int, default=6)
+    a = p.parse_args()
+
+    jobs = [(ds, L) for ds in DATASETS for L in PALIERS]
+    manifest, total = {}, 0
+    with cf.ThreadPoolExecutor(a.jobs) as ex:
+        futs = {ex.submit(sample_one, ds, L, a.n, a.out, a.repo_id): (ds, L)
+                for ds, L in jobs}
+        for i, f in enumerate(cf.as_completed(futs), 1):
+            ds, L = futs[f]
+            try:
+                nb, uids = f.result()
+            except Exception as e:                      # noqa: BLE001 — on veut la suite
+                print(f"[{i:2d}/40] ✗ {ds}/{L} : {e}", flush=True)
+                continue
+            total += nb
+            manifest[f"{ds}/{L}"] = uids
+            print(f"[{i:2d}/40] ✓ {ds}/{L} : {len(uids)} mosaïques, {nb/1e6:.0f} Mo",
+                  flush=True)
+
+    Path(a.out).mkdir(parents=True, exist_ok=True)
+    (Path(a.out) / "manifest.json").write_text(json.dumps(manifest, indent=1))
+    print(f"\nTotal transféré : {total/1e9:.2f} Go → {a.out}")
+
+
+if __name__ == "__main__":
+    main()