Update app.py

app.py

@@ -3,112 +3,118 @@ import numpy as np
 from paddleocr import PaddleOCR
 from sklearn.cluster import KMeans
 
+# -----------------------------
+# OCR
+# -----------------------------
 ocr = PaddleOCR(
     use_textline_orientation=True,
     lang="fr"
 )
 
-HEADER_EXACT = "DESIGNATIONS"
-
-def extract_column2_9_lines(image):
+# -----------------------------
+# Extraction de la 2e colonne
+# -----------------------------
+def extract_second_column(image):
     if image is None:
         return "Aucune image fournie."
 
     img = np.array(image)
     result = ocr.predict(img)
 
-    if not result:
-        return "Aucun texte détecté."
+    if not result or len(result[0]["rec_texts"]) == 0:
+        return "OCR exécuté mais aucun texte détecté."
 
     data = result[0]
-    texts = data.get("rec_texts", [])
-    boxes = data.get("dt_polys", [])
+    texts = data["rec_texts"]
+    boxes = data["dt_polys"]
 
     elements = []
     for text, box in zip(texts, boxes):
         text = text.strip()
-        if len(text) < 2:
+        if len(text) < 3:
             continue
-        x = np.mean([p[0] for p in box])
-        y = np.mean([p[1] for p in box])
-        elements.append((x, y, text))
-
-    if len(elements) < 5:
-        return "Pas assez de données OCR."
-
-    # --- CLUSTER COLONNES ---
-    X = np.array([[e[0]] for e in elements])
-    kmeans = KMeans(n_clusters=min(7, len(elements)//6 + 2), random_state=42, n_init=10)
-    labels = kmeans.fit_predict(X)
-
-    columns = {}
-    for (x, y, t), lbl in zip(elements, labels):
-        columns.setdefault(lbl, []).append((x, y, t))
 
-    # --- COLONNE DESCRIPTION = max texte non numérique ---
-    def score(col):
-        return sum(len(t) for _,_,t in col if not any(c.isdigit() for c in t))
+        x_center = np.mean([p[0] for p in box])
+        y_center = np.mean([p[1] for p in box])
 
-    desc_col = max(columns.values(), key=score)
-    desc_col.sort(key=lambda e: e[1])  # top -> bottom
+        elements.append((x_center, y_center, text))
 
-    # --- LOCALISER L’EN-TÊTE ---
-    header_index = None
-    for i, (_, _, t) in enumerate(desc_col):
-        if t.upper() == HEADER_EXACT:
-            header_index = i
-            break
+    if len(elements) < 5:
+        return "Pas assez de texte détecté."
 
-    if header_index is None:
-        start_index = 0
-    else:
-        start_index = header_index + 1
+    # -----------------------------
+    # 1. Regroupement en colonnes (par X)
+    # -----------------------------
+    X = np.array([[e[0]] for e in elements])
 
-    content = desc_col[start_index:]
+    # Nombre de colonnes estimé automatiquement
+    n_cols = min(6, max(2, len(elements) // 6))
 
-    # --- SEUIL ADAPTATIF ---
-    ys = [y for _,y,_ in content]
-    Y_THRESHOLD = max(22, np.median(np.diff(sorted(ys))) * 1.2) if len(ys) > 1 else 30
+    kmeans = KMeans(n_clusters=n_cols, random_state=42, n_init=10)
+    labels = kmeans.fit_predict(X)
 
-    # --- FUSION ---
-    lines = []
+    columns = {}
+    for (x, y, text), label in zip(elements, labels):
+        columns.setdefault(label, []).append((x, y, text))
+
+    # Trier les colonnes de gauche à droite
+    sorted_columns = sorted(
+        columns.values(),
+        key=lambda col: np.mean([e[0] for e in col])
+    )
+
+    if len(sorted_columns) < 2:
+        return "Impossible de détecter la 2e colonne."
+
+    # -----------------------------
+    # 2. Sélection de la 2e colonne
+    # -----------------------------
+    col = sorted_columns[1]
+    col.sort(key=lambda e: e[1])  # top → bottom
+
+    # -----------------------------
+    # 3. Fusion verticale (cellules)
+    # -----------------------------
+    merged = []
     current = ""
     last_y = None
+    Y_THRESHOLD = 22
 
-    for _, y, text in content:
+    for _, y, text in col:
         if last_y is None or abs(y - last_y) > Y_THRESHOLD:
             if current:
-                lines.append(current.strip())
+                merged.append(current.strip())
             current = text
         else:
             current += " " + text
+
         last_y = y
 
     if current:
-        lines.append(current.strip())
+        merged.append(current.strip())
 
-    # --- NETTOYAGE ---
-    final = []
-    for i, l in enumerate(lines):
-        if i == 0:
-            final.append(l)  # Toujours garder la 1ère vraie ligne
-            continue
-        if len(l) < 5:
-            continue
-        if sum(c.isdigit() for c in l) > len(l)/2:
-            continue
-        final.append(l)
+    # -----------------------------
+    # 4. Nettoyage léger
+    # -----------------------------
+    final = [
+        line for line in merged
+        if len(line) > 5
+    ]
 
-    final = final[:9]
+    if not final:
+        return "Colonne détectée mais vide."
 
-    return "\n".join([f"{i+1}. {l}" for i,l in enumerate(final)])
+    return "\n".join(f"{i+1}. {l}" for i, l in enumerate(final))
 
-# --- GRADIO ---
+# -----------------------------
+# Interface Gradio
+# -----------------------------
 demo = gr.Interface(
-    fn=extract_column2_9_lines,
+    fn=extract_second_column,
     inputs=gr.Image(type="pil", label="Image du tableau"),
-    outputs=gr.Textbox(label="Colonne DESIGNATIONS"),
-    title="Extraction fiable de la colonne DESIGNATIONS",
+    outputs=gr.Textbox(label="Contenu de la 2e colonne"),
+    title="Extraction de la 2e colonne du tableau",
+    description="La colonne cible est toujours la deuxième (texte uniquement)"
 )
 
 demo.launch(server_name="0.0.0.0", server_port=7860)