MVP

app.py

@@ -4,6 +4,7 @@ import tempfile
 from pdf2image import convert_from_path
 import logging
 from commercial_invoice import process_invoice_batch, logger
+from hawb_processing import process_hawb_batch
 
 # Configurar handler para capturar logs
 class GradioHandler(logging.Handler):
@@ -15,7 +16,7 @@ class GradioHandler(logging.Handler):
         log_entry = self.format(record)
         self.log_history.append(log_entry)
 
-def procesar_pdf(pdf_path, progress=gr.Progress()):
+def procesar_pdf_invoice(pdf_path, progress=gr.Progress()):
     """Procesa un archivo PDF y extrae información de las facturas"""
     log_history = []
     handler = GradioHandler(log_history)
@@ -104,6 +105,84 @@ def procesar_pdf(pdf_path, progress=gr.Progress()):
     finally:
         logger.removeHandler(handler)
 
+def procesar_guia_aerea(pdf_path, progress=gr.Progress()):
+    """Procesa un archivo PDF de guía aérea y extrae las imágenes"""
+    log_history = []
+    handler = GradioHandler(log_history)
+    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    
+    try:
+        # Validar que el nombre del archivo comience con "hawb145"
+        filename = os.path.basename(pdf_path).lower()
+        if not filename.startswith("hawb145"):
+            error_msg = """
+            <div style='color: red; font-weight: bold; padding: 10px; border: 1px solid red; border-radius: 5px; background-color: #ffe6e6;'>
+                ⚠️ El archivo debe comenzar con "hawb145" para ser procesado como guía aérea.
+            </div>
+            """
+            logger.error("Archivo incompatible: " + filename)
+            return error_msg, None, "\n".join(log_history)
+
+        progress(0.1, desc="Iniciando procesamiento...")
+        
+        # Usar directorio temporal para las imágenes
+        with tempfile.TemporaryDirectory() as temp_dir:
+            logger.info(f"Convirtiendo PDF a imágenes: {pdf_path}")
+            progress(0.2, desc="Convirtiendo PDF a imágenes...")
+            
+            # Convertir PDF a imágenes
+            images = convert_from_path(pdf_path)
+            image_paths = []
+            
+            # Guardar imágenes en el directorio temporal
+            for i, image in enumerate(images):
+                progress((0.3 + (i/len(images) * 0.6)), desc=f"Procesando página {i+1} de {len(images)}...")
+                image_path = os.path.join(temp_dir, f'hawb_pagina_{i+1}.jpg')
+                image.save(image_path, 'JPEG')
+                image_paths.append(image_path)
+            
+            logger.info(f"Se generaron {len(image_paths)} imágenes en directorio temporal")
+            
+            progress(0.5, desc="¡Proceso completado!")
+
+            # Procesar las imágenes
+            coordinates_json = "./coordinates_HAWB.json"    
+            results_df = process_hawb_batch(image_paths, coordinates_json)
+
+            output_dir = "data"
+            os.makedirs(output_dir, exist_ok=True)
+            csv_path = os.path.join(output_dir, 'hawb_procesados.csv')
+            results_df.to_csv(csv_path, index=False)
+            logger.info(f"Resultados guardados en: {csv_path}")
+                     
+            progress(0.9, desc="Finalizando...")
+            
+            # Preparar mensaje de resultados con estilo
+            mensaje = f"""
+            <div style='padding: 10px; border: 1px solid #4CAF50; border-radius: 5px; background-color: #f1f8e9;'>
+                <h3 style='color: #2E7D32; margin-top: 0;'>✅ Procesamiento completado</h3>
+                <ul style='list-style-type: none; padding-left: 0;'>
+                    <li>📄 Páginas procesadas: {len(image_paths)}</li>
+                    <li>📁 Imágenes procesadas en memoria temporal</li>
+                </ul>
+            </div>
+            """
+            
+            return mensaje, csv_path, "\n".join(log_history)
+            
+    except Exception as e:
+        error_msg = f"""
+        <div style='color: red; font-weight: bold; padding: 10px; border: 1px solid red; border-radius: 5px; background-color: #ffe6e6;'>
+            ⚠️ Error durante el procesamiento: {str(e)}
+        </div>
+        """
+        logger.error(error_msg)
+        return error_msg, None, "\n".join(log_history)
+    finally:
+        logger.removeHandler(handler)
+
 def crear_interfaz():
     with gr.Blocks(css="""
         .message { margin-bottom: 20px; }
@@ -116,50 +195,96 @@ def crear_interfaz():
             max-height: 200px;
             overflow-y: auto;
         }
+        .tab-selected {
+            border-bottom: 2px solid #2196F3 !important;
+        }
     """) as demo:
-        gr.Markdown("# Extractor de Información de Facturas")
-        
-        with gr.Row():
-            pdf_input = gr.File(
-                label="Cargar PDF (el nombre debe empezar con 'ci145')",
-                file_types=[".pdf"]
-            )
-        
-        with gr.Row():
-            procesar_btn = gr.Button(
-                "Procesar PDF", 
-                variant="primary",
-                elem_classes=["custom-button"]
-            )
-        
-        with gr.Row():
-            output_text = gr.HTML(
-                label="Resultados"
-            )
-        
-        with gr.Row():
-            log_output = gr.Textbox(
-                label="Logs del proceso",
-                elem_classes=["logs"],
-                lines=10,
-                max_lines=10,
-                show_label=True
-            )
+        gr.Markdown("# Extractor de Información de Facturas y Guías Aéreas")
         
-        with gr.Row():
-            files_output = gr.File(
-                label="Descargar archivos CSV",
-                file_count="multiple",
-                interactive=False,
-                visible=False
-            )
+        with gr.Tabs() as tabs:
+            with gr.TabItem("Facturas Comerciales", id=1):
+                with gr.Row():
+                    pdf_input = gr.File(
+                        label="Cargar PDF de facturas (el nombre debe empezar con 'ci145')",
+                        file_types=[".pdf"]
+                    )
+                
+                with gr.Row():
+                    procesar_facturas_btn = gr.Button(
+                        "Procesar PDF de Facturas", 
+                        variant="primary",
+                        elem_classes=["custom-button"]
+                    )
+                
+                with gr.Row():
+                    output_text = gr.HTML(
+                        label="Resultados"
+                    )
+                
+                with gr.Row():
+                    log_output = gr.Textbox(
+                        label="Logs del proceso",
+                        elem_classes=["logs"],
+                        lines=10,
+                        max_lines=10,
+                        show_label=True
+                    )
+                
+                with gr.Row():
+                    files_output = gr.File(
+                        label="Descargar archivos CSV",
+                        file_count="multiple",
+                        interactive=False,
+                        visible=False
+                    )
+            
+            with gr.TabItem("Guías Aéreas", id=2):
+                with gr.Row():
+                    guia_aerea_input = gr.File(
+                        label="Cargar PDF de guía aérea. (El nombre debe empezar con 'hawb145')",
+                        file_types=[".pdf"]
+                    )
+                
+                with gr.Row():
+                    procesar_guia_btn = gr.Button(
+                        "Procesar PDF de Guías Aéreas", 
+                        variant="primary",
+                        elem_classes=["custom-button"]
+                    )
+                
+                with gr.Row():
+                    guia_output_text = gr.HTML(
+                        label="Resultados"
+                    )
+                
+                with gr.Row():
+                    guia_log_output = gr.Textbox(
+                        label="Logs del proceso",
+                        elem_classes=["logs"],
+                        lines=10,
+                        max_lines=10,
+                        show_label=True
+                    )
+                
+                with gr.Row():
+                    guia_files_output = gr.File(
+                        label="Descargar archivos procesados",
+                        file_count="multiple",
+                        interactive=False,
+                        visible=False
+                    )
         
-        def process_and_return(pdf_path):
-            message, csv_files, logs = procesar_pdf(pdf_path)
+        def process_and_return_invoices(pdf_path):
+            message, csv_files, logs = procesar_pdf_invoice(pdf_path)
             return message, csv_files if csv_files else None, logs
         
-        procesar_btn.click(
-            fn=process_and_return,
+        def process_and_return_guia(pdf_path):
+            message, files, logs = procesar_guia_aerea(pdf_path)
+            return message, files if files else None, logs
+        
+        # Eventos de los botones
+        procesar_facturas_btn.click(
+            fn=process_and_return_invoices,
             inputs=[pdf_input],
             outputs=[output_text, files_output, log_output],
             show_progress=True
@@ -168,6 +293,17 @@ def crear_interfaz():
             None,
             [files_output]
         )
+        
+        procesar_guia_btn.click(
+            fn=process_and_return_guia,
+            inputs=[guia_aerea_input],
+            outputs=[guia_output_text, guia_files_output, guia_log_output],
+            show_progress=True
+        ).then(
+            lambda: gr.update(visible=True),
+            None,
+            [guia_files_output]
+        )
     
     return demo
 

coordinates_HAWB.json

@@ -0,0 +1,60 @@
+{
+    "boxes": [
+        {
+            "id": "1",
+            "label": "Shipper_name",
+            "x": "590.00",
+            "y": "155.00",
+            "width": "900.00",
+            "height": "60.00",
+            "confidence": null
+        },
+        {
+            "id": "2",
+            "label": "hawb_number",
+            "x": "1396.00",
+            "y": "163.00",
+            "width": "190.00",
+            "height": "50.00",
+            "confidence": null
+        },
+        {
+            "id": "3",
+            "label": "hawb_date",
+            "x": "2162.00",
+            "y": "231.00",
+            "width": "180.00",
+            "height": "62.00",
+            "confidence": null
+        },
+        {
+            "id": "4",
+            "label": "number_pieces",
+            "x": "196.00",
+            "y": "1592.00",
+            "width": "110.00",
+            "height": "50.00",
+            "confidence": null
+        },
+        {
+            "id": "5",
+            "label": "gross_weight",
+            "x": "500.00",
+            "y": "1592.00",
+            "width": "130.00",
+            "height": "62.00",
+            "confidence": null
+        },
+        {
+            "id": "6",
+            "label": "kg_lb",
+            "x": "716.00",
+            "y": "1592.00",
+            "width": "50.00",
+            "height": "62.00",
+            "confidence": null
+        }
+    ],
+    "height": 3509,
+    "width": 2480
+}

escalar.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import os
+
+def resize_image(page_number=1):
+    # Definir dimensiones objetivo
+    img_width = 2480  # Puedes ajustar estos valores según necesites
+    img_height = 3509
+
+    # Ruta de entrada y salida
+    input_path = os.path.join('hawb', f'hawb_pagina_{page_number}.jpg')
+    output_path = os.path.join('hawb', 'hawb_model.jpg')
+
+    try:
+        # Verificar si existe el archivo
+        if not os.path.exists(input_path):
+            print(f"No se encontró la imagen: {input_path}")
+            return False
+
+        # Abrir la imagen
+        image = Image.open(input_path)
+        
+        # Ajustar imagen si es necesario
+        if image.size != (img_width, img_height):
+            image = image.resize((img_width, img_height))
+        
+        # Guardar la imagen redimensionada
+        image.save(output_path)
+        print(f"Imagen procesada exitosamente. Guardada como: {output_path}")
+        return True
+        
+    except Exception as e:
+        print(f"Error al procesar la imagen: {str(e)}")
+        return False
+
+def main():
+    page_number = 1
+    while True:
+        if resize_image(page_number):
+            respuesta = input("¿Desea continuar con la siguiente iteración? (s/n): ")
+            if respuesta.lower() != 's':
+                print("Proceso finalizado.")
+                break
+            page_number += 1
+        else:
+            print("No hay más imágenes para procesar.")
+            break
+
+if __name__ == "__main__":
+    main()

hawb_processing.py

@@ -0,0 +1,93 @@
+import json
+from PIL import Image
+import pytesseract
+import pandas as pd
+import os
+from pathlib import Path
+import logging
+
+# Configurar logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('hawb_processing.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def load_field_areas(coordinates_json):
+    """Carga y procesa las coordenadas desde el archivo JSON"""
+    with open(coordinates_json, 'r') as f:
+        data = json.load(f)
+    field_areas = {}
+    for box in data['boxes']:
+        x = float(box['x'])
+        y = float(box['y'])
+        width = float(box['width'])
+        height = float(box['height'])
+        field_areas[box['label']] = {
+            "x1": int(x - width/2),
+            "y1": int(y - height/2),
+            "x2": int(x + width/2),
+            "y2": int(y + height/2)
+        }
+    return field_areas, data['width'], data['height']
+
+def extract_text_from_area(image, area, margin=10):
+    """Extrae texto de un área específica de la imagen con margen de tolerancia"""
+    x1 = max(0, area["x1"] - margin)
+    y1 = max(0, area["y1"] - margin)
+    x2 = min(image.width, area["x2"] + margin)
+    y2 = min(image.height, area["y2"] + margin)
+    crop = image.crop((x1, y1, x2, y2))
+    custom_config = r'--oem 3 --psm 6'
+    text = pytesseract.image_to_string(crop, lang='eng', config=custom_config).strip()
+    return text
+
+def process_hawb(image_path, coordinates_json, margin=5):
+    """Procesa una imagen de HAWB y extrae los campos principales"""
+    logger.info(f"Procesando HAWB: {image_path}")
+    image = Image.open(image_path)
+    field_areas, img_width, img_height = load_field_areas(coordinates_json)
+    # Ajustar imagen si es necesario
+    if image.size != (img_width, img_height):
+        image = image.resize((img_width, img_height))
+    # Extraer campos principales
+    campos = ["Shipper_name", "hawb_number", "hawb_date", "number_pieces", "gross_weight", "kg_lb"]
+    extracted = {"filename": os.path.basename(image_path)}
+    for campo in campos:
+        if campo in field_areas:
+            extracted[campo] = extract_text_from_area(image, field_areas[campo], margin)
+        else:
+            extracted[campo] = ""
+    return extracted
+
+def process_hawb_batch(image_paths, coordinates_json):
+    """Procesa un lote de imágenes de HAWB"""
+    logger.info(f"Iniciando procesamiento de {len(image_paths)} HAWB")
+    results = []
+    for image_path in image_paths:
+        try:
+            result = process_hawb(image_path, coordinates_json)
+            results.append(result)
+        except Exception as e:
+            logger.error(f"Error procesando {image_path}: {str(e)}")
+            results.append({'filename': os.path.basename(image_path)})
+    df = pd.DataFrame(results)
+    return df
+    
+
+def main(hawb_dir="./hawb", data_dir="./data", coordinates_json="./coordinates_HAWB.json"):
+    Path(data_dir).mkdir(parents=True, exist_ok=True)
+    image_paths = [
+        os.path.join(hawb_dir, f)
+        for f in os.listdir(hawb_dir)
+        if f.lower().endswith(('.jpg', '.jpeg', '.png'))
+    ]
+    df = process_hawb_batch(image_paths, coordinates_json)
+    return df
+
+if __name__ == "__main__":
+    main()

test1.py

@@ -0,0 +1,25 @@
+import os
+from hawb_processing import process_hawb
+
+def test_single_hawb():
+    hawb_path = os.path.join("hawb", "hawb_pagina_5.jpg")
+    coordinates_json = "coordinates_HAWB.json"
+
+    print("Iniciando prueba con GUIA individual...")
+    print(f"Procesando guía: {hawb_path}")
+
+    try:
+        # Procesar la guía
+        results = process_hawb(hawb_path, coordinates_json, margin=5)
+
+     
+        print("\nVerificando resultados:")
+        # imprimir diccionario de resultados
+        for key, value in results.items():
+            print(f"{key}: {value}")
+        
+    except Exception as e:
+        print(f"Error en la prueba: {str(e)}")
+
+if __name__ == "__main__":
+    test_single_hawb()