def from_label_skeleton(cls,
supercategory: str,
name: str,
id: int,
label_skeleton: List[list],
skeleton_idx_offset: int = 0) -> COCO_Category:
label_list = []
for [start_label, end_label] in label_skeleton:
check_type_from_list([start_label, end_label],
valid_type_list=[str])
if start_label not in label_list:
label_list.append(start_label)
if end_label not in label_list:
label_list.append(end_label)
label_list.sort()
int_skeleton = []
for [start_label, end_label] in label_skeleton:
start_idx = label_list.index(start_label) + skeleton_idx_offset
end_idx = label_list.index(end_label) + skeleton_idx_offset
int_skeleton.append([start_idx, end_idx])
return COCO_Category(supercategory=supercategory,
id=id,
name=name,
keypoints=label_list,
skeleton=int_skeleton)
def color_list(self, color: List[GL_Color]):
if type(color) is list:
check_list_length(color, correct_length=len(self))
check_type_from_list(color, valid_type_list=[GL_Color])
for point, val in zip(self, color):
point.color = val
elif type(color) is GL_Color:
for point in self:
point.color = color
else:
raise Exception
def __init__(self: H,
obj_types: List[type],
obj_list: List[T] = None,
random_order: bool = False):
check_type(obj_types, valid_type_list=[list])
check_type_from_list(obj_types, valid_type_list=[type, BaseModeMeta])
self.obj_types = obj_types
if obj_list is not None:
check_type_from_list(obj_list, valid_type_list=obj_types)
self.obj_list = obj_list if obj_list is not None else []
self.random_order = random_order
def __init__(self,
exported_object_classes: List[str] = None,
exported_objects: ExportedObjectHandler = None):
super().__init__()
self.exported_object_classes = exported_object_classes if exported_object_classes is not None else []
check_type_from_list(self.exported_object_classes,
valid_type_list=[str])
self.exported_objects = exported_objects if exported_objects is not None else ExportedObjectHandler(
)
check_type(self.exported_objects,
valid_type_list=[ExportedObjectHandler])
def from_dict(cls, intrinsic_param_dict: dict) -> Camera:
check_type(intrinsic_param_dict, valid_type_list=[dict])
if len(intrinsic_param_dict) > 0:
check_required_keys(intrinsic_param_dict,
required_keys=['f', 'c', 'T'])
check_type_from_list(list(intrinsic_param_dict.values()),
valid_type_list=[list])
return Camera(f=intrinsic_param_dict['f'],
c=intrinsic_param_dict['c'],
T=intrinsic_param_dict['T'])
else:
return None
def replace(self, old: Path, new: Path) -> Path:
check_type_from_list([old, new], valid_type_list=[Path, str])
if type(old) is str:
old_path = Path(old)
else:
old_path = old
if type(new) is str:
new_path = Path(new)
else:
new_path = new
result = self.to_str()
result = result.replace(old_path.to_str(), new_path.to_str())
while '//' in result:
result = result.replace('//', '/')
return Path(result)
def _get_ann_path_list(self, dataset_paths: list, ann_path) -> list:
check_type(item=ann_path, valid_type_list=[str, list])
if type(ann_path) is str:
ann_path_list = [
f"{dataset_path}/{ann_path}" for dataset_path in dataset_paths
]
elif type(ann_path) is list:
if len(ann_path) == len(dataset_paths):
check_type_from_list(item_list=ann_path, valid_type_list=[str])
ann_path_list = [
f"{dataset_path}/{ann_path_path}"
for dataset_path, ann_path_path in zip(
dataset_paths, ann_path)
]
else:
logger.error(
f"type(ann_path) is list but len(ann_path) == {len(ann_path)} != {len(dataset_paths)} == len(dataset_paths)"
)
raise Exception
else:
raise Exception
return ann_path_list
def _get_img_dir_list(self, dataset_paths: list, img_dir) -> list:
check_type(item=img_dir, valid_type_list=[str, list])
if type(img_dir) is str:
img_dir_list = [
f"{dataset_path}/{img_dir}" for dataset_path in dataset_paths
]
elif type(img_dir) is list:
if len(img_dir) == len(dataset_paths):
check_type_from_list(item_list=img_dir, valid_type_list=[str])
img_dir_list = [
f"{dataset_path}/{img_dir_path}"
for dataset_path, img_dir_path in zip(
dataset_paths, img_dir)
]
else:
logger.error(
f"type(img_dir) is list but len(img_dir) == {len(img_dir)} != {len(dataset_paths)} == len(dataset_paths)"
)
raise Exception
else:
raise Exception
return img_dir_list
def __init__(self,
bound_obj,
coco_cat: COCO_Category,
kpt_list: List[Keypoint2D] = None,
kpt_label_list: List[str] = None,
img_filename: str = None):
check_type(bound_obj, valid_type_list=[BBox, Polygon])
self.bound_obj = bound_obj
check_type(coco_cat, valid_type_list=[COCO_Category])
self.coco_cat = coco_cat
if kpt_list is not None:
check_type_from_list(kpt_list, valid_type_list=[Keypoint2D])
self.kpt_list = kpt_list
else:
self.kpt_list = []
self.kpt_label_list = []
self.img_filename = img_filename
if kpt_list is not None or kpt_label_list is not None:
if kpt_list is None or kpt_label_list is None:
logger.error(
f'Must provide both kpt_list and kpt_label_list, or neither.'
)
logger.error(
f'kpt_list: {kpt_list}\nkpt_label_list: {kpt_label_list}')
logger.error(f'Ground truth labels: {self.coco_cat.keypoints}')
if self.img_filename is not None:
logger.error(f'Image filename: {self.img_filename}')
raise Exception
if len(kpt_list) != len(kpt_label_list):
logger.error(
f'len(kpt_list) == {len(kpt_list)} != {len(kpt_label_list)} == len(kpt_label_list)'
)
raise Exception
for kpt, label in zip(kpt_list, kpt_label_list):
self.register(kpt=kpt, label=label)
self.postponed_kpt_list = []
self.postponed_kpt_label_list = []
def tail2head(cls, src_obj: List[Path], dst_obj: List[Path]) -> bool:
# TODO: Assertion test
check_type_from_list([src_obj, dst_obj], valid_type_list=[Path, list])
if type(src_obj) is list:
check_type_from_list(src_obj, valid_type_list=[Path])
if type(dst_obj) is list:
check_type_from_list(dst_obj, valid_type_list=[Path])
if type(src_obj) is Path:
if type(dst_obj) is Path:
success = cls._root_src_tail2dst_head(src_obj, dst_obj)
elif type(dst_obj) is list:
if len(src_obj) > 0:
tail = src_obj.pop_tail()
for dst_path in dst_obj:
dst_path.path_str = (tail + dst_path).to_str()
success = True
else:
success = False
else:
raise Exception
elif type(src_obj) is list:
has_common_tail, common_tail = cls.get_common_tail(src_obj)
if has_common_tail:
if type(dst_obj) is Path:
dst_obj.path_str = (common_tail + dst_obj).to_str()
for src_path in src_obj:
src_path.path_str = src_path.no_tail().to_str()
success = True
elif type(dst_obj) is list:
if len(src_obj) != len(dst_obj):
logger.error(f'len(src_obj) == {len(src_obj)} != {len(dst_obj)} == len(dst_obj)')
raise Exception
for dst_path in dst_obj:
dst_path.path_str = (common_tail + dst_path).to_str()
for src_path in src_obj:
src_path.path_str = src_path.no_tail().to_str()
success = True
else:
raise Exception
else:
success = False
else:
raise Exception
return success
def head2tail(cls, src_obj: List[Path], dst_obj: List[Path]) -> bool:
check_type_from_list([src_obj, dst_obj], valid_type_list=[Path, list])
if type(src_obj) is list:
check_type_from_list(src_obj, valid_type_list=[Path])
if type(dst_obj) is list:
check_type_from_list(dst_obj, valid_type_list=[Path])
if type(src_obj) is Path:
if type(dst_obj) is Path:
success = cls._root_src_head2dst_tail(src_obj, dst_obj)
elif type(dst_obj) is list:
if len(src_obj) > 0:
head = src_obj.pop_head()
for dst_path in dst_obj:
dst_path.path_str = (dst_path + head).to_str()
success = True
else:
success = False
else:
raise Exception
elif type(src_obj) is list:
has_common_head, common_head = cls.get_common_head(src_obj)
if has_common_head:
if type(dst_obj) is Path:
dst_obj.path_str = (dst_obj + common_head).to_str()
for src_path in src_obj:
src_path.path_str = src_path.no_head().to_str()
success = True
elif type(dst_obj) is list:
if len(src_obj) != len(dst_obj):
logger.error(f'len(src_obj) == {len(src_obj)} != {len(dst_obj)} == len(dst_obj)')
raise Exception
for dst_path in dst_obj:
dst_path.path_str = (dst_path + common_head).to_str()
for src_path in src_obj:
src_path.path_str = src_path.no_head().to_str()
success = True
else:
raise Exception
else:
success = False
else:
raise Exception
return success
def __init__(self: H, obj_type: type, obj_list: List[T] = None):
check_type(obj_type, valid_type_list=[type])
self.obj_type = obj_type
if obj_list is not None:
check_type_from_list(obj_list, valid_type_list=[obj_type])
self.obj_list = obj_list if obj_list is not None else []
def from_dict(cls,
collection_dict: dict,
check_paths: bool = True) -> DatasetConfigCollection:
check_required_keys(collection_dict,
required_keys=[
'collection_dir', 'dataset_names',
'dataset_specific'
])
collection_dir = collection_dict['collection_dir']
check_type(collection_dir, valid_type_list=[str])
dataset_names = collection_dict['dataset_names']
check_type(dataset_names, valid_type_list=[list])
check_type_from_list(dataset_names, valid_type_list=[str])
dataset_specific = collection_dict['dataset_specific']
check_type(dataset_specific, valid_type_list=[dict])
collection_tag = None if 'tag' not in collection_dict else collection_dict[
'tag']
check_type(collection_tag, valid_type_list=[type(None), str])
check_required_keys(
dataset_specific,
required_keys=['img_dir', 'ann_path', 'ann_format'])
img_dir = dataset_specific['img_dir']
check_type(img_dir, valid_type_list=[str, list])
if type(img_dir) is list:
check_type_from_list(img_dir, valid_type_list=[str])
check_list_length(img_dir, correct_length=len(dataset_names))
ann_path = dataset_specific['ann_path']
check_type(ann_path, valid_type_list=[str, list])
if type(ann_path) is list:
check_type_from_list(ann_path, valid_type_list=[str])
check_list_length(ann_path, correct_length=len(dataset_names))
ann_format = dataset_specific['ann_format']
check_type(ann_format, valid_type_list=[str, list])
if type(ann_format) is list:
check_type_from_list(ann_format, valid_type_list=[str])
check_list_length(ann_format, correct_length=len(dataset_names))
dataset_tag = None if 'tag' not in dataset_specific else dataset_specific[
'tag']
check_type(dataset_tag, valid_type_list=[type(None), str, list])
if type(dataset_tag) is list:
check_type_from_list(dataset_tag,
valid_type_list=[type(None), str])
check_list_length(dataset_tag, correct_length=len(dataset_names))
dataset_config_list = []
for i in range(len(dataset_names)):
if type(img_dir) is str:
img_dir0 = img_dir
elif type(img_dir) is list:
if i >= len(img_dir):
raise IndexError
img_dir0 = img_dir[i]
else:
raise Exception
if type(ann_path) is str:
ann_path0 = ann_path
elif type(ann_path) is list:
if i >= len(ann_path):
raise IndexError
ann_path0 = ann_path[i]
else:
raise Exception
if type(ann_format) is str:
ann_format0 = ann_format
elif type(ann_format) is list:
if i >= len(ann_format):
raise IndexError
ann_format0 = ann_format[i]
else:
raise Exception
if type(dataset_tag) is str or dataset_tag is None:
dataset_tag0 = dataset_tag
elif type(dataset_tag) is list:
if i >= len(dataset_tag):
raise IndexError
dataset_tag0 = dataset_tag[i]
else:
raise Exception
img_dir1 = rel_to_abs_path(
f'{collection_dir}/{dataset_names[i]}/{img_dir0}')
ann_path1 = rel_to_abs_path(
f'{collection_dir}/{dataset_names[i]}/{ann_path0}')
if check_paths:
check_dir_exists(img_dir1)
check_file_exists(ann_path1)
config = DatasetConfig(img_dir=img_dir1,
ann_path=ann_path1,
ann_format=ann_format0,
tag=dataset_tag0)
dataset_config_list.append(config)
return DatasetConfigCollection(dataset_config_list=dataset_config_list,
tag=collection_tag)
def __init__(self, point_list: List[Point3D]):
check_list_length(point_list, correct_length=8)
check_type_from_list(point_list, valid_type_list=[Point3D])
super().__init__(point_list=point_list)
def __init__(self, settings_list: List[CameraSettings]=None):
super().__init__(obj_type=CameraSettings, obj_list=settings_list)
self.settings_list = self.obj_list
check_type_from_list(self.settings_list, valid_type_list=[CameraSettings])
def __init__(self, exported_obj_list: List[ExportedObject]=None):
super().__init__(obj_type=ExportedObject, obj_list=exported_obj_list)
self.exported_obj_list = self.obj_list
check_type_from_list(self.exported_obj_list, valid_type_list=[ExportedObject])
