@camera.ui/camera-ui-opencl 0.0.4 → 0.0.6

package/package.json

@@ -1,28 +1,29 @@
 {
   "displayName": "OpenCL",
   "name": "@camera.ui/camera-ui-opencl",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "camera.ui opencl 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"
+    "camera.ui": ">=0.0.34-alpha.4",
+    "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-opencl

package/config.schema.json

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

package/requirements.txt

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

package/src/camera_detector.py

@@ -1,245 +0,0 @@
-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,
-    PluginAPI,
-)
-
-from detector_defaults import default_alpha, default_area, default_blur, default_dilt, default_threshold
-from opencl_detector import OpenCLMotionDetector, createProgram
-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
-
-        try:
-            self.ctx = createProgram()
-        except Exception as e:
-            self.camera_logger.error("Error initializing OpenCL detector", e)
-            return
-
-        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("Starting motion detection")
-
-            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:
-        opencl_detector: Optional[OpenCLMotionDetector] = 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"])
-
-            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 not opencl_detector:
-                opencl_detector = OpenCLMotionDetector(self.ctx, width, height, blur, self.camera_logger)
-
-            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_device.update_state("motion", {"detections": detections}, frame)
-
-    async def __default_settings(self) -> None:
-        if self.camera_storage.values["area"] != default_area:
-            await self.camera_storage.setValue("area", default_area)
-
-        if self.camera_storage.values["threshold"] != default_threshold:
-            await self.camera_storage.setValue("threshold", default_threshold)
-
-        if self.camera_storage.values["blur"] != default_blur:
-            await self.camera_storage.setValue("blur", default_blur)
-
-        if self.camera_storage.values["dilation"] != default_dilt:
-            await self.camera_storage.setValue("dilation", default_dilt)
-
-    def __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
-        camera_storage: CameraStorage[CameraStorageValues] = (
-            self.api.storage_controller.create_camera_storage(
-                self,
-                self.camera_device.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 new, old: self.camera_logger.log(
-                            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 new, old: self.camera_logger.log(
-                            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 new, old: self.camera_logger.log(
-                            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 new, old: self.camera_logger.log(
-                            self.camera_device.name,
-                            f"OpenCL model dilation size changed from {old} to {new}",
-                        ),
-                    },
-                    "reset": {
-                        "type": "button",
-                        "title": "Default Settings",
-                        "key": "default",
-                        "description": "Reset motion detection settings to default",
-                        "onSet": lambda new, old: self.__default_settings(),
-                    },
-                },
-            )
-        )
-
-        return camera_storage

package/src/detector_defaults.py

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

package/src/main.py

@@ -1,200 +0,0 @@
-import asyncio
-import tempfile
-from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Union
-
-import cv2
-from camera_ui_python_types import (
-    CameraDevice,
-    CameraExtension,
-    FormSubmitResponse,
-    LoggerService,
-    MotionDetectionPlugin,
-    MotionDetectionPluginResponse,
-    PluginAPI,
-    RootSchema,
-)
-
-from camera_detector import CameraDetector
-from detector_defaults import default_alpha, default_area, default_blur, default_dilt, default_threshold
-from opencl_detector import OpenCLMotionDetector, createProgram
-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
-        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": {
-                "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:
-        ctx = createProgram()
-
-        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))
-
-        blur = config.get("blur", default_blur)
-        threshold = config.get("threshold", default_threshold)
-        area = config.get("area", default_area)
-        dilation = config.get("dilation", default_dilt)
-
-        opencl_detector = OpenCLMotionDetector(ctx, width, height, blur, self.logger)
-
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-
-            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

@@ -1,70 +0,0 @@
-__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
-
-__kernel void process_frame(
-    __read_only image2d_t input,
-    __global float *background_model,
-    __global float *temp_buffer,
-    __write_only image2d_t output,
-    __constant float *kernel_values,
-    int kernel_size,
-    int width,
-    int height,
-    float alpha,
-    float threshold,
-    int dilation_size,
-    int first_frame
-) {
-    int x = get_global_id(0);
-    int y = get_global_id(1);
-    if (x >= width || y >= height) return;
-    int idx = y * width + x;
-
-    // Gaussian blur
-    int radius = (kernel_size - 1) / 2;
-    float blurred_value = 0.0f;
-    for (int i = -radius; i <= radius; i++) {
-        for (int j = -radius; j <= radius; j++) {
-            int2 samplePos = (int2)(clamp(x + i, 0, width - 1), clamp(y + j, 0, height - 1));
-            float4 pixel = read_imagef(input, sampler, samplePos);
-            float weight = kernel_values[i + radius] * kernel_values[j + radius];
-            blurred_value += pixel.x * weight;
-        }
-    }
-
-    // Store blurred value in temp buffer
-    temp_buffer[idx] = blurred_value;
-
-    if (first_frame) {
-        // Initialize background model
-        background_model[idx] = blurred_value;
-        write_imagef(output, (int2)(x, y), (float4)(0.0f, 0.0f, 0.0f, 1.0f));
-    } else {
-        // Background subtraction
-        float bg_pixel = background_model[idx];
-
-        // Update background model
-        float updated_bg = bg_pixel * (1.0f - alpha) + blurred_value * alpha;
-        background_model[idx] = updated_bg;
-
-        // Compute difference and threshold
-        float diff = fabs(blurred_value - bg_pixel);
-        float mask_value = (diff > threshold) ? 1.0f : 0.0f;
-
-        // Dilation
-        float maxValue = mask_value;
-        for (int dy = -dilation_size; dy <= dilation_size; dy++) {
-            int sy = clamp(y + dy, 0, height - 1);
-            for (int dx = -dilation_size; dx <= dilation_size; dx++) {
-                int sx = clamp(x + dx, 0, width - 1);
-                int neighbor_idx = sy * width + sx;
-                float neighbor_pixel = background_model[neighbor_idx];
-                float neighbor_blurred = temp_buffer[neighbor_idx];
-                float neighbor_diff = fabs(neighbor_blurred - neighbor_pixel);
-                float neighbor_mask = (neighbor_diff > threshold) ? 1.0f : 0.0f;
-                maxValue = fmax(maxValue, neighbor_mask);
-            }
-        }
-
-        write_imagef(output, (int2)(x, y), (float4)(maxValue, maxValue, maxValue, 1.0f));
-    }
-}

package/src/opencl_detector.py

@@ -1,182 +0,0 @@
-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
-
-
-def createProgram() -> Any:
-    platforms: Any = cl.get_platforms()
-
-    if len(platforms) == 0:
-        raise RuntimeError("Failed to find any OpenCL platforms.")
-
-    devices = platforms[0].get_devices(cl.device_type.GPU)
-    if len(devices) == 0:
-        devices = platforms[0].get_devices(cl.device_type.CPU)
-        if len(devices) == 0:
-            raise RuntimeError("Could not find OpenCL GPU or CPU device.")
-
-    device = devices[0]
-    context: Any = cl.Context([device])
-
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-    full_path = os.path.join(current_dir, "opencl.cl")
-
-    with open(full_path) as kernelFile:
-        kernelStr = kernelFile.read()
-
-    program = cl.Program(context, kernelStr)
-    program.build(devices=[device])
-
-    return context, device, program
-
-
-class OpenCLMotionDetector:
-    def __init__(
-        self,
-        ctx: tuple[Any, Any, Any],
-        width: int,
-        height: int,
-        blur_radius: int,
-        camera_logger: LoggerService,
-    ):
-        self.camera_logger = camera_logger
-        self.width = width
-        self.height = height
-
-        # OpenCL Setup
-        self.ctx: Any = ctx[0]
-        self.device: Any = ctx[1]
-        self.program: Any = ctx[2]
-        self.queue: Any = cl.CommandQueue(self.ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
-
-        mf: Any = cl.mem_flags
-
-        # Create reusable OpenCL images and buffers
-        self.input_image: Any = cl.Image(
-            self.ctx,
-            mf.READ_ONLY,
-            cl.ImageFormat(cl.channel_order.R, cl.channel_type.UNORM_INT8),
-            shape=(self.width, self.height),
-        )
-        self.result_image: Any = cl.Image(
-            self.ctx,
-            mf.WRITE_ONLY,
-            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
-        )
-        self.temp_buffer: Any = cl.Buffer(
-            self.ctx, mf.READ_WRITE, size=self.width * self.height * np.dtype(np.float32).itemsize
-        )
-
-        # Create host buffer for results
-        self.host_result_buffer = np.zeros((self.height, self.width), dtype=np.float32)
-
-        # Create Gaussian kernel and copy it to global GPU memory
-        self.kernel = self.__create_gaussian_kernel(blur_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))
-
-        max_work_group_size = self.device.get_info(cl.device_info.MAX_WORK_GROUP_SIZE)
-        compute_units = self.device.get_info(cl.device_info.MAX_COMPUTE_UNITS)
-
-        self.local_size = self.__get_optimal_work_group_size(max_work_group_size, compute_units)
-        self.global_size = (
-            ((self.width + self.local_size[0] - 1) // self.local_size[0]) * self.local_size[0],
-            ((self.height + self.local_size[1] - 1) // self.local_size[1]) * self.local_size[1],
-        )
-
-        self.first_frame = True
-
-        self.camera_logger.debug(
-            {
-                "device_name": self.device.name,
-                "opencl_version": self.device.version,
-                "compute_units": compute_units,
-                "local_work_group_size": self.local_size,
-            },
-        )
-
-    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]]:
-        # Copy the frame to OpenCL image
-        cl.enqueue_copy(
-            self.queue,
-            self.input_image,
-            gray_frame,
-            origin=(0, 0),
-            region=(self.width, self.height),
-        )
-
-        # Process frame
-        event = self.program.process_frame(
-            self.queue,
-            self.global_size,
-            self.local_size,
-            self.input_image,
-            self.background_model_buf,
-            self.temp_buffer,
-            self.result_image,
-            self.kernel_buf,
-            self.kernel_size,
-            np.int32(self.width),
-            np.int32(self.height),
-            np.float32(alpha),
-            np.float32(motion_threshold),
-            np.int32(dilation_size),
-            np.int32(self.first_frame),
-        )
-
-        # Copy results back to host
-        cl.enqueue_copy(
-            self.queue,
-            self.host_result_buffer,
-            self.result_image,
-            origin=(0, 0),
-            region=(self.width, self.height),
-            wait_for=[event],
-        )
-
-        motion_mask_cv = (self.host_result_buffer * 255).astype(np.uint8)
-        detections = get_contour_detections(motion_mask_cv, area_threshold)
-
-        self.first_frame = False
-        return detections
-
-    def __get_optimal_work_group_size(self, max_group: int, compute_units: int) -> tuple[int, int]:
-        optimal_group_count = compute_units * 4
-
-        for size in [32, 16, 8, 4]:
-            work_groups_per_dimension = (self.width // size) * (self.height // size)
-            if (
-                self.width % size == 0
-                and self.height % size == 0
-                and size * size <= max_group
-                and work_groups_per_dimension >= optimal_group_count
-            ):
-                return (size, size)
-
-        return (min(max_group, self.width), 1)
-
-    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))
-        return (kernel / np.sum(kernel)).astype(np.float32)
-
-    def __del__(self):
-        # Clean up OpenCL resources
-        self.queue.finish()

package/src/opencl_utils.py

@@ -1,66 +0,0 @@
-from typing import Any
-
-import cv2
-import numpy as np
-
-
-def get_contour_detections(
-    mask: np.ndarray[Any, Any], area_threshold: int
-) -> list[tuple[float, float, float, float]]:
-    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    return [
-        (float(x), float(y), float(x + w), float(y + h))
-        for contour in contours
-        if (_ := cv2.contourArea(contour)) > area_threshold
-        for x, y, w, h in [cv2.boundingRect(contour)]
-    ]
-
-
-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

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