def main(args):
# Load dataset
db = DAVISLoader(year=cfg.YEAR, phase=phase.TRAINVAL)
anno_path = os.path.join(args.datapath, 'Annotations', '480p')
# get trainval seq name
with open(os.path.join(args.datapath, 'ImageSets', '2017', 'train.txt'),
'r') as train_f:
train_list = [s.strip('\n') for s in train_f.readlines()]
with open(os.path.join(args.datapath, 'ImageSets', '2017', 'val.txt'),
'r') as val_f:
val_list = [s.strip('\n') for s in val_f.readlines()]
trainval_list = train_list + val_list
# scan all seq in trainval
for class_name in trainval_list:
print("solving %s ----------" % class_name)
class_out_path = os.path.join(args.outpath, class_name)
# save annotations for each obj
for i in range(len(db[class_name].annotations)):
# get obj path in a class
annotation = db[class_name].annotations[i]
for obj_id in np.unique(annotation)[1:]:
tmp_path = os.path.join(class_out_path, str(obj_id - 1))
if not os.path.exists(tmp_path):
os.makedirs(tmp_path)
obj_mask = (annotation == (obj_id)).astype('int')
np.save(os.path.join(tmp_path, '%05d.png' % i), obj_mask)
#!/usr/bin/env python
# ----------------------------------------------------------------------------
# The 2017 DAVIS Challenge on Video Object Segmentation
#-----------------------------------------------------------------------------
# Copyright (c) 2017 Federico Perazzi
# Licensed under the BSD License [see LICENSE for details]
# Written by Federico Perazzi
# ----------------------------------------------------------------------------
"""
Visualize segmentation.
EXAMPLE:
python experiments/visualize.py
"""
import cv2
from davis import cfg,overlay,DAVISLoader
db = DAVISLoader(year=cfg.YEAR,phase=cfg.PHASE)
im = overlay(db[0].images[0],db[0].annotations[0],db.color_palette)
cv2.imshow("Segmentation",im[...,[2,1,0]])
cv2.waitKey()
print("Class: ", args.seq)
print("Limit: ", args.limit)
print("Augment method: ", args.augment_method)
############################################################
# Dataset
############################################################
# NEED DAVIS TOOL in https://github.com/fperazzi/davis-2017
from davis import cfg, phase, io, DAVISLoader, Annotation
an = Annotation(args.seq, single_object=0)
OBJ_NUMBER = an.n_objects
# Load dataset
db = DAVISLoader(year=args.year, phase=phase.TESTDEV)
AugmentImgPath = os.path.join(args.dataset, 'Augmentations',
args.augment_method, 'JPEGImages', '480p',
args.seq)
AugmentAnnoPath = os.path.join(args.dataset, 'Augmentations',
args.augment_method, 'Annotations', '480p',
args.seq)
# read all the file list
file_names = next(os.walk(AugmentImgPath))[2]
random.shuffle(file_names)
test_files = [x[:-4] for x in file_names[:args.limit]]
train_files = [x[:-4] for x in file_names[args.limit:]]
class DavisDataset(utils.Dataset):
def __init__(self,
db_name="DAVIS",
split='train',
cls_mapper=None,
load_flow=False,
load_inv_db=False):
'''
Args:
cls_mapper(dict type): VOS dataset only provides instance id label or class label that
is not consistent with the object detection model. As our work is to provide object
detection model with the ability for VOS task, so object label is provided by the
prediction of object detection model. The prediction is provided by label_mapper.
If set None, no class is assigned. Otherwise, class_id = cls_mapper[instance_id].
For seq_idx, instance_idx, its class label can be got by "label_mapper[seq_idx][instance_idx]".
As some objects may be predicted as background, we choose the class with highest probability
among non-background classes to be its class label.
'''
super().__init__(db_name + str(cfg_davis.YEAR))
self.split = split
if split is not None:
if split not in splits:
raise ValueError('split not recognizable')
if split == 'train':
self.phase = phase.TRAIN
self.use_local_id = False
elif split == 'val':
self.phase = phase.VAL
self.use_local_id = True
elif split == 'trainval':
self.phase = phase.TRAINVAL
self.use_local_id = False
elif split == 'test-dev':
self.phase = phase.TESTDEV
self.use_local_id = True
else:
raise ValueError('split not recognizable')
if cfg_davis.PHASE != self.phase:
print('phase changed from %s to %s' %
(cfg_davis.PHASE.value, self.phase.value))
cfg_davis.PHASE = self.phase
print('year:', cfg_davis.YEAR)
print('phase:', cfg_davis.PHASE.value)
self.db = DAVISLoader(year=cfg_davis.YEAR, phase=cfg_davis.PHASE)
self.seq_idx = 0
self.cls_mapper = None
if cls_mapper is not None:
assert (isinstance(cls_mapper, dict))
self.cls_mapper = cls_mapper
# Here we adopt COCO classes.
self.number_of_instance_ids = 0
self.global_instance_id_start_of_seq = np.zeros(
self.get_num_sequence(), dtype=np.int32)
self.instance_number_of_seq = np.zeros(self.get_num_sequence(),
dtype=np.int32)
self.set_global_instance_id_start()
self.debug_timer = Timer()
self.keypoints = None
self.load_flow = load_flow
# load_inv_db: only affect get_separate_roidb_from_all_sequences
self.load_inv_db = load_inv_db
#self.COCO = datasets.get_coco_dataset()
#category_ids = list(self.COCO.classes.keys())
#categories = list(self.COCO.classes.values())
#self.category_to_id_map = dict(zip(categories, category_ids))
#self.classes = ['__background__']+categories+['__unknown__']
category_ids = list(range(self.number_of_instance_ids))
self.classes = [
self.global_id_to_seq_name_plus_id(i)
for i in range(self.number_of_instance_ids)
]
categories = self.classes
self.category_to_id_map = dict(zip(categories, category_ids))
print(self.category_to_id_map)
self.num_classes = len(self.classes)
self.cfg = cfg_davis
args = parser.parse_args()
# Cast string to Enum
args.phase = davis.phase[args.phase.upper()]
return args
if __name__ == '__main__':
args = parse_args()
log.info('Loading DAVIS year: {} phase: {}'.format(args.year, args.phase))
# Load DAVIS
db = DAVISLoader(args.year, args.phase, args.single_object)
log.info('Loading video segmentations from: {}'.format(args.input))
# Load segmentations
segmentations = [
Segmentation(osp.join(args.input, s), args.single_object)
for s in db.iternames()
]
# Evaluate results
evaluation = db_eval(db, segmentations, args.metrics)
# Print results
table = PrettyTable(['Method'] + [
p[0] + '_' + p[1]
# Cast string to Enum
args.phase = davis.phase[args.phase.upper()]
return args
if __name__ == '__main__':
args = parse_args()
log.info('Loading DAVIS year: {} phase: {}'.format(
args.year,args.phase))
# Load DAVIS
db = DAVISLoader(args.year,
args.phase,args.single_object)
log.info('Loading video segmentations from: {}'.format(args.input))
# Load segmentations
segmentations = [Segmentation(
osp.join(args.input,s),args.single_object) for s in db.iternames()]
# Evaluate results
evaluation = db_eval(db,segmentations,args.metrics)
# Print results
table = PrettyTable(['Method']+[p[0]+'_'+p[1] for p in
itertools.product(args.metrics,cfg.EVAL.STATISTICS)])
table.add_row([osp.basename(args.input)]+["%.3f"%np.round(