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