def recognize_from_video(net, detector):
video_file = args.video if args.video else args.input[0]
capture = get_capture(video_file)
assert capture.isOpened(), 'Cannot capture source'
# 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:
logger.warning(
'currently, video results cannot be output correctly...')
writer = 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
res_img = recognize_from_frame(net, detector, frame)
# show
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(res_img.astype(np.uint8))
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(detector):
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 = f_h, f_w
writer = webcamera_utils.get_writer(args.savepath, save_h, save_w)
else:
writer = None
if args.write_prediction:
frame_count = 0
frame_digit = int(
math.log10(capture.get(cv2.CAP_PROP_FRAME_COUNT)) + 1)
video_name = os.path.splitext(os.path.basename(args.video))[0]
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
raw_img = frame
if args.detector:
detector.compute(raw_img, args.threshold, args.iou)
res_img = plot_results(detector, raw_img, COCO_CATEGORY)
detect_object = detector
else:
img, ratio = preprocess(raw_img, (HEIGHT, WIDTH))
output = detector.run(img[None, :, :, :])
predictions = postprocess(output[0], (HEIGHT, WIDTH))[0]
detect_object = predictions_to_object(predictions, raw_img, ratio,
args.iou, args.threshold)
detect_object = reverse_letterbox(
detect_object, raw_img, (raw_img.shape[0], raw_img.shape[1]))
res_img = plot_results(detect_object, raw_img, COCO_CATEGORY)
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(res_img)
# write prediction
if args.write_prediction:
savepath = get_savepath(
args.savepath,
video_name,
post_fix='_%s' %
(str(frame_count).zfill(frame_digit) + '_res'),
ext='.png')
pred_file = '%s.txt' % savepath.rsplit('.', 1)[0]
write_predictions(pred_file, detect_object, frame, COCO_CATEGORY)
frame_count += 1
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(net):
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, image = capture.read()
# press q to end video capture
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
logger.info('============================================')
cv2.imshow('frame', image)
image = Image.fromarray(np.uint8(image)).convert('L')
image = pre_process(image)
preds = predict(net, image)
sim_pred = post_process(preds, len(preds), alphabet)
logger.info('String recognized from image is:' + str(sim_pred))
# save results
# if writer is not None:
# writer.write(img)
capture.release()
cv2.destroyAllWindows()
# if writer is not None:
# writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(video):
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
capture = webcamera_utils.get_capture(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, img = capture.read()
# press q to end video capture
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
objs = detect_objects(img, detector)
for obj in objs:
dbface_utils.drawbbox(img, obj)
cv2.imshow('frame', img)
# save results
if writer is not None:
writer.write(img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
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:
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
x = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
x = preprocess(x)
preds_ailia = net.predict(x)
search_gallery(net, preds_ailia, x[0].transpose(1, 2, 0))
# save results
if writer is not None:
savepath = get_savepath(args.savepath, filename)
plt.savefig(savepath, bbox_inches='tight')
#writer.write(res_img)
plt.show()
#break
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
def recognize_from_video():
# Initialize net.
net = _initialize_net(args)
capture = get_capture(args.video)
while True:
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord("q")) or not ret:
break
# Prepare input data.
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frame = cut_max_square(frame)
dataset = _prepare_data(args, frame=frame)
# Inference
depth_pred_col = _estimate(dataset[0], net, args)
# Postprocessing
cv2.imshow(
"frame",
cv2.cvtColor(depth_pred_col.astype("uint8"), cv2.COLOR_RGB2BGR))
capture.release()
cv2.destroyAllWindows()
logger.info("Script finished successfully.")
def recognize_from_video(net, orig_target_sizes):
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, HEIGHT, WIDTH)
else:
writer = None
while True:
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
frame = cv2.resize(frame, dsize=(VIDEO_HEIGHT, VIDEO_WIDTH))
out_pred_logits, out_pred_curves, _, _, weights = predict(net, frame)
results = postprocess(out_pred_logits, out_pred_curves, orig_target_sizes)
preds = draw_annotation(results[0], frame)
cv2.imshow('frame', preds)
# save results
if writer is not None:
writer.write(preds)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
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(video, detector, pp_net):
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
x = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
detect_object, seg_masks = detect_objects(x, detector, pp_net)
res_img = plot_results(detect_object,
frame,
CATEGORY,
segm_masks=seg_masks)
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, detector):
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
recognize_from_frame(net, detector, frame)
# show result
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()
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)
shape = pose.get_input_shape()
print(shape)
IMAGE_WIDTH = shape[3]
IMAGE_HEIGHT = shape[2]
capture = get_capture(args.video)
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_image, input_data = 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)
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
def recognize_from_video(video, net):
capture = webcamera_utils.get_capture(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
out_mask = predict(frame, net)
# draw segmentation area
if not args.orig_size:
frame = cv2.resize(frame, (IMAGE_WIDTH, IMAGE_HEIGHT))
res_img = np.ones(frame.shape, np.uint8) * 255
res_img[out_mask] = frame[out_mask]
# show
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(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(video, det_model):
capture = get_capture(video)
fig = plt.figure(figsize=plt.figaspect(0.5), tight_layout=True)
ax1 = fig.add_subplot(1, 2, 1)
ax2 = fig.add_subplot(1, 2, 2, projection='3d')
axs = [ax1, ax2]
while (True):
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
xyz = predict(frame, det_model)
# visualize results (clear axs at first)
visualize_results(axs, frame, xyz)
plt.pause(SLEEP_TIME)
if not plt.get_fignums():
break
capture.release()
cv2.destroyAllWindows()
print('Script finished successfully.')
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 = 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, rgb=False
)
else:
writer = None
while(True):
ret, img = capture.read()
# press q to end video capture
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
input_img = preprocess(img, False)
d1, d2, d3, d4, d5, d6, d7 = net.predict({'input.1': input_img})
out_img = post_process(d1)
cv2.imshow('frame', out_img)
if writer is not None:
writer.write(out_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(net, det_net):
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
# inference
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
flags, landmarks = pose_estimate(net, det_net, frame_rgb)
# plot result
display_result(frame, landmarks, flags)
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()
logger.info('Script finished successfully.')
def process_video():
# net initialize
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
if args.face_recognition:
locator = FaceLocator()
else:
locator = None
capture = webcamera_utils.get_capture(args.video)
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(args.savepath, args.resolution,
args.resolution)
else:
writer = None
while (True):
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
img = process_frame(net, locator, frame)
img = img[..., ::-1]
cv2.imshow('frame', img)
# save results
if writer is not None:
writer.write(img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(video, detector):
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, img = capture.read()
# press q to end video capture
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
boxes, scores, cls_inds = detect_objects(img, detector)
img = draw_detection(img, boxes, scores, cls_inds)
cv2.imshow('frame', img)
# save results
if writer is not None:
writer.write(img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
print('Script finished successfully.')
def recognize_from_video(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,
rgb=False)
else:
writer = None
while (True):
ret, img = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
out = segment_image(img, net)
cv2.imshow('frame', out)
# save results
if writer is not None:
writer.write(out)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(net):
capture = webcamera_utils.get_capture(args.video)
video_length = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
logger.info(f"video_length: {video_length}")
# create video writer if savepath is specified as video format
fps = int(capture.get(cv2.CAP_PROP_FPS))
f_h, f_w = map(int, args.hw.split(','))
writer = None
if args.savepath != SAVE_IMAGE_PATH:
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w, fps=fps)
# create output buffer
n_output = 1
output_buffer = np.zeros((f_h * (n_output + 2), f_w, 3))
output_buffer = output_buffer.astype(np.uint8)
images = []
if 0 < video_length:
it = iter(tqdm(range(video_length)))
next(it)
while True:
if 0 < video_length:
try:
next(it)
except StopIteration:
break
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# set inputs
images.append(cv2.resize(frame, (f_w, f_h)))
if len(images) < 2:
continue
elif len(images) > 2:
images = images[1:]
# inference
img1, img2 = images
out_img = predict(net, img1, img2)
output_buffer[:f_h, :f_w, :] = images[0]
output_buffer[f_h * 1:f_h * 2, :f_w, :] = out_img
output_buffer[f_h * 2:f_h * 3, :f_w, :] = images[1]
# preview
cv2.imshow('frame', output_buffer)
# save results
if writer is not None:
writer.write(images[0])
writer.write(out_img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(video, detector):
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, img = capture.read()
# press q to end video capture
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
boxes, scores, cls_inds = detect_objects(img, detector)
# show image
detect_object = convert_to_ailia_detector_object(
boxes, scores, cls_inds, img.shape[1], img.shape[0])
img = plot_results(detect_object, img, COCO_CATEGORY)
cv2.imshow('frame', img)
# save results
if writer is not None:
writer.write(img)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
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():
# Initialize net.
net = _initialize_net(args)
capture = get_capture(args.video)
while True:
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord("q")) or not ret:
break
# Prepare input data.
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
dataset = _prepare_data(args, frame=frame)
# Inference
weather, prob = _estimate(dataset, net)
# Postprocessing
cv2.imshow(
"frame",
weather_prediction_from_image_utils.annotate_video(
frame,
_output_text(weather, prob),
),
)
capture.release()
cv2.destroyAllWindows()
logger.info("Script finished successfully.")
def enhance_video():
# net initialize
model = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
upsampler = RealESRGAN(model)
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)
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
img = cv2.resize(frame, dsize=(H, W))
# inference
output = upsampler.enhance(img)
#plot result
cv2.imshow('frame', output)
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video(det_net, reg_net, labels):
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
# inference
img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
reg_detections, det_detections = predict(det_net, reg_net, img, labels)
frame = draw_detections(frame, reg_detections, det_detections, rgb=False)
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()
logger.info('Script finished successfully.')
def recognize_from_video(net, face_net):
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
f_h = f_w = IMAGE_SIZE
if args.savepath != SAVE_IMAGE_PATH:
logger.warning(
'currently, video results cannot be output correctly...')
writer = webcamera_utils.get_writer(args.savepath, f_h, f_w * 2)
else:
writer = None
# create output buffer
res_img = np.ones((f_h, f_w * 2, 3))
# get style image
img_B = load_image(args.image_makeup)
img_B = cv2.cvtColor(img_B, cv2.COLOR_BGRA2RGB)
img_B_style = cv2.cvtColor(cv2.resize(img_B, (f_w // 4, f_h // 4)),
cv2.COLOR_RGB2BGR)
img_B, _ = preprocess(img_B)
while True:
ret, frame = capture.read()
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if not ret:
continue
# face detect
img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img_A, (y, x) = face_detect(img, face_net)
if not (img_A is None):
res_img[:, 0:f_w, :] = cv2.cvtColor(cv2.resize(img_A, (f_w, f_h)),
cv2.COLOR_RGB2BGR)
res_img[f_h // 4 * 3:f_h, 0:f_w // 4, :] = img_B_style
img_A, scale = preprocess(img_A)
output = net.predict({'img_A': img_A, 'img_B': img_B})
fake_A, fake_B = output
res_img[:, f_w:f_w * 2, :] = postprocess(fake_A[0])
# save results
res_img = res_img.astype(np.uint8)
if writer is not None:
writer.write(res_img)
# show
cv2.imshow('frame', res_img)
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)
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():
# net initialize
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_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV3,
env_id=args.env_id,
)
if args.detection_width != DETECTION_SIZE or args.detection_height != DETECTION_SIZE:
detector.set_input_shape(
args.detection_width, args.detection_height
)
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
if args.write_prediction:
frame_count = 0
frame_digit = int(math.log10(capture.get(cv2.CAP_PROP_FRAME_COUNT)) + 1)
video_name = os.path.splitext(os.path.basename(args.video))[0]
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, args.threshold, args.iou)
res_img = plot_results(detector, frame, COCO_CATEGORY, False)
cv2.imshow('frame', res_img)
# save results
if writer is not None:
writer.write(res_img)
# write prediction
if args.write_prediction:
savepath = get_savepath(args.savepath, video_name, post_fix = '_%s' % (str(frame_count).zfill(frame_digit) + '_res'), ext='.png')
pred_file = '%s.txt' % savepath.rsplit('.', 1)[0]
write_predictions(pred_file, detector, frame, COCO_CATEGORY)
frame_count += 1
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
classifier = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# adjust prediction label
labels = np.array(vit_labels.imagenet_category)
# capture video
capture = webcamera_utils.get_capture(args.video)
# create video writer if savepath is specified as video format
if (args.savepath is not None) & (args.savepath.split('.')[-1] == 'mp4'):
writer = webcamera_utils.get_writer(args.savepath, FIGURE_HEIGHT,
FIGURE_WIDTH)
else:
writer = None
while (True):
# read frame
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
# preprocessing
frame = frame[..., ::-1] # BGR2RGB
input_data = prep_input(frame)
# inference
output = classifier.run(input_data)
# pick up logits and attention map
logits = output[0]
att_mat = np.array(output[1:]).squeeze(1)
# get prediction label and its score
probs = np.exp(logits[0])
probs = probs / np.sum(probs)
topN = np.argsort(-probs)[:5]
# calculate attention map
mask = calc_attention_map(att_mat,
height_org=np.shape(frame)[0],
width_org=np.shape(frame)[1])
# visualize result
frame_figure = visualize_result(frame, mask, probs[topN], labels[topN])
# view result figure
cv2.imshow('frame', frame_figure[..., ::-1])
time.sleep(SLEEP_TIME)
# save result
if writer is not None:
writer.write(frame_figure[..., ::-1])
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
# save visualization
logger.info(f'saved at : {args.savepath}')
logger.info('Script finished successfully.')
