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

package/package.json

@@ -1,28 +1,29 @@
 {
   "displayName": "OpenCV",
   "name": "@camera.ui/camera-ui-opencv",
-  "version": "0.0.21",
+  "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.2",
-    "node": ">=20.17.0"
+    "node": ">=20.18.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",
   "keywords": [
@@ -42,6 +43,7 @@
     "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.96

package/src/camera_detector.py

@@ -1,434 +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,
-    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
-
-
-class CameraDetector:
-    def __init__(self, api: PluginAPI, camera_device: CameraDevice) -> None:
-        super().__init__()
-
-        self.api = api
-        self.camera_device = camera_device
-        self.camera_logger = camera_device.logger
-
-        self.started = False
-        self.closed = False
-        self.restarting = False
-
-        self.initialized = False
-
-        self.executor = None
-        self.previous_frame: Optional[np.ndarray[Any, Any]] = None
-
-        self.camera_storage: CameraStorage[CameraStorageValues] = self.__create_camera_storage()
-
-    async def initialize(self) -> None:
-        if self.initialized:
-            return
-
-        self.initialized = True
-
-        async def on_connected(connected: bool) -> None:
-            if connected:
-                await self.start()
-            else:
-                self.close()
-
-        await self.camera_device.on_connected.asubscribe(on_connected)
-
-    async 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.camera_logger.log(f"Starting motion detection ({self.__detector_model()})...")
-
-            await self.__start_detection()
-
-    def close(self) -> None:
-        if not self.closed:
-            self.started = False
-            self.closed = True
-
-            self.camera_logger.log("Stopping motion detection")
-
-            if self.executor is not None:
-                self.executor.shutdown(wait=False)
-                self.executor = None
-
-    async def __start_detection(self) -> None:
-        try:
-            await self.__detect()
-        except asyncio.CancelledError:
-            pass
-        except Exception as error:
-            self.camera_logger.error("Error generating frames", error)
-            await self.__restart()
-
-    async def __restart(self) -> None:
-        if self.restarting or self.closed:
-            return
-
-        self.restarting = True
-
-        self.camera_logger.log("Restarting motion detection in 2s...")
-        await asyncio.sleep(2)
-
-        self.restarting = False
-
-        if self.camera_device.connected and not self.closed:
-            await self.__start_detection()
-
-    async def __detect(self) -> None:
-        backSub: Optional[cv2.BackgroundSubtractorMOG2] = None
-
-        async for frame in self.camera_device.get_frames():
-            if self.closed:
-                break
-
-            frame_image = await frame.to_image(
-                {"format": {"to": "gray"}, "resize": {"width": 640, "height": 0}}
-            )
-
-            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_device.update_state("motion", {"detections": detections}, frame)
-
-    def __detector_model(self) -> Literal["Frame Difference", "Background Substraction", "Default"]:
-        return self.camera_storage.values["motion_detector"]
-
-    async def __default_settings(self) -> None:
-        if self.camera_storage.values["motion_detector"] != default_model:
-            await self.camera_storage.setValue("motion_detector", default_model)
-
-    async def __default_d_settings(self) -> None:
-        if self.camera_storage.values["default"]["area"] != default_area:
-            await self.camera_storage.setValue("default.area", default_area)
-
-        if self.camera_storage.values["default"]["threshold"] != default_threshold:
-            await self.camera_storage.setValue("default.threshold", default_threshold)
-
-        if self.camera_storage.values["default"]["blur"] != default_blur:
-            await self.camera_storage.setValue("default.blur", default_blur)
-
-        if self.camera_storage.values["default"]["dilation"] != default_dilt:
-            await self.camera_storage.setValue("default.dilation", default_dilt)
-
-    async def __default_bs_settings(self) -> None:
-        if self.camera_storage.values["background_substraction"]["area"] != default_area_bs:
-            await self.camera_storage.setValue("background_substraction.area", default_area_bs)
-
-        if self.camera_storage.values["background_substraction"]["threshold"] != default_threshold_bs:
-            await self.camera_storage.setValue("background_substraction.threshold", default_threshold_bs)
-
-        if self.camera_storage.values["background_substraction"]["learning_rate"] != default_learning_rate:
-            await self.camera_storage.setValue("background_substraction.learning_rate", default_learning_rate)
-
-    async def __default_fd_settings(self) -> None:
-        if self.camera_storage.values["frame_difference"]["area"] != default_area_fd:
-            await self.camera_storage.setValue("frame_difference.area", default_area_fd)
-
-    def __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
-        camera_storage: CameraStorage[CameraStorageValues] = (
-            self.api.storage_controller.create_camera_storage(
-                self,
-                self.camera_device.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": lambda new, old: self.camera_logger.log(
-                            f"Motion detection model changed from {old} to {new}"
-                        ),
-                    },
-                    "default": {
-                        "type": "object",
-                        "key": "default",
-                        "title": "Default",
-                        "description": "Settings for the default model",
-                        "group": "Default",
-                        "opened": 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 new, old: self.camera_logger.log(
-                                    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 new, old: self.camera_logger.log(
-                                    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 new, old: self.camera_logger.log(
-                                    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 new, old: self.camera_logger.log(
-                                    f"Default model dilation size changed from {old} to {new}",
-                                ),
-                            },
-                            "reset": {
-                                "type": "button",
-                                "title": "Default Settings",
-                                "key": "default_d",
-                                "description": "Reset motion detection settings to default",
-                                "onSet": lambda new, old: self.__default_d_settings(),
-                            },
-                        },
-                    },
-                    "background_substraction": {
-                        "type": "object",
-                        "key": "background_substraction",
-                        "title": "Background Substraction",
-                        "description": "Settings for the background substraction model",
-                        "group": "Background Substraction",
-                        "opened": 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 new, old: self.camera_logger.log(
-                                    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 new, old: self.camera_logger.log(
-                                    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 new, old: self.camera_logger.log(
-                                    f"Background substraction model threshold changed from {old} to {new}",
-                                ),
-                            },
-                            "reset": {
-                                "type": "button",
-                                "title": "Default Settings",
-                                "key": "default_bs",
-                                "description": "Reset motion detection settings to default",
-                                "onSet": lambda new, old: self.__default_bs_settings(),
-                            },
-                        },
-                    },
-                    "frame_difference": {
-                        "type": "object",
-                        "key": "frame_difference",
-                        "title": "Frame Difference",
-                        "description": "Settings for the frame difference model",
-                        "group": "Frame Difference",
-                        "opened": 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 new, old: self.camera_logger.log(
-                                    f"Frame difference model area changed from {old} to {new}",
-                                ),
-                            },
-                            "reset": {
-                                "type": "button",
-                                "title": "Default Settings",
-                                "key": "default_fd",
-                                "description": "Reset motion detection settings to default",
-                                "onSet": lambda new, old: self.__default_fd_settings(),
-                            },
-                        },
-                    },
-                    "reset": {
-                        "type": "button",
-                        "title": "Default Settings",
-                        "key": "default_settings",
-                        "description": "Reset motion detection settings to default",
-                        "onSet": lambda new, old: self.__default_settings(),
-                    },
-                },
-            )
-        )
-
-        return camera_storage

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 = 0.9
-
-available_models = ["Frame Difference", "Background Substraction", "Default"]
-
-
-default_model = "Background Substraction"

package/src/main.py

@@ -1,341 +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_ui_python_types import (
-    CameraDevice,
-    CameraExtension,
-    FormSubmitResponse,
-    LoggerService,
-    MotionDetectionPlugin,
-    MotionDetectionPluginResponse,
-    PluginAPI,
-    RootSchema,
-)
-
-from camera_detector import CameraDetector
-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
-        await 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]
-
-    async def start(self) -> None:
-        self.logger.log("Plugin Started")
-
-        await asyncio.gather(*[self.create_detector(camera) for camera in self.cameras.values()])
-
-    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_device)
-
-    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
-
-    async def create_detector(self, camera: CameraDevice) -> None:
-        detector = CameraDetector(self.api, camera)
-        self.detectors[camera.id] = detector
-        await detector.initialize()
-
-    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