nedo-vision-worker-core 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

nedo_vision_worker_core/core_service.py

@@ -3,13 +3,20 @@ import time
 import signal
 import os
 from pathlib import Path
-from typing import Callable, Dict, List, Any
+from typing import Callable, Dict, List, Any, Optional
 
 from .util.DrawingUtils import DrawingUtils
 from .streams.VideoStreamManager import VideoStreamManager
 from .streams.StreamSyncThread import StreamSyncThread
 from .pipeline.PipelineSyncThread import PipelineSyncThread
 from .database.DatabaseManager import DatabaseManager
+from .services.VideoSharingDaemonManager import get_daemon_manager
+from .callbacks import (
+    DetectionCallbackManager, 
+    DetectionType, 
+    CallbackTrigger, 
+    DetectionData
+)
 # Import models to ensure they are registered with SQLAlchemy Base registry
 from . import models
 import cv2
@@ -18,18 +25,14 @@ import cv2
 class CoreService:
     """Service class for running the Nedo Vision Core processing."""
 
-    # Class-level callback registry for detection events
-    _detection_callbacks: Dict[str, List[Callable]] = {
-        'ppe_detection': [],
-        'area_violation': [],
-        'general_detection': []
-    }
+    _callback_manager: Optional[DetectionCallbackManager] = None
 
     def __init__(self, 
                  drawing_assets_path: str = None,
                  log_level: str = "INFO",
                  storage_path: str = "data",
-                 rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live"):
+                 rtmp_server: str = "rtmp://live.vision.sindika.co.id:1935/live",
+                 enable_video_sharing_daemon: bool = True):
         """
         Initialize the Core Service.
         
@@ -38,11 +41,17 @@ class CoreService:
             log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
             storage_path: Storage path for databases and files (default: data)
             rtmp_server: RTMP server URL for video streaming (default: rtmp://localhost:1935/live)
+            enable_video_sharing_daemon: Enable automatic video sharing daemon management (default: True)
         """
         self.running = True
         self.video_manager = None
         self.stream_sync_thread = None
         self.pipeline_sync_thread = None
+        self.enable_video_sharing_daemon = enable_video_sharing_daemon
+        
+        # Initialize callback manager if not already done
+        if CoreService._callback_manager is None:
+            CoreService._callback_manager = DetectionCallbackManager()
         
         # Store configuration parameters
         self.storage_path = storage_path
@@ -65,73 +74,106 @@ class CoreService:
         signal.signal(signal.SIGINT, self._signal_handler)
         signal.signal(signal.SIGTERM, self._signal_handler)
 
+    # Detection Callback System Methods
+    
     @classmethod
-    def register_detection_callback(cls, detection_type: str, callback: Callable[[Dict[str, Any]], None]):
+    def register_callback(cls,
+                         name: str,
+                         callback: Callable[[DetectionData], None],
+                         trigger: CallbackTrigger,
+                         detection_types: List[DetectionType],
+                         interval_seconds: Optional[int] = None) -> None:
         """
-        Register a callback for detection events.
+        Register a detection callback.
         
         Args:
-            detection_type: Type of detection ('ppe_detection', 'area_violation', 'general_detection')
-            callback: Function to call when detection occurs. Should accept a dict with detection data.
+            name: Unique name for the callback
+            callback: Function to call when detection occurs
+            trigger: When to trigger (ON_NEW_DETECTION or ON_VIOLATION_INTERVAL)
+            detection_types: Types of detections to listen for
+            interval_seconds: For interval callbacks, how often to call (in seconds)
+        
+        Example:
+            # Immediate callback for PPE violations
+            CoreService.register_callback(
+                "ppe_alert",
+                my_ppe_callback,
+                CallbackTrigger.ON_NEW_DETECTION,
+                [DetectionType.PPE_DETECTION]
+            )
+            
+            # Interval callback for area violations every 30 seconds
+            CoreService.register_callback(
+                "area_summary",
+                my_area_summary_callback,
+                CallbackTrigger.ON_VIOLATION_INTERVAL,
+                [DetectionType.AREA_VIOLATION],
+                interval_seconds=30
+            )
         """
-        if detection_type not in cls._detection_callbacks:
-            cls._detection_callbacks[detection_type] = []
+        if cls._callback_manager is None:
+            cls._callback_manager = DetectionCallbackManager()
         
-        cls._detection_callbacks[detection_type].append(callback)
-        logging.info(f"📞 Registered {detection_type} callback: {callback.__name__}")
-
+        cls._callback_manager.register_callback(
+            name=name,
+            callback=callback,
+            trigger=trigger,
+            detection_types=detection_types,
+            interval_seconds=interval_seconds
+        )
+    
     @classmethod
-    def unregister_detection_callback(cls, detection_type: str, callback: Callable[[Dict[str, Any]], None]):
+    def unregister_callback(cls, name: str) -> bool:
         """
-        Unregister a callback for detection events.
+        Unregister a callback.
         
         Args:
-            detection_type: Type of detection ('ppe_detection', 'area_violation', 'general_detection')
-            callback: Function to unregister
+            name: Name of the callback to remove
+            
+        Returns:
+            True if callback was found and removed, False otherwise
         """
-        if detection_type in cls._detection_callbacks and callback in cls._detection_callbacks[detection_type]:
-            cls._detection_callbacks[detection_type].remove(callback)
-            logging.info(f"📞 Unregistered {detection_type} callback: {callback.__name__}")
-
+        if cls._callback_manager is None:
+            return False
+        
+        return cls._callback_manager.unregister_callback(name)
+    
     @classmethod
-    def trigger_detection_callback(cls, detection_type: str, detection_data: Dict[str, Any]):
+    def trigger_detection(cls, detection_data: DetectionData) -> None:
         """
-        Trigger all registered callbacks for a detection type.
+        Trigger detection callbacks.
         
         Args:
-            detection_type: Type of detection that occurred
-            detection_data: Dict containing detection information
+            detection_data: The detection data to process
         """
-        callbacks = cls._detection_callbacks.get(detection_type, [])
-        general_callbacks = cls._detection_callbacks.get('general_detection', [])
-        
-        # Call specific callbacks
-        for callback in callbacks:
-            try:
-                callback(detection_data)
-            except Exception as e:
-                logging.error(f"❌ Error in {detection_type} callback {callback.__name__}: {e}")
-        
-        # Call general callbacks
-        for callback in general_callbacks:
-            try:
-                callback(detection_data)
-            except Exception as e:
-                logging.error(f"❌ Error in general detection callback {callback.__name__}: {e}")
-
+        if cls._callback_manager is not None:
+            cls._callback_manager.trigger_detection(detection_data)
+    
     @classmethod
-    def list_callbacks(cls) -> Dict[str, List[str]]:
+    def get_callback_stats(cls) -> Dict[str, Any]:
         """
-        List all registered callbacks.
+        Get statistics about registered callbacks and recent activity.
         
         Returns:
-            Dict mapping detection types to callback function names
+            Dictionary with callback statistics
         """
-        return {
-            detection_type: [callback.__name__ for callback in callbacks]
-            for detection_type, callbacks in cls._detection_callbacks.items()
-            if callbacks
-        }
+        if cls._callback_manager is None:
+            return {"error": "Callback manager not initialized"}
+        
+        return cls._callback_manager.get_callback_stats()
+    
+    @classmethod
+    def list_callbacks(cls) -> Dict[str, Dict[str, Any]]:
+        """
+        List all callbacks with their configurations.
+        
+        Returns:
+            Dictionary mapping callback names to their configurations
+        """
+        if cls._callback_manager is None:
+            return {}
+        
+        return cls._callback_manager.list_callbacks()
 
     def _setup_environment(self):
         """Set up environment variables for components that still require them (like RTMPStreamer)."""
@@ -164,6 +206,16 @@ class CoreService:
             # Set up environment variables for internal components that still need them
             self._setup_environment()
 
+            # Initialize video sharing daemon manager if enabled
+            if self.enable_video_sharing_daemon:
+                daemon_manager = get_daemon_manager()
+                daemon_manager.enable_auto_start(True)
+                logging.info("🔗 Video sharing daemon auto-start enabled")
+            else:
+                daemon_manager = get_daemon_manager()
+                daemon_manager.enable_auto_start(False)
+                logging.info("⚠️ Video sharing daemon auto-start disabled")
+
             # Initialize Database with storage path
             DatabaseManager.init_databases(storage_path=self.storage_path)
 
@@ -225,6 +277,20 @@ class CoreService:
 
             if self.video_manager:
                 self.video_manager.stop_all()
+            
+            # Stop video sharing daemons if they were auto-started
+            if self.enable_video_sharing_daemon:
+                try:
+                    daemon_manager = get_daemon_manager()
+                    daemon_manager.stop_all_daemons()
+                    logging.info("🔗 Video sharing daemons stopped")
+                except Exception as e:
+                    logging.warning(f"⚠️ Error stopping video sharing daemons: {e}")
+            
+            # Stop callback manager
+            if CoreService._callback_manager:
+                CoreService._callback_manager.stop()
+                CoreService._callback_manager = None
                 
             # Final cleanup
             cv2.destroyAllWindows()
@@ -234,4 +300,4 @@ class CoreService:
         except Exception as e:
             logging.error(f"Error during shutdown: {e}")
         finally:
-            logging.info("✅ Nedo Vision Core shutdown complete.") 
+            logging.info("✅ Nedo Vision Core shutdown complete.")

nedo_vision_worker_core/database/DatabaseManager.py

@@ -99,11 +99,11 @@ class DatabaseManager:
 
         # Set storage paths - prioritize parameter over environment variables
         if storage_path:
-            DatabaseManager.STORAGE_PATH = Path(storage_path)
+            DatabaseManager.STORAGE_PATH = Path(storage_path).resolve()
         else:
             # Fallback to environment variables for backward compatibility
             DatabaseManager._load_env_file()
-            DatabaseManager.STORAGE_PATH = Path(os.environ.get("STORAGE_PATH", "data"))
+            DatabaseManager.STORAGE_PATH = Path(os.environ.get("STORAGE_PATH", "data")).resolve()
             
         DatabaseManager.STORAGE_PATHS = {
             "db": DatabaseManager.STORAGE_PATH / "sqlite",

nedo_vision_worker_core/detection/BaseDetector.py

@@ -10,12 +10,13 @@ class BaseDetector(ABC):
         pass
 
     @abstractmethod
-    def detect_objects(self, frame, confidence_threshold=0.7):
+    def detect_objects(self, frame, confidence_threshold=0.7, class_thresholds=None):
         """
         Detect objects in the input frame.
         Args:
             frame: Image/frame (numpy array)
             confidence_threshold: Minimum confidence threshold for detections (optional)
+            class_thresholds: Dict mapping class names to specific confidence thresholds (optional)
         Returns:
             List of detections: [{"label": str, "confidence": float, "bbox": [x1, y1, x2, y2]}, ...]
         """

nedo_vision_worker_core/detection/DetectionManager.py

@@ -77,7 +77,7 @@ class DetectionManager:
             self.detector = None
             self.model_metadata = None
 
-    def detect_objects(self, frame, confidence_threshold=0.7):
+    def detect_objects(self, frame, confidence_threshold=0.7, class_thresholds=None):
         if not self.detector:
             return []
-        return self.detector.detect_objects(frame, confidence_threshold)
+        return self.detector.detect_objects(frame, confidence_threshold, class_thresholds)

nedo_vision_worker_core/detection/RFDETRDetector.py

@@ -8,25 +8,30 @@ except ImportError:
     RFDETRBase = None
 
 from ..database.DatabaseManager import DatabaseManager
+from ..models.ai_model import AIModelEntity
 from .BaseDetector import BaseDetector
 
 logging.getLogger("ultralytics").setLevel(logging.WARNING)
 
 class RFDETRDetector(BaseDetector):
-    def __init__(self, model):
+    def __init__(self, model: AIModelEntity):
         if not RFDETR_AVAILABLE:
             raise ImportError(
                 "RF-DETR is required but not installed. Install it manually with:\n"
                 "pip install rfdetr @ git+https://github.com/roboflow/rf-detr.git@1e63dbad402eea10f110e86013361d6b02ee0c09\n"
                 "See the documentation for more details."
             )
+        if not isinstance(model, AIModelEntity):
+            raise TypeError("model must be an instance of AIModelEntity")
         self.model = None
         self.metadata = None
 
         if model:
             self.load_model(model)
 
-    def load_model(self, model):
+    def load_model(self, model: AIModelEntity):
+        if not isinstance(model, AIModelEntity):
+            raise TypeError("model must be an instance of AIModelEntity")
         self.metadata = model
         path = DatabaseManager.STORAGE_PATHS["models"] / model.file
         
@@ -44,17 +49,30 @@ class RFDETRDetector(BaseDetector):
             self.model = None
             return False
 
-    def detect_objects(self, frame, confidence_threshold=0.7):
+    def detect_objects(self, frame, confidence_threshold=0.7, class_thresholds=None):
         if self.model is None:
             return []
 
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         results = self.model.predict(frame_rgb, confidence_threshold)
 
+        class_names = self.metadata.get_classes() if hasattr(self.metadata, "get_classes") else None
+        if not class_names:
+            class_names = getattr(self.model, "class_names", None)
+
         detections = []
-        for class_id, conf, xyxy in zip(results.class_id, results.confidence, results.xyxy): 
+        for class_id, conf, xyxy in zip(results.class_id, results.confidence, results.xyxy):
+            label = class_names[class_id - 1] if class_names else str(class_id)
+            
+            threshold = confidence_threshold
+            if class_thresholds and label in class_thresholds:
+                threshold = class_thresholds[label]
+
+            if conf < threshold:
+                continue
+                
             detections.append({
-                "label": self.model.class_names[class_id],
+                "label": label,
                 "confidence": conf,
                 "bbox": xyxy
             })

nedo_vision_worker_core/detection/YOLODetector.py

@@ -3,18 +3,23 @@ import logging
 from ultralytics import YOLO
 from ..database.DatabaseManager import DatabaseManager
 from .BaseDetector import BaseDetector
+from ..models.ai_model import AIModelEntity
 
 logging.getLogger("ultralytics").setLevel(logging.WARNING)
 
 class YOLODetector(BaseDetector):
-    def __init__(self, model):
+    def __init__(self, model: AIModelEntity):
+        if not isinstance(model, AIModelEntity):
+            raise TypeError("model must be an instance of AIModelEntity")
         self.model = None
         self.metadata = None
 
         if model:
             self.load_model(model)
 
-    def load_model(self, model):
+    def load_model(self, model: AIModelEntity):
+        if not isinstance(model, AIModelEntity):
+            raise TypeError("model must be an instance of AIModelEntity")
         self.metadata = model
         path = DatabaseManager.STORAGE_PATHS["models"] / model.file
         
@@ -32,20 +37,28 @@ class YOLODetector(BaseDetector):
             self.model = None
             return False
 
-    def detect_objects(self, frame, target_classes=None, confidence_threshold=0.7):
+    def detect_objects(self, frame, confidence_threshold=0.7, class_thresholds=None):
         if self.model is None:
             return []
 
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         results = self.model(frame_rgb)
 
+        class_names = self.metadata.get_classes()
+        if not class_names:
+            class_names = self.model.names
+
         detections = []
         for box in results[0].boxes:
             class_id = int(box.cls)
-            label = self.model.names[class_id]
+            label = class_names[class_id]
             confidence = float(box.conf)
 
-            if confidence < confidence_threshold:
+            threshold = confidence_threshold
+            if class_thresholds and label in class_thresholds:
+                threshold = class_thresholds[label]
+
+            if confidence < threshold:
                 continue
 
             detections.append({

nedo_vision_worker_core/detection/detection_processing/DetectionProcessor.py

@@ -20,7 +20,7 @@ class DetectionProcessor(ABC):
         pass
 
     @abstractmethod
-    def update(self, config_manager: PipelineConfigManager):
+    def update(self, config_manager: PipelineConfigManager, ai_model=None):
         pass
 
     @abstractmethod

nedo_vision_worker_core/detection/detection_processing/HumanDetectionProcessor.py

@@ -6,6 +6,7 @@ from .DetectionProcessor import DetectionProcessor
 from ...pipeline.PipelineConfigManager import PipelineConfigManager
 from ...repositories.RestrictedAreaRepository import RestrictedAreaRepository
 from ...util.PersonRestrictedAreaMatcher import PersonRestrictedAreaMatcher
+from ...callbacks import DetectionType, DetectionAttribute, BoundingBox, DetectionData
 
 
 class HumanDetectionProcessor(DetectionProcessor):
@@ -16,16 +17,33 @@ class HumanDetectionProcessor(DetectionProcessor):
     def __init__(self):
         self.repository = RestrictedAreaRepository()
         self.restricted_areas = []
+        self.main_class_threshold = 0.7
+        self.main_class = "person"  # Default fallback
 
-    def update(self, config_manager: PipelineConfigManager):
-        config = config_manager.get_feature_config(self.code, [])
+    def update(self, config_manager: PipelineConfigManager, ai_model=None):
+        config = config_manager.get_feature_config(self.code, {})
         area_list = config.get("restrictedArea", [])
         self.restricted_areas = [
             [(p["x"], p["y"]) for p in area] for area in area_list
         ]
+        
+        # Update main class threshold
+        self.main_class_threshold = config.get("minimumDetectionConfidence", 0.7)
+        
+        # Update main class from AI model
+        if ai_model and ai_model.get_main_class():
+            self.main_class = ai_model.get_main_class()
+        else:
+            self.main_class = "person"  # Default fallback
+
+    def get_main_class_threshold(self, ai_model=None):
+        """Get the confidence threshold for the main class (person)"""
+        if ai_model and ai_model.get_main_class():
+            return self.main_class_threshold
+        return None
 
     def process(self, detections: List[Dict[str, Any]], dimension: Tuple[int, int]) -> List[Dict[str, Any]]:
-        persons = [d for d in detections if d["label"] == "person"]
+        persons = [d for d in detections if d["label"] == self.main_class]
 
         height, width = dimension
         area_polygons = []
@@ -45,3 +63,39 @@ class HumanDetectionProcessor(DetectionProcessor):
         self.repository.save_area_violation(
             pipeline_id, worker_source_id, frame_counter, tracked_objects, frame, frame_drawer
         )
+
+    def get_multi_instance_classes(self):
+        """Human detection doesn't have multi-instance classes"""
+        return []
+
+    @staticmethod
+    def create_detection_data(pipeline_id: str, worker_source_id: str, person_id: str,
+                                    detection_id: str, tracked_obj: Dict[str, Any],
+                                    image_path: str = "", image_tile_path: str = "",
+                                    frame_id: int = 0) -> DetectionData:
+        """Create DetectionData from area violation data."""
+        bbox = BoundingBox.from_list(tracked_obj["bbox"])
+        
+        attributes = []
+        for attr in tracked_obj.get("attributes", []):
+            # Area violations are always violations
+            attributes.append(DetectionAttribute(
+                label=attr["label"],
+                confidence=attr.get("confidence", 1.0),
+                count=attr.get("count", 0),
+                is_violation=True
+            ))
+        
+        return DetectionData(
+            detection_type=DetectionType.AREA_VIOLATION,
+            detection_id=detection_id,
+            person_id=person_id,
+            pipeline_id=pipeline_id,
+            worker_source_id=worker_source_id,
+            confidence_score=tracked_obj.get("confidence", 1.0),
+            bbox=bbox,
+            attributes=attributes,
+            image_path=image_path,
+            image_tile_path=image_tile_path,
+            frame_id=frame_id
+        )