Upload 3 files

README.md

@@ -1,12 +1,58 @@
----
-title: Décompte des tableaux
-emoji: 📊
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.29.0
-app_file: app.py
-pinned: false
----
-
-Décompte de PASF, IPM (= ASS), PR, MUT, RESULTAT et CONTROL dans la 2e colonne de tableaux photographiés (OCR Tesseract + OpenCV).
+# Décompte PASF / IPM(ASS) / PR / MUT / RESULTAT / CONTROL
+
+Petite interface web pour compter automatiquement ces catégories dans des **images de tableaux**.
+
+## Catégories comptées
+
+| Catégorie   | Remarques                          |
+|-------------|------------------------------------|
+| **PASF**    |                                    |
+| **IPM/ASS** | `IPM` et `ASS` sont équivalents    |
+| **PR**      |                                    |
+| **MUT**     |                                    |
+| **RESULTAT**|                                    |
+| **CONTROL** |                                    |
+
+## Installation rapide
+
+```bash
+# 1. Installer Tesseract OCR (si pas déjà fait)
+# Ubuntu/Debian :
+sudo apt update && sudo apt install -y tesseract-ocr tesseract-ocr-fra tesseract-ocr-eng
+
+# macOS (Homebrew) :
+brew install tesseract tesseract-lang
+
+# Windows : télécharger depuis https://github.com/UB-Mannheim/tesseract/wiki
+# et ajouter le chemin dans les variables d'environnement
+
+# 2. Installer les dépendances Python
+pip install -r requirements.txt
+```
+
+## Lancement
+
+```bash
+python app.py
+```
+
+Puis ouvrir dans le navigateur l’adresse affichée (généralement http://127.0.0.1:7860).
+
+## Utilisation
+
+1. Cliquez sur la zone d’upload et sélectionnez une ou plusieurs images de tableaux.
+2. Cliquez sur **Analyser les images**.
+3. Le rapport de décompte apparaît (totaux + détail par image).
+4. Vous pouvez ouvrir l’accordéon « Texte OCR brut » pour vérifier ce que le système a lu.
+
+## Conseils
+
+- Images nettes, bien cadrées, contraste correct.
+- Si l’OCR se trompe (ex. « 1PM » au lieu de « IPM »), regardez le texte OCR et corrigez manuellement le compte si besoin.
+- Le prétraitement d’image (CLAHE + binarisation) aide beaucoup sur les photos de tableaux.
+
+## Notes techniques
+
+- OCR : Tesseract (français + anglais)
+- Interface : Gradio
+- IPM et ASS sont fusionnés dans une seule catégorie « IPM/ASS »

app.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""
+Interface de décompte PASF / IPM(ASS) / PR / MUT / RESULTAT / CONTROL
+à partir d'images de tableaux (OCR).
+"""
+
+import re
+import io
+from collections import Counter, defaultdict
+from typing import List, Dict, Tuple
+
+import gradio as gr
+import numpy as np
+from PIL import Image
+import cv2
+import pytesseract
+
+# Catégories à compter (IPM et ASS sont équivalents)
+CATEGORIES = ["PASF", "IPM/ASS", "PR", "MUT", "RESULTAT", "CONTROL"]
+
+# Patterns regex (insensible à la casse, mots entiers)
+PATTERNS = {
+    "PASF": re.compile(r"\bPASF\b", re.IGNORECASE),
+    "IPM/ASS": re.compile(r"\b(?:IPM|ASS)\b", re.IGNORECASE),
+    "PR": re.compile(r"\bPR\b", re.IGNORECASE),
+    "MUT": re.compile(r"\bMUT\b", re.IGNORECASE),
+    "RESULTAT": re.compile(r"\bRESULTAT\b", re.IGNORECASE),
+    "CONTROL": re.compile(r"\bCONTROL\b", re.IGNORECASE),
+}
+
+
+def preprocess_image(img: Image.Image) -> Image.Image:
+    """Améliore l'image pour un meilleur OCR (tableaux)."""
+    # Convertir en OpenCV
+    arr = np.array(img.convert("RGB"))
+    gray = cv2.cvtColor(arr, cv2.COLOR_RGB2GRAY)
+
+    # Amélioration du contraste (CLAHE)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    gray = clahe.apply(gray)
+
+    # Binarisation adaptative (bon pour les tableaux)
+    binary = cv2.adaptiveThreshold(
+        gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+    )
+
+    # Léger débruitage
+    binary = cv2.medianBlur(binary, 3)
+
+    return Image.fromarray(binary)
+
+
+def extract_text(img: Image.Image, lang: str = "fra+eng") -> str:
+    """OCR avec configuration adaptée aux tableaux."""
+    # Essayer plusieurs modes de segmentation
+    configs = [
+        "--psm 6 --oem 3",   # Bloc uniforme de texte
+        "--psm 4 --oem 3",   # Colonne unique
+        "--psm 11 --oem 3",  # Texte dispersé
+    ]
+    best_text = ""
+    max_len = 0
+
+    processed = preprocess_image(img)
+
+    for config in configs:
+        try:
+            text = pytesseract.image_to_string(processed, lang=lang, config=config)
+            if len(text) > max_len:
+                max_len = len(text)
+                best_text = text
+        except Exception:
+            continue
+
+    # Fallback sans prétraitement si rien
+    if not best_text.strip():
+        best_text = pytesseract.image_to_string(img, lang=lang, config="--psm 6")
+
+    return best_text
+
+
+def count_categories(text: str) -> Dict[str, int]:
+    """Compte les occurrences de chaque catégorie."""
+    counts = {cat: 0 for cat in CATEGORIES}
+    for cat, pattern in PATTERNS.items():
+        matches = pattern.findall(text)
+        counts[cat] = len(matches)
+    return counts
+
+
+def process_images(files: List) -> Tuple[str, str, str]:
+    """
+    Traite une ou plusieurs images et génère le rapport.
+    Retourne : (rapport markdown, détail OCR, résumé JSON-like)
+    """
+    if not files:
+        return "Aucune image fournie.", "", ""
+
+    total_counts = Counter()
+    per_image = []
+    all_ocr = []
+
+    for i, file in enumerate(files, 1):
+        try:
+            # Gradio donne un objet fichier ou un chemin
+            if hasattr(file, "name"):
+                img = Image.open(file.name)
+                name = file.name.split("/")[-1]
+            else:
+                img = Image.open(file)
+                name = f"image_{i}"
+
+            text = extract_text(img)
+            counts = count_categories(text)
+            total_counts.update(counts)
+
+            per_image.append({
+                "nom": name,
+                "counts": counts,
+                "texte": text
+            })
+            all_ocr.append(f"=== {name} ===\n{text}\n")
+        except Exception as e:
+            per_image.append({
+                "nom": f"image_{i}",
+                "counts": {cat: 0 for cat in CATEGORIES},
+                "texte": f"ERREUR: {str(e)}"
+            })
+            all_ocr.append(f"=== image_{i} ===\nERREUR: {e}\n")
+
+    # Construction du rapport
+    lines = []
+    lines.append("# Rapport de décompte")
+    lines.append("")
+    lines.append(f"**Nombre d'images analysées :** {len(files)}")
+    lines.append("")
+    lines.append("## Totaux globaux")
+    lines.append("")
+    lines.append("| Catégorie | Nombre |")
+    lines.append("|-----------|--------|")
+    for cat in CATEGORIES:
+        lines.append(f"| **{cat}** | **{total_counts[cat]}** |")
+    lines.append("")
+    total_all = sum(total_counts.values())
+    lines.append(f"**Total des occurrences :** {total_all}")
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+    lines.append("## Détail par image")
+    lines.append("")
+
+    for item in per_image:
+        lines.append(f"### {item['nom']}")
+        lines.append("")
+        lines.append("| Catégorie | Nombre |")
+        lines.append("|-----------|--------|")
+        for cat in CATEGORIES:
+            lines.append(f"| {cat} | {item['counts'][cat]} |")
+        lines.append("")
+
+    report_md = "\n".join(lines)
+    ocr_text = "\n".join(all_ocr)
+
+    # Résumé simple pour copie
+    summary = "RÉSUMÉ\n" + "\n".join(f"{cat}: {total_counts[cat]}" for cat in CATEGORIES)
+
+    return report_md, ocr_text, summary
+
+
+# Interface Gradio
+with gr.Blocks(
+    title="Décompte PASF / IPM / PR / MUT / RESULTAT / CONTROL",
+) as demo:
+    gr.Markdown(
+        """
+        # 📊 Décompte de catégories dans des tableaux (images)
+
+        **Catégories comptées :** PASF · IPM/ASS · PR · MUT · RESULTAT · CONTROL  
+
+        > **Note :** `IPM` et `ASS` sont considérés comme **équivalents** (même catégorie).
+
+        Uploadez une ou plusieurs images de tableaux, puis cliquez sur **Analyser**.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            files = gr.File(
+                label="Images du/des tableau(x)",
+                file_count="multiple",
+                file_types=["image"],
+                type="filepath"
+            )
+            btn = gr.Button("🔍 Analyser les images", variant="primary", size="lg")
+            clear_btn = gr.Button("Effacer", variant="secondary")
+
+        with gr.Column(scale=2):
+            report = gr.Markdown(label="Rapport")
+            with gr.Accordion("Texte OCR brut (pour vérification)", open=False):
+                ocr_out = gr.Textbox(label="OCR", lines=15, max_lines=30)
+            summary = gr.Textbox(label="Résumé rapide (copiable)", lines=8)
+
+    btn.click(
+        fn=process_images,
+        inputs=[files],
+        outputs=[report, ocr_out, summary]
+    )
+    clear_btn.click(
+        fn=lambda: (None, "", "", ""),
+        inputs=None,
+        outputs=[files, report, ocr_out, summary]
+    )
+
+    gr.Markdown(
+        """
+        ---
+        **Conseils pour de meilleurs résultats :**
+        - Images nettes, bien éclairées, tableau centré
+        - Évitez les photos trop inclinées ou floues
+        - Les colonnes/lignes doivent être lisibles
+        - Si un mot est mal reconnu, vérifiez le texte OCR et corrigez manuellement si besoin
+        """
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        theme=gr.themes.Soft()
+    )

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0
+pytesseract>=0.3.10
+Pillow>=9.0
+opencv-python-headless>=4.5
+numpy>=1.20