256 lines
7.9 KiB
Python
256 lines
7.9 KiB
Python
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'])
|