Update app.py

app.py

@@ -1,9 +1,8 @@
 import gradio as gr
 import cv2
 import os
-import random
 import zipfile
-from PIL import Image
+from PIL import Image, ImageOps
 from datetime import datetime
 import hashlib
 
@@ -24,7 +23,7 @@ def procesar_video(video):
         temp_dir = f"temp_{datetime.now().strftime('%Y%m%d%H%M%S')}"
         os.makedirs(temp_dir, exist_ok=True)
 
-        # Extracción de fotogramas
+        # Extracción de todos los fotogramas
         cap = cv2.VideoCapture(video_path)
         frame_count = 0
         frame_paths = []
@@ -41,53 +40,85 @@ def procesar_video(video):
         cap.release()
 
         if frame_count == 0:
-            raise gr.Error("No se pudieron extraer los fotogramas del video")
+            raise gr.Error("No se pudieron extraer fotogramas del video")
 
-        # Crear collage
-        selected_frames = random.sample(frame_paths, min(4, len(frame_paths)))
-        images = [Image.open(img) for img in selected_frames]
-        margin = 10
+        # Selección estratégica de 4 fotogramas equidistantes
+        n_seleccion = 4
+        step = max(1, frame_count // (n_seleccion + 1))
+        selected_indices = [step * (i+1) for i in range(n_seleccion)]
+        selected_frames = [frame_paths[min(i, len(frame_paths)-1)] for i in selected_indices]
+
+        # Creación de collage profesional
+        images = []
+        for img_path in selected_frames:
+            img = Image.open(img_path)
+            bordered_img = ImageOps.expand(img, border=2, fill='white')  # Borde blanco
+            images.append(bordered_img)
+
+        # Configuración del diseño
+        img_w, img_h = images[0].size
+        margin = 30
+        border_size = 20
+        shadow_offset = 5
+        
+        collage_width = (img_w * 2) + margin + (border_size * 2)
+        collage_height = (img_h * 2) + margin + (border_size * 2)
+        
         collage = Image.new('RGB', 
-            (images[0].width * 2 + margin, images[0].height * 2 + margin), 
-            (255,255,255))
+            (collage_width, collage_height), 
+            (230, 230, 230))  # Fondo gris claro
+        
+        # Posiciones con efecto de profundidad
         positions = [
-            (0, 0),
-            (images[0].width + margin, 0),
-            (0, images[0].height + margin),
-            (images[0].width + margin, images[0].height + margin)
+            (border_size, border_size),
+            (border_size + img_w + margin, border_size),
+            (border_size, border_size + img_h + margin),
+            (border_size + img_w + margin, border_size + img_h + margin)
         ]
+        
+        # Pegar imágenes con sombra
         for i, img in enumerate(images):
+            # Sombra
+            shadow = Image.new('RGBA', (img_w + shadow_offset, img_h + shadow_offset), (0,0,0,50))
+            collage.paste(shadow, (positions[i][0]+shadow_offset, positions[i][1]+shadow_offset), shadow)
+            
+            # Imagen principal
             collage.paste(img, positions[i])
-        collage_path = os.path.join(temp_dir, "collage.jpg")
-        collage.save(collage_path)
 
-        # Generación del ZIP
+        collage_path = os.path.join(temp_dir, "collage_forense.jpg")
+        collage.save(collage_path, quality=95, dpi=(300, 300))
+
+        # Generación del ZIP con cadena de custodia
         base_name = os.path.splitext(original_name)[0]
-        zip_filename = f"{base_name}.zip"
+        zip_filename = f"{base_name}_Fotogramas.zip"
         final_zip_path = os.path.join(temp_dir, zip_filename)
         
         with zipfile.ZipFile(final_zip_path, mode="w") as zipf:
+            # Añadir todos los frames
             for img_path in frame_paths:
                 zipf.write(img_path, os.path.basename(img_path))
             
+            # Archivo TXT con formato profesional
             with open(video_path, "rb") as f:
                 video_hash = hashlib.md5(f.read()).hexdigest()
             
             chain_content = (
-                "=== CADENA DE CUSTODIA ===\r\n\r\n"
-                f"• Nombre del archivo: {original_name}\r\n"
+                "=== CADENA DE CUSTODIA DIGITAL ===\r\n\r\n"
+                f"• Archivo original: {original_name}\r\n"
                 f"• Fecha de procesamiento: {timestamp}\r\n"
-                f"• Fotogramas extraídos: {frame_count}\r\n"
-                f"• Hash MD5 del video original: {video_hash}\r\n\r\n"
-                "Firmado digitalmente por:\n"
-                "Extracción Forense de Fotogramas | Peritos Forenses Digitales de Guatemala | www.forensedigital.gt"
+                f"• Fotogramas totales: {frame_count}\r\n"
+                f"• Hash MD5 video: {video_hash}\r\n"
+                f"• Fotogramas muestra: {', '.join([f'#{i+1}' for i in selected_indices])}\r\n\r\n"
+                "Este documento certifica la integridad del proceso de extracción.\n"
+                "Sistema Certificado por Peritos Forenses Digitales de Guatemala. \n"
+                "www.forensedigital.gt"
             )
-            zipf.writestr("cadena_custodia.txt", chain_content)
+            zipf.writestr("00_CADENA_CUSTODIA.txt", chain_content)
 
         return collage_path, final_zip_path, temp_dir
 
     except Exception as e:
-        raise gr.Error(f"Error al procesar el video: {str(e)}")
+        raise gr.Error(f"Error en procesamiento: {str(e)}")
 
 def limpiar_cache(temp_dir):
     if temp_dir and os.path.exists(temp_dir):
@@ -95,32 +126,33 @@ def limpiar_cache(temp_dir):
             os.remove(os.path.join(temp_dir, file))
         os.rmdir(temp_dir)
 
-with gr.Blocks(title="Extracción Forense de Fotogramas") as demo:
-    gr.Markdown("# 📷 Herramienta de Extracción Forense de Fotogramas")
-    gr.Markdown("**Carga un video para extraer TODOS los fotogramas y generar un archivo ZIP con CoC del contenido.**")
+with gr.Blocks(title="Extractior Forense de Fotogramas") as demo:
+    gr.Markdown("# 📷 Extractor Forense de Fotogramas de Videos")
+    gr.Markdown("**Herramienta certificada para extracción forense de fotogramas de videos**")
     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():
         with gr.Column():
             video_input = gr.Video(
-                label="Subir Video", 
-                interactive=True,
+                label="CARGAR VIDEO",
                 sources=["upload"],
-                format="mp4"
+                format="mp4",
+                interactive=True
             )
-            procesar_btn = gr.Button("Procesar Fotogramas", interactive=False)
+            procesar_btn = gr.Button("🔍 INICIAR ANÁLISIS", interactive=False)
         with gr.Column():
-            gallery_output = gr.Image(label="Collage de Muestra")
-            download_file = gr.File(label="Archivo ZIP generado", visible=True)
+            gr.Markdown("## Resultados:")
+            gallery_output = gr.Image(label="COLLAGE DE REFERENCIA", height=400)
+            download_file = gr.File(label="DESCARGAR EVIDENCIAS", visible=True)
     
     temp_dir_state = gr.State()
     zip_path_state = gr.State()
     
-    def on_video_change(video):
-        return gr.update(interactive=bool(video))
+    def habilitar_procesado(video):
+        return gr.update(interactive=True) if video else gr.update(interactive=False)
     
     video_input.change(
-        fn=on_video_change,
+        fn=habilitar_procesado,
         inputs=video_input,
         outputs=procesar_btn,
         queue=False
@@ -129,8 +161,8 @@ with gr.Blocks(title="Extracción Forense de Fotogramas") as demo:
     def procesar_y_mostrar(video):
         if temp_dir_state.value:
             limpiar_cache(temp_dir_state.value)
-        collage_path, zip_path, temp_dir = procesar_video(video)
-        return collage_path, zip_path, temp_dir, zip_path  # 4 outputs
+        collage, zip_path, temp_dir = procesar_video(video)
+        return collage, zip_path, temp_dir, zip_path
     
     procesar_btn.click(
         fn=procesar_y_mostrar,