@camera.ui/camera-ui-opencl 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-opencl

package/config.schema.json

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

package/package.json

@@ -0,0 +1,44 @@
+{
+  "displayName": "OpenCL",
+  "name": "@camera.ui/camera-ui-opencl",
+  "version": "0.0.1",
+  "description": "camera.ui opencl 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.4.0"
+  },
+  "bugs": {
+    "url": "https://github.com/seydx/camera.ui/issues"
+  },
+  "engines": {
+    "camera.ui": ">=0.0.34-alpha.0",
+    "node": ">=20.17.0"
+  },
+  "homepage": "https://github.com/seydx/camera.ui#readme",
+  "keywords": [
+    "camera-ui-plugin",
+    "motion",
+    "opencl",
+    "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.txt

@@ -0,0 +1,5 @@
+numpy==1.26.4
+opencv-python-headless==4.10.0.84
+camera-ui-python-types==0.1.90
+pyopencl==2024.2.7
+siphash24==1.6

package/src/camera_detector.py

@@ -0,0 +1,213 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Optional
+
+import numpy as np
+from camera_ui_python_types import (
+    CameraDevice,
+    CameraStorage,
+    Detection,
+    LoggerService,
+    PluginAPI,
+)
+from detector_defaults import default_alpha, default_area, default_blur, default_dilt, default_threshold
+from opencl_detector import OpenCLMotionDetector
+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.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:
+                opencl_detector: Optional[OpenCLMotionDetector] = 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"])
+
+                    width = frame_image["info"]["width"]
+                    height = frame_image["info"]["height"]
+                    blur = self.camera_storage.values["blur"]
+                    threshold = self.camera_storage.values["threshold"]
+                    area = self.camera_storage.values["area"]
+                    dilation = self.camera_storage.values["dilation"]
+
+                    if opencl_detector is None:
+                        try:
+                            opencl_detector = OpenCLMotionDetector(self.logger, width, height, blur)
+                        except Exception as error:
+                            self.logger.error(self.camera.name, "Error initializing OpenCL detector", error)
+                            break
+
+                    dets = await asyncio.get_event_loop().run_in_executor(
+                        self.executor,
+                        opencl_detector.process_frame,
+                        image_array,
+                        threshold,
+                        dilation,
+                        area,
+                        default_alpha,
+                    )
+
+                    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 __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
+        camera_storage: CameraStorage[CameraStorageValues] = (
+            self.api.storage_controller.create_camera_storage(
+                self,
+                self.camera.id,
+                {
+                    "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"OpenCL 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": 0,
+                        "maximum": 1,
+                        "step": 0.01,
+                        "required": True,
+                        "onSet": lambda old, new: self.logger.log(
+                            self.camera.name, f"OpenCL 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"OpenCL 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"OpenCL model dilation size changed from {old} to {new}",
+                        ),
+                    },
+                },
+            )
+        )
+
+        return camera_storage

package/src/detector_defaults.py

@@ -0,0 +1,5 @@
+default_area = 400
+default_threshold = 0.1
+default_blur = 6
+default_dilt = 6
+default_alpha = 0.2

package/src/main.py

@@ -0,0 +1,199 @@
+import asyncio
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Optional, Union
+
+import cv2
+from camera_detector import CameraDetector
+from camera_ui_python_types import (
+    CameraDevice,
+    CameraExtension,
+    FormSubmitResponse,
+    LoggerService,
+    MotionDetectionPlugin,
+    MotionDetectionPluginResponse,
+    PluginAPI,
+    RootSchema,
+)
+from detector_defaults import default_alpha, default_area, default_blur, default_dilt, default_threshold
+from opencl_detector import OpenCLMotionDetector
+from opencl_utils import merge_overlapping_boxes
+
+
+class OpenCL(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": {
+                "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": 0,
+                    "maximum": 1,
+                    "step": 0.01,
+                    "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,
+                },
+            }
+        }
+
+        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))
+
+        opencl_detector: Optional[OpenCLMotionDetector] = None
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            blur = config.get("blur", default_blur)
+            threshold = config.get("threshold", default_threshold)
+            area = config.get("area", default_area)
+            dilation = config.get("dilation", default_dilt)
+
+            if opencl_detector is None:
+                opencl_detector = OpenCLMotionDetector(self.logger, width, height, blur)
+
+            dets = await asyncio.get_event_loop().run_in_executor(
+                executor,
+                opencl_detector.process_frame,
+                gray,
+                threshold,
+                dilation,
+                area,
+                default_alpha,
+            )
+
+            merged_boxed = merge_overlapping_boxes(dets)
+
+            for det in merged_boxed:
+                (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 OpenCL

package/src/opencl.cl

@@ -0,0 +1,101 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void gaussian_blur_horizontal(
+    __read_only image2d_t input,
+    __write_only image2d_t output,
+    __global float *kernel_values,
+    int kernel_size
+) {
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    int width = get_image_width(input);
+    int radius = (kernel_size - 1) / 2;
+
+    if (x >= width) return;
+
+    float sum = 0.0f;
+    for (int k = -radius; k <= radius; k++) {
+        int sx = clamp(x + k, 0, width - 1);
+        float4 pixel = read_imagef(input, sampler, (int2)(sx, y));
+        float weight = kernel_values[k + radius];
+        sum += pixel.x * weight;
+    }
+
+    write_imagef(output, (int2)(x, y), (float4)(sum, 0.0f, 0.0f, 1.0f));
+}
+
+__kernel void gaussian_blur_vertical(
+    __read_only image2d_t input,
+    __write_only image2d_t output,
+    __global float *kernel_values,
+    int kernel_size
+) {
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+
+    int height = get_image_height(input);
+    int radius = (kernel_size - 1) / 2;
+
+    if (y >= height) return;
+
+    float sum = 0.0f;
+    for (int k = -radius; k <= radius; k++) {
+        int sy = clamp(y + k, 0, height - 1);
+        float4 pixel = read_imagef(input, sampler, (int2)(x, sy));
+        float weight = kernel_values[k + radius];
+        sum += pixel.x * weight;
+    }
+
+    write_imagef(output, (int2)(x, y), (float4)(sum, 0.0f, 0.0f, 1.0f));
+}
+
+__kernel void background_subtraction(
+    __read_only image2d_t current_frame,
+    __global float *background_model,
+    __write_only image2d_t mask,
+    int width,
+    int height,
+    float alpha,
+    float threshold
+) {
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    if (x >= width || y >= height) return;
+    int idx = y * width + x;
+
+    float current_pixel = read_imagef(current_frame, sampler, (int2)(x, y)).x;
+    float bg_pixel = background_model[idx];
+
+    // Aktualisiere Hintergrundmodell
+    float updated_bg = bg_pixel * (1.0f - alpha) + current_pixel * alpha;
+    background_model[idx] = updated_bg;
+
+    // Berechne Differenz
+    float diff = fabs(current_pixel - bg_pixel);
+    float result = (diff > threshold) ? 1.0f : 0.0f;
+    write_imagef(mask, (int2)(x, y), (float4)(result, 0.0f, 0.0f, 1.0f));
+}
+
+__kernel void dilate(
+    __read_only image2d_t input,
+    __write_only image2d_t output,
+    int size
+) {
+    int x = get_global_id(0);
+    int y = get_global_id(1);
+    int width = get_image_width(input);
+    int height = get_image_height(input);
+    if (x >= width || y >= height) return;
+
+    float maxValue = 0.0f;
+    for (int dy = -size; dy <= size; dy++) {
+        int sy = clamp(y + dy, 0, height - 1);
+        for (int dx = -size; dx <= size; dx++) {
+            int sx = clamp(x + dx, 0, width - 1);
+            float pixel = read_imagef(input, sampler, (int2)(sx, sy)).x;
+            maxValue = fmax(maxValue, pixel);
+        }
+    }
+    write_imagef(output, (int2)(x, y), (float4)(maxValue, 0.0f, 0.0f, 1.0f));
+}

package/src/opencl_detector.py

@@ -0,0 +1,195 @@
+import os
+from typing import Any
+
+import numpy as np
+import pyopencl as cl
+from camera_ui_python_types import LoggerService
+from opencl_utils import get_contour_detections
+
+
+class OpenCLMotionDetector:
+    def __init__(self, logger: LoggerService, width: int, height: int, blur_radius: int):
+        ocl = self.createContext()
+
+        if ocl is None:
+            raise RuntimeError("Failed to create OpenCL context.")
+
+        self.logger = logger
+        self.ctx: Any = ocl[0]
+        self.device: Any = ocl[1]
+        self.queue: Any = cl.CommandQueue(self.ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
+        self.program: Any = self.createProgram(self.ctx, self.device, "opencl.cl")
+
+        self.logger.debug(f"Device OpenCL version: {self.device.version}")
+        self.logger.debug(f"Selected device: {self.device.name}")
+
+        self.width = width
+        self.height = height
+
+        mf: Any = cl.mem_flags
+
+        # Erstelle die Images und Puffer
+        self.gray_image: Any = cl.Image(
+            self.ctx,
+            mf.READ_ONLY,
+            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.UNORM_INT8),
+            shape=(self.width, self.height),
+        )
+        self.temp_image: Any = cl.Image(
+            self.ctx,
+            mf.READ_WRITE,
+            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.FLOAT),
+            shape=(self.width, self.height),
+        )
+        self.blurred_image: Any = cl.Image(
+            self.ctx,
+            mf.READ_WRITE,
+            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.FLOAT),
+            shape=(self.width, self.height),
+        )
+        self.mask_image: Any = cl.Image(
+            self.ctx,
+            mf.READ_WRITE,
+            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.FLOAT),
+            shape=(self.width, self.height),
+        )
+        self.dilated_image: Any = cl.Image(
+            self.ctx,
+            mf.WRITE_ONLY,
+            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.FLOAT),
+            shape=(self.width, self.height),
+        )
+        self.background_model_buf: Any = cl.Buffer(
+            self.ctx,
+            mf.READ_WRITE,
+            size=self.width * self.height * np.dtype(np.float32).itemsize,
+        )
+
+        # Erstelle den Gaussian-Kernel
+        self.kernel_radius = blur_radius
+        self.kernel = self.create_gaussian_kernel(self.kernel_radius)
+        self.kernel_buf: Any = cl.Buffer(self.ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=self.kernel)
+        self.kernel_size = np.int32(len(self.kernel))
+
+        self.first_frame = True
+
+    def process_frame(
+        self,
+        gray_frame: np.ndarray[Any, Any],
+        motion_threshold: float,
+        dilation_size: int,
+        area_threshold: int,
+        alpha: float,
+    ) -> list[tuple[float, float, float, float]]:
+        cl.enqueue_copy(
+            self.queue,
+            self.gray_image,
+            gray_frame,
+            origin=(0, 0),
+            region=(self.width, self.height),
+        )
+
+        global_size = (self.width, self.height)
+
+        self.program.gaussian_blur_horizontal(
+            self.queue,
+            global_size,
+            None,
+            self.gray_image,
+            self.temp_image,
+            self.kernel_buf,
+            self.kernel_size,
+        )
+
+        self.program.gaussian_blur_vertical(
+            self.queue,
+            global_size,
+            None,
+            self.temp_image,
+            self.blurred_image,
+            self.kernel_buf,
+            self.kernel_size,
+        )
+
+        if not self.first_frame:
+            self.program.background_subtraction(
+                self.queue,
+                global_size,
+                None,
+                self.blurred_image,
+                self.background_model_buf,
+                self.mask_image,
+                np.int32(self.width),
+                np.int32(self.height),
+                np.float32(alpha),
+                np.float32(motion_threshold),
+            )
+
+            self.program.dilate(
+                self.queue,
+                global_size,
+                None,
+                self.mask_image,
+                self.dilated_image,
+                np.int32(dilation_size),
+            )
+
+            motion_mask = np.empty((self.height, self.width), dtype=np.float32)
+            cl.enqueue_copy(
+                self.queue,
+                motion_mask,
+                self.dilated_image,
+                origin=(0, 0),
+                region=(self.width, self.height),
+            )
+
+            return get_contour_detections((motion_mask * 255).astype(np.uint8), area_threshold)
+        else:
+            background_model_np = np.empty((self.height, self.width), dtype=np.float32)
+            cl.enqueue_copy(
+                self.queue,
+                background_model_np,
+                self.blurred_image,
+                origin=(0, 0),
+                region=(self.width, self.height),
+            )
+            background_model_np = background_model_np.flatten()
+            cl.enqueue_copy(self.queue, self.background_model_buf, background_model_np)
+            self.first_frame = False
+            return []
+
+    def create_gaussian_kernel(self, radius: int) -> np.ndarray[Any, Any]:
+        sigma = radius / 3.0
+        x = np.arange(-radius, radius + 1)
+        kernel = np.exp(-(x**2) / (2 * sigma**2))
+        kernel = kernel / np.sum(kernel)
+        return kernel.astype(np.float32)
+
+    def createContext(self) -> tuple[Any, Any] | None:
+        platforms: Any = cl.get_platforms()
+        if len(platforms) == 0:
+            self.logger.warn("Failed to find any OpenCL platforms.")
+            return None
+
+        devices = platforms[0].get_devices(cl.device_type.GPU)
+        if len(devices) == 0:
+            self.logger.warn("Could not find GPU device, trying CPU...")
+            devices = platforms[0].get_devices(cl.device_type.CPU)
+            if len(devices) == 0:
+                self.logger.warn("Could not find OpenCL GPU or CPU device.")
+                return None
+
+        context: Any = cl.Context([devices[0]])
+        return context, devices[0]
+
+    def createProgram(self, context: Any, device: Any, filename: str) -> Any:
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        full_path = os.path.join(current_dir, filename)
+
+        with open(full_path) as kernelFile:
+            kernelStr = kernelFile.read()
+
+        program = cl.Program(context, kernelStr)
+        program.build(devices=[device])
+
+        return program

package/src/opencl_utils.py

@@ -0,0 +1,69 @@
+from typing import Any
+
+import cv2
+import numpy as np
+
+DEFAULT_AREA_THRESHOLD = 500
+
+
+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 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

package/src/plugin_typings.py

@@ -0,0 +1,8 @@
+from typing import TypedDict
+
+
+class CameraStorageValues(TypedDict):
+    area: int
+    threshold: int
+    blur: int
+    dilation: int