def test_frames2video(self):
v = mmcv.VideoReader(self.video_path)
frame_dir = tempfile.mkdtemp()
v.cvt2frames(frame_dir)
assert osp.isdir(frame_dir)
for i in range(self.num_frames):
filename = '{}/{:06d}.jpg'.format(frame_dir, i)
assert osp.isfile(filename)
out_filename = osp.join(tempfile.gettempdir(), 'mmcv_test.avi')
mmcv.frames2video(frame_dir, out_filename)
v = mmcv.VideoReader(out_filename)
assert v.fps == 30
assert len(v) == self.num_frames
mmcv.frames2video(
frame_dir,
out_filename,
fps=25,
start=10,
end=50,
show_progress=False)
v = mmcv.VideoReader(out_filename)
assert v.fps == 25
assert len(v) == 40
for i in range(self.num_frames):
filename = '{}/{:06d}.jpg'.format(frame_dir, i)
os.remove(filename)
os.removedirs(frame_dir)
os.remove(out_filename)
def inference(
detection_cfg,
skeleton_cfg,
dataset_cfg,
gpus=1,
worker_per_gpu=1,
):
# get frame num
video_file = dataset_cfg.video_file
video_name = video_file.strip('/n').split('/')[-1]
video_frames = mmcv.VideoReader(video_file)
num_frames = len(video_frames)
del video_frames
data_cfg = skeleton_cfg.data_cfg
if data_cfg.save_video:
data_cfg.img_dir = os.path.join(data_cfg.save_dir,
'{}.img'.format(video_name))
if os.path.exists(data_cfg.img_dir):
import shutil
shutil.rmtree(data_cfg.img_dir)
os.makedirs(data_cfg.img_dir)
# cache model checkpoints
cache_checkpoint(detection_cfg.checkpoint_file)
cache_checkpoint(skeleton_cfg.checkpoint_file)
# multiprocess settings
context = mp.get_context('spawn')
result_queue = context.Queue(num_frames)
procs = []
for w in range(gpus * worker_per_gpu):
shred_list = list(range(w, num_frames, gpus * worker_per_gpu))
p = context.Process(target=worker,
args=(video_file, shred_list, detection_cfg,
skeleton_cfg, data_cfg, w % gpus,
result_queue))
p.start()
procs.append(p)
all_result = []
print('\nPose estimation start:')
prog_bar = ProgressBar(num_frames)
for i in range(num_frames):
t = result_queue.get()
all_result.append(t)
prog_bar.update()
for p in procs:
p.join()
if len(all_result) == num_frames and data_cfg.save_video:
print('\n\nGenerate video:')
video_path = os.path.join(data_cfg.save_dir, video_name)
mmcv.frames2video(data_cfg.img_dir,
video_path,
filename_tmpl='{:01d}.png')
print('Video was saved to {}'.format(video_path))
import IPython
IPython.embed()
def main():
parser = ArgumentParser()
parser.add_argument('--video', help='video file')
parser.add_argument('--config', help='Config file')
parser.add_argument('--checkpoint', help='Checkpoint file')
parser.add_argument('--device',
default='cuda:0',
help='Device used for inference')
parser.add_argument('--score-thr',
type=float,
default=0.3,
help='bbox score threshold')
parser.add_argument('--theme',
type=str,
default='white',
help='themes to show detect results')
args = parser.parse_args()
# build the model from a config file and a checkpoint file
model = init_detector(args.config, args.checkpoint, device=args.device)
# test a video and show the results
video = mmcv.VideoReader(args.video)
result_root = "./results"
check_path_exist(result_root)
frame_dir = osp.join(result_root, 'frame')
check_path_exist(frame_dir)
frame_id = 0
interal = len(video) // 13
key_frame_path = "./key_frame"
check_path_exist(key_frame_path)
key_frame_dir = osp.join(key_frame_path,
args.video.split('/')[-1].split('.')[0])
check_path_exist(key_frame_dir)
for frame in tqdm(video, ncols=64):
result = inference_detector(model, frame)
model.show_result(frame,
result,
score_thr=args.score_thr,
out_file=osp.join(frame_dir,
'{:06d}.jpg'.format(frame_id)))
if (frame_id + 1) % interal == 0:
shutil.copyfile(src=osp.join(frame_dir,
'{:06d}.jpg'.format(frame_id)),
dst=osp.join(key_frame_dir,
'{:06d}.jpg'.format(frame_id)))
frame_id += 1
output_video_path = osp.join(result_root, args.video.split('/')[-1])
mmcv.frames2video(frame_dir,
output_video_path,
fourcc='mp4v',
filename_tmpl='{:06d}.jpg')
shutil.rmtree(frame_dir)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--config', help='test config file path')
parser.add_argument('--checkpoint', help='checkpoint file')
parser.add_argument('--video_path', help='video_path')
parser.add_argument('--frame_path', help='frame_path')
parser.add_argument('--inference_path', help='inference image path')
parser.add_argument('--avi_path', help='avi path')
args = parser.parse_args()
config_file = args.config
checkpoint_file = args.checkpoint
video_path = os.path.abspath(
args.video_path
) # ex) video_path = ./data/CCTV-11_cctv11_0923_Daytime_CH01.avi
frame_path = os.path.abspath(
args.frame_path) # frame으로 바꾼 이미지들, inference를 시킬 이미지들.
inference_path = os.path.abspath(args.inference_path) # inference 시킨 이미지들
avi_path = os.path.abspath(args.avi_path) # avi로 바꾼 이미지들
######### 1. video2frames
video = mmcv.VideoReader(video_path)
##print(len(video)) # get the total frame number
# print(video.width, video.height, video.resolution, video.fps)
# ex) start = 150(기존 영상의 10초부터 시작), max_num = 785 -------------------> 기존 영상의 19초부터
video.cvt2frames(
frame_path, start=0, max_num=10
) # frame을 (H, W, C) = (960, 1280, 3)으로 만들게 됨, 0~600 frame이 40초 영상으로 변환됨
######### 2. implements inference
model = init_detector(config_file, checkpoint_file, device='cuda:0')
images = sorted(os.listdir(frame_path))
integer = 0
# images에 있는 image를 하나씩 뽑아가면서 inference 시켜야함
for imgs in images:
img_for_inference = frame_path + "/" + imgs
result = inference_detector(model, img_for_inference)
last_path = inference_path + "/{0:06d}".format(integer) + ".jpg"
save_result_pyplot(model, img_for_inference, result, last_path)
integer += 1
########## 3. frame2video
mmcv.frames2video(inference_path, avi_path, fps=15)
network = network.cuda()
network.styler = network.styler.cuda()
if args.parallel:
network = nn.DataParallel(network)
if not os.path.exists(args.save_dir):
os.mkdir(args.save_dir)
if not os.path.exists(args.log_dir):
os.mkdir(args.log_dir)
content_tf = train_transform()
style_tf = train_transform()
print('loading dataset done', flush=True)
for bank in range(10):
maxlen = 12
for i in range(1, maxlen):
print(i, bank, flush=True)
path = '%05d.jpg' % (i)
cimg = Image.open(
os.path.join(
'/data/gaowei/datasest/videvo/mini_train/Waterfall1/',
path)).convert('RGB')
cimg = content_tf(cimg).unsqueeze(0).cuda()
out = network.evaluate(cimg, bank)
save_image(out, 'output/%06d.jpg' % (i - 1 + bank * 11))
mmcv.frames2video('output', 'mst_cat_flow.avi', fps=6)
def single_gpu_test(model,
data_loader,
show=False,
out_dir=None,
fps=3,
show_score_thr=0.3):
"""Test model with single gpu.
Args:
model (nn.Module): Model to be tested.
data_loader (nn.Dataloader): Pytorch data loader.
show (bool, optional): If True, visualize the prediction results.
Defaults to False.
out_dir (str, optional): Path of directory to save the
visualization results. Defaults to None.
fps (int, optional): FPS of the output video.
Defaults to 3.
show_score_thr (float, optional): The score threshold of visualization
(Only used in VID for now). Defaults to 0.3.
Returns:
dict[str, list]: The prediction results.
"""
model.eval()
results = defaultdict(list)
dataset = data_loader.dataset
prev_img_meta = None
prog_bar = mmcv.ProgressBar(len(dataset))
for i, data in enumerate(data_loader):
with torch.no_grad():
result = model(return_loss=False, rescale=True, **data)
batch_size = data['img'][0].size(0)
if show or out_dir:
assert batch_size == 1, 'Only support batch_size=1 when testing.'
img_tensor = data['img'][0]
img_meta = data['img_metas'][0].data[0][0]
img = tensor2imgs(img_tensor, **img_meta['img_norm_cfg'])[0]
h, w, _ = img_meta['img_shape']
img_show = img[:h, :w, :]
ori_h, ori_w = img_meta['ori_shape'][:-1]
img_show = mmcv.imresize(img_show, (ori_w, ori_h))
if out_dir:
out_file = osp.join(out_dir, img_meta['ori_filename'])
else:
out_file = None
model.module.show_result(
img_show,
result,
show=show,
out_file=out_file,
score_thr=show_score_thr)
# Whether need to generate a video from images.
# The frame_id == 0 means the model starts processing
# a new video, therefore we can write the previous video.
# There are two corner cases.
# Case 1: prev_img_meta == None means there is no previous video.
# Case 2: i == len(dataset) means processing the last video
need_write_video = (
prev_img_meta is not None and img_meta['frame_id'] == 0
or i == len(dataset))
if out_dir and need_write_video:
prev_img_prefix, prev_img_name = prev_img_meta[
'ori_filename'].rsplit(os.sep, 1)
prev_img_idx, prev_img_type = prev_img_name.split('.')
prev_filename_tmpl = '{:0' + str(
len(prev_img_idx)) + 'd}.' + prev_img_type
prev_img_dirs = f'{out_dir}/{prev_img_prefix}'
prev_img_names = sorted(os.listdir(prev_img_dirs))
prev_start_frame_id = int(prev_img_names[0].split('.')[0])
prev_end_frame_id = int(prev_img_names[-1].split('.')[0])
mmcv.frames2video(
prev_img_dirs,
f'{prev_img_dirs}/out_video.mp4',
fps=fps,
fourcc='mp4v',
filename_tmpl=prev_filename_tmpl,
start=prev_start_frame_id,
end=prev_end_frame_id,
show_progress=False)
prev_img_meta = img_meta
for key in result:
if 'mask' in key:
result[key] = encode_mask_results(result[key])
for k, v in result.items():
results[k].append(v)
for _ in range(batch_size):
prog_bar.update()
return results
def main():
parser = ArgumentParser()
parser.add_argument('config', help='Config file')
parser.add_argument('--input', help='input video file')
parser.add_argument('--output', help='output video file (mp4 format)')
parser.add_argument('--checkpoint', help='Checkpoint file')
parser.add_argument('--device',
default='cuda:0',
help='Device used for inference')
parser.add_argument('--show',
action='store_true',
default=False,
help='whether to show visualizations.')
parser.add_argument('--color',
default=(0, 255, 0),
help='Color of tracked bbox lines.')
parser.add_argument('--thickness',
default=3,
type=int,
help='Thickness of bbox lines.')
parser.add_argument('--fps', help='FPS of the output video')
parser.add_argument('--gt_bbox_file', help='The path of gt_bbox file')
args = parser.parse_args()
# load images
if osp.isdir(args.input):
imgs = sorted(filter(lambda x: x.endswith(('.jpg', '.png', '.jpeg')),
os.listdir(args.input)),
key=lambda x: int(x.split('.')[0]))
IN_VIDEO = False
else:
imgs = mmcv.VideoReader(args.input)
IN_VIDEO = True
# define output
if args.output is not None:
if args.output.endswith('.mp4'):
OUT_VIDEO = True
out_dir = tempfile.TemporaryDirectory()
out_path = out_dir.name
_out = args.output.rsplit(os.sep, 1)
if len(_out) > 1:
os.makedirs(_out[0], exist_ok=True)
else:
OUT_VIDEO = False
out_path = args.output
os.makedirs(out_path, exist_ok=True)
fps = args.fps
if args.show or OUT_VIDEO:
if fps is None and IN_VIDEO:
fps = imgs.fps
if not fps:
raise ValueError('Please set the FPS for the output video.')
fps = int(fps)
# build the model from a config file and a checkpoint file
model = init_model(args.config, args.checkpoint, device=args.device)
prog_bar = mmcv.ProgressBar(len(imgs))
# test and show/save the images
for i, img in enumerate(imgs):
if isinstance(img, str):
img = osp.join(args.input, img)
img = mmcv.imread(img)
if i == 0:
if args.gt_bbox_file is not None:
bboxes = mmcv.list_from_file(args.gt_bbox_file)
init_bbox = list(map(float, bboxes[0].split(',')))
else:
init_bbox = list(cv2.selectROI(args.input, img, False, False))
# convert (x1, y1, w, h) to (x1, y1, x2, y2)
init_bbox[2] += init_bbox[0]
init_bbox[3] += init_bbox[1]
result = inference_sot(model, img, init_bbox, frame_id=i)
if args.output is not None:
if IN_VIDEO or OUT_VIDEO:
out_file = osp.join(out_path, f'{i:06d}.jpg')
else:
out_file = osp.join(out_path, img.rsplit('os.sep', 1)[-1])
else:
out_file = None
model.show_result(img,
result,
show=args.show,
wait_time=int(1000. / fps) if fps else 0,
out_file=out_file,
thickness=args.thickness)
prog_bar.update()
if args.output and OUT_VIDEO:
print(
f'\nmaking the output video at {args.output} with a FPS of {fps}')
mmcv.frames2video(out_path, args.output, fps=fps, fourcc='mp4v')
out_dir.cleanup()
def main():
args = parse_args()
assert args.out or args.eval or args.format_only or args.show \
or args.show_dir, \
('Please specify at least one operation (save/eval/format/show the '
'results / save the results) with the argument "--out", "--eval"'
', "--format-only", "--show" or "--show-dir"')
if args.eval and args.format_only:
raise ValueError('--eval and --format_only cannot be both specified')
if args.out is not None and not args.out.endswith(('.pkl', '.pickle')):
raise ValueError('The output file must be a pkl file.')
# config 파일 읽기
cfg = Config.fromfile(args.config)
# 코드 돌릴 때 --cfg-options 설정하면 기존 config 파일에 내용 합치는 코드
if args.cfg_options is not None:
cfg.merge_from_dict(args.cfg_options)
# import modules from string list.
if cfg.get('custom_imports', None):
from mmcv.utils import import_modules_from_strings
import_modules_from_strings(**cfg['custom_imports'])
# set cudnn_benchmark
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
if cfg.model.get('neck'):
if isinstance(cfg.model.neck, list):
for neck_cfg in cfg.model.neck:
if neck_cfg.get('rfp_backbone'):
if neck_cfg.rfp_backbone.get('pretrained'):
neck_cfg.rfp_backbone.pretrained = None
elif cfg.model.neck.get('rfp_backbone'):
if cfg.model.neck.rfp_backbone.get('pretrained'):
cfg.model.neck.rfp_backbone.pretrained = None
# in case the test dataset is concatenated
if isinstance(cfg.data.test, dict): # cfg.data.test가 dict 타입이면 실행
cfg.data.test.test_mode = True # coco_detection.py 랑 비슷한 form에 test_mode를 설정해줄 수 있나봄
elif isinstance(cfg.data.test, list): # cfg.data.test가 list 타입이면 실행
for ds_cfg in cfg.data.test:
ds_cfg.test_mode = True
# init distributed env first, since logger depends on the dist info.
if args.launcher == 'none':
distributed = False
else:
distributed = True
init_dist(args.launcher, **cfg.dist_params)
# build the dataloader
samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
if samples_per_gpu > 1:
# Replace 'ImageToTensor' to 'DefaultFormatBundle'
cfg.data.test.pipeline = replace_ImageToTensor(cfg.data.test.pipeline)
########################################################################################
""" 여기에서 cctv 영상을 이미지로 변환해서 폴더에 넣고 cfg.data.test 부분에 폴더 경로를 추가"""
video = mmcv.VideoReader("/home/minjae/mjseong/mmdetection/data/test.avi")
print(len(video)) # get the total frame number
print(video.width, video.height, video.resolution, video.fps)
video.cvt2frames(
"/home/minjae/mjseong/mmdetection/data/KRRI_Video_cvt2frames",
start=0,
max_num=10000)
cfg.data.test.img_prefix = "data_root" + "/home/minjae/mjseong/mmdetection/data/KRRI_Video_cvt2frames/"
# cfg.data.test.ann_file =
########################################################################################
dataset = build_dataset(cfg.data.test)
data_loader = build_dataloader(dataset,
samples_per_gpu=samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
# build the model and load checkpoint
model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg)
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
wrap_fp16_model(model)
checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
if args.fuse_conv_bn:
model = fuse_conv_bn(model)
# old versions did not save class info in checkpoints, this walkaround is
# for backward compatibility
if 'CLASSES' in checkpoint['meta']:
model.CLASSES = checkpoint['meta']['CLASSES']
else:
model.CLASSES = dataset.CLASSES
if not distributed:
model = MMDataParallel(model, device_ids=[0])
outputs = single_gpu_test(model, data_loader, args.show, args.show_dir,
args.show_score_thr)
else:
model = MMDistributedDataParallel(
model.cuda(),
device_ids=[torch.cuda.current_device()],
broadcast_buffers=False)
outputs = multi_gpu_test(model, data_loader, args.tmpdir,
args.gpu_collect)
rank, _ = get_dist_info()
if rank == 0:
if args.out:
print(f'\nwriting results to {args.out}')
mmcv.dump(outputs, args.out)
kwargs = {} if args.eval_options is None else args.eval_options
if args.format_only:
dataset.format_results(outputs, **kwargs)
if args.eval:
eval_kwargs = cfg.get('evaluation', {}).copy()
# hard-code way to remove EvalHook args
for key in ['interval', 'tmpdir', 'start', 'gpu_collect']:
eval_kwargs.pop(key, None)
eval_kwargs.update(dict(metric=args.eval, **kwargs))
print(dataset.evaluate(outputs, **eval_kwargs))
########################################################################################
"""여기에서 box쳐진 test 결과의 이미지를 다시 video로 변환 시켜주기"""
mmcv.frames2video(
"/home/minjae/mjseong/mmdetection/data/KRRI_Video_cvt2frames",
"/home/minjae/mjseong/mmdetection/data/test.avi")
def main():
parser = ArgumentParser()
parser.add_argument('config', help='config file')
parser.add_argument('--input', help='input video file or folder')
parser.add_argument('--output',
help='output video file (mp4 format) or folder')
parser.add_argument('--checkpoint', help='checkpoint file')
parser.add_argument('--device',
default='cuda:0',
help='device used for inference')
parser.add_argument('--show',
action='store_true',
help='whether show the results on the fly')
parser.add_argument('--backend',
choices=['cv2', 'plt'],
default='cv2',
help='the backend to visualize the results')
parser.add_argument('--fps', help='FPS of the output video')
args = parser.parse_args()
assert args.output or args.show
# load images
if osp.isdir(args.input):
imgs = sorted(os.listdir(args.input))
IN_VIDEO = False
else:
imgs = mmcv.VideoReader(args.input)
IN_VIDEO = True
# define output
if args.output is not None:
if args.output.endswith('.mp4'):
OUT_VIDEO = True
out_dir = tempfile.TemporaryDirectory()
out_path = out_dir.name
_out = args.output.rsplit('/', 1)
if len(_out) > 1:
os.makedirs(_out[0], exist_ok=True)
else:
OUT_VIDEO = False
out_path = args.output
os.makedirs(out_path, exist_ok=True)
fps = args.fps
if args.show or OUT_VIDEO:
if fps is None and IN_VIDEO:
fps = imgs.fps
if not fps:
raise ValueError('Please set the FPS for the output video.')
fps = int(fps)
# build the model from a config file and a checkpoint file
model = init_model(args.config, args.checkpoint, device=args.device)
prog_bar = mmcv.ProgressBar(len(imgs))
# test and show/save the images
for i, img in enumerate(imgs):
if isinstance(img, str):
img = osp.join(args.input, img)
result = inference_mot(model, img, frame_id=i)
if args.output is not None:
if IN_VIDEO or OUT_VIDEO:
out_file = osp.join(out_path, f'{i:06d}.jpg')
else:
out_file = osp.join(out_path, img.rsplit('/', 1)[-1])
else:
out_file = None
model.show_result(img,
result,
show=args.show,
wait_time=int(1000. / fps) if fps else 0,
out_file=out_file,
backend=args.backend)
prog_bar.update()
if OUT_VIDEO:
print(f'making the output video at {args.output} with a FPS of {fps}')
mmcv.frames2video(out_path, args.output, fps=fps)
out_dir.cleanup()
if __name__ == "__main__":
# cut_video('data/green-video', 'data/green-video/green-background')
# video = mmcv.VideoReader('data/GS_Video/VID_20200727_140923.mp4')
# video.cvt2frames('data/GS_Video/gsvideo_image', filename_tmpl='{:06d}.png')
# mmcv.frames2video('data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/fg-merged', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/fg-merged.avi', filename_tmpl='{:06d}.png')
#concat_video('data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/img-merged.avi', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/fg-merged.avi', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth')
# concat_video('data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/SDK_raw_index.avi', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/EIG.mp4', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/fg-merged.avi', 'data/GS_Video/results/ngs-iter_78000-SAD-7.081.pth/submit')
# video = mmcv.VideoReader('data/GS_Video/motion_blur/sorce.avi')
# video.cvt2frames('data/GS_Video/motion_blur/sorce', filename_tmpl='{:06d}.png')
# mmcv.frames2video('data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged/fg-merged.avi', filename_tmpl='{:06d}.png')
# mmcv.frames2video('data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/img-merged', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged/img-merged.avi', filename_tmpl='{:06d}.png')
# mmcv.frames2video('data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged-low', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged-low.avi', filename_tmpl='{:06d}.png')
# concat_video('data/GS_Video/motion_blur/results/compare/IMG_1967_EIG.mp4', 'data/GS_Video/motion_blur/results/compare/IMG_1967_indexnet_ft_result.avi', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged-low.avi', 'data/GS_Video/motion_blur/results/compare')
mmcv.frames2video(
'data/GS_Video/man/results/port+purebg/fg-merged',
'data/GS_Video/man/results/port+purebg/port+purebg-epoch30.avi',
filename_tmpl='{:06d}.png')
# concat_2video('data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/fg-merged-low.avi', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth/ofd0.1.avi', 'data/GS_Video/motion_blur/results/ngs-iter_78000-SAD-7.081.pth')
# cut_video('data/green-video/video/other_color', 'data/portrait+purebg/bg')
def main():
parser = ArgumentParser()
parser.add_argument('config', help='Config file')
parser.add_argument('--input', help='input video file')
parser.add_argument('--output', help='output video file (mp4 format)')
parser.add_argument('--checkpoint', help='Checkpoint file')
parser.add_argument(
'--device', default='cuda:0', help='Device used for inference')
parser.add_argument(
'--show',
action='store_true',
default=False,
help='whether to show visualizations.')
parser.add_argument(
'--score-thr', type=float, default=0.8, help='bbox score threshold')
parser.add_argument(
'--thickness', default=3, type=int, help='Thickness of bbox lines.')
parser.add_argument('--fps', help='FPS of the output video')
args = parser.parse_args()
# load images
if osp.isdir(args.input):
imgs = sorted(os.listdir(args.input))
IN_VIDEO = False
else:
imgs = mmcv.VideoReader(args.input)
IN_VIDEO = True
# define output
if args.output is not None:
if args.output.endswith('.mp4'):
OUT_VIDEO = True
out_dir = tempfile.TemporaryDirectory()
out_path = out_dir.name
_out = args.output.rsplit('/', 1)
if len(_out) > 1:
os.makedirs(_out[0], exist_ok=True)
else:
OUT_VIDEO = False
out_path = args.output
os.makedirs(out_path, exist_ok=True)
fps = args.fps
if args.show or OUT_VIDEO:
if fps is None and IN_VIDEO:
fps = imgs.fps
if not fps:
raise ValueError('Please set the FPS for the output video.')
fps = int(fps)
# build the model from a config file and a checkpoint file
model = init_model(args.config, args.checkpoint, device=args.device)
prog_bar = mmcv.ProgressBar(len(imgs))
# test and show/save the images
for i, img in enumerate(imgs):
if isinstance(img, str):
img = osp.join(args.input, img)
img = mmcv.imread(img)
result = inference_vid(model, img, frame_id=i)
if args.output is not None:
if IN_VIDEO or OUT_VIDEO:
out_file = osp.join(out_path, f'{i:06d}.jpg')
else:
out_file = osp.join(out_path, img.rsplit('/', 1)[-1])
else:
out_file = None
model.show_result(
img,
result,
score_thr=args.score_thr,
show=args.show,
wait_time=int(1000. / fps) if fps else 0,
out_file=out_file,
thickness=args.thickness)
prog_bar.update()
if OUT_VIDEO:
print(
f'\nmaking the output video at {args.output} with a FPS of {fps}')
mmcv.frames2video(out_path, args.output, fps=fps, fourcc='mp4v')
out_dir.cleanup()
import mmcv
import os
path = os.path.abspath("./data/image_inference_result02/")
mmcv.frames2video(path,
"/home/minjae/mjseong/mmdetection/data/test02.avi",
fps=15)
# mmcv.frames2video("/home/minjae/mjseong/mmdetection/data/KRRI_Video_cvt2frames_6000", "/home/minjae/mjseong/mmdetection/data/6000test.avi", fps= 20)
def main():
args = parse_args()
assert args.show or args.out_dir, \
('Please specify at least one operation (show the results '
'/ save the results) with the argument "--show" or "--out-dir"')
if not args.result_file.endswith(('.pkl', 'pickle')):
raise ValueError('The result file must be a pkl file.')
if args.out_dir is not None:
os.makedirs(args.out_dir, exist_ok=True)
print_log('This script visualizes the error for multiple object tracking. '
'By Default, the red bounding box denotes false positive, '
'the yellow bounding box denotes the false negative '
'and the blue bounding box denotes ID switch.')
cfg = Config.fromfile(args.config)
dataset = build_dataset(cfg.data.val, dict(test_mode=True))
results = mmcv.load(args.result_file)
# create index from frame_id to filename
filenames_dict = dict()
for data_info in dataset.data_infos:
video_name = data_info['filename'].split('/', 1)[0]
frame_id = int(data_info['filename'].rsplit('/', 1)[-1].split('.')[0])
if video_name not in filenames_dict:
filenames_dict[video_name] = dict()
filenames_dict[video_name][frame_id] = data_info['filename']
# format the results to txts
resfiles, video_names, tmp_dir = dataset.format_results(
results, None, ['track'])
for video_name in video_names:
print_log(f'Start processing video {video_name}')
acc, res, gt = compare_res_gts(resfiles, dataset, video_name)
frames_id_list = sorted(
list(set(acc.mot_events.index.get_level_values(0))))
for frame_id in frames_id_list:
# events in the current frame
events = acc.mot_events.xs(frame_id)
cur_res = res.loc[frame_id] if frame_id in res.index else None
cur_gt = gt.loc[frame_id] if frame_id in gt.index else None
# path of image
img = osp.join(dataset.img_prefix,
filenames_dict[video_name][frame_id])
fps = events[events.Type == 'FP']
fns = events[events.Type == 'MISS']
idsws = events[events.Type == 'SWITCH']
bboxes, ids, error_types = [], [], []
for fp_index in fps.index:
hid = events.loc[fp_index].HId
bboxes.append([
cur_res.loc[hid].X, cur_res.loc[hid].Y,
cur_res.loc[hid].X + cur_res.loc[hid].Width,
cur_res.loc[hid].Y + cur_res.loc[hid].Height,
cur_res.loc[hid].Confidence
])
ids.append(hid)
# error_type = 0 denotes false positive error
error_types.append(0)
for fn_index in fns.index:
oid = events.loc[fn_index].OId
bboxes.append([
cur_gt.loc[oid].X, cur_gt.loc[oid].Y,
cur_gt.loc[oid].X + cur_gt.loc[oid].Width,
cur_gt.loc[oid].Y + cur_gt.loc[oid].Height,
cur_gt.loc[oid].Confidence
])
ids.append(-1)
# error_type = 1 denotes false negative error
error_types.append(1)
for idsw_index in idsws.index:
hid = events.loc[idsw_index].HId
bboxes.append([
cur_res.loc[hid].X, cur_res.loc[hid].Y,
cur_res.loc[hid].X + cur_res.loc[hid].Width,
cur_res.loc[hid].Y + cur_res.loc[hid].Height,
cur_res.loc[hid].Confidence
])
ids.append(hid)
# error_type = 2 denotes id switch
error_types.append(2)
if len(bboxes) == 0:
bboxes = np.zeros((0, 5), dtype=np.float32)
else:
bboxes = np.asarray(bboxes, dtype=np.float32)
ids = np.asarray(ids, dtype=np.int32)
error_types = np.asarray(error_types, dtype=np.int32)
imshow_mot_errors(
img,
bboxes,
ids,
error_types,
show=args.show,
out_file=osp.join(args.out_dir,
f'{video_name}/{frame_id:06d}.jpg')
if args.out_dir else None,
backend=args.backend)
print_log(f'Done! Visualization images are saved in '
f'\'{args.out_dir}/{video_name}\'')
mmcv.frames2video(f'{args.out_dir}/{video_name}',
f'{args.out_dir}/{video_name}.mp4',
fps=args.fps,
fourcc='mp4v',
start=frames_id_list[0],
end=frames_id_list[-1],
show_progress=False)
print_log(
f'Done! Visualization video is saved as '
f'\'{args.out_dir}/{video_name}.mp4\' with a FPS of {args.fps}')
