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

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -0,0 +1,338 @@
+import logging
+import time
+import threading
+import queue
+from ..detection.detection_processing.HumanDetectionProcessor import HumanDetectionProcessor
+from ..detection.detection_processing.PPEDetectionProcessor import PPEDetectionProcessor
+from .PipelineConfigManager import PipelineConfigManager
+from .PipelinePrepocessor import PipelinePrepocessor
+from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
+from ..repositories.WorkerSourcePipelineDetectionRepository import WorkerSourcePipelineDetectionRepository
+from ..streams.VideoStreamManager import VideoStreamManager
+from ..ai.VideoDebugger import VideoDebugger
+from ..ai.FrameDrawer import FrameDrawer
+from ..tracker.TrackerManager import TrackerManager
+from ..detection.DetectionManager import DetectionManager
+from ..streams.RTMPStreamer import RTMPStreamer
+
+
+class PipelineProcessor:
+    """Handles pipeline processing including preprocessing, AI model inference, tracking, and video stream processing."""
+
+    def __init__(self, pipeline_id, worker_source_id, model, enable_visualization=True):
+        """
+        Initializes the PipelineProcessor with configurable detection labels.
+
+        :param model: The model to use for inference.
+        :param enable_visualization: Flag to enable visualization.
+        :param detection_labels: List of object labels to detect.
+        """
+        self.running = True
+        self.video_debugger = VideoDebugger(enable_visualization)
+        self.tracker_manager = TrackerManager()
+        self.detection_manager = DetectionManager(model)
+        self.config_manager = PipelineConfigManager()
+        self.preprocessor = PipelinePrepocessor()
+        self.detection_processor = None
+        self.threshold = 0.7
+
+        self.frame_queue = queue.Queue(maxsize=1)
+        self.tracked_objects_render = []
+        self.detection_thread = None
+        self.frame_counter = 0
+        self.frame_drawer = FrameDrawer()
+        self.pipeline_id = pipeline_id
+        self.worker_source_id = worker_source_id
+
+        self.rtmp_streamer = None
+
+        self.detection_processor_codes = [
+            PPEDetectionProcessor.code,
+            HumanDetectionProcessor.code,
+        ]
+
+        self.debug_flag = False
+        self.debug_repo = WorkerSourcePipelineDebugRepository()
+        self.detection_repo = WorkerSourcePipelineDetectionRepository()
+
+    def _get_detection_processor_code(self):
+        for code in self.detection_processor_codes:
+            if self.config_manager.is_feature_enabled(code):
+                return code
+            
+        return None
+    
+    def _get_detection_processor(self, code):
+        if code == PPEDetectionProcessor.code:
+            return PPEDetectionProcessor()
+        elif code == HumanDetectionProcessor.code:
+            return HumanDetectionProcessor()
+        else:
+            return None
+    
+    def _update_detection_processor(self):
+        code = self._get_detection_processor_code()
+
+        if self.detection_processor and self.detection_processor.code == code:
+            return
+        
+        self.detection_processor = self._get_detection_processor(code)
+        if self.detection_processor:
+            self.frame_drawer.update_config(
+                icons=self.detection_processor.icons,
+                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
+        
+    def _update_config(self):
+        self.config_manager.update(self.pipeline_id)
+        self.preprocessor.update(self.config_manager)
+        self.detection_interval = self._get_detection_interval()
+        self._update_detection_processor()
+
+        if self.detection_processor:
+            config = self.config_manager.get_feature_config(self.detection_processor.code)
+            self.detection_processor.update(self.config_manager)
+            self.threshold = config.get("minimumDetectionConfidence", 0.7)
+
+            if self.detection_processor.code == HumanDetectionProcessor.code:
+                self.frame_drawer.polygons = [((0, 0, 255), p) for p in self.detection_processor.restricted_areas]
+        else:
+            self.threshold = 0.7
+            self.frame_drawer.update_config()
+            self.tracker_manager.attribute_labels = []
+            self.tracker_manager.exclusive_attribute_groups = []
+
+    def process_pipeline(self, video_manager: VideoStreamManager):
+        """
+        Runs the full pipeline processing including preprocessing, detection and tracking.
+        """
+        pipeline_id = self.pipeline_id
+        worker_source_id = self.worker_source_id
+
+        logging.info(f"🎯 Running pipeline processing for pipeline {pipeline_id} | Source: {worker_source_id}")
+
+        self._update_config()
+
+        initial_frame = self._wait_for_frame(video_manager)
+        if initial_frame is None:
+            logging.error(f"❌ Pipeline {pipeline_id} | Source {worker_source_id}: No initial frame available. Exiting...")
+            return
+
+        self.rtmp_streamer = RTMPStreamer(pipeline_id)
+
+        # Start detection in a separate thread
+        self.detection_thread = threading.Thread(
+            target=self._detection_worker,
+            name=f"detection-{pipeline_id}"
+        )
+        self.detection_thread.daemon = True
+        self.detection_thread.start()
+
+        try:
+            while self.running:
+                frame = video_manager.get_frame(worker_source_id)
+
+                if frame is None:
+                    logging.warning(f"⚠️ No frame available for {worker_source_id}. Retrying...")
+                    # Check if stream was removed
+                    if not video_manager.has_stream(worker_source_id):
+                        logging.info(f"🛑 Stream {worker_source_id} was removed, stopping pipeline")
+                        break
+                    time.sleep(0.01)
+                    continue
+
+                self.frame_counter += 1
+
+                self.frame_drawer.draw_polygons(frame)
+                drawn_frame = self.frame_drawer.draw_frame(
+                    frame.copy(),
+                    self.tracked_objects_render,
+                    with_trails=True,
+                    trail_length=int(2 / self.detection_interval)
+                )
+
+                if self.debug_flag:
+                    tracked_objects_render = self._process_frame(frame)
+
+                    self.debug_repo.update_debug_entries_by_pipeline_id(
+                        self.pipeline_id, 
+                        self.frame_drawer.draw_frame(
+                            frame.copy(),
+                            tracked_objects_render
+                        ),
+                        tracked_objects_render
+                    )
+                    self.debug_flag = False
+
+                # Check RTMP streamer status before sending frame
+                if self.rtmp_streamer:
+                    try:
+                        self.rtmp_streamer.send_frame(drawn_frame)
+                    except Exception as e:
+                        logging.error(f"❌ RTMP streaming error: {e}")
+                        # Stop RTMP streamer on error
+                        self.rtmp_streamer.stop_stream()
+                        self.rtmp_streamer = None
+
+                # Only put frame in queue if detection thread is still running
+                if self.detection_thread and self.detection_thread.is_alive():
+                    if not self.frame_queue.full():
+                        self.frame_queue.put(frame, block=False)
+
+                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}")
+
+                time.sleep(0.01)
+        except Exception as e:
+            logging.error(f"❌ Error in pipeline {pipeline_id}: {e}", exc_info=True)
+
+    def _process_frame(self, frame):
+        dimension = frame.shape[:2]
+
+        processed_frame = self.preprocessor.apply(frame)
+        detections = self.detection_manager.detect_objects(processed_frame, self.threshold)    
+        detections = self.preprocessor.revert_detections_bboxes(detections, dimension)
+        matched_results = self.detection_processor.process(detections, dimension)
+        return self.tracker_manager.track_objects(matched_results)
+
+
+    def _detection_worker(self):
+        """
+        Runs detection in a separate thread and updates configuration periodically.
+        Applies preprocessing based on pipeline configuration.
+        """
+        pipeline_id = self.pipeline_id
+        worker_source_id = self.worker_source_id
+        last_detection_time = time.time()
+        last_config_update_time = time.time()  
+        config_update_interval = 5  # Update configuration every 5 seconds
+
+        while self.running:
+            try:
+                frame = self.frame_queue.get(block=True, timeout=1)
+                current_time = time.time()
+
+                # Update config periodically
+                if (current_time - last_config_update_time) >= config_update_interval:
+                    self._update_config()
+                    last_config_update_time = current_time 
+                    logging.info(f"🔄 Updated pipeline config for {pipeline_id}")
+
+                # Process detection only if enough time has passed since last detection
+                # detection_interval is the time in seconds between consecutive detections
+                if (current_time - last_detection_time) < self.detection_interval:
+                    continue
+
+                last_detection_time = current_time 
+                
+                if self.detection_processor is None or frame is None or frame.size == 0:
+                    self.tracked_objects_render = []
+                    continue
+
+                self.tracked_objects_render = self._process_frame(frame)
+                
+                # Save to database if enabled
+                if self.config_manager.is_feature_enabled("db"):
+                    self.detection_processor.save_to_db(
+                        pipeline_id,
+                        worker_source_id,
+                        self.frame_counter,
+                        self.tracked_objects_render,
+                        frame,
+                        self.frame_drawer
+                    )
+
+                if self.config_manager.is_feature_enabled("webhook") or self.config_manager.is_feature_enabled("mqtt"):
+                    self.detection_repo.save_detection(
+                        pipeline_id,
+                        frame,
+                        self.tracked_objects_render,
+                        self.frame_drawer
+                    )
+
+            except queue.Empty:
+                pass
+            except Exception as e:
+                logging.error(f"❌ Error in detection thread for pipeline {pipeline_id}: {e}", exc_info=True)
+    
+    def _wait_for_frame(self, video_manager, max_retries=10, sleep_time=3):
+        """Waits until a frame is available from the video source."""
+        for retry_count in range(max_retries):
+            frame = video_manager.get_frame(self.worker_source_id)
+            if frame is not None:
+                return frame
+            logging.warning(f"⚠️ Waiting for video stream {self.worker_source_id} (Attempt {retry_count + 1}/{max_retries})...")
+            time.sleep(sleep_time)
+
+        return None
+
+    def stop(self):
+        """Stops the Pipeline processor and cleans up resources."""
+        if not self.running:  # Prevent multiple stops
+            return
+            
+        logging.info("🛑 Stopping PipelineProcessor...")
+        self.running = False
+
+        # Stop RTMP streamer first
+        if hasattr(self, 'rtmp_streamer') and self.rtmp_streamer:
+            try:
+                self.rtmp_streamer.stop_stream()
+                self.rtmp_streamer = None
+            except Exception as e:
+                logging.error(f"Error stopping RTMP streamer: {e}")
+
+        # Clear frame queue before joining thread
+        try:
+            while True:
+                try:
+                    self.frame_queue.get_nowait()
+                except queue.Empty:
+                    break
+        except Exception as e:
+            logging.error(f"Error clearing frame queue: {e}")
+
+        # Wait for detection thread with increased timeout
+        if self.detection_thread and self.detection_thread.is_alive():
+            try:
+                self.detection_thread.join(timeout=5.0)  # Increased timeout
+                if self.detection_thread.is_alive():
+                    logging.warning("Detection thread did not terminate cleanly")
+            except Exception as e:
+                logging.error(f"Error joining detection thread: {e}")
+            finally:
+                self.detection_thread = None
+
+        # Clear tracked objects
+        self.tracked_objects_render.clear()  # Use clear() instead of reassignment
+
+        # Close video debugger windows last
+        try:
+            if hasattr(self, 'video_debugger'):
+                self.video_debugger.close_all()
+        except Exception as e:
+            logging.error(f"Error closing video debugger: {e}")
+
+        logging.info("✅ PipelineProcessor stopped successfully")
+        
+    def _get_detection_interval(self):
+        """
+        Get detection interval from configuration.
+        Converts frames per second to seconds per frame.
+        """
+        config = self.config_manager.get_feature_config("processing_speed")
+        fps = config.get("decimal", 1.0)
+        
+        if fps <= 0:
+            return 1 / 10  # Default to 10 frame per second if fps is zero or negative 
+        
+        return 1.0 / fps  # Convert fps to seconds per frame
+
+    def enable_debug(self):
+        """Enable debug mode for this pipeline."""
+        self.debug_flag = True

nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -0,0 +1,202 @@
+import json
+import logging
+import time
+import threading
+from typing import Dict, Set, Optional, Callable
+from ..repositories.AIModelRepository import AIModelRepository
+from ..repositories.WorkerSourcePipelineDebugRepository import WorkerSourcePipelineDebugRepository
+from ..repositories.WorkerSourcePipelineRepository import WorkerSourcePipelineRepository
+from .PipelineManager import PipelineManager
+from ..streams.VideoStreamManager import VideoStreamManager
+from ..util.ModelReadinessChecker import ModelReadinessChecker
+
+
+class PipelineSyncThread(threading.Thread):
+    """Thread responsible for synchronizing worker source pipelines from the database in real-time."""
+
+    def __init__(self, video_manager: VideoStreamManager, polling_interval=5, max_workers=4):
+        super().__init__(daemon=True)  # Runs as a daemon
+        self.video_manager = video_manager
+        self.polling_interval = polling_interval
+        self.pipeline_repo = WorkerSourcePipelineRepository()
+        self.debug_repo = WorkerSourcePipelineDebugRepository()
+        self.ai_model_repo = AIModelRepository()
+        self.running = True
+        self.pipeline_manager = PipelineManager(video_manager, self.on_pipeline_stopped, max_workers)
+
+    def _parse_json(self, value: str) -> Optional[dict]:
+        """Attempts to parse the value as JSON if applicable."""
+        if not value:
+            return None
+        
+        value = value.strip()  # Remove leading/trailing spaces
+        if (value.startswith("{") and value.endswith("}")) or (value.startswith("[") and value.endswith("]")):
+            try:
+                return json.loads(value)  # Parse JSON object or list
+            except json.JSONDecodeError:
+                pass  # Keep as string if parsing fails
+        return None
+        
+    def on_pipeline_stopped(self, pipeline_id: str) -> None:
+        """Set the pipeline as stopped in the database."""
+        pipeline = self.pipeline_repo.get_worker_source_pipeline(pipeline_id)
+        pipeline.pipeline_status_code = "run" if pipeline.pipeline_status_code == "restart" else "stop"
+        self.pipeline_repo.session.commit()
+
+    def run(self) -> None:
+        """Continuously updates pipelines based on database changes."""
+        while self.running:
+            try:
+                # Cache model and pipeline data
+                models = {m.id: m for m in self.ai_model_repo.get_models()}
+                db_pipelines = {p.id: p for p in self.pipeline_repo.get_all_pipelines()}
+                
+                # Get pipeline IDs for comparison
+                local_pipeline_ids = set(self.pipeline_manager.get_active_pipelines())
+                db_pipeline_ids = set(db_pipelines.keys())
+
+                restarted_pipeline = False
+
+                # Helper function for model lookup
+                def get_model(pipeline):
+                    return models.get(pipeline.ai_model_id)
+
+                # Process pipeline changes
+                self._add_new_pipelines(db_pipeline_ids - local_pipeline_ids, db_pipelines, get_model, restarted_pipeline)
+                self._remove_deleted_pipelines(local_pipeline_ids - db_pipeline_ids)
+                self._update_existing_pipelines(db_pipeline_ids & local_pipeline_ids, db_pipelines, get_model)
+
+                if restarted_pipeline:
+                    self.pipeline_repo.session.commit()
+
+            except Exception as e:
+                logging.error(f"⚠️ Error syncing pipelines from database: {e}", exc_info=True)
+
+            time.sleep(self.polling_interval) 
+
+    def _add_new_pipelines(self, pipeline_ids: Set[str], db_pipelines: Dict[str, object], 
+                           get_model: Callable, restarted_pipeline: bool) -> None:
+        """Add new pipelines that exist in DB but not locally."""
+        for pid in pipeline_ids:
+            pipeline = db_pipelines[pid]
+
+            if pipeline.pipeline_status_code == 'restart':
+                pipeline.pipeline_status_code = 'run'
+                restarted_pipeline = True
+
+            if pipeline.pipeline_status_code == 'run':
+                model = get_model(pipeline)
+                
+                # Check if model is ready before starting pipeline
+                if model:
+                    readiness = ModelReadinessChecker.check_model_readiness(model)
+                    if not readiness["ready"]:
+                        logging.warning(f"⚠️ Pipeline {pid} ({pipeline.name}): {readiness['reason']}. Skipping pipeline start.")
+                        continue
+                
+                logging.info(f"🟢 Adding new pipeline: {pid} ({pipeline.name})")
+                self.pipeline_manager.start_pipeline(pipeline, model)
+
+    def _remove_deleted_pipelines(self, pipeline_ids: Set[str]) -> None:
+        """Remove pipelines that exist locally but not in DB."""
+        for pid in pipeline_ids:
+            logging.info(f"🔴 Removing deleted pipeline: {pid}")
+            self.pipeline_manager.stop_pipeline(pid)
+
+    def _update_existing_pipelines(self, pipeline_ids: Set[str], db_pipelines: Dict[str, object], 
+                                  get_model: Callable) -> None:
+        """Update existing pipelines that need changes."""
+        debug_pipeline_ids = self.debug_repo.get_pipeline_ids_to_debug()
+
+        for pid in pipeline_ids:
+            db_pipeline = db_pipelines[pid]
+            local_pipeline = self.pipeline_manager.get_pipeline(pid)
+            processor = self.pipeline_manager.processors[pid]
+            local_proc = processor.detection_manager
+            db_model = get_model(db_pipeline)
+
+            self.update_pipeline(pid, db_pipeline, local_pipeline, local_proc, db_model, local_proc.model_metadata)
+            if pid in debug_pipeline_ids:
+                processor.enable_debug()
+
+    def update_pipeline(self, pid, db_pipeline, local_pipeline, local_proc, db_model, local_model):
+        """Handles pipeline updates, ensuring correct model and status."""
+        processor = self.pipeline_manager.processors.get(pid)
+        processor.frame_drawer.location_name = db_pipeline.location_name
+
+        # Case 1: Pipeline should be running but isn't
+        if db_pipeline.pipeline_status_code == "run" and not self.pipeline_manager.is_running(pid):
+            logging.info(f"🟢 Starting pipeline {pid}: {db_pipeline.name} (status: RUNNING)")
+            self.pipeline_manager.start_pipeline(db_pipeline, db_model)
+
+        # Case 2: Pipeline should be stopped but is running
+        elif db_pipeline.pipeline_status_code == "stop" and self.pipeline_manager.is_running(pid):
+            logging.info(f"🔴 Stopping pipeline {pid}: {db_pipeline.name} (status: STOPPED)")
+            self.pipeline_manager.stop_pipeline(pid)
+
+        # Case 3: Pipeline configuration has changed, needs restart
+        elif self._has_pipeline_changed(local_pipeline, db_pipeline):
+            logging.info(f"🟡 Updating pipeline {pid}: {db_pipeline.name} (status: RESTARTING)")
+            if self.pipeline_manager.is_running(pid):
+                self.pipeline_manager.stop_pipeline(pid)
+            self.pipeline_manager.start_pipeline(db_pipeline, db_model)
+
+        # Case 4: AI Model has changed
+        elif local_model and db_model and local_model.id != db_model.id:
+            if db_model:
+                readiness = ModelReadinessChecker.check_model_readiness(db_model)
+                if readiness["ready"]:
+                    local_proc.load_model(db_model)
+                    logging.info(f"🔄 Model updated for pipeline {pid}: {db_pipeline.name} "
+                                 f"(version: {db_model.version if db_model else 'removed'})")
+                else:
+                    logging.warning(f"⚠️ Pipeline {pid}: {readiness['reason']}")
+
+        # Case 5: Local model exists but doesn't match DB model
+        elif local_model and (not db_model or local_model.version != db_model.version):
+            if not db_model or ModelReadinessChecker.check_model_readiness(db_model)["ready"]:
+                local_proc.load_model(db_model)
+                logging.info(f"🔄 Model updated for pipeline {pid}: {db_pipeline.name} "
+                             f"(version: {db_model.version if db_model else 'removed'})")
+            else:
+                readiness = ModelReadinessChecker.check_model_readiness(db_model)
+                logging.warning(f"⚠️ Pipeline {pid}: {readiness['reason']}")
+
+        # Case 6: DB model exists but local model doesn't
+        elif db_model and not local_model:
+            readiness = ModelReadinessChecker.check_model_readiness(db_model)
+            if readiness["ready"]:
+                logging.info(f"🔄 Added model for pipeline {pid}: {db_pipeline.name} (version: {db_model.version})")
+                local_proc.load_model(db_model)
+            else:
+                logging.warning(f"⚠️ Pipeline {pid}: {readiness['reason']}")
+
+    def _has_pipeline_changed(self, local_pipeline, db_pipeline):
+        """Checks if the pipeline configuration has changed."""
+        if db_pipeline.pipeline_status_code == "restart":
+            return True
+
+        local_configs = local_pipeline.worker_source_pipeline_configs
+        db_configs = db_pipeline.worker_source_pipeline_configs
+
+        # Convert config objects to comparable structures
+        local_config_values = [
+            (config.pipeline_config_id, config.is_enabled, config.value, 
+             config.pipeline_config_name, config.pipeline_config_code)
+            for config in local_configs
+        ]
+
+        db_config_values = [
+            (config.pipeline_config_id, config.is_enabled, config.value, 
+             config.pipeline_config_name, config.pipeline_config_code)
+            for config in db_configs
+        ]
+
+        return sorted(local_config_values) != sorted(db_config_values)
+
+    def stop(self):
+        """Stops the synchronization thread and shuts down pipelines properly."""
+        logging.info("🛑 Stopping PipelineSyncThread...")
+        self.running = False
+        self.video_manager.stop_all()
+        self.pipeline_manager.shutdown()

nedo_vision_worker_core/pipeline/__init__.py

@@ -0,0 +1 @@
+ 

nedo_vision_worker_core/preprocessing/ImageResizer.py

@@ -0,0 +1,42 @@
+from typing import Tuple
+import cv2
+import numpy as np
+from ..pipeline.PipelineConfigManager import PipelineConfigManager
+from .Preprocessor import Preprocessor
+
+
+class ImageResizer(Preprocessor):
+    def __init__(self):
+        self.code = "resize"
+        self.is_enabled = False
+        self.factor = 1.0
+
+    def _get_factor(self, config: PipelineConfigManager) -> float:
+        if not self.is_enabled:
+            return 1.0
+        
+        resize_factor = config.get_feature_config(self.code, "1")
+
+        try:
+            return float(resize_factor)
+        except (ValueError, TypeError):
+            return 1.0
+
+    def update_config(self, config: PipelineConfigManager):
+        self.is_enabled = config.is_feature_enabled(self.code)
+        self.factor = self._get_factor(config)
+
+    def apply(self, image: np.ndarray) -> np.ndarray:
+        if not self.is_enabled or self.factor == 1.0:
+            return image
+
+        height, width = image.shape[:2]
+        new_height, new_width = int(height / self.factor), int(width / self.factor)
+
+        return cv2.resize(image, (new_width, new_height))
+    
+    def revert_bboxes(self, bboxes: np.ndarray, dimension: Tuple[int, int]) -> np.ndarray:
+        if not self.is_enabled or self.factor == 1.0:
+            return bboxes
+
+        return bboxes * self.factor

nedo_vision_worker_core/preprocessing/ImageRoi.py

@@ -0,0 +1,61 @@
+from typing import Tuple
+import cv2
+import numpy as np
+from ..pipeline.PipelineConfigManager import PipelineConfigManager
+from .Preprocessor import Preprocessor
+
+
+class ImageRoi(Preprocessor):
+    def __init__(self):
+        self.code = "roi"
+        self.is_enabled = False
+        self.normalized_points = []
+
+    def _get_roi_points(self, config: PipelineConfigManager) -> float:
+        if not self.is_enabled:
+            return []
+        
+        return config.get_feature_config(self.code, [])
+
+    def update_config(self, config: PipelineConfigManager):
+        self.is_enabled = config.is_feature_enabled(self.code)
+        self.normalized_points = self._get_roi_points(config)
+
+    def apply(self, image: np.ndarray) -> np.ndarray:
+        if not self.is_enabled or len(self.normalized_points) < 4:
+            return image
+        
+        height, width = image.shape[:2]
+        points = [(int(p["x"] * width), int(p["y"] * height)) for p in self.normalized_points]
+        x_coords = [p[0] for p in points]
+        y_coords = [p[1] for p in points]
+
+        roi_x = min(x_coords)
+        roi_y = min(y_coords)
+        roi_width = max(x_coords) - roi_x + 1 
+        roi_height = max(y_coords) - roi_y + 1 
+
+        cropped = image[roi_y:roi_y+roi_height, roi_x:roi_x+roi_width].copy()
+        mask = np.zeros(cropped.shape[:2], dtype=np.uint8)
+
+        offset_points = [(x - roi_x, y - roi_y) for x, y in points]
+        points_np = np.array(offset_points, dtype=np.int32).reshape((-1, 1, 2))
+
+        cv2.fillPoly(mask, [points_np], 255)
+
+        return cv2.bitwise_and(cropped, cropped, mask=mask)
+    
+
+    def revert_bboxes(self, bboxes: np.ndarray, dimension: Tuple[int, int]) -> np.ndarray:
+        if not self.is_enabled or len(self.normalized_points) < 4:
+            return bboxes
+
+        height, width = dimension
+        points = [(int(p["x"] * width), int(p["y"] * height)) for p in self.normalized_points]
+        x_coords = [p[0] for p in points]
+        y_coords = [p[1] for p in points]
+
+        roi_x = min(x_coords)
+        roi_y = min(y_coords)
+
+        return bboxes + np.array([roi_x, roi_y, roi_x, roi_y])

nedo_vision_worker_core/preprocessing/Preprocessor.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import Tuple
+import numpy as np
+
+from ..pipeline.PipelineConfigManager import PipelineConfigManager
+
+class Preprocessor(ABC):
+    @abstractmethod
+    def update_config(self, config: PipelineConfigManager):
+        pass
+    @abstractmethod
+    def apply(self, image: np.ndarray) -> np.ndarray:
+        pass
+    @abstractmethod
+    def revert_bboxes(self, bboxes: np.ndarray, dimension: Tuple[int, int]) -> np.ndarray:
+        pass

nedo_vision_worker_core/preprocessing/__init__.py

@@ -0,0 +1 @@
+