Update app.py

app.py

@@ -1,346 +1,346 @@
-"""
-Módulo de rastreamento facial para crop inteligente de vídeos.
-Usa OpenCV e detecção de rostos para manter pessoas centralizadas ao redimensionar.
-"""
+import gradio as gr
+from pathlib import Path
+import shutil
+import os
+from core import transcribe, generate_linear_cuts, generate_creative_cuts, Segment
 
-import cv2
-import numpy as np
-from typing import Tuple, Optional, List
-from dataclasses import dataclass
+SPACE_OUT = Path("outputs"); SPACE_OUT.mkdir(exist_ok=True, parents=True)
 
-@dataclass
-class FaceBox:
-    """Representa uma detecção de rosto."""
-    x: int
-    y: int
-    w: int
-    h: int
-    center_x: int
-    center_y: int
-    confidence: float = 1.0
+def do_transcribe(video_file, model_size):
+    if video_file is None:
+        return [], "Selecione um vídeo."
+    segs = transcribe(video_file, model_size=model_size)
+    # show a small preview of transcript
+    preview = "\n".join([f"[{s.start:.1f}–{s.end:.1f}] {s.text}" for s in segs[:12]])
+    return segs, f"Transcrição ok. Segmentos: {len(segs)}\n\nPrévia:\n{preview}"
 
-class FaceTracker:
-    """Rastreador de rostos para crop inteligente de vídeos."""
-    
-    def __init__(self):
-        """Inicializa o detector de rostos usando Haar Cascades do OpenCV."""
-        # Tenta carregar diferentes cascades (frontal e perfil)
-        cascade_paths = [
-            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml',
-            cv2.data.haarcascades + 'haarcascade_frontalface_alt.xml',
-        ]
-        
-        self.face_cascade = None
-        for path in cascade_paths:
-            try:
-                self.face_cascade = cv2.CascadeClassifier(path)
-                if not self.face_cascade.empty():
-                    break
-            except:
-                continue
-        
-        if self.face_cascade is None or self.face_cascade.empty():
-            print("⚠️ Aviso: Não foi possível carregar detector de rostos. Crop será centralizado.")
-            self.enabled = False
-        else:
-            self.enabled = True
-            print("✓ Detector de rostos carregado com sucesso")
-    
-    def detect_faces(self, frame: np.ndarray) -> List[FaceBox]:
-        """
-        Detecta rostos em um frame.
-        
-        Args:
-            frame: Frame do vídeo (BGR ou RGB)
-            
-        Returns:
-            Lista de FaceBox com rostos detectados
-        """
-        if not self.enabled:
-            return []
-        
-        # Converte para escala de cinza para detecção
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        
-        # Detecta rostos
-        faces = self.face_cascade.detectMultiScale(
-            gray,
-            scaleFactor=1.1,
-            minNeighbors=5,
-            minSize=(30, 30),
-            flags=cv2.CASCADE_SCALE_IMAGE
-        )
-        
-        # Converte para FaceBox
-        face_boxes = []
-        for (x, y, w, h) in faces:
-            center_x = x + w // 2
-            center_y = y + h // 2
-            face_boxes.append(FaceBox(x, y, w, h, center_x, center_y))
-        
-        return face_boxes
+def run_linear(segs, video_file, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking):
+    if not segs:
+        return [], "Transcreva antes de cortar."
+    workdir = SPACE_OUT / (out_subdir or "cortes")
+    outs = generate_linear_cuts(video_file, segs, str(workdir),
+                                min_len=min_len, max_len=max_len, ideal_len=ideal_len,
+                                k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode,
+                                face_tracking=face_tracking)
+    links = [str(Path(p)) for p in outs]
+    return links, f"Gerados: {len(links)} arquivo(s)."
+
+def run_creative(segs, video_file, out_subdir, min_len, max_len, ideal_len, minb, maxb, k, gap, pad, ar_mode, face_tracking):
+    if not segs:
+        return [], "Transcreva antes de cortar."
+    workdir = SPACE_OUT / (out_subdir or "cortes")
+    outs = generate_creative_cuts(video_file, segs, str(workdir),
+                                  min_len=min_len, max_len=max_len, ideal_len=ideal_len,
+                                  min_blocks=minb, max_blocks=maxb,
+                                  k=k, gap_threshold=gap, pad=pad, ar_mode=ar_mode,
+                                  face_tracking=face_tracking)
+    links = [str(Path(p)) for p in outs]
+    return links, f"Gerados: {len(links)} arquivo(s)."
+
+css = """
+/* Design Tokens */
+:root {
+    --neon: #39FF14;
+    --txt: #0a0a0a;
+    --muted: #6b7280;
+    --line: #e5e7eb;
+    --bg: #ffffff;
+}
+
+/* Global Styles */
+.gradio-container {
+    font-family: 'Manrope', system-ui, -apple-system, sans-serif !important;
+    background: linear-gradient(135deg, rgba(57,255,20,0.03) 0%, rgba(255,255,255,1) 100%);
+    background-attachment: fixed;
+}
+
+/* Headers */
+.gradio-container h1, .gradio-container h2, .gradio-container h3 {
+    font-weight: 800 !important;
+    letter-spacing: -0.3px !important;
+    color: var(--txt) !important;
+}
+
+.gradio-container h1 {
+    font-size: clamp(28px, 5vw, 46px) !important;
+    margin-bottom: 8px !important;
+}
+
+.gradio-container .gr-prose p {
+    color: var(--muted) !important;
+    line-height: 1.65 !important;
+    font-size: 16px !important;
+}
+
+/* Buttons */
+.gradio-container button.primary {
+    background: var(--neon) !important;
+    color: #000 !important;
+    border: none !important;
+    border-radius: 10px !important;
+    font-weight: 800 !important;
+    padding: 12px 20px !important;
+    box-shadow: 0 2px 0 rgba(0,0,0,0.12), 0 10px 30px rgba(57,255,20,0.18) !important;
+    transition: all 0.2s ease !important;
+}
+
+.gradio-container button.primary:hover {
+    transform: translateY(-1px) !important;
+    filter: saturate(1.03) !important;
+}
+
+.gradio-container button:not(.primary) {
+    background: #fff !important;
+    border: 1px solid var(--line) !important;
+    border-radius: 10px !important;
+    color: var(--txt) !important;
+    font-weight: 600 !important;
+}
+
+/* Inputs, Textareas, Dropdowns */
+.gradio-container input, .gradio-container textarea, .gradio-container select, .gradio-container .wrap {
+    border: 1px solid var(--line) !important;
+    border-radius: 12px !important;
+    background: #fff !important;
+    transition: all 0.2s ease !important;
+}
+
+.gradio-container input:focus, .gradio-container textarea:focus, .gradio-container select:focus {
+    border-color: #cbd5e1 !important;
+    box-shadow: 0 0 0 3px rgba(57,255,20,0.16) !important;
+}
+
+/* Cards/Panels */
+.gradio-container .block {
+    border: 1px solid var(--line) !important;
+    border-radius: 16px !important;
+    background: #fff !important;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.06) !important;
+    transition: all 0.2s ease !important;
+}
+
+.gradio-container .block:hover {
+    box-shadow: 0 6px 16px rgba(0,0,0,0.08) !important;
+}
+
+/* Tabs */
+.gradio-container .tabs {
+    border-radius: 12px !important;
+}
+
+.gradio-container .tab-nav button {
+    border-radius: 8px !important;
+    font-weight: 600 !important;
+}
+
+.gradio-container .tab-nav button.selected {
+    background: var(--neon) !important;
+    color: #000 !important;
+}
+
+/* Checkboxes */
+.gradio-container input[type="checkbox"]:checked {
+    background: var(--neon) !important;
+    border-color: var(--neon) !important;
+}
+
+/* Video player */
+.gradio-container video {
+    border-radius: 12px !important;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.1) !important;
+}
+
+/* File upload areas */
+.gradio-container .upload-container {
+    border: 2px dashed var(--line) !important;
+    border-radius: 12px !important;
+    background: #fafafa !important;
+}
+
+/* Number inputs */
+.gradio-container input[type="number"] {
+    font-weight: 600 !important;
+}
+
+/* Labels */
+.gradio-container label {
+    font-weight: 600 !important;
+    color: var(--txt) !important;
+}
+
+/* Container spacing */
+.gradio-container .contain {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+"""
+
+with gr.Blocks(title="Editor de cortes automático", css=css) as demo:
+    gr.HTML("""
+    <link href="https://fonts.googleapis.com/css2?family=Manrope:wght@400;600;700;800&display=swap" rel="stylesheet">
+    <div style="text-align: center; padding: 24px 0 16px;">
+        <div style="display: inline-flex; align-items: center; gap: 8px; margin-bottom: 12px;">
+            <div style="width: 12px; height: 12px; border-radius: 50%; background: #39FF14; box-shadow: 0 0 20px rgba(57,255,20,0.4);"></div>
+            <h1 style="margin: 0; font-weight: 800; letter-spacing: -0.4px;">Editor de Cortes Automático</h1>
+        </div>
+        <p style="color: #6b7280; max-width: 720px; margin: 0 auto; line-height: 1.65;">
+            Gere cortes criativos ou trechos a partir de qualquer vídeo com <strong>rastreamento facial inteligente</strong>.
+        </p>
+    </div>
+    """)
     
-    def get_primary_face(self, faces: List[FaceBox], frame_width: int, frame_height: int) -> Optional[FaceBox]:
-        """
-        Seleciona o rosto principal (mais central e maior).
-        
-        Args:
-            faces: Lista de rostos detectados
-            frame_width: Largura do frame
-            frame_height: Altura do frame
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.HTML("""<div style="background: linear-gradient(135deg, #f9fafb 0%, #fff 100%); 
+                      padding: 16px; border-radius: 16px; border: 1px solid #e5e7eb; margin-bottom: 16px;">
+                      <div style="font-weight: 700; color: #0a0a0a; margin-bottom: 8px;">🎬 Entrada</div>
+                      <p style="color: #6b7280; font-size: 14px; margin: 0;">Envie seu vídeo e configure as opções</p>
+                      </div>""")
             
-        Returns:
-            FaceBox do rosto principal ou None
-        """
-        if not faces:
-            return None
-        
-        # Se só há um rosto, retorna ele
-        if len(faces) == 1:
-            return faces[0]
-        
-        # Calcula score para cada rosto (baseado em tamanho e centralização)
-        frame_center_x = frame_width / 2
-        frame_center_y = frame_height / 2
-        
-        scored_faces = []
-        for face in faces:
-            # Score por tamanho (normalizado)
-            size_score = (face.w * face.h) / (frame_width * frame_height)
+            video = gr.Video(label="Vídeo de entrada", interactive=True)
             
-            # Score por distância ao centro (normalizado e invertido)
-            dx = abs(face.center_x - frame_center_x) / frame_width
-            dy = abs(face.center_y - frame_center_y) / frame_height
-            center_score = 1 - (dx + dy) / 2
+            with gr.Row():
+                model_size = gr.Dropdown(
+                    choices=["tiny","base","small","medium"], 
+                    value="small", 
+                    label="Modelo Whisper",
+                    info="Quanto maior, mais preciso mas mais lento"
+                )
+                out_subdir = gr.Textbox(
+                    label="Subpasta de saída", 
+                    value="editor_de_cortes_automatico",
+                    info="Nome da pasta onde os cortes serão salvos"
+                )
             
-            # Score final (peso maior para centralização)
-            total_score = (size_score * 0.3) + (center_score * 0.7)
-            scored_faces.append((total_score, face))
-        
-        # Retorna o rosto com maior score
-        scored_faces.sort(reverse=True, key=lambda x: x[0])
-        return scored_faces[0][1]
-    
-    def calculate_smart_crop(
-        self, 
-        frame: np.ndarray, 
-        target_width: int, 
-        target_height: int
-    ) -> Tuple[int, int, int, int]:
-        """
-        Calcula coordenadas de crop inteligente baseado em detecção facial.
+            transcribe_btn = gr.Button("🎙️ 1) Transcrever Vídeo", variant="primary", size="lg")
+            transcript_preview = gr.Textbox(label="Status / Prévia da Transcrição", lines=10)
         
-        Args:
-            frame: Frame do vídeo
-            target_width: Largura desejada
-            target_height: Altura desejada
+        with gr.Column(scale=1):
+            gr.HTML("""<div style="background: linear-gradient(135deg, rgba(57,255,20,0.08) 0%, rgba(57,255,20,0.02) 100%); 
+                      padding: 16px; border-radius: 16px; border: 1px solid #e5e7eb; margin-bottom: 16px;">
+                      <div style="font-weight: 700; color: #0a0a0a; margin-bottom: 8px;">⚙️ Configurações de Corte</div>
+                      <p style="color: #6b7280; font-size: 14px; margin: 0;">Escolha entre cortes simples ou criativos</p>
+                      </div>""")
             
-        Returns:
-            Tupla (x, y, w, h) das coordenadas de crop
-        """
-        frame_h, frame_w = frame.shape[:2]
-        
-        # Detecta rostos
-        faces = self.detect_faces(frame)
-        primary_face = self.get_primary_face(faces, frame_w, frame_h)
-        
-        # Calcula aspect ratio alvo
-        target_ar = target_width / target_height
-        frame_ar = frame_w / frame_h
-        
-        if primary_face:
-            # Crop baseado no rosto detectado
-            face_center_x = primary_face.center_x
-            face_center_y = primary_face.center_y
+            with gr.Tab("✂️ Cortes Simples"):
+                gr.HTML("""<p style="color: #6b7280; font-size: 14px; margin-bottom: 16px;">
+                        Cortes lineares e contínuos do vídeo original</p>""")
+                
+                with gr.Row():
+                    min_len = gr.Number(value=600, label="⏱️ Duração mínima (s)", info="Mínimo de segundos por corte")
+                    max_len = gr.Number(value=900, label="⏱️ Duração máxima (s)", info="Máximo de segundos por corte")
+                
+                with gr.Row():
+                    ideal_len = gr.Number(value=900, label="🎯 Duração ideal (s)", info="Tamanho preferencial")
+                    k = gr.Number(value=2, label="📊 Quantidade de cortes", info="Quantos vídeos gerar")
+                
+                with gr.Row():
+                    gap = gr.Number(value=0.60, label="Gap (s)", info="Intervalo entre frases")
+                    pad = gr.Number(value=0.08, label="Pad (s)", info="Margem extra")
+                
+                ar_mode = gr.Dropdown(
+                    choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
+                    value="Original", 
+                    label="📐 Formato de vídeo"
+                )
+                
+                face_tracking = gr.Checkbox(
+                    label="👤 Ativar rastreamento facial no crop",
+                    value=True,
+                    info="Detecta e centraliza rostos automaticamente ao redimensionar"
+                )
+                
+                gr.HTML("""<div style="background: #ecfdf5; padding: 12px; border-radius: 10px; border: 1px solid #a7f3d0; margin: 12px 0;">
+                          <strong style="color: #065f46;">💡 Dica:</strong>
+                          <p style="color: #047857; font-size: 13px; margin: 6px 0 0;">
+                          O rastreamento facial mantém a pessoa sempre centralizada ao cortar para 9:16 ou 1:1
+                          </p>
+                          </div>""")
+                
+                go_linear = gr.Button("🚀 2) Gerar Cortes Simples", variant="primary")
+                out_linear = gr.Files(label="📦 Arquivos gerados (simples)")
+                status_linear = gr.Textbox(label="Status", lines=2)
             
-            # Ajusta centro baseado no rosto com margens de segurança
-            if target_ar < frame_ar:  # Crop vertical (9:16, 1:1, 4:5)
-                crop_w = int(frame_h * target_ar)
-                crop_h = frame_h
+            with gr.Tab("🎨 Cortes Criativos"):
+                gr.HTML("""<p style="color: #6b7280; font-size: 14px; margin-bottom: 16px;">
+                        Montagens com múltiplos blocos e transições dinâmicas</p>""")
                 
-                # Centraliza horizontalmente no rosto
-                crop_x = max(0, min(face_center_x - crop_w // 2, frame_w - crop_w))
-                crop_y = 0
-            else:  # Crop horizontal ou quadrado
-                crop_w = frame_w
-                crop_h = int(frame_w / target_ar)
+                with gr.Row():
+                    minb = gr.Number(value=3, label="🧩 Blocos mínimos", info="Mínimo de segmentos por vídeo")
+                    maxb = gr.Number(value=8, label="🧩 Blocos máximos", info="Máximo de segmentos por vídeo")
                 
-                # Centraliza verticalmente no rosto (com leve offset para cima)
-                offset = int(crop_h * 0.1)  # 10% offset para dar espaço acima da cabeça
-                crop_x = 0
-                crop_y = max(0, min(face_center_y - crop_h // 2 - offset, frame_h - crop_h))
-        else:
-            # Fallback: crop centralizado tradicional
-            if target_ar < frame_ar:  # Mais alto que largo
-                crop_w = int(frame_h * target_ar)
-                crop_h = frame_h
-                crop_x = (frame_w - crop_w) // 2
-                crop_y = 0
-            else:  # Mais largo que alto
-                crop_w = frame_w
-                crop_h = int(frame_w / target_ar)
-                crop_x = 0
-                crop_y = (frame_h - crop_h) // 2
-        
-        return (crop_x, crop_y, crop_w, crop_h)
+                with gr.Row():
+                    k2 = gr.Number(value=2, label="📊 Quantidade de cortes")
+                    gap2 = gr.Number(value=0.60, label="Gap (s)")
+                
+                with gr.Row():
+                    pad2 = gr.Number(value=0.08, label="Pad (s)")
+                    ar_mode2 = gr.Dropdown(
+                        choices=["Original","Vertical 9:16","Quadrado 1:1","Retrato 4:5"], 
+                        value="Original", 
+                        label="📐 Formato"
+                    )
+                
+                face_tracking2 = gr.Checkbox(
+                    label="👤 Ativar rastreamento facial no crop",
+                    value=True,
+                    info="Detecta e centraliza rostos automaticamente"
+                )
+                
+                gr.HTML("""<div style="background: #fef3c7; padding: 12px; border-radius: 10px; border: 1px solid #fcd34d; margin: 12px 0;">
+                          <strong style="color: #92400e;">⚡ Cortes Criativos:</strong>
+                          <p style="color: #78350f; font-size: 13px; margin: 6px 0 0;">
+                          Combina diferentes momentos do vídeo em uma montagem dinâmica
+                          </p>
+                          </div>""")
+                
+                go_creative = gr.Button("🎬 3) Gerar Cortes Criativos", variant="primary")
+                out_creative = gr.Files(label="📦 Arquivos gerados (criativos)")
+                status_creative = gr.Textbox(label="Status", lines=2)
 
+    segs_state = gr.State([])
 
-def apply_smart_crop_to_video(
-    input_path: str,
-    output_path: str,
-    target_width: int,
-    target_height: int,
-    sample_frames: int = 10
-) -> bool:
-    """
-    Aplica crop inteligente com rastreamento facial a um vídeo.
-    
-    Args:
-        input_path: Caminho do vídeo de entrada
-        output_path: Caminho do vídeo de saída
-        target_width: Largura desejada
-        target_height: Altura desejada
-        sample_frames: Número de frames para amostragem (para calcular posição média)
-        
-    Returns:
-        True se sucesso, False caso contrário
-    """
-    tracker = FaceTracker()
-    
-    # Abre vídeo de entrada
-    cap = cv2.VideoCapture(input_path)
-    if not cap.isOpened():
-        print(f"❌ Erro ao abrir vídeo: {input_path}")
-        return False
-    
-    # Propriedades do vídeo
-    fps = int(cap.get(cv2.CAP_PROP_FPS))
-    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    
-    # Amostra alguns frames para determinar melhor posição de crop
-    sample_positions = []
-    frame_indices = np.linspace(0, frame_count - 1, min(sample_frames, frame_count), dtype=int)
-    
-    for idx in frame_indices:
-        cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
-        ret, frame = cap.read()
-        if ret:
-            crop_coords = tracker.calculate_smart_crop(frame, target_width, target_height)
-            sample_positions.append(crop_coords)
-    
-    # Calcula posição média de crop (suaviza movimento)
-    if sample_positions:
-        avg_x = int(np.median([p[0] for p in sample_positions]))
-        avg_y = int(np.median([p[1] for p in sample_positions]))
-        crop_w = sample_positions[0][2]
-        crop_h = sample_positions[0][3]
-        final_crop = (avg_x, avg_y, crop_w, crop_h)
-    else:
-        # Fallback
-        frame_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        frame_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        target_ar = target_width / target_height
-        frame_ar = frame_w / frame_h
-        
-        if target_ar < frame_ar:
-            crop_w = int(frame_h * target_ar)
-            crop_h = frame_h
-            final_crop = ((frame_w - crop_w) // 2, 0, crop_w, crop_h)
-        else:
-            crop_w = frame_w
-            crop_h = int(frame_w / target_ar)
-            final_crop = (0, (frame_h - crop_h) // 2, crop_w, crop_h)
-    
-    # Reseta para início do vídeo
-    cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-    
-    # Configura writer de saída
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (target_width, target_height))
-    
-    if not out.isOpened():
-        print(f"❌ Erro ao criar vídeo de saída: {output_path}")
-        cap.release()
-        return False
-    
-    # Processa cada frame
-    print(f"🎬 Processando vídeo com crop inteligente: {final_crop}")
-    frame_num = 0
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-        
-        # Aplica crop
-        x, y, w, h = final_crop
-        cropped = frame[y:y+h, x:x+w]
-        
-        # Redimensiona para tamanho final
-        resized = cv2.resize(cropped, (target_width, target_height), interpolation=cv2.INTER_LANCZOS4)
-        
-        # Escreve frame
-        out.write(resized)
-        frame_num += 1
-        
-        # Progress
-        if frame_num % 30 == 0:
-            progress = (frame_num / frame_count) * 100
-            print(f"  Progresso: {progress:.1f}% ({frame_num}/{frame_count} frames)")
-    
-    # Finaliza
-    cap.release()
-    out.release()
-    
-    print(f"✓ Vídeo processado com sucesso: {output_path}")
-    return True
+    transcribe_btn.click(
+        do_transcribe,
+        inputs=[video, model_size],
+        outputs=[segs_state, transcript_preview],
+    )
 
+    go_linear.click(
+        run_linear,
+        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, k, gap, pad, ar_mode, face_tracking],
+        outputs=[out_linear, status_linear],
+    )
 
-def get_aspect_ratio_dimensions(ar_mode: str, base_height: int = 1080) -> Tuple[int, int]:
-    """
-    Retorna dimensões (width, height) baseado no modo de aspect ratio.
-    
-    Args:
-        ar_mode: Modo do aspect ratio ("Original", "Vertical 9:16", "Quadrado 1:1", "Retrato 4:5")
-        base_height: Altura base para cálculos (padrão: 1080p)
-        
-    Returns:
-        Tupla (width, height)
-    """
-    ar_map = {
-        "Original": None,  # Mantém original
-        "Vertical 9:16": (9, 16),
-        "Quadrado 1:1": (1, 1),
-        "Retrato 4:5": (4, 5),
-    }
-    
-    if ar_mode not in ar_map or ar_map[ar_mode] is None:
-        return None
-    
-    w_ratio, h_ratio = ar_map[ar_mode]
+    go_creative.click(
+        run_creative,
+        inputs=[segs_state, video, out_subdir, min_len, max_len, ideal_len, minb, maxb, k2, gap2, pad2, ar_mode2, face_tracking2],
+        outputs=[out_creative, status_creative],
+    )
     
-    # Calcula width baseado na altura
-    width = int((base_height / h_ratio) * w_ratio)
+    gr.HTML("""
+    <div style="margin-top: 32px; padding: 20px; background: #f9fafb; border-radius: 16px; border: 1px solid #e5e7eb;">
+        <h3 style="margin: 0 0 12px; font-weight: 700; color: #0a0a0a;">💡 Como funciona o rastreamento facial</h3>
+        <ul style="color: #6b7280; line-height: 1.65; padding-left: 20px; margin: 0;">
+            <li><strong>Detecção automática:</strong> O sistema identifica rostos em cada frame do vídeo</li>
+            <li><strong>Crop inteligente:</strong> Ao redimensionar para 9:16 ou 1:1, mantém o rosto centralizado</li>
+            <li><strong>Múltiplos rostos:</strong> Se houver várias pessoas, prioriza o rosto mais central/próximo</li>
+            <li><strong>Fallback:</strong> Se nenhum rosto for detectado, usa crop centralizado tradicional</li>
+        </ul>
+    </div>
+    """)
     
-    return (width, base_height)
+    gr.HTML("""
+    <footer style="margin-top: 40px; padding: 24px 0; border-top: 1px solid #e5e7eb; text-align: center;">
+        <div style="display: inline-flex; align-items: center; gap: 8px; margin-bottom: 8px;">
+            <div style="width: 10px; height: 10px; border-radius: 50%; background: #39FF14;"></div>
+            <span style="font-weight: 700; color: #0a0a0a;">Leicam · Tech</span>
+        </div>
+        <p style="color: #6b7280; font-size: 13px; margin: 0;">
+            Ferramentas práticas para produção de conteúdo
+        </p>
+    </footer>
+    """)
 
-
-# Exemplo de uso:
 if __name__ == "__main__":
-    # Teste básico
-    tracker = FaceTracker()
-    
-    # Simula um frame de teste
-    test_frame = np.zeros((1080, 1920, 3), dtype=np.uint8)
-    
-    # Detecta rostos
-    faces = tracker.detect_faces(test_frame)
-    print(f"Rostos detectados: {len(faces)}")
-    
-    # Calcula crop para 9:16
-    crop_coords = tracker.calculate_smart_crop(test_frame, 1080, 1920)
-    print(f"Coordenadas de crop (9:16): {crop_coords}")
-    
-    # Testa diferentes aspect ratios
-    for ar_mode in ["Vertical 9:16", "Quadrado 1:1", "Retrato 4:5"]:
-        dims = get_aspect_ratio_dimensions(ar_mode)
-        print(f"{ar_mode}: {dims}")
+    demo.launch()