@camera.ui/camera-ui-opencv 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+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

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

package/LICENSE.md

@@ -0,0 +1,22 @@
+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

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

package/config.schema.json

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

package/package.json

@@ -0,0 +1,44 @@
+{
+  "displayName": "OpenCV",
+  "name": "@camera.ui/camera-ui-opencv",
+  "version": "0.0.1",
+  "description": "camera.ui opencv plugin",
+  "author": "seydx (https://github.com/seydx/camera.ui)",
+  "main": "./src/main.py",
+  "type": "module",
+  "scripts": {
+    "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.3.7"
+  },
+  "bugs": {
+    "url": "https://github.com/seydx/camera.ui/issues"
+  },
+  "engines": {
+    "camera.ui": ">=0.0.1",
+    "node": ">=18.12.0"
+  },
+  "homepage": "https://github.com/seydx/camera.ui#readme",
+  "keywords": [
+    "camera-ui-plugin",
+    "motion",
+    "opencv",
+    "detection"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seydx/camera.ui.git"
+  },
+  "camera.ui": {
+    "pythonVersion": "3.11",
+    "extension": "motionDetection",
+    "dependencies": []
+  }
+}

package/requirements-lock.txt

@@ -0,0 +1,6 @@
+# Python version: 3.11.9
+# Server version: 0.0.6
+# Dependency version: 0.1.64
+numpy==1.26.4
+opencv-python==4.10.0.84
+camera-ui-python-types==0.1.75

package/requirements.txt

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

package/ruff.toml

@@ -0,0 +1,90 @@
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 110
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py39"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = [
+    # pycodestyle
+    "E",
+    # Pyflakes
+    "F",
+    # pyupgrade
+    "UP",
+    # flake8-bugbear
+    "B",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+]
+ignore = ["E501", "B023", "B006"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = true
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"

package/src/camera_detector.py

@@ -0,0 +1,440 @@
+import asyncio
+import time
+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,
+    PluginAPI,
+    PluginLogger,
+)
+from opencv_utils import get_detections, get_detections_bs, get_detections_fd
+
+background_tasks = set[asyncio.Task[Any]]()
+
+
+defaultArea = 250
+defaultAreaFd = 500
+defaultAreaBs = 500
+
+defaultThreshold = 50
+defaultThresholdBs = 200
+
+defaultBlur = 9
+defaultDilt = 3
+
+defaultReferenceFrameFrequency = 5
+
+available_models = ["Frame Difference", "Background Substraction", "Default"]
+
+
+class CameraDetector:
+    def __init__(self, api: PluginAPI, camera: CameraDevice, logger: PluginLogger) -> None:
+        super().__init__()
+
+        self.api = api
+        self.camera = camera
+        self.logger = logger
+
+        self.started = False
+        self.closed = False
+        self.frame_generation_task = None
+        self.executor = None
+
+        self.camera_storage = 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:
+        try:
+            first_frame = None
+            last_frame_time = 0
+            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"])
+
+                now = time.time() * 1000
+
+                detector_model = self.__detector_model()
+
+                if detector_model == "Frame Difference":
+                    area = self.camera_storage.values["frame_difference"]["area"]
+                    reference_frame_frequency = self.camera_storage.values["frame_difference"][
+                        "reference_frame_frequency"
+                    ]
+
+                    if first_frame is None or (
+                        reference_frame_frequency
+                        and now - last_frame_time > (reference_frame_frequency * 1000)
+                    ):
+                        first_frame = image_array
+                        last_frame_time = now
+                        continue
+
+                    dets = await asyncio.get_event_loop().run_in_executor(
+                        self.executor,
+                        get_detections_fd,
+                        first_frame,
+                        image_array,
+                        area,
+                    )
+
+                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"]
+
+                    dets = await asyncio.get_event_loop().run_in_executor(
+                        self.executor,
+                        get_detections_bs,
+                        image_array,
+                        backSub,
+                        threshold,
+                        area,
+                    )
+
+                else:  # default
+                    blur = self.camera_storage.values["default"]["blur"]
+                    threshold = self.camera_storage.values["default"]["threshold"]
+                    area = self.camera_storage.values["default"]["area"]
+                    reference_frame_frequency = self.camera_storage.values["default"][
+                        "reference_frame_frequency"
+                    ]
+
+                    image_array = cv2.stackBlur(image_array, (blur, blur))
+
+                    if first_frame is None or (
+                        reference_frame_frequency
+                        and now - last_frame_time > (reference_frame_frequency * 1000)
+                    ):
+                        first_frame = image_array
+                        last_frame_time = now
+                        continue
+
+                    dets = await asyncio.get_event_loop().run_in_executor(
+                        self.executor,
+                        get_detections,
+                        first_frame,
+                        image_array,
+                        threshold,
+                        area,
+                    )
+
+                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:
+            pass
+        except Exception as error:
+            self.logger.error(self.camera.name, "Error generating frames", error)
+
+    def __detector_model(self) -> Literal["Frame Difference", "Background Substraction", "Default"]:
+        return self.camera_storage.values["motion_detector"]
+
+    def __create_camera_storage(self) -> CameraStorage:
+        camera_storage = self.api.storage_controller.get_camera_storage(self.camera.id)
+
+        if camera_storage is not None:
+            return camera_storage
+
+        camera_storage = 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",
+                    "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 area for a motion detection",
+                            "store": True,
+                            "defaultValue": defaultArea,
+                            "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": "Threshold for the default model",
+                            "store": True,
+                            "defaultValue": defaultThreshold,
+                            "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": "Blur for the default model",
+                            "store": True,
+                            "defaultValue": defaultBlur,
+                            "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": "Dilation for the default model",
+                            "store": True,
+                            "defaultValue": defaultDilt,
+                            "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}"
+                            ),
+                        },
+                        "reference_frame_frequency": {
+                            "type": "number",
+                            "key": "reference_frame_frequency",
+                            "title": "Reference Frame Frequency",
+                            "description": "Frequency to update the reference frame",
+                            "store": True,
+                            "defaultValue": defaultReferenceFrameFrequency,
+                            "minimum": 1,
+                            "maximum": 60,
+                            "step": 1,
+                            "required": True,
+                            "onSet": lambda old, new: self.logger.log(
+                                self.camera.name,
+                                f"Default model reference frame frequency 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 area for a motion detection",
+                            "store": True,
+                            "defaultValue": defaultAreaBs,
+                            "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": "Threshold for the background substraction",
+                            "store": True,
+                            "defaultValue": defaultThresholdBs,
+                            "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}",
+                            ),
+                        },
+                    },
+                },
+                "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 area for a motion detection",
+                            "store": True,
+                            "defaultValue": defaultAreaFd,
+                            "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}"
+                            ),
+                        },
+                        "reference_frame_frequency": {
+                            "type": "number",
+                            "key": "reference_frame_frequency",
+                            "title": "Reference Frame Frequency",
+                            "description": "Frequency to update the reference frame",
+                            "store": True,
+                            "defaultValue": defaultReferenceFrameFrequency,
+                            "minimum": 1,
+                            "maximum": 60,
+                            "step": 1,
+                            "required": True,
+                            "onSet": lambda old, new: self.logger.log(
+                                self.camera.name,
+                                f"Frae difference model reference frame frequency 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.get_schema("default")
+        elif current_model == "Background Substraction":
+            current_model_schema = camera_storage.get_schema("background_substraction")
+        elif current_model == "Frame Difference":
+            current_model_schema = camera_storage.get_schema("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
+
+        if old_model == "Default":
+            old_schema = self.camera_storage.get_schema("default")
+        elif old_model == "Background Substraction":
+            old_schema = self.camera_storage.get_schema("background_substraction")
+        elif old_model == "Frame Difference":
+            old_schema = self.camera_storage.get_schema("frame_difference")
+
+        if new_model == "Default":
+            new_schema = self.camera_storage.get_schema("default")
+        elif new_model == "Background Substraction":
+            new_schema = self.camera_storage.get_schema("background_substraction")
+        elif new_model == "Frame Difference":
+            new_schema = self.camera_storage.get_schema("frame_difference")
+
+        if old_schema:
+            old_schema["hidden"] = True
+
+        if new_schema:
+            new_schema["hidden"] = False

package/src/main.py

@@ -0,0 +1,351 @@
+import asyncio
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Union
+
+import cv2
+from camera_detector import (
+    CameraDetector,
+    defaultArea,
+    defaultAreaBs,
+    defaultAreaFd,
+    defaultBlur,
+    defaultReferenceFrameFrequency,
+    defaultThreshold,
+    defaultThresholdBs,
+)
+from camera_ui_python_types import (
+    CameraDevice,
+    CameraExtension,
+    FormSubmitResponse,
+    MotionDetectionPlugin,
+    MotionDetectionPluginResponse,
+    PluginAPI,
+    PluginLogger,
+    RootSchema,
+)
+from opencv_utils import get_detections, get_detections_bs, get_detections_fd
+
+
+class OpenCV(MotionDetectionPlugin):
+    def __init__(self, logger: PluginLogger, 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 configure_cameras(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 | None:
+        return {
+            "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",
+                    "required": True,
+                },
+                "default": {
+                    "type": "object",
+                    "key": "default",
+                    "title": "Default",
+                    "description": "Settings for the default model",
+                    "opened": False,
+                    "properties": {
+                        "area": {
+                            "type": "number",
+                            "key": "area",
+                            "title": "Area",
+                            "description": "Minimum area for a motion detection",
+                            "store": False,
+                            "defaultValue": 250,
+                            "minimum": 10,
+                            "maximum": 1000,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "threshold": {
+                            "type": "number",
+                            "key": "threshold",
+                            "title": "Threshold",
+                            "description": "Threshold for the default model",
+                            "store": False,
+                            "defaultValue": 50,
+                            "minimum": 1,
+                            "maximum": 255,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "blur": {
+                            "type": "number",
+                            "key": "blur",
+                            "title": "Blur",
+                            "description": "Blur for the default model",
+                            "store": False,
+                            "defaultValue": 9,
+                            "minimum": 1,
+                            "maximum": 21,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "dilation": {
+                            "type": "number",
+                            "key": "dilation",
+                            "title": "Dilation",
+                            "description": "Dilation for the default model",
+                            "store": False,
+                            "defaultValue": 3,
+                            "minimum": 1,
+                            "maximum": 21,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "reference_frame_frequency": {
+                            "type": "number",
+                            "key": "reference_frame_frequency",
+                            "title": "Reference Frame Frequency",
+                            "description": "Frequency to update the reference frame",
+                            "store": False,
+                            "defaultValue": 5,
+                            "minimum": 1,
+                            "maximum": 60,
+                            "step": 1,
+                            "required": True,
+                        },
+                    },
+                },
+                "background_substraction": {
+                    "type": "object",
+                    "key": "background_substraction",
+                    "title": "Background Substraction",
+                    "description": "Settings for the background substraction model",
+                    "opened": False,
+                    "properties": {
+                        "area": {
+                            "type": "number",
+                            "key": "area",
+                            "title": "Area",
+                            "description": "Minimum area for a motion detection",
+                            "store": False,
+                            "defaultValue": 500,
+                            "minimum": 10,
+                            "maximum": 1000,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "threshold": {
+                            "type": "number",
+                            "key": "threshold",
+                            "title": "Threshold",
+                            "description": "Threshold for the background substraction",
+                            "store": False,
+                            "defaultValue": 200,
+                            "minimum": 1,
+                            "maximum": 255,
+                            "step": 1,
+                            "required": True,
+                        },
+                    },
+                },
+                "frame_difference": {
+                    "type": "object",
+                    "key": "frame_difference",
+                    "title": "Frame Difference",
+                    "description": "Settings for the frame difference model",
+                    "opened": False,
+                    "properties": {
+                        "area": {
+                            "type": "number",
+                            "key": "area",
+                            "title": "Area",
+                            "description": "Minimum area for a motion detection",
+                            "store": False,
+                            "defaultValue": 500,
+                            "minimum": 10,
+                            "maximum": 1000,
+                            "step": 1,
+                            "required": True,
+                        },
+                        "reference_frame_frequency": {
+                            "type": "number",
+                            "key": "reference_frame_frequency",
+                            "title": "Reference Frame Frequency",
+                            "description": "Frequency to update the reference frame",
+                            "store": False,
+                            "defaultValue": 5,
+                            "minimum": 1,
+                            "maximum": 60,
+                            "step": 1,
+                            "required": True,
+                        },
+                    },
+                },
+            }
+        }
+
+    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))
+
+        first_frame = None
+        last_frame_time = 0
+        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)
+            now = time.time() * 1000
+
+            if detector_model == "Frame Difference":
+                area = config.get("frame_difference", {}).get("area", defaultAreaFd)
+                reference_frame_frequency = config.get("frame_difference", {}).get(
+                    "reference_frame_frequency", defaultReferenceFrameFrequency
+                )
+
+                if first_frame is None or (
+                    reference_frame_frequency and now - last_frame_time > (reference_frame_frequency * 1000)
+                ):
+                    first_frame = gray
+                    last_frame_time = now
+                    continue
+
+                dets = await asyncio.get_event_loop().run_in_executor(
+                    executor,
+                    get_detections_fd,
+                    first_frame,
+                    gray,
+                    area,
+                )
+
+            elif detector_model == "Background Substraction":
+                if backSub is None:
+                    backSub = cv2.createBackgroundSubtractorMOG2(varThreshold=18, detectShadows=False)
+
+                threshold = config.get("background_substraction", {}).get("threshold", defaultThresholdBs)
+                area = config.get("background_substraction", {}).get("area", defaultAreaBs)
+
+                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", defaultBlur)
+                threshold = config.get("default", {}).get("threshold", defaultThreshold)
+                area = config.get("default", {}).get("area", defaultArea)
+                reference_frame_frequency = config.get("default", {}).get(
+                    "reference_frame_frequency", defaultReferenceFrameFrequency
+                )
+
+                gray = cv2.stackBlur(gray, (blur, blur))
+
+                if first_frame is None or (
+                    reference_frame_frequency and now - last_frame_time > (reference_frame_frequency * 1000)
+                ):
+                    first_frame = gray
+                    last_frame_time = now
+                    continue
+
+                dets = await asyncio.get_event_loop().run_in_executor(
+                    executor,
+                    get_detections,
+                    first_frame,
+                    gray,
+                    threshold,
+                    area,
+                )
+
+            for det in dets:
+                (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

@@ -0,0 +1,172 @@
+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)
+
+
+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 is_in_bbox(point: tuple[float, float], bbox: tuple[float, float, float, float]) -> bool:
+    return point[0] >= bbox[0] and point[0] <= bbox[2] and point[1] >= bbox[1] and point[1] <= bbox[3]
+
+
+def intersect(bbox: tuple[float, float, float, float], bbox_: tuple[float, float, float, float]) -> bool:
+    for i in range(int(len(bbox) / 2)):
+        for j in range(int(len(bbox) / 2)):
+            # Check if one of the corner of bbox inside bbox_
+            if is_in_bbox((bbox[2 * i], bbox[2 * j + 1]), bbox_):
+                return True
+    return False
+
+
+def good_intersect(bbox: tuple[float, float, float, float], bbox_: tuple[float, float, float, float]) -> bool:
+    return bbox[0] < bbox_[2] and bbox[2] > bbox_[0] and bbox[1] < bbox_[3] and bbox[3] > bbox_[1]
+
+
+def calculate_iou(
+    bbox1: tuple[float, float, float, float], bbox2: tuple[float, float, float, float]
+) -> float:
+    x1 = max(bbox1[0], bbox2[0])
+    y1 = max(bbox1[1], bbox2[1])
+    x2 = min(bbox1[2], bbox2[2])
+    y2 = min(bbox1[3], bbox2[3])
+
+    intersection_area = max(0, x2 - x1) * max(0, y2 - y1)
+
+    bbox1_area = (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1])
+    bbox2_area = (bbox2[2] - bbox2[0]) * (bbox2[3] - bbox2[1])
+
+    union_area = bbox1_area + bbox2_area - intersection_area
+
+    iou = intersection_area / union_area
+
+    return iou
+
+
+def merge_bboxes(
+    bboxes: list[tuple[float, float, float, float]],
+    delta_x: float = 0.4,
+    delta_y: float = 0.4,
+    iou_threshold: float = 0,
+) -> list[tuple[float, float, float, float]]:
+    # Sort bboxes by ymin
+    bboxes = sorted(bboxes, key=lambda x: x[1])
+
+    merged_bboxes: list[tuple[float, float, float, float]] = []
+
+    for bbox in bboxes:
+        is_merged = False
+
+        for i in range(len(merged_bboxes)):
+            merged_bbox = merged_bboxes[i]
+
+            # Compute the bboxes with a margin
+            bmargin: tuple[float, float, float, float] = (
+                bbox[0] - (bbox[2] - bbox[0]) * delta_x,
+                bbox[1] - (bbox[3] - bbox[1]) * delta_y,
+                bbox[2] + (bbox[2] - bbox[0]) * delta_x,
+                bbox[3] + (bbox[3] - bbox[1]) * delta_y,
+            )
+            merged_bmargin: tuple[float, float, float, float] = (
+                merged_bbox[0] - (merged_bbox[2] - merged_bbox[0]) * delta_x,
+                merged_bbox[1] - (merged_bbox[3] - merged_bbox[1]) * delta_y,
+                merged_bbox[2] + (merged_bbox[2] - merged_bbox[0]) * delta_x,
+                merged_bbox[3] + (merged_bbox[3] - merged_bbox[1]) * delta_y,
+            )
+
+            # Check if bboxes with margin have an intersection or if IoU is above the threshold
+            if intersect(bmargin, merged_bmargin) or calculate_iou(bbox, merged_bbox) >= iou_threshold:
+                merged_bboxes[i] = (
+                    min(bbox[0], merged_bbox[0]),
+                    min(bbox[1], merged_bbox[1]),
+                    max(bbox[2], merged_bbox[2]),
+                    max(bbox[3], merged_bbox[3]),
+                )
+                is_merged = True
+                break
+
+        if not is_merged:
+            merged_bboxes.append(bbox)
+
+    return merged_bboxes
+
+
+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
+    detections = get_contour_detections(thresh_frame, area_threshold)
+    return merge_bboxes(detections)
+
+
+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)
+    detections = get_contour_detections(mask, area_threshold)
+    return merge_bboxes(detections)
+
+
+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,
+) -> list[tuple[float, float, float, float]]:
+    fg_mask = backSub.apply(frame)
+    motion_mask = get_motion_mask(fg_mask, threshold=threshold)
+    detections = get_contour_detections(motion_mask, area_threshold)
+    return merge_bboxes(detections)