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
frame = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
input_data = preprocess(frame)
net.set_input_shape(input_data.shape)
boxes, labels, scores, masks = net.predict([input_data])
display_objdetect_image(frame, boxes, labels, scores, masks)
plt.pause(.01)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video(video, detector):
if 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
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)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def get_capture(video):
"""
Get cv2.VideoCapture
* TODO: maybe get capture & writer at the same time?
* then, you can use capture frame size directory
Parameters
----------
video : str
webcamera-id or video path
Returns
-------
capture : cv2.VideoCapture
"""
try:
video_id = int(video)
# webcamera-mode
capture = cv2.VideoCapture(video_id)
if not capture.isOpened():
print(f"[ERROR] webcamera (ID - {video_id}) not found")
sys.exit(0)
except ValueError:
# if file path is given, open video file
if check_file_existance(video):
capture = cv2.VideoCapture(video)
return capture
def process_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.face_recognition:
locator = FaceLocator()
else:
locator = None
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
img = process_frame(net, locator, frame)
cv2.imshow('frame', img[..., ::-1])
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_tag_from_image():
# prepare input data
input_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
input_data = prepare_input_data(input_img)
# net initialize
tag_net = ailia.Net(TAG_MODEL_PATH, TAG_WEIGHT_PATH, env_id=args.env_id)
tag_net.set_input_shape(input_data.shape)
if check_file_existance(TAG_PATH):
tags = np.array(json.loads(open(TAG_PATH, 'r').read()))
assert(len(tags) == 1539)
input_dict = {'data': input_data}
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
preds_ailia = tag_net.predict(input_dict)[0]
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
preds_ailia = tag_net.predict(input_dict)[0]
prob = preds_ailia.reshape(preds_ailia.shape[0], -1)
preds = estimate_top_tags(prob, tags, 512) # TODO how to decide n_tag?
pprint(apply_threshold(preds, THRESHOLD))
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)
net.set_input_shape((1, IMAGE_HEIGHT, IMAGE_WIDTH, 3))
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)
fig = create_figure()
tight_layout = True
while(True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_image, resized_img = adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH
)
resized_img = cv2.cvtColor(resized_img, cv2.COLOR_BGR2RGB)
if args.apply_rotate:
rotation_angle = np.random.randint(360)
rotated_img = generate_rotated_image(
resized_img,
rotation_angle,
size=(IMAGE_HEIGHT, IMAGE_WIDTH),
crop_center=True,
crop_largest_rect=True
)
input_data = rotated_img.reshape((1, IMAGE_HEIGHT, IMAGE_WIDTH, 3))
else:
rotation_angle = 0
rotated_img = resized_img
input_data = rotated_img.reshape((1, IMAGE_HEIGHT, IMAGE_WIDTH, 3))
# inference
preds_ailia = net.predict(input_data)
# visualize
predicted_angle = np.argmax(preds_ailia, axis=1)[0]
plt = visualize(fig, rotated_img, rotation_angle, predicted_angle, tight_layout)
plt.pause(.01)
tight_layout = False
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_tag_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
tag_net = ailia.Net(TAG_MODEL_PATH, TAG_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)
if check_file_existance(TAG_PATH):
tags = np.array(json.loads(open(TAG_PATH, 'r').read()))
assert (len(tags) == 1539)
while (True):
ret, frame = capture.read()
_, frame = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_data = prepare_input_data(frame, bgr=True)
input_dict = {'data': input_data}
tag_net.set_input_shape(input_data.shape)
# inference
preds_ailia = tag_net.predict(input_dict)[0]
prob = preds_ailia.reshape(preds_ailia.shape[0], -1)
preds = estimate_top_tags(prob, tags, 512)
print('==============================================================')
pprint(apply_threshold(preds, THRESHOLD))
cv2.imshow('frame', frame)
time.sleep(SLEEP_TIME)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
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)
# # 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)
net.set_input_shape((1, 3, args.duration, IMAGE_HEIGHT, IMAGE_WIDTH))
# prepare input data
original_queue = deque([])
input_blob = np.empty((1, 3, args.duration, IMAGE_HEIGHT, IMAGE_WIDTH))
for i in range(args.duration - 1):
ret, frame = capture.read()
if not ret:
continue
original_queue.append(frame)
input_blob[0, :, i, :, :] = convert_input_frame(frame)
next_input_index = args.duration - 1
input_frame_size = capture.get(cv2.CAP_PROP_FRAME_COUNT)
while (next_input_index <= input_frame_size or input_frame_size == 0):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
original_queue.append(frame)
input_blob[0, :, args.duration - 1, :, :] = convert_input_frame(frame)
if args.ailia:
result = net.predict(input_blob)
else:
result = session.run(
[output_name], {input_name: input_blob.astype(np.float32)})[0]
print_mars_result(result)
preview_img = original_queue.popleft()
cv2.imshow('preview', preview_img)
for i in range(args.duration - 1):
input_blob[0, :, i, :, :] = input_blob[0, :, i + 1, :, :]
next_input_index += 1
capture.release()
print('Script finished successfully.')
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():
etl_word = codecs.open(ETL_PATH, 'r', 'utf-8').readlines()
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
classifier = ailia.Classifier(
MODEL_PATH,
WEIGHT_PATH,
env_id=env_id,
format=ailia.NETWORK_IMAGE_FORMAT_GRAY,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32
)
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
in_frame, frame = 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()
print('==============================================================')
print(f'class_count: {count}')
for idx in range(count) :
print(f"+ idx={idx}")
info = classifier.get_class(idx)
print(f" category={info.category} [ {etl_word[info.category]} ]" )
print(f" prob={info.prob}")
cv2.imshow('frame', in_frame)
time.sleep(SLEEP_TIME)
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}')
classifier = ailia.Classifier(
MODEL_PATH,
WEIGHT_PATH,
env_id=env_id,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32
)
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
_, resized_frame = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
input_data = cv2.cvtColor(
resized_frame.astype(np.float32),
cv2.COLOR_RGB2BGRA
).astype(np.uint8)
classifier.compute(input_data, MAX_CLASS_COUNT)
count = classifier.get_class_count()
# show results
print('==============================================================')
print(f'class_count: {count}')
for idx in range(count):
print(f'+ idx={idx}')
info = classifier.get_class(idx)
print(f' category={info.category} [ ' +\
f'{googlenet_labels.imagenet_category[info.category]} ]')
print(f' prob={info.prob}')
cv2.imshow('frame', frame)
time.sleep(SLEEP_TIME)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
# [WARNING] This is test impl
print('[WARNING] This is test implementation')
# 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
img = preProcess(frame)
input_data = padCropImg(img)
input_data = input_data.astype(np.float32) / 255.0
ynum = input_data.shape[0]
xnum = input_data.shape[1]
preds_ailia = np.zeros((ynum, xnum, 128, 128, 3), dtype=np.float32)
for j in range(ynum):
for i in range(xnum):
patchImg = input_data[j, i]
patchImg = (patchImg - 0.5) / 0.5
patchImg = patchImg.transpose((2, 0, 1))
patchImg = patchImg[np.newaxis, :, :, :]
out = net.predict(patchImg)
out = out.transpose((0, 2, 3, 1))[0]
out = (np.clip(out, 0, 1) * 255).astype(np.uint8)
preds_ailia[j, i] = out
resImg = composePatch(preds_ailia)
resImg = postProcess(resImg)
cv2.imshow('frame', img_as_ubyte(resImg))
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def compare_videoframe_image():
# 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)
# img part
fname = args.video[1]
input_data = load_and_preprocess(fname)
_ = net.predict(input_data)
i_feature = net.get_blob_data(net.find_blob_index_by_name('conv5_3'))
# video part
if args.video[0] == '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
_, resized_frame = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
input_data = preprocess(resized_frame, input_is_bgr=True)
# inference
_ = net.predict(input_data)
v_feature = net.get_blob_data(net.find_blob_index_by_name('conv5_3'))
# show result
dist = distance(i_feature, v_feature)
print('=============================================================')
print(f'{os.path.basename(fname)} vs video frame = {dist}')
if dist < THRESHOLD:
print('Same person')
else:
print('Not same person')
cv2.imshow('frame', resized_frame)
time.sleep(SLEEP_TIME)
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 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 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
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
pose = ailia.PoseEstimator(MODEL_PATH,
WEIGHT_PATH,
env_id=env_id,
algorithm=ALGORITHM)
baseline = ailia.Net(BASELINE_MODEL_PATH,
BASELINE_WEIGHT_PATH,
env_id=env_id)
baseline.set_input_shape((1, 32))
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 = adjust_frame_size(
frame,
IMAGE_HEIGHT,
IMAGE_WIDTH,
)
input_data = cv2.cvtColor(input_data, cv2.COLOR_BGR2BGRA)
# inferece
_ = pose.compute(input_data)
# postprocessing
display_result(input_image, pose, baseline)
cv2.imshow('frame', input_image)
# display 3d pose
plt.pause(0.01)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_tag_from_video():
# net initialize
tag_net = ailia.Net(TAG_MODEL_PATH, TAG_WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(args.video)
if check_file_existance(TAG_PATH):
tags = np.array(json.loads(open(TAG_PATH, 'r').read()))
assert len(tags) == 1539
# 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
_, frame = webcamera_utils.adjust_frame_size(
frame, IMAGE_HEIGHT, IMAGE_WIDTH
)
input_data = prepare_input_data(frame, bgr=True)
input_dict = {'data': input_data}
tag_net.set_input_shape(input_data.shape)
# inference
preds_ailia = tag_net.predict(input_dict)[0]
prob = preds_ailia.reshape(preds_ailia.shape[0], -1)
preds = estimate_top_tags(prob, tags, 512)
print('==============================================================')
pprint(apply_threshold(preds, THRESHOLD))
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()
print('Script finished successfully.')
def compare_image_and_video():
# prepare base image
base_imgs = prepare_input_data(args.video[1])
# net itinialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
# web camera
if args.video[0] == '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[0]):
capture = cv2.VideoCapture(args.video[0])
# inference loop
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
frame, resized_frame = adjust_frame_size(frame, IMAGE_HEIGHT,
IMAGE_WIDTH)
input_frame = preprocess_image(resized_frame, input_is_bgr=True)
input_data = np.concatenate([base_imgs, input_frame], axis=0)
# inference
preds_ailia = net.predict(input_data)
# postprocessing
fe_1 = np.concatenate([preds_ailia[0], preds_ailia[1]], axis=0)
fe_2 = np.concatenate([preds_ailia[2], preds_ailia[3]], axis=0)
sim = cosin_metric(fe_1, fe_2)
bool_sim = False if THRESHOLD > sim else True
frame = draw_result_on_img(
frame,
texts=[f"Similarity: {sim:06.3f}", f"SAME FACE: {bool_sim}"])
cv2.imshow('frame', frame)
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}')
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(FACE_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=RANGE,
algorithm=ALGORITHM,
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
_, resized_img = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
img = cv2.cvtColor(resized_img, cv2.COLOR_BGR2BGRA)
detector.compute(img, THRESHOLD, IOU)
detections = []
for idx in range(detector.get_object_count()):
obj = detector.get_object(idx)
detections.append(obj)
detections=nms_between_categories(detections,frame.shape[1],frame.shape[0],categories=[0,1],iou_threshold=IOU)
res_img = plot_results(detections, resized_img, FACE_CATEGORY, False)
cv2.imshow('frame', res_img)
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
# prepare frame
img, resized_img = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
data = cv2.cvtColor(resized_img, cv2.COLOR_BGR2GRAY)
data = cv2.equalizeHist(data)
if platform.system() == 'Darwin':
data = data[np.newaxis, np.newaxis, :, :] / 255.0 - 0.5
else:
data = data[np.newaxis, np.newaxis, :, :] / 127.5 - 1.0
eyeI = np.concatenate((data, data), axis=0)
eyeI = eyeI.reshape(2, IMAGE_HEIGHT, IMAGE_WIDTH, 1)
# inference
preds_ailia = net.predict(eyeI)
preds_ailia = net.get_blob_data(
net.find_blob_index_by_name(OUTPUT_BLOB_NAME)
)
# postprocessing
img = plot_on_image(img, preds_ailia)
cv2.imshow('frame', img)
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)
input_shape_set = False
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
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
cv2.imshow('depth', out.transpose(1, 2, 0).astype("uint16"))
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)
# create video writer if savepath is specified as video format
f_h = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
f_w = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w, rgb=False)
else:
writer = None
while(True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_data = transform(frame, IMAGE_SIZE)
# inference
preds_ailia = net.predict([input_data])
# postprocessing
pred = cv2.resize(norm(preds_ailia[0][0, 0, :, :]), (f_w, f_h))
cv2.imshow('frame', pred)
# save results
if writer is not None:
writer.write((pred * 255).astype(np.uint8))
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')
# 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}')
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(COCO_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_S_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV2,
env_id=env_id
)
detector.set_anchors(ANCHORS)
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
_, resized_img = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
img = cv2.cvtColor(resized_img, cv2.COLOR_RGB2BGRA)
detector.compute(img, THRESHOLD, IOU)
res_img = plot_results(detector, resized_img, COCO_CATEGORY, False)
cv2.imshow('frame', res_img)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video():
# net initialize
detector = None
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
if int(args.detection_width) != DETECTION_WIDTH:
detector.set_input_shape(
(1, 3, int(args.detection_width), int(args.detection_width)))
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
img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (IMAGE_WIDTH, IMAGE_HEIGHT))
img = np.transpose(img, [2, 0, 1])
img = img.astype(np.float32) / 255
img = np.expand_dims(img, 0)
output = detector.predict([img])
detect_object = yolov4_utils.post_processing(img, THRESHOLD, IOU,
output)
res_img = plot_results(detect_object[0], frame, COCO_CATEGORY)
cv2.imshow('frame', res_img)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def extract_feature_vec_from_video():
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
fe_net = ailia.Net(FE_MODEL_PATH, FE_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()
_, frame = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
input_data = prepare_input_data(frame, bgr=True)
input_dict = {'data': input_data}
fe_net.set_input_shape(input_data.shape)
# inference
_ = fe_net.predict(input_dict)[0]
# Extracting the output of a specifc layer
idx = fe_net.find_blob_index_by_name('encode1')
preds_ailia = fe_net.get_blob_data(idx)
print('==============================================================')
print(preds_ailia.reshape(preds_ailia.shape[0], -1))
cv2.imshow('frame', frame)
time.sleep(SLEEP_TIME)
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():
# 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
_, resized_image = adjust_frame_size(frame, IMAGE_HEIGHT, IMAGE_WIDTH)
if args.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)
# postprocessing
output_img = preds_ailia[0].transpose(1, 2, 0)
cv2.imshow('frame', output_img)
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.')
