feat: filtrage macOS, exclusion chars, Vue Analyses, métriques robustes

1. Filtrage fichiers cachés macOS (._*)
- corpus.py : exclure les fichiers débutant par '.' lors de la détection
des images (._0000.png, .DS_Store etc.)
- app.py _flatten_zip_to_dir : ignorer les entrées ._* et .* dans les ZIPs
- app.py _analyze_corpus_dir : idem, plus de faux avertissements GT manquant

2. Profils de normalisation avec exclusion de caractères
- NormalizationProfile.exclude_chars (frozenset) : supprime ces chars des
deux textes (GT et OCR) avant TOUT calcul CER/WER/MER/WIL
- _parse_exclude_chars() : parse "', -, –" (comma+espace) ou ".,;:!?" (chars)
- Deux profils prédéfinis : sans_ponctuation, sans_apostrophes
- compute_metrics() accepte char_exclude= et l'applique en amont
- run_benchmark() accepte char_exclude= et le transmet
- BenchmarkRequest / BenchmarkRunRequest : champ char_exclude
- SPA : champ "Caractères à ignorer" + auto-remplissage depuis le profil

3. Vue Analyses — Chart.js inline (plus de CDN)
- Embarque chart.umd.min.js (v4.5.1) dans le rapport HTML auto-contenu
- Supprime les références CDN chart.js et diff2html (diff2html non utilisé)
- Injection post-.format() pour éviter les conflits avec les {} du JS
- Vérifié node --check sur le rapport démo : 0 SyntaxError

4. Métriques robustes (exclusion des hallucinations)
- Nouvelle carte "Métriques robustes" dans la vue Classement
- Deux curseurs JS : seuil d'ancrage (défaut 0.5) et ratio longueur (défaut 1.5)
- Recalcule CER/WER en excluant les docs détectés hallucinés, en temps réel
- Affiche : Δ CER global→robuste, docs exclus et restants, liste cliquable
- Entièrement côté client (aucun changement de pipeline nécessaire)

Tests : 979 passés (+ 15 nouveaux dans test_sprint12_nouvelles_fonctionnalites.py)

https://claude.ai/code/session_017gXea9mxBQqDTAsSQd7aAq

picarones/core/corpus.py

@@ -109,9 +109,10 @@ def load_corpus_from_directory(
     documents: list[Document] = []
     skipped = 0
 
-    # Collecte de toutes les images
+    # Collecte de toutes les images (on exclut les fichiers cachés macOS ._* et .*)
     image_paths = sorted(
-        p for p in directory.iterdir() if p.suffix.lower() in IMAGE_EXTENSIONS
+        p for p in directory.iterdir()
+        if p.suffix.lower() in IMAGE_EXTENSIONS and not p.name.startswith(".")
     )
 
     for image_path in image_paths:

picarones/core/metrics.py

@@ -120,6 +120,7 @@ def compute_metrics(
     reference: str,
     hypothesis: str,
     normalization_profile: "Optional[NormalizationProfile]" = None,  # noqa: F821
+    char_exclude: "Optional[frozenset]" = None,
 ) -> MetricsResult:
     """Calcule l'ensemble des métriques CER/WER pour une paire de textes.
 
@@ -133,6 +134,9 @@ def compute_metrics(
         Profil de normalisation diplomatique optionnel.
         Si fourni, calcule ``cer_diplomatic`` en plus des métriques standard.
         Si None, utilise le profil medieval_french par défaut.
+    char_exclude:
+        Ensemble de caractères à supprimer des deux textes avant tout calcul
+        (CER, WER, MER, WIL). Appliqué également au CER diplomatique.
 
     Returns
     -------
@@ -149,6 +153,11 @@ def compute_metrics(
         )
 
     try:
+        # Exclusion de caractères avant tout calcul
+        if char_exclude:
+            reference  = "".join(c for c in reference  if c not in char_exclude)
+            hypothesis = "".join(c for c in hypothesis if c not in char_exclude)
+
         # CER variants
         cer_raw = _cer_from_strings(reference, hypothesis)
         cer_nfc = _cer_from_strings(

picarones/core/normalization.py

@@ -152,6 +152,10 @@ class NormalizationProfile:
     diplomatic_table:
         Table de correspondances graphiques historiques appliquée caractère
         par caractère sur les deux textes avant calcul du CER.
+    exclude_chars:
+        Ensemble de caractères supprimés des deux textes (GT et OCR) avant
+        tout calcul de métriques (CER, WER, MER, WIL et CER diplomatique).
+        Utile pour ignorer la ponctuation ou les apostrophes.
     description:
         Description courte du profil (affichée dans le rapport HTML).
     """
@@ -160,10 +164,13 @@ class NormalizationProfile:
     nfc: bool = True
     caseless: bool = False
     diplomatic_table: dict[str, str] = field(default_factory=dict)
+    exclude_chars: frozenset = field(default_factory=frozenset)
     description: str = ""
 
     def normalize(self, text: str) -> str:
         """Applique le profil de normalisation à un texte."""
+        if self.exclude_chars:
+            text = "".join(c for c in text if c not in self.exclude_chars)
         if self.nfc:
             text = unicodedata.normalize("NFC", text)
         if self.caseless:
@@ -178,6 +185,7 @@ class NormalizationProfile:
             "nfc": self.nfc,
             "caseless": self.caseless,
             "diplomatic_table": self.diplomatic_table,
+            "exclude_chars": sorted(self.exclude_chars),
             "description": self.description,
         }
 
@@ -186,7 +194,8 @@ class NormalizationProfile:
         """Charge un profil depuis un fichier YAML.
 
         Le fichier YAML doit contenir les clés ``name``, optionnellement
-        ``caseless``, ``description`` et ``diplomatic`` (dict str→str).
+        ``caseless``, ``description``, ``diplomatic`` (dict str→str) et
+        ``exclude_chars`` (liste ou chaîne de caractères à ignorer).
 
         Example
         -------
@@ -195,6 +204,7 @@ class NormalizationProfile:
             name: medieval_custom
             caseless: false
             description: Français médiéval personnalisé
+            exclude_chars: ".,;:!?"
             diplomatic:
               ſ: s
               u: v
@@ -213,6 +223,7 @@ class NormalizationProfile:
             nfc=bool(data.get("nfc", True)),
             caseless=bool(data.get("caseless", False)),
             diplomatic_table=data.get("diplomatic", {}),
+            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
             description=data.get("description", ""),
         )
 
@@ -224,6 +235,7 @@ class NormalizationProfile:
             nfc=bool(data.get("nfc", True)),
             caseless=bool(data.get("caseless", False)),
             diplomatic_table=data.get("diplomatic", {}),
+            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
             description=data.get("description", ""),
         )
 
@@ -296,6 +308,23 @@ NORMALIZATION_PROFILES: dict[str, NormalizationProfile] = {
         diplomatic_table=DIPLOMATIC_EN_SECRETARY,
         description="Secretary hand (XVIth–XVIIth c.): ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y",
     ),
+    # ── Profils d'exclusion de caractères ────────────────────────────────
+    "sans_ponctuation": NormalizationProfile(
+        name="sans_ponctuation",
+        nfc=True,
+        caseless=False,
+        diplomatic_table={},
+        exclude_chars=frozenset(". , ; : ! ? ' \u2019 \" - \u2013 \u2014 ( ) [ ]".split()),
+        description="NFC + suppression de la ponctuation courante : . , ; : ! ? ' \" - – — ( ) [ ]",
+    ),
+    "sans_apostrophes": NormalizationProfile(
+        name="sans_apostrophes",
+        nfc=True,
+        caseless=False,
+        diplomatic_table={},
+        exclude_chars=frozenset(["'", "\u2019"]),  # apostrophe droite + apostrophe typographique
+        description="NFC + suppression des apostrophes droite (') et typographique (\u2019)",
+    ),
 }
 
 
@@ -331,6 +360,31 @@ def get_builtin_profile(name: str) -> NormalizationProfile:
 # Fonctions utilitaires
 # ---------------------------------------------------------------------------
 
+def _parse_exclude_chars(value: "str | list | None") -> frozenset:
+    """Convertit une liste de caractères (str ou list) en frozenset.
+
+    Accepte :
+    - Une chaîne de caractères séparés par une virgule+espace (ex. ``"', -, –"``)
+      ou simplement concaténés sans séparateur (ex. ``".,;:!?"``)
+    - Une liste Python/YAML de chaînes (chacune un caractère)
+    - None ou chaîne vide → frozenset vide
+
+    Règle de désambiguïsation : si la chaîne contient la séquence ``", "``
+    (virgule suivie d'un espace), on découpe par ``", "``. Sinon, chaque
+    caractère Unicode est un item distinct.
+    """
+    if not value:
+        return frozenset()
+    if isinstance(value, (list, tuple)):
+        return frozenset(str(c) for c in value if c)
+    raw = str(value)
+    # Désambiguïsation : séparer par ", " si présent (format lisible)
+    if ", " in raw:
+        return frozenset(c.strip() for c in raw.split(",") if c.strip())
+    # Sinon, chaque caractère Unicode est un item distinct
+    return frozenset(raw)
+
+
 def _apply_diplomatic_table(text: str, table: dict[str, str]) -> str:
     """Applique une table de correspondances diplomatiques caractère par caractère.
 

picarones/core/runner.py

@@ -22,6 +22,7 @@ def run_benchmark(
     output_json: Optional[str | Path] = None,
     show_progress: bool = True,
     progress_callback: Optional[callable] = None,
+    char_exclude: Optional[frozenset] = None,
 ) -> BenchmarkResult:
     """Exécute le benchmark d'un ou plusieurs moteurs/pipelines sur un corpus.
 
@@ -72,7 +73,7 @@ def run_benchmark(
             ocr_result = engine.run(doc.image_path)
 
             if ocr_result.success:
-                metrics = compute_metrics(doc.ground_truth, ocr_result.text)
+                metrics = compute_metrics(doc.ground_truth, ocr_result.text, char_exclude=char_exclude)
             else:
                 metrics = MetricsResult(
                     cer=1.0, cer_nfc=1.0, cer_caseless=1.0,

picarones/report/generator.py

@@ -22,6 +22,20 @@ import math
 from pathlib import Path
 from typing import Optional
 
+# ---------------------------------------------------------------------------
+# Ressources vendor (embarquées dans le rapport HTML)
+# ---------------------------------------------------------------------------
+
+_VENDOR_DIR = Path(__file__).parent / "vendor"
+
+
+def _load_vendor_js(name: str) -> str:
+    """Lit un fichier JS vendorisé et retourne son contenu."""
+    p = _VENDOR_DIR / name
+    if p.exists():
+        return p.read_text(encoding="utf-8")
+    return f"/* vendor/{name} non trouvé */"
+
 from picarones.core.results import BenchmarkResult
 from picarones.report.diff_utils import compute_char_diff, compute_word_diff
 from picarones.core.statistics import (
@@ -435,17 +449,8 @@ _HTML_TEMPLATE = """\
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>Picarones — {corpus_name}</title>
 
-<!-- Chart.js -->
-<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js"
-  integrity="sha512-CQBWl4fJHWbryGE+Pc3UJWW1h3Q8IkkvNnPTozals+S49OTEQPoQj/m1LZRM28Wr/7bJCMlpYS3/Zp4hHuWQ=="
-  crossorigin="anonymous"></script>
-
-<!-- diff2html -->
-<link rel="stylesheet"
-  href="https://cdnjs.cloudflare.com/ajax/libs/diff2html/3.4.47/diff2html.min.css"
-  crossorigin="anonymous">
-<script src="https://cdnjs.cloudflare.com/ajax/libs/diff2html/3.4.47/diff2html.min.js"
-  crossorigin="anonymous"></script>
+<!-- Chart.js (vendorisé inline) -->
+<script>{chartjs_inline}</script>
 
 <style>
 /* ── Reset & base ─────────────────────────────────────────────────── */
@@ -579,6 +584,22 @@ tbody tr:hover {{ background: #f8fafc; }}
 }}
 
 /* ── Gallery ──────────────────────────────────────────────────────── */
+/* Robust metrics controls */
+.robust-controls {{
+  display: flex; flex-wrap: wrap; gap: 1.5rem; margin-bottom: .75rem;
+}}
+.robust-controls label {{
+  display: flex; align-items: center; gap: .4rem;
+  font-size: .82rem; color: var(--text-muted);
+}}
+.robust-controls input[type=range] {{ width: 140px; }}
+.slider-val {{
+  font-weight: 700; color: var(--text); min-width: 2.5rem;
+}}
+.robust-table td {{ padding: .4rem .6rem; font-size: .85rem; }}
+.robust-table .improved {{ color: #16a34a; font-weight: 600; }}
+.robust-table .worsened {{ color: #dc2626; font-weight: 600; }}
+
 .gallery-controls {{
   display: flex; align-items: center; gap: .75rem;
   margin-bottom: 1rem; flex-wrap: wrap;
@@ -1057,6 +1078,31 @@ body.present-mode nav .meta {{ display: none; }}
       </div>
     </div>
   </div>
+
+  <!-- ── Métriques robustes ────────────────────────────────────── -->
+  <div class="card" id="robust-metrics-card">
+    <h2 data-i18n="h_robust">Métriques robustes (sans hallucinations)</h2>
+    <p style="font-size:.82rem;color:var(--text-muted);margin-bottom:.75rem" data-i18n="robust_desc">
+      Recalcule CER, WER, MER, WIL en excluant les documents détectés comme hallucinés.
+    </p>
+    <div class="robust-controls">
+      <label>
+        <span data-i18n="robust_anchor_label">Seuil d'ancrage min :</span>
+        <input type="range" id="robust-anchor" min="0" max="1" step="0.05" value="0.5"
+          oninput="document.getElementById('robust-anchor-val').textContent=parseFloat(this.value).toFixed(2);renderRobustMetrics()">
+        <span id="robust-anchor-val" class="slider-val">0.50</span>
+      </label>
+      <label>
+        <span data-i18n="robust_ratio_label">Ratio longueur max :</span>
+        <input type="range" id="robust-ratio" min="1" max="3" step="0.1" value="1.5"
+          oninput="document.getElementById('robust-ratio-val').textContent=parseFloat(this.value).toFixed(1);renderRobustMetrics()">
+        <span id="robust-ratio-val" class="slider-val">1.5</span>
+      </label>
+    </div>
+    <div id="robust-summary" style="font-size:.82rem;color:var(--text-muted);margin:.5rem 0"></div>
+    <div id="robust-table-wrap" class="table-wrap"></div>
+    <div id="robust-excluded-docs" style="margin-top:.75rem;font-size:.82rem"></div>
+  </div>
 </div>
 
 <!-- ════ Vue 2 : Galerie ═══════════════════════════════════════════ -->
@@ -1692,6 +1738,110 @@ document.querySelectorAll('#ranking-table th.sortable').forEach(th => {{
   }});
 }});
 
+// ── Métriques robustes ──────────────────────────────────────────
+function renderRobustMetrics() {{
+  const anchorThreshold = parseFloat(document.getElementById('robust-anchor').value);
+  const ratioThreshold  = parseFloat(document.getElementById('robust-ratio').value);
+
+  // Pour chaque engine : recalculer CER/WER en excluant les docs hallucinés
+  const results = DATA.engines.map(eng => {{
+    const allDocs = DATA.documents;
+    const excluded = [];
+    const cerVals = [], werVals = [], merVals = [], wilVals = [];
+
+    allDocs.forEach(doc => {{
+      const er = doc.engine_results.find(r => r.engine === eng.name);
+      if (!er || er.error) return;
+      const hm = er.hallucination_metrics;
+      const isHall = hm && (hm.anchor_score < anchorThreshold || hm.length_ratio > ratioThreshold);
+      if (isHall) {{
+        excluded.push({{ doc_id: doc.doc_id, anchor: hm.anchor_score, ratio: hm.length_ratio }});
+      }} else {{
+        cerVals.push(er.cer);
+        werVals.push(er.wer);
+        if (er.mer !== undefined) merVals.push(er.mer);
+        if (er.wil !== undefined) wilVals.push(er.wil);
+      }}
+    }});
+
+    const mean = arr => arr.length ? arr.reduce((a,b)=>a+b,0)/arr.length : null;
+    return {{
+      name: eng.name,
+      global_cer: eng.cer,
+      global_wer: eng.wer,
+      robust_cer: mean(cerVals),
+      robust_wer: mean(werVals),
+      robust_mer: mean(merVals),
+      robust_docs: cerVals.length,
+      excluded_count: excluded.length,
+      excluded_docs: excluded,
+    }};
+  }});
+
+  // Résumé
+  const totalExcluded = Math.max(...results.map(r => r.excluded_count));
+  const totalDocs = DATA.documents.length;
+  document.getElementById('robust-summary').textContent =
+    `${{totalExcluded}} document(s) exclu(s) sur ${{totalDocs}} ` +
+    `(seuil ancrage < ${{anchorThreshold.toFixed(2)}}, ratio > ${{ratioThreshold.toFixed(1)}})`;
+
+  // Tableau comparatif
+  const hasRobust = results.some(r => r.excluded_count > 0);
+  const card = document.getElementById('robust-metrics-card');
+  if (!results.some(r => r.excluded_docs.length > 0 || r.robust_cer !== null)) {{
+    document.getElementById('robust-table-wrap').innerHTML =
+      '<p style="color:var(--text-muted);font-size:.82rem">Aucune donnée de hallucinations disponible pour ce corpus.</p>';
+    return;
+  }}
+
+  const rows = results.map(r => {{
+    const delta = r.robust_cer !== null ? r.robust_cer - r.global_cer : null;
+    const deltaClass = delta === null ? '' : (delta < -0.001 ? 'improved' : delta > 0.001 ? 'worsened' : '');
+    const deltaStr = delta === null ? '—' : (delta >= 0 ? '+' : '') + (delta*100).toFixed(2) + '%';
+    return `<tr>
+      <td><b>${{esc(r.name)}}</b></td>
+      <td>${{pct(r.global_cer)}}</td>
+      <td>${{r.robust_cer !== null ? pct(r.robust_cer) : '—'}}</td>
+      <td class="${{deltaClass}}">${{deltaStr}}</td>
+      <td>${{pct(r.global_wer)}}</td>
+      <td>${{r.robust_wer !== null ? pct(r.robust_wer) : '—'}}</td>
+      <td style="color:var(--text-muted)">${{r.excluded_count}} exclu(s) / ${{r.robust_docs}} restant(s)</td>
+    </tr>`;
+  }}).join('');
+
+  document.getElementById('robust-table-wrap').innerHTML = `
+    <table class="robust-table" style="width:100%;border-collapse:collapse">
+      <thead>
+        <tr style="background:var(--bg)">
+          <th style="text-align:left;padding:.4rem .6rem;font-size:.8rem">Moteur</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">CER global</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">CER robuste</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">Δ CER</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">WER global</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">WER robuste</th>
+          <th style="padding:.4rem .6rem;font-size:.8rem">Documents</th>
+        </tr>
+      </thead>
+      <tbody>${{rows}}</tbody>
+    </table>`;
+
+  // Documents exclus
+  const allExcluded = results.flatMap(r => r.excluded_docs.map(d => ({{...d, engine: r.name}})));
+  if (allExcluded.length > 0) {{
+    const uniq = [...new Map(allExcluded.map(d => [d.doc_id, d])).values()];
+    document.getElementById('robust-excluded-docs').innerHTML =
+      `<details><summary style="cursor:pointer;font-size:.82rem;color:var(--text-muted)">` +
+      `▶ Documents exclus (${{uniq.length}})</summary>` +
+      `<ul style="margin:.4rem 0 0 1rem;font-size:.8rem;color:var(--text-muted)">` +
+      uniq.map(d => `<li><a href="#" onclick="openDocument('${{esc(d.doc_id)}}');return false">${{esc(d.doc_id)}}</a>` +
+        ` — ancrage: ${{d.anchor !== undefined ? d.anchor.toFixed(3) : '?'}}, ratio: ${{d.ratio !== undefined ? d.ratio.toFixed(2) : '?'}}</li>`
+      ).join('') +
+      `</ul></details>`;
+  }} else {{
+    document.getElementById('robust-excluded-docs').innerHTML = '';
+  }}
+}}
+
 // ── Vue Galerie ─────────────────────────────────────────────────
 function renderGallery() {{
   const sortKey  = document.getElementById('gallery-sort').value;
@@ -2979,6 +3129,7 @@ function init() {{
   }});
 
   renderRanking();
+  renderRobustMetrics();
   renderGallery();
   buildDocList();
 
@@ -3076,13 +3227,18 @@ class ReportGenerator:
         report_json = json.dumps(report_data, ensure_ascii=False, separators=(",", ":"))
         i18n_json = json.dumps(labels, ensure_ascii=False, separators=(",", ":"))
 
+        # Chart.js contient des { } qui casseraient .format() → injection post-format
+        chartjs_js = _load_vendor_js("chart.umd.min.js")
+
         html = _HTML_TEMPLATE.format(
             corpus_name=self.benchmark.corpus_name,
             picarones_version=self.benchmark.picarones_version,
             report_data_json=report_json,
             i18n_json=i18n_json,
             html_lang=labels.get("html_lang", "fr"),
+            chartjs_inline="__CHARTJS_PLACEHOLDER__",
         )
+        html = html.replace("__CHARTJS_PLACEHOLDER__", chartjs_js)
 
         output_path.write_text(html, encoding="utf-8")
         return output_path.resolve()

picarones/web/app.py

@@ -125,6 +125,7 @@ class BenchmarkRequest(BaseModel):
     corpus_path: str
     engines: list[str] = ["tesseract"]
     normalization_profile: str = "nfc"
+    char_exclude: str = ""   # Caractères à ignorer (séparés par virgule, ex: "',–")
     output_dir: str = "./rapports/"
     report_name: str = ""
     lang: str = "fra"
@@ -156,6 +157,7 @@ class BenchmarkRunRequest(BaseModel):
     corpus_path: str
     competitors: list[CompetitorConfig]
     normalization_profile: str = "nfc"
+    char_exclude: str = ""   # Caractères à ignorer (séparés par virgule, ex: "',–")
     output_dir: str = "./rapports/"
     report_name: str = ""
     report_lang: str = "fr"
@@ -612,7 +614,11 @@ def _extract_page_text(root: ET.Element) -> str:
 
 def _analyze_corpus_dir(path: Path) -> dict:
     """Analyse un dossier et retourne un résumé des paires image/GT détectées."""
-    images = sorted(f.name for f in path.iterdir() if f.suffix.lower() in _IMAGE_EXTS)
+    # Exclure les fichiers cachés macOS (._* AppleDouble) et tout fichier débutant par .
+    images = sorted(
+        f.name for f in path.iterdir()
+        if f.suffix.lower() in _IMAGE_EXTS and not f.name.startswith(".")
+    )
     pairs: list[dict] = []
     missing_gt: list[str] = []
     for img in images:
@@ -662,6 +668,9 @@ def _flatten_zip_to_dir(zf: zipfile.ZipFile, dest: Path) -> None:
             continue
         p = Path(member.filename)
         name = p.name
+        # Ignorer les fichiers cachés macOS (._* créés par AppleDouble dans les ZIPs)
+        if name.startswith("."):
+            continue
         # Accepter images, .gt.txt et .xml (ALTO/PAGE)
         if p.suffix.lower() in _IMAGE_EXTS or name.endswith(".gt.txt") or p.suffix.lower() == ".xml":
             data = zf.read(member.filename)
@@ -779,6 +788,7 @@ async def api_normalization_profiles() -> dict:
             "description": p.description or p.name,
             "caseless": p.caseless,
             "diplomatic_rules": len(p.diplomatic_table),
+            "exclude_chars": sorted(p.exclude_chars),
         }
         for pid, p in NORMALIZATION_PROFILES.items()
     ]
@@ -1155,12 +1165,16 @@ def _run_benchmark_thread_v2(job: BenchmarkJob, req: BenchmarkRunRequest) -> Non
                 "total": total_steps,
             })
 
+        from picarones.core.normalization import _parse_exclude_chars
+        char_excl = _parse_exclude_chars(req.char_exclude) if req.char_exclude else None
+
         result = run_benchmark(
             corpus=corpus,
             engines=engines,
             output_json=output_json,
             show_progress=False,
             progress_callback=_progress_callback,
+            char_exclude=char_excl,
         )
 
         if job.status == "cancelled":
@@ -1259,6 +1273,9 @@ def _run_benchmark_thread(job: BenchmarkJob, req: BenchmarkRequest) -> None:
                 "total": total_steps,
             })
 
+        from picarones.core.normalization import _parse_exclude_chars
+        char_excl = _parse_exclude_chars(req.char_exclude) if req.char_exclude else None
+
         # Lancer le benchmark
         result = run_benchmark(
             corpus=corpus,
@@ -1266,6 +1283,7 @@ def _run_benchmark_thread(job: BenchmarkJob, req: BenchmarkRequest) -> None:
             output_json=output_json,
             show_progress=False,
             progress_callback=_progress_callback,
+            char_exclude=char_excl,
         )
 
         if job.status == "cancelled":
@@ -1661,6 +1679,10 @@ tr:hover td { background: #f0ede6; }
             <option value="nfc">NFC (standard)</option>
           </select>
         </div>
+        <div class="form-group">
+          <label data-i18n="bench_char_exclude_label">Caractères à ignorer <span style="color:var(--text-muted);font-size:.75rem">(séparés par virgule, ex : ', -, –)</span></label>
+          <input type="text" id="char-exclude" placeholder="ex: ', -, –, ." style="font-family:monospace" />
+        </div>
         <div class="form-group">
           <label data-i18n="bench_output_label">Dossier de sortie</label>
           <input type="text" id="output-dir" value="./rapports/" />
@@ -2239,19 +2261,27 @@ function renderCompetitors() {
 }
 
 // ─── Normalization profiles ──────────────────────────────────────────────────
+let _normProfilesData = [];
 async function loadNormProfiles() {
   try {
     const r = await fetch("/api/normalization/profiles");
     const d = await r.json();
+    _normProfilesData = d.profiles || [];
     const sel = document.getElementById("norm-profile");
     sel.innerHTML = "";
-    d.profiles.forEach(p => {
+    _normProfilesData.forEach(p => {
       const opt = document.createElement("option");
       opt.value = p.id;
       opt.textContent = `${p.name} — ${p.description}`;
       if (p.id === "nfc") opt.selected = true;
       sel.appendChild(opt);
     });
+    sel.addEventListener("change", () => {
+      const p = _normProfilesData.find(x => x.id === sel.value);
+      if (p && p.exclude_chars && p.exclude_chars.length) {
+        document.getElementById("char-exclude").value = p.exclude_chars.join(", ");
+      }
+    });
   } catch(e) {}
 }
 
@@ -2322,6 +2352,7 @@ async function startBenchmark() {
     corpus_path: corpusPath,
     competitors: _competitors,
     normalization_profile: document.getElementById("norm-profile").value,
+    char_exclude: document.getElementById("char-exclude").value.trim(),
     output_dir: document.getElementById("output-dir").value,
     report_name: document.getElementById("report-name").value,
   };

tests/test_report.py

@@ -161,11 +161,12 @@ class TestReportGenerator:
         html = out.read_text(encoding="utf-8")
         assert "chart.js" in html.lower() or "Chart.js" in html
 
-    def test_contains_diff2html(self, sample_generator, tmp_path):
+    def test_contains_chartjs(self, sample_generator, tmp_path):
         out = tmp_path / "rapport.html"
         sample_generator.generate(out)
         html = out.read_text(encoding="utf-8")
-        assert "diff2html" in html.lower()
+        # Chart.js est désormais embarqué inline (plus de CDN)
+        assert "Chart.js" in html or "new Chart(" in html
 
     def test_data_embedded(self, sample_generator, tmp_path):
         out = tmp_path / "rapport.html"

tests/test_sprint12_nouvelles_fonctionnalites.py

@@ -0,0 +1,258 @@
+"""Tests pour les nouvelles fonctionnalités du sprint 12 :
+1. Filtrage des fichiers cachés macOS (._*) dans corpus et ZIP
+2. Profils de normalisation avec exclusion de caractères
+3. Vue Analyses — Chart.js inline (plus de CDN)
+4. Métriques robustes dans le rapport HTML
+"""
+
+from __future__ import annotations
+
+import io
+import zipfile
+from pathlib import Path
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# 1. Filtrage des fichiers cachés macOS
+# ---------------------------------------------------------------------------
+
+FAKE_PNG = (
+    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01"
+    b"\x00\x00\x00\x01\x08\x02\x00\x00\x00\x90wS\xde\x00\x00"
+    b"\x00\x0cIDATx\x9cc\xf8\x0f\x00\x00\x01\x01\x00\x05\x18"
+    b"\xd8N\x00\x00\x00\x00IEND\xaeB`\x82"
+)
+
+
+class TestMacOSHiddenFilesFiltering:
+    def test_hidden_images_ignored_in_corpus(self, tmp_path):
+        """Les fichiers ._* ne doivent pas être comptés comme images valides."""
+        from picarones.core.corpus import load_corpus_from_directory
+
+        # Image réelle avec GT
+        (tmp_path / "page_001.png").write_bytes(FAKE_PNG)
+        (tmp_path / "page_001.gt.txt").write_text("Texte réel", encoding="utf-8")
+
+        # Fichiers AppleDouble macOS (sans GT associé)
+        (tmp_path / "._page_001.png").write_bytes(b"\x00\x05\x16\x07")
+        (tmp_path / ".DS_Store").write_bytes(b"\x00\x00\x00\x01Bud1")
+
+        corpus = load_corpus_from_directory(tmp_path)
+        assert len(corpus) == 1
+        assert corpus.documents[0].doc_id == "page_001"
+
+    def test_hidden_files_not_extracted_from_zip(self, tmp_path):
+        """_flatten_zip_to_dir doit ignorer les entrées ._* dans le ZIP."""
+        from picarones.web.app import _flatten_zip_to_dir
+
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w") as zf:
+            zf.writestr("page_001.png", FAKE_PNG)
+            zf.writestr("page_001.gt.txt", "Texte réel")
+            zf.writestr("._page_001.png", b"\x00\x05\x16\x07")
+            zf.writestr("__MACOSX/._page_001.png", b"\x00\x05\x16\x07")
+
+        buf.seek(0)
+        dest = tmp_path / "corpus"
+        dest.mkdir()
+        with zipfile.ZipFile(buf) as zf:
+            _flatten_zip_to_dir(zf, dest)
+
+        files = {f.name for f in dest.iterdir()}
+        assert "._page_001.png" not in files
+        assert "page_001.png" in files
+        assert "page_001.gt.txt" in files
+
+
+# ---------------------------------------------------------------------------
+# 2. Profils de normalisation avec exclusion de caractères
+# ---------------------------------------------------------------------------
+
+class TestExcludeCharsNormalization:
+    def test_parse_exclude_chars_from_comma_string(self):
+        from picarones.core.normalization import _parse_exclude_chars
+
+        result = _parse_exclude_chars("', -, –")
+        assert "'" in result
+        assert "-" in result
+        assert "–" in result
+
+    def test_parse_exclude_chars_from_plain_string(self):
+        from picarones.core.normalization import _parse_exclude_chars
+
+        result = _parse_exclude_chars(".,;:!?")
+        assert "." in result
+        assert "," in result
+        assert "?" in result
+
+    def test_parse_exclude_chars_empty(self):
+        from picarones.core.normalization import _parse_exclude_chars
+
+        assert _parse_exclude_chars("") == frozenset()
+        assert _parse_exclude_chars(None) == frozenset()
+
+    def test_normalize_strips_excluded_chars(self):
+        from picarones.core.normalization import NormalizationProfile
+
+        profile = NormalizationProfile(
+            name="test",
+            exclude_chars=frozenset([".", ","]),
+        )
+        assert profile.normalize("Bonjour, monde.") == "Bonjour monde"
+
+    def test_sans_ponctuation_profile_exists(self):
+        from picarones.core.normalization import NORMALIZATION_PROFILES
+
+        assert "sans_ponctuation" in NORMALIZATION_PROFILES
+        p = NORMALIZATION_PROFILES["sans_ponctuation"]
+        assert "." in p.exclude_chars
+        assert "," in p.exclude_chars
+        assert "?" in p.exclude_chars
+
+    def test_sans_apostrophes_profile_exists(self):
+        from picarones.core.normalization import NORMALIZATION_PROFILES
+
+        assert "sans_apostrophes" in NORMALIZATION_PROFILES
+        p = NORMALIZATION_PROFILES["sans_apostrophes"]
+        assert "'" in p.exclude_chars
+        assert "\u2019" in p.exclude_chars  # apostrophe typographique
+
+    def test_compute_metrics_with_char_exclude(self):
+        from picarones.core.metrics import compute_metrics
+
+        ref = "Bonjour, monde!"
+        hyp = "Bonjour monde"
+        # Sans exclusion, CER > 0 (virgule et ! manquants)
+        metrics_raw = compute_metrics(ref, hyp)
+        assert metrics_raw.cer > 0
+
+        # Avec exclusion de la ponctuation, les deux textes deviennent identiques
+        metrics_excl = compute_metrics(ref, hyp, char_exclude=frozenset([",", "!", " "]))
+        # CER devrait être 0 ou très faible maintenant (Bonjourmonde == Bonjourmonde)
+        assert metrics_excl.cer == 0.0
+
+    def test_char_exclude_propagated_in_run_benchmark(self, tmp_path):
+        """char_exclude doit être transmis à run_benchmark et réduire le CER."""
+        from picarones.core.corpus import Corpus, Document
+        from picarones.core.runner import run_benchmark
+        from picarones.engines.base import BaseOCREngine, EngineResult
+
+        class MockEngine(BaseOCREngine):
+            name = "mock"
+            version = "0.0"
+
+            def _run_ocr(self, image_path):
+                return EngineResult(text="Bonjour monde", success=True)
+
+        doc = Document(image_path=tmp_path / "page.png", ground_truth="Bonjour, monde!")
+        (tmp_path / "page.png").write_bytes(FAKE_PNG)
+        corpus = Corpus(name="test", documents=[doc])
+
+        result_raw = run_benchmark(corpus, [MockEngine()])
+        cer_raw = result_raw.engine_reports[0].document_results[0].metrics.cer
+
+        result_excl = run_benchmark(corpus, [MockEngine()], char_exclude=frozenset([",", "!"]))
+        cer_excl = result_excl.engine_reports[0].document_results[0].metrics.cer
+
+        assert cer_excl <= cer_raw
+
+
+# ---------------------------------------------------------------------------
+# 3. Vue Analyses — Chart.js inline
+# ---------------------------------------------------------------------------
+
+class TestChartJsInline:
+    def test_chartjs_embedded_inline(self, sample_generator, tmp_path):
+        """Le rapport HTML doit embarquer Chart.js inline (pas de CDN)."""
+        out = tmp_path / "rapport.html"
+        sample_generator.generate(out)
+        html = out.read_text(encoding="utf-8")
+
+        assert "cdnjs.cloudflare.com/ajax/libs/Chart.js" not in html
+        assert "Chart.js v" in html or "new Chart(" in html
+
+    def test_no_diff2html_cdn(self, sample_generator, tmp_path):
+        """Le rapport ne doit plus référencer diff2html (CDN supprimé)."""
+        out = tmp_path / "rapport.html"
+        sample_generator.generate(out)
+        html = out.read_text(encoding="utf-8")
+
+        assert "diff2html" not in html
+
+    def test_build_charts_function_present(self, sample_generator, tmp_path):
+        out = tmp_path / "rapport.html"
+        sample_generator.generate(out)
+        html = out.read_text(encoding="utf-8")
+
+        assert "function buildCharts()" in html
+        assert "buildCerHistogram" in html
+        assert "buildRadar" in html
+
+
+@pytest.fixture
+def sample_generator():
+    """Fixture partagée : crée un ReportGenerator avec des données fictives."""
+    from picarones.report.generator import ReportGenerator
+    from picarones.core.results import BenchmarkResult, DocumentResult, EngineReport
+    from picarones.core.metrics import MetricsResult
+
+    def _make_metric(cer=0.1):
+        return MetricsResult(
+            cer=cer, cer_nfc=cer, cer_caseless=cer,
+            wer=cer, wer_normalized=cer, mer=cer, wil=cer,
+            reference_length=100, hypothesis_length=100,
+        )
+
+    docs = [
+        DocumentResult(
+            doc_id=f"doc_{i}", image_path="", ground_truth="GT text",
+            hypothesis="Hyp text", metrics=_make_metric(0.1 + i * 0.01),
+            duration_seconds=0.1,
+        )
+        for i in range(3)
+    ]
+    report = EngineReport(engine_name="tesseract", engine_version="5.0", engine_config={}, document_results=docs)
+    bm = BenchmarkResult(
+        corpus_name="TestCorpus", corpus_source=None, document_count=3,
+        engine_reports=[report],
+    )
+    return ReportGenerator(bm)
+
+
+# ---------------------------------------------------------------------------
+# 4. Métriques robustes — présence dans le rapport HTML
+# ---------------------------------------------------------------------------
+
+class TestRobustMetrics:
+    def test_robust_metrics_card_present(self, sample_generator, tmp_path):
+        """La carte Métriques robustes doit être présente dans le rapport."""
+        out = tmp_path / "rapport.html"
+        sample_generator.generate(out)
+        html = out.read_text(encoding="utf-8")
+
+        assert "robust-metrics-card" in html
+        assert "robust-anchor" in html
+        assert "robust-ratio" in html
+        assert "renderRobustMetrics" in html
+
+    def test_robust_metrics_js_syntax_valid(self, sample_generator, tmp_path):
+        """La fonction renderRobustMetrics ne doit pas introduire de SyntaxError JS."""
+        import re
+        import subprocess
+
+        out = tmp_path / "rapport.html"
+        sample_generator.generate(out)
+        html = out.read_text(encoding="utf-8")
+
+        scripts = re.findall(r"<script>(.*?)</script>", html, re.DOTALL)
+        # Le bloc applicatif est le dernier script
+        app_js = tmp_path / "app.js"
+        app_js.write_text(scripts[-1], encoding="utf-8")
+
+        result = subprocess.run(
+            ["node", "--check", str(app_js)],
+            capture_output=True, text=True,
+        )
+        assert result.returncode == 0, f"Erreur JS : {result.stderr}"