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

nedo_vision_worker_core/__init__.py

@@ -0,0 +1,23 @@
+"""
+Nedo Vision Core Library
+
+A library for running AI vision processing and detection in the Nedo Vision platform.
+"""
+
+from .core_service import CoreService
+
+__version__ = "0.2.0"
+__all__ = ["CoreService"]
+
+# Convenience functions for callback management
+def register_ppe_detection_callback(callback):
+    """Register a callback for PPE detection events."""
+    return CoreService.register_detection_callback('ppe_detection', callback)
+
+def register_area_violation_callback(callback):
+    """Register a callback for restricted area violation events."""
+    return CoreService.register_detection_callback('area_violation', callback)
+
+def register_general_detection_callback(callback):
+    """Register a callback for all detection events."""
+    return CoreService.register_detection_callback('general_detection', callback) 

nedo_vision_worker_core/ai/FrameDrawer.py

@@ -0,0 +1,144 @@
+from typing import List, Tuple
+import cv2
+import logging
+import os
+from pathlib import Path
+
+import numpy as np
+from ..util.DrawingUtils import DrawingUtils
+
+class FrameDrawer:
+    """Handles frame processing by drawing objects, annotations, and managing icons."""
+
+    def __init__(self):
+        self.icons = {}
+        self.violation_labels = []
+        self.compliance_labels = []
+        self.polygons: List[Tuple[Tuple[int, int, int], List[Tuple[float, float]]]] = []
+        self.trails = {}
+        self.location_name = "LOCATION"
+
+    def update_config(self, icons = {}, violation_labels = [], compliance_labels = []):
+        self.icons = self._load_icons(icons)
+        self.violation_labels = violation_labels
+        self.compliance_labels = compliance_labels
+
+    def _load_icons(self, icon_paths, size=(20, 20)):
+        icons = {}
+        base_dir = Path(__file__).parent.parent
+        
+        for key, path in icon_paths.items():
+            try:
+                full_path = base_dir / path
+                icon = cv2.imread(str(full_path), cv2.IMREAD_UNCHANGED)
+                if icon is None:
+                    raise FileNotFoundError(f"Icon '{path}' not found at {full_path}.")
+                icons[key] = cv2.resize(icon, size)
+            except Exception as e:
+                logging.warning(f"⚠️ Failed to load icon {path}: {e}")
+                icons[key] = None
+        return icons
+
+    def _get_color(self, label):
+        if label in self.violation_labels:
+            return ((0, 0, 255), False)
+        elif label in self.compliance_labels:
+            return ((255, 141, 11), True)
+        else:
+            return ((255, 255, 255), None)
+
+    def _get_color_from_labels(self, labels):
+        compliance_count = 0
+        for label in labels:
+            if label in self.violation_labels:
+                return ((0, 0, 255), False)
+            elif label in self.compliance_labels:
+                compliance_count += 1
+
+        if labels and compliance_count == len(labels):
+            return ((255, 141, 11), True)
+        else:
+            return ((255, 255, 255), None)
+
+    def draw_polygons(self, frame):
+        height, width = frame.shape[:2]
+        for color, normalized_points in self.polygons:
+            points = [
+                (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)
+
+    def draw_frame(self, frame, tracked_objects, with_trails=False, trail_length=10):
+        current_ids = set()
+
+        for obj in tracked_objects:
+            bbox = obj.get("bbox", [])
+            if len(bbox) != 4:
+                continue
+
+            track_id = obj.get('track_id', -1)
+            x1, y1, x2, y2 = map(int, bbox)
+
+            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}")
+
+            # Trailing
+            if with_trails:
+                if not hasattr(self, "trails"):
+                    self.trails = {}
+
+                if track_id not in self.trails:
+                    self.trails[track_id] = {
+                        "points": [],
+                        "missed_frames": 0
+                    }
+
+                center_x = int((x1 + x2) / 2)
+                center_y = int((y1 + y2) / 2)
+
+                self.trails[track_id]["points"].append((center_x, center_y))
+
+                # Limit the number of points
+                if len(self.trails[track_id]["points"]) > trail_length:
+                    self.trails[track_id]["points"] = self.trails[track_id]["points"][-trail_length:]
+
+                points = self.trails[track_id]["points"]
+                num_points = len(points)
+
+                # Draw faded trail
+                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))
+
+            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))
+
+            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"):
+            for track_id in list(self.trails.keys()):
+                if track_id not in current_ids:
+                    self.trails[track_id]["missed_frames"] += 1
+                else:
+                    self.trails[track_id]["missed_frames"] = 0
+
+                if self.trails[track_id]["missed_frames"] > 30:
+                    del self.trails[track_id]
+
+        return frame

nedo_vision_worker_core/ai/ImageDebugger.py

@@ -0,0 +1,126 @@
+import cv2
+import random
+import logging
+import threading
+import os
+
+class ImageDebugger:
+    """Handles image visualization for AI detections and tracking."""
+    def __init__(self, window_name="AI Debugger", display=True):
+        """
+        Initializes the ImageDebugger.
+
+        :param window_name: Name of the display window.
+        :param display: Flag to enable visualization (skips if no GUI available).
+        """
+        self.window_name = window_name
+        self.display = display and os.environ.get("DISPLAY", None) is not None
+
+    def draw_detections(self, frame, detections):
+        """
+        Draws bounding boxes and labels on the given frame.
+
+        :param frame: The image frame to draw on.
+        :param detections: List of detection results.
+        :return: Image with drawn detections.
+        """
+        for detection in detections:
+            label = detection.get("label", "unknown")
+            confidence = detection.get("confidence", 0)
+            bbox = detection.get("bbox", [])
+
+            if not bbox or len(bbox) != 4:
+                continue  # Skip invalid bounding boxes
+
+            color = self._get_color(label)
+            x1, y1, x2, y2 = map(int, bbox)
+
+            # Draw bounding box
+            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+
+            # Draw label and confidence
+            label_text = f"{label} ({confidence:.2f})"
+            cv2.putText(frame, label_text, (x1, max(y1 - 10, 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+        return frame
+
+    def draw_tracked_objects(self, frame, tracked_objects):
+        """
+        Draws tracked objects with unique IDs and attribute matches.
+
+        :param frame: The image frame to draw on.
+        :param tracked_objects: List of tracked object results.
+        :return: Image with drawn tracking details.
+        """
+        for obj in tracked_objects:
+            track_id = obj.get("track_id", -1)
+            detections = obj.get("detections", 0)
+            bbox = obj.get("bbox", [])
+
+            if not bbox or len(bbox) != 4:
+                continue  # Skip invalid bounding boxes
+
+            color = self._get_color("track")  # Unique color for tracked objects
+            x1, y1, x2, y2 = map(int, bbox)
+
+            # Draw tracking box
+            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
+
+            # Draw track ID and detection count
+            track_text = f"ID: {track_id} | Detections: {detections}"
+            cv2.putText(frame, track_text, (x1, max(y1 - 10, 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+            # Draw attributes
+            for attr in obj.get("attributes", []):
+                attr_label = attr.get("label", "unknown")
+                attr_conf = attr.get("confidence", 0)
+                attr_bbox = attr.get("bbox", [])
+
+                if attr_bbox and len(attr_bbox) == 4:
+                    ax1, ay1, ax2, ay2 = map(int, attr_bbox)
+                    attr_color = self._get_color(attr_label)
+                    cv2.rectangle(frame, (ax1, ay1), (ax2, ay2), attr_color, 2)
+                    cv2.putText(frame, f"{attr_label} ({attr_conf:.2f})", (ax1, max(ay1 - 10, 20)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, attr_color, 2)
+
+        return frame
+
+    def show_image(self, frame):
+        """Displays the image in a window without blocking execution."""
+        if self.display:
+            print("[DEBUG] Showing image...")  # Debug print
+            cv2.imshow(self.window_name, frame)
+            key = cv2.waitKey(10) & 0xFF
+            if key == ord('q'):  # Allows exit with 'q'
+                self.close()
+            print("[DEBUG] Image displayed.")
+
+    
+    def show_image_threaded(self, frame):
+        """Runs show_image in a separate thread to prevent blocking."""
+        thread = threading.Thread(target=self.show_image, args=(frame,))
+        thread.start()
+
+    def save_image(self, frame, filename="debug_output.jpg"):
+        """
+        Saves the image to a file.
+
+        :param frame: Image to save.
+        :param filename: Name of the output file.
+        """
+        cv2.imwrite(filename, frame)
+        logging.info(f"📸 Debug image saved as {filename}")
+
+    def close(self):
+        """Closes all OpenCV windows."""
+        cv2.destroyAllWindows()
+        cv2.waitKey(1)  # Ensure the window fully closes
+
+    def _get_color(self, label):
+        """
+        Generates a unique color for each label.
+
+        :param label: Label name.
+        :return: BGR color tuple.
+        """
+        random.seed(hash(label) % 256)
+        return tuple(random.randint(100, 255) for _ in range(3))

nedo_vision_worker_core/ai/VideoDebugger.py

@@ -0,0 +1,69 @@
+import cv2
+import threading
+import time
+from collections import defaultdict
+
+# TODO: fix timer error (because of threading)
+class VideoDebugger:
+    """Handles real-time visualization of video streams with object detections."""
+
+    def __init__(self, enable_visualization=True):
+        """
+        Initializes the VideoDebugger with frame drawing and visualization capabilities.
+
+        Args:
+            enable_visualization (bool): Whether to display frames.
+        """
+        self.enable_visualization = enable_visualization
+        self.windows = {}  # Tracks OpenCV windows
+        self.lock = threading.Lock()  # Thread-safe updates
+        self.fps_tracker = defaultdict(lambda: {"start_time": time.time(), "frame_count": 0})
+
+    def show_frame(self, pipeline_id, worker_source_id, frame):
+        """
+        Displays a frame with FPS overlay.
+
+        Args:
+            pipeline_id (str/int): Identifier for the pipeline.
+            worker_source_id (str): Identifier for the worker/source.
+            frame: The frame to display.
+        """
+        if not self.enable_visualization or frame is None:
+            return
+
+        window_name = f"Pipeline {pipeline_id} - {worker_source_id}"
+        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)
+
+            # Display FPS on the frame
+            cv2.putText(frame, f"FPS: {fps:.2f}", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)
+
+            # Show the window
+            if window_name not in self.windows:
+                self.windows[window_name] = True  # Register window
+
+            cv2.imshow(window_name, frame)
+
+            # Close on 'q' press
+            if cv2.waitKey(1) & 0xFF == ord('q'):
+                self.close_window(window_name)
+
+    def close_window(self, window_name):
+        """Closes a specific OpenCV window."""
+        with self.lock:
+            if window_name in self.windows:
+                cv2.destroyWindow(window_name)
+                del self.windows[window_name]
+
+    def close_all(self):
+        """Closes all OpenCV windows."""
+        with self.lock:
+            for window in list(self.windows.keys()):
+                cv2.destroyWindow(window)
+            self.windows.clear()
+        cv2.waitKey(1)

nedo_vision_worker_core/ai/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/cli.py

@@ -0,0 +1,197 @@
+import argparse
+import signal
+import sys
+import traceback
+import logging
+
+from .core_service import CoreService
+from . import __version__
+
+
+def signal_handler(signum, frame):
+    """Handle system signals for graceful shutdown"""
+    logging.info(f"Received signal {signum}, shutting down...")
+    sys.exit(0)
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Nedo Vision Core Library CLI",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Start core service with default settings
+  nedo-core run
+
+  # Start with custom drawing assets path
+  nedo-core run --drawing-assets /path/to/assets
+
+  # Start with debug logging
+  nedo-core run --log-level DEBUG
+
+  # Start with custom storage path and RTMP server
+  nedo-core run --storage-path /path/to/storage --rtmp-server rtmp://server.com:1935/live
+
+  # Start with all custom parameters
+  nedo-core run --drawing-assets /path/to/assets --log-level DEBUG --storage-path /data --rtmp-server rtmp://server.com:1935/live
+
+  # Run system diagnostics
+  nedo-core doctor
+
+Detection Callbacks:
+  The core service supports detection callbacks for extensible event handling.
+  See example_callbacks.py for usage examples.
+        """
+    )
+    
+    # Add subcommands
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Run command
+    run_parser = subparsers.add_parser(
+        'run',
+        help='Start the core service',
+        description='Start the Nedo Vision Core Service'
+    )
+    
+    # Doctor command
+    doctor_parser = subparsers.add_parser(
+        'doctor',
+        help='Run system diagnostics',
+        description='Run diagnostic checks for system requirements and dependencies'
+    )
+    
+    run_parser.add_argument(
+        "--drawing-assets",
+        default=None,
+        help="Path to drawing assets directory (optional, uses bundled assets by default)"
+    )
+    
+    run_parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        default="INFO",
+        help="Logging level (default: INFO)"
+    )
+    
+    run_parser.add_argument(
+        "--storage-path",
+        default="data",
+        help="Storage path for databases and files (default: data)"
+    )
+    
+    run_parser.add_argument(
+        "--rtmp-server",
+        default="rtmp://localhost:1935/live",
+        help="RTMP server URL for video streaming (default: rtmp://localhost:1935/live)"
+    )
+    
+    # Add legacy arguments for backward compatibility (when no subcommand is used)
+    parser.add_argument(
+        "--drawing-assets",
+        help="(Legacy) Path to drawing assets directory (optional, uses bundled assets by default)"
+    )
+    
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        default="INFO",
+        help="(Legacy) Logging level (default: INFO)"
+    )
+    
+    parser.add_argument(
+        "--storage-path",
+        default="data",
+        help="(Legacy) Storage path for databases and files (default: data)"
+    )
+    
+    parser.add_argument(
+        "--rtmp-server",
+        default="rtmp://localhost:1935/live",
+        help="(Legacy) RTMP server URL for video streaming (default: rtmp://localhost:1935/live)"
+    )
+    
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"nedo-vision-core {__version__}"
+    )
+    
+    args = parser.parse_args()
+    
+    # Handle subcommands
+    if args.command == 'run':
+        run_core_service(args)
+    elif args.command == 'doctor':
+        run_doctor()
+    elif hasattr(args, 'drawing_assets') and args.drawing_assets is not None:  # Legacy mode - if any arguments are provided without subcommand
+        print("⚠️  Warning: Using legacy command format. Consider using 'nedo-core run --drawing-assets ...' instead.")
+        run_core_service(args)
+    else:
+        # If no subcommand provided, show help
+        parser.print_help()
+        sys.exit(1)
+
+
+def run_doctor():
+    """Run system diagnostics."""
+    try:
+        from .doctor import run_diagnostics
+        success = run_diagnostics()
+        sys.exit(0 if success else 1)
+    except ImportError:
+        print("❌ Doctor module not available")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Doctor failed: {e}")
+        sys.exit(1)
+
+
+def run_core_service(args):
+    """Run the core service with the provided arguments."""
+    
+def run_core_service(args):
+    """Run the core service with the provided arguments."""
+    # Set up signal handlers for graceful shutdown
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    logger = logging.getLogger(__name__)
+    
+    try:
+        # Create and start the core service
+        service = CoreService(
+            drawing_assets_path=args.drawing_assets,
+            log_level=args.log_level,
+            storage_path=args.storage_path,
+            rtmp_server=args.rtmp_server
+        )
+        
+        logger.info("🚀 Starting Nedo Vision Core...")
+        if args.drawing_assets:
+            logger.info(f"🎨 Drawing Assets: {args.drawing_assets}")
+        else:
+            logger.info("🎨 Drawing Assets: Using bundled assets")
+        logger.info(f"📝 Log Level: {args.log_level}")
+        logger.info(f"💾 Storage Path: {args.storage_path}")
+        logger.info(f"📡 RTMP Server: {args.rtmp_server}")
+        logger.info("Press Ctrl+C to stop the service")
+        
+        # Start the service
+        success = service.run()
+        
+        if success:
+            logger.info("✅ Core service completed successfully")
+        else:
+            logger.error("❌ Core service failed")
+            sys.exit(1)
+            
+    except Exception as e:
+        logger.error(f"❌ Error: {e}")
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()