def from_dict(cls, ann_dict: dict) -> Detectron2_Annotation:
check_required_keys(
ann_dict,
required_keys=['iscrowd', 'bbox', 'category_id', 'bbox_mode'])
if ann_dict['bbox_mode'] == BoxMode.XYWH_ABS:
bbox = BBox.from_list(ann_dict['bbox'], input_format='pminsize')
elif ann_dict['bbox_mode'] == BoxMode.XYXY_ABS:
bbox = BBox.from_list(ann_dict['bbox'], input_format='pminpmax')
else:
raise NotImplementedError
if 'keypoints' in ann_dict:
keypoints = Keypoint2D_List.from_list(
value_list=ann_dict['keypoints'], demarcation=False)
else:
keypoints = Keypoint2D_List()
return Detectron2_Annotation(iscrowd=ann_dict['iscrowd'],
bbox=bbox,
keypoints=keypoints,
category_id=ann_dict['category_id'],
segmentation=Segmentation.from_list(
points_list=ann_dict['segmentation']
if 'segmentation' in ann_dict else [],
demarcation=False),
bbox_mode=ann_dict['bbox_mode'])
def from_dict(cls, ann_dict: dict, strict: bool = True) -> COCO_Annotation:
if strict:
check_required_keys(ann_dict,
required_keys=[
'segmentation', 'num_keypoints', 'area',
'iscrowd', 'keypoints', 'image_id', 'bbox',
'category_id', 'id'
])
return COCO_Annotation(
segmentation=Segmentation.from_list(ann_dict['segmentation'],
demarcation=False),
num_keypoints=ann_dict['num_keypoints'],
area=ann_dict['area'],
iscrowd=ann_dict['iscrowd'],
keypoints=Keypoint2D_List.from_list(ann_dict['keypoints'],
demarcation=False),
image_id=ann_dict['image_id'],
bbox=BBox.from_list(ann_dict['bbox'], input_format='pminsize'),
category_id=ann_dict['category_id'],
id=ann_dict['id'],
keypoints_3d=Keypoint3D_List.from_list(
ann_dict['keypoints_3d'], demarcation=False)
if 'keypoints_3d' in ann_dict else None,
camera=Camera.from_dict(ann_dict['camera_params'])
if 'camera_params' in ann_dict else None)
else:
check_required_keys(
ann_dict, required_keys=['id', 'category_id', 'image_id'])
return COCO_Annotation(
segmentation=Segmentation.from_list(ann_dict['segmentation'],
demarcation=False)
if 'segmentation' in ann_dict else None,
num_keypoints=ann_dict['num_keypoints']
if 'num_keypoints' in ann_dict else None,
area=ann_dict['area'] if 'area' in ann_dict else None,
iscrowd=ann_dict['iscrowd'] if 'iscrowd' in ann_dict else None,
keypoints=Keypoint2D_List.from_list(ann_dict['keypoints'],
demarcation=False)
if 'keypoints' in ann_dict else None,
image_id=ann_dict['image_id'],
bbox=BBox.from_list(ann_dict['bbox'], input_format='pminsize')
if 'bbox' in ann_dict else None,
category_id=ann_dict['category_id'],
id=ann_dict['id'],
keypoints_3d=Keypoint3D_List.from_list(
ann_dict['keypoints_3d'], demarcation=False)
if 'keypoints_3d' in ann_dict else None,
camera=Camera.from_dict(ann_dict['camera_params'])
if 'camera_params' in ann_dict else None)
def from_dict(self, item_dict: dict) -> BBoxKeypointResult:
return BBoxKeypointResult(image_id=item_dict['image_id'],
category_id=item_dict['category_id'],
keypoints=Keypoint2D_List.from_list(
item_dict['keypoints'],
demarcation=False),
bbox=BBox.from_list(item_dict['bbox'],
input_format='pminsize'),
score=item_dict['score'])
def from_dict(self, item_dict: dict) -> KeypointResult:
check_required_keys(
item_dict, required_keys=['image_id', 'category_id', 'keypoints'])
if 'score' not in item_dict and 'score_list' not in item_dict:
logger.error(
f"Need to provide a dictionary with either a 'score' key or a 'score_list' key."
)
raise Exception
return KeypointResult(image_id=item_dict['image_id'],
category_id=item_dict['category_id'],
keypoints=Keypoint2D_List.from_list(
item_dict['keypoints'], demarcation=False),
score=item_dict['score'])
def run(
path: str,
key: str = 'measure',
show_image: bool = False,
show_video: bool = True,
):
dataset = COCO_Dataset.load_from_path(json_path=f'{path}/{key}-coco.json',
img_dir=path,
strict=False)
# for i, coco_ann in enumerate(dataset.annotations):
# if i % 2 == 0:
# coco_ann.segmentation = Segmentation()
# if i % 3 == 0:
# coco_ann.keypoints = Keypoint2D_List()
# coco_ann.num_keypoints = 0
for coco_ann in dataset.annotations:
coco_ann.segmentation = Segmentation()
coco_ann.keypoints = Keypoint2D_List()
coco_ann.num_keypoints = 0
coco_ann.keypoints_3d = None
coco_ann.camera = None
for coco_cat in dataset.categories:
coco_cat.keypoints = []
coco_cat.skeleton = []
dataset.save_to_path('non_strict_dataset.json',
overwrite=True,
strict=False)
dataset0 = COCO_Dataset.load_from_path('non_strict_dataset.json',
strict=False)
dataset0.images.sort(attr_name='file_name')
if show_image:
dataset0.save_visualization(save_dir=f'{path}_{dt_string3}_visualize',
show_preview=True,
kpt_idx_offset=-1,
overwrite=True,
show_details=True)
if show_video:
dataset0.save_video(
save_path=f'{path}_{dt_string3}.mp4',
# draw_order=['screw'],
show_details=True,
show_preview=True,
kpt_idx_offset=-1,
overwrite=True,
fps=5,
show_seg=True)
logger.green('Visualisation complete')
def get_keypoints(self, kpt_labels: List[str]) -> (Keypoint2D_List, Keypoint3D_List):
kpts_2d = Keypoint2D_List()
kpts_3d = Keypoint3D_List()
for kpt_label in kpt_labels:
found = False
for contained_instance in self.contained_instance_list:
if contained_instance.instance_type == 'kpt' and contained_instance.instance_name == kpt_label:
kpts_2d.append(Keypoint2D(point=contained_instance.ndds_ann_obj.projected_cuboid_centroid, visibility=2))
kpts_3d.append(Keypoint3D(point=contained_instance.ndds_ann_obj.cuboid_centroid, visibility=2))
found = True
break
if not found:
kpts_2d.append(Keypoint2D.origin())
kpts_3d.append(Keypoint3D.origin())
return kpts_2d, kpts_3d
def __init__(
self,
id: int,
category_id: int,
image_id: int, # Standard Required
segmentation: Segmentation = None, # Standard Optional
bbox: BBox = None,
area: float = None,
keypoints: Keypoint2D_List = None,
num_keypoints: int = None,
iscrowd: int = 0,
keypoints_3d: Keypoint3D_List = None,
camera: Camera = None # Custom Optional
):
super().__init__(id=id)
# Standard Required
self.category_id = category_id
self.image_id = image_id
# Standard Optional
self.segmentation = segmentation if segmentation is not None else Segmentation(
[])
if bbox is not None:
self.bbox = bbox
else:
if len(self.segmentation) > 0:
self.bbox = self.segmentation.to_bbox()
else:
logger.error(
f'A COCO_Annotation needs to be given either a bbox or a non-empty segmentation at the very least to make a valid annotation.'
)
logger.error(
f'id: {id}, category_id: {category_id}, image_id: {image_id}'
)
raise Exception
self.area = area
self.keypoints = keypoints if keypoints is not None else Keypoint2D_List(
[])
self.num_keypoints = num_keypoints if num_keypoints is not None else len(
self.keypoints)
self.iscrowd = iscrowd
# Custom Optional
self.keypoints_3d = keypoints_3d
self.camera = camera
keypoints.append(item.keypoints)
bbox.append(item.bbox)
segmentation.append(item.segmentation)
# print(segmentation)
image, keypoints, bbox, poly = handler(image=img,
keypoints=keypoints,
bounding_boxes=bbox,
polygons=segmentation)
kpts_aug_list = keypoints[0].to_numpy(demarcation=True)[:, :2].reshape(
ann_instance, keypoints_num, 2)
kpts_aug_list = [[[x, y, 2] for x, y in kpts_aug]
for kpts_aug in kpts_aug_list]
keypoints = [
Keypoint2D_List.from_list(kpts_aug, demarcation=True)
for kpts_aug in kpts_aug_list
]
# print(image, keypoints, bbox, poly)
cv2.imshow("a", image)
cv2.waitKey(500)
# break
# print(results)
# preview0 = concat_n_images(img_list=resize(images=img_buffer), orientation=0)
# preview1 = concat_n_images(img_list=resize(images=results), orientation=0)
# preview = concat_n_images(img_list=[preview0, preview1], orientation=1)
# img_buffer = []
# quit_flag = cv_simple_image_viewer(img=preview, preview_width=1000)
assert kpt2d_0 - pt2d_1 == Keypoint2D(point=kpt2d_0.point - pt2d_1,
visibility=kpt2d_0.visibility)
assert kpt2d_0 - const_int == Keypoint2D(point=kpt2d_0.point - const_int,
visibility=kpt2d_0.visibility)
assert kpt2d_0 - kpt2d_1 == Keypoint2D(point=kpt2d_0.point - kpt2d_1.point,
visibility=int(
max(kpt2d_0.visibility,
kpt2d_1.visibility)))
assert kpt2d_0 * const_int == Keypoint2D(point=kpt2d_0.point * const_int,
visibility=kpt2d_0.visibility)
assert kpt2d_0 / const_int == Keypoint2D(point=kpt2d_0.point / const_int,
visibility=kpt2d_0.visibility)
print(f'Keypoint2D Test Passed')
kpt2d_list_0 = Keypoint2D_List(kpt_list=[kpt2d_0 for i in range(5)])
assert kpt2d_list_0 + kpt2d_1 == Keypoint2D_List(
[kpt + kpt2d_1 for kpt in kpt2d_list_0])
assert kpt2d_list_0 + pt2d_1 == Keypoint2D_List(
[kpt + pt2d_1 for kpt in kpt2d_list_0])
assert kpt2d_list_0 + const_int == Keypoint2D_List(
[kpt + const_int for kpt in kpt2d_list_0])
assert kpt2d_list_0 - kpt2d_1 == Keypoint2D_List(
[kpt - kpt2d_1 for kpt in kpt2d_list_0])
assert kpt2d_list_0 - pt2d_1 == Keypoint2D_List(
[kpt - pt2d_1 for kpt in kpt2d_list_0])
assert kpt2d_list_0 - const_int == Keypoint2D_List(
[kpt - const_int for kpt in kpt2d_list_0])
assert kpt2d_list_0 * const_int == Keypoint2D_List(
[kpt * const_int for kpt in kpt2d_list_0])
def from_dict(cls, ann_dict: dict, strict: bool = True) -> COCO_Annotation:
if strict:
check_required_keys(ann_dict,
required_keys=[
'segmentation', 'num_keypoints', 'area',
'iscrowd', 'keypoints', 'image_id', 'bbox',
'category_id', 'id'
])
return COCO_Annotation(
segmentation=Segmentation.from_list(ann_dict['segmentation'],
demarcation=False),
num_keypoints=ann_dict['num_keypoints'],
area=ann_dict['area'],
iscrowd=ann_dict['iscrowd'],
keypoints=Keypoint2D_List.from_list(ann_dict['keypoints'],
demarcation=False),
image_id=ann_dict['image_id'],
bbox=BBox.from_list(ann_dict['bbox'], input_format='pminsize'),
category_id=ann_dict['category_id'],
id=ann_dict['id'],
keypoints_3d=Keypoint3D_List.from_list(
ann_dict['keypoints_3d'], demarcation=False)
if 'keypoints_3d' in ann_dict else None,
camera=Camera.from_dict(ann_dict['camera_params'])
if 'camera_params' in ann_dict else None)
else:
check_required_keys(
ann_dict, required_keys=['id', 'category_id', 'image_id'])
if 'segmentation' not in ann_dict:
seg = None
elif ann_dict['iscrowd'] == 1 and type(
ann_dict['segmentation']) == dict:
compressed_rle = mask.frPyObjects(
ann_dict['segmentation'],
ann_dict['segmentation']['size'][0],
ann_dict['segmentation']['size'][1])
seg_mask = mask.decode(compressed_rle)
contours, _ = cv2.findContours(seg_mask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
seg = Segmentation.from_contour(contour_list=contours)
else:
seg = Segmentation.from_list(ann_dict['segmentation'],
demarcation=False)
return COCO_Annotation(
segmentation=seg,
num_keypoints=ann_dict['num_keypoints']
if 'num_keypoints' in ann_dict else None,
area=ann_dict['area'] if 'area' in ann_dict else None,
iscrowd=ann_dict['iscrowd'] if 'iscrowd' in ann_dict else None,
keypoints=Keypoint2D_List.from_list(ann_dict['keypoints'],
demarcation=False)
if 'keypoints' in ann_dict else None,
image_id=ann_dict['image_id'],
bbox=BBox.from_list(ann_dict['bbox'], input_format='pminsize')
if 'bbox' in ann_dict else None,
category_id=ann_dict['category_id'],
id=ann_dict['id'],
keypoints_3d=Keypoint3D_List.from_list(
ann_dict['keypoints_3d'], demarcation=False)
if 'keypoints_3d' in ann_dict else None,
camera=Camera.from_dict(ann_dict['camera_params'])
if 'camera_params' in ann_dict else None)
def to_coco(self,
img_dir: str = None,
mask_dir: str = None,
coco_license: COCO_License = None,
check_paths: bool = True,
mask_lower_bgr: Tuple[int] = None,
mask_upper_bgr: Tuple[int] = (255, 255, 255),
show_pbar: bool = True) -> COCO_Dataset:
dataset = COCO_Dataset.new(
description='Dataset converted from Linemod to COCO format.')
dataset.licenses.append(
coco_license if coco_license is not None else COCO_License(
url=
'https://github.com/cm107/annotation_utils/blob/master/LICENSE',
name='MIT License',
id=len(dataset.licenses)))
coco_license0 = dataset.licenses[-1]
for linemod_image in self.images:
file_name = get_filename(linemod_image.file_name)
img_path = linemod_image.file_name if img_dir is None else f'{img_dir}/{file_name}'
if file_exists(img_path):
date_captured = get_ctime(img_path)
else:
if check_paths:
raise FileNotFoundError(
f"Couldn't find image at {img_path}")
date_captured = ''
coco_image = COCO_Image(license_id=coco_license0.id,
file_name=file_name,
coco_url=img_path,
width=linemod_image.width,
height=linemod_image.height,
date_captured=date_captured,
flickr_url=None,
id=linemod_image.id)
dataset.images.append(coco_image)
pbar = tqdm(total=len(self.annotations),
unit='annotation(s)') if show_pbar else None
if pbar is not None:
pbar.set_description('Converting Linemod to COCO')
for linemod_ann in self.annotations:
mask_filename = get_filename(linemod_ann.mask_path)
if mask_dir is not None:
mask_path = f'{mask_dir}/{mask_filename}'
if not file_exists(mask_path):
if check_paths:
raise FileNotFoundError(
f"Couldn't find mask at {mask_path}")
else:
seg = Segmentation()
else:
seg = Segmentation.from_mask_path(mask_path,
lower_bgr=mask_lower_bgr,
upper_bgr=mask_upper_bgr)
elif file_exists(linemod_ann.mask_path):
seg = Segmentation.from_mask_path(linemod_ann.mask_path,
lower_bgr=mask_lower_bgr,
upper_bgr=mask_upper_bgr)
elif img_dir is not None and file_exists(
f'{img_dir}/{mask_filename}'):
seg = Segmentation.from_mask_path(f'{img_dir}/{mask_filename}',
lower_bgr=mask_lower_bgr,
upper_bgr=mask_upper_bgr)
elif not check_paths:
seg = Segmentation()
else:
raise FileNotFoundError(f"""
Couldn't resolve mask_path for calculating segmentation.
Please either specify mask_dir or correct the mask paths
in your linemod dataset.
linemod_ann.id: {linemod_ann.id}
linemod_ann.mask_path: {linemod_ann.mask_path}
""")
if len(seg) > 0:
bbox = seg.to_bbox()
else:
xmin = int(
linemod_ann.corner_2d.to_numpy(demarcation=True)[:,
0].min())
xmax = int(
linemod_ann.corner_2d.to_numpy(demarcation=True)[:,
0].max())
ymin = int(
linemod_ann.corner_2d.to_numpy(demarcation=True)[:,
1].min())
ymax = int(
linemod_ann.corner_2d.to_numpy(demarcation=True)[:,
1].max())
bbox = BBox(xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax)
keypoints = Keypoint2D_List.from_point_list(linemod_ann.fps_2d,
visibility=2)
keypoints_3d = Keypoint3D_List.from_point_list(linemod_ann.fps_3d,
visibility=2)
num_keypoints = len(keypoints)
if linemod_ann.category_id not in [
cat.id for cat in dataset.categories
]:
linemod_cat = self.categories.get_obj_from_id(
linemod_ann.category_id)
cat_keypoints = list(
'abcdefghijklmnopqrstuvwxyz'.upper())[:num_keypoints]
cat_keypoints_idx_list = [
idx for idx in range(len(cat_keypoints))
]
cat_keypoints_idx_list_shift_left = cat_keypoints_idx_list[
1:] + cat_keypoints_idx_list[:1]
dataset.categories.append(
COCO_Category(
id=linemod_ann.category_id,
supercategory=linemod_cat.supercategory,
name=linemod_cat.name,
keypoints=cat_keypoints,
skeleton=[[start_idx, end_idx]
for start_idx, end_idx in zip(
cat_keypoints_idx_list,
cat_keypoints_idx_list_shift_left)]))
coco_ann = COCO_Annotation(
id=linemod_ann.id,
category_id=linemod_ann.category_id,
image_id=linemod_ann.image_id,
segmentation=seg,
bbox=bbox,
area=bbox.area(),
keypoints=keypoints,
num_keypoints=num_keypoints,
iscrowd=0,
keypoints_3d=keypoints_3d,
camera=COCO_Camera(f=[linemod_ann.K.fx, linemod_ann.K.fy],
c=[linemod_ann.K.cx, linemod_ann.K.cy],
T=[0, 0]))
dataset.annotations.append(coco_ann)
if pbar is not None:
pbar.update()
if pbar is not None:
pbar.close()
return dataset
from common_utils.common_types.keypoint import Keypoint2D_List
dataset = COCO_Dataset.load_from_path(
json_path=
'/home/clayton/workspace/prj/data_keep/data/toyota/dataset/sim/20200228/28_02_2020_11_18_30_coco-data/HSR-coco.json',
img_dir=
'/home/clayton/workspace/prj/data_keep/data/toyota/dataset/sim/20200228/28_02_2020_11_18_30_coco-data'
)
# for i, coco_ann in enumerate(dataset.annotations):
# if i % 2 == 0:
# coco_ann.segmentation = Segmentation()
# if i % 3 == 0:
# coco_ann.keypoints = Keypoint2D_List()
# coco_ann.num_keypoints = 0
for coco_ann in dataset.annotations:
coco_ann.segmentation = Segmentation()
coco_ann.keypoints = Keypoint2D_List()
coco_ann.num_keypoints = 0
coco_ann.keypoints_3d = None
coco_ann.camera = None
for coco_cat in dataset.categories:
coco_cat.keypoints = []
coco_cat.skeleton = []
dataset.save_to_path('non_strict_dataset.json', overwrite=True, strict=False)
dataset0 = COCO_Dataset.load_from_path('non_strict_dataset.json', strict=False)
dataset0.images.sort(attr_name='file_name')
dataset0.save_visualization(save_dir='test_vis',
show_preview=True,
kpt_idx_offset=-1,
overwrite=True,
show_details=True)
