nedo-vision-worker-core 0.3.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

nedo_vision_worker_core/__init__.py

@@ -7,7 +7,7 @@ A library for running AI vision processing and detection in the Nedo Vision plat
 from .core_service import CoreService
 from .callbacks import DetectionType, CallbackTrigger, DetectionData, IntervalMetadata
 
-__version__ = "0.3.8"
+__version__ = "0.4.0"
 __all__ = [
     "CoreService", 
     "DetectionType", 

nedo_vision_worker_core/ai/FrameDrawer.py

@@ -3,12 +3,16 @@ import cv2
 import logging
 import os
 from pathlib import Path
+import threading
 
 import numpy as np
 from ..util.DrawingUtils import DrawingUtils
 
 class FrameDrawer:
     """Handles frame processing by drawing objects, annotations, and managing icons."""
+    
+    # Share the same lock as DrawingUtils for consistent locking
+    _cv_lock = DrawingUtils._cv_lock
 
     def __init__(self):
         self.icons = {}
@@ -67,7 +71,8 @@ class FrameDrawer:
                 (int(x * width), int(y * height)) for (x, y) in normalized_points
             ]
             if len(points) >= 3:
-                cv2.polylines(frame, [np.array(points, np.int32)], isClosed=True, color=color, thickness=2)
+                with self._cv_lock:
+                    cv2.polylines(frame, [np.array(points, np.int32)], isClosed=True, color=color, thickness=2)
 
     def draw_frame(self, frame, tracked_objects, with_trails=False, trail_length=10):
         current_ids = set()
@@ -83,7 +88,9 @@ class FrameDrawer:
             attributes = obj.get("attributes", [])
             labels = [attr.get("label") for attr in attributes]
             (color, flag) = self._get_color_from_labels(labels)
-            DrawingUtils.draw_bbox_info(frame, bbox, (color, flag), f"{track_id}", self.location_name, f"{obj.get('confidence', 0):.2f}")
+            
+            with self._cv_lock:
+                DrawingUtils.draw_bbox_info(frame, bbox, (color, flag), f"{track_id}", self.location_name, f"{obj.get('confidence', 0):.2f}")
 
             # Trailing
             if with_trails:
@@ -109,26 +116,28 @@ class FrameDrawer:
                 num_points = len(points)
 
                 # Draw faded trail
-                for i in range(1, num_points):
-                    cv2.line(frame, points[i-1], points[i], color, 1)
+                with self._cv_lock:
+                    for i in range(1, num_points):
+                        cv2.line(frame, points[i-1], points[i], color, 1)
 
                 current_ids.add(track_id)
 
-            DrawingUtils.draw_main_bbox(frame, bbox, (color, flag))
+            with self._cv_lock:
+                DrawingUtils.draw_main_bbox(frame, bbox, (color, flag))
 
-            for attr in attributes:
-                attr_bbox = attr.get("bbox", [])         
-                if len(attr_bbox) != 4:
-                    continue
+                for attr in attributes:
+                    attr_bbox = attr.get("bbox", [])         
+                    if len(attr_bbox) != 4:
+                        continue
 
-                attr_label = attr.get("label", "")
-                DrawingUtils.draw_inner_box(frame, attr_bbox, self._get_color(attr_label))
+                    attr_label = attr.get("label", "")
+                    DrawingUtils.draw_inner_box(frame, attr_bbox, self._get_color(attr_label))
 
-            icon_x = x1
-            for (label, icon) in self.icons.items():
-                if label in labels:
-                    DrawingUtils.draw_alpha_overlay(frame, icon, icon_x, y1 - 25)
-                    icon_x += 25
+                icon_x = x1
+                for (label, icon) in self.icons.items():
+                    if label in labels:
+                        DrawingUtils.draw_alpha_overlay(frame, icon, icon_x, y1 - 25)
+                        icon_x += 25
 
         # Cleanup trails for objects that disappeared
         if with_trails and hasattr(self, "trails"):

nedo_vision_worker_core/ai/VideoDebugger.py

@@ -22,43 +22,58 @@ class VideoDebugger:
         window_name = f"Pipeline {pipeline_id} - {worker_source_id}"
         
         try:
-            with self.lock:
-                if window_name not in self.fps_tracker:
-                    self.fps_tracker[window_name] = {"start_time": time.time(), "frame_count": 0}
-
-                self.fps_tracker[window_name]["frame_count"] += 1
-                elapsed_time = time.time() - self.fps_tracker[window_name]["start_time"]
-                fps = self.fps_tracker[window_name]["frame_count"] / max(elapsed_time, 1e-5)
-
-                cv2.putText(frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+            # Serialize ALL OpenCV operations to prevent segfaults
+            with self._cv_lock:
+                with self.lock:
+                    if window_name not in self.fps_tracker:
+                        self.fps_tracker[window_name] = {"start_time": time.time(), "frame_count": 0}
 
-                if window_name not in self.windows:
-                    self.windows[window_name] = True
+                    self.fps_tracker[window_name]["frame_count"] += 1
+                    elapsed_time = time.time() - self.fps_tracker[window_name]["start_time"]
+                    fps = self.fps_tracker[window_name]["frame_count"] / max(elapsed_time, 1e-5)
 
-            # Serialize cv2 calls to prevent segfaults
-            with self._cv_lock:
+                    if window_name not in self.windows:
+                        self.windows[window_name] = True
+                
+                # Make a copy to avoid modifying the original frame from multiple threads
+                display_frame = frame.copy()
+                
                 try:
-                    cv2.imshow(window_name, frame)
+                    cv2.putText(display_frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+                    cv2.imshow(window_name, display_frame)
                     key = cv2.waitKey(1) & 0xFF
                     
                     if key == ord('q'):
-                        self.close_window(window_name)
+                        self._close_window_unsafe(window_name)
                 except Exception as e:
                     logging.error(f"Error displaying frame for {window_name}: {e}")
                     
         except Exception as e:
             logging.error(f"Error in show_frame for {window_name}: {e}")
 
+    def _close_window_unsafe(self, window_name):
+        """Close window without acquiring locks (called when already locked)."""
+        if window_name in self.windows:
+            try:
+                cv2.destroyWindow(window_name)
+            except Exception as e:
+                logging.error(f"Error closing window {window_name}: {e}")
+            del self.windows[window_name]
+
     def close_window(self, window_name):
         """Close specific window."""
+        with self._cv_lock:
+            with self.lock:
+                self._close_window_unsafe(window_name)
+    
+    def is_window_open(self, pipeline_id):
+        """Check if a window is open for a given pipeline."""
         with self.lock:
-            if window_name in self.windows:
-                with self._cv_lock:
-                    try:
-                        cv2.destroyWindow(window_name)
-                    except Exception as e:
-                        logging.error(f"Error closing window {window_name}: {e}")
-                del self.windows[window_name]
+            # Check if any window exists for this pipeline
+            for window_name in self.windows.keys():
+                if f"Pipeline {pipeline_id}" in window_name:
+                    return True
+            return False
 
     def close_all(self):
         """Close all windows."""

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -45,7 +45,7 @@ class PipelineProcessor:
         self.rtmp_streamer = None
         self.rtmp_streaming_active = False
         self.last_preview_check_time = 0
-        self.preview_check_interval = 5.0  # Check every 5 seconds
+        self.preview_check_interval = 10.0  # Check every 10 seconds (reduced from 5s to save CPU)
         self.pipeline_repo = WorkerSourcePipelineRepository()
 
         self.detection_processor_codes = [
@@ -174,55 +174,62 @@ class PipelineProcessor:
         )
         self.detection_thread.start()
 
+        target_render_fps = 25.0
+        target_frame_time = 1.0 / target_render_fps
+        last_preview_check = 0
+
         try:
             while self.running:
+                loop_start = time.time()
+                
                 frame = video_manager.get_frame(worker_source_id)
 
                 if frame is None:
                     if not self._handle_frame_failure(video_manager, worker_source_id):
                         break
-                    # no frame this tick—just continue (the streamer will repeat last good frame)
+                    time.sleep(0.04)
                     continue
                     
-                # successful frame
                 self.consecutive_frame_failures = 0
-                self.last_successful_frame_time = time.time()
+                self.last_successful_frame_time = loop_start
                 self.frame_counter += 1
 
-                # draw annotations
-                try:
-                    self.frame_drawer.draw_polygons(frame)
-                    frame_to_draw = frame.copy() if self.debug_flag else frame
-                    drawn_frame = self.frame_drawer.draw_frame(
-                        frame_to_draw,
-                        self.tracked_objects_render,
-                        with_trails=True,
-                        trail_length=int(max(1, 2 / self.detection_interval))
-                    )
-                except Exception as e:
-                    logging.error(f"❌ Draw failed, using raw frame: {e}")
+                # Check preview status less frequently
+                if loop_start - last_preview_check >= self.preview_check_interval:
+                    self._check_and_update_rtmp_streaming()
+                    last_preview_check = loop_start
+
+                should_draw = self.rtmp_streaming_active or self.debug_flag
+                
+                if should_draw:
+                    try:
+                        frame_to_draw = frame.copy()
+                        self.frame_drawer.draw_polygons(frame_to_draw)
+                        drawn_frame = self.frame_drawer.draw_frame(
+                            frame_to_draw,
+                            self.tracked_objects_render,
+                            with_trails=True,
+                            trail_length=int(max(1, 2 / self.detection_interval))
+                        )
+                    except Exception as e:
+                        logging.error(f"❌ Draw failed, using raw frame: {e}")
+                        drawn_frame = frame
+                else:
                     drawn_frame = frame
 
-                # debug snapshot if requested
                 if self.debug_flag:
                     tracked_objects_render = self._process_frame(frame)
                     try:
+                        debug_frame = frame.copy()
                         self.debug_repo.update_debug_entries_by_pipeline_id(
                             self.pipeline_id,
-                            self.frame_drawer.draw_frame(frame, tracked_objects_render),
+                            self.frame_drawer.draw_frame(debug_frame, tracked_objects_render),
                             tracked_objects_render
                         )
                     except Exception as e:
                         logging.warning(f"Debug save failed: {e}")
                     self.debug_flag = False
 
-                # Check if RTMP streaming should be active based on preview requests
-                current_time = time.time()
-                if current_time - self.last_preview_check_time >= self.preview_check_interval:
-                    self._check_and_update_rtmp_streaming()
-                    self.last_preview_check_time = current_time
-
-                # Push frame to RTMP stream if preview is active
                 if self.rtmp_streaming_active:
                     if self.rtmp_streamer is None:
                         try:
@@ -243,39 +250,21 @@ class PipelineProcessor:
                                 except Exception:
                                     pass
                                 self.rtmp_streamer = None
-                else:
-                    # Stop RTMP streaming if preview is no longer active
-                    if self.rtmp_streamer is not None:
-                        try:
-                            logging.info(f"🛑 Stopping RTMP streamer for pipeline {pipeline_id} (preview expired)")
-                            self.rtmp_streamer.stop_stream()
-                        except Exception as e:
-                            logging.error(f"❌ Error stopping RTMP streamer: {e}")
-                        finally:
-                            self.rtmp_streamer = None
-
-                # feed detection worker with latest-only behavior
-                if self.detection_thread and self.detection_thread.is_alive():
+                elif self.rtmp_streamer is not None:
                     try:
-                        self.frame_queue.put_nowait(frame)
-                    except queue.Full:
-                        try:
-                            _ = self.frame_queue.get_nowait()
-                        except queue.Empty:
-                            pass
-                        try:
-                            self.frame_queue.put_nowait(frame)
-                        except queue.Full:
-                            pass
+                        logging.info(f"🛑 Stopping RTMP streamer for pipeline {pipeline_id} (preview expired)")
+                        self.rtmp_streamer.stop_stream()
+                    except Exception as e:
+                        logging.error(f"❌ Error stopping RTMP streamer: {e}")
+                    finally:
+                        self.rtmp_streamer = None
 
-                # visualize
-                try:
-                    self.video_debugger.show_frame(pipeline_id, worker_source_id, drawn_frame)
-                except Exception as e:
-                    logging.error(f"⚠️ Failed to render frame for pipeline {pipeline_id}: {e}")
+                # Simplified queue feeding - avoid expensive try-except
+                if not self.frame_queue.full():
+                    self.frame_queue.put_nowait(frame)
                 
-                # Dynamic sleep based on detection interval to reduce CPU
-                sleep_time = min(0.01, self.detection_interval / 10)
+                loop_elapsed = time.time() - loop_start
+                sleep_time = max(0.001, target_frame_time - loop_elapsed)
                 time.sleep(sleep_time)
 
         except Exception as e:

nedo_vision_worker_core/util/DrawingUtils.py

@@ -2,8 +2,12 @@ import math
 import cv2
 import numpy as np
 import os
+import threading
 
 class DrawingUtils:
+    # Global lock for all OpenCV drawing operations to prevent segfaults
+    _cv_lock = threading.Lock()
+    
     _color_map = {
         True: "blue",
         False: "red",

{nedo_vision_worker_core-0.3.8.dist-info → nedo_vision_worker_core-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.8
+Version: 0.4.0
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
@@ -30,7 +30,7 @@ Classifier: Environment :: No Input/Output (Daemon)
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: alembic>=1.8.0
-Requires-Dist: numpy>=1.21.0
+Requires-Dist: numpy<2.0.0,>=1.21.0
 Requires-Dist: pillow>=8.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: scipy>=1.9.0
@@ -40,8 +40,6 @@ Requires-Dist: torch>=1.9.0
 Requires-Dist: torchvision>=0.10.0
 Requires-Dist: ultralytics>=8.0.0
 Requires-Dist: rfdetr<2.0.0,>=1.2.0
-Provides-Extra: opencv
-Requires-Dist: opencv-python>=4.6.0; extra == "opencv"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: black>=22.0.0; extra == "dev"
@@ -49,6 +47,8 @@ Requires-Dist: isort>=5.10.0; extra == "dev"
 Requires-Dist: mypy>=0.950; extra == "dev"
 Requires-Dist: flake8>=4.0.0; extra == "dev"
 Requires-Dist: pre-commit>=2.17.0; extra == "dev"
+Provides-Extra: opencv
+Requires-Dist: opencv-python<5.0.0,>=4.6.0; extra == "opencv"
 
 # Nedo Vision Worker Core
 

{nedo_vision_worker_core-0.3.8.dist-info → nedo_vision_worker_core-0.4.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
-nedo_vision_worker_core/__init__.py,sha256=HAUgt6tA__5tRxc5EtEDSooC_CQI0Uyjp0RFJtSK754,1924
+nedo_vision_worker_core/__init__.py,sha256=_NVuaujglbPX63LBohmNR6a1n7ctmMl97EsX9LBIVHA,1924
 nedo_vision_worker_core/cli.py,sha256=8YuKWsIgICUYXE_QtwyU3WzGhVjTWiAo5uzpFOmjNc8,5766
 nedo_vision_worker_core/core_service.py,sha256=q8-GuGW_l5l6wTWQDqc7BDdhM7zKC-mMLZ5wIHu9xV0,11628
 nedo_vision_worker_core/doctor.py,sha256=K_-hVV2-mdEefZ4Cfu5hMCiOxBiI1aXY8VtkkpK80Lc,10651
-nedo_vision_worker_core/ai/FrameDrawer.py,sha256=lj83WFaE70BQfkEc6AHcMBXaiEm8l3s_zJZG9C0NkAs,5286
+nedo_vision_worker_core/ai/FrameDrawer.py,sha256=47z3qnj75tDxKHasZozBCzBhW3yJU-57GGVMoVD6b78,5623
 nedo_vision_worker_core/ai/ImageDebugger.py,sha256=5FwgNGZrxO2eT7hxdxp7N2gQ0oyyYDZChJ3PJapKu-w,4612
-nedo_vision_worker_core/ai/VideoDebugger.py,sha256=4BqOB_vszS4Prux1VFnZ3nGwQ3dyQOljtp5ud0XZBCU,3074
+nedo_vision_worker_core/ai/VideoDebugger.py,sha256=2qQrCrUTUxr3TCA5NfbxIGvIhdhphPoi5FgqmK99b1c,3818
 nedo_vision_worker_core/ai/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/callbacks/DetectionCallbackManager.py,sha256=Ogoco3JD_o5IMccruau1ly69bDWnsckJyVtzCw259JQ,13379
 nedo_vision_worker_core/callbacks/DetectionCallbackTypes.py,sha256=U7Qb0dCMtOHuZi_HNjapKjPqsCNM9ucHQosjHk9vPJ8,5057
@@ -61,7 +61,7 @@ nedo_vision_worker_core/pipeline/ModelManager.py,sha256=2DoQiIdF-PAqU7nT_u6bj-DY
 nedo_vision_worker_core/pipeline/PipelineConfigManager.py,sha256=X55i9GyXcW9ylO6cj2UMAZFSxxPViacL4H4DZl60CAY,1157
 nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=3I9UBJu_rRfTEctwj8i4hO4MHjpBtYpfh-rIi64qgEw,7638
 nedo_vision_worker_core/pipeline/PipelinePrepocessor.py,sha256=cCiVSHHqsKCtKYURdYoEjHJX2GnT6zd8kQ6ZukjQ3V0,1271
-nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=9gQ6AVOD_cC-c9VLqJ8WwaDb8HZNkAOT35Op0nHDROs,34194
+nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=FYpZw2vRRuweJ798gRhygOfF7cCJbKRApwZ52kxSEEM,33478
 nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=HkW6wj0eDr6M1K3Y25IlB2V6tpIZsKA34AM49AXvcQk,8707
 nedo_vision_worker_core/pipeline/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/preprocessing/ImageResizer.py,sha256=RvOazxe6dJQuiy0ZH4lIGbdFfiu0FLUVCHoMvxkDNT4,1324
@@ -90,7 +90,7 @@ nedo_vision_worker_core/tracker/SFSORT.py,sha256=0kggw0l4yPZ55AKHdqVX6mu9ehHmJed
 nedo_vision_worker_core/tracker/TrackerManager.py,sha256=xtDMI657W2s7HM2lMGtwU0x5Hq74BZpLHd-5xk-278I,6152
 nedo_vision_worker_core/tracker/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/util/BoundingBoxMetrics.py,sha256=S2h87VRSmgD2t5lPBYW0EKSIAvWjjy4fo37zQwqc21g,1735
-nedo_vision_worker_core/util/DrawingUtils.py,sha256=sLptmzVaJakP_ZgbZsLL03RMH_9Nwkw0f8_gbIAf03A,13621
+nedo_vision_worker_core/util/DrawingUtils.py,sha256=YXL3TUB4A7PEwk3k4OuRTLEY9f0bjZncVzfTSYxVVU0,13748
 nedo_vision_worker_core/util/ModelReadinessChecker.py,sha256=ywHvt_d7UlY3DyFEJrO4Iyl0zx3SaLKb-Qab5l5Q8n4,6548
 nedo_vision_worker_core/util/PersonAttributeMatcher.py,sha256=PhYTPYSF62Nfuc7dage03K6icw_bBBdpvXvnlzCbS30,2773
 nedo_vision_worker_core/util/PersonRestrictedAreaMatcher.py,sha256=iuzCU32BQKaZ3dIy0QHNg2yoWJA-XhTRwwYqCvFdDgg,1711
@@ -98,8 +98,8 @@ nedo_vision_worker_core/util/PipelinePreviewChecker.py,sha256=XxlSMlrDlRrzfV8_Y-
 nedo_vision_worker_core/util/PlatformDetector.py,sha256=GGL8UfeMQITR22EMYIRWnuOEnSqo7Dr5mb0PaFrl8AM,3006
 nedo_vision_worker_core/util/TablePrinter.py,sha256=wzLGgb1GFMeIbAP6HmKcZD33j4D-IlyqlyeR7C5yD7w,1137
 nedo_vision_worker_core/util/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker_core-0.3.8.dist-info/METADATA,sha256=uClzBEF9GttUKm4thh8BpzA7VEhVBeZ8M6Yf1bGFl10,14412
-nedo_vision_worker_core-0.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker_core-0.3.8.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
-nedo_vision_worker_core-0.3.8.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
-nedo_vision_worker_core-0.3.8.dist-info/RECORD,,
+nedo_vision_worker_core-0.4.0.dist-info/METADATA,sha256=xzaULdQDUdB5jKhmotw2EL4Ua4LJlQ0kExewX2JfUn8,14426
+nedo_vision_worker_core-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker_core-0.4.0.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
+nedo_vision_worker_core-0.4.0.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
+nedo_vision_worker_core-0.4.0.dist-info/RECORD,,