Update app.py

app.py

@@ -70,98 +70,94 @@ def analizar_manipulacion(imagen, metadatos):
     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
-    else:
-        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.")
+    # ❌ 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:
+        return "Baja (0.5% - 2%) - Posible compresión o ruido, pero no manipulación evidente."
+    elif porcentaje_ela < 5.0:
+        return "Moderada (2% - 5%) - Posible edición o retoque localizado."
+    elif porcentaje_ela < 15.0:
+        return "Alta (5% - 15%) - Alta probabilidad de manipulación o zonas borradas."
+    else:
+        return "Muy alta (> 15%) - Manipulación extensa o generación por IA detectada."
 
 def realizar_ela(imagen):
-    """Realiza ELA con los parámetros y algoritmo exactos del código JavaScript, valores por defecto."""
+    """Realiza ELA optimizado para detectar manipulaciones incluso en imágenes generadas por IA."""
     try:
-        # Convertir imagen a array numpy y a BGR para OpenCV
         img_np = np.array(imagen.convert("RGB"))
         img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
 
-        # ✅ Parámetros por defecto del código JS
-        quality = 95          # Calidad JPG (0-100)
-        noise_level = 5       # Amplitud del ruido (1-30)
-        error_scale = 15 # Escala de error (0-100 → 0.0-1.0)
-        brightness_pct = 100  # Brillo (0-150%)
-        equalize_histogram = False  # Por defecto desactivado
+        # ✅ Parámetros ajustados para mayor sensibilidad (especialmente en IA)
+        quality = 90          # Bajamos calidad para resaltar más diferencias
+        noise_level = 8       # Aumentamos sensibilidad al ruido
+        error_scale = 25      # Más sensible a errores
+        brightness_pct = 100
+        equalize_histogram = False
 
-        # Guardar como JPG con calidad especificada
         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")
 
-        # Calcular diferencia absoluta
         diferencia = cv2.absdiff(img_cv.astype(np.float32), img_comprimida.astype(np.float32))
-
-        # Aplicar "noiseLevel" y "errorScale" como en el código JS
-        # En JS: diff = Math.max(diffR, diffG, diffB) * errorScale * 20;
-        # Y cada canal se multiplica por (noiseLevel / 10)
-        scaled_diff = diferencia * (noise_level / 10.0) * error_scale * 20.0
-
-        # Limitar valores a 0-255 y convertir a uint8
+        scaled_diff = diferencia * (noise_level / 10.0) * (error_scale / 100.0) * 20.0
         scaled_diff = np.clip(scaled_diff, 0, 255).astype(np.uint8)
 
-        # Crear máscara: áreas con error significativo (simulando elaData.data[i + 3] > 0)
+        # ✅ Reducimos umbral para captar sutilezas de IA
         gray_diff = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
-        _, mask = cv2.threshold(gray_diff, 30, 255, cv2.THRESH_BINARY)  # Umbral arbitrario para "diff > 0.3"
+        _, mask = cv2.threshold(gray_diff, 20, 255, cv2.THRESH_BINARY)  # ← ¡MÁS SENSIBLE!
         mask = mask.astype(np.uint8)
 
-        # ✅ Aplicar ecualización de histograma si estuviera activada (aunque por defecto es False)
         if equalize_histogram:
-            # Convertir a escala de grises, ecualizar, y volver a BGR
             gray = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
             gray_eq = cv2.equalizeHist(gray)
             scaled_diff = cv2.cvtColor(gray_eq, cv2.COLOR_GRAY2BGR)
 
-        # ✅ Aplicar brillo (brightness)
         brightness_factor = min(1.1, brightness_pct / 100.0)
         scaled_diff = cv2.convertScaleAbs(scaled_diff, alpha=brightness_factor, beta=0)
 
-        # ✅ Crear imagen final: fondo negro, áreas detectadas en blanco/amarillo
-        # Convertimos la diferencia escalada a una imagen en color
         ela_color = scaled_diff.copy()
-
-        # Fondo: imagen original en escala de grises oscurecida
         img_gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
         img_gray = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
-        img_gray = cv2.convertScaleAbs(img_gray, alpha=0.5, beta=0)  # Fondo oscuro
+        img_gray = cv2.convertScaleAbs(img_gray, alpha=0.5, beta=0)
 
-        # Combinar: donde hay máscara, mostrar color; donde no, fondo gris
         result = np.where(mask[..., None] > 0, ela_color, img_gray)
 
         os.remove(temp_path)
-        return result
+        return result, mask  # ← ¡Ahora devuelve también la máscara para cálculo!
 
     except Exception as e:
         logger.error(f"Error en ELA: {str(e)}")
         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
-
-
-
-
-
+        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, ""
+
     try:
         img = Image.open(archivo_imagen)
         logger.info(f"Imagen cargada: {archivo_imagen}")
@@ -175,9 +171,17 @@ def procesar_imagen(archivo_imagen):
         zip_path = os.path.join(evidence_dir, f"{nombre}_errorELA.zip")
 
         img.save(original_path)
-        ela_result = realizar_ela(img)
+        ela_result, mask = realizar_ela(img)  # ← Recibimos máscara
+
+        if mask is None:
+            raise Exception("No se pudo generar la máscara 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:
@@ -226,6 +230,11 @@ def procesar_imagen(archivo_imagen):
 
         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"
+
         if manipulada:
             info_manipulacion += "⚠️ **LA IMAGEN HA SIDO MANIPULADA.**\r\nRazones:\r\n"
             for r in razones:
@@ -245,7 +254,6 @@ def procesar_imagen(archivo_imagen):
 
         logger.info(f"Análisis completado. Archivo ZIP: {zip_path}")
 
-        # Convertir imagen ELA a RGB para Gradio
         ela_rgb = cv2.cvtColor(ela_result, cv2.COLOR_BGR2RGB)
 
         return zip_path, analysis_text, ela_rgb, google_maps_url or ""
@@ -265,7 +273,6 @@ 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.
     """)
-    # ✅ Línea de crédito correctamente indentada y con URL limpia
     gr.Markdown("Desarrollado por José R. Leonett para el Grupo de Peritos Forenses Digitales de Guatemala - [www.forensedigital.gt](https://www.forensedigital.gt)")
 
     with gr.Row():
@@ -282,7 +289,7 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
         with gr.Column():
             with gr.Accordion("Resultado del Análisis ELA", open=True):
                 ela_image = gr.Image(
-                    label="🔍 Blanco = áreas borradas o manipuladas",
+                    label="🔍 Blanco/Amarillo = áreas manipuladas o generadas por IA",
                     type="numpy",
                     height=400,
                     show_label=True
@@ -293,7 +300,6 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
                 google_maps_btn = gr.Button("📍 Ver ubicación en Google Maps", visible=False)
                 google_maps_url_state = gr.State("")
 
-    # Función para resetear todo al cargar nueva imagen
     def reset_on_upload():
         return (
             gr.update(value=None),
@@ -303,7 +309,6 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
             ""
         )
 
-    # Evento de análisis
     process_btn.click(
         fn=procesar_imagen,
         inputs=input_image,
@@ -319,7 +324,6 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
         outputs=download_zip
     )
 
-    # Evento para abrir Google Maps
     google_maps_btn.click(
         fn=lambda url: url,
         inputs=google_maps_url_state,
@@ -327,7 +331,6 @@ with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme) as d
         js="(url) => { window.open(url, '_blank'); }"
     )
 
-    # Resetear al subir nueva imagen
     input_image.upload(
         fn=reset_on_upload,
         inputs=None,