V3.1: QA automatique + confidence naming + manifest JSON téléchargeable

Dockerfile

@@ -10,7 +10,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY pipeline.py main.py storage_r2.py painterly.py superpixels.py pipeline_v2.py pipeline_v3_sam2.py ./
+COPY pipeline.py main.py storage_r2.py painterly.py superpixels.py pipeline_v2.py pipeline_v3_sam2.py qa_manifest.py ./
 COPY frontend /app/frontend
 
 ENV STORAGE_DIR=/data

frontend/index.html

@@ -329,10 +329,12 @@ async function pollJob(id) {
         <div style="font-size:12px;color:#7a5a3a;margin-bottom:4px;margin-top:12px;">Aperçu illustration HD</div>
         <img src="${hdUrl}">
       `;
+      const manifestUrl = `${API || location.origin}/jobs/${id}/download/manifest`;
       actionsEl.innerHTML = `
         <a href="${photopeaUrl}" target="_blank" rel="noopener" class="primary">Ouvrir dans Photopea</a>
         <a href="${psdUrl}" download class="dark">Télécharger PSD</a>
         <a href="${hdUrl}" download class="secondary">Télécharger HD</a>
+        <a href="${manifestUrl}" download style="background:#5a8a3a;">Télécharger manifest.json</a>
       `;
       window.open(photopeaUrl, "_blank");
       break;

main.py

@@ -158,6 +158,9 @@ async def download(job_id: str, kind: str):
         raise HTTPException(404, "job non terminé")
     r = JOBS[job_id]["result"]
     paths = {"psd": r["psd"], "illu_hd": r["illu_hd"]}
+    meta = r.get("meta", {})
+    if meta.get("manifest_path"):
+        paths["manifest"] = meta["manifest_path"]
     if kind not in paths:
         raise HTTPException(400, f"kind doit être l'un de {list(paths)}")
     return FileResponse(paths[kind])

pipeline_v3_sam2.py

@@ -228,14 +228,26 @@ class CadrimagesV3SAM2:
         for i, m in enumerate(grid_cells):
             all_blobs.append({"mask": m, "source": "grid", "idx": i})
 
-        # Nommage intelligent
+        # Nommage intelligent avec confidence score et fallback
+        from qa_manifest import name_confidence
         if progress_cb: progress_cb(78, f"Nommage intelligent ({len(all_blobs)} calques)")
         for i, blob in enumerate(all_blobs):
             if blob["source"] == "grid":
                 blob["name"] = f"Cellule grille {blob['idx']+1:02d}"
+                blob["confidence"] = 1.0
+                blob["naming_source"] = "grid"
             else:
-                blob["name"] = self.name_blob_claude(illu_pil, blob["mask"])
-            log(f"    [{i+1}/{len(all_blobs)}] {blob['source']} → {blob['name']}")
+                raw_name = self.name_blob_claude(illu_pil, blob["mask"])
+                conf = name_confidence(raw_name)
+                if conf < 0.4:
+                    blob["name"] = "Élément"
+                    blob["confidence"] = 0.0
+                    blob["naming_source"] = "fallback"
+                else:
+                    blob["name"] = raw_name
+                    blob["confidence"] = conf
+                    blob["naming_source"] = "vlm"
+            log(f"    [{i+1}/{len(all_blobs)}] {blob['source']} → {blob['name']} (conf={blob['confidence']:.2f}, {blob['naming_source']})")
 
         # Construction PSD avec groupes thématiques
         if progress_cb: progress_cb(90, "Construction PSD groupé")
@@ -281,12 +293,53 @@ class CadrimagesV3SAM2:
 
         if progress_cb: progress_cb(95, "Sauvegarde PSD")
         psd.save(out_path)
+
+        # Manifest JSON exporté à côté du PSD
+        from qa_manifest import qa_illustration, build_manifest, write_manifest
+        qa = qa_illustration(illu_pil, ref_photo)
+        layers_named = []
+        for theme, blobs in themed.items():
+            for b in blobs:
+                layers_named.append({
+                    "group": theme,
+                    "name": b["display_name"],
+                    "raw_name": b["name"],
+                    "vlm_confidence": b.get("confidence", 0),
+                    "source": b["source"],
+                    "naming_source": b.get("naming_source", "fallback"),
+                })
+        manifest = build_manifest(
+            job_id=os.path.basename(out_path).replace("_FINAL.psd", ""),
+            style="cadrimages_fidele",
+            src_size=ref_photo.size,
+            illu_size=illu_pil.size,
+            psd_path=out_path,
+            psd_meta={"size_mb": os.path.getsize(out_path) // 1024 // 1024,
+                      "n_layers": total_layers},
+            qa=qa,
+            layers_named=layers_named,
+            sources_used={
+                "painterly": "cadrimages_fidele",
+                "segmentation_primary": "sam2_fal" if len(sam_masks) > 0 else "fallback",
+                "grid_detection": "hough" if len(grid_cells) > 0 else "none",
+                "naming_primary": "nemotron_vision_openrouter",
+                "vlm_model": VLM_MODEL,
+            },
+        )
+        manifest_path = out_path.replace(".psd", "_manifest.json")
+        write_manifest(manifest, manifest_path)
+
         return {
             "path": out_path,
+            "manifest_path": manifest_path,
             "size_mb": os.path.getsize(out_path) // 1024 // 1024,
             "width": W, "height": H,
             "n_layers": total_layers,
             "n_sam": len(sam_masks),
             "n_grid": len(grid_cells),
             "groups": group_stats,
+            "qa_status": qa["status"],
+            "qa_warnings": qa["warnings"],
+            "naming_avg_confidence": manifest["naming"]["vlm_average_confidence"],
+            "naming_fallback_count": manifest["naming"]["fallback_count"],
         }

qa_manifest.py

@@ -0,0 +1,182 @@
+"""
+QA automatique + manifest JSON pour chaque génération Cadrimages.
+
+Patterns appliqués :
+- QA visuel post-génération : flag les images pathologiques (trop de noir, trop simple, etc.)
+- Confidence score sur naming : flag les noms VLM peu plausibles, fallback nom sémantique
+- Manifest JSON exporté avec le PSD : traçabilité complète (sources, fallbacks utilisés, scores)
+"""
+import os
+import json
+import re
+from typing import Optional, Dict, Any, List
+import numpy as np
+from PIL import Image
+
+
+# Mots français basiques attendus pour un naming acceptable
+COMMON_FR_WORDS = {
+    "tour", "bâtiment", "mur", "fenêtre", "porte", "volet", "balcon", "toit", "cheminée",
+    "arbre", "cyprès", "plante", "fleur", "buisson", "herbe", "feuillage", "branche",
+    "chaise", "table", "fauteuil", "banc", "banquette", "coussin", "lampe", "lampadaire",
+    "ciel", "nuage", "lune", "soleil", "étoile", "eau", "mer", "rivière", "rocher",
+    "sol", "pavé", "carreau", "trottoir", "route", "rambarde", "garde-corps", "clôture",
+    "treillis", "maille", "barreau", "personne", "homme", "femme", "client", "serveur",
+    "vase", "pot", "lanterne", "ornement", "colonne", "arche", "tour", "abbaye", "maison",
+    "rouge", "vert", "bleu", "jaune", "blanc", "noir", "marbre", "bois", "métal", "verre",
+    "rotin", "rayée", "central", "droit", "gauche", "centre", "premier", "fond",
+}
+
+
+def name_confidence(name: str) -> float:
+    """
+    Score 0-1 sur la qualité du nom retourné par le VLM.
+    Plus c'est haut, plus le nom est crédible.
+    """
+    if not name or name == "Élément":
+        return 0.0
+    s = name.lower().strip()
+    if len(s) < 2 or len(s) > 60:
+        return 0.0
+    # Pénalité : caractères non-ASCII/français bizarres
+    weird_chars = sum(1 for c in s if not (c.isalpha() or c in " -'éèêëàâäôöûüçîï"))
+    if weird_chars > 2:
+        return 0.2
+    # Bonus : contient au moins un mot du vocabulaire attendu
+    words = re.findall(r"[a-zA-Zéèêëàâäôöûüçîï]+", s)
+    if not words:
+        return 0.1
+    matches = sum(1 for w in words if w.lower() in COMMON_FR_WORDS)
+    if matches >= 1:
+        return min(1.0, 0.6 + 0.2 * matches)
+    # Cas pas de match mais semble plausible (lettres FR sensées)
+    return 0.3
+
+
+def qa_illustration(illu_pil: Image.Image, ref_pil: Optional[Image.Image] = None) -> Dict[str, Any]:
+    """
+    QA visuel post-painterly. Détecte les pathologies courantes :
+    - Trop de noir (cas hachures massives)
+    - Palette trop pauvre (mode "encre" non voulu)
+    - Trop monochrome (mode "tinté" raté)
+    - Surface utile insuffisante
+    - Dimensions divergentes vs source
+    Retourne un dict avec status et warnings.
+    """
+    arr = np.array(illu_pil.convert("RGB"))
+    H, W = arr.shape[:2]
+    total_px = H * W
+
+    flat = arr.reshape(-1, 3)
+    luminance = 0.299 * flat[:, 0] + 0.587 * flat[:, 1] + 0.114 * flat[:, 2]
+
+    pct_black = float((luminance < 30).sum() / total_px * 100)
+    pct_very_dark = float((luminance < 60).sum() / total_px * 100)
+
+    # Diversité chromatique : nombre de teintes distinctes (quantif x16)
+    quantized = (flat // 16) * 16
+    unique_colors = len(np.unique(quantized.view(np.dtype((np.void, 3 * 1))), axis=0))
+
+    # Saturation moyenne
+    max_c = flat.max(axis=1).astype(np.float32)
+    min_c = flat.min(axis=1).astype(np.float32)
+    saturation = np.where(max_c > 0, (max_c - min_c) / max_c, 0)
+    mean_saturation = float(saturation.mean())
+
+    # Comparaison dimensions vs ref si dispo
+    dim_match = True
+    if ref_pil is not None:
+        dim_match = (illu_pil.size == ref_pil.size)
+
+    warnings = []
+    if pct_black > 25:
+        warnings.append(f"BLACK_EXCESS: {pct_black:.1f}% pixels quasi-noirs (>25%) — hachures suspectes")
+    if pct_very_dark > 50:
+        warnings.append(f"DARK_EXCESS: {pct_very_dark:.1f}% pixels sombres (>50%) — rendu trop sombre")
+    if unique_colors < 60:
+        warnings.append(f"LOW_PALETTE: {unique_colors} teintes distinctes — palette trop pauvre")
+    if mean_saturation < 0.08:
+        warnings.append(f"MONOCHROME: saturation moyenne {mean_saturation:.2f} — image quasi N&B")
+    if mean_saturation > 0.65:
+        warnings.append(f"OVER_SATURATED: saturation moyenne {mean_saturation:.2f} — couleurs criardes")
+    if not dim_match:
+        warnings.append(f"DIM_MISMATCH: illu {illu_pil.size} != ref {ref_pil.size if ref_pil else '?'}")
+
+    status = "ok" if not warnings else "warning"
+    return {
+        "status": status,
+        "warnings": warnings,
+        "metrics": {
+            "size": list(illu_pil.size),
+            "pct_black": round(pct_black, 2),
+            "pct_very_dark": round(pct_very_dark, 2),
+            "unique_colors": int(unique_colors),
+            "mean_saturation": round(mean_saturation, 3),
+            "dim_match_source": dim_match,
+        },
+    }
+
+
+def build_manifest(
+    job_id: str,
+    style: str,
+    src_size: tuple,
+    illu_size: tuple,
+    psd_path: str,
+    psd_meta: Dict[str, Any],
+    qa: Dict[str, Any],
+    layers_named: List[Dict[str, Any]],
+    sources_used: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Construit un manifest JSON exporté à côté du PSD.
+
+    layers_named : [{ "group": "Architecture", "name": "Bâtiment", "vlm_confidence": 0.8, "source": "sam2|grid|sem" }, ...]
+    sources_used : { "painterly": "cadrimages_fidele", "segmentation": "sam2", "naming": "nemotron|fallback", "lora": "cadrimages_lora_url" }
+    """
+    # Score qualité naming global
+    confidences = [l.get("vlm_confidence", 0) for l in layers_named if l.get("vlm_confidence") is not None]
+    naming_score = round(sum(confidences) / len(confidences), 2) if confidences else 0
+    fallback_used = sum(1 for l in layers_named if l.get("source_naming") == "fallback")
+
+    # Group counts
+    group_counts = {}
+    for l in layers_named:
+        g = l.get("group", "?")
+        group_counts[g] = group_counts.get(g, 0) + 1
+
+    return {
+        "manifest_version": "1.0",
+        "job_id": job_id,
+        "style": style,
+        "source": {"width": src_size[0], "height": src_size[1]},
+        "illustration": {"width": illu_size[0], "height": illu_size[1]},
+        "psd": {
+            "path": os.path.basename(psd_path),
+            "size_mb": psd_meta.get("size_mb"),
+            "total_layers": psd_meta.get("n_layers"),
+            "groups": group_counts,
+        },
+        "qa": qa,
+        "naming": {
+            "vlm_average_confidence": naming_score,
+            "fallback_count": fallback_used,
+            "total": len(layers_named),
+        },
+        "sources_used": sources_used,
+        "layers": layers_named,
+    }
+
+
+def write_manifest(manifest: Dict[str, Any], path: str) -> str:
+    """Écrit le manifest JSON et retourne le chemin."""
+    with open(path, "w") as f:
+        json.dump(manifest, f, indent=2, ensure_ascii=False)
+    return path
+
+
+if __name__ == "__main__":
+    import sys
+    img = Image.open(sys.argv[1]).convert("RGB")
+    qa = qa_illustration(img)
+    print(json.dumps(qa, indent=2, ensure_ascii=False))