Update app.py

app.py

@@ -21,7 +21,7 @@ logger.info(f"Directorio de evidencia creado en: {evidence_dir}")
 def obtener_metadatos(imagen):
     try:
         exif_data = imagen.getexif()
-        if not exif_data:
+        if not exif_
             return {}
         metadata = {}
         for tag_id, value in exif_data.items():
@@ -36,7 +36,7 @@ def obtener_metadatos(imagen):
         return {}
 
 def obtener_coordenadas(exif_data):
-    if not exif_data or "GPSInfo" not in exif_data:
+    if not exif_data or "GPSInfo" not in exif_
         return None
     try:
         gps_info = exif_data["GPSInfo"]
@@ -70,25 +70,20 @@ def analizar_manipulacion(imagen, metadatos):
     if imagen.mode == "P":
         razones.append("La imagen tiene marcas de agua o es una imagen indexada.")
         manipulada = True
-    # ❌ Eliminado: ya no se añade por defecto "no tiene metadatos" ni "hash no coincide"
     if "Software" in metadatos:
         razones.append(f"La imagen fue editada con: {metadatos['Software']}")
         manipulada = True
     return manipulada, razones
 
 def calcular_porcentaje_ela(ela_imagen, mask):
-    """Calcula porcentaje de píxeles blancos/amarillos (altos valores) en la imagen ELA."""
     if mask is None or mask.size == 0:
         return 0.0
-
     total_pixeles = mask.size
     pixeles_detectados = np.count_nonzero(mask)
     porcentaje = (pixeles_detectados / total_pixeles) * 100
-
     return porcentaje
 
 def estimar_probabilidad_manipulacion(porcentaje_ela):
-    """Estima probabilidad de manipulación basado en porcentaje de áreas detectadas."""
     if porcentaje_ela < 0.5:
         return "Muy baja (< 0.5%) - Imagen probablemente auténtica."
     elif porcentaje_ela < 2.0:
@@ -101,15 +96,13 @@ def estimar_probabilidad_manipulacion(porcentaje_ela):
         return "Muy alta (> 15%) - Manipulación extensa o generación por IA detectada."
 
 def realizar_ela(imagen):
-    """Realiza ELA optimizado para detectar manipulaciones incluso en imágenes generadas por IA."""
     try:
         img_np = np.array(imagen.convert("RGB"))
         img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
 
-        # ✅ Parámetros ajustados para mayor sensibilidad (especialmente en IA)
-        quality = 99          # Bajamos calidad para resaltar más diferencias
-        noise_level = 3       # Aumentamos sensibilidad al ruido
-        error_scale = 15      # Más sensible a errores
+        quality = 90
+        noise_level = 8
+        error_scale = 25
         brightness_pct = 100
         equalize_histogram = False
 
@@ -117,15 +110,14 @@ def realizar_ela(imagen):
         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")
+            raise ValueError("No se pudo leer la imagen comprimida.")
 
         diferencia = cv2.absdiff(img_cv.astype(np.float32), img_comprimida.astype(np.float32))
         scaled_diff = diferencia * (noise_level / 10.0) * (error_scale / 100.0) * 20.0
         scaled_diff = np.clip(scaled_diff, 0, 255).astype(np.uint8)
 
-        # ✅ Reducimos umbral para captar sutilezas de IA
         gray_diff = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
-        _, mask = cv2.threshold(gray_diff, 20, 255, cv2.THRESH_BINARY)  # ← ¡MÁS SENSIBLE!
+        _, mask = cv2.threshold(gray_diff, 20, 255, cv2.THRESH_BINARY)
         mask = mask.astype(np.uint8)
 
         if equalize_histogram:
@@ -133,7 +125,7 @@ def realizar_ela(imagen):
             gray_eq = cv2.equalizeHist(gray)
             scaled_diff = cv2.cvtColor(gray_eq, cv2.COLOR_GRAY2BGR)
 
-        brightness_factor = min(1.0, brightness_pct / 100.0)
+        brightness_factor = min(1.1, brightness_pct / 100.0)
         scaled_diff = cv2.convertScaleAbs(scaled_diff, alpha=brightness_factor, beta=0)
 
         ela_color = scaled_diff.copy()
@@ -144,7 +136,7 @@ def realizar_ela(imagen):
         result = np.where(mask[..., None] > 0, ela_color, img_gray)
 
         os.remove(temp_path)
-        return result, mask  # ← ¡Ahora devuelve también la máscara para cálculo!
+        return result, mask
 
     except Exception as e:
         logger.error(f"Error en ELA: {str(e)}")
@@ -153,10 +145,12 @@ def realizar_ela(imagen):
         return error_img, None
 
 def procesar_imagen(archivo_imagen):
-    """Procesa la imagen y devuelve ZIP + texto de análisis + imagen ELA + URL de Google Maps (si aplica)."""
-    # ✅ Validación: si no hay imagen, devolver mensaje
-    if not archivo_imagen or not os.path.exists(archivo_imagen):
-        return None, "❌ Por favor, cargue una imagen válida antes de analizar.", None, ""
+    # ✅ VALIDACIÓN URGENTE: Si no hay imagen, detener y avisar
+    if not archivo_imagen:
+        return None, "❌ **ERROR: Por favor, cargue una imagen antes de analizar.**", None, ""
+
+    if not os.path.exists(archivo_imagen):
+        return None, "❌ **ERROR: El archivo de imagen no existe o es inválido.**", None, ""
 
     try:
         img = Image.open(archivo_imagen)
@@ -171,25 +165,23 @@ def procesar_imagen(archivo_imagen):
         zip_path = os.path.join(evidence_dir, f"{nombre}_errorELA.zip")
 
         img.save(original_path)
-        ela_result, mask = realizar_ela(img)  # ← Recibimos máscara
+        ela_result, mask = realizar_ela(img)
 
         if mask is None:
-            raise Exception("No se pudo generar la máscara ELA.")
+            raise Exception("No se pudo generar el análisis ELA.")
 
         cv2.imwrite(ela_path, ela_result)
 
-        # Calcular porcentaje de áreas detectadas
         porcentaje_ela = calcular_porcentaje_ela(ela_result, mask)
         probabilidad = estimar_probabilidad_manipulacion(porcentaje_ela)
 
-        # ✅ Obtener tamaño del archivo
         file_size_bytes = os.path.getsize(archivo_imagen)
         if file_size_bytes < 1024 * 1024:
             file_size = f"{file_size_bytes / 1024:.2f} KB"
         else:
             file_size = f"{file_size_bytes / (1024 * 1024):.2f} MB"
 
-        # Información básica
+        # ✅ TODOS LOS CAMPOS EN NEGRITA como solicitaste
         info_basica = f"**Nombre del archivo:** {nombre_original}\r\n"
         info_basica += f"**Tamaño del archivo:** {file_size}\r\n"
         info_basica += f"**Dimensiones:** {img.size[0]} x {img.size[1]} píxeles\r\n"
@@ -226,12 +218,10 @@ def procesar_imagen(archivo_imagen):
             info_metadatos += "- No se encontraron metadatos EXIF\r\n"
 
         sha3_hash = calcular_hash(img)
-        info_metadatos += f"\r\n- SHA3-256: {sha3_hash}\r\n\r\n"
+        info_metadatos += f"\r\n**SHA3-256:** {sha3_hash}\r\n\r\n"
 
         manipulada, razones = analizar_manipulacion(img, metadatos)
         info_manipulacion = "**ANÁLISIS DE MANIPULACIÓN:**\r\n\r\n"
-
-        # ✅ Añadir porcentaje y estimación
         info_manipulacion += f"- **Porcentaje de áreas detectadas (blanco/amarillo en ELA):** {porcentaje_ela:.3f}%\r\n"
         info_manipulacion += f"- **Estimación forense:** {probabilidad}\r\n\r\n"
 
@@ -260,9 +250,10 @@ def procesar_imagen(archivo_imagen):
 
     except Exception as e:
         logger.error(f"Error en procesamiento: {str(e)}")
+        mensaje_error = f"❌ **ERROR CRÍTICO:** {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, ""
+        cv2.putText(error_img, "ERROR INTERNO", (80, 160), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        return None, mensaje_error, error_img, ""
 
 # 🎨 Tema moderno
 theme = gr.themes.Soft(primary_hue="blue", secondary_hue="slate", neutral_hue="stone")
@@ -284,7 +275,14 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
                 sources=["upload"]
             )
             process_btn = gr.Button("Analizar imagen", variant="primary")
-            download_zip = gr.File(label="⬇️ Descargar resultados (ZIP)", interactive=False, visible=False)
+
+            # ✅ BOTÓN DE DESCARGA NARANJA MODERNO
+            download_zip = gr.DownloadButton(
+                label="⬇️ Descargar resultados (ZIP)",
+                variant="primary",
+                visible=False,
+                interactive=True
+            )
 
         with gr.Column():
             with gr.Accordion("Resultado del Análisis ELA", open=True):
@@ -309,6 +307,7 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
             ""
         )
 
+    # ✅ Conexión del evento de análisis — ahora con manejo de errores visible
     process_btn.click(
         fn=procesar_imagen,
         inputs=input_image,
@@ -344,5 +343,5 @@ if __name__ == "__main__":
         server_port=7860,
         share=True,
         inbrowser=True,
-        favicon_path="https://huggingface.co/datasets/huggingface/logo/resolve/main/hf-logo.png"
+        favicon_path="https://www.forensedigital.gt/wp-content/uploads/2019/07/cropped-40fb84a6-c75a-4c38-bfa0-c0a9777430cd-1.jpg"
     )