Create app.ly

app.ly

@@ -0,0 +1,180 @@
+import gradio as gr
+import cv2
+import numpy as np
+from skimage.metrics import structural_similarity as ssim
+import matplotlib.pyplot as plt
+from PIL import Image
+import imagehash
+import os
+import math
+
+# --- Constantes ---
+THUMBNAIL_HEIGHT = 100 # Altura de cada miniatura na timeline
+
+# --- Funções de Análise (mesmas de antes, mas adaptadas para Gradio) ---
+
+def analisar_video(video_path, progress=gr.Progress()):
+    """Função principal que processa o vídeo e gera os artefatos de saída."""
+    if video_path is None:
+        raise gr.Error("Por favor, faça o upload de um arquivo de vídeo.")
+
+    # 1. Extrair Frames
+    progress(0, desc="Carregando vídeo e extraindo frames...")
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) # Gradio usa RGB
+    cap.release()
+    
+    if not frames:
+        raise gr.Error("Não foi possível ler os frames do vídeo.")
+
+    # 2. Análise Frame-a-Frame
+    ssim_scores = []
+    phash_distances = []
+    num_frames = len(frames)
+    
+    for i in progress.tqdm(range(num_frames - 1), desc="Analisando transições..."):
+        frame_atual = frames[i]
+        proximo_frame = frames[i+1]
+        
+        # Converte para cinza para SSIM
+        gray1 = cv2.cvtColor(frame_atual, cv2.COLOR_RGB2GRAY)
+        gray2 = cv2.cvtColor(proximo_frame, cv2.COLOR_RGB2GRAY)
+        ssim_val, _ = ssim(gray1, gray2, full=True)
+        
+        # Converte para PIL para pHash
+        pil_img1 = Image.fromarray(frame_atual)
+        pil_img2 = Image.fromarray(proximo_frame)
+        phash_dist = imagehash.phash(pil_img1) - imagehash.phash(pil_img2)
+        
+        ssim_scores.append(ssim_val)
+        phash_distances.append(phash_dist)
+
+    # 3. Gerar Gráfico
+    progress(0.8, desc="Gerando gráfico de análise...")
+    grafico_path = gerar_grafico_analise(ssim_scores, phash_distances, num_frames, fps)
+
+    # 4. Gerar Timeline Visual
+    progress(0.9, desc="Criando timeline de miniaturas...")
+    timeline_path = gerar_timeline_visual(frames, num_frames, fps)
+    
+    return grafico_path, timeline_path
+
+def gerar_grafico_analise(ssim_scores, phash_distances, num_frames, fps):
+    """Gera e salva um gráfico com as métricas de análise."""
+    x_axis_frames = range(num_frames - 1)
+    x_axis_time = [i / fps for i in x_axis_frames]
+    
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(16, 10), sharex=True)
+    fig.suptitle('Análise Quantitativa da Coerência do Vídeo', fontsize=16)
+
+    # --- Gráfico 1: SSIM ---
+    ax1.plot(x_axis_time, ssim_scores, color='tab:blue', lw=2)
+    ax1.set_ylabel('Índice SSIM (1.0 = Perfeito)')
+    ax1.set_title('Métrica 1: Fidelidade do Eco e Continuidade da Cena')
+    ax1.grid(True, linestyle='--', alpha=0.6)
+    ax1.set_ylim(0, 1.05)
+    ax1.axhline(y=0.9, color='green', linestyle='--', label='Limiar de Alta Fidelidade (0.9)')
+    ax1.legend()
+
+    # --- Gráfico 2: pHash ---
+    ax2.plot(x_axis_time, phash_distances, color='tab:red', lw=2)
+    ax2.set_ylabel('Distância pHash (0 = Idêntico)')
+    ax2.set_title('Métrica 2: Detecção de Transições Semânticas e Cortes')
+    ax2.grid(True, linestyle='--', alpha=0.6)
+    ax2.axhline(y=10, color='orange', linestyle='--', label='Limiar de Corte Forte (>10)')
+    ax2.legend()
+    
+    ax2.set_xlabel('Tempo (segundos)')
+    
+    plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+    
+    grafico_path = 'analise_fidelidade.png'
+    plt.savefig(grafico_path)
+    plt.close() # Libera memória
+    return grafico_path
+
+def gerar_timeline_visual(frames, num_frames, fps):
+    """Cria uma única imagem com miniaturas de frames em intervalos regulares."""
+    intervalo_frames = 8
+    indices_selecionados = list(range(0, num_frames, intervalo_frames))
+    
+    thumbnails = []
+    for i in indices_selecionados:
+        frame = Image.fromarray(frames[i])
+        # Redimensiona mantendo a proporção
+        aspect_ratio = frame.width / frame.height
+        new_width = int(THUMBNAIL_HEIGHT * aspect_ratio)
+        thumbnail = frame.resize((new_width, THUMBNAIL_HEIGHT), Image.Resampling.LANCZOS)
+        thumbnails.append(thumbnail)
+        
+    # Calcula o tamanho da imagem final
+    total_width = sum(t.width for t in thumbnails)
+    max_height = THUMBNAIL_HEIGHT
+    
+    # Cria a imagem da timeline
+    timeline_img = Image.new('RGB', (total_width, max_height + 40), (255, 255, 255))
+    from PIL import ImageDraw, ImageFont
+    draw = ImageDraw.Draw(timeline_img)
+    try:
+        font = ImageFont.truetype("DejaVuSans.ttf", 15)
+    except IOError:
+        font = ImageFont.load_default()
+
+    current_x = 0
+    for i, thumb in enumerate(thumbnails):
+        timeline_img.paste(thumb, (current_x, 0))
+        # Adiciona o timestamp
+        frame_idx = indices_selecionados[i]
+        timestamp = frame_idx / fps
+        draw.text((current_x + 5, max_height + 5), f"{timestamp:.1f}s", fill=(0,0,0), font=font)
+        current_x += thumb.width
+        
+    timeline_path = 'timeline_visual.png'
+    timeline_img.save(timeline_path)
+    return timeline_path
+
+# --- Interface Gradio ---
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Analisador de Coerência ADUC-SDR") as demo:
+    gr.Markdown(
+        """
+        # Prova Científica da Arquitetura ADUC-SDR
+        ### Validação Quantitativa da Coerência Narrativa e Fidelidade do Eco
+        Faça o upload de um vídeo gerado para mapear matematicamente sua estabilidade e transições. 
+        Este Space analisa cada frame para provar a continuidade mantida pela arquitetura.
+        Desenvolvido a partir do projeto: [carlex22/Aduc-sdr](https://github.com/carlex22/Aduc-sdr).
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            video_input = gr.Video(label="Upload do Vídeo", sources=["upload"])
+            analyze_button = gr.Button("Analisar Vídeo", variant="primary")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### **Resultados da Análise**")
+            plot_output = gr.Image(label="Gráfico de Análise (SSIM e pHash)", type="filepath")
+            timeline_output = gr.Image(label="Timeline Visual (A cada 8 frames)", type="filepath")
+            
+    analyze_button.click(
+        fn=analisar_video,
+        inputs=[video_input],
+        outputs=[plot_output, timeline_output]
+    )
+    
+    gr.Examples(
+        [["https://huggingface.co/spaces/carlex22/aduc-sdr/resolve/main/video.mp4"]],
+        inputs=[video_input],
+    )
+
+
+if __name__ == "__main__":
+    # Para rodar localmente com GPU, você pode precisar configurar o PyTorch.
+    # No HF Spaces, a GPU é gerenciada pelo ambiente.
+    demo.queue().launch(share=True)