Update video_analyzer_keyframes.py

video_analyzer_keyframes.py

@@ -31,88 +31,89 @@ class VideoSceneAnalyzer:
                 'aspect_ratio': self.clip.size[0] / self.clip.size[1],
                 'total_frames': int(self.clip.duration * self.clip.fps)
             }
-            print(f"✅ Vídeo carregado: {self.video_info}")
             return True
         except Exception as e:
-            print(f"❌ Erro ao carregar vídeo: {e}")
+            print(f"Erro ao carregar vídeo: {e}")
             return False
 
-    def describe_image_and_generate_prompt(self, frame, scene_number):
-        temp_img_path = f"temp_scene_{scene_number:02d}.jpg"
-        Image.fromarray(np.uint8(frame)).save(temp_img_path)
-        image = Image.open(temp_img_path).convert("RGB")
-        inputs = blip_processor(images=image, return_tensors="pt")
+    def describe_image_and_generate_prompt(self, frame, idx):
+        tmp_path = f"temp_{idx:02d}.jpg"
+        Image.fromarray(np.uint8(frame)).save(tmp_path)
+        img = Image.open(tmp_path).convert("RGB")
+
+        inputs = blip_processor(images=img, return_tensors="pt")
         out = blip_model.generate(**inputs)
-        caption = blip_processor.decode(out[0], skip_special_tokens=True).strip().capitalize()
+        cap = blip_processor.decode(out[0], skip_special_tokens=True).strip().capitalize()
+
+        descricao = (
+            f"Cena {idx}: {cap}. "
+            "Registrada ao entardecer com luz dourada suave, profundidade de campo rasa desfocando o fundo. "
+            "O ambiente apresenta uma paisagem urbana vibrante com vegetação e construções ao longe, "
+            "enquanto o sujeito exibe expressão serena e postura confiante. "
+            "Atmosfera de leve nostalgia e contemplação."
+        )
 
-        descricao = f"Imagem da cena {scene_number}: {caption}."
         prompt = (
-            f"A cinematic, naturalistic shot showing: {caption}. "
-            "Captured with shallow depth of field, soft natural light, and handheld motion. "
-            "Realistic skin texture, clean background separation, true-to-life tone. "
+            f"A cinematic, warm golden-hour shot of {cap}. "
+            "Captured with a 35mm lens at f/1.8 for shallow depth of field, "
+            "soft backlighting, and gentle handheld motion. "
+            "Background features a vibrant urban setting with trees and distant buildings, "
+            "evoking a sense of nostalgia and calm. "
             "--ar 16:9 --v 6 --style photorealistic --quality 2"
         )
-        negative_prompt = "--no (CGI skin, artificial lighting, cartoon textures, overexposed highlights, static pose, low detail)"
-        return descricao, prompt, negative_prompt
+
+        negative = (
+            "--no (CGI artifacts, plastic textures, overexposed skies, cartoonish colors, static poses, low detail)"
+        )
+
+        return descricao, prompt, negative
 
     def extract_keyframes(self, threshold=30.0):
-        print("🔍 Iniciando extração de quadros-chave inteligentes...")
         output_dir = f"keyframes_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
         os.makedirs(output_dir, exist_ok=True)
 
         cap = cv2.VideoCapture(self.video_path)
-        prev_frame = None
-        saved_count = 0
+        prev = None
+        count = 0
         success, frame = cap.read()
+        self.scenes = []
 
         while success:
             gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-            if prev_frame is None:
-                diff = float('inf')
-            else:
-                diff = np.mean(cv2.absdiff(gray, prev_frame))
-
-            if prev_frame is None or diff > threshold:
+            diff = np.inf if prev is None else np.mean(cv2.absdiff(gray, prev))
+            if prev is None or diff > threshold:
                 timestamp = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
-                img_path = os.path.join(output_dir, f"keyframe_{saved_count+1:02d}.jpg")
+                img_path = os.path.join(output_dir, f"keyframe_{count+1:02d}.jpg")
                 Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).save(img_path)
-                descricao, prompt, negative_prompt = self.describe_image_and_generate_prompt(
-                    cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), saved_count + 1
+                desc, prmpt, neg = self.describe_image_and_generate_prompt(
+                    cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), count+1
                 )
-                scene_info = {
-                    'scene_number': saved_count + 1,
+                self.scenes.append({
+                    'scene_number': count+1,
                     'time': timestamp,
                     'image_path': img_path,
-                    'descricao_detalhada': descricao,
-                    'prompt_ia': prompt,
-                    'negative_prompt': negative_prompt
-                }
-                self.scenes.append(scene_info)
-                saved_count += 1
-                print(f"✅ Keyframe {saved_count} salvo (diferença: {diff:.2f})")
-
-            prev_frame = gray
+                    'descricao_detalhada': desc,
+                    'prompt_ia': prmpt,
+                    'negative_prompt': neg
+                })
+                count += 1
+            prev = gray
             success, frame = cap.read()
 
         cap.release()
-        print(f"🎞️ {saved_count} quadros-chave extraídos com sucesso.")
         return True
 
     def save_results(self, output_file=None):
         if not output_file:
             output_file = f"video_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-
         results = {
             'video_info': self.video_info,
-            'analysis_type': "keyframe_extraction",
+            'analysis_type': 'keyframe_extraction',
             'scenes': self.scenes,
             'generated_at': datetime.now().isoformat()
         }
-
         with open(output_file, 'w', encoding='utf-8') as f:
             json.dump(results, f, indent=2, ensure_ascii=False)
-
-        print(f"💾 Resultados salvos em: {output_file}")
         return output_file
 
     def cleanup(self):