def store_data_source(self, hdf5_handler, data, set_name):
"""
Store classes + filenames as a nested tree.
"""
# progress bar
if self.verbose:
prgbar = progressbar.ProgressBar(max_value=len(data)).start()
counter = 0
sourceg = hdf5_handler.create_group('source/' + set_name)
# cycle all classes from the data with the original annotations
for cname in data:
images_filenames = [os.path.join(set_name, cname, fname) for fname in data[cname]]
images_filenames.sort()
hdf5_write_data(sourceg, cname + '/' + 'image_filenames',
str2ascii(images_filenames), dtype=np.uint8, fillvalue=0)
# update progress bar
if self.verbose:
counter += 1
prgbar.update(counter)
# force progressbar to 100%
if self.verbose:
prgbar.finish()
def add_data_to_default(self, hdf5_handler, data, set_name):
"""
Add data of a set to the default group.
"""
image_filenames = []
keypoints = []
object_id = []
object_fields = ["image_filenames", "keypoints"]
if self.verbose:
print('> Adding data to default group:')
prgbar = progressbar.ProgressBar(max_value=len(data))
for i, annot in enumerate(data):
image_filenames.append(annot["filename"])
keypoints.append(annot["joints"])
object_id.append([i, i])
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
hdf5_write_data(hdf5_handler,
'image_filenames',
str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'keypoints',
np.array(keypoints, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'keypoint_names',
str2ascii(self.keypoints_labels),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0)
def add_data_to_source(self, hdf5_handler, data, set_name=None):
"""
Store data annotations in a nested tree fashion.
It closely follows the tree structure of the data.
"""
hdf5_write_data(hdf5_handler,
'images',
data["images"],
dtype=np.uint8,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'labels',
data["labels"],
dtype=np.uint8,
fillvalue=0)
def process_set_metadata(self, data, set_name):
"""
Saves the metadata of a set.
"""
hdf5_handler = self.hdf5_manager.get_group(set_name)
data_array = self.convert_data_to_arrays(data)
hdf5_write_data(hdf5_handler,
'activities',
data_array["activities"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'videos',
data_array["videos"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'image_filenames',
data_array["image_filenames"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'boxes',
data_array["boxes"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_ids',
data_array["object_ids"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
data_array["object_fields"],
dtype=np.uint8,
fillvalue=0)
pad_value = -1
hdf5_write_data(hdf5_handler,
'list_object_ids_per_video',
data_array["list_object_ids_per_video"],
dtype=np.int32,
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_filenames_per_video',
data_array["list_filenames_per_video"],
dtype=np.int32,
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_boxes_per_video',
data_array["list_boxes_per_video"],
dtype=np.int32,
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_videos_per_activity',
data_array["list_videos_per_activity"],
dtype=np.int32,
fillvalue=pad_value)
def add_data_to_default(self, hdf5_handler, data, set_name=None):
"""
Add data of a set to the default group.
For each field, the data is organized into a single big matrix.
"""
data_array = self.convert_data_to_arrays(data, set_name)
hdf5_write_data(hdf5_handler, 'image_filenames',
data_array["image_filenames"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'classes', data_array["classes"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'labels', data_array["labels"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'descriptions',
data_array["descriptions"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'object_ids',
data_array["object_ids"], dtype=np.int32, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_fields',
data_array["object_fields"], dtype=np.uint8, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'list_image_filenames_per_class',
data_array["list_image_filenames_per_class"], dtype=np.int32, fillvalue=-1)
def process_set_metadata(self, data, set_name):
"""
Saves the metadata of a set.
"""
hdf5_handler = self.hdf5_manager.get_group(set_name)
image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])
if "test" in set_name:
is_test = True
data_ = data[0]
filename_ids = data[1]
annotations = data[2]
category = data[3]
supercategory = data[4]
category_id = data[5]
else:
is_test = False
data_ = data[0]
annotations = data[1]
image_filenames = []
width = []
height = []
coco_urls = []
image_id = []
caption = []
object_id = []
# coco id lists
# These are order by entry like in the annotation files.
# I.e., coco_images_ids[0] has the object_id with the file_name, id, height, etc.
# as coco_annotation_file[set_name]["images"][0]
coco_images_ids = []
coco_categories_ids = []
if is_test:
object_fields = ["image_filenames", "coco_urls", "width", "height"]
else:
object_fields = ["image_filenames", "coco_urls", "width", "height", "captions"]
list_captions_per_image = []
list_object_ids_per_image = []
if self.verbose:
print('> Adding data to default group:')
prgbar = progressbar.ProgressBar(max_value=len(data_))
counter = 0
for i, key in enumerate(data_):
annotation = data_[key]
image_filenames.append(annotation["file_name"])
width.append(annotation["width"])
height.append(annotation["height"])
coco_urls.append(annotation["coco_url"])
image_id.append(annotation["id"])
if is_test:
object_id.append([i, i, i, i])
list_object_ids_per_image.append([i])
else:
captions_per_image = []
for cap in annotation["captions"]:
caption.append(cap)
# object_id
# [filename, caption, width, height]
object_id.append([i, i, i, i, counter])
captions_per_image.append(counter)
# update counter
counter += 1
list_captions_per_image.append(captions_per_image)
list_object_ids_per_image.append(captions_per_image)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
# set coco id lists
if self.verbose:
print('> Processing coco lists:')
prgbar = progressbar.ProgressBar(max_value=len(annotations['images']))
for i, annot in enumerate(annotations['images']):
fname_id = image_filenames.index(os.path.join(image_dir, annot['file_name']))
coco_images_ids.append(fname_id)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
if is_test:
coco_categories_ids = list(range(len(category)))
hdf5_write_data(hdf5_handler, 'image_filenames',
str2ascii(image_filenames), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'coco_urls',
str2ascii(coco_urls), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'width',
np.array(width, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'height',
np.array(height, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'image_id',
np.array(image_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'coco_images_ids',
np.array(coco_images_ids, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_fields',
str2ascii(object_fields), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'list_object_ids_per_image',
np.array(pad_list(list_object_ids_per_image, -1), dtype=np.int32),
fillvalue=-1)
if not is_test:
hdf5_write_data(hdf5_handler, 'captions',
str2ascii(caption), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'list_captions_per_image',
np.array(pad_list(list_captions_per_image, -1), dtype=np.int32),
fillvalue=-1)
else:
hdf5_write_data(hdf5_handler, 'category',
str2ascii(category), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'supercategory',
str2ascii(supercategory), dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler, 'coco_categories_ids',
np.array(coco_categories_ids, dtype=np.int32),
fillvalue=-1)
def add_data_to_default(self, hdf5_handler, data, set_name):
"""
Add data of a set to the default file.
"""
object_fields = ['image_filenames', 'classes', 'boxes', 'boxesv', 'id', 'occlusion']
image_filenames = []
bbox = []
bboxv = []
lbl_id = []
occlusion = []
object_id = []
list_image_filenames_per_class = []
list_boxes_per_image = []
list_boxesv_per_image = []
list_object_ids_per_image = []
list_objects_ids_per_class = []
# list_objects_ids_per_id = []
# list_objects_ids_per_occlusion= []
if self.verbose:
print('> Adding data to default file...')
prgbar = progressbar.ProgressBar(max_value=len(data))
img_counter = 0
obj_counter = 0
for i, set_data in enumerate(sorted(data)):
for video in sorted(data[set_data]):
img_fnames = data[set_data][video]["images"]
annot_fnames = data[set_data][video]["annotations"]
# cycle all images + annotations
for j in range(0, len(img_fnames)):
# add image filename
image_filenames.append(img_fnames[j])
# load annotation file
annotation = load_json(annot_fnames[j])
obj_per_img = []
if any(annotation):
for obj in annotation:
# convert [x,y,w,h] to [xmin,ymin,xmax,ymax]
# discard any bbox smaller than 5px wide/high
if obj['pos'][2] >= 5 and obj['pos'][3] >= 5:
bb_correct_format = [obj['pos'][0],
obj['pos'][1],
obj['pos'][0] + obj['pos'][2] - 1,
obj['pos'][1] + obj['pos'][3] - 1]
bbox.append(bb_correct_format)
if isinstance(obj['posv'], list):
# convert [x,y,w,h] to [xmin,ymin,xmax,ymax]
bbv_correct_format = [obj['posv'][0],
obj['posv'][1],
obj['posv'][0] + obj['posv'][2] - 1,
obj['posv'][1] + obj['posv'][3] - 1]
bboxv.append(bbv_correct_format)
else:
bboxv.append([0, 0, 0, 0])
if isinstance(obj['id'], int):
lbl_id.append(obj['id'])
else:
lbl_id.append(0)
occlusion.append(obj['occl'])
class_lbl = self.classes.index(obj['lbl'])
# img, class, bbox, bboxv, id, occlusion
object_id.append([img_counter, class_lbl, obj_counter,
obj_counter, obj_counter, obj_counter])
obj_per_img.append(obj_counter)
# increment counter
obj_counter += 1
# add to lists
list_boxes_per_image.append(obj_per_img)
list_boxesv_per_image.append(obj_per_img)
list_object_ids_per_image.append(obj_per_img)
# increment counter
img_counter += 1
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
if self.verbose:
print('> Processing lists...')
# Process lists
for i in range(len(self.classes)):
imgs_per_class = [val[0] for j, val in enumerate(object_id) if val[1] == i]
imgs_per_class = list(set(imgs_per_class)) # get unique values
imgs_per_class.sort()
list_image_filenames_per_class.append(imgs_per_class)
for i in range(len(self.classes)):
objs_per_class = [j for j, val in enumerate(object_id) if val[1] == i]
objs_per_class = list(set(objs_per_class)) # get unique values
objs_per_class.sort()
list_objects_ids_per_class.append(objs_per_class)
# add data to hdf5 file
hdf5_write_data(hdf5_handler, 'image_filenames', str2ascii(image_filenames),
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'classes', str2ascii(self.classes),
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'boxes', np.array(bbox, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'boxesv', np.array(bboxv, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'id', np.array(lbl_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'occlusion', np.array(occlusion, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_ids', np.array(object_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_fields', str2ascii(object_fields),
dtype=np.uint8, fillvalue=0)
pad_value = -1
hdf5_write_data(hdf5_handler, 'list_image_filenames_per_class',
np.array(pad_list(list_image_filenames_per_class, pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler, 'list_boxes_per_image',
np.array(pad_list(list_boxes_per_image, pad_value), dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler, 'list_boxesv_per_image',
np.array(pad_list(list_boxesv_per_image, pad_value), dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler, 'list_object_ids_per_image',
np.array(pad_list(list_object_ids_per_image, pad_value), dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler, 'list_objects_ids_per_class',
np.array(pad_list(list_objects_ids_per_class, pad_value), dtype=np.int32),
fillvalue=pad_value)
if self.verbose:
print('> Done.')
def add_data_to_default(self, hdf5_handler, data, set_name):
"""
Add data of a set to the default group.
"""
object_fields = [
'image_filenames', 'classes', 'boxes', 'sizes', 'difficult',
'truncated'
]
image_filenames = []
size = []
bbox = []
truncated = [0, 1]
difficult = [0, 1]
object_id = []
obj_id = [] # needed because of ms coco
image_id = [] # needed because of ms coco
category_id = list(range(1, len(self.classes) + 1)) # for mscoco
list_image_filenames_per_class = []
list_boxes_per_image = []
list_object_ids_per_image = []
list_objects_ids_per_class = []
list_objects_ids_no_difficult = []
list_objects_ids_difficult = []
list_objects_ids_no_truncated = []
list_objects_ids_truncated = []
if self.verbose:
print('> Adding data to default group...')
prgbar = progressbar.ProgressBar(max_value=len(data))
# cycle all data files/annotations
obj_counter = 0
for i, data_ in enumerate(data):
image_filename, fileid, annotation = data_
image_filenames.append(image_filename)
image_id.append(fileid)
width = annotation['annotation']['size']['width']
height = annotation['annotation']['size']['height']
depth = annotation['annotation']['size']['depth']
size.append([depth, height, width])
if isinstance(annotation['annotation']['object'], list):
obj_list = annotation['annotation']['object']
else:
obj_list = [annotation['annotation']['object']]
# cycle all objects
for _, obj in enumerate(obj_list):
class_id = self.classes.index(obj['name'])
obj_id.append(obj_counter)
bbox.append([
obj['bndbox']['xmin'], obj['bndbox']['ymin'],
obj['bndbox']['xmax'], obj['bndbox']['ymax']
])
object_id.append([
i, class_id, obj_counter, i,
difficult.index(int(obj['difficult'])),
difficult.index(int(obj['truncated']))
])
# increment counter
obj_counter += 1
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
if self.verbose:
print('> Processing lists...')
# process lists
for i in range(len(self.classes)):
imgs_per_class = [
val[0] for j, val in enumerate(object_id) if val[1] == i
]
imgs_per_class = list(set(imgs_per_class)) # get unique values
imgs_per_class.sort()
list_image_filenames_per_class.append(imgs_per_class)
for i in range(len(image_filenames)):
boxes_per_img = [
val[2] for j, val in enumerate(object_id) if val[0] == i
]
boxes_per_img = list(set(boxes_per_img)) # get unique values
boxes_per_img.sort()
list_boxes_per_image.append(boxes_per_img)
for i in range(len(image_filenames)):
objs_per_img = [
j for j, val in enumerate(object_id) if val[0] == i
]
objs_per_img = list(set(objs_per_img)) # get unique values
objs_per_img.sort()
list_object_ids_per_image.append(objs_per_img)
for i in range(len(self.classes)):
objs_per_class = [
j for j, val in enumerate(object_id) if val[1] == i
]
objs_per_class = list(set(objs_per_class)) # get unique values
objs_per_class.sort()
list_objects_ids_per_class.append(objs_per_class)
objs_no_difficult = [
j for j, val in enumerate(object_id) if val[4] == 0
]
objs_no_difficult.sort()
list_objects_ids_no_difficult = objs_no_difficult
objs_difficult = [j for j, val in enumerate(object_id) if val[4] == 1]
objs_difficult.sort()
list_objects_ids_difficult = objs_difficult
objs_no_truncated = [
j for j, val in enumerate(object_id) if val[5] == 0
]
objs_no_truncated.sort()
list_objects_ids_no_truncated = objs_no_truncated
objs_truncated = [j for j, val in enumerate(object_id) if val[5] == 1]
objs_truncated.sort()
list_objects_ids_truncated = objs_truncated
hdf5_write_data(hdf5_handler,
'image_filenames',
str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'id',
np.array(obj_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'image_id',
np.array(image_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'category_id',
np.array(category_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'sizes',
np.array(size, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'classes',
str2ascii(self.classes),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'boxes',
np.array(bbox, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'truncated',
np.array(truncated, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'difficult',
np.array(difficult, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0)
pad_value = -1
hdf5_write_data(hdf5_handler,
'list_image_filenames_per_class',
np.array(pad_list(list_image_filenames_per_class,
pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_boxes_per_image',
np.array(pad_list(list_boxes_per_image, pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_per_image',
np.array(pad_list(list_object_ids_per_image,
pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_per_class',
np.array(pad_list(list_objects_ids_per_class,
pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_no_difficult',
np.array(list_objects_ids_no_difficult,
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_difficult',
np.array(list_objects_ids_difficult, dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_no_truncated',
np.array(list_objects_ids_no_truncated,
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_object_ids_truncated',
np.array(list_objects_ids_truncated, dtype=np.int32),
fillvalue=pad_value)
def add_data_to_default(self, hdf5_handler, data, set_name=None):
"""
Add data of a set to the default group.
For each field, the data is organized into a single big matrix.
"""
data_array = self.convert_data_to_arrays(data)
hdf5_write_data(hdf5_handler,
'videos',
data_array["videos"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'video_filenames',
data_array["video_filenames"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'activities',
data_array["activities"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'image_filenames',
data_array["image_filenames"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'annotations',
data_array["annotations"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'total_frames',
data_array["total_frames"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_ids',
data_array["object_ids"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
data_array["object_fields"],
dtype=np.uint8,
fillvalue=0)
pad_value = -1
hdf5_write_data(hdf5_handler,
'list_videos_per_activity',
data_array["list_videos_per_activity"],
dtype=np.int32,
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_image_filenames_per_video',
data_array["list_image_filenames_per_video"],
dtype=np.int32,
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_annotations_per_video',
data_array["list_annotations_per_video"],
dtype=np.int32,
fillvalue=pad_value)
def add_data_to_default(self, hdf5_handler, data, set_name=None):
"""
Add data of a set to the default group.
For each field, the data is organized into a single big matrix.
"""
hdf5_write_data(hdf5_handler,
'classes',
data["class_name"],
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'labels',
data["labels"],
dtype=np.uint8,
fillvalue=1)
hdf5_write_data(hdf5_handler,
'images',
data["data"],
dtype=np.uint8,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_ids',
data["object_ids"],
dtype=np.int32,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
data["object_fields"],
dtype=np.uint8,
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'list_images_per_class',
data["list_images_per_class"],
dtype=np.int32,
fillvalue=-1)
def add_data_to_default(self, hdf5_handler, data, set_name):
"""
Add data of a set to the default group.
"""
image_dir = os.path.join(self.data_path, self.image_dir_path[set_name])
if 'test' in set_name:
is_test = True
data_ = data[0]
filename_ids = data[1]
annotations = data[2]
category = data[3]
supercategory = data[4]
category_id = data[5]
else:
is_test = False
data_ = data[0]
annotations = data[1]
annotation_id_dict = data[2]
category = data[3]
supercategory = data[4]
category_id = data[5]
filename_ids = data[6]
images_fname_by_id = data[7]
image_filenames = []
coco_urls = []
width = []
height = []
image_id = []
annotation_id = []
area = []
iscrowd = [0, 1]
segmentation = []
bbox = []
object_id = []
# coco id lists
# These are order by entry like in the annotation files.
# I.e., coco_images_ids[0] has the object_id with the file_name, id, height, etc.
# as coco_annotation_file[set_name]["images"][0]
coco_images_ids = []
coco_categories_ids = []
coco_annotations_ids = []
if is_test:
object_fields = ["image_filenames", "coco_urls", "width", "height"]
else:
object_fields = [
"image_filenames", "coco_urls", "width", "height", "category",
"supercategory", "boxes", "area", "iscrowd", "segmentation",
"image_id", "category_id", "annotation_id"
]
list_image_filenames_per_category = []
list_image_filenames_per_supercategory = []
list_boxes_per_image = []
list_object_ids_per_image = []
list_objects_ids_per_category = []
list_objects_ids_per_supercategory = []
if self.verbose:
print('> Adding data to default group:')
prgbar = progressbar.ProgressBar(max_value=len(data[0]))
counter = 0
segmentation_t1_counter, segmentation_t2_counter = 0, 0
tmp_coco_annotations_ids = {}
for i, fname_idx in enumerate(data_):
# fetch annotation
annotation = data_[fname_idx]
# add fields
image_filenames.append(annotation["file_name"])
width.append(annotation["width"])
height.append(annotation["height"])
coco_urls.append(annotation["coco_url"])
image_id.append(annotation["id"])
if is_test:
# *** object_id ***
# [filename, coco_url, width, height]
object_id.append([i, i, i, i])
list_object_ids_per_image.append([i])
else:
boxes_per_image = []
if "object" in annotation:
for j, obj_idx in enumerate(annotation["object"]):
obj = annotation["object"][obj_idx]
area.append(obj["area"])
bbox.append(obj["bbox"])
annotation_id.append(obj["id"])
segmentation.append(obj["segmentation"])
# *** object_id ***
# [filename, coco_url, width, height,
# category, supercategory,
# bbox, area, iscrowd, segmentation,
# "image_id", "category_id", "annotation_id"]
object_id.append([
i, i, i, i,
category.index(obj["category"]),
supercategory.index(obj["supercategory"]), counter,
counter, obj["iscrowd"], counter, i,
category.index(obj["category"]), counter
])
boxes_per_image.append(counter)
# temporary var
tmp_coco_annotations_ids[obj["id"]] = counter
# update counter
counter += 1
list_boxes_per_image.append(boxes_per_image)
list_object_ids_per_image.append(boxes_per_image)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
if self.verbose:
print('> Processing coco lists:')
prgbar = progressbar.ProgressBar(
max_value=len(annotations['images']))
# set coco id lists
for i, annot in enumerate(annotations['images']):
fname_id = image_filenames.index(
os.path.join(image_dir, annot['file_name']))
coco_images_ids.append(fname_id)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
coco_categories_ids = list(range(len(category)))
if not is_test:
if self.verbose:
prgbar = progressbar.ProgressBar(
max_value=len(annotations['annotations']))
for i, annot in enumerate(annotations['annotations']):
annot_id = tmp_coco_annotations_ids[annot['id']]
coco_annotations_ids.append(annot_id)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
# process lists
if not is_test:
if self.verbose:
print('> Processing lists...')
for i in range(len(category)):
imgs_per_category = [
val[0] for _, val in enumerate(object_id) if val[4] == i
]
imgs_per_category = list(
set(imgs_per_category)) # get unique values
imgs_per_category.sort()
list_image_filenames_per_category.append(imgs_per_category)
for i in range(len(supercategory)):
imgs_per_supercategory = [
val[0] for _, val in enumerate(object_id) if val[5] == i
]
imgs_per_supercategory = list(
set(imgs_per_supercategory)) # get unique values
imgs_per_supercategory.sort()
list_image_filenames_per_supercategory.append(
imgs_per_supercategory)
for i in range(len(category)):
obj_per_category = [
j for j, val in enumerate(object_id) if val[4] == i
]
obj_per_category = list(
set(obj_per_category)) # get unique values
obj_per_category.sort()
list_objects_ids_per_category.append(obj_per_category)
for i in range(len(supercategory)):
obj_per_supercategory = [
j for j, val in enumerate(object_id) if val[5] == i
]
obj_per_supercategory = list(
set(obj_per_supercategory)) # get unique values
obj_per_supercategory.sort()
list_objects_ids_per_supercategory.append(
obj_per_supercategory)
if self.verbose:
print('> Done.')
hdf5_write_data(hdf5_handler,
'image_filenames',
str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'coco_urls',
str2ascii(coco_urls),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'width',
np.array(width, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'height',
np.array(height, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'category',
str2ascii(category),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'supercategory',
str2ascii(supercategory),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'image_id',
np.array(image_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'category_id',
np.array(category_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'object_fields',
str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'coco_images_ids',
np.array(coco_images_ids, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'coco_categories_ids',
np.array(coco_categories_ids, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'list_object_ids_per_image',
np.array(pad_list(list_object_ids_per_image, -1),
dtype=np.int32),
fillvalue=-1)
if not is_test:
hdf5_write_data(hdf5_handler,
'annotation_id',
np.array(annotation_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'boxes',
np.array(bbox, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'iscrowd',
np.array(iscrowd, dtype=np.uint8),
fillvalue=0)
nrows = len(segmentation)
ncols = max([len(l) for l in segmentation])
dset = hdf5_handler.create_dataset('segmentation', (nrows, ncols),
dtype=np.float,
chunks=True,
compression="gzip",
compression_opts=4,
fillvalue=-1)
if self.verbose:
print(
' -- Saving segmentation masks to disk (this will take some time)'
)
prgbar = progressbar.ProgressBar(max_value=nrows)
for i in range(nrows):
dset[i, :len(segmentation[i])] = np.array(segmentation[i],
dtype=np.float)
if self.verbose:
prgbar.update(i)
if self.verbose:
prgbar.finish()
hdf5_write_data(hdf5_handler,
'area',
np.array(area, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'coco_annotations_ids',
np.array(coco_annotations_ids, dtype=np.int32),
fillvalue=-1)
pad_value = -1
hdf5_write_data(hdf5_handler,
'list_image_filenames_per_category',
np.array(pad_list(
list_image_filenames_per_category, pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_image_filenames_per_supercategory',
np.array(pad_list(
list_image_filenames_per_supercategory,
pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_boxes_per_image',
np.array(pad_list(list_boxes_per_image, pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_objects_ids_per_category',
np.array(pad_list(list_objects_ids_per_category,
pad_value),
dtype=np.int32),
fillvalue=pad_value)
hdf5_write_data(hdf5_handler,
'list_objects_ids_per_supercategory',
np.array(pad_list(
list_objects_ids_per_supercategory, pad_value),
dtype=np.int32),
fillvalue=pad_value)
def process_set_metadata(self, data, set_name):
"""
Saves the metadata of a set.
"""
hdf5_handler = self.hdf5_manager.get_group(set_name)
image_filenames = []
width = []
height = []
movienames = []
torso_boxes = []
keypoints = []
object_id = []
object_fields = [
"image_filenames", "torso_boxes", "keypoints", "width", "height"
]
if self.verbose:
print('> Adding data to default group:')
prgbar = progressbar.ProgressBar(max_value=len(data))
for i, annot in enumerate(data):
image_filenames.append(annot["filename"])
movienames.append(annot["moviename"])
width.append(annot["width"])
height.append(annot["height"])
torso_boxes.append(annot["torso_box"])
keypoints.append(annot["parts"])
object_id.append([i, i, i, i, i])
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
hdf5_write_data(hdf5_handler,
'image_filenames',
str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'movienames',
str2ascii(movienames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'width',
np.array(width, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'height',
np.array(height, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'torso_boxes',
np.array(torso_boxes, dtype=np.float).squeeze(),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'keypoints',
np.array(keypoints, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'keypoint_names',
str2ascii(self.keypoints_labels),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'object_fields',
str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=-1)
def add_data_to_default(self, hdf5_handler, data, set_name):
"""
Add data of a set to the default group.
"""
# split list
data_, videonames = data
if set_name == 'test':
is_train = False
else:
is_train = True
image_filenames = []
frame_sec = []
video_idx = []
# single_person_id_list = []
category_name, activity_name, activity_id = [], [], []
scale = []
objpos = [] # [x, y]
head_bbox = []
keypoints = []
object_id = []
if is_train:
object_fields = [
"image_filenames", "scale", "objpos", "head_bbox", "keypoints",
"frame_sec", "video_idx"
]
else:
object_fields = ["image_filenames", "scale", "objpos"]
# adicionar listas
list_object_ids_per_image = []
list_single_person_per_image = []
list_keypoints_per_image = []
if self.verbose:
print('> Adding data to default group:')
prgbar = progressbar.ProgressBar(max_value=len(data_))
obj_per_img_counter = 0
for i, annot in enumerate(data_):
image_filenames.append(annot["image_filename"])
if is_train:
frame_sec.append(annot["frame_sec"])
video_idx.append(annot["video_idx"])
category_name.append(annot["activity"]["cat_name"])
activity_name.append(annot["activity"]["act_name"])
activity_id.append(annot["activity"]["act_id"])
objs_per_image = []
keypoints_per_image = []
single_person_per_image = []
if not any(annot["poses_annotations"]):
if is_train:
if self.is_full:
object_id.append([i, -1, -1, -1, -1, i, i])
objs_per_image.append(
obj_per_img_counter) # add object_id to the list
obj_per_img_counter += 1 # update counter
else:
object_id.append([i, -1, -1])
objs_per_image.append(
obj_per_img_counter) # add object_id to the list
obj_per_img_counter += 1 # update counter
else:
for j, pose_annot in enumerate(annot["poses_annotations"]):
scale.append(pose_annot["scale"])
objpos.append(
[pose_annot["objpos"]["x"], pose_annot["objpos"]["y"]])
if j + 1 in annot["single_person"]:
single_person_per_image.append(obj_per_img_counter)
if is_train:
head_bbox.append([
pose_annot["x1"], pose_annot["y1"],
pose_annot["x2"], pose_annot["y2"]
])
keypoints.append(pose_annot["keypoints"])
object_id.append([
i, obj_per_img_counter, obj_per_img_counter,
obj_per_img_counter, obj_per_img_counter, i, i
])
# add object_id to the keypoint list
keypoints_per_image.append(obj_per_img_counter)
else:
object_id.append(
[i, obj_per_img_counter, obj_per_img_counter])
# add object_id to the list
objs_per_image.append(obj_per_img_counter)
# update counter
obj_per_img_counter += 1
list_object_ids_per_image.append(objs_per_image)
list_single_person_per_image.append(single_person_per_image)
list_keypoints_per_image.append(keypoints_per_image)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
hdf5_write_data(hdf5_handler,
'image_filenames',
str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'scale',
np.array(scale, dtype=np.float),
fillvalue=0)
hdf5_write_data(hdf5_handler,
'objpos',
np.array(objpos, dtype=np.float),
fillvalue=0)
hdf5_write_data(hdf5_handler,
'object_ids',
np.array(object_id, dtype=np.int32),
fillvalue=0)
hdf5_write_data(hdf5_handler,
'object_fields',
str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'video_names',
str2ascii(videonames),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'keypoint_names',
str2ascii(self.keypoints_labels),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'list_object_ids_per_image',
np.array(pad_list(list_object_ids_per_image, -1),
dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'list_single_person_per_image',
np.array(pad_list(list_single_person_per_image, -1),
dtype=np.int32),
fillvalue=-1)
if is_train:
hdf5_write_data(hdf5_handler,
'frame_sec',
np.array(frame_sec, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'video_idx',
np.array(video_idx, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'category_name',
str2ascii(category_name),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'activity_name',
str2ascii(activity_name),
dtype=np.uint8,
fillvalue=0)
hdf5_write_data(hdf5_handler,
'activity_id',
np.array(activity_id, dtype=np.int32),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'head_bbox',
np.array(head_bbox, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'keypoints',
np.array(keypoints, dtype=np.float),
fillvalue=-1)
hdf5_write_data(hdf5_handler,
'list_keypoints_per_image',
np.array(pad_list(list_keypoints_per_image, -1),
dtype=np.int32),
fillvalue=-1)
def process_set_metadata(self, data, set_name):
"""
Saves the metadata of a set.
"""
hdf5_handler = self.hdf5_manager.get_group(set_name)
hdf5_write_data(hdf5_handler, 'activities',
data["activities"],
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'videos',
data["videos"],
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'video_filenames',
data["video_filenames"],
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'image_filenames',
data["image_filenames"],
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'total_frames',
data["total_frames"],
dtype=np.int32, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_ids',
data["object_ids"],
dtype=np.int32, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_fields',
data["object_fields"],
dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'list_videos_per_activity',
data["list_videos_per_activity"],
dtype=np.int32, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'list_image_filenames_per_video',
data["list_image_filenames_per_video"],
dtype=np.int32, fillvalue=-1)
def process_set_metadata(self, data, set_name):
"""
Saves the metadata of a set.
"""
hdf5_handler = self.hdf5_manager.get_group(set_name)
data_array = self.convert_data_to_arrays(data, set_name)
hdf5_write_data(hdf5_handler, 'image_filenames',
data_array["image_filenames"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'classes', data_array["classes"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'labels', data_array["labels"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'descriptions',
data_array["descriptions"], dtype=np.uint8, fillvalue=0)
hdf5_write_data(hdf5_handler, 'object_ids',
data_array["object_ids"], dtype=np.int32, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'object_fields',
data_array["object_fields"], dtype=np.uint8, fillvalue=-1)
hdf5_write_data(hdf5_handler, 'list_image_filenames_per_class',
data_array["list_image_filenames_per_class"], dtype=np.int32, fillvalue=-1)
