Update app.py

app.py

@@ -9,7 +9,6 @@ import torch
 from scipy.stats import pearsonr
 
 # --- MÓDULO DE INICIALIZAÇÃO ---
-# Tenta carregar os modelos e módulos, definindo flags de disponibilidade.
 CLIP_AVAILABLE, SALIENCY_AVAILABLE = False, False
 try:
     from transformers import CLIPProcessor, CLIPModel
@@ -22,7 +21,6 @@ except Exception as e:
     print(f"AVISO: Modelo CLIP não carregado. Teste de Inteligência desabilitado. Erro: {e}")
 
 try:
-    # A instalação de 'opencv-contrib-python-headless' deve resolver isso.
     saliency_detector = cv2.saliency.StaticSaliencySpectralResidual_create()
     SALIENCY_AVAILABLE = True
     print("Módulo de Saliência carregado com sucesso.")
@@ -32,32 +30,135 @@ except AttributeError:
 except Exception as e:
     print(f"AVISO: Módulo de Saliência não carregado. Erro: {e}")
 
-# --- FUNÇÕES DE ANÁLISE E PLOTAGEM ---
-# (Cole aqui TODAS as suas funções de análise e plotagem que já funcionavam.
-#  analisar_fidelidade, analisar_cor_iluminacao, analisar_anomalias_movimento,
-#  executar_teste_semantico, etc.)
-# ...
+
+# --- FUNÇÕES DE ANÁLISE ---
+
+def analisar_fidelidade(video_path):
+    cap = cv2.VideoCapture(video_path)
+    frames, ssim_scores, phash_distances = [], [], []
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30
+    
+    while True:
+        ret, frame = cap.read()
+        if not ret: break
+        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    cap.release()
+
+    for i in range(len(frames) - 1):
+        gray1 = cv2.cvtColor(frames[i], cv2.COLOR_RGB2GRAY)
+        gray2 = cv2.cvtColor(frames[i+1], cv2.COLOR_RGB2GRAY)
+        ssim_val, _ = ssim(gray1, gray2, full=True, data_range=gray1.max() - gray1.min())
+        
+        pil_img1 = Image.fromarray(frames[i])
+        pil_img2 = Image.fromarray(frames[i+1])
+        phash_dist = imagehash.phash(pil_img1) - imagehash.phash(pil_img2)
+        
+        ssim_scores.append(ssim_val)
+        phash_distances.append(phash_dist)
+    
+    return frames, fps, ssim_scores, phash_distances
+
+def analisar_cor_iluminacao(frames):
+    lum_corr_scores, color_corr_scores = [], []
+    for i in range(len(frames) - 1):
+        frame1, frame2 = frames[i], frames[i+1]
+        gray1, gray2 = cv2.cvtColor(frame1, cv2.COLOR_RGB2GRAY), cv2.cvtColor(frame2, cv2.COLOR_RGB2GRAY)
+        hist1_lum, hist2_lum = cv2.calcHist([gray1], [0], None, [256], [0,256]), cv2.calcHist([gray2], [0], None, [256], [0,256])
+        lum_corr = cv2.compareHist(hist1_lum, hist2_lum, cv2.HISTCMP_CORREL)
+        lum_corr_scores.append(lum_corr)
+
+        corrs = []
+        for chan in range(3):
+            hist1, hist2 = cv2.calcHist([frame1],[chan],None,[256],[0,256]), cv2.calcHist([frame2],[chan],None,[256],[0,256])
+            corrs.append(cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL))
+        color_corr_scores.append(np.mean(corrs))
+        
+    return lum_corr_scores, color_corr_scores
+
+def analisar_anomalias_movimento(frames):
+    magnitude_scores, orientation_variance_scores = [], []
+    prev_gray = cv2.cvtColor(frames[0], cv2.COLOR_RGB2GRAY)
+    for i in range(1, len(frames)):
+        current_gray = cv2.cvtColor(frames[i], cv2.COLOR_RGB2GRAY)
+        flow = cv2.calcOpticalFlowFarneback(prev_gray, current_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+        magnitude, angle = cv2.cartToPolar(flow[...,0], flow[...,1])
+        magnitude_scores.append(np.mean(magnitude))
+        orientation_variance_scores.append(np.var(angle))
+        prev_gray = current_gray
+    return magnitude_scores, orientation_variance_scores
+
+def analisar_estabilidade_foco(frames):
+    ssim_foco_scores, jitter_foco_scores = [], []
+    last_roi_center = None
+    for i in range(len(frames) - 1):
+        frame1, frame2 = frames[i], frames[i+1]
+        try:
+            _, saliencyMap1 = saliency_detector.computeSaliency(frame1)
+            _, saliencyMap2 = saliency_detector.computeSaliency(frame2)
+            saliencyMap1_8bit, saliencyMap2_8bit = (saliencyMap1 * 255).astype("uint8"), (saliencyMap2 * 255).astype("uint8")
+            _, thresh1, _, thresh2 = cv2.threshold(saliencyMap1_8bit, 0, 255, cv2.THRESH_OTSU), cv2.threshold(saliencyMap2_8bit, 0, 255, cv2.THRESH_OTSU)
+            contours1, _ = cv2.findContours(thresh1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            contours2, _ = cv2.findContours(thresh2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+            if contours1 and contours2:
+                x1, y1, w1, h1 = cv2.boundingRect(max(contours1, key=cv2.contourArea))
+                x2, y2, w2, h2 = cv2.boundingRect(max(contours2, key=cv2.contourArea))
+                roi1, roi2 = frame1[y1:y1+h1, x1:x1+w1], frame2[y2:y2+h2, x2:x2+w2]
+                roi1_gray, roi2_gray = cv2.cvtColor(roi1, cv2.COLOR_RGB2GRAY), cv2.cvtColor(roi2, cv2.COLOR_RGB2GRAY)
+                roi2_gray_resized = cv2.resize(roi2_gray, (roi1_gray.shape[1], roi1_gray.shape[0]))
+                
+                ssim_foco, _ = ssim(roi1_gray, roi2_gray_resized, full=True, data_range=255) if min(roi1_gray.shape) > 7 else (0, None)
+                ssim_foco_scores.append(ssim_foco)
+                
+                center = (x1 + w1/2, y1 + h1/2)
+                jitter_foco_scores.append(np.linalg.norm(np.array(center) - np.array(last_roi_center)) if last_roi_center else 0)
+                last_roi_center = center
+            else:
+                ssim_foco_scores.append(0); jitter_foco_scores.append(0)
+        except:
+            ssim_foco_scores.append(0); jitter_foco_scores.append(0)
+    return ssim_foco_scores, jitter_foco_scores
+
+def executar_teste_semantico(phash_distances, descriptions_text):
+    # (Função como definida anteriormente)
+    return None, "Função ainda não implementada completamente no template"
+
+
+# --- FUNÇÕES DE PLOTAGEM ---
+# (Todas as suas funções `gerar_grafico_...` devem estar aqui)
+def gerar_grafico_fidelidade(ssim, phash, num_frames, fps):
+    path = "fidelidade.png"
+    # ... lógica de plotagem ...
+    plt.figure(); plt.plot(ssim); plt.savefig(path); plt.close()
+    return path
+# ... e assim por diante para todas as outras funções de plotagem ...
+
 
 # --- FUNÇÃO DE CALLBACK PRINCIPAL ---
-def run_full_analysis(video_path, descriptions_text, progress=gr.Progress()):
-    if video_path is None: raise gr.Error("Por favor, faça o upload de um vídeo.")
+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.")
     
-    # Executa as análises principais que sempre funcionam
     progress(0, desc="Analisando fidelidade...")
-    frames, fps, ssim_scores, phash_distances = analisar_fidelidade(video_path, progress)
+    frames, fps, ssim_scores, phash_distances = analisar_fidelidade(video_path)
     
+    progress(0.2, desc="Gerando gráfico de fidelidade...")
     fidelidade_plot_path = gerar_grafico_fidelidade(ssim_scores, phash_distances, len(frames), fps)
-    cor_plot_path = gerar_grafico_cor_luz(ssim_scores, phash_distances, len(frames), fps) # Supondo que você tenha essa função
-    anomalias_plot_path = gerar_grafico_anomalias(ssim_scores, phash_distances, len(frames), fps) # Supondo que você tenha essa função
 
-    # Executa análises opcionais apenas se os módulos estiverem disponíveis
-    foco_plot_path, semantico_path = None, None
+    progress(0.3, desc="Analisando cor e iluminação...")
+    lum_scores, color_scores = analisar_cor_iluminacao(frames)
+    cor_plot_path = "cor.png" # Placeholder para a função de plotagem
+
+    progress(0.4, desc="Analisando glitches de movimento...")
+    mag_scores, var_scores = analisar_anomalias_movimento(frames)
+    anomalias_plot_path = "anomalias.png" # Placeholder
 
+    foco_plot_path = None
     if SALIENCY_AVAILABLE:
         progress(0.6, desc="Analisando foco móvel...")
-        ssim_foco, jitter_foco = analisar_estabilidade_foco(frames, progress)
-        foco_plot_path = gerar_grafico_foco(ssim_scores, ssim_foco, jitter_foco, len(frames), fps)
+        ssim_foco, jitter_foco = analisar_estabilidade_foco(frames)
+        foco_plot_path = "foco.png" # Placeholder
 
+    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)
@@ -68,31 +169,23 @@ def run_full_analysis(video_path, descriptions_text, progress=gr.Progress()):
 # --- INTERFACE GRADIO ---
 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)")
-
     with gr.Row():
         with gr.Column(scale=1):
             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. Fidelidade e Coerência"):
             plot_fidelidade = gr.Image(label="Gráfico de Análise de Fidelidade (SSIM e pHash)")
-        
         with gr.TabItem("2. Cor e Iluminação"):
             plot_cor = gr.Image(label="Gráfico de Análise de Cor e Luminância")
-        
         with gr.TabItem("3. Foco (Vídeo Móvel)"):
             plot_foco = gr.Image(label="Gráfico de Análise de Foco e Jitter")
-        
         with gr.TabItem("4. Glitches de Movimento"):
             plot_anomalias = gr.Image(label="Gráfico do Detector de Anomalias de Movimento")
-            
         with gr.TabItem("5. Inteligência Adaptativa"):
             plot_semantico = gr.Image(label="Gráfico de Estresse Semântico")
 
-    # A interatividade foi removida para garantir que o app inicie
-    # O callback do botão agora é mais simples
     analyze_button.click(
         fn=run_full_analysis,
         inputs=[video_input, descriptions_input],
@@ -100,4 +193,4 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
     )
 
 if __name__ == "__main__":
-    demo.queue().launch(share=True)
+    demo.queue().launch()