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

nedo_vision_worker_core/detection/detection_processing/PPEDetectionProcessor.py

@@ -6,6 +6,7 @@ from .DetectionProcessor import DetectionProcessor
 from ...pipeline.PipelineConfigManager import PipelineConfigManager
 from ...repositories.PPEDetectionRepository import PPEDetectionRepository
 from ...util.PersonAttributeMatcher import PersonAttributeMatcher
+from ...callbacks import DetectionType, DetectionAttribute, BoundingBox, DetectionData
 
 class PPEDetectionProcessor(DetectionProcessor):
     code = "ppe"
@@ -15,22 +16,118 @@ class PPEDetectionProcessor(DetectionProcessor):
         "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 = []
+        self.ppe_groups = {}
+        self.group_thresholds = {}
+        self.main_class_threshold = 0.7
+        self.main_class = "person"
+        
+        self.labels = ["helmet", "no_helmet", "vest", "no_vest", "gloves", "no_gloves", "goggles", "no_goggles", "boots", "no_boots"]
+        self.violation_labels = ["no_helmet", "no_vest", "no_gloves", "no_goggles", "no_boots"]
+        self.compliance_labels = ["helmet", "vest", "gloves", "goggles", "boots"]
+        self.exclusive_labels = [("helmet", "no_helmet"), ("vest", "no_vest"), ("gloves", "no_gloves"), ("goggles", "no_goggles"), ("boots", "no_boots")]
+
+    def update(self, config_manager: PipelineConfigManager, ai_model=None):
+        config = config_manager.get_feature_config(self.code, {})
+        
+        # Update from AI model
+        if ai_model:
+            self._update_from_ai_model(ai_model)
+        
+        # Update PPE type configuration
+        ppe_type_configs = config.get("ppeType", [])
+        self.types = []
+        self.group_thresholds = {}
+        
+        for ppe_config in ppe_type_configs:
+            if isinstance(ppe_config, dict):
+                group = ppe_config.get("group")
+                threshold = ppe_config.get("confidenceThreshold", 0.7)
+                if group:
+                    self.types.append(group)
+                    self.group_thresholds[group] = threshold
+            elif isinstance(ppe_config, str):
+                # Backward compatibility
+                self.types.append(ppe_config)
+                self.group_thresholds[ppe_config] = 0.7
+        
+        # Update main class threshold
+        self.main_class_threshold = config.get("mainClassConfidenceThreshold", 0.7)
+
+    def _update_from_ai_model(self, ai_model):
+        """Update processor settings from AI model configuration"""
+        if ai_model and hasattr(ai_model, 'ppe_groups') and ai_model.ppe_groups:
+            self.ppe_groups = {group.group_name: group for group in ai_model.ppe_groups}
+            self._build_labels_from_groups()
+            
+        if ai_model and hasattr(ai_model, 'main_class') and ai_model.main_class:
+            self.main_class = ai_model.main_class
 
-    def update(self, config_manager: PipelineConfigManager):
-        config = config_manager.get_feature_config(self.code, [])
-        self.types = config.get("ppeType", [])
+    def _build_labels_from_groups(self):
+        """Build standard PPE labels from AI model PPE groups"""
+        if not self.ppe_groups:
+            return
+            
+        labels = []
+        violation_labels = []
+        compliance_labels = []
+        exclusive_labels = []
+        
+        for group_name in self.ppe_groups.items():
+            compliance_class = group_name  
+            violation_class = f"no_{group_name}" 
+            
+            # Build label lists using standard naming
+            labels.extend([compliance_class, violation_class])
+            compliance_labels.append(compliance_class)
+            violation_labels.append(violation_class)
+            exclusive_labels.append((compliance_class, violation_class))
+        
+        # Update instance variables with dynamic labels
+        self.labels = labels
+        self.violation_labels = violation_labels
+        self.compliance_labels = compliance_labels
+        self.exclusive_labels = exclusive_labels
+
+    def get_multi_instance_classes(self):
+        """Get PPE classes that can have multiple instances per person"""
+        multi_instance_base = ["boots", "gloves", "goggles"]
+        multi_instance = []
+        
+        for label in self.labels:
+            base_label = label.replace("no_", "") if label.startswith("no_") else label
+            if base_label in multi_instance_base:
+                multi_instance.append(label)
+        return multi_instance
 
     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)]
+        persons = [d for d in detections if d["label"] == self.main_class]
+        
+        ppe_attributes = []
+        for detection in detections:
+            label = detection["label"]
+            
+            for group_name in self.types:
+                if group_name in self.ppe_groups:
+                    group_config = self.ppe_groups[group_name]
+                    
+                    original_compliance = group_config.get("compliance")
+                    original_violation = group_config.get("violation")
+                    
+                    if label in [original_compliance, original_violation]:
+                        if label == original_compliance:
+                            detection["label"] = group_name
+                        elif label == original_violation:
+                            detection["label"] = f"no_{group_name}"
+                        
+                        ppe_attributes.append(detection)
+                        break
+                elif label == group_name or label == f"no_{group_name}":
+                    ppe_attributes.append(detection)
+                    break
 
         matched_results = PersonAttributeMatcher.match_persons_with_attributes(
             persons, ppe_attributes, coverage_threshold=0.5
@@ -38,7 +135,73 @@ class PPEDetectionProcessor(DetectionProcessor):
 
         return matched_results
 
+    def get_class_thresholds(self):
+        """Get confidence thresholds for each class using original AI model class names"""
+        thresholds = {}
+        
+        for group_name, threshold in self.group_thresholds.items():
+            if group_name in self.ppe_groups:
+                group_config = self.ppe_groups[group_name]
+                
+                original_compliance = group_config.get("compliance")
+                original_violation = group_config.get("violation")
+                
+                if original_compliance:
+                    thresholds[original_compliance] = threshold
+                if original_violation:
+                    thresholds[original_violation] = threshold
+                    
+                thresholds[group_name] = threshold
+                thresholds[f"no_{group_name}"] = threshold
+            else:
+                thresholds[group_name] = threshold
+                if not group_name.startswith("no_"):
+                    thresholds[f"no_{group_name}"] = threshold
+        
+        return thresholds
+
     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
         )
+
+    @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 PPE detection data."""
+        bbox = BoundingBox.from_list(tracked_obj["bbox"])
+        
+        attributes = []
+        for attr in tracked_obj.get("attributes", []):
+            attr_bbox = None
+            if "bbox" in attr:
+                attr_bbox = BoundingBox.from_list(attr["bbox"])
+            
+            # Determine if this is a violation based on label
+            is_violation = attr["label"].startswith("no_") or attr["label"] in [
+                "no_helmet", "no_vest", "no_gloves", "no_goggles", "no_boots"
+            ]
+            
+            attributes.append(DetectionAttribute(
+                label=attr["label"],
+                confidence=attr.get("confidence", 1.0),
+                count=attr.get("count", 0),
+                bbox=attr_bbox,
+                is_violation=is_violation
+            ))
+        
+        return DetectionData(
+            detection_type=DetectionType.PPE_DETECTION,
+            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
+        )

nedo_vision_worker_core/models/ai_model.py

@@ -1,6 +1,6 @@
 import uuid
+import json
 from sqlalchemy import Column, String, DateTime
-from datetime import datetime
 from ..database.DatabaseManager import Base
 
 class AIModelEntity(Base):
@@ -15,6 +15,9 @@ class AIModelEntity(Base):
     download_status = Column(String, nullable=True, default="completed")  # pending, downloading, completed, failed
     last_download_attempt = Column(DateTime, nullable=True)
     download_error = Column(String, nullable=True)
+    classes = Column(String, nullable=True) 
+    ppe_class_groups = Column(String, nullable=True) 
+    main_class = Column(String, nullable=True)
 
     def __repr__(self):
         return (
@@ -38,4 +41,22 @@ class AIModelEntity(Base):
 
     def has_download_failed(self) -> bool:
         """Check if the model download has failed."""
-        return self.download_status == "failed"
+        return self.download_status == "failed"
+
+    def set_classes(self, classes_list):
+        self.classes = json.dumps(classes_list)
+
+    def get_classes(self):
+        return json.loads(self.classes) if self.classes else []
+
+    def set_ppe_class_groups(self, groups_list):
+        self.ppe_class_groups = json.dumps(groups_list)
+
+    def get_ppe_class_groups(self):
+        return json.loads(self.ppe_class_groups) if self.ppe_class_groups else []
+
+    def set_main_class(self, main_class):
+        self.main_class = main_class
+
+    def get_main_class(self):
+        return self.main_class or None

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -55,6 +55,21 @@ class PipelineProcessor:
         self.debug_repo = WorkerSourcePipelineDebugRepository()
         self.detection_repo = WorkerSourcePipelineDetectionRepository()
 
+    def load_model(self, model):
+        """
+        Load a new AI model into the detection manager.
+        This allows runtime model updates without restarting the pipeline.
+        
+        :param model: The new AI model to load
+        """
+        logging.info(f"🔄 Loading new model for pipeline {self.pipeline_id}: {model.name if model else 'None'}")
+        self.detection_manager.load_model(model)
+        
+        # Re-initialize detection processor to use the new model configuration
+        self._update_detection_processor()
+        
+        logging.info(f"✅ Model updated for pipeline {self.pipeline_id}")
+
     def _get_detection_processor_code(self):
         for code in self.detection_processor_codes:
             if self.config_manager.is_feature_enabled(code):
@@ -83,8 +98,15 @@ class PipelineProcessor:
                 violation_labels=self.detection_processor.violation_labels,
                 compliance_labels=self.detection_processor.compliance_labels,
             )
-            self.tracker_manager.attribute_labels = self.detection_processor.labels
-            self.tracker_manager.exclusive_attribute_groups = self.detection_processor.exclusive_labels
+            multi_instance_classes = []
+            if hasattr(self.detection_processor, 'get_multi_instance_classes'):
+                multi_instance_classes = self.detection_processor.get_multi_instance_classes()
+            
+            self.tracker_manager.update_config(
+                attribute_labels=self.detection_processor.labels,
+                exclusive_attribute_groups=self.detection_processor.exclusive_labels,
+                multi_instance_classes=multi_instance_classes
+            )
         
     def _update_config(self):
         self.config_manager.update(self.pipeline_id)
@@ -92,9 +114,11 @@ class PipelineProcessor:
         self.detection_interval = self._get_detection_interval()
         self._update_detection_processor()
 
+        ai_model = self.detection_manager.model_metadata
+
         if self.detection_processor:
             config = self.config_manager.get_feature_config(self.detection_processor.code)
-            self.detection_processor.update(self.config_manager)
+            self.detection_processor.update(self.config_manager, ai_model)
             self.threshold = config.get("minimumDetectionConfidence", 0.7)
 
             if self.detection_processor.code == HumanDetectionProcessor.code:
@@ -102,8 +126,11 @@ class PipelineProcessor:
         else:
             self.threshold = 0.7
             self.frame_drawer.update_config()
-            self.tracker_manager.attribute_labels = []
-            self.tracker_manager.exclusive_attribute_groups = []
+            self.tracker_manager.update_config(
+                attribute_labels=[], 
+                exclusive_attribute_groups=[], 
+                multi_instance_classes=[]
+            )
 
     def process_pipeline(self, video_manager: VideoStreamManager):
         """
@@ -195,10 +222,26 @@ class PipelineProcessor:
         dimension = frame.shape[:2]
 
         processed_frame = self.preprocessor.apply(frame)
-        detections = self.detection_manager.detect_objects(processed_frame, self.threshold)    
+        
+        class_thresholds = {}
+        ai_model = self.detection_manager.model_metadata
+        
+        if self.detection_processor:
+            if self.detection_processor.code == PPEDetectionProcessor.code:
+                class_thresholds.update(self.detection_processor.get_class_thresholds())
+            elif self.detection_processor.code == HumanDetectionProcessor.code:
+                main_threshold = self.detection_processor.get_main_class_threshold(ai_model)
+                if main_threshold and ai_model and ai_model.get_main_class():
+                    class_thresholds[ai_model.get_main_class()] = main_threshold
+        
+        detections = self.detection_manager.detect_objects(processed_frame, self.threshold, class_thresholds)    
         detections = self.preprocessor.revert_detections_bboxes(detections, dimension)
-        matched_results = self.detection_processor.process(detections, dimension)
-        return self.tracker_manager.track_objects(matched_results)
+        
+        if self.detection_processor:
+            matched_results = self.detection_processor.process(detections, dimension)
+            return self.tracker_manager.track_objects(matched_results)
+        else:
+            return self.tracker_manager.track_objects(detections)
 
 
     def _detection_worker(self):

nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -171,6 +171,38 @@ class PipelineSyncThread(threading.Thread):
             else:
                 logging.warning(f"⚠️ Pipeline {pid}: {readiness['reason']}")
 
+        # Case 7: Model metadata has changed (same ID and version, but different properties)
+        elif local_model and db_model and local_model.id == db_model.id and local_model.version == db_model.version:
+            # Check if model metadata (classes, PPE groups, main_class) has changed
+            if self._has_model_metadata_changed(local_model, db_model):
+                readiness = ModelReadinessChecker.check_model_readiness(db_model)
+                if readiness["ready"]:
+                    local_proc.load_model(db_model)
+                    logging.info(f"🔄 Model metadata updated for pipeline {pid}: {db_pipeline.name} "
+                                 f"(same version {db_model.version}, updated properties)")
+                else:
+                    logging.warning(f"⚠️ Pipeline {pid}: {readiness['reason']}")
+
+    def _has_model_metadata_changed(self, local_model, db_model):
+        """Check if model metadata has changed without version change."""
+        # Compare classes
+        local_classes = set(local_model.get_classes() or [])
+        db_classes = set(db_model.get_classes() or [])
+        if local_classes != db_classes:
+            return True
+        
+        # Compare PPE class groups
+        local_ppe_groups = local_model.get_ppe_class_groups() or {}
+        db_ppe_groups = db_model.get_ppe_class_groups() or {}
+        if local_ppe_groups != db_ppe_groups:
+            return True
+        
+        # Compare main class
+        if local_model.get_main_class() != db_model.get_main_class():
+            return True
+        
+        return False
+
     def _has_pipeline_changed(self, local_pipeline, db_pipeline):
         """Checks if the pipeline configuration has changed."""
         if db_pipeline.pipeline_status_code == "restart":

nedo_vision_worker_core/repositories/PPEDetectionRepository.py

@@ -120,23 +120,26 @@ class PPEDetectionRepository:
                 self.session.commit()
                 logging.info(f"✅ Inserted detection for Person {person_id}, Attributes: {valid_attributes}")
 
-                # Trigger detection callback
+                # Trigger detection callback with unified data structure
                 try:
                     from ..core_service import CoreService
-                    detection_data = {
-                        'type': 'ppe_detection',
-                        'pipeline_id': pipeline_id,
-                        'worker_source_id': worker_source_id,
-                        'person_id': person_id,
-                        'detection_id': new_detection.id,
-                        'attributes': valid_attributes,
-                        'confidence_score': tracked_obj.get("confidence", 1.0),
-                        'bbox': bbox,
-                        'image_path': full_image_path,
-                        'image_tile_path': cropped_image_path,
-                        'timestamp': current_datetime
-                    }
-                    CoreService.trigger_detection_callback('ppe_detection', detection_data)
+                    from ..detection.detection_processing.PPEDetectionProcessor import PPEDetectionProcessor
+                    
+                    # Create unified detection data using the processor's factory method
+                    unified_data = PPEDetectionProcessor.create_detection_data(
+                        pipeline_id=pipeline_id,
+                        worker_source_id=worker_source_id,
+                        person_id=person_id,
+                        detection_id=new_detection.id,
+                        tracked_obj=tracked_obj,
+                        image_path=full_image_path,
+                        image_tile_path=cropped_image_path,
+                        frame_id=frame_id
+                    )
+                    
+                    # Trigger callbacks
+                    CoreService.trigger_detection(unified_data)
+                    
                 except Exception as e:
                     logging.warning(f"⚠️ Failed to trigger PPE detection callback: {e}")
 

nedo_vision_worker_core/repositories/RestrictedAreaRepository.py

@@ -69,19 +69,23 @@ class RestrictedAreaRepository:
                 # Trigger detection callback
                 try:
                     from ..core_service import CoreService
-                    detection_data = {
-                        'type': 'area_violation',
-                        'pipeline_id': pipeline_id,
-                        'worker_source_id': worker_source_id,
-                        'person_id': person_id,
-                        'detection_id': new_detection.id if hasattr(new_detection, 'id') else None,
-                        'confidence_score': tracked_obj.get("confidence", 1.0),
-                        'bbox': bbox,
-                        'image_path': full_image_path,
-                        'image_tile_path': cropped_image_path,
-                        'timestamp': current_datetime
-                    }
-                    CoreService.trigger_detection_callback('area_violation', detection_data)
+                    from ..detection.detection_processing.HumanDetectionProcessor import HumanDetectionProcessor
+                    
+                    # Create unified detection data using the processor's factory method
+                    unified_data = HumanDetectionProcessor.create_detection_data(
+                        pipeline_id=pipeline_id,
+                        worker_source_id=worker_source_id,
+                        person_id=person_id,
+                        detection_id=new_detection.id if hasattr(new_detection, 'id') else f"area_{person_id}_{current_datetime}",
+                        tracked_obj=tracked_obj,
+                        image_path=full_image_path,
+                        image_tile_path=cropped_image_path,
+                        frame_id=frame_id
+                    )
+                    
+                    # Trigger callbacks
+                    CoreService.trigger_detection(unified_data)
+                    
                 except Exception as e:
                     logging.warning(f"⚠️ Failed to trigger area violation callback: {e}")