@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.1

package/src/decoder/python/test/test.py

@@ -1,427 +0,0 @@
-import time
-from typing import Any, Optional
-
-import cv2
-import numpy as np
-import pyopencl as cl
-
-BLUR_RADIUS = 6
-MOTION_THRESHOLD = 0.04
-DILATION_SIZE = 6
-AREA_THRESHOLD = 400
-ALPHA = 0.2
-
-video_path = "motion2.mp4"
-image1_path = "test1_resized.jpg"
-image2_path = "test2_resized.jpg"
-fps = 10
-num_frames = fps * 15
-
-
-class ProfilingInfo:
-    def __init__(self):
-        self.start_time = 0
-        self.end_time = 0
-
-    def get_execution_time(self):
-        return (self.end_time - self.start_time) * 1e-9  # Convert nanoseconds to seconds
-
-
-def profile_event(event: Any, name: Any):
-    event.wait()
-    profiling_info = ProfilingInfo()
-    profiling_info.start_time = event.get_profiling_info(cl.profiling_info.START)
-    profiling_info.end_time = event.get_profiling_info(cl.profiling_info.END)
-    print(f"{name} execution time: {profiling_info.get_execution_time():.6f} seconds")
-
-
-from typing import Any, Tuple
-
-
-class OpenCLMotionDetector:
-    def __init__(self, width: int, height: int):
-        self.width = width
-        self.height = height
-
-        # OpenCL Setup
-        self.ctx, self.device = self.create_context()
-        self.queue: Any = cl.CommandQueue(self.ctx, properties=cl.command_queue_properties.PROFILING_ENABLE)
-        self.program = self.create_program(self.ctx, self.device, "opencl.cl")
-
-        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))
-
-        self.local_size = self.get_optimal_work_group_size()
-        print(f"Local size: {self.local_size}")
-
-        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
-
-    @staticmethod
-    def create_context() -> Tuple[Any, Any]:
-        platforms: Any = cl.get_platforms()
-        if len(platforms) == 0:
-            raise RuntimeError("No OpenCL platforms found.")
-
-        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("No OpenCL devices found.")
-
-        context: Any = cl.Context([devices[0]])
-        return context, devices[0]
-
-    @staticmethod
-    def create_program(context: Any, device: Any, filename: str) -> Any:
-        with open(filename) as file:
-            kernel_source = file.read()
-        program = cl.Program(context, kernel_source)
-        program.build(devices=[device])
-        return program
-
-    @staticmethod
-    def create_gaussian_kernel(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 process_frame(
-        self,
-        gray_frame: np.ndarray[Any, Any],
-        motion_threshold: float,
-        dilation_size: int,
-        area_threshold: int,
-        alpha: float,
-    ) -> tuple[Optional[np.ndarray[Any, Any]], 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),
-        )
-
-        # Profile the event
-        # self.profile_event(event, "Process 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 = self.get_contour_detections(motion_mask_cv, area_threshold)
-
-        self.first_frame = False
-        return motion_mask_cv, detections
-
-    def get_optimal_work_group_size(self) -> Tuple[int, int]:
-        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)
-        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_work_group_size
-                and work_groups_per_dimension >= optimal_group_count
-            ):
-                return (size, size)
-
-        return (min(max_work_group_size, self.width), 1)
-
-    @staticmethod
-    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)]
-        ]
-
-    @staticmethod
-    def profile_event(event: Any, name: str) -> None:
-        event.wait()
-        elapsed = 1e-9 * (event.profile.end - event.profile.start)
-        print(f"{name} execution time: {elapsed:.6f} seconds")
-
-    def __del__(self):
-        # Clean up OpenCL resources
-        self.queue.finish()
-
-
-def process_video(display: bool = True):
-    cap = cv2.VideoCapture(video_path)
-
-    if not cap.isOpened():
-        print(f"Error opening video file {video_path}")
-        return
-
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-    detector = OpenCLMotionDetector(width, height)
-
-    frame_count = 0
-    total_time = 0
-    total_gpu_time = 0
-
-    if display:
-        cv2.namedWindow("Motion Detection", cv2.WINDOW_NORMAL)
-        cv2.namedWindow("Motion Mask", cv2.WINDOW_NORMAL)
-
-    while True:
-        start_time = time.perf_counter()
-
-        ret, frame = cap.read()
-        if not ret:
-            break
-
-        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-
-        gpu_time = time.perf_counter()
-        motion_mask, boxes = detector.process_frame(
-            frame_gray,
-            MOTION_THRESHOLD,
-            DILATION_SIZE,
-            AREA_THRESHOLD,
-            ALPHA,
-        )
-        end_time = time.perf_counter()
-
-        gpu_processing_time = end_time - gpu_time
-        total_gpu_time += gpu_processing_time
-
-        processing_time = end_time - start_time
-        total_time += processing_time
-
-        frame_count += 1
-
-        if display and motion_mask is not None:
-            debug_frame = frame.copy()
-
-            cv2.putText(
-                debug_frame,
-                f"Frame: {frame_count}",
-                (10, 30),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
-            )
-            cv2.putText(
-                debug_frame,
-                f"Boxes: {len(boxes)}",
-                (10, 70),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
-            )
-
-            for box in boxes:
-                x1, y1, x2, y2 = map(int, box)
-                cv2.rectangle(debug_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-
-            fps_text = f"FPS: {1/processing_time:.2f}"
-            cv2.putText(
-                debug_frame,
-                fps_text,
-                (10, 110),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
-            )
-
-            cv2.imshow("Motion Mask", motion_mask)
-            cv2.imshow("Motion Detection", debug_frame)
-
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                break
-
-    cap.release()
-    if display:
-        cv2.destroyAllWindows()
-
-    avg_gpu_time = total_gpu_time / frame_count if frame_count > 0 else 0
-    avg_time = total_time / frame_count if frame_count > 0 else 0
-    avg_fps = 1 / avg_time if avg_time > 0 else 0
-
-    print(f"Processed {frame_count} frames")
-    print(f"Average total processing time per frame: {avg_time:.4f} seconds")
-    print(f"Average GPU processing time per frame: {avg_gpu_time:.4f} seconds")
-    print(f"Average frames per second: {avg_fps:.2f}")
-
-
-def simulate_stream(img1: np.ndarray[Any, Any], img2: np.ndarray[Any, Any], display: bool = True):
-    height, width = img1.shape
-    detector = OpenCLMotionDetector(width, height)
-
-    frame_time = 1 / fps
-    total_time = 0
-    total_gpu_time = 0
-    detected_motions = 0
-
-    if display:
-        cv2.namedWindow("Motion Detection", cv2.WINDOW_NORMAL)
-        cv2.namedWindow("Motion Mask", cv2.WINDOW_NORMAL)
-
-    max_time = time.perf_counter()
-
-    for frame_count in range(num_frames):
-        start_time = time.perf_counter()
-
-        current_frame = img1 if frame_count % 2 == 0 else img2
-
-        gpu_time = time.perf_counter()
-        motion_mask, boxes = detector.process_frame(
-            current_frame,
-            MOTION_THRESHOLD,
-            DILATION_SIZE,
-            AREA_THRESHOLD,
-            ALPHA,
-        )
-        end_time = time.perf_counter()
-
-        gpu_processing_time = end_time - gpu_time
-        total_gpu_time += gpu_processing_time
-
-        processing_time = end_time - start_time
-        total_time += processing_time
-
-        if boxes:
-            detected_motions += 1
-
-        if display and motion_mask is not None:
-            debug_frame = cv2.cvtColor(current_frame, cv2.COLOR_GRAY2BGR)
-
-            cv2.putText(
-                debug_frame,
-                f"Frame: {frame_count + 1}",
-                (10, 30),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
-            )
-            cv2.putText(
-                debug_frame, f"Boxes: {len(boxes)}", (10, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2
-            )
-            cv2.putText(
-                debug_frame,
-                f"FPS: {1/processing_time:.2f}",
-                (10, 110),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 255, 0),
-                2,
-            )
-
-            for box in boxes:
-                x1, y1, x2, y2 = map(int, box)
-                cv2.rectangle(debug_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
-
-            cv2.imshow("Motion Mask", motion_mask)
-            cv2.imshow("Motion Detection", debug_frame)
-
-            if cv2.waitKey(1) & 0xFF == ord("q"):
-                break
-
-        # Simulate frame rate
-        time_to_wait = frame_time - processing_time
-        if time_to_wait > 0:
-            time.sleep(time_to_wait)
-
-    max_time = time.perf_counter() - max_time
-
-    print(f"Max time: {max_time:.4f} seconds")
-
-    if display:
-        cv2.destroyAllWindows()
-
-    avg_gpu_time = total_gpu_time / num_frames
-    avg_time = total_time / num_frames
-    avg_fps = 1 / avg_time if avg_time > 0 else 0
-
-    print(f"Processed {num_frames} frames")
-    print(f"Average total processing time per frame: {avg_time:.4f} seconds")
-    print(f"Average GPU processing time per frame: {avg_gpu_time:.4f} seconds")
-    print(f"Average frames per second: {avg_fps:.2f}")
-    print(f"Frames with detected motion: {detected_motions}")
-    print(f"Percentage of frames with motion: {(detected_motions/num_frames)*100:.2f}%")
-
-
-if __name__ == "__main__":
-    video = False
-    display = False
-
-    if video:
-        process_video(display)
-    else:
-        img1 = cv2.imread(image1_path, cv2.IMREAD_GRAYSCALE)
-        img2 = cv2.imread(image2_path, cv2.IMREAD_GRAYSCALE)
-        simulate_stream(img1, img2, display)