def do_predict_pb(sess, input_tensor, output_tensors, input_file, output_file, drawcontour=True): print('input fn: ', input_file) img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image_pb(sess, input_tensor, output_tensors, img) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) if drawcontour==True: if results: binary = results[0].mask*255 # dilate = cv2.dilate(binary, np.ones((7,7), np.uint8)) # erode = cv2.erode(dilate, np.ones((9,9), np.uint8)) # edge = binary - erode # # idx_r, idx_c = np.where(edge==255) # # idx1 = np.stack((idx_r, idx_c), axis=1) # idx1 = np.where(edge==255) # edge3d = np.zeros((edge.shape[0], edge.shape[1], 3)) # edge3d[idx1] = 255 # viz = np.concatenate((img, final, edge3d), axis=1) binary = np.repeat(binary[:, :, np.newaxis], 3, axis=-1) viz = np.concatenate((img, final, binary), axis=1) else: viz = img else: viz = final cv2.imwrite(output_file, viz) logger.info("Inference output for {} written to output.png".format(output_file))
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) # tpviz.interactive_imshow(viz) cv2.imwrite(os.path.basename(input_file), viz)
def viz_detection(args, fname, bb_list): input_file = os.path.join(args.anno_dir, '..', 'frames', os.path.basename(fname).split('.')[0] + '.jpg') img = cv2.imread(input_file, cv2.IMREAD_COLOR) final = draw_final_outputs(img, bb_list, tags_on=False, bb_list_input=True) viz = np.concatenate((img, final), axis=1) cv2.imwrite(os.path.basename(input_file), viz)
def visualize(model, model_path, nr_visualize=100, output_dir='output'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor( PredictConfig(model=model, session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/probs'.format( 'fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_probs', 'final_boxes', 'final_probs', 'final_labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img = dp[0] if cfg.MODE_MASK: gt_boxes, gt_labels, gt_masks = dp[-3:] else: gt_boxes, gt_labels = dp[-2:] rpn_boxes, rpn_scores, all_probs, \ final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) results = [ DetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) print(len(results)) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info("Inference output written to output.png") tpviz.interactive_imshow(viz)
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) # tpviz.interactive_imshow(viz) cv2.imwrite('../drive/train_log/predicted_image.jpg', viz) cv2.destroyAllWindows()
def visualize(model_path, nr_visualize=50, output_dir='output'): df = get_train_dataflow_coco() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_rpn_proposals/boxes', 'generate_rpn_proposals/probs', 'fastrcnn_all_probs', 'final_boxes', 'final_probs', 'final_labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img, _, _, gt_boxes, gt_labels = dp rpn_boxes, rpn_scores, all_probs, \ final_boxes, final_probs, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) if config.USE_SECOND_HEAD: results = [ SecondDetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] else: results = [ DetectionResult(*args) for args in zip(final_boxes, final_probs, final_labels, [None] * len(final_labels)) ] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def eval_on_dataflow(df, detect_func, tqdm_bar=None): """ Args: df: a DataFlow which produces (image, image_id) detect_func: a callable, takes [image] and returns [DetectionResult] tqdm_bar: a tqdm object to be shared among multiple evaluation instances. If None, will create a new one. Return: list of dict, to be dumped to COCO json format """ csv_path = os.path.join(config.BASEDIR, 'train_ship_segmentations_v2.csv') seg_df = pd.read_csv(csv_path, engine="python") seg_df = seg_df.dropna(axis=0) seg_df = seg_df.set_index('ImageId') df.reset_state() all_results = [] # tqdm is not quite thread-safe: https://github.com/tqdm/tqdm/issues/323 with ExitStack() as stack: if tqdm_bar is None: tqdm_bar = stack.enter_context( tqdm.tqdm(total=df.size(), **get_tqdm_kwargs())) score = 0.0 all_score = [] count = 0.0 eval_names = [] eval_imgs = [] all_det = [] all_im = [] for img, img_id in df.get_data(): results = detect_func(img) #mask_whole = detect_func(img) #all_det.append(mask_whole) all_im.append(img) eval_names.append(img_id) final = draw_final_outputs(img, results) cv2.imwrite('./eval_out_bb/{}'.format(img_id), final) mask_instances = [r.mask for r in results] score_instances = [r.score for r in results] masks = clean_overlap_instance(mask_instances, score_instances, img_id) if len(masks) == 0: print("no mask!!", img_id) v = 0 else: v = local_eval(masks, img_id, seg_df) #pred, imgId score += v all_score.append(v) count += 1 tqdm_bar.update(1) for k in np.array(all_score).argsort()[:20]: print(all_score[k], eval_names[k]) # cv2.imwrite("./eval_out/{}".format(eval_names[k]), all_im[k]) # cv2.imwrite("./eval_out/{}_mask.jpg".format(eval_names[k].split(".")[0]), all_det[k]*255) print("Local Eval: ", score / count) return all_results, score / count
def do_predict(pred_func, input_file, output_path=None): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) out_filename = input_file.split("/")[-1] output_path = out_path + out_filename cv2.imwrite(output_path, viz) logger.info("Inference output for {} written to output.png".format(input_file))
def predict_many(pred_func, input_files): if not os.path.exists('output'): os.mkdir('output') for idx, input_file in enumerate(input_files): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs(img, results) plt.imshow(final) plt.savefig(os.path.join('output', str(idx) + '.png'))
def do_predict(predictor, input_file): img = cv2.imread(os.path.join('test_images', input_file), cv2.IMREAD_COLOR) results = predict_image(img, predictor) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) #concatenate hata dena opp = cv2.imwrite(os.path.join('test_inferences', input_file.split('.')[0]+".png"), viz) if opp: logger.info("Inference output for {} Successful".format(input_file))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info( "Inference output for {} written to output.png".format(input_file))
def visualize(model, model_path, nr_visualize=100, output_dir='output'): """ Visualize some intermediate results (proposals, raw predictions) inside the pipeline. """ df = get_train_dataflow() # we don't visualize mask stuff df.reset_state() pred = OfflinePredictor(PredictConfig( model=model, session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_{}_proposals/boxes'.format('fpn' if cfg.MODE_FPN else 'rpn'), 'generate_{}_proposals/scores'.format('fpn' if cfg.MODE_FPN else 'rpn'), 'fastrcnn_all_scores', 'output/boxes', 'output/scores', 'output/labels', ])) if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df), nr_visualize): img = dp[0] if cfg.MODE_MASK: gt_boxes, gt_labels, gt_masks = dp[-3:] else: gt_boxes, gt_labels = dp[-2:] rpn_boxes, rpn_scores, all_scores, \ final_boxes, final_scores, final_labels = pred(img, gt_boxes, gt_labels) # draw groundtruth boxes gt_viz = draw_annotation(img, gt_boxes, gt_labels) # draw best proposals for each groundtruth, to show recall proposal_viz, good_proposals_ind = draw_proposal_recall(img, rpn_boxes, rpn_scores, gt_boxes) # draw the scores for the above proposals score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_scores[good_proposals_ind]) results = [DetectionResult(*args) for args in zip(final_boxes, final_scores, final_labels, [None] * len(final_labels))] final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches([ gt_viz, proposal_viz, score_viz, final_viz], 2, 2) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def predict_one_image(input_file, pred_func): print('Predicting '+input_file) path = '/home/bonniehu/projects/def-jjclark/bonniehu/FasterRCNN/pred_out/' img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) trimap_path = 'trimap/' trimaps = trimap_outputs(img, results, trimap_path, input_file.split('/')[-1][:-4]) final = draw_final_outputs(img, results) #viz = np.concatenate((img, final), axis=1) #not support in ubuntu #tpviz.interactive_imshow(viz) misc.imsave(path+input_file.split('/')[-1][:-4]+'_mask.png', final)
def _predict_with_gt(pred_func, input_file, ground_truths, output_dir=None, font_rs=10, thickness_rs=10): img = cv2.imread(input_file, cv2.IMREAD_COLOR) # resized_img, orig_shape, scale = run_resize_image(img) # TODO: predict_image already contains resize results = predict_image(img, pred_func) results = list(filter(lambda x: x.score > 0.7, results)) font_scale = np.sqrt(min(img.shape[:2])) / font_rs thickness = thickness_rs print('font_scale:', font_scale) img = cv2.imread(input_file, cv2.IMREAD_COLOR) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results, font_scale=font_scale, thickness=thickness) else: final = draw_final_outputs(img, results, font_scale=font_scale, thickness=thickness) img = cv2.imread(input_file, cv2.IMREAD_COLOR) image_with_gt = draw_final_outputs(img, ground_truths, font_scale=font_scale, thickness=thickness) viz = np.concatenate((image_with_gt, final), axis=1) out_path = os.path.join(output_dir, re.sub('/', '-', input_file) + '.out.png') cv2.imwrite(out_path, viz) logger.info("Inference output for {} written to\n {}".format( input_file, out_path))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) # add green rectangle arround original picture that with failure height, width, channels = img.shape cv2.rectangle(img, (0, 0), (width, height), color=(100, 220, 80), thickness=5) viz = np.concatenate((img, final), axis=1) cv2.imwrite(result_folder_path+"/0.png", viz) logger.info("Inference output written to 0.png")
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) t = time.time() results = detect_one_image(img, pred_func) t_final = time.time() - t height, width, channels = img.shape print("Time: ", t_final, " for ", height * width / 1e6, " Mpixels , i.e. Width=", width, " Height=", height, " Channels=", channels) print("Throughput: ", height * width / 1e6 / t_final, " Mpixels/Sec") final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def classifier_eval_output(df, pred_func, tqdm_bar=None): """ Args: df: a DataFlow which produces (image, image_id) detect_func: a callable, takes [image] and returns [DetectionResult] tqdm_bar: a tqdm object to be shared among multiple evaluation instances. If None, will create a new one. Returns: list of dict, to be dumped to COCO json format """ df.reset_state() all_results = [] jsonable = False # tqdm is not quite thread-safe: https://github.com/tqdm/tqdm/issues/323 with ExitStack() as stack: if tqdm_bar is None: tqdm_bar = stack.enter_context( tqdm.tqdm(total=df.size(), **get_tqdm_kwargs())) for fname, img, orig_shape in df.get_data(): bbs, probs = pred_func(img, orig_shape) if VIZ: input_file = os.path.join( '/media/yingges/TOSHIBA EXT/datasets/re-ID/PRW-v16.04.20/frames', os.path.basename(fname).split('.')[0] + '.jpg') img = cv2.imread(input_file, cv2.IMREAD_COLOR) final = draw_final_outputs(img, bbs, tags_on=False, bb_list_input=True) viz = np.concatenate((img, final), axis=1) cv2.imwrite(os.path.basename(input_file), viz) result_list = [] result_list.append(fname) bb_list = [] prob_list = [] for bb, prob in zip(bbs, probs): bb_list.append(list(map(lambda x: round(float(x), 2), bb))) prob_list.append(list(map(lambda x: round(float(x), 4), prob))) result_list.append(bb_list) result_list.append(prob_list) if not jsonable: jsonable = jsonable_test(result_list) all_results.append(result_list) tqdm_bar.update(1) return all_results
def predict(model_path, input_file): pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image'], output_names=[ 'fastrcnn_fg_probs', 'fastrcnn_fg_boxes', ])) img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) # get error from this img_name = ntpath.basename(input_file) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) if not os.path.exists(result_folder): os.makedirs(result_folder) cv2.imwrite(result_folder + img_name, viz) logger.info("Inference output for {} written to {}".format( input_file, result_folder))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) start = time.time() results = predict_image(img, pred_func) end = time.time() print('cost time is :/s', end - start) #if cfg.MODE_MASK: # final = draw_final_outputs_blackwhite(img, results) #else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("{}.png".format(input_file[-15:-4]), viz) logger.info("Inference output for {} written to {}.png".format( input_file, input_file[-15:-4]))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) # while True: print('Starting predtiction') start_time = time.time() results = predict_image(img, pred_func) print(time.time() - start_time) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info( "Inference output for {} written to output.png".format(input_file))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) # start_time = time.time() results = predict_image(img, pred_func) # end_time = time.time() # print(f"--------- Inference time : {end_time - start_time}seconds -----------------") if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info( "Inference output for {} written to output.png".format(input_file)) tpviz.interactive_imshow(viz)
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) # get error from this img_name = ntpath.basename(input_file) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) save_path = "/home/jetson/Documents/result/" + model_num + "/" if not os.path.exists(save_path): os.makedirs(save_path) cv2.imwrite(save_path + img_name, viz) logger.info("Inference output for {} written to {}".format( input_file, save_path))
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) # add green rectangle arround original picture that with failure height, width, channels = img.shape cv2.rectangle(img, (0, 0), (width, height), color=(100, 220, 80), thickness=5) viz = np.concatenate((img, final), axis=1) cv2.imwrite( "/home/jetson/tensorpack/examples/FasterRCNN/static/images/output.png", viz) logger.info("Inference output written to output.png")
def do_predict(pred_func, input_file): ''' 输入input_file,读取与图片,然后调用pred_func,得到了box,score,lables, 结果输出到output.jpg,并交互显示 boxes,labels,scores :param pred_func: :param input_file: :return: ''' img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) cv2.imwrite("output.png", viz) logger.info("Inference output for {} written to output.png".format(input_file)) tpviz.interactive_imshow(viz)
def visualize(model_path, nr_visualize=50, output_dir='output'): pred = OfflinePredictor( PredictConfig(model=Model(), session_init=get_model_loader(model_path), input_names=['image', 'gt_boxes', 'gt_labels'], output_names=[ 'generate_rpn_proposals/boxes', 'generate_rpn_proposals/probs', 'fastrcnn_all_probs', 'fastrcnn_fg_probs', 'fastrcnn_fg_boxes', ])) df = get_train_dataflow() df.reset_state() if os.path.isdir(output_dir): shutil.rmtree(output_dir) utils.fs.mkdir_p(output_dir) with tqdm.tqdm(total=nr_visualize) as pbar: for idx, dp in itertools.islice(enumerate(df.get_data()), nr_visualize): img, _, _, gt_boxes, gt_labels = dp rpn_boxes, rpn_scores, all_probs, fg_probs, fg_boxes = pred( img, gt_boxes, gt_labels) gt_viz = draw_annotation(img, gt_boxes, gt_labels) proposal_viz, good_proposals_ind = draw_proposal_recall( img, rpn_boxes, rpn_scores, gt_boxes) score_viz = draw_predictions(img, rpn_boxes[good_proposals_ind], all_probs[good_proposals_ind]) fg_boxes = clip_boxes(fg_boxes, img.shape[:2]) fg_viz = draw_predictions(img, fg_boxes, fg_probs) results = nms_fastrcnn_results(fg_boxes, fg_probs) final_viz = draw_final_outputs(img, results) viz = tpviz.stack_patches( [gt_viz, proposal_viz, score_viz, fg_viz, final_viz], 2, 3) if os.environ.get('DISPLAY', None): tpviz.interactive_imshow(viz) cv2.imwrite("{}/{:03d}.png".format(output_dir, idx), viz) pbar.update()
def predict(pred_func, input_file): image_paths = [] if os.path.isdir(input_file): for inp_file in os.listdir(input_file): image_paths += [input_file + inp_file] for image_path in image_paths: (path1,file1)=os.path.split(image_path) (filename1, filename2) = os.path.splitext(file1) objectfile = open('results/%s.txt' % filename1,'w') img = cv2.imread(image_path, cv2.IMREAD_COLOR) start=time.time() results = detect_one_image(img, pred_func) end=time.time() print(end-start) final = draw_final_outputs(img, results,objectfile) #viz = np.concatenate((img, final), axis=1) viz=final cv2.imwrite('outimages/%s.png'%filename1,viz)
def do_predict(pred_func, input_file): img = imread(input_file) if (len(img.shape) == 2): img = np.expand_dims(img, axis=2) img = np.repeat(img, 3, axis=2) img = scipy.misc.imresize(img, (800, 800)) results = predict_image(img, pred_func) print(len(results)) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) #for result in results: #if(result.class_id != 3): #print(result) imsave('./output2/outputimg.tif', final) logger.info( "Inference output for {} written to outputimg.tif".format(input_file)) return results
def do_predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = predict_image(img, pred_func) if cfg.MODE_MASK: final = draw_final_outputs_blackwhite(img, results) else: final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) '''fxl # modify file name cv2.imwrite("output.png", viz) logger.info("Inference output for {} written to output.png".format(input_file)) ''' base_name = os.path.basename(input_file) img_name = os.path.splitext(base_name)[0] result_file = "/content/drive/My Drive/Colab/tp/myoutput/predict_output/" + img_name + ".png" cv2.imwrite(result_file, viz) print(img_number, end='') print("." + "Inference for {} written to {}".format(base_name, result_file))
def predict(pred_func, input_file): img = cv2.imread(input_file, cv2.IMREAD_COLOR) results = detect_one_image(img, pred_func) final = draw_final_outputs(img, results) viz = np.concatenate((img, final), axis=1) tpviz.interactive_imshow(viz)