deploy: batch update 5 file(s)

alert_routes.py

@@ -45,8 +45,12 @@ def alert_stream():
         event: heartbeat
         data: {"time": 1234567890}
     """
-    engine = get_alert_engine()
-    subscriber_queue = engine.subscribe()
+    try:
+        engine = get_alert_engine()
+        subscriber_queue = engine.subscribe()
+    except Exception as e:
+        logger.error(f"Failed to initialise alert engine / subscribe: {e}")
+        return jsonify({'error': 'Alert engine unavailable', 'detail': str(e)}), 503
     
     def event_stream():
         try:

app.py

@@ -3691,10 +3691,27 @@ def process_live_frame():
         if 'frame' not in request.files:
             return jsonify({'error': 'No frame provided'}), 400
 
+        # Wait for heavy models to finish loading (max 120s)
+        if not _init_ready.is_set():
+            logger.info("⏳ Waiting for background init before processing live frame...")
+            _init_ready.wait(timeout=120)
+
         camera_id = request.form.get('camera_id', 'webcam_01')
 
         from live_stream_processor import get_live_processor
-        processor = get_live_processor(camera_id)
+
+        # Share pre-loaded models from the main pipeline to avoid loading them twice
+        shared_obj_det = None
+        shared_beh_ana = None
+        if db_video_service:
+            shared_obj_det = getattr(db_video_service, 'object_detector', None)
+            shared_beh_ana = getattr(db_video_service, 'behavior_analyzer', None)
+
+        processor = get_live_processor(
+            camera_id,
+            object_detector=shared_obj_det,
+            behavior_analyzer=shared_beh_ana,
+        )
 
         # Decode uploaded JPEG into OpenCV frame
         import cv2
@@ -3735,9 +3752,16 @@ def live_video_feed(camera_id):
     """Video feed endpoint for live stream - streams frames directly"""
     logger.info(f"🎬 ===== VIDEO FEED REQUESTED ===== camera_id: {camera_id}")
     try:
+        if not _init_ready.is_set():
+            _init_ready.wait(timeout=120)
+
         from live_stream_processor import get_live_processor
-        
-        processor = get_live_processor(camera_id)
+
+        shared_obj_det = getattr(db_video_service, 'object_detector', None) if db_video_service else None
+        shared_beh_ana = getattr(db_video_service, 'behavior_analyzer', None) if db_video_service else None
+        processor = get_live_processor(camera_id,
+                                       object_detector=shared_obj_det,
+                                       behavior_analyzer=shared_beh_ana)
         source_type = getattr(processor, 'source_type', '')
         camera_index = getattr(processor, 'camera_index', 0)
         stream_url = getattr(processor, 'stream_url', None)

behavior_analysis/action_recognition.py

@@ -139,7 +139,7 @@ ACTION_LABELS = {
 # Per-action confidence thresholds
 ACTION_CONFIDENCE_THRESHOLDS = {
     "fighting": 0.5,
-    "accident": 0.80,
+    "accident": 0.65,
     "climbing": 0.8
 }
 

live_stream_processor.py

@@ -42,13 +42,16 @@ logger = logging.getLogger(__name__)
 class LiveStreamProcessor:
     """Process live video streams with DetectifAI pipeline"""
     
-    def __init__(self, config: VideoProcessingConfig = None, camera_id: str = "webcam_01"):
+    def __init__(self, config: VideoProcessingConfig = None, camera_id: str = "webcam_01",
+                 object_detector=None, behavior_analyzer=None):
         """
         Initialize live stream processor
         
         Args:
             config: VideoProcessingConfig object
             camera_id: Unique identifier for the camera/stream
+            object_detector: Pre-loaded ObjectDetector (shared from main pipeline)
+            behavior_analyzer: Pre-loaded BehaviorAnalysisIntegrator (shared)
         """
         self.config = config or get_security_focused_config()
         self.camera_id = camera_id
@@ -60,29 +63,49 @@ class LiveStreamProcessor:
         self.keyframe_interval = 1.0  # Extract keyframe every 1 second
         
         # Initialize database connections
-        self.db_manager = DatabaseManager()
-        self.video_repo = VideoRepository(self.db_manager)
-        self.event_repo = EventRepository(self.db_manager)
-        self.keyframe_repo = KeyframeRepository(self.db_manager)
-        
-        # Initialize processing components
-        self.object_detector = None
-        if self.config.enable_object_detection:
+        try:
+            self.db_manager = DatabaseManager()
+            self.video_repo = VideoRepository(self.db_manager)
+            self.event_repo = EventRepository(self.db_manager)
+            self.keyframe_repo = KeyframeRepository(self.db_manager)
+        except Exception as e:
+            logger.warning(f"⚠️ Database connection failed (live stream continues without DB): {e}")
+            self.db_manager = None
+            self.video_repo = None
+            self.event_repo = None
+            self.keyframe_repo = None
+        
+        # Initialize processing components — prefer shared models from main pipeline
+        self.object_detector = object_detector
+        if self.object_detector is None and self.config.enable_object_detection:
             try:
                 self.object_detector = ObjectDetector(self.config)
-                logger.info("✅ Object detection enabled for live stream")
+                logger.info("✅ Object detection enabled for live stream (new instance)")
             except Exception as e:
                 logger.warning(f"⚠️ Object detection initialization failed: {e}")
                 self.config.enable_object_detection = False
+        elif self.object_detector is not None:
+            logger.info("✅ Object detection enabled for live stream (shared instance)")
         
-        self.behavior_analyzer = None
-        if getattr(self.config, 'enable_behavior_analysis', False):
+        self.behavior_analyzer = behavior_analyzer
+        if self.behavior_analyzer is None and getattr(self.config, 'enable_behavior_analysis', False):
             try:
                 self.behavior_analyzer = BehaviorAnalysisIntegrator(self.config)
-                logger.info("✅ Behavior analysis enabled for live stream")
+                logger.info("✅ Behavior analysis enabled for live stream (new instance)")
             except Exception as e:
                 logger.warning(f"⚠️ Behavior analysis initialization failed: {e}")
                 self.config.enable_behavior_analysis = False
+        elif self.behavior_analyzer is not None:
+            logger.info("✅ Behavior analysis enabled for live stream (shared instance)")
+        
+        # General-purpose YOLO detector for person/car validation (Option B)
+        self.general_detector = None
+        try:
+            from ultralytics import YOLO as _YOLO
+            self.general_detector = _YOLO("yolov8n.pt")
+            logger.info("✅ General YOLO detector (yolov8n) loaded for person/car validation")
+        except Exception as e:
+            logger.warning(f"⚠️ General YOLO detector not available: {e}")
         
         # Initialize facial recognition if enabled
         self.face_recognizer = None
@@ -325,8 +348,28 @@ class LiveStreamProcessor:
                     logger.info(f"🎭 REAL-TIME BEHAVIOR: {len(results['behaviors_detected'])} behavior(s) detected: {', '.join(behavior_types)} (frame {self.frame_count})")
                     
                     # Generate real-time alerts for each behavior
+                    # Option B: validate fight/accident with YOLO person/car detection
                     if self.alert_engine:
                         for beh in results['behaviors_detected']:
+                            btype = beh['behavior_type'].lower()
+                            
+                            # Option B: fight requires 2+ persons close together
+                            if btype in ('fighting', 'fight'):
+                                valid, person_dets = self._validate_fight_with_yolo(processed_frame)
+                                if not valid:
+                                    logger.info(f"🚫 Skipping fight alert — YOLO person check failed")
+                                    continue
+                                # Include person bounding boxes in alert
+                                beh['yolo_context'] = person_dets
+                            
+                            # Option B: accident requires 2+ vehicles close together
+                            elif btype in ('accident', 'road_accident'):
+                                valid, vehicle_dets = self._validate_accident_with_yolo(processed_frame)
+                                if not valid:
+                                    logger.info(f"🚫 Skipping accident alert — YOLO vehicle check failed")
+                                    continue
+                                beh['yolo_context'] = vehicle_dets
+                            
                             alert = self.alert_engine.process_detection(
                                 camera_id=self.camera_id,
                                 detection_class=beh['behavior_type'],
@@ -550,6 +593,112 @@ class LiveStreamProcessor:
             logger.error(traceback.format_exc())
             return None
     
+    def _validate_fight_with_yolo(self, frame: np.ndarray) -> Tuple[bool, List[Dict]]:
+        """
+        Option B: Validate fighting detection by checking for 2+ persons close together.
+        Uses general YOLO (yolov8n) to detect persons (COCO class 0).
+        
+        Returns:
+            (is_valid, person_detections) — True if 2+ persons are near each other
+        """
+        if self.general_detector is None:
+            # No general detector — allow the detection anyway
+            return True, []
+        try:
+            results = self.general_detector(frame, conf=0.35, verbose=False)
+            persons = []
+            for r in results:
+                for box in r.boxes:
+                    cls_id = int(box.cls)
+                    if cls_id == 0:  # person
+                        x1, y1, x2, y2 = box.xyxy[0].tolist()
+                        persons.append({
+                            'class': 'person', 'confidence': float(box.conf),
+                            'bbox': [x1, y1, x2, y2],
+                            'center': ((x1 + x2) / 2, (y1 + y2) / 2)
+                        })
+            if len(persons) < 2:
+                logger.info(f"🚫 Fight validation failed: only {len(persons)} person(s) detected, need 2+")
+                return False, persons
+            # Check proximity: any pair of persons with overlapping/close bounding boxes
+            for i in range(len(persons)):
+                for j in range(i + 1, len(persons)):
+                    if self._boxes_are_close(persons[i]['bbox'], persons[j]['bbox'], frame.shape):
+                        logger.info(f"✅ Fight validation passed: {len(persons)} persons, pair ({i},{j}) close together")
+                        return True, persons
+            logger.info(f"🚫 Fight validation failed: {len(persons)} persons but none close together")
+            return False, persons
+        except Exception as e:
+            logger.warning(f"⚠️ Fight YOLO validation error: {e}")
+            return True, []  # On error, allow detection
+
+    def _validate_accident_with_yolo(self, frame: np.ndarray) -> Tuple[bool, List[Dict]]:
+        """
+        Option B: Validate accident detection by checking for 2+ vehicles close together.
+        Uses general YOLO (yolov8n) to detect cars/trucks/buses (COCO classes 2,5,7).
+        
+        Returns:
+            (is_valid, vehicle_detections) — True if 2+ vehicles are near each other
+        """
+        if self.general_detector is None:
+            return True, []
+        try:
+            results = self.general_detector(frame, conf=0.35, verbose=False)
+            vehicles = []
+            vehicle_classes = {2: 'car', 3: 'motorcycle', 5: 'bus', 7: 'truck'}
+            for r in results:
+                for box in r.boxes:
+                    cls_id = int(box.cls)
+                    if cls_id in vehicle_classes:
+                        x1, y1, x2, y2 = box.xyxy[0].tolist()
+                        vehicles.append({
+                            'class': vehicle_classes[cls_id], 'confidence': float(box.conf),
+                            'bbox': [x1, y1, x2, y2],
+                            'center': ((x1 + x2) / 2, (y1 + y2) / 2)
+                        })
+            if len(vehicles) < 2:
+                logger.info(f"🚫 Accident validation failed: only {len(vehicles)} vehicle(s) detected, need 2+")
+                return False, vehicles
+            for i in range(len(vehicles)):
+                for j in range(i + 1, len(vehicles)):
+                    if self._boxes_are_close(vehicles[i]['bbox'], vehicles[j]['bbox'], frame.shape):
+                        logger.info(f"✅ Accident validation passed: {len(vehicles)} vehicles, pair ({i},{j}) close together")
+                        return True, vehicles
+            logger.info(f"🚫 Accident validation failed: {len(vehicles)} vehicles but none close together")
+            return False, vehicles
+        except Exception as e:
+            logger.warning(f"⚠️ Accident YOLO validation error: {e}")
+            return True, []
+
+    @staticmethod
+    def _boxes_are_close(bbox1: List[float], bbox2: List[float], frame_shape: tuple,
+                         overlap_threshold: float = 0.0, distance_ratio: float = 0.15) -> bool:
+        """
+        Check if two bounding boxes are close/touching/overlapping.
+        
+        Args:
+            bbox1, bbox2: [x1, y1, x2, y2]
+            frame_shape: (height, width, channels)
+            overlap_threshold: IoU threshold (0 = any overlap counts)
+            distance_ratio: max gap as fraction of frame diagonal for 'close'
+        
+        Returns:
+            True if boxes overlap or are very close
+        """
+        x1a, y1a, x2a, y2a = bbox1
+        x1b, y1b, x2b, y2b = bbox2
+        # Check overlap (IoU > 0)
+        ix1 = max(x1a, x1b); iy1 = max(y1a, y1b)
+        ix2 = min(x2a, x2b); iy2 = min(y2a, y2b)
+        if ix2 > ix1 and iy2 > iy1:
+            return True  # Boxes overlap
+        # Check distance between closest edges
+        dx = max(0, max(x1a, x1b) - min(x2a, x2b))
+        dy = max(0, max(y1a, y1b) - min(y2a, y2b))
+        distance = (dx ** 2 + dy ** 2) ** 0.5
+        diag = (frame_shape[0] ** 2 + frame_shape[1] ** 2) ** 0.5
+        return distance < (diag * distance_ratio)
+
     def process_single_frame(self, frame: np.ndarray) -> Dict[str, Any]:
         """
         Process a single frame sent from the browser webcam.
@@ -891,10 +1040,28 @@ class LiveStreamProcessor:
 _live_processors = {}
 
 
-def get_live_processor(camera_id: str = "webcam_01", config: VideoProcessingConfig = None) -> LiveStreamProcessor:
-    """Get or create a live stream processor for a camera"""
+def get_live_processor(camera_id: str = "webcam_01", config: VideoProcessingConfig = None,
+                       object_detector=None, behavior_analyzer=None) -> LiveStreamProcessor:
+    """Get or create a live stream processor for a camera.
+    
+    If object_detector / behavior_analyzer are provided they will be
+    shared with the processor (avoids loading models twice).
+    """
     if camera_id not in _live_processors:
-        _live_processors[camera_id] = LiveStreamProcessor(config, camera_id)
+        _live_processors[camera_id] = LiveStreamProcessor(
+            config, camera_id,
+            object_detector=object_detector,
+            behavior_analyzer=behavior_analyzer
+        )
+    else:
+        # If processor already exists but doesn't have models yet, inject them
+        proc = _live_processors[camera_id]
+        if proc.object_detector is None and object_detector is not None:
+            proc.object_detector = object_detector
+            logger.info("✅ Injected shared object detector into existing live processor")
+        if proc.behavior_analyzer is None and behavior_analyzer is not None:
+            proc.behavior_analyzer = behavior_analyzer
+            logger.info("✅ Injected shared behavior analyzer into existing live processor")
     return _live_processors[camera_id]
 
 

real_time_alerts.py

@@ -735,7 +735,9 @@ class RealTimeAlertEngine:
             "knife": 0.60,
             "fighting": 0.55,
             "road_accident": 0.50,
+            "accident": 0.50,
             "wallclimb": 0.50,
+            "climbing": 0.50,
             "suspicious_reappearance": 0.55,
         }
         return thresholds.get(detection_class, 0.50)