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

nedo_vision_worker_core/streams/VideoStreamManager.py

@@ -1,6 +1,7 @@
 import logging
 import time
 from .VideoStream import VideoStream
+from .SharedVideoDeviceManager import SharedVideoDeviceManager
 import threading
 
 class VideoStreamManager:
@@ -10,21 +11,85 @@ class VideoStreamManager:
         self.streams = {}  # Store streams as {worker_source_id: VideoStream}
         self.running = False
         self.lock = threading.Lock()  # Add thread lock
+        self.shared_device_manager = SharedVideoDeviceManager()
+        self.direct_device_streams = {}  # Store direct device streams {worker_source_id: latest_frame}
+        self.direct_device_locks = {}  # Store locks for direct device frame access
+
+    def _is_direct_device(self, url) -> bool:
+        """Check if URL represents a direct video device."""
+        if isinstance(url, str):
+            return url.isdigit() or url.startswith('/dev/video')
+        return isinstance(url, int)
 
     def add_stream(self, worker_source_id, url):
         """Adds a new video stream if it's not already active."""
-        if worker_source_id not in self.streams:
-            self.streams[worker_source_id] = VideoStream(url)  # Create and start the VideoStream thread
-
+        if worker_source_id not in self.streams and worker_source_id not in self.direct_device_streams:
+            # Check if this is a direct video device
+            if self._is_direct_device(url):
+                self._add_direct_device_stream(worker_source_id, url)
+            else:
+                # Regular stream (file, RTSP, etc.)
+                stream = VideoStream(url)
+                stream.start()  # Start the thread
+                self.streams[worker_source_id] = stream
+                logging.info(f"✅ Added and started video stream: {worker_source_id}")
         else:
             logging.warning(f"⚠️ Stream {worker_source_id} is already active.")
 
+    def _add_direct_device_stream(self, worker_source_id, url):
+        """Add a direct device stream using the shared device manager."""
+        try:
+            # Initialize frame storage for this stream
+            self.direct_device_streams[worker_source_id] = {
+                'url': url,
+                'latest_frame': None,
+                'last_update': time.time()
+            }
+            self.direct_device_locks[worker_source_id] = threading.Lock()
+            
+            # Create callback for receiving frames
+            def frame_callback(frame):
+                with self.direct_device_locks[worker_source_id]:
+                    self.direct_device_streams[worker_source_id]['latest_frame'] = frame
+                    self.direct_device_streams[worker_source_id]['last_update'] = time.time()
+            
+            # Subscribe to the shared device
+            success = self.shared_device_manager.subscribe_to_device(
+                source=url,
+                subscriber_id=f"stream_{worker_source_id}",
+                callback=frame_callback
+            )
+            
+            if success:
+                logging.info(f"✅ Added direct device stream: {worker_source_id} -> {url}")
+            else:
+                # Clean up on failure
+                if worker_source_id in self.direct_device_streams:
+                    del self.direct_device_streams[worker_source_id]
+                if worker_source_id in self.direct_device_locks:
+                    del self.direct_device_locks[worker_source_id]
+                logging.error(f"❌ Failed to add direct device stream: {worker_source_id}")
+                
+        except Exception as e:
+            logging.error(f"❌ Error adding direct device stream {worker_source_id}: {e}")
+            # Clean up on error
+            if worker_source_id in self.direct_device_streams:
+                del self.direct_device_streams[worker_source_id]
+            if worker_source_id in self.direct_device_locks:
+                del self.direct_device_locks[worker_source_id]
+
     def remove_stream(self, worker_source_id):
         """Removes and stops a video stream."""
         if not worker_source_id:
             return
 
         with self.lock:
+            # Check if it's a direct device stream
+            if worker_source_id in self.direct_device_streams:
+                self._remove_direct_device_stream(worker_source_id)
+                return
+            
+            # Check if it's a regular stream
             if worker_source_id not in self.streams:
                 logging.warning(f"⚠️ Stream {worker_source_id} not found in manager.")
                 return
@@ -45,6 +110,33 @@ class VideoStreamManager:
 
         logging.info(f"✅ Stream {worker_source_id} removed successfully.")
 
+    def _remove_direct_device_stream(self, worker_source_id):
+        """Remove a direct device stream from the shared device manager."""
+        try:
+            device_info = self.direct_device_streams.get(worker_source_id)
+            if device_info:
+                url = device_info['url']
+                
+                # Unsubscribe from the shared device
+                success = self.shared_device_manager.unsubscribe_from_device(
+                    source=url,
+                    subscriber_id=f"stream_{worker_source_id}"
+                )
+                
+                if success:
+                    logging.info(f"✅ Removed direct device stream: {worker_source_id}")
+                else:
+                    logging.warning(f"⚠️ Failed to unsubscribe direct device stream: {worker_source_id}")
+            
+            # Clean up local storage
+            if worker_source_id in self.direct_device_streams:
+                del self.direct_device_streams[worker_source_id]
+            if worker_source_id in self.direct_device_locks:
+                del self.direct_device_locks[worker_source_id]
+                
+        except Exception as e:
+            logging.error(f"❌ Error removing direct device stream {worker_source_id}: {e}")
+
     def start_all(self):
         """Starts all video streams."""
         logging.info("🔄 Starting all video streams...")
@@ -59,18 +151,31 @@ class VideoStreamManager:
         with self.lock:
             # Get a list of IDs to avoid modification during iteration
             stream_ids = list(self.streams.keys())
+            direct_stream_ids = list(self.direct_device_streams.keys())
             
-        # Stop each stream
+        # Stop each regular stream
         for worker_source_id in stream_ids:
             try:
                 self.remove_stream(worker_source_id)
             except Exception as e:
                 logging.error(f"Error stopping stream {worker_source_id}: {e}")
         
+        # Stop each direct device stream
+        for worker_source_id in direct_stream_ids:
+            try:
+                self.remove_stream(worker_source_id)
+            except Exception as e:
+                logging.error(f"Error stopping direct device stream {worker_source_id}: {e}")
+        
         self.running = False
 
     def get_frame(self, worker_source_id):
         """Retrieves the latest frame for a specific stream."""
+        # Check if it's a direct device stream first
+        if worker_source_id in self.direct_device_streams:
+            return self._get_direct_device_frame(worker_source_id)
+        
+        # Handle regular streams
         with self.lock:  # Add lock protection for stream access
             stream = self.streams.get(worker_source_id)
             if stream is None:
@@ -98,18 +203,50 @@ class VideoStreamManager:
                 logging.error(f"Error getting frame from stream {worker_source_id}: {e}")
                 return None
 
+    def _get_direct_device_frame(self, worker_source_id):
+        """Get the latest frame from a direct device stream."""
+        try:
+            if worker_source_id not in self.direct_device_locks:
+                return None
+            
+            with self.direct_device_locks[worker_source_id]:
+                device_info = self.direct_device_streams.get(worker_source_id)
+                if not device_info:
+                    return None
+                
+                frame = device_info.get('latest_frame')
+                last_update = device_info.get('last_update', 0)
+                
+                # Check if frame is too old (5 seconds threshold)
+                if time.time() - last_update > 5.0:
+                    return None
+                
+                return frame.copy() if frame is not None else None
+                
+        except Exception as e:
+            logging.error(f"Error getting frame from direct device stream {worker_source_id}: {e}")
+            return None
+
     def get_active_stream_ids(self):
         """Returns a list of active stream IDs."""
-        return list(self.streams.keys())
+        regular_streams = list(self.streams.keys())
+        direct_streams = list(self.direct_device_streams.keys())
+        return regular_streams + direct_streams
 
     def get_stream_url(self, worker_source_id):
         """Returns the URL of a specific stream."""
+        # Check direct device streams first
+        if worker_source_id in self.direct_device_streams:
+            return self.direct_device_streams[worker_source_id]['url']
+        
+        # Check regular streams
         stream = self.streams.get(worker_source_id)
         return stream.source if stream else None
     
     def has_stream(self, worker_source_id):
         """Checks if a stream is active."""
-        return worker_source_id in self.streams
+        return (worker_source_id in self.streams or 
+                worker_source_id in self.direct_device_streams)
 
     def is_running(self):
         """Checks if the manager is running."""
@@ -117,5 +254,20 @@ class VideoStreamManager:
 
     def is_video_file(self, worker_source_id):
         """Check if a stream is a video file."""
+        # Direct device streams are never video files
+        if worker_source_id in self.direct_device_streams:
+            return False
+        
+        # Check regular streams
         stream = self.streams.get(worker_source_id)
         return stream.is_file if stream else False
+
+    def get_device_sharing_info(self):
+        """Get information about device sharing."""
+        return self.shared_device_manager.get_all_devices_info()
+
+    def shutdown(self):
+        """Shutdown the manager and clean up all resources."""
+        logging.info("Shutting down VideoStreamManager")
+        self.stop_all()
+        # The SharedVideoDeviceManager is a singleton and will clean up automatically

nedo_vision_worker_core/tracker/TrackerManager.py

@@ -4,8 +4,8 @@ import numpy as np
 from .SFSORT import SFSORT
 
 class TrackerManager:
-    def __init__(self, attribute_labels=None, exclusive_attribute_groups=None):
-        self.tracker = SFSORT({
+    def __init__(self, attribute_labels=None, exclusive_attribute_groups=None, multi_instance_classes=None, tracker_config=None):
+        default_config = {
             "dynamic_tuning": True,
             "cth": 0.5,
             "high_th": 0.6,
@@ -15,14 +15,30 @@ class TrackerManager:
             "new_track_th": 0.7,
             "marginal_timeout": 7,
             "central_timeout": 30
-        })
+        }
+        
+        config = {**default_config, **(tracker_config or {})}
+        self.tracker = SFSORT(config)
+        
         self.track_uuid_map = {}
         self.track_count_map = {}
         self.track_attributes_presence = {}
         self.track_last_seen = {}
-        self.track_timeout_seconds = 5
+        self.track_timeout_seconds = config.get("track_timeout_seconds", 5)
         self.attribute_labels = attribute_labels or []
         self.exclusive_attribute_groups = exclusive_attribute_groups or []
+        self.multi_instance_classes = multi_instance_classes or []
+
+    def update_config(self, attribute_labels=None, exclusive_attribute_groups=None, multi_instance_classes=None, tracker_config=None):
+        """Update tracker configuration at runtime"""
+        if attribute_labels is not None:
+            self.attribute_labels = attribute_labels
+        if exclusive_attribute_groups is not None:
+            self.exclusive_attribute_groups = exclusive_attribute_groups
+        if multi_instance_classes is not None:
+            self.multi_instance_classes = multi_instance_classes
+        if tracker_config:
+            self.track_timeout_seconds = tracker_config.get("track_timeout_seconds", self.track_timeout_seconds)
 
     def track_objects(self, detections):
         if not detections:
@@ -52,7 +68,7 @@ class TrackerManager:
             obj_uuid = self._assign_uuid(track_id)
 
             self.track_count_map[obj_uuid] += 1
-            self.track_last_seen[obj_uuid] = time.time()  # Time-based last seen
+            self.track_last_seen[obj_uuid] = time.time()
 
             attributes = data.get("attributes", [])
             filtered_attributes = self._filter_exclusive_attributes(attributes)
@@ -87,7 +103,6 @@ class TrackerManager:
         if not attributes:
             return []
 
-        # Group attributes by label to handle multiple instances
         attrs_by_label = {}
         for attr in attributes:
             label = attr["label"]
@@ -95,12 +110,6 @@ class TrackerManager:
                 attrs_by_label[label] = []
             attrs_by_label[label].append(attr)
 
-        # Multi-instance classes that can have multiple instances per person
-        MULTI_INSTANCE_CLASSES = ["boots", "gloves", "goggles", "no_gloves"]
-        # Negative classes that are exclusive with their positive counterparts
-        NEGATIVE_CLASSES = ["no_helmet", "no_vest", "no_goggles", "no_boots"]
-        
-        # For exclusive groups, keep only the highest confidence per group
         filtered_attrs = []
         for group in self.exclusive_attribute_groups:
             group_attrs = []
@@ -108,33 +117,18 @@ class TrackerManager:
                 if label in attrs_by_label:
                     group_attrs.extend(attrs_by_label[label])
             if group_attrs:
-                # Keep only the highest confidence in this exclusive group
                 best = max(group_attrs, key=lambda a: a["confidence"])
                 filtered_attrs.append(best)
 
-        # For multi-instance classes, add all instances (but respect exclusive logic above)
         exclusive_labels = set(l for group in self.exclusive_attribute_groups for l in group)
         for label, attrs in attrs_by_label.items():
-            # Skip if already handled by exclusive logic
             if label in exclusive_labels:
                 continue
-            # Add all instances of multi-instance classes
-            if label in MULTI_INSTANCE_CLASSES:
+            if label in self.multi_instance_classes:
                 filtered_attrs.extend(attrs)
-        
-        # Special case: for multi-instance classes, we want to allow multiple instances
-        # even if they were in exclusive groups, but we need to handle the negative classes properly
-        for label, attrs in attrs_by_label.items():
-            # If this is a multi-instance class and not a negative class, add all instances
-            if label in MULTI_INSTANCE_CLASSES and label not in NEGATIVE_CLASSES:
-                # Check which attributes were already added
-                for attr in attrs:
-                    already_added = any(
-                        a["label"] == label and list(a["bbox"]) == list(attr["bbox"]) 
-                        for a in filtered_attrs
-                    )
-                    if not already_added:
-                        filtered_attrs.append(attr)
+            else:
+                best = max(attrs, key=lambda a: a["confidence"])
+                filtered_attrs.append(best)
 
         return filtered_attrs