Update app.py

app.py

@@ -1,245 +1,83 @@
-import gradio as gr
-import fitz  # PyMuPDF
-from PIL import Image
-import numpy as np
-import cv2
 import pytesseract
-import base64
-import os
-import unicodedata
+from PIL import Image
 import re
-from transformers import pipeline
-
-# Inicializa el pipeline de traducción EN->ES una sola vez
-translator = pipeline("translation_en_to_es", model="Helsinki-NLP/opus-mt-en-es")
-
-# ---------- OCR y limpieza de texto ----------
+import unicodedata
 
-def clean_ocr_text(text):
-    text = unicodedata.normalize("NFC", text)
-    lines = text.splitlines()
-    cleaned_lines = [line.strip() for line in lines if line.strip()]
-    return "\n".join(cleaned_lines)
+# Configuración avanzada de Tesseract para OCR en español
+OCR_CONFIG = r'--oem 3 --psm 6'
+
+# Corrección básica de errores comunes de OCR
+def clean_text(text):
+    # Normaliza caracteres Unicode (acentos, símbolos)
+    text = unicodedata.normalize('NFKC', text)
+
+    # Diccionario de correcciones frecuentes
+    replacements = {
+        "martphone": "smartphone",
+        "desinstatar": "desinstalar",
+        "Desconectas": "desconectadas",
+        "cuestiónn": "cuestión",
+        "el coche sólo cargando": "el coche solo carga cuando",
+        "Modo online": "Modo en línea",
+        "Modo Online": "Modo en línea",
+        "Modo sin conexión": "modo sin conexión",
+        "desconectas": "desconectadas",
+        "cuestión no resolverá": "cuestión no solucionará",
+        "El símbolo del globo": "\nEl símbolo del globo",
+    }
+
+    for wrong, correct in replacements.items():
+        text = text.replace(wrong, correct)
 
-def fix_common_ocr_errors(text):
-    text = text.replace(" e ", " • ")  # cuando OCR confunde viñetas con "e"
-    text = re.sub(r'\bposibl\b', 'posible', text, flags=re.IGNORECASE)
-    text = re.sub(r'\binstatar\b', 'instalar', text)
-    text = re.sub(r'\bfuncionación\b', 'función taller', text)
-    text = re.sub(r'\boptar\b', 'opta', text)
-    text = re.sub(r'ICACIONES\b', 'APLICACIONES', text)
-    text = re.sub(r'Lar\b', 'la', text)
-    text = re.sub(r'([a-zA-Z])-\n([a-zA-Z])', r'\1\2', text)  # une palabras partidas por salto
     return text
 
+# Formatea el texto limpio en Markdown estructurado
 def format_text_to_markdown(text):
-    # Corrige errores comunes
-    text = fix_common_ocr_errors(text)
-    
-    # Línea por línea
+    text = clean_text(text)
     lines = text.splitlines()
-    markdown_lines = []
-    
+    markdown = []
+
     for line in lines:
         line = line.strip()
         if not line:
             continue
 
-        # Encabezados conocidos
-        if re.search(r"\b(posible causa)\b", line, re.IGNORECASE):
-            markdown_lines.append("### 🛑 Posible causa\n")
+        # Encabezados comunes detectados por OCR
+        if re.search(r"^posible causa", line, re.IGNORECASE):
+            markdown.append("### 🛑 Posible causa\n")
             continue
-        elif re.search(r"\b(posible solución)\b", line, re.IGNORECASE):
-            markdown_lines.append("### ✅ Posible solución\n")
+        elif re.search(r"^posible solución", line, re.IGNORECASE):
+            markdown.append("### ✅ Posible solución\n")
             continue
-        elif re.search(r"\b(descripción del problema)\b", line, re.IGNORECASE):
-            markdown_lines.append("### 📝 Descripción del problema\n")
+        elif re.search(r"^descripción del problema", line, re.IGNORECASE):
+            markdown.append("### 📝 Descripción del problema\n")
             continue
+
+        # Listas con viñetas o números
         elif re.match(r"^\d+\.", line):
-            markdown_lines.append(f"- {line}")
+            markdown.append(f"- {line}")
             continue
         elif re.match(r"^[•*-]", line):
-            markdown_lines.append(f"- {line[1:].strip()}")
-            continue
-        else:
-            # Detecta si la línea es basura (letras sin sentido, símbolos)
-            if len(line) < 5:
-                continue
-            if re.search(r"[^\w\s.,:;¡!¿?\-()]", line):
-                symbols = re.findall(r"[^\w\s.,:;¡!¿?\-()]", line)
-                if len(symbols) > 3:
-                    continue  # basura
-            markdown_lines.append(line)
-
-    # Une líneas y separa párrafos correctamente
-    formatted_text = "\n\n".join(markdown_lines)
-    return formatted_text
-
-def translate_text(text):
-    if len(text.strip()) < 5:
-        return text
-    chunks = [text[i:i+500] for i in range(0, len(text), 500)]
-    translated = []
-    for chunk in chunks:
-        result = translator(chunk)
-        translated.append(result[0]["translation_text"])
-    return "\n".join(translated)
-
-# ---------- Funciones de imagen ----------
-
-def text_area_ratio(image):
-    np_img = np.array(image.convert("L"))
-    _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY_INV)
-    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    text_area = sum(w * h for x, y, w, h in [cv2.boundingRect(c) for c in contours if 8 < cv2.boundingRect(c)[3] < 40 and 5 < cv2.boundingRect(c)[2] < 100])
-    total_area = np_img.shape[0] * np_img.shape[1]
-    return text_area / total_area if total_area > 0 else 0
-
-def has_significant_text(image):
-    return text_area_ratio(image) > 0.25
-
-def is_primarily_text(image, ocr_threshold=30):
-    if has_significant_text(image):
-        ocr_result = pytesseract.image_to_string(image, lang="eng+spa")
-        return len(ocr_result.strip()) > ocr_threshold
-    return False
-
-def is_likely_photo(crop):
-    np_crop = np.array(crop)
-    gray = cv2.cvtColor(np_crop, cv2.COLOR_RGB2GRAY)
-    return np.std(gray) > 25 and len(np.unique(gray)) > 50
-
-def extract_visual_regions(image):
-    np_img = np.array(image.convert("RGB"))
-    gray = cv2.cvtColor(np_img, cv2.COLOR_RGB2GRAY)
-    _, binary = cv2.threshold(gray, 220, 255, cv2.THRESH_BINARY_INV)
-    closed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15)))
-    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(closed, connectivity=8)
-    results = []
-    for i in range(1, num_labels):
-        x, y, w, h, area = stats[i]
-        if area > 2000 and 0.3 < (w / float(h)) < 3.5:
-            bbox = (x, y, x + w, y + h)
-            crop = image.crop(bbox)
-            if is_likely_photo(crop) and text_area_ratio(crop) < 0.25 and not is_primarily_text(crop):
-                results.append(crop)
-    return results
-
-# ---------- Extracción de texto + imágenes ----------
-
-def extract_text_markdown(doc, image_paths, page_index, seen_xrefs):
-    markdown_output = f"\n## Página {page_index + 1}\n\n"
-    image_counter = 1
-    elements = []
-    page = doc[0]
-    blocks = page.get_text("dict")["blocks"]
-
-    for b in blocks:
-        y = b["bbox"][1]
-        if b["type"] == 0:
-            for line in b["lines"]:
-                line_y = line["bbox"][1]
-                line_text = " ".join([span["text"] for span in line["spans"]]).strip()
-                line_text = clean_ocr_text(line_text)
-                max_font_size = max([span.get("size", 10) for span in line["spans"]])
-                if line_text:
-                    elements.append((line_y, line_text, max_font_size))
-
-    images_on_page = page.get_images(full=True)
-    for img_index, img in enumerate(images_on_page):
-        xref = img[0]
-        if xref in seen_xrefs:
+            markdown.append(f"- {line[1:].strip()}")
             continue
-        seen_xrefs.add(xref)
-        try:
-            base_image = page.parent.extract_image(xref)
-            image_bytes = base_image["image"]
-            ext = base_image["ext"]
-            image_path = f"/tmp/imagen_p{page_index + 1}_{img_index + 1}.{ext}"
-            with open(image_path, "wb") as f:
-                f.write(image_bytes)
-            image_paths.append(image_path)
-            elements.append((float("inf") - img_index, f"\n\n![imagen_{image_counter}]({image_path})\n", 10))
-            image_counter += 1
-        except Exception as e:
-            elements.append((float("inf"), f"[Error imagen: {e}]", 10))
-
-    elements.sort(key=lambda x: x[0])
-    previous_y = None
-
-    for y, text, font_size in elements:
-        is_header = font_size >= 14
-        if previous_y is not None and abs(y - previous_y) > 10:
-            markdown_output += "\n"
-        fixed = fix_common_ocr_errors(text.strip())
-        formatted = format_text_to_markdown(fixed)
-        translated = translate_text(formatted)
-        markdown_output += f"\n### {translated}\n" if is_header else translated + "\n"
-        previous_y = y
-
-    markdown_output += "\n---\n\n"
-    return markdown_output.strip()
-
-# ---------- Función principal ----------
 
-def convert(pdf_file):
-    temp_pdf_path = pdf_file.name
-    doc = fitz.open(temp_pdf_path)
-    markdown_output = ""
-    image_paths = []
-    seen_xrefs = set()
+        # Texto normal
+        markdown.append(line)
 
-    for page_num in range(len(doc)):
-        page = doc[page_num]
-        text = page.get_text("text").strip()
+    return "\n\n".join(markdown)
 
-        if len(text) > 30:
-            extracted = extract_text_markdown([page], image_paths, page_num, seen_xrefs)
-            markdown_output += extracted + "\n"
-        else:
-            markdown_output += f"\n## Página {page_num + 1}\n\n"
-            pix = page.get_pixmap(dpi=300)
-            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
-            image_path = f"/tmp/ocr_page_{page_num + 1}.jpg"
-            img.save(image_path)
-            image_paths.append(image_path)
-            markdown_output += f"![imagen_pagina_{page_num + 1}]({image_path})\n"
+# Función principal: OCR → Limpieza → Markdown
+def ocr_to_markdown(image_path):
+    image = Image.open(image_path)
+    raw_text = pytesseract.image_to_string(image, lang='spa', config=OCR_CONFIG)
+    return format_text_to_markdown(raw_text)
 
-            try:
-                ocr_text = pytesseract.image_to_string(img, lang="spa", config="--oem 3 --psm 6")
-            except pytesseract.TesseractError:
-                ocr_text = ""
-            ocr_text_clean = clean_ocr_text(fix_common_ocr_errors(ocr_text))
-            formatted = format_text_to_markdown(ocr_text_clean)
-            translated = translate_text(formatted)
-            markdown_output += translated + "\n"
+# Ejecutar y exportar resultado como archivo .md
+if __name__ == "__main__":
+    image_path = "tu_imagen.png"  # <-- Cambia este nombre al de tu archivo
+    markdown_output = ocr_to_markdown(image_path)
 
-            crops = extract_visual_regions(img)
-            for i, crop in enumerate(crops):
-                crop_path = f"/tmp/recorte_p{page_num + 1}_{i + 1}.jpg"
-                crop.save(crop_path)
-                image_paths.append(crop_path)
-                markdown_output += f"\n\n![imagen_detectada]({crop_path})\n"
-
-            markdown_output += "\n---\n\n"
-
-    markdown_path = "/tmp/resultado.md"
-    with open(markdown_path, "w", encoding="utf-8") as f:
+    with open("resultado.md", "w", encoding="utf-8") as f:
+        f.write("## Página 1\n\n")
+        f.write(f"![imagen_pagina_1]({image_path})\n\n")
         f.write(markdown_output)
-
-    return markdown_output.strip(), image_paths, markdown_path
-
-# ---------- Gradio Interface ----------
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        pdf_input = gr.File(label="Upload your PDF", type="filepath", file_types=[".pdf"])
-        submit_btn = gr.Button("Process PDF")
-
-    markdown_output = gr.Textbox(label="Generated Markdown", lines=25, interactive=True)
-    gallery_output = gr.Gallery(label="Extracted and Detected Images", type="file")
-    download_md = gr.File(label="Download Markdown File")
-
-    submit_btn.click(fn=convert, inputs=[pdf_input], outputs=[markdown_output, gallery_output, download_md])
-
-demo.launch()