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)