def __init__(self, image_set, year, use_diff=False):
name = 'icpr_' + year + '_' + image_set
imdb.__init__(self, name)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path()
self._data_path = os.path.join(self._devkit_path, 'image_10000')
self._xml_path = os.path.join(self._devkit_path, 'xml_10000')
self._classes = ('__background__', # always index 0
'text')
self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
#self._salt = str(uuid.uuid4())
#self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup': True,
'use_salt': True,
'use_diff': use_diff,
'matlab_eval': False,
'rpn_file': None}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = os.path.join(self._devkit_path, 'total')
self._classes = ('__background__', # always index 0
'_1', '_2', '_3', '_4',
'_5', '_6', '_7', '_8', '_9',
'_10', '_11', '_12')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.png'
# self._image_index = self._load_image_set_index()
# self._image_index = [x for x in range(1056)]
self._image_index = self._load_image_set_index('ImageList_train.txt')
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = os.path.join(self._devkit_path, sdha_cfg.stream_name)
self._classes = ('__background__')
if sdha_cfg.category == 2:
self._classes = sdha_cfg.two_category
elif sdha_cfg.category == 7:
self._classes = sdha_cfg.seven_category
else:
pass
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = ['.npy']
self._image_index = self._load_image_set_index()
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# Specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'top_k' : 2000,
'use_diff' : False,
'rpn_file' : None}
assert os.path.exists(self._devkit_path), \
'Devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set):
imdb.__init__(self, 'imagenet')
self._image_set = image_set
self._data_path = os.path.join(cfg.DATA_DIR, "imagenet")
self._class_wnids = [
('background', 'background'),
('cup', 'n03147509'),
('glasses', 'n04272054'),
('tool', 'n04451818'),
('laptop', 'n03642806'),
('chair', 'n03001627')
]
self._classes = tuple([class_[0] for class_ in self._class_wnids])
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
print(self._class_to_ind)
self._xml_path = os.path.join(self._data_path, "Annotations")
self._image_ext = '.JPEG'
# the xml file name and each one corresponding to image file name
self._image_index = self._load_xml_filenames()
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
# COCO specific config options
self.config = {'top_k' : 2000,
'use_salt' : True,
'cleanup' : True,
'crowd_thresh' : 0.7,
'min_size' : 2}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_ann_file())
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._class_to_coco_cat_id = dict(zip([c['name'] for c in cats],
self._COCO.getCatIds()))
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('selective_search')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {'minival2014' : 'val2014'}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if self._view_map.has_key(coco_name)
else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
def __init__(self, image_set, devkit_path):
imdb.__init__(self, 'pipa_' + image_set)
#self._year = year
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = os.path.join(self._devkit_path, 'data')
self._classes = ('__background__', # always index 0
'head')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, config=None):
imdb.__init__(self, 'caltech_ped_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._data_path = self._get_default_path()
self._classes = ('__background__', # always index 0
'person', 'ignore')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.rpn_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp1' # usage?
# Caltech specific config options: Reasonable (default) for training
# pLoad={'lbls',{'person'},'ilbls',{'people'},'squarify',{3,.41}, ...
# 'hRng',[50 inf], 'vRng',[1 1]};
self.config = {'labels' : ['person'],
'ign_labels' : ['people'],
'squarify' : [3, 0.41],
'vRng' : [1, 1],
'xRng' : [0, 640],
'yRng' : [0, 480],
'wRng' : [-np.inf, np.inf],
'hRng' : [50, np.inf],
'use_flip' : True
'matlab_eval' : False}
# To do: write config-merge code
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = ('__background__', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'coco_ori_' + year + '_' + image_set)
self._year = year
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = self._devkit_path
clasnum = 80
classes = ['__background__']
for i in range(clasnum):
classes.append(str(i + 1))
self._classes=tuple(classes)
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_type = 'images';
self._image_set = image_set;
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('mcg')
self._salt = str(uuid.uuid4())
# PASCAL specific config options
self.config = {'top_k' : 2000,
'use_salt' : True,
'cleanup' : True,
'crowd_thresh' : 0.7,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set):
imdb.__init__(self, 'coco_text_' + image_set)
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco_text', image_set)
self._classes = ('__background__', # always index 0
'frame')
self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
self._image_ext = '.jpg'
if 'dragonball' in image_set:
self._image_ext = '.png'
self._image_index = self._load_image_name()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
# PASCAL specific config options
self.config = {'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2}
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path):
imdb.__init__(self,"INRIA_Person_" + image_set)
self._image_set = image_set
self._devkit_path = devkit_path
if image_set == 'train':
self._data_path = os.path.join(self._devkit_path, 'data')
else:
self._data_path = os.path.join(self._devkit_path, 'testData')
self._classes = ('__background__', # always index 0
'person')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = ['.jpg', '.png']
self._image_index = self._load_image_set_index()
self._list_of_output_detection_results = {}
# Specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'top_k' : 2000,
'use_diff' : False,
'rpn_file' : None}
assert os.path.exists(self._devkit_path), \
'Devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, version):
imdb.__init__(self, 'vg_' + version+ '_' + image_set)
self._image_set = image_set
self._data_path = '%s/%s' % (DEFAULT_PATH, version)
cfg.CACHE_DIR = self._data_path
self._image_ext = '.jpg'
print 'data_path: %s' % self._data_path
region_imset_path = os.path.join(self._data_path, '%s_gt_regions.json' % image_set)
self._classes = ('__background__', '__foreground__')
print 'loading from %s' % region_imset_path
self._gt_regions = json.load(open(region_imset_path))
#print self._gt_regions.items()[0]
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.rpn_roidb
self._salt = str(uuid.uuid4())
vocab_path = os.path.join(self._data_path,'vocabulary.txt')
with open(vocab_path,'r') as f:
self._vocabulary_inverted = [line.strip() for line in f]
self._vocabulary = dict([(w,i) for i,w in enumerate(self._vocabulary_inverted)])
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'nyud2_images_' + year + '_' + image_set)
self._year = year
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'data')
self._classes = ('__background__', # always index 0
'bathtub', 'bed', 'bookshelf', 'box', 'chair', 'counter', 'desk',
'door', 'dresser', 'garbage-bin', 'lamp', 'monitor', 'night-stand',
'pillow', 'sink', 'sofa', 'table', 'television', 'toilet');
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_type = 'images';
self._image_set = image_set;
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.mcg_roidb
self._salt = str(uuid.uuid4())
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
# Brent (2016/06/08) - read from file (rather than hard-coded here and in classification script)
# FIXME: specify model (or labels file in cfg)
self._classes = ['__background__'] + readLines('/opt/dev/proj/sony/research/py-faster-rcnn/lib/datasets/pascal_voc_labels.txt')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, loc, devkit_path=None):
imdb.__init__(self, 'joy_' + loc + '_' + image_set)
self._loc = loc
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'Joy' + self._loc)
self._classes = ('__background__', # always index 0
"鸡蛋","玉米","茄子-长","茄子-圆","番茄","胡萝卜",
"青椒-长","青椒-圆","冬瓜","黄瓜","苦瓜","丝瓜",
"西葫芦","洋葱","蒜苔","青菜","菜花","西兰花",
"菠菜","芹菜","生菜","莴笋","空心菜","苹果","梨",
"葡萄","橙","金针菇","平菇","香菇","酸奶","豆腐")
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
# self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self):
imdb.__init__(self, 'wider')
self._data_path = self._get_default_path()
self.db = CuteReader(os.path.join(self._data_path, 'wider-imdb'))
self._image_width = []
self._image_height = []
self._classes = ('__background__', # always index 0
'face')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
# max indexes not including flipped images
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
def __init__(self, devkit_path=None):
# voc_2007_test
imdb.__init__(self, 'person_head')
self._devkit_path = '/data2/yichaoxiong/data/youtu'
self._image_set = 'test'
self._data_path = os.path.join(self._devkit_path, self.name)
self._classes = ('__background__', # always index 0
'person', 'head')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
#self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : False,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path):
imdb.__init__(self, image_set)
# pdb.set_trace()
print image_set
self._image_set = image_set
self._devkit_path = devkit_path
if image_set == 'train':
self._data_path = os.path.join(self._devkit_path)
else:
self._data_path = os.path.join(self._devkit_path)
#self.annotations_file = '/home/will/dev/py-faster-rcnn/hover/rcnn_tri_box_sz'
self.annotations_file = '/home/will/dev/py-faster-rcnn/hover/rcnn_tri_box_with_buffer_test'
self._classes = ('__background__', # always index 0
'gable',
)
print 'number of classes: ', self.num_classes
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = ['.jpg']
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
# Specific config options
self.config = {'cleanup' : True,
'use_diff' : False,
'use_salt' : True,
'rpn_file' : None }
#'top_k' : 2000}
assert os.path.exists(self._devkit_path), \
'Devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, name, root_path='custom'):
imdb.__init__(self, 'custom_' + name + '_' + image_set)
self._image_set = image_set
self._root_path = os.path.join(cfg.DATA_DIR, root_path)
self._data_path = os.path.join(self._root_path, name)
self._image_path = os.path.join(self._root_path, name, 'images')
self._label_path = os.path.join(self._root_path, name, 'labels')
self._classes = ('__background__', # always index 0
'0', '1', '2', '3', '4')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
self._salt = str(uuid.uuid4())
self.config = {'cleanup' : True,
'use_salt' : True,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._root_path), \
'Custom root path does not exist: {}'.format(self._root_path)
assert os.path.exists(self._data_path), \
'Data path does not exist: {}'.format(self._data_path)
assert os.path.exists(self._image_path), \
'Image path does not exist: {}'.format(self._image_path)
assert os.path.exists(self._label_path), \
'Label path does not exist: {}'.format(self._label_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, 'grotoap2_' + '_' + image_set) # change name here
self._year = 2007
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = self._get_default_path()
# Set your zones here
self._classes = ('__background__', # always index 0
'title', 'abstract', 'acknowledgment', 'affiliation', 'author',
'bib_info', 'body', 'body_content', 'conflict_statement', 'copyright', 'correspondence',
'dates', 'editor', 'equation', 'figure', 'glossary', 'keywords', 'page_number', 'references',
'table', 'title_author', 'type', 'unknown')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc3_' + year + '_' + image_set)
self._year = year
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = self._devkit_path
clasnum = 20 * 2
classes = ['__background__']
for i in range(clasnum):
classes.append(str(i + 1))
self._classes=tuple(classes)
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_type = 'images';
self._image_set = image_set;
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, PHASE, mat_annot_file=None):
imdb.__init__(self, image_set, PHASE)
if PHASE == 'TRAIN':
self._image_set = './action_experiments/listfiles/' + image_set + '.trainlist' # you need a full path for image list and data path
else:
self._image_set = './action_experiments/listfiles/' + image_set + '.testlist'
self._USE_MAT_GT = mat_annot_file != None
self._annot_path = "/home/lear/xpeng/data/UCF101/UCF101_24_Annotations" # you only have annotations in RGB data folder
if 'RGB' in image_set and 'FLOW' in image_set:
self._data_path = '/home/lear/xpeng/data/UCF101/flows_color'
else:
self._MOD = image_set.split('_')[1]
self._LEN = image_set.split('_')[2]
self._data_path = None
if self._MOD == 'RGB':
self._data_path = '/home/lear/xpeng/data/UCF101/frames_240'
if self._MOD == 'FLOW':
self._data_path = '/home/lear/xpeng/data/UCF101/flows_color'
self._classes = ('__background__', 'Basketball', 'BasketballDunk',
'Biking', 'CliffDiving', 'CricketBowling', 'Diving',
'Fencing', 'FloorGymnastics', 'GolfSwing',
'HorseRiding', 'IceDancing', 'LongJump', 'PoleVault',
'RopeClimbing', 'SalsaSpin', 'SkateBoarding',
'Skiing', 'Skijet', 'SoccerJuggling', 'Surfing',
'TennisSwing', 'TrampolineJumping',
'VolleyballSpiking', 'WalkingWithDog')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._img_format = '' # it will update after load image set index
self._image_index = self._load_image_set_index(
) # get the temporal anotation
self.test_videos = sorted([
l.split()[0][:-4] for l in file(
'./action_experiments/listfiles/UCF101_video_testlist01.txt')
])
self.train_videos = sorted([
l.split()[0][:-4] for l in file(
'./action_experiments/listfiles/UCF101_video_trainlist01.txt')
])
self.videos = sorted([
l.split()[0][:-4] for l in file(
"./action_experiments/listfiles/UCF101_video_trainlist01.txt")
] + self.test_videos)
self.video_to_label = {
v: self._class_to_ind[v.split('/')[0]]
for v in self.videos
}
if mat_annot_file:
self._mat_gt = self.get_mat_gt(mat_annot_file)
# Default to roidb handler
self._roidb_handler = self.gt_roidb
def __init__(self, split, wider_path=None):
self._test_flag = True if split == 'test' else False
self._split = split
imdb.__init__(self, 'wider_' + split)
self._image_set = split
self._annotation_file_name = 'wider_face_test_filelist.txt' if self._test_flag else \
'wider_face_{}_bbx_gt.txt'.format(split)
if wider_path is None:
self._dataset_path = self._get_default_path()
else:
self._dataset_path = wider_path
self._imgs_path = os.path.join(self._dataset_path,
'JPEGImages/wider_{}'.format(split),
'images')
# Read the annotations file
anno_path = os.path.join(os.path.join(DATA_DIR,
'facedata'), 'wider_face_split',
self._annotation_file_name)
assert os.path.isfile(
anno_path), 'Annotation file not found {}'.format(anno_path)
self._fp_bbox_map = {}
with open(anno_path, 'r') as file:
annos = file.readlines()
self._fp_bbox_map = {}
count = 0
if not self._test_flag:
while count < len(annos):
name = str(annos[count]).rstrip()
self._fp_bbox_map[name] = []
count += 1
n_anno = int(annos[count])
for i in xrange(n_anno):
count += 1
bbox = annos[count].split(' ')[0:4]
bbox = [int(round(float(x))) for x in bbox]
x1 = max(0, bbox[0])
y1 = max(0, bbox[1])
self._fp_bbox_map[name].append(
[x1, y1, x1 + bbox[2], y1 + bbox[3]])
count += 1
self._image_paths = self._fp_bbox_map.keys()
else:
self._image_paths = []
for path in annos:
self._image_paths.append(str(path).rstrip())
self._image_index = range(len(self._image_paths))
self._classes = ['bg', 'face']
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
'''
self._devkit_path = os.environ['HOME'] + '/data/Object_Detection/pascal/VOCdevkit'
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = ('__background__', # always index 0
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat', 'chair',
'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')
'''
self._devkit_path = '/workspace/mnt/group/general-reg/zhuriheng/github/code_zrh/caffe/img-det/refinedet/experiment/train_model_refinedet_res18_320x320/eval'
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = (
'__background__', # always index 0
'tibetan_flag',
'gongzhang_logo',
'BK_LOGO',
'taiwan_bairiqi_flag',
'isis_flag',
'not_terror_card_text',
'not_terror',
'knives',
'guns',
'card',
'islamic_flag',
'china_guoqi_flag')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = os.path.join(self._devkit_path)
self._classes = ('__background__', 'person')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_index = self._load_image_set_index('ImageList_MOT.txt')
self._roidb_handler = self.gt_roidb
self.config = {'cleanup': True, 'use_salt': True, 'top_k': 2000}
assert os.path.exists(
devkit_path), 'data path dose not exist: {}'.format(devkit_path)
def __init__(self,
image_set,
obj_attr_type,
devkit_path=None,
aux_path=None,
use_attrs=False,
is_smol=False):
self.obj_attr_type = obj_attr_type
imdb.__init__(
self, 'IRSG_{}_{}{}'.format(image_set, self.obj_attr_type,
'_smol' if is_smol else ''))
self._image_set = image_set
self._devkit_path = (self._get_default_path()
if devkit_path is None else devkit_path)
self._aux_path = (self._get_default_aux_path()
if aux_path is None else aux_path)
self.train_image_path = os.path.join(self._devkit_path,
'sg_train_images')
self.test_image_path = os.path.join(self._devkit_path,
'sg_test_images')
self._classes = self._load_classes(is_smol=is_smol)
self._class_to_ind = dict(zip(self.classes, range(self.num_classes)))
self._roidb_handler = self.rpn_roidb
train_anno_path = os.path.join(self._devkit_path,
'sg_train_annotations.json')
test_anno_path = os.path.join(self._devkit_path,
'sg_test_annotations.json')
with open(train_anno_path) as f:
print('loading train annotations...')
self.train_annotations = self._filter_annotations(json.load(f))
with open(test_anno_path) as f:
print('loading test annotations...')
self.test_annotations = self._filter_annotations(json.load(f))
train_size = len(self.train_annotations)
test_size = len(self.test_annotations)
if image_set is 'train':
self.annotations = self.train_annotations
self.image_path = self.train_image_path
self._image_index = self._get_image_index('train')
elif image_set is 'val':
self.annotations = self.train_annotations
self.image_path = self.train_image_path
self._image_index = self._get_image_index('val')
elif image_set is 'test':
self.annotations = self.test_annotations
self.image_path = self.test_image_path
self._image_index = self._get_image_index('test')
else:
error_format = ('invalid image set name \'{}\': only'
'\'train\' and \'test\' are allowed')
raise ValueError(error_format.format(image_set))
def __init__(self, image_set, year):
imdb.__init__(self, 'fovea_' + year + '_' + image_set)
# COCO specific config options
self.config = {'use_salt': True, 'cleanup': True}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'fovea')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_ann_file())
"""
self._COCO.getCatIds() ---> [1, 2, 3, ...91]
cats = self._COCO.loadCats(self._COCO.getCatIds()) ---> [{"supercategory": "person", "id": 1, "name": "person"},..., {"supercategory": "person", "id": 1, "name": "person"}]
self._classes = ('__background__', "person", "bicycle", "car", "motorcycle", ..., "toothbrush")
self._class_to_ind = {'__background__':0, "person":1, ..., "tothbrush":92}
self._class_to_coco_cat_id = {"person":1, ..., "tothbrush":92}
self._image_index = [img_id1, img_id2, ..., img_idN]
self.roidb_handler = self.gt_roidb #Return the database of ground-truth regions of interest.
"""
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._class_to_coco_cat_id = dict(
list(zip([c['name'] for c in cats], self._COCO.getCatIds())))
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('gt')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014': 'val2014', # 5k val2014 subset
'valminusminival2014': 'val2014', # val2014 \setminus minival2014
'test-dev2015': 'test2015',
}
fovea_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[fovea_name]
if fovea_name in self._view_map else fovea_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val')
with open(self._get_ann_file(), 'r') as annfile:
load_dict = json.load(annfile)
self.image_paths = {}
for idx, ann in enumerate(load_dict['images']):
self.image_paths[str(ann['id'])] = ann['file_name']
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'nyud3_images_' + year + '_' + image_set)
self._year = year
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'data')
self._classes = (
'__background__', # always index 0
'bathtub',
'bed',
'bookshelf',
'box',
'chair',
'counter',
'desk',
'door',
'dresser',
'garbage-bin',
'lamp',
'monitor',
'night-stand',
'pillow',
'sink',
'sofa',
'table',
'television',
'toilet',
'hard_background')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_type = 'images'
self._image_set = image_set
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.mcg_roidb
self._salt = str(uuid.uuid4())
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, use_diff=False):
name = 'voc_' + year + '_' + image_set
if use_diff:
name += '_diff'
imdb.__init__(self, name)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path()
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = (
'__background__', # always index 0
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor')
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb ## self._roidb_handler is another name of the function self.gt_roidb. As defined in the imdb.py ,when using the self.roidb, roidb=self._roidb_handler()
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': use_diff,
'matlab_eval': False,
'rpn_file': None
}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path, data_path):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = data_path
synsets_image = sio.loadmat(
os.path.join(self._devkit_path, 'data', 'meta_det.mat'))
synsets_video = sio.loadmat(
os.path.join(self._devkit_path, 'data', 'meta_vid.mat'))
self._classes_image = ('__background__', )
self._wnid_image = (0, )
self._classes = ('__background__', )
self._wnid = (0, )
for i in xrange(200):
self._classes_image = self._classes_image + \
(synsets_image['synsets'][0][i][2][0],)
self._wnid_image = self._wnid_image + \
(synsets_image['synsets'][0][i][1][0],)
for i in xrange(30):
self._classes = self._classes + \
(synsets_video['synsets'][0][i][2][0],)
self._wnid = self._wnid + (synsets_video['synsets'][0][i][1][0], )
self._wnid_to_ind_image = dict(zip(self._wnid_image, xrange(201)))
self._class_to_ind_image = dict(zip(self._classes_image, xrange(201)))
self._wnid_to_ind = dict(zip(self._wnid, xrange(31)))
self._class_to_ind = dict(zip(self._classes, xrange(31)))
# check for valid intersection between video and image classes
self._valid_image_flag = [0] * 201
for i in range(1, 201):
if self._wnid_image[i] in self._wnid_to_ind:
self._valid_image_flag[i] = 1
self._image_ext = ['.JPEG']
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
# Specific config options
self.config = {'cleanup': True, 'use_salt': True, 'top_k': 2000}
assert os.path.exists(
self._devkit_path), 'Devkit path does not exist: {}'.format(
self._devkit_path)
assert os.path.exists(
self._data_path), 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
self._classes = (
'__background__', # always index 0
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor')
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
#self._roidb_handler = self.selective_search_roidb
self._roidb_handler = self.gt_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'sg_vrd_vp_' + year + '_' + image_set)
#self._image_set_path = 'imagenet_' + year + '_' + image_set
self._year = year
self._image_set = image_set
self._folder_path = self._image_set
#to handle splitted datasets so that we don't have to symlink for every splits
if 'train' in self._image_set: self._folder_path = 'train'
self._devkit_path = os.path.join(self._get_default_path(), 'devkit')
self._data_path = os.path.join(self._get_default_path(), 'Data',
self._folder_path)
self._annot_path = os.path.join(self._get_default_path(),
'Annotations', self._folder_path)
self._classes = () # always index 0
self._class_name = () # always index 0
self._class_ids = () # always index 0
self.m = h5py.File('/home/zawlin/Dropbox/proj/sg_vrd_vp_meta.h5', 'r',
'core')
for i in range(len(self.m['meta/tri/idx2name/'].keys())):
self._classes += (str(self.m['meta/tri/idx2name/' +
str(i)][...]), )
self._class_name += (str(self.m['meta/tri/idx2name/' +
str(i)][...]), )
self._class_ids += (str(self.m['meta/tri/idx2name/' +
str(i)][...]), )
self._class_to_ind = dict(zip(self._classes, xrange(self.num_classes)))
self._class_to_ind.update(
dict(zip(self._class_ids, xrange(self.num_classes))))
self._class_to_ind = dict(zip(self._classes, xrange(self.num_classes)))
self._class_to_ind.update(
dict(zip(self._class_ids, xrange(self.num_classes))))
self._image_ext = '.jpg'
self._image_index, self._image_id = self._load_image_set_index()
self._wh = self._load_image_width_height()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'top_k': 2000,
'use_diff': False,
'rpn_file': None
}
assert os.path.exists(self._data_path), \
'sg_vrd data path does not exist: {}'.format(self._data_path)
if self._image_set != 'test':
assert os.path.exists(self._annot_path), \
'sg_vrd annotation path does not exist: {}'.format(self._annot_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
# COCO specific config options
self.config = {
'top_k': 2000,
'use_salt': True,
'cleanup': True,
'crowd_thresh': 0.7,
'min_size': 2
}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_ann_file())
cats = self._COCO.loadCats(cfg.TRAIN.CAT_IDS)
# if the list in the cfg file is empty, use all possible category IDs
if cfg.TRAIN.CAT_IDS == []:
cfg.TRAIN.CAT_IDS = self._COCO.getCatIds()
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._class_to_coco_cat_id = dict(
zip([c['name'] for c in cats], cfg.TRAIN.CAT_IDS))
print str(self._class_to_coco_cat_id)
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('selective_search')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014': 'val2014', # 5k val2014 subset
'valminusminival2014': 'val2014', # val2014 \setminus minival2014
}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if self._view_map.has_key(coco_name) else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
def __init__(self, data_conf, common_conf, conf):
imdb.__init__(self, data_conf, common_conf, conf)
self._classes = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
'bus', 'car', 'cat', 'chair', 'cow', 'diningtable',
'dog', 'horse', 'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor')
self._class_to_ind = dict( \
zip(self.classes, range(self.num_classes)))
self._image_set = data_conf['image_set']
self._image_index = self._load_image_set_idex()
self._all_image_paths = self.all_img_paths()
self._cache_file = self.cache_file()
self.debug()
def __init__(self, datasetName, imageSet, configName):
imdb.__init__(self, datasetName)
self._local_path = os.path.dirname(__file__)
self._datasetName = datasetName
self._configName = configName
self._image_set = imageSet
self._image_index = []
self._convertIdToCls = None
self._obj_proposer = 'gt'
self._roidb = None
self._roidb_handler = self.gt_roidb
self._roidbSize = []
self._parseDatasetFile()
def __init__(self, split, wider_path=None):
self._test_flag = False
self._split = split
imdb.__init__(self, 'wider_' + split)
self._image_set = split
if wider_path is None:
self._dataset_path = self._get_default_path()
else:
self._dataset_path = wider_path
self._imgs_path = os.path.join(self._dataset_path,
'WIDER_{}'.format(split), 'images')
csv_path = os.path.join(self._dataset_path, 'WIDER_{}'.format(split),
'imglist.csv')
if not os.path.exists(csv_path) and split != 'test':
path = os.path.join(os.path.dirname(__file__), '..', '..',
'matlab')
cmd = 'cd {} && '.format(path)
cmd += 'matlab -nodisplay -nodesktop '
cmd += '-r "dbstop if error; '
cmd += 'wider_csv(\'{:s}\',\'{:s}\',\'{:s}\'); quit;"' \
.format(self._dataset_path, split,
csv_path)
print('Running:\n{}'.format(cmd))
status = subprocess.call(cmd, shell=True)
elif split == 'test':
self._test_flag = True
self._fp_bbox_map = {}
prev_file = 'blah'
with open(csv_path, 'r') as f:
reader = csv.reader(f)
if not self._test_flag:
for row in reader:
if row[0] != prev_file:
self._fp_bbox_map[row[0]] = []
prev_file = row[0]
x1 = max(0, int(row[1]))
y1 = max(0, int(row[2]))
w = int(row[3])
h = int(row[4])
self._fp_bbox_map[row[0]].append([x1, y1, x1 + w, y1 + h])
self._image_paths = self._fp_bbox_map.keys()
else:
self._image_paths = []
for row in reader:
self._image_paths.append(row[0])
self._image_index = range(len(self._image_paths))
self._classes = ['_bg', 'face']
def __init__(self, image_set, name, kaist_path=None, kaist_classes=None):
imdb.__init__(self, 'kaist_' + name + '_' + image_set)
self._name = name
self._image_set = image_set
##### CONFIGURATION ############################################################################################
if kaist_path == None:
### *** HOME ***
#self._kaist_path = '{}/data/KAIST'.format(os.environ['HOME']) # kaist_path usually given from 'factory.py'
### *** WORK ***
self._kaist_path = '/net4/merkur/storage/deeplearning/users/gueste/data/KAIST' # kaist_path usually given from 'factory.py'
################################################################################################################
else:
self._kaist_path = kaist_path
self._ImageSets_path = os.path.join(self._kaist_path, self._name)
#self._ImageData_path = os.path.join(self._kaist_path, 'data-kaist', 'test-all')
self._ImageData_path = None
self._Annotations_path = None
#self._classes = ('__background__', # always index 0
# 'person')
self._classes = kaist_classes if not kaist_classes == None else (
'__background__', 'person') # Usually given from 'factory.py'
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.png'
self._use_07_metric = False # Shoult be 'False' in order to ensure correct calculation of Average Precision
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4()).split('-')[
0] # Modified to use only first UUID part (shorter)
self._comp_id = 'comp4' # DEFAULT: 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._kaist_path), \
'KAIST path does not exist: {}'.format(self._kaist_path)
assert os.path.exists(self._ImageSets_path), \
'Path does not exist: {}'.format(self._ImageSets_path)
assert os.path.exists(self._ImageData_path), \
'Path does not exist: {}'.format(self._ImageData_path)
assert os.path.exists(self._Annotations_path), \
'Path does not exist: {}'.format(self._Annotations_path)
def __init__(self, image_set, use_diff=False):
name = 'kitti_' + image_set
if use_diff:
name += '_diff'
imdb.__init__(self, name)
self._year = 0
self._image_set = image_set
self._devkit_path = self._get_default_path()
# my
#--------------------------------------------------------------------------
self._devkit_path = os.path.join(cfg.DATA_DIR, 'kitti_devkit')
#--------------------------------------------------------------------------
self._data_path = os.path.join(self._devkit_path, 'kitti')
self._classes = (
'__background__', # always index 0
#-------------------------------------------------------------------------
# voc datasets
# 'aeroplane', 'bicycle', 'bird',
# 'boat', 'bottle', 'bus', 'car',
# 'cat', 'chair', 'cow', 'diningtable',
# 'dog', 'horse', 'motorbike', 'person',
# 'pottedplant', 'sheep', 'sofa', 'train',
# 'tvmonitor'
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
# kitti datatets
'car'
#---------------------------------------------------------------------------
)
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': use_diff,
'matlab_eval': False,
'rpn_file': None
}
assert os.path.exists(self._devkit_path), \
'kittidevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'DeepScoresV2' + year + '_' + image_set)
self._year = year
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._image_set = image_set
self._data_path = self._devkit_path + "/images"
self.blacklist = ["staff", 'legerLine']
self.o = OBBAnns(self._devkit_path+'/deepscores_'+image_set+'.json')
self.o.load_annotations()
print(self.o.annotation_sets)
self.o.set_annotation_set_filter(['deepscores'])
self.o.set_class_blacklist(self.blacklist)
self._classes = [v["name"] for (k, v) in self.o.get_cats().items()]
self._class_ids = [k for (k, v) in self.o.get_cats().items()]
self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
self._class_ids_to_ind = dict(list(zip(self._class_ids, list(range(self.num_classes)))))
self._ind_to_class_ids = {v: k for k, v in self._class_ids_to_ind.items()}
self._image_index = self._load_image_set_index()
# self.cat_ids = list(self.o.get_cats().keys())
# self.cat2label = {
# cat_id: i
# for i, cat_id in enumerate(self.cat_ids)
# }
# self.label2cat = {v: k for k, v in self.cat2label.items()}
# self.CLASSES = tuple([v["name"] for (k, v) in self.o.get_cats().items()])
# self.img_ids = [id['id'] for id in self.o.img_info]
self._image_ext = '.png'
# Default to roidb handler
self._roidb_handler = self.gt_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None}
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'voc_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'VOC' + self._year)
# if not set_classes, set in here
if self._classes == []:
self._classes = (
'__background__', # always index 0,'player','football',
# 'pillar')
'Croissant',
'Pineapple',
'Coconut',
'Cheese',
'Baguette',
'Walnut',
'PorkFloss'
) #'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
# '0','1','2','3',
# '4','5','6','7','8','9')
#'aeroplane', 'bicycle', 'bird', 'boat',
#'bottle', 'bus', 'car', 'cat', 'chair',
#'cow', 'diningtable', 'dog', 'horse',
#'motorbike', 'person', 'pottedplant',
#'sheep', 'sofa', 'train', 'tvmonitor')
self._class_to_ind = dict(
zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_instances_ann_file())
self._image_index = self._load_image_set_index()
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._class_to_coco_cat_id = dict(
zip([c['name'] for c in cats], self._COCO.getCatIds()))
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014': 'val2014', # 5k val2014 subset
'valminusminival2014': 'val2014', # val2014 \setminus minival2014
}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if self._view_map.has_key(coco_name) else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
self._roidb = self.gt_roidb()
self.filter_roidb()
file_path = osp.join(
self._data_path,
self._image_set + self._year + '_filtered_persons.txt')
assert osp.exists(file_path), 'Path does not exist: {}'.format(
file_path)
self._cand_objs = set(np.loadtxt(file_path, dtype=str))
if cfg.TRAIN.USE_FLIPPED:
print 'Appending horizontally-flipped examples...'
self.append_flipped_images()
print 'done'
self.permute_roidb_indices()
print('roidb entries: {}'.format(len(self._roidb)))
self._objdb = self.gt_objdb()
self.permute_objdb_indices()
print('objdb entries: {}'.format(len(self._objdb)))
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, 'FDDB_' + image_set)
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path)
self._classes = (
'__background__', # always index 0
'face')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# 32202 images and 393703 faces
print 'fddb image size = {}'.format(len(self._image_index))
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, 'sun_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._anno_set_dir = image_set
if "val" in image_set:
if "val1" in image_set:
self._anno_set_dir = "val1"
if "val2" in image_set:
self._anno_set_dir = "val2"
elif "train" in image_set:
self._anno_set_dir = "train"
elif "test" in image_set:
self._anno_set_dir = "test"
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'SUN' + self._year)
self._classes = (
'__background__', # always index 0
'person')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
self._image_path = os.path.join(self._data_path, 'JPEGImages',
'{}' + self._image_ext)
self.dataset_name = "sun" # for index class
# SUN specific config options
self.config = {
'cleanup': True,
'use_salt': False,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2,
'only_people': True
}
assert os.path.exists(self._devkit_path), \
'SUN path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
# COCO specific config options
self.config = {'use_salt': True, 'cleanup': True}
# name, paths
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'simulated')
# load COCO API, classes, class <-> id mappings
if image_set == 'train':
# self._COCO = COCO('/home/tony/datasets/simulated_data/annotations/train.json')
self._COCO = COCO(
osp.join(self._data_path, 'annotations', 'train.json'))
else:
# self._COCO = COCO('/home/tony/datasets/simulated_data/annotations/test.json')
self._COCO = COCO(
osp.join(self._data_path, 'annotations', 'test.json'))
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._class_to_coco_cat_id = dict(
list(zip([c['name'] for c in cats], self._COCO.getCatIds())))
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('gt')
self.competition_mode(False)
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
# self._view_map = {
# 'minival2014': 'val2014', # 5k val2014 subset
# 'valminusminival2014': 'val2014', # val2014 \setminus minival2014
# 'test-dev2015': 'test2015',
# 'valminuscapval2014': 'val2014',
# 'capval2014': 'val2014',
# 'captest2014': 'val2014'
# }
# coco_name = image_set + year # e.g., "val2014"
# self._data_name = (self._view_map[coco_name]
# if coco_name in self._view_map
# else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
if image_set == 'train':
self._data_name = 'simulated2020'
else:
self._data_name = 'unseen_simulated2020'
self._gt_splits = ('train', 'val', 'minival')
def __init__(self, version, image_set, ):
imdb.__init__(self, 'vg_' + version + '_' + image_set)
self._version = version
self._image_set = image_set
self._data_path = os.path.join(cfg.DATA_DIR, 'genome')
self._img_path = os.path.join(cfg.DATA_DIR, 'vg')
# VG specific config options
self.config = {'cleanup' : False}
# Load classes
self._classes = ['__background__']
self._class_to_ind = {}
self._class_to_ind[self._classes[0]] = 0
with open(os.path.join(self._data_path, self._version, 'objects_vocab.txt')) as f:
count = 1
for object in f.readlines():
names = [n.lower().strip() for n in object.split(',')]
self._classes.append(names[0])
for n in names:
self._class_to_ind[n] = count
count += 1
# Load attributes
self._attributes = ['__no_attribute__']
self._attribute_to_ind = {}
self._attribute_to_ind[self._attributes[0]] = 0
with open(os.path.join(self._data_path, self._version, 'attributes_vocab.txt')) as f:
count = 1
for att in f.readlines():
names = [n.lower().strip() for n in att.split(',')]
self._attributes.append(names[0])
for n in names:
self._attribute_to_ind[n] = count
count += 1
# Load relations
self._relations = ['__no_relation__']
self._relation_to_ind = {}
self._relation_to_ind[self._relations[0]] = 0
with open(os.path.join(self._data_path, self._version, 'relations_vocab.txt')) as f:
count = 1
for rel in f.readlines():
names = [n.lower().strip() for n in rel.split(',')]
self._relations.append(names[0])
for n in names:
self._relation_to_ind[n] = count
count += 1
self._image_ext = '.jpg'
self._image_index, self._id_to_dir = self._load_image_set_index()
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, 'kitti_' + '_' + image_set)
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None else devkit_path
self._data_path = os.path.join(self._devkit_path, 'data_object_image_2/training/image_2')
self._classes = ('__background__','Car', 'Van', 'Truck', 'Cyclist','Pedestrian', 'Person_sitting', 'Tram', 'Misc' ,'DontCare')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
assert os.path.exists(self._devkit_path), 'Kitti path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), 'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, 'ir_' + image_set)
self._year = 0
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'ir')
## COCO CLASSES ##
#self._classes =('__background__',
# 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
# 'bus','train', 'truck', 'boat', 'traffic light',
# 'fire hydrant', 'stop sign', 'parking meter','bench', 'bird',
# 'cat', 'dog', 'horse', 'sheep', 'cow',
# 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
# 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
# 'skis', 'snowboard', 'sports ball', 'kite','baseball bat',
# 'baseball glove', 'skateboard', 'surfboard', 'tennis racket', 'bottle',
# 'wine glass', 'cup', 'fork', 'knife', 'spoon',
# 'bowl', 'banana', 'apple', 'sandwich', 'orange',
# 'broccoli','carrot', 'hot dog', 'pizza', 'donut',
# 'cake', 'chair', 'couch', 'potted plant', 'bed',
# 'dining table','toilet', 'tv', 'laptop', 'mouse',
# 'remote', 'keyboard', 'cell phone', 'microwave', 'oven',
# 'toaster', 'sink', 'refrigerator', 'book', 'clock',
# 'vase', 'scissors', 'teddy bear', 'hair drier','toothbrush')
self._classes = ('__background__', 'tv')
#self._classes = ('__background__', 'tv')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'IR devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self):
imdb.__init__(self, 'coco21trainval_voc0712trainval')
self.data_root = '/home/prmct/Database/'
self.imageset_root = '/home/prmct/Database/MSCOCO/annotations/'
self.source = 'coco21trainval_voc0712trainval_image2xml.txt'
self.img_set = 'coco21trainval_voc0712trainval.txt'
assert os.path.exists(self.data_root), \
'Data root path does not exist: {}'.format(self.data_root)
assert os.path.exists(self.imageset_root), \
'Image set root path does not exist: {}'.format(self.imageset_root)
self._classes = (
'__background__', # always index 0
'aeroplane',
'bicycle',
'bird',
'boat',
'bottle',
'bus',
'car',
'cat',
'chair',
'cow',
'diningtable',
'dog',
'horse',
'motorbike',
'person',
'pottedplant',
'sheep',
'sofa',
'train',
'tvmonitor')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_index = self._load_image_set_index
self.image_path_list = []
self.xml_path_list = []
self._load_image_xml_path()
self._roidb_handler = self.gt_roidb
self.config = {
'cleanup': False,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
def __init__(self, datasetName, cls_order, cls_mapper=None, sets="train"):
name = "openImages_v4"
#FOR DEBUGGING
self.debugging = True
self.sets = sets
imdb.__init__(self, name)
self._data_path = '/root/data/data-openImages_v4'
#CLS_mapper,labelList = self.parseConfig()
print cls_order
if cls_mapper == None:
tempMapper = {}
for i in cls_order:
tempMapper[i] = i
cls_mapper = tempMapper
print cls_mapper
self.CLS_mapper = cls_mapper
namedAnnotation, annotation, target_imgs = self.getAnnotation(
cls_order, cls_mapper, sets)
tempClass = []
for i in cls_order:
if cls_mapper.has_key(i):
if cls_mapper.get(i) not in tempClass:
tempClass.append(cls_mapper.get(i))
elif i not in tempClass:
tempClass.append(i)
self._classes = tempClass
self._num_classes = len(tempClass)
self._annotation = annotation
self._class_to_ind = dict(zip(self._classes,
xrange(self._num_classes)))
self.original_classes = self.get_original_classes()
meta_data_path = os.path.join(self._data_path, "meta.json")
self._meta = load_meta(meta_data_path)
self._image_ext = self._meta["format"]
self._image_ext = '.jpg'
self._image_index = target_imgs
self._imageSizeMap = self._mappedImgSize()
print "images set loaded"
def __init__(self, image_set):
name = "learnit_db" + "_" + image_set
imdb.__init__(self, name)
self._classes = (
'__background__', # always index 0
'box')
self._data_path = os.path.join(cfg.DATA_DIR, 'learnit_db')
self._class_to_ind = dict(
list(zip(self.classes, list(range(self.num_classes)))))
self._image_set = image_set
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
self._image_ext = '.jpg'
def __init__(self, image_set, devkit_path):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = os.path.join(self._devkit_path, 'data')
self._classes = (
'__background__', # always index 0
'Basketball',
'Biking',
'CricketBowling',
'Fencing',
'GolfSwing',
'IceDancing',
'PoleVault',
'SalsaSpin',
'Skiing',
'SoccerJuggling',
'TennisSwing',
'VolleyballSpiking',
'BasketballDunk',
'CliffDiving',
'Diving',
'FloorGymnastics',
'HorseRiding',
'LongJump',
'RopeClimbing',
'SkateBoarding',
'Skijet',
'Surfing',
'TrampolineJumping',
'WalkingWithDog')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# Specific config options
self.config = {
'cleanup': True,
'use_salt': True,
'top_k': 2000,
'use_diff': False,
'rpn_file': None
}
assert os.path.exists(self._devkit_path), \
'Devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, 'celeba_' + image_set)
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join(self._devkit_path, 'CelebA')
self._classes = (
'__background__', # always index 0
'eye',
'nose',
'mouth',
'upper',
'lower',
'face')
self._face_attributes_name = (
'5_o_Clock_Shadow', 'Arched_Eyebrows', 'Attractive',
'Bags_Under_Eyes', 'Bald', 'Bangs', 'Big_Lips', 'Big_Nose',
'Black_Hair', 'Blond_Hair', 'Blurry', 'Brown_Hair',
'Bushy_Eyebrows', 'Chubby', 'Double_Chin', 'Eyeglasses', 'Goatee',
'Gray_Hair', 'Heavy_Makeup', 'High_Cheekbones', 'Male',
'Mouth_Slightly_Open', 'Mustache', 'Narrow_Eyes', 'No_Beard',
'Oval_Face', 'Pale_Skin', 'Pointy_Nose', 'Receding_Hairline',
'Rosy_Cheeks', 'Sideburns', 'Smiling', 'Straight_Hair',
'Wavy_Hair', 'Wearing_Earrings', 'Wearing_Hat', 'Wearing_Lipstick',
'Wearing_Necklace', 'Wearing_Necktie', 'Young')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
# PASCAL specific config options
# min_size here means the minimum size of the boxes to keep
# cleanup means whether to clean up the voc results file or not
self.config = {
'cleanup': False,
'use_salt': True,
'use_diff': False,
'matlab_eval': False,
'rpn_file': None,
'min_size': 2
}
assert os.path.exists(self._devkit_path), \
'CelebAdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, year):
imdb.__init__(self, 'coco_' + year + '_' + image_set)
self._year = year
self._image_set = image_set
self._data_path = osp.join(cfg.DATA_DIR, 'coco')
# load COCO API, classes, class <-> id mappings
self._COCO = COCO(self._get_instances_ann_file())
self._image_index = self._load_image_set_index()
cats = self._COCO.loadCats(self._COCO.getCatIds())
self._classes = tuple(['__background__'] + [c['name'] for c in cats])
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._class_to_coco_cat_id = dict(zip([c['name'] for c in cats],
self._COCO.getCatIds()))
# Some image sets are "views" (i.e. subsets) into others.
# For example, minival2014 is a random 5000 image subset of val2014.
# This mapping tells us where the view's images and proposals come from.
self._view_map = {
'minival2014' : 'val2014', # 5k val2014 subset
'valminusminival2014' : 'val2014', # val2014 \setminus minival2014
}
coco_name = image_set + year # e.g., "val2014"
self._data_name = (self._view_map[coco_name]
if self._view_map.has_key(coco_name)
else coco_name)
# Dataset splits that have ground-truth annotations (test splits
# do not have gt annotations)
self._gt_splits = ('train', 'val', 'minival')
self._roidb = self.gt_roidb()
self.filter_roidb()
file_path = osp.join(self._data_path, self._image_set+self._year+'_filtered_persons.txt')
assert osp.exists(file_path), 'Path does not exist: {}'.format(file_path)
self._cand_objs = set(np.loadtxt(file_path, dtype=str))
if cfg.TRAIN.USE_FLIPPED:
print 'Appending horizontally-flipped examples...'
self.append_flipped_images()
print 'done'
self.permute_roidb_indices()
print('roidb entries: {}'.format(len(self._roidb)))
self._objdb = self.gt_objdb()
self.permute_objdb_indices()
print('objdb entries: {}'.format(len(self._objdb)))
def __init__(self, image_set, year, devkit_path=None):
imdb.__init__(self, "voc_" + year + "_" + image_set)
self._year = year
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None else devkit_path
self._data_path = os.path.join(self._devkit_path, "VOC" + self._year)
self._classes = (
"__background__", # always index 0
"aeroplane",
"bicycle",
"bird",
"boat",
"bottle",
"bus",
"car",
"cat",
"chair",
"cow",
"diningtable",
"dog",
"horse",
"motorbike",
"person",
"pottedplant",
"sheep",
"sofa",
"train",
"tvmonitor",
)
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = ".jpg"
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = "comp4"
# PASCAL specific config options
self.config = {
"cleanup": True,
"use_salt": True,
"use_diff": False,
"matlab_eval": False,
"rpn_file": None,
"min_size": 2,
}
assert os.path.exists(self._devkit_path), "VOCdevkit path does not exist: {}".format(self._devkit_path)
assert os.path.exists(self._data_path), "Path does not exist: {}".format(self._data_path)
def __init__(self, image_set, devkit_path=None):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path2 = '/media/dey/debidatd/pascal3d/PASCAL/VOCdevkit/'
self._devkit_path = '/media/dey/debidatd/pascal3d/'
self._data_path = '/media/dey/debidatd/pascal3d/Images/'#os.path.join(self._devkit_path, 'data')
self._classes = ('__background__', # always index 0
'aeroplane',
'bicycle',
'boat',
'bottle',
'bus',
'car',
'chair',
'diningtable',
'motorbike',
'sofa',
'train',
'tvmonitor')
#self._classes = ['__background__']
#for i in xrange(1,len(self._pseudo_classes)):
# for j in xrange(24):
# self._classes.append(self._pseudo_classes[i]+'_'+str(j))
#self._classes = tuple(self._classes)
#self._classes = ('__background__', # always index 0
# 'aeroplane', 'bicycle', 'bird', 'boat',
# 'bottle', 'bus', 'car', 'cat', 'chair',
# 'cow', 'diningtable', 'dog', 'horse',
# 'motorbike', 'person', 'pottedplant',
# 'sheep', 'sofa', 'train', 'tvmonitor' )
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
self._comp_id = 'comp4'
self._year = '2012'
# PASCAL specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
assert os.path.exists(self._devkit_path), \
'Devkit path does not exist: {}'.format(self._devkit_path)
def __init__(self, image_set, devkit_path, data_path):
imdb.__init__(self, image_set)
self._image_set = image_set
self._devkit_path = devkit_path
self._data_path = data_path
synsets_image = sio.loadmat(os.path.join(self._devkit_path, 'data', 'meta_det.mat'))
synsets_video = sio.loadmat(os.path.join(self._devkit_path, 'data', 'meta_vid.mat'))
self._classes_image = ('__background__',)
self._wnid_image = (0,)
self._classes = ('__background__',)
self._wnid = (0,)
for i in xrange(200):
self._classes_image = self._classes_image + (synsets_image['synsets'][0][i][2][0],)
self._wnid_image = self._wnid_image + (synsets_image['synsets'][0][i][1][0],)
for i in xrange(30):
self._classes = self._classes + (synsets_video['synsets'][0][i][2][0],)
self._wnid = self._wnid + (synsets_video['synsets'][0][i][1][0],)
self._wnid_to_ind_image = dict(zip(self._wnid_image, xrange(201)))
self._class_to_ind_image = dict(zip(self._classes_image, xrange(201)))
self._wnid_to_ind = dict(zip(self._wnid, xrange(31)))
self._class_to_ind = dict(zip(self._classes, xrange(31)))
#check for valid intersection between video and image classes
self._valid_image_flag = [0]*201
for i in range(1,201):
if self._wnid_image[i] in self._wnid_to_ind:
self._valid_image_flag[i] = 1
self._image_ext = ['.JPEG']
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
# Specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'top_k' : 2000}
assert os.path.exists(self._devkit_path), 'Devkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), 'Path does not exist: {}'.format(self._data_path)
def __init__(self, split, wider_path=None):
self._test_flag = True if split == 'test' else False
self._split = split
imdb.__init__(self, 'wider_' + split)
self._image_set = split
self._annotation_file_name = 'wider_face_test_filelist.txt' if self._test_flag else \
'wider_face_{}_bbx_gt.txt'.format(split)
if wider_path is None:
self._dataset_path = self._get_default_path()
else:
self._dataset_path = wider_path
self._imgs_path = os.path.join(self._dataset_path, 'WIDER_{}'.format(split), 'images')
# Read the annotations file
anno_path = os.path.join(self._dataset_path,'wider_face_split',self._annotation_file_name)
assert os.path.isfile(anno_path), 'Annotation file not found {}'.format(anno_path)
self._fp_bbox_map = {}
with open(anno_path, 'r') as file:
annos = file.readlines()
self._fp_bbox_map = {}
count = 0
if not self._test_flag:
while count < len(annos):
name = str(annos[count]).rstrip()
self._fp_bbox_map[name] = []
count += 1
n_anno = int(annos[count])
for i in xrange(n_anno):
count += 1
bbox = annos[count].split(' ')[0:4]
bbox = [int(round(float(x))) for x in bbox]
x1 = max(0, bbox[0])
y1 = max(0, bbox[1])
self._fp_bbox_map[name].append([x1, y1, x1 + bbox[2], y1 + bbox[3]])
count += 1
self._image_paths = self._fp_bbox_map.keys()
else:
self._image_paths = []
for path in annos:
self._image_paths.append(str(path).rstrip())
self._image_index = range(len(self._image_paths))
self._classes = ['bg', 'face']
def __init__(self, image_set, kitti_path=None):
imdb.__init__(self, 'kitti_' + image_set)
self._image_set = image_set
self._kitti_path = self._get_default_path() if kitti_path is None \
else kitti_path
self._data_path = os.path.join(self._kitti_path, 'data_object_image_2')
self._classes = ('__background__', 'Pedestrian', 'Car', 'Cyclist')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.png'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.gt_roidb
assert os.path.exists(self._kitti_path), \
'KITTI path does not exist: {}'.format(self._kitti_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, version, image_set, devkit_path="caltech-pedestrian-dataset-converter"):
imdb.__init__(self,'caltech_pedestrian_' + image_set)
self.version = version
self.config = {"include_all_classes":False, "include_background": False}
self._image_set = image_set
self._devkit_path = self._get_default_path() if devkit_path is None \
else devkit_path
self._data_path = os.path.join("data",self._devkit_path, 'data')
self._classes = ('__background__', # always index 0
'person')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
annotation_path = os.path.join(self._data_path, "annotations.json")
assert os.path.exists(annotation_path), \
'Annotation path does not exist.: {}'.format(annotation_path)
self._annotation = json.load(open(annotation_path))
self._image_ext = '.jpg'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self._roidb_handler = self.selective_search_roidb
self._salt = str(uuid.uuid4())
#
'''
# Caltech Pedestrain specific config options
self.config = {'cleanup' : True,
'use_salt' : True,
'use_diff' : False,
'matlab_eval' : False,
'rpn_file' : None,
'min_size' : 2}
'''
#not usre if I should keep this line
#assert os.path.exists(self._devkit_path), \
# 'VOCdevkit path does not exist: {}'.format(self._devkit_path)
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
def __init__(self, image_set, data_path):
imdb.__init__(self, str(image_set))
self._image_set = image_set
self._data_path = data_path
self._classes = ('__background__', # always index 0
'TrafficSign', 'TrafficLight', 'StreetNumber', 'StreetName', 'BusinessName', 'StreetNumberRange', 'SecondaryUnitDesignator', 'None')
self._class_to_ind = dict(zip(self.classes, xrange(self.num_classes)))
self._image_ext = '.jpg'
self._label_ext = '_labeled.xml'
self._image_index = self._load_image_set_index()
# Default to roidb handler
self.set_proposal_method('selective_search')
self.competition_mode(False)
# Put any IEI-specific config options here
self.config = {'cleanup': True}
assert os.path.exists(self._data_path), \
'Path does not exist: {}'.format(self._data_path)
