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

nedo_vision_worker_core/detection/DetectionManager.py

@@ -0,0 +1,83 @@
+import logging
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except ImportError:
+    TORCH_AVAILABLE = False
+from .BaseDetector import BaseDetector
+from .RFDETRDetector import RFDETRDetector
+from .YOLODetector import YOLODetector
+
+
+class DetectionManager:
+    def __init__(self, model=None):
+        self.detector: BaseDetector | None = None
+        self.model_metadata = None
+
+        if model:
+            self.load_model(model)
+
+    def load_model(self, model):
+        """
+        Loads a new model at runtime and replaces current detector if successful.
+        Checks download status before attempting to load the model.
+        """
+        if not model:
+            if self.detector:
+                logging.info("🧹 Model unloaded")
+            self.detector = None
+            self.model_metadata = None
+            return
+
+        # Check download status before loading
+        if not model.is_ready_for_use():
+            if model.is_downloading():
+                logging.warning(f"⏳ Model {model.name} is still downloading. Skipping load.")
+                self.detector = None
+                self.model_metadata = None
+                return
+            elif model.has_download_failed():
+                logging.error(f"❌ Model {model.name} download failed: {model.download_error}")
+                self.detector = None
+                self.model_metadata = None
+                return
+            else:
+                logging.warning(f"⚠️ Model {model.name} is not ready for use (status: {model.download_status})")
+                self.detector = None
+                self.model_metadata = None
+                return
+
+        detector_type = model.type.lower()
+
+        try:
+            if detector_type == "yolo":
+                detector = YOLODetector(model)
+            elif detector_type == "rf_detr":
+                detector = RFDETRDetector(model)
+            else:
+                raise ValueError(f"Unsupported model type: {detector_type}")
+
+            if detector.model is not None:
+                self.detector = detector
+                self.model_metadata = model
+                # Log device info
+                if TORCH_AVAILABLE:
+                    device = "GPU" if torch.cuda.is_available() else "CPU"
+                else:
+                    device = "CPU (torch not installed)"
+                logging.info(f"🚀 Model {model.name} loaded on {device}")
+                logging.info(f"📥 Model {model.name} with {detector_type} detector loaded")
+            else:
+                logging.error(f"❌ Error loading model: {model.name} with {detector_type} detector")
+                self.detector = None
+                self.model_metadata = None
+
+        except Exception as e:
+            logging.error(f"❌ Error loading model: {model.name} with {detector_type} detector: {e}")
+            self.detector = None
+            self.model_metadata = None
+
+    def detect_objects(self, frame, confidence_threshold=0.7):
+        if not self.detector:
+            return []
+        return self.detector.detect_objects(frame, confidence_threshold)

nedo_vision_worker_core/detection/RFDETRDetector.py

@@ -0,0 +1,62 @@
+import cv2
+import logging
+try:
+    from rfdetr import RFDETRBase
+    RFDETR_AVAILABLE = True
+except ImportError:
+    RFDETR_AVAILABLE = False
+    RFDETRBase = None
+
+from ..database.DatabaseManager import DatabaseManager
+from .BaseDetector import BaseDetector
+
+logging.getLogger("ultralytics").setLevel(logging.WARNING)
+
+class RFDETRDetector(BaseDetector):
+    def __init__(self, model):
+        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."
+            )
+        self.model = None
+        self.metadata = None
+
+        if model:
+            self.load_model(model)
+
+    def load_model(self, model):
+        self.metadata = model
+        path = DatabaseManager.STORAGE_PATHS["models"] / model.file
+        
+        if not path.is_file() or path.stat().st_size == 0:
+            logging.error(f"❌ Model file not found or empty: {path}")
+            self.model = None
+            return False
+            
+        try:
+            self.model = RFDETRBase(pretrain_weights=path.as_posix())
+            self.model.optimize_for_inference()
+            return True
+        except Exception as e:
+            logging.error(f"❌ Error loading RFDETR model {model.name}: {e}")
+            self.model = None
+            return False
+
+    def detect_objects(self, frame, confidence_threshold=0.7):
+        if self.model is None:
+            return []
+
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self.model.predict(frame_rgb, confidence_threshold)
+
+        detections = []
+        for class_id, conf, xyxy in zip(results.class_id, results.confidence, results.xyxy): 
+            detections.append({
+                "label": self.model.class_names[class_id],
+                "confidence": conf,
+                "bbox": xyxy
+            })
+
+        return detections

nedo_vision_worker_core/detection/YOLODetector.py

@@ -0,0 +1,57 @@
+import cv2
+import logging
+from ultralytics import YOLO
+from ..database.DatabaseManager import DatabaseManager
+from .BaseDetector import BaseDetector
+
+logging.getLogger("ultralytics").setLevel(logging.WARNING)
+
+class YOLODetector(BaseDetector):
+    def __init__(self, model):
+        self.model = None
+        self.metadata = None
+
+        if model:
+            self.load_model(model)
+
+    def load_model(self, model):
+        self.metadata = model
+        path = DatabaseManager.STORAGE_PATHS["models"] / model.file
+        
+        # Check if file exists and has content
+        if not path.is_file() or path.stat().st_size == 0:
+            logging.error(f"❌ Model file not found or empty: {path}")
+            self.model = None
+            return False
+            
+        try:
+            self.model = YOLO(path)
+            return True
+        except Exception as e:
+            logging.error(f"❌ Error loading YOLO model {model.name}: {e}")
+            self.model = None
+            return False
+
+    def detect_objects(self, frame, target_classes=None, confidence_threshold=0.7):
+        if self.model is None:
+            return []
+
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = self.model(frame_rgb)
+
+        detections = []
+        for box in results[0].boxes:
+            class_id = int(box.cls)
+            label = self.model.names[class_id]
+            confidence = float(box.conf)
+
+            if confidence < confidence_threshold:
+                continue
+
+            detections.append({
+                "label": label,
+                "confidence": confidence,
+                "bbox": box.xyxy.tolist()[0]
+            })
+
+        return detections

nedo_vision_worker_core/detection/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/detection/detection_processing/DetectionProcessor.py

@@ -0,0 +1,29 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Tuple
+
+import numpy as np
+
+from ...ai.FrameDrawer import FrameDrawer
+from ...pipeline.PipelineConfigManager import PipelineConfigManager
+
+class DetectionProcessor(ABC):
+    code = ""
+    icons = {}
+    labels = []
+    exclusive_labels = []
+    violation_labels = []
+    compliance_labels = []
+
+    @abstractmethod
+    def process(self, detections: List[Dict[str, Any]], dimension: Tuple[int, int]) -> List[Dict[str, Any]]:
+        """Process raw detections and return processed results."""
+        pass
+
+    @abstractmethod
+    def update(self, config_manager: PipelineConfigManager):
+        pass
+
+    @abstractmethod
+    def save_to_db(self, pipeline_id: str, worker_source_id: str, frame_counter: int, tracked_objects: List[Dict[str, Any]], frame: np.ndarray, frame_drawer: FrameDrawer):
+        """Save processed detections to the database."""
+        pass

nedo_vision_worker_core/detection/detection_processing/HumanDetectionProcessor.py

@@ -0,0 +1,47 @@
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+from shapely.geometry import Polygon
+from .DetectionProcessor import DetectionProcessor
+from ...pipeline.PipelineConfigManager import PipelineConfigManager
+from ...repositories.RestrictedAreaRepository import RestrictedAreaRepository
+from ...util.PersonRestrictedAreaMatcher import PersonRestrictedAreaMatcher
+
+
+class HumanDetectionProcessor(DetectionProcessor):
+    code = "human"
+    labels = ["in_restricted_area"]
+    violation_labels = ["in_restricted_area"]
+
+    def __init__(self):
+        self.repository = RestrictedAreaRepository()
+        self.restricted_areas = []
+
+    def update(self, config_manager: PipelineConfigManager):
+        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
+        ]
+
+    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"]
+
+        height, width = dimension
+        area_polygons = []
+
+        for area in self.restricted_areas:
+            points = [(int(x * width), int(y * height)) for x, y in area]
+            area_polygons.append(Polygon(points))
+
+        matched_results = PersonRestrictedAreaMatcher.match_persons_with_restricted_areas(
+            persons, area_polygons
+        )
+
+        return matched_results
+
+    def save_to_db(self, pipeline_id: str, worker_source_id: str, frame_counter: int, tracked_objects: List[Dict[str, Any]], frame: np.ndarray, frame_drawer):
+        """Save the processed detections to the database if the feature is enabled."""
+        self.repository.save_area_violation(
+            pipeline_id, worker_source_id, frame_counter, tracked_objects, frame, frame_drawer
+        )

nedo_vision_worker_core/detection/detection_processing/PPEDetectionProcessor.py

@@ -0,0 +1,44 @@
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+from ...ai.FrameDrawer import FrameDrawer
+from .DetectionProcessor import DetectionProcessor
+from ...pipeline.PipelineConfigManager import PipelineConfigManager
+from ...repositories.PPEDetectionRepository import PPEDetectionRepository
+from ...util.PersonAttributeMatcher import PersonAttributeMatcher
+
+class PPEDetectionProcessor(DetectionProcessor):
+    code = "ppe"
+    icons = {
+        "helmet": "icons/helmet-green.png",
+        "no_helmet": "icons/helmet-red.png",
+        "vest": "icons/vest-green.png",
+        "no_vest": "icons/vest-red.png"
+    }
+    labels = ["helmet", "no_helmet", "vest", "no_vest", "gloves", "no_gloves", "goggles", "no_goggles", "boots", "no_boots"]
+    violation_labels = ["no_helmet", "no_vest", "no_gloves", "no_goggles", "no_boots"]
+    compliance_labels = ["helmet", "vest", "gloves", "goggles", "boots"]
+    exclusive_labels = [("helmet", "no_helmet"), ("vest", "no_vest"), ("gloves", "no_gloves"), ("goggles", "no_goggles"), ("boots", "no_boots")]
+
+    def __init__(self):
+        self.ppe_storage = PPEDetectionRepository()
+        self.types = []
+
+    def update(self, config_manager: PipelineConfigManager):
+        config = config_manager.get_feature_config(self.code, [])
+        self.types = config.get("ppeType", [])
+
+    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"]
+        ppe_attributes = [d for d in detections if any(x in d["label"] for x in self.types)]
+
+        matched_results = PersonAttributeMatcher.match_persons_with_attributes(
+            persons, ppe_attributes, coverage_threshold=0.5
+        )
+
+        return matched_results
+
+    def save_to_db(self, pipeline_id: str, worker_source_id: str, frame_counter: int, tracked_objects: List[Dict[str, Any]], frame: np.ndarray, frame_drawer: FrameDrawer):
+        self.ppe_storage.save_ppe_detection(
+            pipeline_id, worker_source_id, frame_counter, tracked_objects, frame, frame_drawer
+        )

nedo_vision_worker_core/detection/detection_processing/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/doctor.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""
+Nedo Vision Worker Core Doctor
+
+This module provides diagnostic capabilities to check system requirements
+and dependencies for the Nedo Vision Worker Core.
+"""
+
+import subprocess
+import sys
+import platform
+import shutil
+import os
+from pathlib import Path
+
+
+def check_python_version():
+    """Check if Python version meets requirements."""
+    print("🐍 Checking Python version...")
+    
+    version = sys.version_info
+    min_version = (3, 8)
+    
+    if version >= min_version:
+        print(f"   ✅ Python {version.major}.{version.minor}.{version.micro} (meets requirement >= {min_version[0]}.{min_version[1]})")
+        return True
+    else:
+        print(f"   ❌ Python {version.major}.{version.minor}.{version.micro} (requires >= {min_version[0]}.{min_version[1]})")
+        return False
+
+
+def check_pytorch():
+    """Check if PyTorch is properly installed."""
+    print("🔥 Checking PyTorch...")
+    
+    try:
+        import torch
+        import torchvision
+        
+        torch_version = torch.__version__
+        torchvision_version = torchvision.__version__
+        
+        print(f"   ✅ PyTorch {torch_version} installed")
+        print(f"   ✅ TorchVision {torchvision_version} installed")
+        
+        # Check CUDA availability
+        if torch.cuda.is_available():
+            device_count = torch.cuda.device_count()
+            current_device = torch.cuda.current_device()
+            device_name = torch.cuda.get_device_name(current_device)
+            
+            print(f"   🚀 CUDA available with {device_count} device(s)")
+            print(f"   🎮 Current device: {device_name}")
+            
+            # Check CUDA version
+            cuda_version = torch.version.cuda
+            if cuda_version:
+                print(f"   🔧 CUDA version: {cuda_version}")
+        else:
+            print("   ⚠️ CUDA not available (using CPU only)")
+        
+        # Test basic tensor operations
+        try:
+            x = torch.randn(5, 3)
+            y = torch.randn(3, 4)
+            z = torch.mm(x, y)
+            print("   ✅ PyTorch basic operations working")
+            return True
+        except Exception as e:
+            print(f"   ❌ PyTorch basic operations failed: {e}")
+            return False
+            
+    except ImportError as e:
+        print(f"   ❌ PyTorch not installed: {e}")
+        return False
+    except Exception as e:
+        print(f"   ❌ PyTorch test failed: {e}")
+        return False
+
+
+def check_ultralytics():
+    """Check if Ultralytics (YOLO) is properly installed."""
+    print("🎯 Checking Ultralytics YOLO...")
+    
+    try:
+        from ultralytics import YOLO
+        import ultralytics
+        
+        version = ultralytics.__version__
+        print(f"   ✅ Ultralytics {version} installed")
+        
+        # Test YOLO model loading (without downloading)
+        try:
+            # Check if we can import required modules
+            from ultralytics.models import YOLO as YOLOModel
+            from ultralytics.utils import checks
+            print("   ✅ Ultralytics modules importing correctly")
+            return True
+        except Exception as e:
+            print(f"   ⚠️ Ultralytics modules test failed: {e}")
+            return False
+            
+    except ImportError:
+        print("   ❌ Ultralytics not installed")
+        return False
+    except Exception as e:
+        print(f"   ❌ Ultralytics test failed: {e}")
+        return False
+
+
+def check_opencv():
+    """Check if OpenCV is properly installed."""
+    print("👁️ Checking OpenCV...")
+    
+    try:
+        import cv2
+        version = cv2.__version__
+        build_info = cv2.getBuildInformation()
+        
+        print(f"   ✅ OpenCV {version} installed")
+        
+        # Check OpenCV build configuration
+        if "CUDA" in build_info:
+            print("   🚀 OpenCV built with CUDA support")
+        if "OpenMP" in build_info:
+            print("   ⚡ OpenCV built with OpenMP support")
+        
+        # Check for platform-specific optimizations
+        machine = platform.machine()
+        if machine in ["aarch64", "armv7l", "arm64"]:
+            if "NEON" in build_info:
+                print("   🎯 OpenCV built with ARM NEON optimizations")
+            else:
+                print("   ⚠️ OpenCV may not have ARM optimizations")
+        
+        # Test basic functionality
+        import numpy as np
+        test_img = np.zeros((100, 100, 3), dtype=np.uint8)
+        
+        # Test encoding/decoding
+        _, encoded = cv2.imencode('.jpg', test_img)
+        decoded = cv2.imdecode(encoded, cv2.IMREAD_COLOR)
+        
+        if decoded is not None:
+            print("   ✅ OpenCV basic functionality working")
+            return True
+        else:
+            print("   ❌ OpenCV encoding/decoding test failed")
+            return False
+            
+    except ImportError:
+        print("   ❌ OpenCV not installed")
+        return False
+    except Exception as e:
+        print(f"   ❌ OpenCV test failed: {e}")
+        return False
+
+
+def check_ffmpeg():
+    """Check if FFmpeg is installed and accessible."""
+    print("🎬 Checking FFmpeg...")
+    
+    try:
+        # Check if ffmpeg is in PATH
+        ffmpeg_path = shutil.which("ffmpeg")
+        if not ffmpeg_path:
+            print("   ❌ FFmpeg not found in PATH")
+            return False
+        
+        # Check ffmpeg version
+        result = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            # Extract version from output
+            version_line = result.stdout.split('\n')[0]
+            print(f"   ✅ {version_line}")
+            print(f"   📍 Location: {ffmpeg_path}")
+            return True
+        else:
+            print("   ❌ FFmpeg found but failed to get version")
+            return False
+            
+    except subprocess.TimeoutExpired:
+        print("   ❌ FFmpeg check timed out")
+        return False
+    except Exception as e:
+        print(f"   ❌ Error checking FFmpeg: {e}")
+        return False
+
+
+def check_storage_access():
+    """Check if storage directories are accessible."""
+    print("💾 Checking storage access...")
+    
+    try:
+        storage_path = Path("data")
+        
+        # Check if we can create the directory
+        storage_path.mkdir(exist_ok=True)
+        print(f"   ✅ Storage directory accessible: {storage_path.absolute()}")
+        
+        # Test write access
+        test_file = storage_path / "test_access.txt"
+        try:
+            with open(test_file, 'w') as f:
+                f.write("test")
+            test_file.unlink()  # Clean up
+            print("   ✅ Storage write access working")
+            return True
+        except Exception as e:
+            print(f"   ❌ Storage write access failed: {e}")
+            return False
+            
+    except Exception as e:
+        print(f"   ❌ Storage access check failed: {e}")
+        return False
+
+
+def check_system_resources():
+    """Check system resources (memory, disk space)."""
+    print("🖥️ Checking system resources...")
+    
+    try:
+        import psutil
+        
+        # Check memory
+        memory = psutil.virtual_memory()
+        memory_gb = memory.total / (1024**3)
+        print(f"   💾 Total RAM: {memory_gb:.1f} GB")
+        
+        if memory_gb >= 4:
+            print("   ✅ Sufficient RAM available")
+        else:
+            print("   ⚠️ Low RAM (recommended: 4+ GB)")
+        
+        # Check disk space
+        disk = psutil.disk_usage('.')
+        disk_free_gb = disk.free / (1024**3)
+        print(f"   💿 Free disk space: {disk_free_gb:.1f} GB")
+        
+        if disk_free_gb >= 2:
+            print("   ✅ Sufficient disk space available")
+        else:
+            print("   ⚠️ Low disk space (recommended: 2+ GB)")
+        
+        # Check CPU
+        cpu_count = psutil.cpu_count()
+        cpu_freq = psutil.cpu_freq()
+        print(f"   🔢 CPU cores: {cpu_count}")
+        if cpu_freq:
+            print(f"   ⚡ CPU frequency: {cpu_freq.current:.0f} MHz")
+        
+        return True
+        
+    except ImportError:
+        print("   ❌ psutil not installed for system resource checks")
+        return False
+    except Exception as e:
+        print(f"   ❌ System resource check failed: {e}")
+        return False
+
+
+def check_model_files():
+    """Check if model files are available."""
+    print("🤖 Checking model files...")
+    
+    try:
+        # Check for YOLO model file
+        model_file = Path("yolov11n.pt")
+        if model_file.exists():
+            size_mb = model_file.stat().st_size / (1024**2)
+            print(f"   ✅ YOLO model found: {model_file} ({size_mb:.1f} MB)")
+            return True
+        else:
+            print("   ⚠️ YOLO model file not found (will be downloaded on first use)")
+            return True  # Not a critical failure
+            
+    except Exception as e:
+        print(f"   ❌ Model file check failed: {e}")
+        return False
+
+
+def run_diagnostics():
+    """Run all diagnostic checks."""
+    print("🏥 Nedo Vision Worker Core - System Diagnostics")
+    print("=" * 60)
+    
+    checks = [
+        ("Python Version", check_python_version),
+        ("PyTorch", check_pytorch),
+        ("Ultralytics YOLO", check_ultralytics),
+        ("OpenCV", check_opencv),
+        ("FFmpeg", check_ffmpeg),
+        ("Storage Access", check_storage_access),
+        ("System Resources", check_system_resources),
+        ("Model Files", check_model_files),
+    ]
+    
+    results = []
+    
+    for name, check_func in checks:
+        print()
+        try:
+            result = check_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"   ❌ Unexpected error in {name}: {e}")
+            results.append((name, False))
+    
+    # Summary
+    print()
+    print("=" * 60)
+    print("📋 DIAGNOSTIC SUMMARY")
+    print("=" * 60)
+    
+    passed = 0
+    total = len(results)
+    
+    for name, result in results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"{status:8} {name}")
+        if result:
+            passed += 1
+    
+    print()
+    print(f"Results: {passed}/{total} checks passed")
+    
+    if passed == total:
+        print("🎉 All checks passed! The system is ready for Nedo Vision Worker Core.")
+        return True
+    else:
+        print("⚠️ Some checks failed. Please address the issues above.")
+        return False
+
+
+if __name__ == "__main__":
+    run_diagnostics()