Update app.py

app.py

@@ -5,162 +5,165 @@ from skimage.metrics import structural_similarity as ssim
 import matplotlib.pyplot as plt
 from PIL import Image, ImageDraw, ImageFont
 import imagehash
+import torch
+from scipy.stats import pearsonr
 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)
-    if fps == 0:
-        fps = 30 # Define um padrão caso não consiga ler o 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)
+# --- MÓDULOS DE ANÁLISE (CLIP E SALIÊNCIA) ---
+CLIP_AVAILABLE, SALIENCY_AVAILABLE = False, False
+try:
+    from transformers import CLIPProcessor, CLIPModel
+    MODEL_ID = "openai/clip-vit-base-patch32"
+    clip_model = CLIPModel.from_pretrained(MODEL_ID)
+    clip_processor = CLIPProcessor.from_pretrained(MODEL_ID)
+    CLIP_AVAILABLE = True
+    print("Modelo CLIP carregado.")
+except Exception as e:
+    print(f"Aviso CLIP: {e}")
+
+try:
+    saliency = cv2.saliency.StaticSaliencySpectralResidual_create()
+    SALIENCY_AVAILABLE = True
+    print("Módulo de Saliência carregado.")
+except Exception as e:
+    print(f"Aviso Saliência: {e}")
+
+
+# --- FUNÇÕES DE ANÁLISE CORE ---
+# (As funções de análise de fidelidade, foco e semântica permanecem as mesmas)
+def analisar_cor_iluminacao(frames, progress):
+    """Executa o novo teste de consistência cromática e de iluminação."""
+    lum_corr_scores, color_corr_scores = [], []
     
-    for i in progress.tqdm(range(num_frames - 1), desc="Analisando transições..."):
-        frame_atual = frames[i]
-        proximo_frame = frames[i+1]
-        
-        gray1 = cv2.cvtColor(frame_atual, cv2.COLOR_RGB2GRAY)
-        gray2 = cv2.cvtColor(proximo_frame, cv2.COLOR_RGB2GRAY)
-        ssim_val, _ = ssim(gray1, gray2, full=True)
+    progress(0.3, desc="Analisando cor e iluminação...")
+    for i in range(len(frames) - 1):
+        frame1 = frames[i]
+        frame2 = frames[i+1]
+
+        # 1. Análise de Luminância (Brilho)
+        gray1 = cv2.cvtColor(frame1, cv2.COLOR_RGB2GRAY)
+        gray2 = cv2.cvtColor(frame2, cv2.COLOR_RGB2GRAY)
+        hist1_lum = cv2.calcHist([gray1], [0], None, [256], [0, 256])
+        hist2_lum = cv2.calcHist([gray2], [0], None, [256], [0, 256])
+        cv2.normalize(hist1_lum, hist1_lum, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX)
+        cv2.normalize(hist2_lum, hist2_lum, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX)
+        lum_corr = cv2.compareHist(hist1_lum, hist2_lum, cv2.HISTCMP_CORREL)
+        lum_corr_scores.append(lum_corr)
+
+        # 2. Análise de Cor (RGB)
+        corr_r, corr_g, corr_b = 0, 0, 0
+        for chan in range(3):
+            hist1_color = cv2.calcHist([frame1], [chan], None, [256], [0, 256])
+            hist2_color = cv2.calcHist([frame2], [chan], None, [256], [0, 256])
+            cv2.normalize(hist1_color, hist1_color, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX)
+            cv2.normalize(hist2_color, hist2_color, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX)
+            if chan == 0: corr_r = cv2.compareHist(hist1_color, hist2_color, cv2.HISTCMP_CORREL)
+            if chan == 1: corr_g = cv2.compareHist(hist1_color, hist2_color, cv2.HISTCMP_CORREL)
+            if chan == 2: corr_b = cv2.compareHist(hist1_color, hist2_color, cv2.HISTCMP_CORREL)
         
-        pil_img1 = Image.fromarray(frame_atual)
-        pil_img2 = Image.fromarray(proximo_frame)
-        phash_dist = imagehash.phash(pil_img1) - imagehash.phash(pil_img2)
+        # Média da correlação dos 3 canais de cor
+        avg_color_corr = (corr_r + corr_g + corr_b) / 3.0
+        color_corr_scores.append(avg_color_corr)
         
-        ssim_scores.append(ssim_val)
-        phash_distances.append(phash_dist)
+    return lum_corr_scores, color_corr_scores
 
-    # 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):
-    x_axis_frames = range(num_frames - 1)
-    x_axis_time = [i / fps for i in x_axis_frames]
-    
+# --- FUNÇÕES DE PLOTAGEM ADICIONAIS ---
+def gerar_grafico_cor(lum_scores, color_scores, num_frames, fps):
+    x_axis_time = [i / fps for i in range(num_frames - 1)]
     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)
+    fig.suptitle('Análise de Consistência Cromática e de Iluminação', fontsize=16)
 
-    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.plot(x_axis_time, color_scores, color='magenta', lw=2, label='Correlação de Cor (RGB)')
+    ax1.set_ylabel('Correlação de Histograma')
+    ax1.set_title('Consistência da Paleta de Cores da Cena')
     ax1.set_ylim(0, 1.05)
-    ax1.axhline(y=0.9, color='green', linestyle='--', label='Limiar de Alta Fidelidade (0.9)')
-    ax1.legend()
-
-    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()
+    ax1.grid(True, linestyle='--'); ax1.legend()
     
+    ax2.plot(x_axis_time, lum_scores, color='gold', lw=2, label='Correlação de Luminância (Brilho)')
+    ax2.set_ylabel('Correlação de Histograma')
+    ax2.set_title('Consistência da Iluminação da Cena')
     ax2.set_xlabel('Tempo (segundos)')
+    ax2.set_ylim(0, 1.05)
+    ax2.grid(True, linestyle='--'); ax2.legend()
     
     plt.tight_layout(rect=[0, 0.03, 1, 0.95])
-    
-    grafico_path = 'analise_fidelidade.png'
-    plt.savefig(grafico_path)
+    path = 'analise_cor_luz.png'
+    plt.savefig(path)
     plt.close()
-    return grafico_path
+    return path
+
 
-def gerar_timeline_visual(frames, num_frames, fps):
-    intervalo_frames = 8
-    indices_selecionados = list(range(0, num_frames, intervalo_frames))
+# --- FUNÇÃO DE CALLBACK PRINCIPAL ---
+def run_full_analysis(video_path, descriptions_text, progress=gr.Progress()):
+    if video_path is None: raise gr.Error("Faça o upload de um vídeo.")
     
-    thumbnails = []
-    for i in indices_selecionados:
-        frame = Image.fromarray(frames[i])
-        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)
-        
-    total_width = sum(t.width for t in thumbnails)
-    max_height = THUMBNAIL_HEIGHT
+    # Análise de Fidelidade
+    frames, fps, ssim_scores, phash_distances = analisar_fidelidade(video_path, progress)
+    fidelidade_plot = gerar_grafico_fidelidade_plot(ssim_scores, phash_distances, len(frames), fps)
+    timeline_path = gerar_timeline_visual(frames, len(frames), fps)
     
-    timeline_img = Image.new('RGB', (total_width, max_height + 40), (20, 20, 20)) # Fundo escuro
-    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))
-        frame_idx = indices_selecionados[i]
-        timestamp = frame_idx / fps
-        draw.text((current_x + 5, max_height + 5), f"{timestamp:.1f}s", fill=(255,255,255), font=font) # Texto branco
-        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).
-        """
-    )
+    # Análise de Cor e Iluminação
+    lum_scores, color_scores = analisar_cor_iluminacao(frames, progress)
+    cor_plot_path = gerar_grafico_cor(lum_scores, color_scores, len(frames), fps)
+
+    # Análise de Foco Móvel
+    foco_plot_path = None
+    if SALIENCY_AVAILABLE:
+        ssim_foco, jitter_foco = analisar_estabilidade_foco(frames, progress)
+        foco_plot_path = gerar_grafico_foco(ssim_scores, ssim_foco, jitter_foco, len(frames), fps)
+
+    # Análise Semântica
+    semantico_path = None
+    if CLIP_AVAILABLE and descriptions_text.strip():
+        progress(0.8, desc="Executando teste semântico...")
+        semantico_path, error_msg = executar_teste_semantico(phash_distances, descriptions_text)
+        if error_msg: gr.Warning(error_msg)
+    
+    state_data = {"frames": frames, "fps": fps, "ssim_scores": ssim_scores, "phash_distances": phash_distances}
     
+    return fidelidade_plot, timeline_path, semantico_path, foco_plot_path, cor_plot_path, state_data, None, None, ""
+
+# --- INTERFACE GRADIO COMPLETA ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Suíte de Validação Completa para Geração de Vídeo (ADUC-SDR)")
+    shared_state = gr.State(value={})
+
     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")
+            video_input = gr.Video(label="1. Upload do vídeo")
+            descriptions_input = gr.Textbox(lines=5, label="2. Descrições (Opcional)", placeholder="Uma descrição por cena...")
+            analyze_button = gr.Button("3. Executar Análise Completa", variant="primary")
+
+    with gr.Tabs():
+        with gr.TabItem("1. Análise Principal e Diagnóstico"):
+            plot_fidelidade = gr.Plot(label="Gráfico de Análise de Fidelidade (Clique para inspecionar)")
+            with gr.Row():
+                frame_antes = gr.Image(label="Frame Antes")
+                frame_depois = gr.Image(label="Frame Depois")
+                info_box = gr.Textbox(label="Dados do Ponto Selecionado")
+            timeline_output = gr.Image(label="Timeline Visual", interactive=False)
+
+        with gr.TabItem("2. Análise de Cor e Iluminação"):
+            gr.Markdown("### Teste de Consistência Cromática e de Iluminação")
+            plot_cor = gr.Image(label="Gráfico de Análise de Cor e Luminância")
+
+        with gr.TabItem("3. Análise para Vídeo Móvel"):
+            gr.Markdown("### Teste de Estabilidade de Foco")
+            plot_foco = gr.Image(label="Gráfico de Análise de Foco e Jitter")
             
+        with gr.TabItem("4. Teste de Inteligência Adaptativa"):
+            gr.Markdown("### Validação da Decisão Adaptativa")
+            plot_semantico = gr.Image(label="Gráfico de Estresse Semântico")
+
+    # --- Lógica de Eventos ---
     analyze_button.click(
-        fn=analisar_video,
-        inputs=[video_input],
-        outputs=[plot_output, timeline_output]
+        fn=run_full_analysis,
+        inputs=[video_input, descriptions_input],
+        outputs=[plot_fidelidade, timeline_output, plot_semantico, plot_foco, plot_cor, shared_state, frame_antes, frame_depois, info_box]
     )
-
-# O bloco gr.Examples foi removido daqui.
-
-if __name__ == "__main__":
-    demo.queue().launch(share=True)
+    plot_fidelidade.select(
+        fn=inspect_transition,
+        inputs=[shared_state],
+        outputs=[frame_antes, frame_depois, info_box]
+    )