def track(opt): logger.setLevel(logging.INFO) result_root = opt.output_root if opt.output_root!='' else '.' mkdir_if_missing(result_root) cfg_dict = parse_model_cfg(opt.cfg) opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])] # run tracking timer = Timer() accs = [] n_frame = 0 logger.info('start tracking...') dataloader = datasets.LoadImages(opt.input_images, opt.img_size) result_filename = os.path.join(result_root, 'results.txt') frame_dir = None if opt.output_format=='text' else osp.join(result_root, 'frame') try: eval_seq(opt, dataloader, 'mot', result_filename, save_dir=frame_dir, show_image=False) except Exception as e: logger.info(e) if opt.output_format == 'video': output_video_path = osp.join(result_root, 'result.mp4') cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(osp.join(result_root, 'frame'), output_video_path) os.system(cmd_str)
def main(opt, data_root='/data/MOT16/train', det_root=None, seqs=('MOT16-05',), exp_name='demo', save_images=False, save_videos=False, show_image=True): logger.setLevel(logging.INFO) result_root = os.path.join(data_root, '..', 'results', exp_name) mkdir_if_missing(result_root) data_type = 'mot' # Read config cfg_dict = parse_model_cfg(opt.cfg) opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])] # run tracking accs = [] n_frame = 0 timer_avgs, timer_calls = [], [] for seq in seqs: output_dir = os.path.join(data_root, '..','outputs', exp_name, seq) if save_images or save_videos else None logger.info('start seq: {}'.format(seq)) dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size) result_filename = os.path.join(result_root, '{}.txt'.format(seq)) meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read() frame_rate = int(meta_info[meta_info.find('frameRate')+10:meta_info.find('\nseqLength')]) nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename, save_dir=output_dir, show_image=show_image, frame_rate=frame_rate) n_frame += nf timer_avgs.append(ta) timer_calls.append(tc) # eval logger.info('Evaluate seq: {}'.format(seq)) evaluator = Evaluator(data_root, seq, data_type) accs.append(evaluator.eval_file(result_filename)) if save_videos: output_video_path = osp.join(output_dir, '{}.mp4'.format(seq)) cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format(output_dir, output_video_path) os.system(cmd_str) timer_avgs = np.asarray(timer_avgs) timer_calls = np.asarray(timer_calls) all_time = np.dot(timer_avgs, timer_calls) avg_time = all_time / np.sum(timer_calls) logger.info('Time elapsed: {:.2f} seconds, FPS: {:.2f}'.format(all_time, 1.0 / avg_time)) # get summary metrics = mm.metrics.motchallenge_metrics mh = mm.metrics.create() summary = Evaluator.get_summary(accs, seqs, metrics) strsummary = mm.io.render_summary( summary, formatters=mh.formatters, namemap=mm.io.motchallenge_metric_names ) print(strsummary) sys.stdout.flush() Evaluator.save_summary(summary, os.path.join(result_root, 'summary_{}.xlsx'.format(exp_name)))
def track(opt): result_root = opt.output_root if opt.output_root != '' else '.' mkdir_if_missing(result_root) cfg_dict = parse_model_cfg(opt.cfg) opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])] # run tracking timer = Timer() accs = [] n_frame = 0 logger.info('Starting tracking...') print(opt.input_video_images) print(os.path.isdir(opt.input_video_images)) if os.path.isdir(opt.input_video_images): dataloader = datasets.LoadImages(opt.input_video_images, opt.img_size) else: dataloader = datasets.LoadVideo(opt.input_video, opt.img_size) #dataloader = datasets.LoadVideo(opt.input_video, opt.img_size) result_filename = os.path.join(result_root, 'results.txt') frame_rate = dataloader.frame_rate # print(111) frame_dir = None if opt.output_format == 'text' else osp.join( result_root, 'frame') try: eval_seq(opt, dataloader, 'mot', result_filename, save_dir=frame_dir, show_image=False, frame_rate=frame_rate) except Exception as e: logger.info(e)
def main(opt, data_root='/data/MOT16/train', det_root=None, seqs=('MOT16-05', ), exp_name='demo', save_images=False, save_videos=False, show_image=True): logger.setLevel(logging.INFO) result_root = os.path.join(data_root, '..', 'results', exp_name) mkdir_if_missing(result_root) data_type = 'mot' # run tracking timer = Timer() accs = [] n_frame = 0 timer.tic() for seq in seqs: output_dir = os.path.join(data_root, '..', 'outputs', exp_name, seq) if save_images or save_videos else None logger.info('start seq: {}'.format(seq)) dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size) result_filename = os.path.join(result_root, '{}.txt'.format(seq)) meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read() frame_rate = int(meta_info[meta_info.find('frameRate') + 10:meta_info.find('\nseqLength')]) n_frame += eval_seq(opt, dataloader, data_type, result_filename, save_dir=output_dir, show_image=show_image, frame_rate=frame_rate) # eval logger.info('Evaluate seq: {}'.format(seq)) evaluator = Evaluator(data_root, seq, data_type) accs.append(evaluator.eval_file(result_filename)) if save_videos: output_video_path = osp.join(output_dir, '{}.mp4'.format(seq)) cmd_str = 'ffmpeg -f image2 -i {}/%05d.jpg -c:v copy {}'.format( output_dir, output_video_path) os.system(cmd_str) timer.toc() logger.info('Time elapsed: {}, FPS {}'.format(timer.average_time, n_frame / timer.average_time)) # get summary # metrics = ['mota', 'num_switches', 'idp', 'idr', 'idf1', 'precision', 'recall'] metrics = mm.metrics.motchallenge_metrics mh = mm.metrics.create() summary = Evaluator.get_summary(accs, seqs, metrics) strsummary = mm.io.render_summary(summary, formatters=mh.formatters, namemap=mm.io.motchallenge_metric_names) print(strsummary) Evaluator.save_summary( summary, os.path.join(result_root, 'summary_{}.xlsx'.format(exp_name)))
mkdir_if_missing(result_root) data_type = 'mot' # Read config cfg_dict = parse_model_cfg(opt.cfg) opt.img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])] # run tracking accs = [] n_frame = 0 timer_avgs, timer_calls = [], [] for seq in seqs: output_dir = os.path.join(data_root, '..','outputs', exp_name, seq) if save_images or save_videos else None logger.info('start seq: {}'.format(seq)) dataloader = datasets.LoadImages(osp.join(data_root, seq, 'img1'), opt.img_size) result_filename = os.path.join(result_root, '{}.txt'.format(seq)) meta_info = open(os.path.join(data_root, seq, 'seqinfo.ini')).read() frame_rate = int(meta_info[meta_info.find('frameRate')+10:meta_info.find('\nseqLength')]) nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename, save_dir=output_dir, show_image=show_image, frame_rate=frame_rate) n_frame += nf timer_avgs.append(ta) timer_calls.append(tc) # eval logger.info('Evaluate seq: {}'.format(seq)) evaluator = Evaluator(data_root, seq, data_type) accs.append(evaluator.eval_file(result_filename)) if save_videos: output_video_path = osp.join(output_dir, '{}.mp4'.format(seq))
def main(): args = parser.parse_args() config = get_config(args.config) # CUDA configuration cuda = config['cuda'] device_ids = config['gpu_ids'] if cuda: os.environ['CUDA_VISIBLE_DEVICES'] = ','.join(str(i) for i in device_ids) device_ids = list(range(len(device_ids))) config['gpu_ids'] = device_ids cudnn.benchmark = True # Set random seed if args.seed is None: args.seed = random.randint(1, 10000) # print("Random seed: {}".format(args.seed)) random.seed(args.seed) torch.manual_seed(args.seed) if cuda: torch.cuda.manual_seed_all(args.seed) t0 = time.time() dataset = datasets.LoadImages(args.image) chunker = ImageChunker(config['image_shape'][0], config['image_shape'][1], args.overlap) try: # for unexpected error logging with torch.no_grad(): # enter no grad context # Set checkpoint path if not args.checkpoint_path: checkpoint_path = os.path.join('checkpoints', config['dataset_name'], config['mask_type'] + '_' + config['expname']) else: checkpoint_path = args.checkpoint_path last_model_name = get_model_list(checkpoint_path, "gen", iteration=args.iter) prev_fname = '' vid_writer = None for fpath, img_ori, vid_cap in dataset : imgs, masks = [], [] if prev_fname == fpath : frame += 1 # increase frame number if still on the same file else : frame = 0 # start frame number _, img_h, img_w = img_ori.shape txtfile = pathlib.Path(fpath).with_suffix('.txt') # Load mask txt file txtfile = os.path.join(args.output, str(txtfile).split('/')[-1]) if os.path.exists(txtfile) : bboxes, bframes = load_bbox_txt(txtfile, img_w, img_h) assert len(bboxes) == len(bframes) idx = [ii for ii, val in enumerate(bframes) if val==frame] bndbxs = [bboxes[ii] for ii in idx] img_ori = np.moveaxis(img_ori, 0, -1) if len(bndbxs) > 0 : # if any logo detected mask_ori = create_mask(bndbxs, img_w, img_h) # fig, axes = plt.subplots(1,2); axes[0].imshow(img_ori[0]); axes[1].imshow(mask_ori); plt.show() chunked_images = chunker.dimension_preprocess(np.array(deepcopy(img_ori))) chunked_masks = chunker.dimension_preprocess(np.array(deepcopy(mask_ori))) for (x, msk) in zip(chunked_images, chunked_masks) : x = transforms.ToTensor()(x) mask = transforms.ToTensor()(msk)[0].unsqueeze(dim=0) # x = normalize(x) x = x * (1. - mask) x = x.unsqueeze(dim=0) mask = mask.unsqueeze(dim=0) imgs.append(x) masks.append(mask) # Define the trainer netG = Generator(config['netG'], cuda, device_ids) netG.load_state_dict(torch.load(last_model_name)) model_iteration = int(last_model_name[-11:-3]) # print("Resume from {} at iteration {}".format(checkpoint_path, model_iteration)) pred_imgs = [] for (x, mask) in zip(imgs, masks) : if torch.max(mask) == 1 : if cuda: netG = nn.parallel.DataParallel(netG, device_ids=device_ids) x = x.cuda() mask = mask.cuda() # Inference x1, x2, offset_flow = netG(x, mask) inpainted_result = x2 * mask + x * (1. - mask) inpainted_result = inpainted_result.squeeze(dim=0).permute(1,2,0).cpu() pred_imgs.append(inpainted_result.numpy()) else : pred_imgs.append(x.squeeze(dim=0).permute(1,2,0).numpy()) pred_imgs = np.asarray(pred_imgs, dtype=np.float32) reconstructed_image = chunker.dimension_postprocess(pred_imgs, np.array(img_ori)) reconstructed_image = np.uint8(reconstructed_image[:, :, ::-1]*255) # BGR to RGB, and rescaling else : # no logo detected reconstructed_image = img_ori[:, :, ::-1] # Save results (image with detections) outname = fpath.split('/')[-1] outname = outname.split('.')[0] + '-inp.' + outname.split('.')[-1] outpath = os.path.join(args.output, outname) if dataset.mode == 'images': cv2.imwrite(outpath, reconstructed_image) print("Saved the inpainted image to {}".format(outpath)) else : if fpath != prev_fname: # new video if isinstance(vid_writer, cv2.VideoWriter): vid_writer.release() # release previous video writer print("Saved the inpainted video to {}".format(outpath)) fps = vid_cap.get(cv2.CAP_PROP_FPS) w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH)) h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) vid_writer = cv2.VideoWriter(outpath, cv2.VideoWriter_fourcc(*args.fourcc), fps, (w, h)) vid_writer.write(reconstructed_image) prev_fname = fpath # exit no grad context except Exception as err: # for unexpected error logging print("Error: {}".format(err)) pass print('Inpainting: (%.3fs)' % (time.time() - t0))