def recognize_from_video():
# net initialize
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(FACE_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_S_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV1,
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
_, resized_img = webcamera_utils.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, FACE_CATEGORY, False)
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()
print('Script finished successfully.')
def recognize_from_image():
# net initialize
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
org_img = load_image(image_path)
org_img = cv2.cvtColor(org_img, cv2.COLOR_BGRA2BGR)
logger.debug(f'input image shape: {org_img.shape}')
img = letterbox_convert(org_img, (IMAGE_HEIGHT, IMAGE_WIDTH))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, [2, 0, 1])
img = img.astype(np.float32) / 255
img = np.expand_dims(img, 0)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
output = detector.predict([img])
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
output = detector.predict([img])
detect_object = yolov4_utils.post_processing(img, args.threshold,
args.iou, output)
detect_object = reverse_letterbox(detect_object[0], org_img,
(IMAGE_HEIGHT, IMAGE_WIDTH))
# plot result
res_img = plot_results(detect_object, org_img, COCO_CATEGORY)
# plot result
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
logger.info('Script finished successfully.')
def recognize_from_image():
# net initialize
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(VOC_CATEGORY),
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_S_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_YOLOV1,
env_id=args.env_id,
)
if args.profile:
detector.set_profile_mode(True)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
img = load_image(image_path)
logger.debug(f'input image shape: {img.shape}')
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detector.compute(img, THRESHOLD, IOU)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
detector.compute(img, THRESHOLD, IOU)
# plot result
res_img = plot_results(detector, img, VOC_CATEGORY)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
if args.profile:
print(detector.get_summary())
logger.info('Script finished successfully.')
def recognize_from_image(filename, detector):
if args.profile:
detector.set_profile_mode(True)
# load input image
img = load_image(filename)
img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
boxes, scores, cls_inds = detect_objects(img, detector)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
boxes, scores, cls_inds = detect_objects(img, detector)
try:
logger.info('\n'.join([
'pos:{}, ids:{}, score:{:.3f}'.format(
'(%.1f,%.1f,%.1f,%.1f)' % (box[0], box[1], box[2], box[3]),
COCO_CATEGORY[int(obj_cls)], score)
for box, obj_cls, score in zip(boxes, cls_inds, scores)
]))
except:
# FIXME: do not use bare 'except'
pass
# 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)
savepath = get_savepath(args.savepath, filename)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, img)
if args.profile:
print(detector.get_summary())
logger.info('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
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)
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
detector.compute(raw_img, args.threshold, args.iou)
res_img = plot_results(detector, raw_img, COCO_CATEGORY)
detect_object = detector
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 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 recognize_from_video(video, net):
capture = get_capture(video)
while True:
ret, frame = capture.read()
if (cv2.waitKey(1) & 0xFF == ord('q')) or not ret:
break
pred = predict(frame, net)
# plot result
detect_object = convert_to_ailia_detector_object(
pred, frame.shape[1], frame.shape[0])
img = plot_results(detect_object, frame, obj_list)
cv2.imshow('frame', img)
capture.release()
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
img = load_image(args.input)
print(f'input image shape: {img.shape}')
# 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
)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detector.compute(img, THRESHOLD, IOU)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
detector.compute(img, THRESHOLD, IOU)
# nms
detections = []
for idx in range(detector.get_object_count()):
obj = detector.get_object(idx)
detections.append(obj)
detections=nms_between_categories(detections,img.shape[1],img.shape[0],categories=[0,1],iou_threshold=IOU)
# plot result
res_img = plot_results(detections, img, FACE_CATEGORY)
cv2.imwrite(args.savepath, res_img)
print('Script finished successfully.')
def recognize_from_video():
# net initialize
env_id = args.env_id
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
detector = NanoDetDetection(net,
input_shape=[HEIGHT, WIDTH],
reg_max=REG_MAX)
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 = f_h, f_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
raw_img = frame
detect_object = detector.detect(raw_img)
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)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')
def recognize_from_image(detector):
# input image loop
for image_path in args.input:
# prepare input data
logger.debug(f'input image: {image_path}')
raw_img = cv2.imread(image_path, cv2.IMREAD_COLOR)
logger.debug(f'input image shape: {raw_img.shape}')
def compute():
detector.compute(raw_img, args.threshold, args.iou)
return None
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
total_time = 0
for i in range(args.benchmark_count):
start = int(round(time.time() * 1000))
output = compute()
end = int(round(time.time() * 1000))
if i != 0:
total_time = total_time + (end - start)
logger.info(f'\tailia processing time {end - start} ms')
logger.info(f'\taverage time {total_time / (args.benchmark_count-1)} ms')
else:
output = compute()
res_img = plot_results(detector, raw_img, COCO_CATEGORY)
detect_object = detector
# plot result
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
# write prediction
if args.write_prediction:
pred_file = '%s.txt' % savepath.rsplit('.', 1)[0]
write_predictions(pred_file, detect_object, raw_img, COCO_CATEGORY)
logger.info('Script finished successfully.')
def recognize_from_image():
# 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)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
# prepare input data
img = load_image(image_path)
logger.info(f'input image shape: {img.shape}')
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detector.compute(img, args.threshold, args.iou)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
detector.compute(img, args.threshold, args.iou)
# plot result
res_img = plot_results(detector, img, COCO_CATEGORY)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
logger.info('Script finished successfully.')
def recognize_from_video(video, detector):
capture = get_capture(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, seg_masks = detect_objects(x, detector)
res_img = plot_results(detect_object,
frame,
CATEGORY,
segm_masks=seg_masks)
cv2.imshow('frame', res_img)
capture.release()
cv2.destroyAllWindows()
def recognize_from_image():
# prepare input data
org_img = load_image(
args.input,
(IMAGE_HEIGHT, IMAGE_WIDTH),
normalize_type='None',
)
if org_img.shape[2] == 3:
org_img = cv2.cvtColor(org_img, cv2.COLOR_BGR2BGRA)
# net initialize
env_id = ailia.get_gpu_environment_id()
print(f'env_id: {env_id}')
categories = 80
threshold = 0.4
iou = 0.45
detector = ailia.Detector(MODEL_PATH,
WEIGHT_PATH,
categories,
format=ailia.NETWORK_IMAGE_FORMAT_RGB,
channel=ailia.NETWORK_IMAGE_CHANNEL_FIRST,
range=ailia.NETWORK_IMAGE_RANGE_U_FP32,
algorithm=ailia.DETECTOR_ALGORITHM_SSD,
env_id=env_id)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detector.compute(org_img, threshold, iou)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
detector.compute(org_img, threshold, iou)
# postprocessing
res_img = plot_results(detector, org_img, VOC_CATEGORY)
cv2.imwrite(args.savepath, res_img)
print('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))
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
img = letterbox_convert(frame, (IMAGE_HEIGHT, IMAGE_WIDTH))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
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 = post_processing(img, args.threshold, args.iou, output)
detect_object = reverse_letterbox(detect_object[0], frame,
(IMAGE_HEIGHT, IMAGE_WIDTH))
res_img = plot_results(detect_object, frame, COCO_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()
print('Script finished successfully.')
def recognize_from_image(image_path, net):
if args.profile:
net.set_profile_mode(True)
# prepare input data
img = load_image(image_path)
logger.debug(f'input image shape: {img.shape}')
img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
# inference
logger.info('Start inference...')
if args.benchmark:
if not args.profile:
net.set_profile_mode(True)
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
pred = predict(img, net)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
if not args.profile:
print(net.get_summary())
else:
pred = predict(img, net)
# plot result
detect_object = convert_to_ailia_detector_object(pred, img.shape[1],
img.shape[0])
img = plot_results(detect_object, img, obj_list)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, img)
if args.profile:
print(net.get_summary())
logger.info('Script finished successfully.')
def recognize_from_image():
# prepare input data
org_img = load_image(args.input)
print(f'input image shape: {org_img.shape}')
img = cv2.cvtColor(org_img, cv2.COLOR_BGRA2RGB)
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)
# net initialize
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)))
# inferece
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
output = detector.predict([img])
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
output = detector.predict([img])
detect_object = yolov4_utils.post_processing(img, THRESHOLD, IOU, output)
# plot result
res_img = plot_results(detect_object[0], org_img, COCO_CATEGORY)
# plot result
cv2.imwrite(args.savepath, res_img)
print('Script finished successfully.')
def recognize_from_image(filename, detector):
# prepare input data
img = load_image(filename)
print(f'input image shape: {img.shape}')
x = cv2.cvtColor(img, cv2.COLOR_BGRA2RGB)
# inferece
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detect_object = detect_objects(x, detector)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
detect_object = detect_objects(x, detector)
# plot result
res_img = plot_results(detect_object, img, category)
cv2.imwrite(args.savepath, res_img)
print('Script finished successfully.')
def recognize_from_image():
# prepare input data
img = load_image(args.input)
print(f'input image shape: {img.shape}')
# 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 int(args.detection_width) != 416:
detector.set_input_shape(
int(args.detection_width), int(args.detection_width)
)
# inference
print('Start inference...')
if args.benchmark:
print('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detector.compute(img, THRESHOLD, IOU)
end = int(round(time.time() * 1000))
print(f'\tailia processing time {end - start} ms')
else:
detector.compute(img, THRESHOLD, IOU)
# plot result
res_img = plot_results(detector, img, COCO_CATEGORY)
cv2.imwrite(args.savepath, res_img)
print('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()
print('Script finished successfully.')
def recognize_from_image():
env_id = args.env_id
net = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=env_id)
net.set_input_shape((1, 3, HEIGHT, WIDTH))
detector = NanoDetDetection(net,
input_shape=[HEIGHT, WIDTH],
reg_max=REG_MAX)
# input image loop
for image_path in args.input:
# prepare input data
logger.debug(f'input image: {image_path}')
raw_img = cv2.imread(image_path)
logger.debug(f'input image shape: {raw_img.shape}')
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
detect_object = detector.detect(raw_img)
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
else:
detect_object = detector.detect(raw_img)
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)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
logger.info('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
detector = None
detector = 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))
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 = letterbox_convert(frame, (IMAGE_HEIGHT, IMAGE_WIDTH))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
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 = yolov5_utils.post_processing(img, args.threshold,
args.iou, output)
detect_object = reverse_letterbox(detect_object[0], frame,
(IMAGE_HEIGHT, IMAGE_WIDTH))
res_img = plot_results(detect_object, frame, 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_image():
# net initialize
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=args.env_id)
if args.profile:
detector.set_profile_mode(True)
# input image loop
for image_path in args.input:
# prepare input data
logger.info(image_path)
# prepare input data
org_img = load_image(image_path)
org_img = cv2.cvtColor(org_img, cv2.COLOR_BGRA2BGR)
logger.info(f'input image shape: {org_img.shape}')
img = letterbox_convert(org_img, (IMAGE_HEIGHT, IMAGE_WIDTH))
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, [2, 0, 1])
img = img.astype(np.float32) / 255
img = np.expand_dims(img, 0)
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
total_time = 0
for i in range(args.benchmark_count):
start = int(round(time.time() * 1000))
output = detector.predict([img])
end = int(round(time.time() * 1000))
if i != 0:
total_time = total_time + (end - start)
logger.info(f'\tailia processing time {end - start} ms')
logger.info(
f'\taverage time {total_time / (args.benchmark_count-1)} ms')
else:
output = detector.predict([img])
detect_object = yolov5_utils.post_processing(img, args.threshold,
args.iou, output)
detect_object = reverse_letterbox(detect_object[0], org_img,
(IMAGE_HEIGHT, IMAGE_WIDTH))
# plot result
res_img = plot_results(detect_object, org_img, COCO_CATEGORY)
# plot result
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
# write prediction
if args.write_prediction:
pred_file = '%s.txt' % savepath.rsplit('.', 1)[0]
write_predictions(pred_file, detect_object, org_img, COCO_CATEGORY)
if args.profile:
print(detector.get_summary())
logger.info('Script finished successfully.')
def recognize_from_image():
# net initialize
if args.detector == True:
detector = ailia.Detector(
MODEL_PATH,
WEIGHT_PATH,
len(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=args.env_id,
)
detector.set_anchors(ANCHORS)
if args.profile:
detector.set_profile_mode(True)
else:
print("path", WEIGHT_PATH)
net = ailia.Net(None, WEIGHT_PATH)
# input image loop
for image_path in args.input:
# prepare input data logger.info(image_path)
img = load_image(image_path)
logger.debug(f'input image shape: {img.shape}')
# inference
logger.info('Start inference...')
if args.benchmark:
logger.info('BENCHMARK mode')
for i in range(5):
start = int(round(time.time() * 1000))
if args.detector:
detector.compute(img, THRESHOLD, IOU)
else:
pass
end = int(round(time.time() * 1000))
logger.info(f'\tailia processing time {end - start} ms')
# plot result
res_img = plot_results(detector, img, CATEGORY)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
if args.profile:
print(detector.get_summary())
else:
if args.detector:
detector.compute(img, THRESHOLD, IOU)
# plot result
res_img = plot_results(detector, img, CATEGORY)
savepath = get_savepath(args.savepath, image_path)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, res_img)
if args.profile:
print(detector.get_summary())
else:
savepath = get_savepath(args.savepath, image_path)
img_PIL = Image.open(image_path).convert('RGB')
input_data = cv2.imread(image_path)
input_data = cv2.resize(input_data, (416, 416)) / 255
input_data = input_data.transpose((2, 0, 1))
input_data = input_data[np.newaxis, :, :, :].astype(np.float32)
results = net.run([input_data])
results = torch.FloatTensor(results[0])
detect(img_PIL, results, savepath, video=False)
logger.info('Script finished successfully.')
def recognize_from_image(filename, detector):
if args.profile:
detector.set_profile_mode(True)
# load input image
img = load_image(filename)
img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
logger.info('Start inference...')
if args.benchmark:
for mode in range(2):
if mode == 0:
logger.info('BENCHMARK mode (without post process)')
else:
logger.info('BENCHMARK mode (with post process)')
zeros = np.zeros((1, 3, 512, 512))
total_time = 0
for i in range(args.benchmark_count):
start = int(round(time.time() * 1000))
if mode == 0:
detector.predict(zeros)
else:
boxes, scores, cls_inds = detect_objects(img, detector)
end = int(round(time.time() * 1000))
if i != 0:
total_time = total_time + (end - start)
logger.info(f'\tailia processing time {end - start} ms')
logger.info(
f'\taverage time {total_time / (args.benchmark_count-1)} ms')
else:
boxes, scores, cls_inds = detect_objects(img, detector)
try:
logger.info('\n'.join([
'pos:{}, ids:{}, score:{:.3f}'.format(
'(%.1f,%.1f,%.1f,%.1f)' % (box[0], box[1], box[2], box[3]),
COCO_CATEGORY[int(obj_cls)], score)
for box, obj_cls, score in zip(boxes, cls_inds, scores)
]))
except:
# FIXME: do not use base 'except'
pass
Detection = namedtuple('Detection',
['category', 'prob', 'x', 'y', 'w', 'h'])
ary = []
h, w = (img.shape[0], img.shape[1])
for i, box in enumerate(boxes):
d = Detection(int(cls_inds[i]), scores[i], box[0] / w, box[1] / h,
(box[2] - box[0]) / w, (box[3] - box[1]) / h)
ary.append(d)
im2show = plot_results(ary, img, COCO_CATEGORY)
savepath = get_savepath(args.savepath, filename)
logger.info(f'saved at : {savepath}')
cv2.imwrite(savepath, im2show)
# write prediction
if args.write_prediction:
pred_file = '%s.txt' % savepath.rsplit('.', 1)[0]
write_predictions(pred_file, ary, img, category=COCO_CATEGORY)
if args.profile:
print(detector.get_summary())
logger.info('Script finished successfully.')
def recognize_from_video():
# net initialize
env_id = args.env_id
detector = ailia.Net(MODEL_PATH, WEIGHT_PATH, env_id=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 = f_h, f_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
raw_img = frame
img = cv2.resize(raw_img, dsize=(1280, 896))
img = np.transpose(img, (2, 0, 1))
img = np.expand_dims(img, 0)
img = img / 255.0
pred = detector.predict(img)
pred = non_max_suppression_numpy(pred, THRESHOLD, IOU)
for i, det in enumerate(pred):
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
raw_img.shape).round()
img_size_h, img_size_w = raw_img.shape[:2]
output = []
# Write results
for *xyxy, conf, cls in det:
xyxy = [int(v) for v in xyxy]
x1, y1, x2, y2 = xyxy
r = ailia.DetectorObject(
category=int(cls),
prob=conf,
x=x1 / img_size_w,
y=y1 / img_size_h,
w=(x2 - x1) / img_size_w,
h=(y2 - y1) / img_size_h,
)
output.append(r)
detect_object = reverse_letterbox(output, 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)
capture.release()
cv2.destroyAllWindows()
if writer is not None:
writer.release()
logger.info('Script finished successfully.')