Update app.py

app.py

@@ -1,279 +1,451 @@
-import gradio as gr
-from PIL import Image, ExifTags
+tengo este programa emmi canal de huggiefaces gratuito de analisis de ela y estab funcionando bien y ahora dice error de api, podrias revisar que sucede y generarme el codigo completo, verifica haqsta 3 veces que funciones correctamente "import gradio as gr
+from PIL import Image
 import cv2
 import numpy as np
 import os
 import zipfile
 import hashlib
 import logging
+from pathlib import Path
+from PIL import ExifTags
 import plotly.graph_objects as go
-import tempfile
-import time
 
-# Configuración
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+# Configuración de logs
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-EVIDENCE_DIR = "/tmp/evidence_ela"
-os.makedirs(EVIDENCE_DIR, exist_ok=True)
+# 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 get_exif_data(image):
-    """Extrae metadatos EXIF completos"""
+def obtener_metadatos(imagen):
     try:
-        exif_data = image.getexif()
+        exif_data = imagen.getexif()
         if not exif_data:
             return {}
-        
         metadata = {}
         for tag_id, value in exif_data.items():
-            tag_name = ExifTags.TAGS.get(tag_id, tag_id)
-            
-            # Limpieza de datos para visualización
-            if isinstance(value, bytes):
-                try:
-                    value = value.decode('utf-8', errors='ignore')
-                except:
-                    value = str(value)
-            elif isinstance(value, tuple):
-                value = str(value)
-            
-            metadata[tag_name] = value
+            try:
+                tag = ExifTags.TAGS.get(tag_id, tag_id)
+                metadata[tag] = value
+            except Exception as e:
+                logger.debug(f"Error al procesar etiqueta EXIF: {str(e)}")
         return metadata
     except Exception as e:
-        logger.error(f"Error EXIF: {e}")
+        logger.error(f"Error al obtener metadatos: {str(e)}")
         return {}
 
-def get_gps_coords(exif_data):
-    """Convierte coordenadas GPS a decimales"""
-    if "GPSInfo" not in exif_data:
+def obtener_coordenadas(exif_data):
+    if not exif_data or "GPSInfo" not in exif_data:
         return None
-    
-    gps = exif_data["GPSInfo"]
-    
-    def convert_to_degrees(value):
-        d, m, s = value
-        return float(d) + (float(m) / 60.0) + (float(s) / 3600.0)
-
     try:
-        lat = gps.get(2)
-        lon = gps.get(4)
-        lat_ref = gps.get(1)
-        lon_ref = gps.get(3)
-
+        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 = convert_to_degrees(lat)
-            lon_deg = convert_to_degrees(lon)
-            
-            if lat_ref == "S": lat_deg *= -1
-            if lon_ref == "W": lon_deg *= -1
-            
+            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:
-        pass
+    except Exception as e:
+        logger.error(f"Error al procesar coordenadas GPS: {str(e)}")
     return None
 
-def calculate_hash(image):
-    """Hash SHA3-256 del contenido de la imagen"""
-    return hashlib.sha3_256(np.array(image).tobytes()).hexdigest()
+def calcular_hash(imagen):
+    return hashlib.sha3_256(imagen.tobytes()).hexdigest()
+
+def analizar_manipulacion(imagen, metadatos):
+    manipulada = False
+    razones = []
+    if imagen.mode == "P":
+        razones.append("La imagen tiene marcas de agua o es una imagen indexada.")
+        manipulada = True
+    if "Software" in metadatos:
+        razones.append(f"La imagen fue editada con: {metadatos['Software']}")
+        manipulada = True
+    return manipulada, razones
+
+def calcular_porcentaje_ela(mask):
+    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):
+    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 perform_ela_analysis(image):
-    """Realiza Error Level Analysis"""
+def realizar_ela(imagen):
     try:
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-        
-        img_np = np.array(image)
+        img_np = np.array(imagen.convert("RGB"))
         img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
-        
-        # Compresión temporal para ELA
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            temp_path = tmp.name
-        
-        cv2.imwrite(temp_path, img_cv, [cv2.IMWRITE_JPEG_QUALITY, 75])
-        compressed = cv2.imread(temp_path)
-        
-        if compressed is None:
-            raise ValueError("Fallo en compresión JPEG")
-            
-        # Diferencia
-        diff = cv2.absdiff(img_cv.astype(np.float32), compressed.astype(np.float32))
-        scaled = np.clip(diff * 15, 0, 255).astype(np.uint8)
-        
-        # Máscara y Color
-        gray = cv2.cvtColor(scaled, cv2.COLOR_BGR2GRAY)
-        _, mask = cv2.threshold(gray, 5, 255, cv2.THRESH_BINARY)
-        color_map = cv2.applyColorMap(gray, cv2.COLORMAP_TURBO)
-        
-        # Composición final
-        bg_gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
-        bg_gray = cv2.cvtColor(bg_gray, cv2.COLOR_GRAY2BGR)
-        result = np.where(mask[..., None] > 0, color_map, bg_gray)
-        
+
+        # Fuerza la compresión para detectar artefactos
+        quality = 75  
+        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("No se pudo leer la imagen comprimida.")
+
+        # Calcula diferencias
+        diferencia = cv2.absdiff(img_cv.astype(np.float32), img_comprimida.astype(np.float32))
+        scaled_diff = np.clip(diferencia * 15, 0, 255).astype(np.uint8)  # Escalado fuerte
+
+        # Convertir a escala de grises y aplicar umbral más bajo
+        gray_diff = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
+        _, mask = cv2.threshold(gray_diff, 5, 255, cv2.THRESH_BINARY)
+
+        # Resalta con color donde hay diferencias
+        ela_color = cv2.applyColorMap(gray_diff, cv2.COLORMAP_TURBO)
+
+        # Combinar con la original en escala de grises
+        img_gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+        img_gray = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
+        result = np.where(mask[..., None] > 0, ela_color, img_gray)
+
         os.remove(temp_path)
         return result, mask
-        
+
     except Exception as e:
-        logger.error(f"Error ELA: {e}")
-        err_img = np.zeros((300, 600, 3), dtype=np.uint8) + 50
-        cv2.putText(err_img, "ERROR EN PROCESO ELA", (50, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255,255,255), 2)
-        return err_img, None
-
-def generate_plots(percentage):
-    """Genera gráficos estadísticos con Plotly"""
-    # Gráfico de Barra
-    color = '#FF4B4B' if percentage > 5 else '#4CAF50'
-    fig_bar = go.Figure(data=[go.Bar(x=['Nivel ELA'], y=[percentage], marker_color=color)])
-    fig_bar.update_layout(title_text="Porcentaje de Anomalías", height=250, margin=dict(t=30, b=10))
+        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, None
+
+
+
+
+def crear_graficos_estadisticas(porcentaje_ela, dimensiones, metadatos):
+    """Crear gráficos estadísticos para el análisis ELA"""
+    
+    # Gráfico 1: Porcentaje de manipulación (Barra)
+    fig_bar = go.Figure()
+    fig_bar.add_trace(go.Bar(
+        x=['Áreas Detectadas'],
+        y=[porcentaje_ela],
+        marker_color=['#4CAF50' if porcentaje_ela > 2 else '#36A2EB'],
+        text=[f'{porcentaje_ela:.3f}%'],
+        textposition='auto',
+    ))
+    fig_bar.update_layout(
+        title=dict(text="<b>Porcentaje de Áreas Manipuladas</b>", x=0.5),
+        yaxis_title="Porcentaje (%)",
+        height=250,
+        showlegend=False,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    
+    # Gráfico 2: Probabilidad de manipulación (Pie)
+    niveles = ['Muy baja', 'Baja', 'Moderada', 'Alta', 'Muy alta']
+    color_map = ['#00CC96', '#36A2EB', '#FFCE56', '#FF9F40', '#FF6384']
+    
+    prob_index = 0
+    if porcentaje_ela >= 15:
+        prob_index = 4
+    elif porcentaje_ela >= 5:
+        prob_index = 3
+    elif porcentaje_ela >= 2:
+        prob_index = 2
+    elif porcentaje_ela >= 0.5:
+        prob_index = 1
+        
+    fig_pie = go.Figure()
+    fig_pie.add_trace(go.Pie(
+        labels=[niveles[prob_index]],
+        values=[100],
+        hole=.6,
+        marker_colors=[color_map[prob_index]],
+        textinfo='label'
+    ))
+    fig_pie.update_layout(
+        title=dict(text="<b>Nivel de Probabilidad</b>", x=0.5),
+        height=250,
+        showlegend=False,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
+    
+    # Gráfico 3: Distribución de píxeles (Box plot)
+    fig_box = go.Figure()
+    fig_box.add_trace(go.Box(
+        y=[porcentaje_ela],
+        name="Distribución ELA",
+        marker_color='#FF6B35',
+        boxpoints='all'
+    ))
+    fig_box.update_layout(
+        title=dict(text="<b>Distribución de Anomalías</b>", x=0.5),
+        yaxis_title="Porcentaje (%)",
+        height=250,
+        showlegend=False,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
     
-    # Gráfico de Gauge (Riesgo)
-    level = "Bajo" if percentage < 2 else "Medio" if percentage < 10 else "Alto"
-    fig_gauge = go.Figure(go.Indicator(
-        mode = "gauge+number",
-        value = percentage,
-        domain = {'x': [0, 1], 'y': [0, 1]},
-        title = {'text': f"Riesgo: {level}"},
-        gauge = {'axis': {'range': [None, 20]}, 'steps': [
-            {'range': [0, 2], 'color': "lightgreen"},
-            {'range': [2, 10], 'color': "yellow"},
-            {'range': [10, 20], 'color': "red"}]}
+    # Gráfico 4: Tendencias temporales (Scatter)
+    fig_scatter = go.Figure()
+    fig_scatter.add_trace(go.Scatter(
+        x=['Compresión', 'Ruido', 'Manipulación'],
+        y=[max(0.1, porcentaje_ela-1), max(0.1, porcentaje_ela-0.5), max(0.1, porcentaje_ela)],
+        mode='lines+markers',
+        line=dict(color='#FF6B35', width=3),
+        marker=dict(size=10)
     ))
-    fig_gauge.update_layout(height=250, margin=dict(t=30, b=10))
+    fig_scatter.update_layout(
+        title=dict(text="<b>Análisis de Componentes</b>", x=0.5),
+        yaxis_title="Intensidad",
+        height=250,
+        margin=dict(l=20, r=20, t=40, b=20)
+    )
     
-    return fig_bar, fig_gauge
+    return fig_bar, fig_pie, fig_box, fig_scatter
+
+def procesar_imagen(archivo_imagen):
+    if not archivo_imagen:
+        return [None, "❌ **ERROR: Por favor, cargue una imagen antes de analizar.**", None, ""] + [None] * 4
 
-def process_forensic_image(file_path):
-    """Función principal de procesamiento"""
-    if file_path is None:
-        return None, "Sube una imagen para comenzar.", None, "", None, None
+    if not os.path.exists(archivo_imagen):
+        return [None, "❌ **ERROR: El archivo de imagen no existe o es inválido.**", None, ""] + [None] * 4
 
-    start_time = time.time()
     try:
-        img = Image.open(file_path)
-        filename = os.path.basename(file_path)
-        name_no_ext = os.path.splitext(filename)[0]
-        
-        # 1. Metadatos
-        exif = get_exif_data(img)
-        gps = get_gps_coords(exif)
-        google_maps_link = ""
-        
-        report = f"📂 ARCHIVO: {filename}\n"
-        report += f"📏 DIMENSIONES: {img.size[0]} x {img.size[1]} px\n"
-        report += f"🎨 MODO: {img.mode}\n"
-        report += f"#️⃣ HASH SHA3-256: {calculate_hash(img)}\n\n"
-        
-        report += "📋 METADATOS EXIF:\n"
-        for k, v in exif.items():
-            if k not in ["GPSInfo"]:
-                report += f"   • {k}: {v}\n"
-                
-        if gps:
-            lat, lon = gps
-            report += f"\n🌍 GPS DETECTADO: {lat:.6f}, {lon:.6f}\n"
-            google_maps_link = f"https://www.google.com/maps?q={lat},{lon}"
+        img = Image.open(archivo_imagen)
+        logger.info(f"Imagen cargada: {archivo_imagen}")
+
+        nombre_original = os.path.basename(archivo_imagen)
+        nombre = os.path.splitext(nombre_original)[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, "JPEG")
+        ela_result, mask = realizar_ela(img)
+
+        if mask is None:
+            raise Exception("No se pudo generar el análisis ELA.")
+
+        cv2.imwrite(ela_path, ela_result)
+
+        porcentaje_ela = calcular_porcentaje_ela(mask)
+        probabilidad = estimar_probabilidad_manipulacion(porcentaje_ela)
+
+        # Crear gráficos estadísticos
+        fig_bar, fig_pie, fig_box, fig_scatter = crear_graficos_estadisticas(
+            porcentaje_ela, img.size, obtener_metadatos(img)
+        )
+
+        file_size_bytes = os.path.getsize(archivo_imagen)
+        if file_size_bytes < 1024 * 1024:
+            file_size = f"{file_size_bytes / 1024:.2f} KB"
         else:
-            report += "\n🌍 GPS: No disponible\n"
-
-        # 2. Análisis ELA
-        ela_img, mask = perform_ela_analysis(img)
-        percentage = 0.0
-        if mask is not None:
-            total_pixels = mask.shape[0] * mask.shape[1]
-            white_pixels = np.count_nonzero(mask)
-            percentage = round((white_pixels / total_pixels) * 100, 2)
-        
-        report += f"\n🔍 ANÁLISIS ELA:\n"
-        report += f"   • Porcentaje de diferencia: {percentage}%\n"
-        
-        if percentage < 1:
-            report += "   • Veredicto: Imagen probablemente ORIGINAL.\n"
-        elif percentage < 5:
-            report += "   • Veredicto: Posible compresión o edición LEVE.\n"
+            file_size = f"{file_size_bytes / (1024 * 1024):.2f} MB"
+
+        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"
+        info_basica += f"Formato: {img.format}\r\n"
+        info_basica += f"Modo: {img.mode}\r\n\r\n"
+
+        metadatos = obtener_metadatos(img)
+        info_metadatos = "ANÁLISIS FORENSE DE LOS METADATOS:\r\n\r\n"
+
+        google_maps_url = None
+
+        if metadatos:
+            for tag, value in metadatos.items():
+                if tag == "DateTime":
+                    info_metadatos += f"- Fecha y hora de captura: {value}\r\n"
+                elif tag == "Make":
+                    info_metadatos += f"- Fabricante de cámara: {value}\r\n"
+                elif tag == "Model":
+                    info_metadatos += f"- Modelo de cámara: {value}\r\n"
+                elif tag == "Software":
+                    info_metadatos += f"- Software de edición: {value}\r\n"
+                elif tag == "GPSInfo":
+                    coords = obtener_coordenadas(metadatos)
+                    if coords:
+                        lat, lon = coords
+                        info_metadatos += f"- Coordenadas GPS: {lat:.6f}, {lon:.6f}\r\n"
+                        google_maps_url = f"https://www.google.com/maps?q={lat},{lon}"
+                        info_metadatos += f"- Enlace a Google Maps: {google_maps_url}\r\n"
+                    else:
+                        info_metadatos += "- **Coordenadas GPS:** No se encontraron coordenadas válidas\r\n"
+                else:
+                    info_metadatos += f"- **{tag}:** {value}\r\n"
         else:
-            report += "   • Veredicto: ALTA PROBABILIDAD de MANIPULACIÓN.\n"
-
-        # 3. Generar ZIP
-        zip_path = os.path.join(EVIDENCE_DIR, f"{name_no_ext}_forensic.zip")
-        with zipfile.ZipFile(zip_path, 'w') as zf:
-            # Guardar original temporalmente para el zip
-            orig_temp = os.path.join(EVIDENCE_DIR, f"{name_no_ext}_orig.jpg")
-            img.save(orig_temp, "JPEG")
-            zf.write(orig_temp, os.path.basename(orig_temp))
-            
-            # Guardar ELA temporalmente
-            ela_temp = os.path.join(EVIDENCE_DIR, f"{name_no_ext}_ela.jpg")
-            cv2.imwrite(ela_temp, ela_img)
-            zf.write(ela_temp, os.path.basename(ela_temp))
-            
-            # Guardar reporte
-            txt_temp = os.path.join(EVIDENCE_DIR, f"{name_no_ext}_report.txt")
-            with open(txt_temp, 'w', encoding='utf-8') as f:
-                f.write(report)
-            zf.write(txt_temp, os.path.basename(txt_temp))
-
-        # 4. Gráficos
-        fig1, fig2 = generate_plots(percentage)
-        
-        # Convertir ELA a RGB para Gradio
-        ela_rgb = cv2.cvtColor(ela_img, cv2.COLOR_BGR2RGB)
-        
-        logger.info(f"Proceso completado en {time.time() - start_time:.2f}s")
-        return zip_path, report, ela_rgb, google_maps_link, fig1, fig2
+            info_metadatos += "- **Metadatos EXIF:** 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"
+
+        manipulada, razones = analizar_manipulacion(img, metadatos)
+        info_manipulacion = "ANÁLISIS DE MANIPULACIÓN:\r\n\r\n"
+        info_manipulacion += f"- Porcentaje de áreas detectadas: {porcentaje_ela:.3f}%\r\n"
+        info_manipulacion += f"- Estimación forense: {probabilidad}\r\n\r\n"
+
+        analysis_text = info_basica + info_metadatos + info_manipulacion
+
+        with open(text_path, "w", encoding="utf-8", newline="\r\n") 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}")
+
+        ela_rgb = cv2.cvtColor(ela_result, cv2.COLOR_BGR2RGB)
+
+        return [zip_path, analysis_text, ela_rgb, google_maps_url or "", fig_bar, fig_pie, fig_box, fig_scatter]
 
     except Exception as e:
-        logger.error(f"Error crítico: {e}", exc_info=True)
-        return None, f"❌ ERROR: {str(e)}", None, "", None, None
+        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, "ERROR INTERNO", (80, 160), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        return [None, mensaje_error, error_img, ""] + [None] * 4
 
-# --- INTERFAZ GRADIO ---
-theme = gr.themes.Soft(primary_hue="blue")
+# 🎨 Tema moderno
+theme = gr.themes.Soft(primary_hue="blue", secondary_hue="slate", neutral_hue="stone")
 
-with gr.Blocks(title="Forense Digital ELA", theme=theme) as demo:
-    gr.Markdown("# 🕵️‍♂️ Análisis Forense de Imágenes (ELA)")
-    gr.Markdown("Herramienta profesional para detección de manipulaciones mediante Error Level Analysis.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(label="Cargar Imagen (JPG/PNG)", type="filepath", height=400)
-            btn_analyze = gr.Button("🚀 INICIAR ANÁLISIS FORENSE", variant="primary", size="lg")
-            
-            with gr.Accordion("📥 Descargas y Enlaces", open=False):
-                download_zip = gr.DownloadButton(label="Descargar Informe Completo (ZIP)", visible=False)
-                btn_maps = gr.Button("🗺️ Abrir Google Maps", visible=False, link=None)
-                
-        with gr.Column(scale=1):
-            output_ela = gr.Image(label="Visualización ELA (Zonas Turquesas = Sospechosas)", type="numpy", height=400)
-            report_box = gr.Textbox(label="Informe Técnico", lines=10, show_copy_button=True)
+# 🖥️ Interfaz Gradio
+with gr.Blocks(title="Análisis Forense de Imágenes con ELA", theme=theme, css="""
+    .orange-download-btn {
+        background: linear-gradient(45deg, #FF6B35, #FF8E53) !important;
+        color: white !important;
+        border: none !important;
+        font-weight: bold !important;
+    }
+    .orange-download-btn:hover {
+        background: linear-gradient(45deg, #E55A2B, #FF7B42) !important;
+        transform: scale(1.02) !important;
+        box-shadow: 0 4px 12px rgba(255, 107, 53, 0.3) !important;
+    }
+    .equal-height {
+        height: 400px !important;
+    }
+""") as demo:
+    gr.Markdown("""
+    # 📸 Análisis Forense de Imágenes (Error Level Analysis - ELA)
+    **Programa de computación forense para analizar imágenes en busca de evidencia de manipulación o edición.**
+    """)
+    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():
-        plot_stats = gr.Plot(label="Estadísticas de Anomalías")
-        plot_risk = gr.Plot(label="Nivel de Riesgo")
+        with gr.Column():
+            input_image = gr.Image(
+                label="Subir imagen (JPG/PNG)",
+                type="filepath",
+                height=400,
+                sources=["upload"],
+                elem_classes=["equal-height"]
+            )
+            process_btn = gr.Button("Analizar imagen", variant="primary")
+
+            download_zip = gr.DownloadButton(
+                label="⬇️ Descargar resultados (ZIP)",
+                variant="secondary",
+                visible=False,
+                interactive=True,
+                elem_classes=["orange-download-btn"]
+            )
+
+            # Estadísticas en 2x2 grid
+            with gr.Row(visible=False) as stats_row:
+                with gr.Column():
+                    stats_bar = gr.Plot(label="Porcentaje de Manipulación", show_label=True)
+                    stats_pie = gr.Plot(label="Nivel de Probabilidad", show_label=True)
+                with gr.Column():
+                    stats_box = gr.Plot(label="Distribución de Anomalías", show_label=True)
+                    stats_scatter = gr.Plot(label="Análisis de Componentes", show_label=True)
 
-    # Variables de estado ocultas para manejar enlaces
-    url_state = gr.State("")
+        with gr.Column():
+            with gr.Accordion(open=True):
+                ela_image = gr.Image(
+                    label="ÁREAS TURQUESA = manipulaciones o borrados",
+                    type="numpy",
+                    height=400,
+                    show_label=True,
+                    elem_classes=["equal-height"]
+                )
 
-    def update_links(url):
-        if url:
-            return gr.update(visible=True), gr.update(visible=True, link=url)
-        return gr.update(visible=False), gr.update(visible=False)
+            with gr.Accordion("Informe Detallado", open=True):
+                analysis_text = gr.Textbox(label="📝 Resultados del análisis forense", lines=15, max_lines=25)
+                google_maps_btn = gr.Button("📍 Ver ubicación en Google Maps", visible=False)
+                google_maps_url_state = gr.State("")
 
-    btn_analyze.click(
-        fn=process_forensic_image,
+    def reset_on_upload():
+        return (
+            gr.update(value=None),
+            gr.update(value=None),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            "",
+            gr.update(visible=False),
+            None, None, None, None
+        )
+
+    process_btn.click(
+        fn=procesar_imagen,
         inputs=input_image,
-        outputs=[download_zip, report_box, output_ela, url_state, plot_stats, plot_risk]
+        outputs=[download_zip, analysis_text, ela_image, google_maps_url_state, stats_bar, stats_pie, stats_box, stats_scatter],
+        api_name="analyze_image"
+    ).then(
+        fn=lambda url: gr.update(visible=bool(url)),
+        inputs=google_maps_url_state,
+        outputs=google_maps_btn
     ).then(
         fn=lambda: gr.update(visible=True),
         inputs=None,
         outputs=download_zip
     ).then(
-        fn=update_links,
-        inputs=url_state,
-        outputs=[btn_maps, btn_maps] # Actualiza visibilidad y link
+        fn=lambda: gr.update(visible=True),
+        inputs=None,
+        outputs=stats_row
     )
 
-    input_image.clear(
-        fn=lambda: (None, "", None, "", None, None, gr.update(visible=False), gr.update(visible=False)),
-        outputs=[output_ela, report_box, download_zip, url_state, plot_stats, plot_risk, btn_maps, download_zip]
+    google_maps_btn.click(
+        fn=lambda url: url,
+        inputs=google_maps_url_state,
+        outputs=None,
+        js="(url) => { window.open(url, '_blank'); }"
+    )
+
+    input_image.upload(
+        fn=reset_on_upload,
+        inputs=None,
+        outputs=[analysis_text, ela_image, download_zip, google_maps_btn, google_maps_url_state, stats_row, stats_bar, stats_pie, stats_box, stats_scatter]
     )
 
+# ▶️ Ejecución
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        inbrowser=True,
+        favicon_path="https://www.forensedigital.gt/wp-content/uploads/2019/07/cropped-40fb84a6-c75a-4c38-bfa0-c0a9777430cd-1.jpg"
+    )