Update app.py

app.py

@@ -13,18 +13,16 @@ from PIL import ExifTags
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Directorio de evidencia (seguro en Hugging Face Spaces)
+# Directorio de evidencia
 evidence_dir = "/home/user/app"
 os.makedirs(evidence_dir, exist_ok=True)
 logger.info(f"Directorio de evidencia creado en: {evidence_dir}")
 
 def obtener_metadatos(imagen):
-    """Obtiene los metadatos EXIF de la imagen."""
     try:
         exif_data = imagen.getexif()
         if not exif_data:
             return {}
-        
         metadata = {}
         for tag_id, value in exif_data.items():
             try:
@@ -38,52 +36,40 @@ def obtener_metadatos(imagen):
         return {}
 
 def obtener_coordenadas(exif_data):
-    """Extrae coordenadas GPS de los metadatos EXIF."""
     if not exif_data or "GPSInfo" not in exif_data:
         return None
-    
     try:
         gps_info = exif_data["GPSInfo"]
         if not gps_info:
             return None
-        
         def gps_to_degrees(coord):
             d, m, s = coord
             return d + (m / 60.0) + (s / 3600.0)
-        
         lat = gps_info.get(2)
         lon = gps_info.get(4)
         lat_ref = gps_info.get(1)
         lon_ref = gps_info.get(3)
-        
         if lat and lon and lat_ref and lon_ref:
             lat_deg = gps_to_degrees(lat)
             lon_deg = gps_to_degrees(lon)
-            
             if lat_ref == "S":
                 lat_deg = -lat_deg
             if lon_ref == "W":
                 lon_deg = -lon_deg
-                
             return lat_deg, lon_deg
     except Exception as e:
         logger.error(f"Error al procesar coordenadas GPS: {str(e)}")
-    
     return None
 
 def calcular_hash(imagen):
-    """Calcula el hash SHA3-256 de la imagen."""
     return hashlib.sha3_256(imagen.tobytes()).hexdigest()
 
 def analizar_manipulacion(imagen, metadatos):
-    """Analiza si la imagen ha sido manipulada."""
     manipulada = False
     razones = []
-    
     if imagen.mode == "P":
         razones.append("La imagen tiene marcas de agua o es una imagen indexada.")
         manipulada = True
-    
     if not metadatos:
         razones.append("La imagen no tiene metadatos EXIF.")
         manipulada = True
@@ -91,62 +77,70 @@ def analizar_manipulacion(imagen, metadatos):
         if "Software" in metadatos:
             razones.append(f"La imagen fue editada con: {metadatos['Software']}")
             manipulada = True
-    
     hash_conocido = "d8e3d0e0d7a5e2b2c9d5f9d1c8e7a6f5b0d4e7c3f9d1a2b3c4d5e6f7a8b9c0d1"
     hash_actual = calcular_hash(imagen)
     if hash_actual != hash_conocido:
         razones.append("El hash de la imagen no coincide con el hash conocido.")
         manipulada = True
-    
     return manipulada, razones
 
-def realizar_ela(imagen, quality=95, scale=100):
-    """Realiza el Error Level Analysis (ELA) en la imagen."""
+def realizar_ela(imagen, quality=95, scale=15):
+    """Realiza ELA y devuelve imagen en color sobre fondo oscuro para resaltar errores."""
     try:
-        img_np = np.array(imagen)
+        img_np = np.array(imagen.convert("RGB"))
         img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
-        
+
         temp_path = "/tmp/temp_image.jpg"
         cv2.imwrite(temp_path, img_cv, [cv2.IMWRITE_JPEG_QUALITY, quality])
-        
+
         img_comprimida = cv2.imread(temp_path)
         if img_comprimida is None:
             raise ValueError("Error al leer la imagen comprimida")
-        
+
         diferencia = cv2.absdiff(img_cv, img_comprimida)
         ela_imagen = scale * diferencia
-        ela_imagen_gray = cv2.cvtColor(ela_imagen, cv2.COLOR_BGR2GRAY)
-        
+
+        # Aplicar mapa de color JET (rojo/amarillo = alto error)
+        ela_color = cv2.applyColorMap(ela_imagen, cv2.COLORMAP_JET)
+
+        # Crear fondo oscuro (gris-negro) para mejorar contraste
+        background = np.zeros_like(ela_color) + 20  # Gris muy oscuro
+        mask = ela_imagen > 5  # Solo resaltar donde hay error significativo
+        mask = np.any(mask, axis=2, keepdims=True)
+        result = np.where(mask, ela_color, background)
+
         os.remove(temp_path)
-        
-        return ela_imagen_gray
+        return result
+
     except Exception as e:
         logger.error(f"Error en ELA: {str(e)}")
-        return np.zeros((100, 100), dtype=np.uint8)
+        # Devolver imagen de error con fondo oscuro y texto blanco
+        error_img = np.zeros((300, 600, 3), dtype=np.uint8) + 30
+        cv2.putText(error_img, "Error al procesar ELA", (50, 150), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)
+        return error_img
 
 def procesar_imagen(archivo_imagen):
-    """Procesa la imagen completa y genera resultados."""
+    """Procesa la imagen y devuelve ZIP + texto de análisis + imagen ELA."""
     try:
         img = Image.open(archivo_imagen)
         logger.info(f"Imagen cargada: {archivo_imagen}")
-        
+
         nombre = os.path.splitext(os.path.basename(archivo_imagen))[0]
-        
+
         original_path = os.path.join(evidence_dir, f"{nombre}_original.jpg")
         ela_path = os.path.join(evidence_dir, f"{nombre}_ela.jpg")
         text_path = os.path.join(evidence_dir, f"{nombre}_analisis.txt")
         zip_path = os.path.join(evidence_dir, f"{nombre}_errorELA.zip")
-        
+
         img.save(original_path)
-        ela_imagen = realizar_ela(img)
-        ela_color = cv2.applyColorMap(ela_imagen, cv2.COLORMAP_JET)
-        cv2.imwrite(ela_path, ela_color)
-        
+        ela_result = realizar_ela(img)
+        cv2.imwrite(ela_path, ela_result)
+
         info_basica = f"Formato: {img.format}\nTamaño: {img.size} píxeles\nModo: {img.mode}\n"
-        
+
         metadatos = obtener_metadatos(img)
         info_metadatos = "ANÁLISIS FORENSE DE LOS METADATOS:\n"
-        
+
         if metadatos:
             for tag, value in metadatos.items():
                 if tag == "DateTime":
@@ -170,10 +164,10 @@ def procesar_imagen(archivo_imagen):
                     info_metadatos += f"{tag}: {value}\n"
         else:
             info_metadatos += "No se encontraron metadatos EXIF\n"
-        
+
         sha3_hash = calcular_hash(img)
         info_metadatos += f"\nSHA3-256: {sha3_hash}\n"
-        
+
         manipulada, razones = analizar_manipulacion(img, metadatos)
         info_manipulacion = "\nANÁLISIS DE MANIPULACIÓN:\n"
         if manipulada:
@@ -182,33 +176,32 @@ def procesar_imagen(archivo_imagen):
                 info_manipulacion += f"- {r}\n"
         else:
             info_manipulacion += "LA IMAGEN NO HA SIDO MANIPULADA.\n"
-        
+
         analysis_text = f"{info_basica}\n{info_metadatos}\n{info_manipulacion}"
-        
+
         with open(text_path, "w") as f:
             f.write(analysis_text)
-        
+
         with zipfile.ZipFile(zip_path, "w") as zipf:
             zipf.write(original_path, os.path.basename(original_path))
             zipf.write(ela_path, os.path.basename(ela_path))
             zipf.write(text_path, os.path.basename(text_path))
-        
+
         logger.info(f"Análisis completado. Archivo ZIP: {zip_path}")
-        
-        # Devolver solo 2 valores (coincide con los 2 outputs definidos)
-        return zip_path, analysis_text
+
+        # Convertir imagen ELA de BGR a RGB para mostrar en Gradio
+        ela_rgb = cv2.cvtColor(ela_result, cv2.COLOR_BGR2RGB)
+
+        return zip_path, analysis_text, ela_rgb
 
     except Exception as e:
         logger.error(f"Error en procesamiento: {str(e)}")
-        return f"Error: {str(e)}", f"Error al procesar la imagen: {str(e)}"
+        error_img = np.zeros((300, 600, 3), dtype=np.uint8)
+        cv2.putText(error_img, f"ERROR: {str(e)[:50]}", (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
+        return f"Error: {str(e)}", f"Error al procesar la imagen: {str(e)}", error_img
 
-# 🎨 Tema moderno y compatible (¡sin errores!)
-# Soft ya incluye modo oscuro automático y es visualmente agradable
-theme = gr.themes.Soft(
-    primary_hue="blue",
-    secondary_hue="slate",
-    neutral_hue="stone",
-)
+# 🎨 Tema moderno y compatible
+theme = gr.themes.Soft(primary_hue="blue", secondary_hue="slate", neutral_hue="stone")
 
 # 🖥️ Interfaz Gradio
 with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as demo:
@@ -216,36 +209,48 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
     # 📸 Análisis Forense de Imágenes con Error Level Analysis (ELA)
     Programa de computación forense para analizar imágenes en busca de evidencia de manipulación o edición.
     """)
-    
+
     with gr.Row():
         with gr.Column():
-            input_image = gr.Image(label="Subir imagen (JPG/PNG)", type="filepath", height=400)
+            # 👇 SIN WEBCAM — Solo carga de archivo
+            input_image = gr.Image(
+                label="Subir imagen (JPG/PNG)",
+                type="filepath",
+                height=400,
+                sources=["upload"]  # ← ¡Esto elimina la webcam!
+            )
             process_btn = gr.Button("Analizar imagen", variant="primary")
-        
+
+            # 👇 ZIP aparece SOLO después del análisis
+            download_zip = gr.File(label="⬇️ Descargar resultados (ZIP)", interactive=False, visible=False)
+
         with gr.Column():
-            with gr.Accordion("Descargar resultados ZIP", open=True):
-                download_zip = gr.File(label="Descargar archivo ZIP", interactive=False)
-                metadata_text = gr.Textbox(label="Metadatos y SHA3-256", lines=10, max_lines=20)
-            
-            with gr.Accordion("Análisis detallado", open=True):
-                ela_image = gr.Image(label="Imagen con Error Level Analysis (ELA)", type="numpy", elem_id="ela_image")
-                analysis_text = gr.Textbox(label="Análisis detallado", lines=15, max_lines=25)
-    
-    # ⚙️ Conexión de eventos
+            with gr.Accordion("Resultado del Análisis ELA", open=True):
+                # 👇 Aquí SÍ se muestra la imagen ELA procesada
+                ela_image = gr.Image(
+                    label="🔍 Áreas resaltadas = posibles manipulaciones",
+                    type="numpy",
+                    height=400,
+                    show_label=True
+                )
+
+            with gr.Accordion("Informe Detallado", open=True):
+                analysis_text = gr.Textbox(label="📝 Resultados del análisis forense", lines=15, max_lines=25)
+
+    # ⚙️ Evento de análisis — ahora devuelve 3 valores
     process_btn.click(
         fn=procesar_imagen,
         inputs=input_image,
-        outputs=[download_zip, analysis_text],  # 👈 Solo 2 outputs (ZIP y texto)
+        outputs=[download_zip, analysis_text, ela_image],
         api_name="analyze_image"
-    )
-    
-    input_image.change(
-        fn=lambda x: f"Análisis en progreso para: {os.path.basename(x)}" if x else "",
-        inputs=input_image,
-        outputs=analysis_text
+    ).then(
+        # 👇 Hacer visible el ZIP después del análisis
+        fn=lambda: gr.update(visible=True),
+        inputs=None,
+        outputs=download_zip
     )
 
-    # 👇👇👇 AÑADIDO: Línea de crédito solicitada
+    # 👇 Línea de crédito solicitada
     gr.Markdown("Desarrollado por José R. Leonett para el Grupo de Peritos Forenses Digitales de Guatemala - [www.forensedigital.gt](https://www.forensedigital.gt)")
 
 # ▶️ Ejecución