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.')