@camera.ui/camera-ui-opencv 0.0.20 → 0.0.22

package/package.json

@@ -1,28 +1,29 @@
 {
   "displayName": "OpenCV",
   "name": "@camera.ui/camera-ui-opencv",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "camera.ui opencv plugin",
   "author": "seydx (https://github.com/seydx/camera.ui)",
-  "main": "./src/main.py",
-  "type": "module",
+  "main": "./dist/main.py",
+  "type": "commonjs",
   "scripts": {
+    "bundle": "npm run format && npm run lint && cui bundle",
     "format": "ruff format",
     "install-updates": "npm i --save",
-    "lint": "ruff check --fix",
-    "update": "updates --update ./",
-    "prepublishOnly": "npm i --package-lock-only && npm run format && npm run lint"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "updates": "^16.4.0"
+    "lint": "ruff check",
+    "lint:fix": "ruff check --fix",
+    "prepublishOnly": "node -e \"if(!process.env.SAFE_PUBLISH){console.error('Error: Please use @camera.ui/cli to publish the plugin:\\n  npm run publish:alpha\\n  npm run publish:beta\\n  npm run publish:latest\\n');process.exit(1)}\"",
+    "publish:alpha": "cui publish --alpha",
+    "publish:beta": "cui publish --beta",
+    "publish:latest": "cui publish --latest",
+    "update": "updates --update ./"
   },
   "bugs": {
     "url": "https://github.com/seydx/camera.ui/issues"
   },
   "engines": {
-    "camera.ui": ">=0.0.34-alpha.1",
-    "node": ">=20.17.0"
+    "camera.ui": ">=0.0.34-alpha.2",
+    "node": ">=20.18.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",
   "keywords": [
@@ -39,6 +40,10 @@
   "camera.ui": {
     "pythonVersion": "3.11",
     "extension": "motionDetection",
-    "dependencies": []
+    "dependencies": [],
+    "options": {
+      "extendedMotionDetection": true
+    },
+    "bundled": true
   }
-}
+}

package/CHANGELOG.md

@@ -1,8 +0,0 @@
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [X.X.X] - ???
-
-- Initial Release

package/CONTRIBUTING.md

@@ -1 +0,0 @@
-# Contributing

package/LICENSE.md

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2023-2024 seydx <dev@seydx.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1 +0,0 @@
-# @camera.ui/camera-ui-opencv

package/config.schema.json

@@ -1,3 +0,0 @@
-{
-  "schema": {}
-}

package/requirements.txt

@@ -1,3 +0,0 @@
-numpy==1.26.4
-opencv-python-headless==4.10.0.84
-camera-ui-python-types==0.1.93

package/src/camera_detector.py

@@ -1,413 +0,0 @@
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Literal, Optional
-
-import cv2
-import numpy as np
-from camera_ui_python_types import (
-    CameraDevice,
-    CameraStorage,
-    Detection,
-    LoggerService,
-    PluginAPI,
-)
-from detector_defaults import (
-    available_models,
-    default_area,
-    default_area_bs,
-    default_area_fd,
-    default_blur,
-    default_dilt,
-    default_learning_rate,
-    default_model,
-    default_threshold,
-    default_threshold_bs,
-)
-from opencv_utils import get_detections, get_detections_bs, get_detections_fd
-from plugin_typings import CameraStorageValues
-
-background_tasks = set[asyncio.Task[Any]]()
-
-
-class CameraDetector:
-    def __init__(self, api: PluginAPI, camera: CameraDevice, logger: LoggerService) -> None:
-        super().__init__()
-
-        self.api = api
-        self.camera = camera
-        self.logger = logger
-
-        self.started = False
-        self.closed = False
-        self.frame_generation_task: Optional[asyncio.Task[Any]] = None
-        self.executor = None
-        self.previous_frame: Optional[np.ndarray[Any, Any]] = None
-
-        self.camera_storage: CameraStorage[CameraStorageValues] = self.__create_camera_storage()
-        self.camera.on_connected.subscribe(lambda connected: self.start() if connected else self.close())
-
-    def start(self) -> None:
-        if not self.started:
-            self.started = True
-            self.closed = False
-
-            self.executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="OpenCV")
-
-            self.logger.log(
-                f"Starting motion detection for camera {self.camera.name} ({self.__detector_model()})..."
-            )
-
-            self.frame_generation_task = asyncio.create_task(
-                self.__detect(), name=f"MotionDetection-{self.camera.name}"
-            )
-
-            background_tasks.add(self.frame_generation_task)
-            self.frame_generation_task.add_done_callback(
-                lambda _: background_tasks.remove(self.frame_generation_task)
-                if self.frame_generation_task in background_tasks
-                else None
-            )
-
-    def close(self) -> None:
-        if self.started and not self.closed:
-            self.started = False
-            self.closed = True
-
-            self.logger.log(f"Stopping motion detection for camera {self.camera.name}...")
-
-            if self.frame_generation_task is not None:
-                self.frame_generation_task.cancel()
-                self.frame_generation_task = None
-
-            if self.executor is not None:
-                self.executor.shutdown(wait=False)
-                self.executor = None
-
-    def restart(self) -> None:
-        self.logger.log(f"Restarting motion detection for camera {self.camera.name}...")
-
-        self.close()
-
-        if self.camera.connected:
-            self.start()
-
-    async def __detect(self) -> None:
-        while not self.closed:
-            try:
-                backSub: Optional[cv2.BackgroundSubtractorMOG2] = None
-
-                async for frame in self.camera.get_frames():
-                    if self.closed:
-                        break
-
-                    frame_image = await frame.to_image({"format": {"to": "gray"}})
-                    image_array = np.array(frame_image["image"])
-
-                    detector_model = self.__detector_model()
-
-                    if detector_model == "Frame Difference":
-                        area = self.camera_storage.values["frame_difference"]["area"]
-
-                        if self.previous_frame is None:
-                            self.previous_frame = image_array
-                            continue
-
-                        dets = await asyncio.get_event_loop().run_in_executor(
-                            self.executor,
-                            get_detections_fd,
-                            self.previous_frame,
-                            image_array,
-                            area,
-                        )
-
-                        self.previous_frame = image_array
-
-                    elif detector_model == "Background Substraction":
-                        if backSub is None:
-                            backSub = cv2.createBackgroundSubtractorMOG2(varThreshold=18, detectShadows=False)
-
-                        threshold = self.camera_storage.values["background_substraction"]["threshold"]
-                        area = self.camera_storage.values["background_substraction"]["area"]
-                        learning_rate = self.camera_storage.values["background_substraction"]["learning_rate"]
-
-                        dets = await asyncio.get_event_loop().run_in_executor(
-                            self.executor,
-                            get_detections_bs,
-                            image_array,
-                            backSub,
-                            threshold,
-                            area,
-                            learning_rate,
-                        )
-
-                    else:  # default
-                        blur = self.camera_storage.values["default"]["blur"]
-                        threshold = self.camera_storage.values["default"]["threshold"]
-                        area = self.camera_storage.values["default"]["area"]
-                        image_array = cv2.stackBlur(image_array, (blur, blur))
-
-                        if self.previous_frame is None:
-                            self.previous_frame = image_array
-                            continue
-
-                        dets = await asyncio.get_event_loop().run_in_executor(
-                            self.executor,
-                            get_detections,
-                            self.previous_frame,
-                            image_array,
-                            threshold,
-                            area,
-                        )
-
-                        self.previous_frame = image_array
-
-                    detections: list[Detection] = []
-
-                    for det in dets:
-                        (x1, y1, x2, y2) = det
-
-                        detection: Detection = {
-                            "label": "motion",
-                            "confidence": 1,
-                            "boundingBox": (x1, y1, x2, y2),
-                            "inputWidth": frame_image["info"]["width"],
-                            "inputHeight": frame_image["info"]["height"],
-                            "origWidth": frame.metadata["origWidth"],
-                            "origHeight": frame.metadata["origHeight"],
-                        }
-
-                        detections.append(detection)
-
-                    await self.camera.update_state("motion", {"detections": detections}, frame)
-            except asyncio.CancelledError:
-                break
-            except Exception as error:
-                self.logger.error(self.camera.name, "Error generating frames", error)
-                self.logger.log(self.camera.name, "Restarting motion detection in 5 seconds...")
-                await asyncio.sleep(5)
-                continue
-
-    def __detector_model(self) -> Literal["Frame Difference", "Background Substraction", "Default"]:
-        return self.camera_storage.values["motion_detector"]
-
-    def __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
-        camera_storage: CameraStorage[CameraStorageValues] = (
-            self.api.storage_controller.create_camera_storage(
-                self,
-                self.camera.id,
-                {
-                    "motion_detector": {
-                        "type": "string",
-                        "key": "motion_detector",
-                        "title": "Motion Detector",
-                        "description": "Select the motion detection model to use",
-                        "group": "Manage",
-                        "enum": available_models,
-                        "store": True,
-                        "defaultValue": default_model,
-                        "required": True,
-                        "onSet": self.__change_model,
-                    },
-                    "default": {
-                        "type": "object",
-                        "key": "default",
-                        "title": "Default",
-                        "description": "Settings for the default model",
-                        "group": "Default",
-                        "opened": True,
-                        "hidden": True,
-                        "properties": {
-                            "area": {
-                                "type": "number",
-                                "key": "area",
-                                "title": "Area",
-                                "description": "Minimum size of detected motion (pixels)",
-                                "store": True,
-                                "defaultValue": default_area,
-                                "minimum": 10,
-                                "maximum": 1000,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name, f"Default model motion area changed from {old} to {new}"
-                                ),
-                            },
-                            "threshold": {
-                                "type": "number",
-                                "key": "threshold",
-                                "title": "Threshold",
-                                "description": "Sensitivity of motion detection (higher = less sensitive)",
-                                "store": True,
-                                "defaultValue": default_threshold,
-                                "minimum": 1,
-                                "maximum": 255,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name, f"Default model threshold changed from {old} to {new}"
-                                ),
-                            },
-                            "blur": {
-                                "type": "number",
-                                "key": "blur",
-                                "title": "Blur",
-                                "description": "Gaussian blur radius to reduce noise",
-                                "store": True,
-                                "defaultValue": default_blur,
-                                "minimum": 1,
-                                "maximum": 21,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name, f"Default model blur radius changed from {old} to {new}"
-                                ),
-                            },
-                            "dilation": {
-                                "type": "number",
-                                "key": "dilation",
-                                "title": "Dilation",
-                                "description": "Expansion of detected motion areas",
-                                "store": True,
-                                "defaultValue": default_dilt,
-                                "minimum": 1,
-                                "maximum": 21,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name,
-                                    f"Default model dilation size changed from {old} to {new}",
-                                ),
-                            },
-                        },
-                    },
-                    "background_substraction": {
-                        "type": "object",
-                        "key": "background_substraction",
-                        "title": "Background Substraction",
-                        "description": "Settings for the background substraction model",
-                        "group": "Background Substraction",
-                        "opened": True,
-                        "hidden": True,
-                        "properties": {
-                            "area": {
-                                "type": "number",
-                                "key": "area",
-                                "title": "Area",
-                                "description": "Minimum size of detected motion (pixels)",
-                                "store": True,
-                                "defaultValue": default_area_bs,
-                                "minimum": 10,
-                                "maximum": 1000,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name,
-                                    f"Background substraction model area changed from {old} to {new}",
-                                ),
-                            },
-                            "threshold": {
-                                "type": "number",
-                                "key": "threshold",
-                                "title": "Threshold",
-                                "description": "Sensitivity of motion detection (higher = less sensitive)",
-                                "store": True,
-                                "defaultValue": default_threshold_bs,
-                                "minimum": 1,
-                                "maximum": 255,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name,
-                                    f"Background substraction model threshold changed from {old} to {new}",
-                                ),
-                            },
-                            "learning_rate": {
-                                "type": "number",
-                                "key": "threshold",
-                                "title": "Learning Rate",
-                                "description": "Speed of background model adaptation (0-1, -1 for auto)",
-                                "store": True,
-                                "defaultValue": default_learning_rate,
-                                "minimum": -1,
-                                "maximum": 1,
-                                "step": 0.01,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name,
-                                    f"Background substraction model threshold changed from {old} to {new}",
-                                ),
-                            },
-                        },
-                    },
-                    "frame_difference": {
-                        "type": "object",
-                        "key": "frame_difference",
-                        "title": "Frame Difference",
-                        "description": "Settings for the frame difference model",
-                        "group": "Frame Difference",
-                        "opened": True,
-                        "hidden": True,
-                        "properties": {
-                            "area": {
-                                "type": "number",
-                                "key": "area",
-                                "title": "Area",
-                                "description": "Minimum size of detected motion (pixels)",
-                                "store": True,
-                                "defaultValue": default_area_fd,
-                                "minimum": 10,
-                                "maximum": 1000,
-                                "step": 1,
-                                "required": True,
-                                "onSet": lambda old, new: self.logger.log(
-                                    self.camera.name,
-                                    f"Frame difference model area changed from {old} to {new}",
-                                ),
-                            }
-                        },
-                    },
-                },
-            )
-        )
-
-        current_model = camera_storage.values["motion_detector"]
-        current_model_schema = None
-
-        if current_model == "Default":
-            current_model_schema = camera_storage.getSchema("default")
-        elif current_model == "Background Substraction":
-            current_model_schema = camera_storage.getSchema("background_substraction")
-        elif current_model == "Frame Difference":
-            current_model_schema = camera_storage.getSchema("frame_difference")
-
-        if current_model_schema:
-            current_model_schema["hidden"] = False
-
-        return camera_storage
-
-    def __change_model(self, old_model: str, new_model: str) -> None:
-        self.logger.log(self.camera.name, f"Motion detection model changed from {old_model} to {new_model}")
-
-        old_schema = None
-        new_schema = None
-        self.previous_frame = None
-
-        if old_model == "Default":
-            old_schema = self.camera_storage.getSchema("default")
-        elif old_model == "Background Substraction":
-            old_schema = self.camera_storage.getSchema("background_substraction")
-        elif old_model == "Frame Difference":
-            old_schema = self.camera_storage.getSchema("frame_difference")
-
-        if new_model == "Default":
-            new_schema = self.camera_storage.getSchema("default")
-        elif new_model == "Background Substraction":
-            new_schema = self.camera_storage.getSchema("background_substraction")
-        elif new_model == "Frame Difference":
-            new_schema = self.camera_storage.getSchema("frame_difference")
-
-        if old_schema:
-            old_schema["hidden"] = True
-
-        if new_schema:
-            new_schema["hidden"] = False

package/src/detector_defaults.py

@@ -1,16 +0,0 @@
-default_area = 350
-default_area_fd = 350
-default_area_bs = 350
-
-default_threshold = 50
-default_threshold_bs = 50
-
-default_blur = 11
-default_dilt = 15
-
-default_learning_rate = -1
-
-available_models = ["Frame Difference", "Background Substraction", "Default"]
-
-
-default_model = "Background Substraction"

package/src/main.py

@@ -1,340 +0,0 @@
-import asyncio
-import tempfile
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Optional, Union
-
-import cv2
-import numpy as np
-from camera_detector import CameraDetector
-from camera_ui_python_types import (
-    CameraDevice,
-    CameraExtension,
-    FormSubmitResponse,
-    LoggerService,
-    MotionDetectionPlugin,
-    MotionDetectionPluginResponse,
-    PluginAPI,
-    RootSchema,
-)
-from detector_defaults import (
-    default_area,
-    default_area_bs,
-    default_area_fd,
-    default_blur,
-    default_dilt,
-    default_learning_rate,
-    default_model,
-    default_threshold,
-    default_threshold_bs,
-)
-from opencv_utils import get_detections, get_detections_bs, get_detections_fd, merge_overlapping_boxes
-
-
-class OpenCV(MotionDetectionPlugin):
-    def __init__(self, logger: LoggerService, api: PluginAPI):
-        self.api = api
-        self.logger = logger
-        self.cameras: dict[str, CameraDevice] = {}
-        self.detectors: dict[str, CameraDetector] = {}
-
-        self.api.on("finishLaunching", self.start)
-        self.api.on("shutdown", self.stop)
-
-        self.api.device_manager.on("cameraSelected", self.camera_selected)
-        self.api.device_manager.on("cameraDeselected", self.camera_deselected)
-
-    async def camera_selected(self, camera: CameraDevice, extension: CameraExtension) -> None:
-        self.logger.log(f"New camera added ({extension}): {camera.name}")
-        self.cameras[camera.id] = camera
-        self.create_detector(camera)
-
-    def camera_deselected(self, id: str, extension: CameraExtension) -> None:
-        camera = self.cameras.get(id)
-
-        if camera:
-            self.logger.log(f"Camera removed ({extension}): {camera.name}")
-            self.remove_detector(self.cameras[id])
-            del self.cameras[id]
-
-    def start(self) -> None:
-        self.logger.log("Plugin Started")
-
-        for camera_device in self.cameras.values():
-            self.create_detector(camera_device)
-
-    def stop(self) -> None:
-        self.logger.log("Plugin Stopped")
-
-        detectors_copy = list(self.detectors.values())
-
-        for detector in detectors_copy:
-            self.remove_detector(detector.camera)
-
-    async def onFormSubmit(self, action_id: str, payload: Any) -> Union[FormSubmitResponse, None]:
-        print("Form submitted", action_id, payload)
-
-    def configureCameras(self, cameras: list[CameraDevice]) -> None:
-        for camera in cameras:
-            self.cameras[camera.id] = camera
-
-    def create_detector(self, camera: CameraDevice) -> None:
-        detector = CameraDetector(self.api, camera, self.logger)
-        self.detectors[camera.id] = detector
-
-    def remove_detector(self, camera: CameraDevice) -> None:
-        detector = self.detectors[camera.id]
-
-        if detector:
-            detector.close()
-            del self.detectors[camera.id]
-
-    def interfaceSchema(self) -> RootSchema:
-        root_schema: RootSchema = {
-            "schema": {
-                "motion_detector": {
-                    "type": "string",
-                    "key": "motion_detector",
-                    "title": "Motion Detector",
-                    "description": "Select the motion detection model to use",
-                    "enum": ["Frame Difference", "Background Substraction", "Default"],
-                    "store": False,
-                    "defaultValue": default_model,
-                    "required": True,
-                },
-                "default": {
-                    "type": "object",
-                    "key": "default",
-                    "title": "Default",
-                    "description": "Settings for the default model",
-                    "group": "Default",
-                    "opened": True,
-                    "hidden": True,
-                    "properties": {
-                        "area": {
-                            "type": "number",
-                            "key": "area",
-                            "title": "Area",
-                            "description": "Minimum size of detected motion (pixels)",
-                            "store": False,
-                            "defaultValue": default_area,
-                            "minimum": 10,
-                            "maximum": 1000,
-                            "step": 1,
-                            "required": True,
-                        },
-                        "threshold": {
-                            "type": "number",
-                            "key": "threshold",
-                            "title": "Threshold",
-                            "description": "Sensitivity of motion detection (higher = less sensitive)",
-                            "store": False,
-                            "defaultValue": default_threshold,
-                            "minimum": 1,
-                            "maximum": 255,
-                            "step": 1,
-                            "required": True,
-                        },
-                        "blur": {
-                            "type": "number",
-                            "key": "blur",
-                            "title": "Blur",
-                            "description": "Gaussian blur radius to reduce noise",
-                            "store": False,
-                            "defaultValue": default_blur,
-                            "minimum": 1,
-                            "maximum": 21,
-                            "step": 1,
-                            "required": True,
-                        },
-                        "dilation": {
-                            "type": "number",
-                            "key": "dilation",
-                            "title": "Dilation",
-                            "description": "Expansion of detected motion areas",
-                            "store": False,
-                            "defaultValue": default_dilt,
-                            "minimum": 1,
-                            "maximum": 21,
-                            "step": 1,
-                            "required": True,
-                        },
-                    },
-                },
-                "background_substraction": {
-                    "type": "object",
-                    "key": "background_substraction",
-                    "title": "Background Substraction",
-                    "description": "Settings for the background substraction model",
-                    "group": "Background Substraction",
-                    "opened": True,
-                    "hidden": True,
-                    "properties": {
-                        "area": {
-                            "type": "number",
-                            "key": "area",
-                            "title": "Area",
-                            "description": "Minimum size of detected motion (pixels)",
-                            "store": False,
-                            "defaultValue": default_area_bs,
-                            "minimum": 10,
-                            "maximum": 1000,
-                            "step": 1,
-                            "required": True,
-                        },
-                        "threshold": {
-                            "type": "number",
-                            "key": "threshold",
-                            "title": "Threshold",
-                            "description": "Sensitivity of motion detection (higher = less sensitive)",
-                            "store": False,
-                            "defaultValue": default_threshold_bs,
-                            "minimum": 1,
-                            "maximum": 255,
-                            "step": 1,
-                            "required": True,
-                        },
-                        "learning_rate": {
-                            "type": "number",
-                            "key": "threshold",
-                            "title": "Learning Rate",
-                            "description": "Speed of background model adaptation (0-1, -1 for auto)",
-                            "store": False,
-                            "defaultValue": default_learning_rate,
-                            "minimum": -1,
-                            "maximum": 1,
-                            "step": 0.01,
-                            "required": True,
-                        },
-                    },
-                },
-                "frame_difference": {
-                    "type": "object",
-                    "key": "frame_difference",
-                    "title": "Frame Difference",
-                    "description": "Settings for the frame difference model",
-                    "group": "Frame Difference",
-                    "opened": True,
-                    "hidden": True,
-                    "properties": {
-                        "area": {
-                            "type": "number",
-                            "key": "area",
-                            "title": "Area",
-                            "description": "Minimum size of detected motion (pixels)",
-                            "store": False,
-                            "defaultValue": default_area_fd,
-                            "minimum": 10,
-                            "maximum": 1000,
-                            "step": 1,
-                            "required": True,
-                        }
-                    },
-                },
-            }
-        }
-
-        return root_schema
-
-    async def detectMotion(self, video_path: str, config: dict[str, Any]) -> MotionDetectionPluginResponse:
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_file:
-            output_file = temp_file.name
-
-        cap = cv2.VideoCapture(video_path)
-        executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="OpenCV")
-
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        fps = int(cap.get(cv2.CAP_PROP_FPS))
-
-        fourcc = cv2.VideoWriter.fourcc("a", "v", "c", "1")
-        out = cv2.VideoWriter(output_file, fourcc, fps, (width, height))
-
-        previous_frame: Optional[np.ndarray[Any, Any]] = None
-        backSub = None
-
-        detector_model = config.get("motion_detector", "Default")
-
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-
-            if detector_model == "Frame Difference":
-                area = config.get("frame_difference", {}).get("area", default_area_fd)
-
-                if previous_frame is None:
-                    previous_frame = gray
-                    continue
-
-                dets = await asyncio.get_event_loop().run_in_executor(
-                    executor,
-                    get_detections_fd,
-                    previous_frame,
-                    gray,
-                    area,
-                )
-
-                previous_frame = gray
-
-            elif detector_model == "Background Substraction":
-                if backSub is None:
-                    backSub = cv2.createBackgroundSubtractorMOG2(varThreshold=18, detectShadows=False)
-
-                threshold = config.get("background_substraction", {}).get("threshold", default_threshold_bs)
-                area = config.get("background_substraction", {}).get("area", default_area_bs)
-
-                dets = await asyncio.get_event_loop().run_in_executor(
-                    executor,
-                    get_detections_bs,
-                    gray,
-                    backSub,
-                    threshold,
-                    area,
-                )
-
-            else:  # default
-                blur = config.get("default", {}).get("blur", default_blur)
-                threshold = config.get("default", {}).get("threshold", default_threshold)
-                area = config.get("default", {}).get("area", default_area)
-                gray = cv2.stackBlur(gray, (blur, blur))
-
-                if previous_frame is None:
-                    previous_frame = gray
-                    continue
-
-                dets = await asyncio.get_event_loop().run_in_executor(
-                    executor,
-                    get_detections,
-                    previous_frame,
-                    gray,
-                    threshold,
-                    area,
-                )
-
-                previous_frame = gray
-
-            merged_boxes = merge_overlapping_boxes(dets)
-
-            for det in merged_boxes:
-                (x1, y1, x2, y2) = det
-
-                pt1: cv2.typing.Point = (int(x1), int(y1))
-                pt2: cv2.typing.Point = (int(x2), int(y2))
-
-                cv2.rectangle(frame, pt1, pt2, (0, 255, 0), 2)
-
-            out.write(frame)
-
-        cap.release()
-        out.release()
-        executor.shutdown()
-
-        return {
-            "filePath": output_file,
-        }
-
-
-def __main__():
-    return OpenCV

package/src/opencv_utils.py

@@ -1,136 +0,0 @@
-from typing import Any, Union, cast
-
-import cv2
-import numpy as np
-
-DEFAULT_AREA_THRESHOLD = 500
-DEFAULT_THRESHOLD = 50
-DEFAULT_MASK_KERNEL = np.array((9, 9), dtype=np.uint8)
-DEFAULT_LEARNING_RATE = 0.08
-
-
-def merge_overlapping_boxes(
-    boxes: list[tuple[float, float, float, float]], overlap_threshold: float = 0.1
-) -> list[tuple[float, float, float, float]]:
-    if not boxes:
-        return []
-
-    boxes_array = np.array(boxes)
-    merged_boxes: list[tuple[float, float, float, float]] = []
-
-    while len(boxes_array) > 0:
-        box = boxes_array[0]
-        boxes_array: np.ndarray[Any, Any] = boxes_array[1:]
-
-        x1, y1, w1, h1 = box
-        x2 = x1 + w1
-        y2 = y1 + h1
-
-        indices_to_remove: list[int] = []
-        for i, (x1o, y1o, w1o, h1o) in enumerate(boxes_array):
-            x2o = x1o + w1o
-            y2o = y1o + h1o
-
-            xx1 = max(x1, x1o)
-            yy1 = max(y1, y1o)
-            xx2 = min(x2, x2o)
-            yy2 = min(y2, y2o)
-
-            w_overlap = max(0, xx2 - xx1)
-            h_overlap = max(0, yy2 - yy1)
-            overlap_area = w_overlap * h_overlap
-            area1 = w1 * h1
-            area2 = w1o * h1o
-
-            if area1 == 0 or area2 == 0:
-                continue
-            overlap_ratio = overlap_area / min(area1, area2)
-
-            if overlap_ratio > overlap_threshold:
-                x1 = min(x1, x1o)
-                y1 = min(y1, y1o)
-                x2 = max(x2, x2o)
-                y2 = max(y2, y2o)
-                indices_to_remove.append(i)
-
-        boxes_array = np.delete(boxes_array, indices_to_remove, axis=0)
-        merged_boxes.append((int(x1), int(y1), int(x2 - x1), int(y2 - y1)))
-
-    return merged_boxes
-
-
-def get_mask(
-    frame1: np.ndarray[Any, Any],
-    frame2: np.ndarray[Any, Any],
-    kernel: np.ndarray[Any, Any] = DEFAULT_MASK_KERNEL,
-) -> cv2.typing.MatLike:
-    frame_diff = cv2.subtract(frame2, frame1)
-    frame_diff = cv2.medianBlur(frame_diff, 3)
-
-    mask = cv2.adaptiveThreshold(
-        frame_diff, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 3
-    )
-    mask = cv2.medianBlur(mask, 3)
-    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=1)
-
-    return mask
-
-
-def get_motion_mask(
-    fg_mask: cv2.typing.MatLike,
-    threshold: int = DEFAULT_THRESHOLD,
-) -> cv2.typing.MatLike:
-    thresh = cv2.threshold(fg_mask, threshold, 255, cv2.THRESH_BINARY)[1]
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-
-    motion_mask = cv2.medianBlur(thresh, 3)
-    motion_mask = cv2.morphologyEx(motion_mask, cv2.MORPH_OPEN, kernel, iterations=1)
-    motion_mask = cv2.morphologyEx(motion_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
-
-    return motion_mask
-
-
-def get_contour_detections(
-    mask: cv2.typing.MatLike, area_threshold: int = DEFAULT_AREA_THRESHOLD
-) -> list[tuple[float, float, float, float]]:
-    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    detections: list[tuple[float, float, float, float]] = []
-    for cnt in cnts:
-        x, y, w, h = cv2.boundingRect(cnt)
-        area = w * h
-        if area > area_threshold:
-            detections.append((x, y, x + w, y + h))
-    return detections
-
-
-def get_detections(
-    blurred_frame1: cv2.typing.MatLike,
-    blurred_frame2: cv2.typing.MatLike,
-    threshold: int = DEFAULT_THRESHOLD,
-    area_threshold: int = DEFAULT_AREA_THRESHOLD,
-) -> list[tuple[float, float, float, float]]:
-    delta_frame = cv2.absdiff(blurred_frame1, blurred_frame2)
-    thresh_frame = cv2.threshold(delta_frame, threshold, 255, cv2.THRESH_BINARY)[1]
-    thresh_frame = cast(cv2.typing.MatLike, cv2.dilate(thresh_frame, None, iterations=2))  # type: ignore
-    return get_contour_detections(thresh_frame, area_threshold)
-
-
-def get_detections_fd(
-    frame1: np.ndarray[Any, Any],
-    frame2: np.ndarray[Any, Any],
-    area_threshold: int = DEFAULT_AREA_THRESHOLD,
-) -> list[tuple[float, float, float, float]]:
-    mask = get_mask(frame1, frame2, DEFAULT_MASK_KERNEL)
-    return get_contour_detections(mask, area_threshold)
-
-
-def get_detections_bs(
-    frame: np.ndarray[Any, Any],
-    backSub: Union[cv2.BackgroundSubtractorMOG2, cv2.BackgroundSubtractorKNN],
-    threshold: int = DEFAULT_THRESHOLD,
-    area_threshold: int = DEFAULT_AREA_THRESHOLD,
-    learning_rate: float = DEFAULT_LEARNING_RATE,
-) -> list[tuple[float, float, float, float]]:
-    fg_mask = backSub.apply(frame, learningRate=learning_rate)
-    motion_mask = get_motion_mask(fg_mask, threshold=threshold)
-    return get_contour_detections(motion_mask, area_threshold)

package/src/plugin_typings.py

@@ -1,29 +0,0 @@
-from typing import Literal, TypedDict
-
-Detectors = Literal["Frame Difference", "Background Substraction", "Default"]
-
-
-class DefaultModelValues(TypedDict):
-    area: int
-    threshold: int
-    blur: int
-    dilation: int
-    # reference_frame_frequency: int
-
-
-class BackgroundSubstractionValues(TypedDict):
-    area: int
-    threshold: int
-    learning_rate: float
-
-
-class FrameDifferenceValues(TypedDict):
-    area: int
-    # reference_frame_frequency: int
-
-
-class CameraStorageValues(TypedDict):
-    motion_detector: Detectors
-    default: DefaultModelValues
-    background_substraction: BackgroundSubstractionValues
-    frame_difference: FrameDifferenceValues