def add_data_to_source(self, hdf5_handler, data, set_name):
"""
Store classes + filenames as a nested tree.
"""
if self.verbose:
print('> Adding data to source group:')
prgbar = progressbar.ProgressBar(max_value=len(data))
keypoint_names = str2ascii(self.keypoints_labels)
for i, annot in enumerate(data):
file_grp = hdf5_handler.create_group(str(i))
file_grp['image_filename'] = str2ascii(annot["filename"])
file_grp['moviename'] = str2ascii(annot["moviename"])
file_grp['width'] = np.array(annot["width"], dtype=np.int32)
file_grp['height'] = np.array(annot["height"], dtype=np.int32)
file_grp['keypoint_names'] = keypoint_names
file_grp['torso_box'] = np.array(annot["torso_box"], dtype=np.float)
file_grp['keypoints'] = np.array(annot["parts"], dtype=np.float)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
def add_data_to_source(self, hdf5_handler, data, set_name):
"""
Add data of a set to the source group.
"""
if self.verbose:
print('> Adding data to the source group')
prgbar = progressbar.ProgressBar(max_value=len(data))
# create set group
set_name_grp = hdf5_handler.create_group('source/' + set_name)
for i, set_data in enumerate(sorted(data)):
set_grp = set_name_grp.create_group(set_data)
for video in sorted(data[set_data]):
video_grp = set_grp.create_group(video)
for j in range(len(data[set_data][video]['images'])):
set_data_video = data[set_data][video]
file_grp = video_grp.create_group(str(j))
file_grp['image_filenames'] = str2ascii(set_data_video['images'][j])
file_grp['annotation_filenames'] = str2ascii(set_data_video['annotations'][j])
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
if self.verbose:
prgbar.finish()
def load_data_set(self, is_test):
"""
Fetch train/test data.
"""
# merge the path with the extracted folder name
data_path_ = os.path.join(self.data_path, 'cifar-10-batches-py')
class_names = self.get_class_names(data_path_)
# load test data file
if is_test:
batch = load_pickle(os.path.join(data_path_, self.data_files[6]))
data = batch['data'].reshape(10000, 3, 32, 32)
labels = np.array(batch['labels'], dtype=np.uint8)
else:
batch1 = load_pickle(os.path.join(data_path_, self.data_files[1]))
batch2 = load_pickle(os.path.join(data_path_, self.data_files[2]))
batch3 = load_pickle(os.path.join(data_path_, self.data_files[3]))
batch4 = load_pickle(os.path.join(data_path_, self.data_files[4]))
batch5 = load_pickle(os.path.join(data_path_, self.data_files[5]))
# concatenate data
data = np.concatenate(
(batch1['data'], batch2['data'], batch3['data'],
batch4['data'], batch5['data']),
axis=0,
)
data = data.reshape((50000, 3, 32, 32))
labels = np.concatenate(
(batch1['labels'], batch2['labels'], batch3['labels'],
batch4['labels'], batch5['labels']),
axis=0,
)
data = np.transpose(data, (0, 2, 3, 1)) # NxHxWxC
object_list = self.get_object_list(data, labels)
# organize list of image indexes per class
images_per_class = []
unique_labels = np.unique(labels)
for label in unique_labels:
images_idx = np.where(labels == label)[0].tolist()
images_per_class.append(images_idx)
return {
"object_fields":
str2ascii(['images', 'classes']),
"class_name":
str2ascii(class_names['label_names']),
"data":
data,
"labels":
labels,
"object_ids":
object_list,
"list_images_per_class":
np.array(pad_list(images_per_class, 1), dtype=np.int32)
}
def load_data_set(self, is_test):
"""
Load train/test data.
"""
# merge the path with the extracted folder name
data_path_ = os.path.join(self.data_path, 'cifar-100-python')
# load classes name file
class_names = self.get_class_names(data_path_)
# load test data file
if is_test:
batch = load_pickle(os.path.join(data_path_, self.data_files[2]))
data = batch['data'].reshape(10000, 3, 32, 32)
else:
batch = load_pickle(os.path.join(data_path_, self.data_files[1]))
data = batch['data'].reshape(50000, 3, 32, 32)
data = np.transpose(data, (0, 2, 3, 1)) # NxHxWxC
labels = np.array(batch['fine_labels'], dtype=np.uint8)
coarse_labels = np.array(batch['coarse_labels'], dtype=np.uint8)
object_list = self.get_object_list(data, labels, coarse_labels)
# organize list of image indexes per class
images_per_class = []
unique_labels = np.unique(labels)
for label in unique_labels:
images_idx = np.where(labels == label)[0].tolist()
images_per_class.append(images_idx)
# organize list of image indexes per superclass
images_per_superclass = []
unique_coarse_labels = np.unique(coarse_labels)
for coarse_label in unique_coarse_labels:
images_idx = np.where(coarse_labels == coarse_label)[0].tolist()
images_per_superclass.append(images_idx)
return {
"object_fields":
str2ascii(['images', 'classes', 'superclasses']),
"data":
data,
"class_name":
str2ascii(self.finer_classes),
"coarse_class_name":
str2ascii(self.coarse_classes),
"labels":
labels,
"coarse_labels":
coarse_labels,
"object_id_list":
object_list,
"list_images_per_class":
np.array(pad_list(images_per_class, 1), dtype=np.int32),
"list_images_per_superclass":
np.array(pad_list(images_per_superclass, 1), dtype=np.int32),
}
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 process(self, classes):
"""Processes and saves the classes metadata to hdf5."""
class_names, class_ids, class_unique_ids = self.get_class_labels_ids(
classes)
self.save_field_to_hdf5(set_name=self.set_name,
field='classes',
data=str2ascii(class_names),
dtype=np.uint8,
fillvalue=0)
self.save_field_to_hdf5(set_name=self.set_name,
field='classes_unique',
data=str2ascii(classes),
dtype=np.uint8,
fillvalue=0)
return class_ids, class_unique_ids
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 process(self):
"""Processes and saves the columns metadata to hdf5."""
self.save_field_to_hdf5(set_name=self.set_name,
field='__COLUMNS__',
data=str2ascii(self.fields),
dtype=np.uint8,
fillvalue=0)
def save_fields_types(self):
columns = [field['type'] for field in self.fields]
self.save_field_to_hdf5(set_name=self.set_name,
field='__TYPES__',
data=str2ascii(columns),
dtype=np.uint8,
fillvalue=0)
def process(self):
"""Processes and saves the labels metadata to hdf5."""
self.save_field_to_hdf5(set_name=self.set_name,
field='object_fields',
data=str2ascii(['images', 'labels']),
dtype=np.uint8,
fillvalue=0)
def load_data_test(self):
"""
Fetch test data.
"""
# files path
fname_test_imgs = os.path.join(self.data_path,
't10k-images.idx3-ubyte')
fname_test_lbls = os.path.join(self.data_path,
't10k-labels.idx1-ubyte')
# read files to memory
test_images = self.load_images_numpy(fname_test_imgs)
test_labels = self.load_labels_numpy(fname_test_lbls)
size_test = 10000
# reshape images
test_data = test_images.reshape(size_test, 28, 28)
# get object_id lists
test_object_list = np.array([[i, test_labels[i]]
for i in range(size_test)])
# classes
classes = str2ascii(self.classes)
# organize list of image indexes per class
test_images_per_class = []
labels = np.unique(test_labels)
for label in labels:
ts_images_idx = np.where(test_labels == label)[0].tolist()
test_images_per_class.append(ts_images_idx)
return {
"classes":
classes,
"images":
test_data,
"labels":
test_labels,
"object_fields":
str2ascii(['images', 'labels']),
"object_ids":
test_object_list,
"list_images_per_class":
np.array(pad_list(test_images_per_class, 1), dtype=np.int32)
}
def process(self):
"""Processes and saves the classes metadata to hdf5."""
class_names = self.get_class_names()
self.save_field_to_hdf5(set_name=self.set_name,
field='classes',
data=str2ascii(class_names),
dtype=np.uint8,
fillvalue=0)
def process(self, video_ids):
"""Processes and saves the video names metadata to hdf5."""
video_names = self.get_video_names(video_ids)
self.save_field_to_hdf5(
set_name=self.set_name,
field='video_name',
data=str2ascii(video_names),
dtype=np.uint8,
fillvalue=0
)
def process(self):
"""Processes and saves the keypoint labels metadata to hdf5."""
keypoint_labels = self.get_keypoint_labels()
self.save_field_to_hdf5(
set_name=self.set_name,
field='keypoint_labels',
data=str2ascii(keypoint_labels),
dtype=np.uint8,
fillvalue=0
)
def process(self):
"""Processes and saves the category names metadata to hdf5."""
category_name = self.get_category_name()
self.save_field_to_hdf5(
set_name=self.set_name,
field='category_name',
data=str2ascii(category_name),
dtype=np.uint8,
fillvalue=0
)
def process(self):
"""Processes and saves the object fields metadata to hdf5."""
object_fields = self.get_object_fields()
self.save_field_to_hdf5(
set_name=self.set_name,
field='object_fields',
data=str2ascii(object_fields),
dtype=np.uint8,
fillvalue=0
)
def process(self):
"""Processes and saves the activity names metadata to hdf5."""
activity_name = self.get_activity_name()
self.save_field_to_hdf5(
set_name=self.set_name,
field='activity_name',
data=str2ascii(activity_name),
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.
"""
for activity in data:
activity_grp = hdf5_handler.create_group(activity)
for video_name in data[activity]:
video_grp = activity_grp.create_group(video_name)
set_data = data[activity][video_name]
video_grp.create_dataset('image_filenames',
data=str2ascii(
set_data['image_filenames']),
dtype=np.uint8)
video_grp.create_dataset('video_filename',
data=str2ascii(
set_data['video_filename']),
dtype=np.uint8)
def convert_data_to_arrays(self, data, set_name):
"""
Convert folders/filenames to arrays.
"""
# load annotations
annotations = self.get_annotations()
# intialize lists
classes = list(data.keys())
classes.sort()
label_list = [annotations[cname]['label'] for _, cname in enumerate(classes)]
description_list = [annotations[cname]['description'] for _, cname in enumerate(classes)]
object_ids = []
filenames = []
list_image_filenames_per_class = []
# cycle all classes
count_fname = 0
for class_id, cname in enumerate(classes):
range_ini = len(filenames)
for filename in data[cname]:
filenames.append(os.path.join(self.data_path, set_name, cname, filename))
object_ids.append([count_fname, class_id])
count_fname += 1
# organize filenames by class id
list_image_filenames_per_class.append(list(range(range_ini, len(filenames))))
# pad list with zeros in order to have all lists of the same size
list_image_filenames_per_class = pad_list(list_image_filenames_per_class, -1)
return {
"classes": str2ascii(classes),
"labels": str2ascii(label_list),
"image_filenames": str2ascii(filenames),
"descriptions": str2ascii(description_list),
"object_fields": str2ascii(['image_filenames', 'classes']),
"object_ids": np.array(object_ids, dtype=np.int32),
"list_image_filenames_per_class": np.array(list_image_filenames_per_class,
dtype=np.int32)
}
def process(self):
"""Processes and saves the image filenames metadata to hdf5."""
image_filenames, image_filename_ids = self.get_image_filenames()
self.save_field_to_hdf5(
set_name=self.set_name,
field='image_filenames',
data=str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0
)
return image_filename_ids
def process(self):
"""Processes and saves the image filenames metadata to hdf5."""
image_filenames_unique = self.get_image_filenames_from_data()
image_filenames_unique_ids = self.get_image_filenames_obj_ids_from_data(
)
image_filenames = [
image_filenames_unique[id] for id in image_filenames_unique_ids
]
self.save_field_to_hdf5(set_name=self.set_name,
field='image_filenames',
data=str2ascii(image_filenames),
dtype=np.uint8,
fillvalue=0)
self.save_field_to_hdf5(set_name=self.set_name,
field='image_filenames_unique',
data=str2ascii(image_filenames_unique),
dtype=np.uint8,
fillvalue=0)
image_filenames_ids = list(range(len(image_filenames_unique_ids)))
return image_filenames_ids, image_filenames_unique_ids
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 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 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_source(self, hdf5_handler, data, set_name):
"""
Store classes + filenames as a nested tree.
"""
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]
annotations = data[2]
else:
is_test = False
data_ = data[0]
annotations = data[1]
if self.verbose:
print('> Adding data to source group...')
if self.verbose:
print('>>> Adding data to group: images')
prgbar = progressbar.ProgressBar(
max_value=len(annotations['images']))
# images - original
image_grp = hdf5_handler.create_group('images')
for i, annot in enumerate(annotations['images']):
file_grp = image_grp.create_group(str(i))
file_grp['file_name'] = str2ascii(
os.path.join(image_dir, annot["file_name"]))
file_grp['coco_url'] = str2ascii(annot["coco_url"])
file_grp['width'] = np.array(annot["width"], dtype=np.int32)
file_grp['height'] = np.array(annot["height"], dtype=np.int32)
file_grp['id'] = np.array(annot["id"], dtype=np.int32)
# update progressbar
if self.verbose:
prgbar.update(i)
if self.verbose:
prgbar.finish()
print('>>> Adding data to group: categories')
prgbar = progressbar.ProgressBar(
max_value=len(annotations['categories']))
# categories - original
cat_grp = hdf5_handler.create_group('categories')
for i, annot in enumerate(annotations['categories']):
file_grp = cat_grp.create_group(str(i))
file_grp['supercategory'] = str2ascii(annot["supercategory"])
file_grp['name'] = str2ascii(annot["name"])
file_grp['id'] = np.array(annot["id"], dtype=np.int32)
# update progressbar
if self.verbose:
prgbar.update(i)
# annotations - original
if not is_test:
if self.verbose:
prgbar.finish()
print('>>> Adding data to group: annotations')
prgbar = progressbar.ProgressBar(
max_value=len(annotations['annotations']))
annot_grp = hdf5_handler.create_group('annotations')
for i, annot in enumerate(annotations['annotations']):
file_grp = annot_grp.create_group(str(i))
file_grp['iscrowd'] = np.array(annot["iscrowd"],
dtype=np.int32)
file_grp['area'] = np.array(annot["area"], dtype=np.float)
file_grp['id'] = np.array(annot["id"], dtype=np.int32)
file_grp['category_id'] = np.array(annot["category_id"],
dtype=np.int32)
file_grp['image_id'] = np.array(annot["image_id"],
dtype=np.int32)
file_grp['bbox'] = np.array(annot["bbox"], dtype=np.float)
file_grp['segmentation'] = np.array(annot["segmentation"],
dtype=np.float)
# update progressbar
if self.verbose:
prgbar.update(i)
if self.verbose:
prgbar.finish()
print('>>> Adding data to group: grouped')
prgbar = progressbar.ProgressBar(max_value=len(data_))
# grouped/combined data - parsed by me
grouped_grp = hdf5_handler.create_group('grouped')
for i, key in enumerate(data_):
file_grp = grouped_grp.create_group(str(i))
file_grp['image_filename'] = str2ascii(data_[key]["file_name"])
file_grp['coco_url'] = str2ascii(data_[key]["coco_url"])
file_grp['width'] = np.array(data_[key]["width"], dtype=np.int32)
file_grp['height'] = np.array(data_[key]["height"], dtype=np.int32)
file_grp['id'] = np.array(data_[key]["id"], dtype=np.int32)
if 'object' in data_[key]:
for j, obj_id in enumerate(data_[key]["object"]):
obj_grp = file_grp.create_group(str(j))
obj = data_[key]["object"][obj_id]
obj_grp['id'] = np.array(obj["id"], dtype=np.int32)
obj_grp['image_id'] = np.array(obj["image_id"],
dtype=np.int32)
obj_grp['category_id'] = np.array(obj["category_id"],
dtype=np.int32)
obj_grp['category'] = str2ascii(obj["category"])
obj_grp['supercategory'] = str2ascii(obj["supercategory"])
obj_grp['area'] = np.array(obj["area"], dtype=np.int32)
obj_grp['iscrowd'] = np.array(obj["iscrowd"],
dtype=np.int32)
obj_grp['bbox'] = np.array(obj["bbox"], dtype=np.float)
obj_grp['segmentation'] = np.array(obj["segmentation"],
dtype=np.float)
# update progressbar
if self.verbose:
prgbar.update(i)
# update progressbar
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.
"""
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 convert_data_to_arrays(self, data):
"""
Convert data to arrays.
"""
# intialize lists
object_ids = []
videos = []
video_filenames = []
image_filenames = []
annotations = []
total_frames = []
list_videos_per_class = {}
list_image_filenames_per_video = []
list_annotations_per_video = []
count_video = 0
for activity_id, activity in enumerate(self.classes):
videos_ordered = list(data[activity].keys())
videos_ordered.sort()
for _, video_name in enumerate(videos_ordered):
img_fnames = data[activity][video_name]['image_filenames']
annot = data[activity][video_name]['image_annotations']
num_imgs = len(img_fnames)
total_frames.append(num_imgs)
videos.append(video_name) # add video name
video_filenames.append(
data[activity][video_name]['video_filename'])
image_filenames = image_filenames + img_fnames
annotations = annotations + annot
# add to list of images per video
total_imgs = len(image_filenames)
list_range = list(range(total_imgs - num_imgs, total_imgs))
list_image_filenames_per_video.append(list_range)
list_annotations_per_video.append(list_range)
# add to list of videos per class
try:
list_videos_per_class[activity_id].append(count_video)
except KeyError:
list_videos_per_class[activity_id] = [count_video]
# add data to 'object_ids'
# [video, video_filename, list_images_per_video,
# list_annotations_per_video, activity, total_imgs]
object_ids.append([
count_video, count_video, count_video, count_video,
activity_id, num_imgs
])
# update video counter
count_video += 1
return {
"object_fields":
str2ascii([
'videos', 'video_filenames', 'list_image_filenames_per_video',
'list_annotations_per_video', 'activities', 'total_frames'
]),
"object_ids":
np.array(object_ids, dtype=np.int32),
"videos":
str2ascii(videos),
"video_filenames":
str2ascii(video_filenames),
"activities":
str2ascii(self.classes),
"image_filenames":
str2ascii(image_filenames),
"annotations":
np.array(annotations, dtype=np.int32),
"total_frames":
np.array(total_frames, dtype=np.int32),
"list_videos_per_activity":
np.array(pad_list(list(list_videos_per_class.values()), -1),
dtype=np.int32),
"list_image_filenames_per_video":
np.array(pad_list(list_image_filenames_per_video, -1),
dtype=np.int32),
"list_annotations_per_video":
np.array(pad_list(list_annotations_per_video, -1), dtype=np.int32)
}
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 convert_data_to_arrays(self, data):
"""
Convert data to arrays.
"""
# intialize lists
activities = self.classes
object_fields = ['image_filenames', 'boxes', 'videos', "activities"]
object_ids = []
videos = []
video_filenames_ids = []
video_boxes_ids = []
image_filenames = []
bboxes = []
activity_video_ids = []
counter_files_id = 0
counter_video_id = 0
for activity_id, activity in enumerate(activities):
video_ids = []
for _, video_data in enumerate(data[activity]):
videos.append(video_data['video_folder_name'])
video_ids.append(counter_video_id)
img_fnames = video_data['image_filenames']
boxes = video_data['image_bboxes']
fname_ids = []
bboxes_ids = []
for i, fname in enumerate(img_fnames):
image_filenames.append(fname)
bboxes.append(boxes[i])
fname_ids.append(counter_files_id)
bboxes_ids.append(counter_files_id)
object_ids.append([
counter_files_id, counter_files_id, counter_video_id,
activity_id
])
# increment file counter
counter_files_id += 1
num_imgs = len(img_fnames)
video_filenames_ids.append(fname_ids)
video_boxes_ids.append(bboxes_ids)
# increment video counter
counter_video_id += 1
activity_video_ids.append(video_ids)
return {
"activities":
str2ascii(activities),
"videos":
str2ascii(videos),
"image_filenames":
str2ascii(image_filenames),
"boxes":
np.array(bboxes, dtype=np.int32),
"object_ids":
np.array(object_ids, dtype=np.int32),
"object_fields":
str2ascii(object_fields),
"list_object_ids_per_video":
np.array(pad_list(video_filenames_ids, -1), dtype=np.int32),
"list_filenames_per_video":
np.array(pad_list(video_filenames_ids, -1), dtype=np.int32),
"list_boxes_per_video":
np.array(pad_list(video_boxes_ids, -1), dtype=np.int32),
"list_videos_per_activity":
np.array(pad_list(activity_video_ids, -1), dtype=np.int32)
}
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)
