def recognize_from_video():
# net initialize
classifier = ailia.Classifier(
MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath is not None:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# prepare input data
input_image, input_data = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
input_data = cv2.cvtColor(input_data, cv2.COLOR_BGR2BGRA)
# inference
classifier.compute(input_data, MAX_CLASS_COUNT)
# get result
count = classifier.get_class_count()
logger.info('=' * 80)
for idx in range(count):
# logger.info result
logger.info(f'+ idx={idx}')
info = classifier.get_class(idx)
logger.info(
f' category={info.category}'
f'[ {inceptionv3_labels.imagenet_category[info.category]} ]')
logger.info(f' prob={info.prob}')
cv2.imshow('frame', input_image)
time.sleep(SLEEP_TIME)
# save results
if writer is not None:
writer.write(input_image)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(video, detector):
capture = get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
ailia_input_w = detector.get_input_shape()[3]
ailia_input_h = detector.get_input_shape()[2]
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = calc_adjust_fsize(f_h, f_w, ailia_input_h,
ailia_input_w)
# save_w * 2: we stack source frame and estimated heatmap
writer = get_writer(args.savepath, save_h, save_w * 2)
else:
writer = None
while True:
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
x = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
detect_object = detect_objects(x, detector)
res_img = plot_results(detect_object, frame, category)
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(res_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
def recognize_from_video():
etl_word = codecs.open(ETL_PATH, 'r', 'utf-8').readlines()
# net initialize
classifier = ailia.Classifier(
MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
format=ailia.NETWORK_IMAGE_FORMAT_GRAY,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath is not None:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
in_frame, frame = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
frame = preprocess_image(frame)
# inference
# compute execution time
classifier.compute(frame, MAX_CLASS_COUNT)
# get result
count = classifier.get_class_count()
logger.info('=' * 80)
logger.info(f'class_count: {count}')
for idx in range(count):
logger.info(f"+ idx={idx}")
info = classifier.get_class(idx)
logger.info(
f" category={info.category} [ {etl_word[info.category].rstrip()} ]"
)
logger.info(f" prob={info.prob}")
cv2.imshow('frame', in_frame)
# save results
if writer is not None:
writer.write(in_frame)
time.sleep(SLEEP_TIME)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
logger.warning(
'currently, video results cannot be output correctly...'
)
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = calc_adjust_fsize(f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
# save_w * 2: we stack source frame and estimated heatmap
writer = get_writer(args.savepath, save_h, save_w * 2)
else:
writer = None
input_shape_set = False
while(True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
resized_img = midas_resize(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
resized_img = resized_img.transpose((2, 0, 1)) # channel first
resized_img = resized_img[np.newaxis, :, :, :]
if(not input_shape_set):
net.set_input_shape(resized_img.shape)
input_shape_set = True
result = net.predict(resized_img)
depth_min = result.min()
depth_max = result.max()
max_val = (2 ** 16) - 1
if depth_max - depth_min > np.finfo("float").eps:
out = max_val * (result - depth_min) / (depth_max - depth_min)
else:
out = 0
res_img = out.transpose(1, 2, 0).astype("uint16")
cv2.imshow('depth', res_img)
# save results
if writer is not None:
# FIXME: cannot save correctly...
res_img = cv2.cvtColor(res_img, cv2.COLOR_GRAY2BGR)
writer.write(cv2.convertScaleAbs(res_img))
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
print(
'[WARNING] currently, video results cannot be output correctly...')
# TODO: DEBUG: save image shape
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
_, resized_image = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
# add noise
resized_image = add_noise(resized_image)
resized_image = resized_image / 255.0
input_data = resized_image.transpose(2, 0, 1)
input_data.shape = (1, ) + input_data.shape
# inference
preds_ailia = net.predict(input_data)
# side by side
preds_ailia[:, :, :, 0:input_data.shape[3] //
2] = input_data[:, :, :, 0:input_data.shape[3] // 2]
# postprocessing
output_img = preds_ailia[0].transpose(1, 2, 0)
cv2.imshow('frame', output_img)
# # save results
# if writer is not None:
# writer.write(output_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('Script finished successfully.')
def segment_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
ailia_input_w = net.get_input_shape()[3]
ailia_input_h = net.get_input_shape()[2]
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, ailia_input_h, ailia_input_w)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.preprocess_frame(
frame, ailia_input_h, ailia_input_w, normalize_type='127.5')
# inference
input_blobs = net.get_input_blob_list()
net.set_input_blob_data(input_data, input_blobs[0])
net.update()
preds_ailia = np.array(net.get_results())[0, 0] # TODO why?
# postprocessing
seg_map = np.argmax(preds_ailia.transpose(1, 2, 0), axis=2)
seg_image = label_to_color_image(seg_map).astype(np.uint8)
# showing the segmented image (simple)
seg_image = cv2.cvtColor(seg_image, cv2.COLOR_RGB2BGR)
seg_image = cv2.resize(seg_image,
(input_image.shape[1], input_image.shape[0]))
cv2.imshow('frame', seg_image)
# save results
if writer is not None:
writer.write(seg_image)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
if args.video == '0':
print('[INFO] Webcam mode is activated')
capture = cv2.VideoCapture(0)
if not capture.isOpened():
print("[ERROR] webcamera not found")
sys.exit(1)
else:
if check_file_existance(args.video):
capture = cv2.VideoCapture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='127.5')
# inference
input_blobs = net.get_input_blob_list()
net.set_input_blob_data(input_data, input_blobs[0])
net.update()
preds_ailia = net.get_results()
# postprocessing
detections = postprocess(preds_ailia)
show_result(input_image, detections)
cv2.imshow('frame', input_image)
# save results
if writer is not None:
writer.write(input_image)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
# net initialize
classifier = ailia.Classifier(
MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
range=IMAGE_RANGE,
)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath is not None:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
in_frame, frame = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
frame = preprocess_image(frame)
# inference
classifier.compute(frame, MAX_CLASS_COUNT)
# get result
# count = classifier.get_class_count()
plot_results(in_frame, classifier, resnet50_labels.imagenet_category)
cv2.imshow('frame', in_frame)
time.sleep(SLEEP_TIME)
# save results
if writer is not None:
writer.write(in_frame)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
pose = ailia.PoseEstimator(MODEL_PATH,
WEIGHT_PATH,
env_id=args.env_id,
algorithm=ALGORITHM)
if args.threshold != THRESHOLD_DEFAULT:
pose.set_threshold(args.threshold)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.adjust_frame_size(
frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
)
input_data = cv2.cvtColor(input_data, cv2.COLOR_BGR2BGRA)
# inference
_ = pose.compute(input_data)
# postprocessing
display_result(input_image, pose)
cv2.imshow('frame', input_image)
# save results
if writer is not None:
writer.write(input_image)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
logger.warning(
'currently, video results cannot be output correctly...')
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = calc_adjust_fsize(f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
# save_w * 2: we stack source frame and estimated heatmap
writer = get_writer(args.savepath, save_h, save_w * 2)
else:
writer = None
input_shape_set = False
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
_, img = preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='None')
img = np.transpose(img, (0, 2, 3, 1))
if (not input_shape_set):
net.set_input_shape(img.shape)
input_shape_set = True
result = net.predict(img)[0]
plt.imshow(result)
plt.pause(.01)
if not plt.get_fignums():
break
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def unwarp_from_video():
# net initialize
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=args.env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
logger.warning(
'currently, video results cannot be output correctly...'
)
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, WC_IMG_HEIGHT, WC_IMG_WIDTH
)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while(True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
org_image, input_data = webcamera_utils.preprocess_frame(
frame, WC_IMG_HEIGHT, WC_IMG_WIDTH, normalize_type='255'
)
uwpred = run_inference(wc_net, bm_net, input_data, org_image)
cv2.imshow('frame', uwpred)
# TODO: FIXME:
# >>> error: (-215:Assertion failed)
# >>> image.depth() == CV_8U in function 'write'
# # save results
# if writer is not None:
# writer.write(uwpred)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath is not None:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH
)
# save_w * 2: we stack source frame and estimated heatmap
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while(True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='ImageNet'
)
# Inference
preds_ailia = net.predict(input_data)
plot_results(
input_image, preds_ailia, partialconv_label.imagenet_category
)
cv2.imshow('frame', input_image)
time.sleep(SLEEP_TIME)
# save results
if writer is not None:
writer.write(input_image)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
flag_set_shape = False
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
input_data = cv2.cvtColor(input_data, cv2.COLOR_BGR2RGB) / 255.0
input_data = input_data[np.newaxis, :, :, :]
if not flag_set_shape:
net.set_input_shape(input_data.shape)
flag_set_shape = True
preds_ailia = net.predict(input_data)
pred = preds_ailia.reshape((IMAGE_HEIGHT, IMAGE_WIDTH))
dst = transfer(input_image, pred)
cv2.imshow('frame', dst)
# save results
if writer is not None:
writer.write(dst)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='127.5')
# inference
input_blobs = net.get_input_blob_list()
net.set_input_blob_data(input_data, input_blobs[0])
net.update()
preds_ailia = net.get_results()
# postprocessing
detections = but.postprocess(preds_ailia)
but.show_result(input_image, detections)
cv2.imshow('frame', input_image)
# save results
if writer is not None:
writer.write(input_image)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('Script finished successfully.')
def estimate_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
# save_w * 2: we stack source frame and estimated heatmap
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w * 2)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = webcamera_utils.preprocess_frame(
frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
data_rgb=False,
normalize_type='None',
)
# inference
preds_ailia = net.predict(input_data)
# estimated crowd count
et_count = int(np.sum(preds_ailia))
# density map
density_map = (255 * preds_ailia / np.max(preds_ailia))[0][0]
density_map = cv2.resize(
density_map,
(input_image.shape[1], input_image.shape[0]),
)
heatmap = cv2.applyColorMap(density_map.astype(np.uint8),
cv2.COLORMAP_JET)
cv2.putText(
heatmap,
f'Est Count: {et_count}',
(40, 440), # position
cv2.FONT_HERSHEY_SIMPLEX, # font
0.8, # fontscale
(255, 255, 255), # color
2, # thickness
)
res_img = np.hstack((input_image, heatmap))
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(res_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def estimate_from_video():
# net initialize
enc_net = ailia.Net(ENC_MODEL_PATH, ENC_WEIGHT_PATH, env_id=args.env_id)
dec_net = ailia.Net(DEC_MODEL_PATH, DEC_WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
logger.warning('currently video results output feature '
'is not supported in this model!')
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = webcamera_utils.calc_adjust_fsize(
f_h, f_w, IMAGE_HEIGHT, IMAGE_WIDTH)
# save_w * 2: we stack source frame and estimated heatmap
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w * 2)
else:
writer = None
ret, frame = capture.read()
org_height, org_width, _ = frame.shape
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
_, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH)
# encoder
enc_input_blobs = enc_net.get_input_blob_list()
enc_net.set_input_blob_data(input_data, enc_input_blobs[0])
enc_net.update()
features = enc_net.get_results()
# decoder
dec_inputs_blobs = dec_net.get_input_blob_list()
for f_idx in range(len(features)):
dec_net.set_input_blob_data(features[f_idx],
dec_inputs_blobs[f_idx])
dec_net.update()
preds_ailia = dec_net.get_results()
# postprocessing
disp = preds_ailia[-1]
disp_resized, vmax = result_plot(disp, org_width, org_height)
plt.imshow(disp_resized, cmap='magma', vmax=vmax)
plt.pause(.01)
if not plt.get_fignums():
break
# save results
# FIXME: How to save plt --> cv2.VideoWriter()
# if writer is not None:
# # put pixel buffer in numpy array
# canvas = FigureCanvas(fig)
# canvas.draw()
# mat = np.array(canvas.renderer._renderer)
# res_img = cv2.cvtColor(mat, cv2.COLOR_RGB2BGR)
# writer.write(res_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
if args.env_id is not None:
count = ailia.get_environment_count()
if count > args.env_id:
env_id = args.env_id
else:
print(f'specified env_id: {args.env_id} cannot found error')
print(f'env_id: {env_id}')
detector = ailia.Detector(MODEL_PATH,
WEIGHT_PATH,
len(HAND_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV3,
env_id=env_id)
hand = ailia.PoseEstimator(HAND_MODEL_PATH,
HAND_WEIGHT_PATH,
env_id=env_id,
algorithm=HAND_ALGORITHM)
hand.set_threshold(0.1)
ailia_input_w = detector.get_input_shape()[3]
ailia_input_h = detector.get_input_shape()[2]
capture = get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_PATH:
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
save_h, save_w = calc_adjust_fsize(f_h, f_w, ailia_input_h,
ailia_input_w)
writer = get_writer(args.savepath, save_h, save_w)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
img = cv2.cvtColor(frame, cv2.COLOR_BGR2BGRA)
detector.compute(img, THRESHOLD, IOU)
h, w = img.shape[0], img.shape[1]
count = detector.get_object_count()
for idx in range(count):
# get detected hand
obj = detector.get_object(idx)
margin = 1.0
cx = (obj.x + obj.w / 2) * w
cy = (obj.y + obj.h / 2) * h
cw = max(obj.w * w, obj.h * h) * margin
fx = max(cx - cw / 2, 0)
fy = max(cy - cw / 2, 0)
fw = min(cw, w - fx)
fh = min(cw, h - fy)
top_left = (int(fx), int(fy))
bottom_right = (int(fx + fw), int(fy + fh))
# display detected hand
color = hsv_to_rgb(0, 255, 255)
cv2.rectangle(frame, top_left, bottom_right, color, 4)
# get detected face
crop_img = img[top_left[1]:bottom_right[1],
top_left[0]:bottom_right[0], 0:4]
if crop_img.shape[0] <= 0 or crop_img.shape[1] <= 0:
continue
# inference
_ = hand.compute(crop_img.astype(np.uint8, order='C'))
# postprocessing
display_result(frame, hand, top_left, bottom_right)
cv2.imshow('frame', frame)
# save results
if writer is not None:
writer.write(frame)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('Script finished successfully.')
