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

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "OpenCL",
   "name": "@camera.ui/camera-ui-opencl",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "camera.ui opencl plugin",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "main": "./src/main.py",
@@ -21,7 +21,7 @@
     "url": "https://github.com/seydx/camera.ui/issues"
   },
   "engines": {
-    "camera.ui": ">=0.0.34-alpha.1",
+    "camera.ui": ">=0.0.34-alpha.2",
     "node": ">=20.17.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",
@@ -39,6 +39,9 @@
   "camera.ui": {
     "pythonVersion": "3.11",
     "extension": "motionDetection",
-    "dependencies": []
+    "dependencies": [],
+    "options": {
+      "extendedMotionDetection": true
+    }
   }
 }

package/requirements.txt

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

package/src/camera_detector.py

@@ -7,143 +7,168 @@ 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 opencl_detector import OpenCLMotionDetector, createProgram
 from plugin_typings import CameraStorageValues
 
-background_tasks = set[asyncio.Task[Any]]()
-
 
 class CameraDetector:
-    def __init__(self, api: PluginAPI, camera: CameraDevice, logger: LoggerService) -> None:
+    def __init__(self, api: PluginAPI, camera_device: CameraDevice) -> None:
         super().__init__()
 
         self.api = api
-        self.camera = camera
-        self.logger = logger
+        self.camera_device = camera_device
+        self.camera_logger = camera_device.logger
 
         self.started = False
         self.closed = False
-        self.frame_generation_task: Optional[asyncio.Task[Any]] = None
+        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()
-        self.camera.on_connected.subscribe(lambda connected: self.start() if connected else self.close())
 
-    def start(self) -> None:
+    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.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}"
-            )
+            self.camera_logger.log("Starting motion detection")
 
-            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
-            )
+            await self.__start_detection()
 
     def close(self) -> None:
-        if self.started and not self.closed:
+        if 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
+            self.camera_logger.log("Stopping motion detection")
 
             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}...")
+    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.close()
+        self.restarting = False
 
-        if self.camera.connected:
-            self.start()
+        if self.camera_device.connected and not self.closed:
+            await self.__start_detection()
 
     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:
+        opencl_detector: Optional[OpenCLMotionDetector] = None
+
+        async for frame in self.camera_device.get_frames():
+            if self.closed:
                 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
+
+            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.id,
+                self.camera_device.id,
                 {
                     "area": {
                         "type": "number",
@@ -156,8 +181,8 @@ class CameraDetector:
                         "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}"
+                        "onSet": lambda new, old: self.camera_logger.log(
+                            f"OpenCL model motion area changed from {old} to {new}"
                         ),
                     },
                     "threshold": {
@@ -171,8 +196,8 @@ class CameraDetector:
                         "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}"
+                        "onSet": lambda new, old: self.camera_logger.log(
+                            f"OpenCL model threshold changed from {old} to {new}"
                         ),
                     },
                     "blur": {
@@ -186,8 +211,8 @@ class CameraDetector:
                         "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}"
+                        "onSet": lambda new, old: self.camera_logger.log(
+                            f"OpenCL model blur radius changed from {old} to {new}"
                         ),
                     },
                     "dilation": {
@@ -201,11 +226,18 @@ class CameraDetector:
                         "maximum": 21,
                         "step": 1,
                         "required": True,
-                        "onSet": lambda old, new: self.logger.log(
-                            self.camera.name,
+                        "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(),
+                    },
                 },
             )
         )

package/src/main.py

@@ -1,10 +1,9 @@
 import asyncio
 import tempfile
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import cv2
-from camera_detector import CameraDetector
 from camera_ui_python_types import (
     CameraDevice,
     CameraExtension,
@@ -15,8 +14,10 @@ from camera_ui_python_types import (
     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
+from opencl_detector import OpenCLMotionDetector, createProgram
 from opencl_utils import merge_overlapping_boxes
 
 
@@ -36,7 +37,7 @@ class OpenCL(MotionDetectionPlugin):
     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)
+        await self.create_detector(camera)
 
     def camera_deselected(self, id: str, extension: CameraExtension) -> None:
         camera = self.cameras.get(id)
@@ -46,11 +47,10 @@ class OpenCL(MotionDetectionPlugin):
             self.remove_detector(self.cameras[id])
             del self.cameras[id]
 
-    def start(self) -> None:
+    async def start(self) -> None:
         self.logger.log("Plugin Started")
 
-        for camera_device in self.cameras.values():
-            self.create_detector(camera_device)
+        await asyncio.gather(*[self.create_detector(camera) for camera in self.cameras.values()])
 
     def stop(self) -> None:
         self.logger.log("Plugin Stopped")
@@ -58,7 +58,7 @@ class OpenCL(MotionDetectionPlugin):
         detectors_copy = list(self.detectors.values())
 
         for detector in detectors_copy:
-            self.remove_detector(detector.camera)
+            self.remove_detector(detector.camera_device)
 
     async def onFormSubmit(self, action_id: str, payload: Any) -> Union[FormSubmitResponse, None]:
         print("Form submitted", action_id, payload)
@@ -67,9 +67,10 @@ class OpenCL(MotionDetectionPlugin):
         for camera in cameras:
             self.cameras[camera.id] = camera
 
-    def create_detector(self, camera: CameraDevice) -> None:
-        detector = CameraDetector(self.api, camera, self.logger)
+    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]
@@ -135,6 +136,8 @@ class OpenCL(MotionDetectionPlugin):
         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
 
@@ -148,7 +151,12 @@ class OpenCL(MotionDetectionPlugin):
         fourcc = cv2.VideoWriter.fourcc("a", "v", "c", "1")
         out = cv2.VideoWriter(output_file, fourcc, fps, (width, height))
 
-        opencl_detector: Optional[OpenCLMotionDetector] = None
+        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()
@@ -156,13 +164,6 @@ class OpenCL(MotionDetectionPlugin):
                 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,

package/src/opencl.cl

@@ -1,101 +1,70 @@
 __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
 
-__kernel void gaussian_blur_horizontal(
+__kernel void process_frame(
     __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,
+    __global float *temp_buffer,
+    __write_only image2d_t output,
+    __constant float *kernel_values,
+    int kernel_size,
     int width,
     int height,
     float alpha,
-    float threshold
+    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;
 
-    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;
+    // 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;
+        }
+    }
 
-    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);
+    // 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));
     }
-    write_imagef(output, (int2)(x, y), (float4)(maxValue, 0.0f, 0.0f, 1.0f));
-}
+}

package/src/opencl_detector.py

@@ -4,75 +4,106 @@ 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()
+def createProgram() -> Any:
+    platforms: Any = cl.get_platforms()
 
-        if ocl is None:
-            raise RuntimeError("Failed to create OpenCL context.")
+    if len(platforms) == 0:
+        raise RuntimeError("Failed to find any OpenCL platforms.")
 
-        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")
+    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")
 
-        self.logger.debug(f"Device OpenCL version: {self.device.version}")
-        self.logger.debug(f"Selected device: {self.device.name}")
+    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
 
-        # Erstelle die Images und Puffer
-        self.gray_image: Any = cl.Image(
+        # Create reusable OpenCL images and buffers
+        self.input_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),
+            cl.ImageFormat(cl.channel_order.R, cl.channel_type.UNORM_INT8),
             shape=(self.width, self.height),
         )
-        self.dilated_image: Any = cl.Image(
+        self.result_image: Any = cl.Image(
             self.ctx,
             mf.WRITE_ONLY,
-            format=cl.ImageFormat(cl.channel_order.R, cl.channel_type.FLOAT),
+            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.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
         )
 
-        # Erstelle den Gaussian-Kernel
-        self.kernel_radius = blur_radius
-        self.kernel = self.create_gaussian_kernel(self.kernel_radius)
+        # 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],
@@ -81,115 +112,71 @@ class OpenCLMotionDetector:
         area_threshold: int,
         alpha: float,
     ) -> list[tuple[float, float, float, float]]:
+        # Copy the frame to OpenCL image
         cl.enqueue_copy(
             self.queue,
-            self.gray_image,
+            self.input_image,
             gray_frame,
             origin=(0, 0),
             region=(self.width, self.height),
         )
 
-        global_size = (self.width, self.height)
-
-        self.program.gaussian_blur_horizontal(
+        # Process frame
+        event = self.program.process_frame(
             self.queue,
-            global_size,
-            None,
-            self.gray_image,
-            self.temp_image,
+            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),
         )
 
-        self.program.gaussian_blur_vertical(
+        # Copy results back to host
+        cl.enqueue_copy(
             self.queue,
-            global_size,
-            None,
-            self.temp_image,
-            self.blurred_image,
-            self.kernel_buf,
-            self.kernel_size,
+            self.host_result_buffer,
+            self.result_image,
+            origin=(0, 0),
+            region=(self.width, self.height),
+            wait_for=[event],
         )
 
-        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)
+        motion_mask_cv = (self.host_result_buffer * 255).astype(np.uint8)
+        detections = get_contour_detections(motion_mask_cv, area_threshold)
 
-    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
+        self.first_frame = False
+        return detections
 
-        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 __get_optimal_work_group_size(self, max_group: int, compute_units: int) -> tuple[int, int]:
+        optimal_group_count = compute_units * 4
 
-    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)
+        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)
 
-        with open(full_path) as kernelFile:
-            kernelStr = kernelFile.read()
+        return (min(max_group, self.width), 1)
 
-        program = cl.Program(context, kernelStr)
-        program.build(devices=[device])
+    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)
 
-        return program
+    def __del__(self):
+        # Clean up OpenCL resources
+        self.queue.finish()

package/src/opencl_utils.py

@@ -3,20 +3,17 @@ 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
+    mask: np.ndarray[Any, Any], area_threshold: int
 ) -> 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
+    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(