def recognize_from_video(net):
if args.back == True:
IMAGE_HEIGHT = IMAGE_HEIGHT_BACK
IMAGE_WIDTH = IMAGE_WIDTH_BACK
ANCHOR_PATH = ANCHOR_PATH_BACK
else:
IMAGE_HEIGHT = IMAGE_HEIGHT_FRONT
IMAGE_WIDTH = IMAGE_WIDTH_FRONT
ANCHOR_PATH = ANCHOR_PATH_FRONT
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))
writer = webcamera_utils.get_writer(args.savepath, f_h, f_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,
anchor_path=ANCHOR_PATH,
back=args.back)
but.show_result(input_image, detections)
# remove padding
dh = input_image.shape[0]
dw = input_image.shape[1]
sh = frame.shape[0]
sw = frame.shape[1]
input_image = input_image[(dh - sh) // 2:(dh - sh) // 2 + sh,
(dw - sw) // 2:(dw - sw) // 2 + sw, :]
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()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
detector = ailia.Net(FACE_MODEL_PATH, FACE_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:
writer = webcamera_utils.get_writer(args.savepath, IMAGE_HEIGHT,
IMAGE_WIDTH)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# detect face
detections = compute_blazeface(
detector,
frame,
anchor_path='../../face_detection/blazeface/anchors.npy',
)
# get detected face
if len(detections) == 0:
crop_img = frame
else:
crop_img, top_left, bottom_right = crop_blazeface(
detections[0], FACE_MARGIN, frame)
if crop_img.shape[0] <= 0 or crop_img.shape[1] <= 0:
crop_img = frame
# preprocess
input_image, input_data = webcamera_utils.preprocess_frame(
crop_img, IMAGE_HEIGHT, IMAGE_WIDTH, data_rgb=False)
# inference
preds_ailia = net.predict(input_data)[0]
# postprocessing
fig = gen_img_from_predsailia(input_data, preds_ailia)
fig.savefig('tmp.png')
img = cv2.imread('tmp.png')
cv2.imshow('frame', img)
# save results
if writer is not None:
img = cv2.resize(img, (IMAGE_WIDTH, IMAGE_HEIGHT))
writer.write(img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
os.remove('tmp.png')
print('Script finished successfully.')
def recognize_from_video(filename, net, face_pool_net, toonify=None):
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(args.savepath, IMAGE_HEIGHT,
IMAGE_WIDTH)
else:
writer = None
# average image
avg_img = np.load('average/avg_image.npy')
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# Resize by padding the perimeter.
_, input_data = webcamera_utils.preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='255')
resized_input = cv2.resize(input_data[0].transpose(1, 2, 0),
(RESIZE_HEIGHT, RESIZE_WIDTH))
resized_input = np.expand_dims(resized_input.transpose(2, 0, 1),
axis=0)
resized_input = (resized_input * 2) - 1
# inference
if toonify is None:
result_batch = run_on_batch(resized_input, net, face_pool_net,
args.iteration, avg_img)
# toonification task
else:
result_batch = run_on_batch(resized_input,
net,
face_pool_net,
args.iteration,
avg_img,
toonify=toonify)
# post-processing
res_img = post_processing(result_batch, input_data)
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 estimate_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = preprocess_frame(frame,
HEIGHT,
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)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=-1)
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) * int(args.scale))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH) * int(args.scale))
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w)
else:
writer = None
time.sleep(1)
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
IMAGE_HEIGHT, IMAGE_WIDTH = frame.shape[0], frame.shape[1]
if args.bilinear:
output_img = cv2.resize(frame,
(int(IMAGE_WIDTH * int(args.scale)),
int(IMAGE_HEIGHT * int(args.scale))))
else:
# Preprocessing
input_image, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='None')
net.set_input_shape((1, 3, IMAGE_HEIGHT, IMAGE_WIDTH))
# Inference
preds_ailia = net.predict(input_data)[0]
# Postprocessing
output_img = preds_ailia.transpose(1, 2, 0)
output_img = cv2.cvtColor(output_img, cv2.COLOR_RGB2BGR)
output_img = np.clip(output_img, 0, 255)
output_img = output_img.astype(np.uint8)
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()
logger.info('Script finished successfully.')
def video_style_transfer():
# net initialize
vgg = ailia.Net(VGG_MODEL_PATH, VGG_WEIGHT_PATH, env_id=args.env_id)
decoder = 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:
writer = webcamera_utils.get_writer(args.savepath, IMAGE_HEIGHT,
IMAGE_WIDTH)
else:
writer = None
# Style image
style_img = load_image(args.style, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True)
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# Resize by padding the perimeter.
_, input_data = webcamera_utils.preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='255')
# # The image will be distorted by normal resize
# input_data = (cv2.cvtColor(
# cv2.resize(frame, (IMAGE_WIDTH, IMAGE_HEIGHT)), cv2.COLOR_BGR2RGB
# ) / 255.0).transpose(2, 0, 1)[np.newaxis, :, :, :]
# inference
preds_ailia = style_transfer(vgg, decoder, input_data, style_img)
# post-processing
res_img = cv2.cvtColor(preds_ailia[0].transpose(1, 2, 0),
cv2.COLOR_RGB2BGR)
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(np.clip(res_img * 255 + 0.5, 0, 255).astype(np.uint8))
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('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
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
enc_net = ailia.Net(ENC_MODEL_PATH, ENC_WEIGHT_PATH, env_id=env_id)
dec_net = ailia.Net(DEC_MODEL_PATH, DEC_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)
ret, frame = capture.read()
org_height, org_width, _ = frame.shape
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
_, input_data = 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)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def segment_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)
ailia_input_w = net.get_input_shape()[3]
ailia_input_h = net.get_input_shape()[2]
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)
while(True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = 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)
capture.release()
cv2.destroyAllWindows()
print('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:
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))
writer = webcamera_utils.get_writer(args.savepath, f_h, f_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,
)
# inference
preds_ailia = net.predict(input_data)
# postprocessing
if args.smooth:
preds_ailia = smooth_output(preds_ailia)
gen_img = gen_preds_img(preds_ailia, IMAGE_HEIGHT, IMAGE_WIDTH)
plt.imshow(gen_img)
plt.pause(.01)
if not plt.get_fignums():
break
# # 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 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)
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 unwarp_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
org_image, input_data = preprocess_frame(frame,
WC_IMG_HEIGHT,
WC_IMG_WIDTH,
normalize_type='255')
# inference
wc_output = wc_net.predict(input_data)[0]
pred_wc = np.clip(wc_output, 0, 1.0).transpose(1, 2, 0)
bm_input = cv2.resize(pred_wc,
(BM_IMG_WIDTH, BM_IMG_HEIGHT)).transpose(
2, 0, 1)
bm_input = np.expand_dims(bm_input, 0)
outputs_bm = bm_net.predict(bm_input)[0]
uwpred = unwarp(org_image, outputs_bm) # This is not on GPU!
cv2.imshow('frame', uwpred)
capture.release()
cv2.destroyAllWindows()
print('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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = 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)
capture.release()
cv2.destroyAllWindows()
print('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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = preprocess_frame(
frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
)
# inference
preds_ailia = net.predict(input_data)
# postprocessing
if args.smooth:
preds_ailia = smooth_output(preds_ailia)
gen_img = gen_preds_img(preds_ailia, IMAGE_HEIGHT, IMAGE_WIDTH)
plt.imshow(gen_img)
plt.pause(.01)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video(filename, net):
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(
args.savepath, IMAGE_HEIGHT, IMAGE_WIDTH
)
else:
writer = None
while(True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# Resize by padding the perimeter.
_, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='255'
)
resized_input = cv2.resize(input_data[0].transpose(1,2,0), (RESIZE_HEIGHT, RESIZE_WIDTH))
resized_input = np.expand_dims(resized_input.transpose(2,0,1), axis=0)
resized_input = (resized_input * 2) - 1
input_batch = [add_aging_channel(resized_input[0], age) for age in args.target_age.split(',')]
result_batch = run_on_batch(input_batch, net)
# post-processing
res_img = post_processing(result_batch, input_data)
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():
# 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))
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w)
else:
writer = None
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, normalize_type='ImageNet')
input_data = input_data.transpose(0, 2, 3, 1)
# inference
preds_ailia = net.predict(input_data)
# postprocessing
plot_results(frame, preds_ailia,
efficientnetv2_labels.imagenet_category)
cv2.imshow('frame', frame)
time.sleep(SLEEP_TIME)
# save results
if writer is not None:
writer.write(frame)
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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
data_rgb=False)
# inference
preds_ailia = net.predict(input_data)[0]
# postprocessing
fig = gen_img_from_predsailia(input_data, preds_ailia)
fig.savefig('tmp.png')
img = cv2.imread('tmp.png')
cv2.imshow('frame', img)
capture.release()
cv2.destroyAllWindows()
os.remove('tmp.png')
print('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...')
writer = webcamera_utils.get_writer(args.savepath, IMAGE_HEIGHT,
IMAGE_WIDTH)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
src_img, input_data = webcamera_utils.preprocess_frame(
frame, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='ImageNet')
src_img = cv2.resize(src_img, (IMAGE_WIDTH, IMAGE_HEIGHT))
src_img = cv2.cvtColor(src_img, cv2.COLOR_BGR2RGB)
preds_ailia = net.predict(input_data)
res_img = postprocess(src_img, preds_ailia)
cv2.imshow('frame', res_img / 255.0)
# # save results
# if writer is not None:
# writer.write(res_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, input_data = preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='255')
# inference
preds_ailia = net.predict(input_data)
# postprocessing
output_img = preds_ailia[0].transpose((1, 2, 0))
output_img = cv2.cvtColor(output_img, cv2.COLOR_RGB2BGR)
cv2.imshow('frame', output_img)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def unwarp_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
bm_net = ailia.Net(BM_MODEL_PATH, BM_WEIGHT_PATH, env_id=env_id)
wc_net = ailia.Net(WC_MODEL_PATH, WC_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)
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
org_image, input_data = 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)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
if args.active_3d:
logger.info('>>> 3D mode is activated!')
depth_net = ailia.Net(DEPTH_MODEL_PATH,
DEPTH_WEIGHT_PATH,
env_id=args.env_id)
detector = ailia.Net(FACE_MODEL_PATH, FACE_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('[WARNING] currently video results output feature '
'is not supported in this model!')
# TODO: shape should be debugged!
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w)
else:
writer = None
fig, axs = create_figure(active_3d=args.active_3d)
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# detect face
detections = compute_blazeface(
detector,
frame,
anchor_path='../../face_detection/blazeface/anchors.npy',
)
# get detected face
if len(detections) == 0:
crop_img = frame
else:
crop_img, top_left, bottom_right = crop_blazeface(
detections[0], FACE_MARGIN, frame)
if crop_img.shape[0] <= 0 or crop_img.shape[1] <= 0:
crop_img = frame
# preprocess
input_image, input_data = webcamera_utils.preprocess_frame(
crop_img, IMAGE_HEIGHT, IMAGE_WIDTH, normalize_type='255')
# inference
preds_ailia = net.predict(input_data)
pts, pts_img = get_preds_from_hm(preds_ailia)
pts, pts_img = pts.reshape(68, 2) * 4, pts_img.reshape(68, 2)
if args.active_3d:
# 3D mode
heatmaps = np.zeros((68, IMAGE_HEIGHT, IMAGE_WIDTH),
dtype=np.float32)
for i in range(68):
if pts[i, 0] > 0:
heatmaps[i] = draw_gaussian(heatmaps[i], pts[i], 2)
heatmaps = heatmaps[np.newaxis, :, :, :]
depth_pred = depth_net.predict(
np.concatenate((input_data, heatmaps), 1))
depth_pred = depth_pred.reshape(68, 1)
pts_img = np.concatenate((pts_img, depth_pred * 2), 1)
resized_img = cv2.resize(cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB),
(IMAGE_WIDTH, IMAGE_HEIGHT))
# visualize results (clear axs at first)
axs = visualize_results(axs,
resized_img,
pts_img,
active_3d=args.active_3d)
plt.pause(0.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 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 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))
s = max(f_h, f_w)
writer = get_writer(args.savepath, s, s)
else:
writer = None
input_shape_set = False
debugger = Debugger()
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
img, data = preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='None')
s = max(img.shape[0], img.shape[1]) * 1.0
c = np.array([img.shape[1] / 2., img.shape[0] / 2.], dtype=np.float32)
trans_input = get_affine_transform(c, s, 0,
[IMAGE_HEIGHT, IMAGE_WIDTH])
inp = cv2.warpAffine(img,
trans_input, (IMAGE_HEIGHT, IMAGE_WIDTH),
flags=cv2.INTER_LINEAR)
inp = (inp / 255. - mean) / std
inp = inp.transpose(2, 0, 1)[np.newaxis, ...].astype(np.float32)
net.set_input_shape(inp.shape)
result = net.run(inp)
pred = get_preds(result[0])[0]
pred = transform_preds(pred, c, s, (64, 64))
pred_3d = get_preds_3d(result[0], result[1])[0]
debugger.add_img(img)
debugger.add_point_2d(pred, (255, 0, 0))
debugger.add_point_3d(pred_3d, 'b')
debugger.show_all_imgs(pause=False)
plt.pause(.01)
debugger.ax.clear()
if not plt.get_fignums():
break
if writer is not None:
debugger.save_video(writer)
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()
env_id = 0
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
net.set_input_shape((1,IMAGE_HEIGHT,IMAGE_WIDTH,4))
env_id = ailia.get_gpu_environment_id()
seg_net = ailia.Net(SEGMENTATION_MODEL_PATH, SEGMENTATION_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)
while(True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
# grab src image
src_img, input_data = preprocess_frame(
frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='None'
)
crop_size = (max(src_img.shape[0],src_img.shape[1]),max(src_img.shape[0],src_img.shape[1]))
src_img=safe_crop(src_img, crop_size)
trimap_data,seg_data = generate_trimap(seg_net,src_img)
input_data, src_img, trimap_data = matting_preprocess(src_img,trimap_data,seg_data)
preds_ailia = net.predict(input_data)
# postprocessing
res_img = postprocess(src_img, trimap_data, preds_ailia)
seg_img = res_img.copy()
# seg_data=safe_crop(seg_data, x, y, crop_size)
seg_img [:,:,3] = seg_data[:,:,0]
seg_img = composite(seg_img)
res_img = composite(res_img)
cv2.imshow('matting', res_img / 255.0)
cv2.imshow('masked', seg_img / 255.0)
cv2.imshow('trimap', trimap_data / 255.0)
cv2.imshow('segmentation', seg_data / 255.0)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def video_style_transfer():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
vgg = ailia.Net(VGG_MODEL_PATH, VGG_WEIGHT_PATH, env_id=env_id)
decoder = ailia.Net(DEC_MODEL_PATH, DEC_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)
# Style image
style_img = load_image(args.style, (IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='255',
gen_input_ailia=True)
# create video writer if savepath is specified as video format
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(args.savepath, IMAGE_HEIGHT,
IMAGE_WIDTH)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# Resize by padding the perimeter.
_, input_data = webcamera_utils.preprocess_frame(frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
normalize_type='255')
# # The image will be distorted by normal resize
# input_data = (cv2.cvtColor(
# cv2.resize(frame, (IMAGE_WIDTH, IMAGE_HEIGHT)), cv2.COLOR_BGR2RGB
# ) / 255.0).transpose(2, 0, 1)[np.newaxis, :, :, :]
# inference
preds_ailia = style_transfer(vgg, decoder, input_data, style_img)
# postprocessing
res_img = cv2.cvtColor(preds_ailia[0].transpose(1, 2, 0),
cv2.COLOR_RGB2BGR)
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(np.clip(res_img * 255 + 0.5, 0, 255).astype(np.uint8))
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
