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(