Upload 16 files

backend/core/engine.py

@@ -141,40 +141,77 @@ class VideoProcessor:
         self.video_path, self.output_dir = video_path, output_dir
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
-    def extract_keyframes(self, max_frames: int = 50) -> List[Frame]:
+    def extract_keyframes(self, max_frames: int = 30) -> List[Frame]:
+        """
+        Extraction intelligente de keyframes avec échantillonnage adaptatif.
+        - Vidéos courtes (<2min) : 1 frame toutes les 3-4s
+        - Vidéos moyennes (2-10min) : 1 frame toutes les 10-15s
+        - Vidéos longues (>10min) : 1 frame toutes les 20-30s
+        """
         try:
             from decord import VideoReader, cpu
             vr = VideoReader(str(self.video_path), ctx=cpu(0))
             total = len(vr)
-            step = max(1, total // max_frames)
-            indices = range(0, total, step)[:max_frames]
-            frames_data = vr.get_batch(indices).asnumpy()
             fps = vr.get_avg_fps()
+            duration_seconds = total / fps
+
+            # Échantillonnage adaptatif basé sur la durée
+            if duration_seconds < 120:  # < 2 minutes
+                target_interval = 3  # 1 frame toutes les 3 secondes
+            elif duration_seconds < 600:  # 2-10 minutes
+                target_interval = 12  # 1 frame toutes les 12 secondes
+            else:  # > 10 minutes
+                target_interval = 25  # 1 frame toutes les 25 secondes
+
+            # Calculer le nombre de frames optimal
+            optimal_frames = min(int(duration_seconds / target_interval), max_frames)
+            optimal_frames = max(optimal_frames, 10)  # Minimum 10 frames
+
+            step = max(1, total // optimal_frames)
+            indices = range(0, total, step)[:optimal_frames]
+            frames_data = vr.get_batch(indices).asnumpy()
+
             extracted = []
             for i, idx in enumerate(indices):
                 img = cv2.cvtColor(frames_data[i], cv2.COLOR_RGB2BGR)
                 ts = idx / fps
                 p = self.output_dir / f"f_{idx}.jpg"
-                cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 70])
                 extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
+
+            logger.info(f"✅ Extraction adaptative : {len(extracted)} frames pour {duration_seconds:.1f}s de vidéo (1 frame/{target_interval}s)")
             return extracted
         except Exception as e:
             logger.warning(f"Decord failed, fallback to CV2: {e}")
             cap = cv2.VideoCapture(str(self.video_path))
             fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
             total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1000
-            step = max(1, total // max_frames)
+            duration_seconds = total / fps
+
+            # Même logique adaptative pour le fallback CV2
+            if duration_seconds < 120:
+                target_interval = 3
+            elif duration_seconds < 600:
+                target_interval = 12
+            else:
+                target_interval = 25
+
+            optimal_frames = min(int(duration_seconds / target_interval), max_frames)
+            optimal_frames = max(optimal_frames, 10)
+
+            step = max(1, total // optimal_frames)
             extracted = []
             for idx in range(0, total, step):
-                if len(extracted) >= max_frames: break
+                if len(extracted) >= optimal_frames: break
                 cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
                 ret, img = cap.read()
                 if ret:
                     ts = idx / fps
                     p = self.output_dir / f"f_{idx}.jpg"
-                    cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 85])
+                    cv2.imwrite(str(p), img, [cv2.IMWRITE_JPEG_QUALITY, 70])
                     extracted.append(Frame(path=p, timestamp=ts, metrics=self.get_frame_metrics(img)))
             cap.release()
+            logger.info(f"✅ Extraction CV2 adaptative : {len(extracted)} frames pour {duration_seconds:.1f}s de vidéo")
             return extracted
 
 class AudioProcessor:
@@ -183,7 +220,8 @@ class AudioProcessor:
         if WHISPER_AVAILABLE and self.model is None:
             try:
                 device = "cuda" if torch.cuda.is_available() else "cpu"
-                self.model = WhisperModel("base", device=device, compute_type="int8")
+                # Utiliser tiny au lieu de base pour plus de rapidité
+                self.model = WhisperModel("tiny", device=device, compute_type="int8")
             except: pass
     def transcribe(self, p: Path) -> str:
         self.initialize()
@@ -273,13 +311,13 @@ class ZenithAnalyzer:
 
                 if self.yolo:
                     all_paths = [str(f.path) for f in frames]
-                    batch_size = 10
+                    batch_size = 20
                     for i in range(0, len(all_paths), batch_size):
                         batch = all_paths[i:i+batch_size]
-                        results = await loop.run_in_executor(executor, lambda: self.yolo(batch, verbose=False, imgsz=320, stream=False))
+                        results = await loop.run_in_executor(executor, lambda: self.yolo(batch, verbose=False, imgsz=256, stream=False))
                         for j, res in enumerate(results):
                             idx = i + j
-                            objs = [res.names[int(b.cls[0])] for b in res.boxes if b.conf > 0.25]
+                            objs = [res.names[int(b.cls[0])] for b in res.boxes if b.conf > 0.35]
                             ambiance = f"Ambiance: {'Sombre' if frames[idx].metrics['brightness'] < 50 else 'Lumineuse'}"
                             frames[idx].vision_content = f"{ambiance}, Objets: " + ", ".join([f"{v}x {k}" for k,v in Counter(objs).items()])
 
@@ -307,11 +345,20 @@ class ZenithAnalyzer:
 
         Produis un rapport TECHNIQUE, FACTUEL et STRUCTURÉ en Markdown."""
 
-        # Encodage parallèle des images
-        selected_frames = [frames[i] for i in range(0, len(frames), max(1, len(frames)//10))][:10]
+        # Encodage parallèle des images - Sélection intelligente et équilibrée
+        # On prend des images réparties uniformément sur toute la durée
+        num_images_to_send = min(8, len(frames))  # Max 8 images pour l'IA
+        if len(frames) > 0:
+            step = max(1, len(frames) // num_images_to_send)
+            selected_frames = [frames[i] for i in range(0, len(frames), step)][:num_images_to_send]
+        else:
+            selected_frames = []
+
         def encode_f(f):
             img = cv2.imread(str(f.path))
-            _, buf = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 70])
+            # Redimensionner pour réduire la taille tout en gardant la qualité visuelle
+            img = cv2.resize(img, (800, 450), interpolation=cv2.INTER_AREA)
+            _, buf = cv2.imencode('.jpg', img, [cv2.IMWRITE_JPEG_QUALITY, 65])
             return {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64.b64encode(buf).decode()}"}}
 
         with concurrent.futures.ThreadPoolExecutor() as executor: