import numpy as np from functools import partial from hailo_platform import VDevice, HailoSchedulingAlgorithm, FormatType import cv2 import numpy as np def resize_image(img_in, reshape_to_final=True): if not isinstance(img_in, np.ndarray): img_in = np.asarray(img_in) max_l = 640 asp_rat = img_in.shape[0] / img_in.shape[1] if asp_rat < 1: output_size = [int(asp_rat * max_l), max_l] else: output_size = [max_l, int(max_l / asp_rat)] im_arr_not_pad = cv2.resize(img_in, output_size[::-1]) pad_amt = [max_l, max_l] - np.asarray(im_arr_not_pad.shape[0:2]) left_pad, top_pad = (pad_amt / 2).astype(np.int64) right_pad, bottom_pad = pad_amt - [left_pad, top_pad] im_pass = np.zeros(shape=(max_l, max_l, 3), dtype=np.uint8) im_pass[left_pad:(max_l - right_pad), top_pad:(max_l - bottom_pad)] = (im_arr_not_pad) data = im_pass if reshape_to_final: data = np.moveaxis(data, [2], [0])[None, :, :, :] return data def model_scoring_callback(completion_info, bindings, data): if completion_info.exception: # handle exception pass ff = bindings.output().get_buffer() timeout_ms = 1000 params = VDevice.create_params() params.scheduling_algorithm = HailoSchedulingAlgorithm.ROUND_ROBIN import time # The vdevice is used as a context manager ("with" statement) to ensure it's released on time. with VDevice(params) as vdevice: # Create an infer model from an HEF: infer_model = vdevice.create_infer_model("yolov11l_inat.hef") # Configure the infer model and create bindings for it with infer_model.configure() as configured_infer_model: bindings = configured_infer_model.create_bindings() st = time.time() for i in range(1): # Set input and output buffers buffer = inp # np.zeros(infer_model.input().shape).astype(np.uint8) bindings.input().set_buffer(buffer) output_array = np.zeros([infer_model.output().shape[0] ]).astype(np.float32) bindings.output().set_buffer(output_array) # Run synchronous inference and access the output buffers configured_infer_model.run([bindings], timeout_ms) buffer = bindings.output().get_buffer() # Run asynchronous inference job = configured_infer_model.run_async( [bindings], partial(example_callback, bindings=bindings, data=time.time()), ) job.wait(timeout_ms) # %% import cv2 import time import multiprocessing import numpy as np import ctypes import shutil from utils import * cameras = { "camera_sidefeeder": { 'url': "rtsp://admin:marybear@192.168.1.157:554/h264Preview_01_sub", 'resolution': (480, 640, 3) }, "camera_driveway": { 'url': "rtsp://admin:marybear@192.168.1.152:554/h264Preview_01_sub", 'resolution': (480, 640, 3) }, "camera_railing": { 'url': "rtsp://admin:marybear@192.168.1.153:554/h264Preview_01_sub", 'resolution': (512, 896, 3) }, "camera_ptz_right": { 'url': "rtsp://admin:marybear@192.168.1.155:554/h264Preview_01_sub", 'resolution': (360, 640, 3) }, "camera_wrenwatch": { 'url': "rtsp://admin:marybear@192.168.1.158:554/h264Preview_01_sub", 'resolution': (360, 640, 3) }, "camera_backyard": { 'url': "rtsp://admin:marybear@192.168.1.162:554/h264Preview_01_sub", 'resolution': (432, 1536, 3), 'split_into_two': True }, } from functools import partial cameras = dict() for cam_name, details in cameras.items(): rtsp_url = details['url'] resolution = details['resolution'] cameras[cam_name] = StreamManager( rtsp_url, resolution, cam_name) # %% details['cam_name'] = cam_name details['img_array'] = multiprocessing.Array(ctypes.c_uint8, int(array_len), lock=True) details['img_timestamp'] = multiprocessing.Value(ctypes.c_double) details['queue'] = multiprocessing.Queue() details['rtsp_url'] = format_ffmpeg_decode_url(details['url']).split(" ") details['process_func'] = partial(stream_wrapper, details['resolution'], details['rtsp_url'], camera_name=cam_name, queue=details['queue'], img_array=details['img_array'], img_timestamp=details['img_timestamp']) for cam_name, details in cameras.items(): p = multiprocessing.Process(target = details['process_func']) details['process'] = p p.start() # %% img_array = details['img_array'] img_timestamp = details['img_timestamp'] import time with img_timestamp.get_lock(): img_timestamp.value = -1 details['queue'].put('get') for i in range(1000): val = img_timestamp.value print(val) if val > 0: print('Done') break time.sleep(0.001) # %% for cam_name, details in cameras.items(): details['queue'].put('get') img_array = details['img_array'] img_timestamp = details['img_timestamp'] with img_array.get_lock(), img_timestamp.get_lock(): reshaped_image = np.frombuffer(details['img_array'].get_obj(), dtype=np.uint8).reshape( details['resolution']) timestamp = img_timestamp.value img_timestamp.value = -1 print('Writing for ' + cam_name + f' for {reshaped_image.shape}') cv2.imwrite('images/'+ cam_name + '.jpg', reshaped_image) # %% import asyncio img_scoring_queue = multiprocessing.Queue() for cam_name, details in cameras.items(): p = multiprocessing.Process(target=rtsp_stream_manager, args=(cam_name, details['gst_pipeline_str'], details['queue'], details['img_array'], details['img_timestamp'])) details['process'] = p asyncio.create_task(details['async_task']) shape = (512, 896, 3) asyncio.run(read_stream(shape, cmd)) import datetime as dt for cam_name, details in cameras.items(): details['process'].start() # %% for cam_name, details in cameras.items(): details['queue'].put('restart') # %% for cam_name, details in cameras.items(): details['queue'].put('get') if os.path.exists('images/'): shutil.rmtree('images/') os.makedirs('images/') def create_score_message(details, reshaped_image, timestamp): frames = list() msg = list() if details.get('split_into_two', False): split_point = int(reshaped_image.shape[1] / 2) left_frame = resize_image(reshaped_image[:, :split_point, :], reshape_to_final=False) right_frame = resize_image(reshaped_image[:, split_point:, :], reshape_to_final=False) left_frame = cv2.cvtColor(left_frame, cv2.COLOR_BGR2RGB) right_frame = cv2.cvtColor(right_frame, cv2.COLOR_BGR2RGB) msg.append({ 'camera_name': details['cam_name'] + '_left', 'frame': left_frame, 'image_timestamp': timestamp }) msg.append({ 'camera_name': details['cam_name'] + '_right', 'frame': right_frame, 'image_timestamp': timestamp }) else: frame = resize_image(reshaped_image, reshape_to_final=False) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) msg.append({ 'camera_name': details['cam_name'], 'frame': frame, 'image_timestamp': timestamp }) return msg for x in range(img_scoring_queue.qsize()): qu = img_scoring_queue.get() print(qu['camera_name'], qu['frame'].shape) cv2.imwrite(str(x) + '.jpg', qu['frame'])