| | import os
|
| | import numpy as np
|
| | import json
|
| | import imageio
|
| | import cv2
|
| | import open3d as o3d
|
| | from PIL import Image
|
| |
|
| |
|
| | def trimesh_to_open3d(tri_mesh):
|
| |
|
| | o3d_mesh = o3d.geometry.TriangleMesh(
|
| | vertices=o3d.utility.Vector3dVector(tri_mesh.vertices.copy()),
|
| | triangles=o3d.utility.Vector3iVector(tri_mesh.faces.copy())
|
| | )
|
| |
|
| |
|
| | if hasattr(tri_mesh, 'visual'):
|
| | if hasattr(tri_mesh.visual, 'vertex_colors'):
|
| |
|
| | vertex_colors = tri_mesh.visual.vertex_colors[:, :3] / 255.0
|
| | else:
|
| | vertex_colors = tri_mesh.visual.to_color().vertex_colors[:, :3] / 255.0
|
| | o3d_mesh.vertex_colors = o3d.utility.Vector3dVector(vertex_colors)
|
| |
|
| | return o3d_mesh
|
| |
|
| | def load_im(path):
|
| | """Loads an image from a file.
|
| |
|
| | :param path: Path to the image file to load.
|
| | :return: ndarray with the loaded image.
|
| | """
|
| | im = imageio.imread(path)
|
| | return im
|
| |
|
| |
|
| | def io_load_gt(
|
| | gt_file,
|
| | instance_ids=None,
|
| | ):
|
| | """Load ground truth from an I/O object.
|
| | Instance_ids can be specified to load only a
|
| | subset of object instances.
|
| |
|
| | :param gt_file: I/O object that can be read with json.load.
|
| | :param instance_ids: List of instance ids.
|
| | :return: List of ground truth annotations (one dict per object instance).
|
| | """
|
| | gt = json.load(gt_file)
|
| | if instance_ids is not None:
|
| | gt = [gt_n for n, gt_n in enumerate(gt) if n in instance_ids]
|
| | gt = [_gt_as_numpy(gt_n) for gt_n in gt]
|
| | return gt
|
| |
|
| |
|
| | def io_load_masks(
|
| | mask_file,
|
| | instance_ids=None
|
| | ):
|
| | """Load object masks from an I/O object.
|
| | Instance_ids can be specified to apply RLE
|
| | decoding to a subset of object instances contained
|
| | in the file.
|
| |
|
| | :param mask_file: I/O object that can be read with json.load.
|
| | :param masks_path: Path to json file.
|
| | :return: a [N,H,W] binary array containing object masks.
|
| | """
|
| | masks_rle = json.load(mask_file)
|
| | masks_rle = {int(k): v for k, v in masks_rle.items()}
|
| | if instance_ids is None:
|
| | instance_ids = masks_rle.keys()
|
| | instance_ids = sorted(instance_ids)
|
| | masks = np.stack([
|
| | rle_to_binary_mask(masks_rle[instance_id])
|
| | for instance_id in instance_ids])
|
| | return masks
|
| |
|
| |
|
| | def _gt_as_numpy(gt):
|
| | if 'cam_R_m2c' in gt.keys():
|
| | gt['cam_R_m2c'] = \
|
| | np.array(gt['cam_R_m2c'], np.float64).reshape((3, 3))
|
| | if 'cam_t_m2c' in gt.keys():
|
| | gt['cam_t_m2c'] = \
|
| | np.array(gt['cam_t_m2c'], np.float64).reshape((3, 1))
|
| | return gt
|
| |
|
| |
|
| | def rle_to_binary_mask(rle):
|
| | """Converts a COCOs run-length encoding (RLE) to binary mask.
|
| |
|
| | :param rle: Mask in RLE format
|
| | :return: a 2D binary numpy array where '1's represent the object
|
| | """
|
| | binary_array = np.zeros(np.prod(rle.get('size')), dtype=bool)
|
| | counts = rle.get('counts')
|
| |
|
| | start = 0
|
| | for i in range(len(counts)-1):
|
| | start += counts[i]
|
| | end = start + counts[i+1]
|
| | binary_array[start:end] = (i + 1) % 2
|
| |
|
| | binary_mask = binary_array.reshape(*rle.get('size'), order='F')
|
| |
|
| | return binary_mask
|
| |
|
| |
|
| | def get_point_cloud_from_depth(depth, K, bbox=None):
|
| | cam_fx, cam_fy, cam_cx, cam_cy = K[0,0], K[1,1], K[0,2], K[1,2]
|
| |
|
| | im_H, im_W = depth.shape
|
| | xmap = np.array([[i for i in range(im_W)] for j in range(im_H)])
|
| | ymap = np.array([[j for i in range(im_W)] for j in range(im_H)])
|
| |
|
| | if bbox is not None:
|
| | rmin, rmax, cmin, cmax = bbox
|
| | depth = depth[rmin:rmax, cmin:cmax].astype(np.float32)
|
| | xmap = xmap[rmin:rmax, cmin:cmax].astype(np.float32)
|
| | ymap = ymap[rmin:rmax, cmin:cmax].astype(np.float32)
|
| |
|
| | pt2 = depth.astype(np.float32)
|
| | pt0 = (xmap.astype(np.float32) - cam_cx) * pt2 / cam_fx
|
| | pt1 = (ymap.astype(np.float32) - cam_cy) * pt2 / cam_fy
|
| |
|
| | cloud = np.stack([pt0,pt1,pt2]).transpose((1,2,0))
|
| | return cloud
|
| |
|
| |
|
| | def get_resize_rgb_choose(choose, bbox, img_size):
|
| | rmin, rmax, cmin, cmax = bbox
|
| | crop_h = rmax - rmin
|
| | ratio_h = img_size / crop_h
|
| | crop_w = cmax - cmin
|
| | ratio_w = img_size / crop_w
|
| |
|
| | row_idx = choose // crop_w
|
| | col_idx = choose % crop_w
|
| | choose = (np.floor(row_idx * ratio_h) * img_size + np.floor(col_idx * ratio_w)).astype(np.int64)
|
| | return choose
|
| |
|
| |
|
| | def get_bbox(label):
|
| | img_width, img_length = label.shape
|
| | rows = np.any(label, axis=1)
|
| | cols = np.any(label, axis=0)
|
| |
|
| | rmin, rmax = np.where(rows)[0][[0, -1]]
|
| |
|
| | cmin, cmax = np.where(cols)[0][[0, -1]]
|
| | rmax += 1
|
| | cmax += 1
|
| | r_b = rmax - rmin
|
| | c_b = cmax - cmin
|
| | b = min(max(r_b, c_b), min(img_width, img_length))
|
| | center = [int((rmin + rmax) / 2), int((cmin + cmax) / 2)]
|
| |
|
| | rmin = center[0] - int(b / 2)
|
| | rmax = center[0] + int(b / 2)
|
| | cmin = center[1] - int(b / 2)
|
| | cmax = center[1] + int(b / 2)
|
| |
|
| | if rmin < 0:
|
| | delt = -rmin
|
| | rmin = 0
|
| | rmax += delt
|
| | if cmin < 0:
|
| | delt = -cmin
|
| | cmin = 0
|
| | cmax += delt
|
| | if rmax > img_width:
|
| | delt = rmax - img_width
|
| | rmax = img_width
|
| | rmin -= delt
|
| | if cmax > img_length:
|
| | delt = cmax - img_length
|
| | cmax = img_length
|
| | cmin -= delt
|
| | return [rmin, rmax, cmin, cmax]
|
| |
|
| | def get_random_rotation():
|
| | angles = np.random.rand(3) * 2 * np.pi
|
| | rand_rotation = np.array([
|
| | [1,0,0],
|
| | [0,np.cos(angles[0]),-np.sin(angles[0])],
|
| | [0,np.sin(angles[0]), np.cos(angles[0])]
|
| | ]) @ np.array([
|
| | [np.cos(angles[1]),0,np.sin(angles[1])],
|
| | [0,1,0],
|
| | [-np.sin(angles[1]), 0, np.cos(angles[1])]
|
| | ]) @ np.array([
|
| | [np.cos(angles[2]),-np.sin(angles[2]),0],
|
| | [np.sin(angles[2]), np.cos(angles[2]),0],
|
| | [0,0,1]
|
| | ])
|
| | return rand_rotation
|
| |
|
| | def get_model_info(obj, return_color=False, sample_num=2048):
|
| | if return_color:
|
| | model_points, model_color, symmetry_flag = obj.get_item(return_color, sample_num)
|
| | return (model_points, model_color, symmetry_flag)
|
| | else:
|
| | model_points, symmetry_flag = obj.get_item()
|
| | return (model_points, symmetry_flag)
|
| |
|
| | def get_bop_depth_map(inst):
|
| | scene_id, img_id, data_folder = inst['scene_id'], inst['img_id'], inst['data_folder']
|
| | try:
|
| | depth = np.array(Image.open(os.path.join(data_folder, f'{scene_id:06d}', 'depth', f'{img_id:06d}.png'))) / 1000.0
|
| | except:
|
| | depth = np.array(Image.open(os.path.join(data_folder, f'{scene_id:06d}', 'depth', f'{img_id:06d}.tif'))) / 1000.0
|
| | return depth
|
| |
|
| | def get_bop_image(inst, bbox, img_size, mask=None):
|
| | scene_id, img_id, data_folder = inst['scene_id'], inst['img_id'], inst['data_folder']
|
| | rmin, rmax, cmin, cmax = bbox
|
| | img_path = os.path.join(data_folder, f'{scene_id:06d}/')
|
| |
|
| | strs = [f'rgb/{img_id:06d}.jpg', f'rgb/{img_id:06d}.png', f'gray/{img_id:06d}.tif']
|
| | for s in strs:
|
| | if os.path.exists(os.path.join(img_path,s)):
|
| | img_path = os.path.join(img_path,s)
|
| | break
|
| |
|
| | rgb = load_im(img_path).astype(np.uint8)
|
| | if len(rgb.shape)==2:
|
| | rgb = np.concatenate([rgb[:,:,None], rgb[:,:,None], rgb[:,:,None]], axis=2)
|
| | rgb = rgb[..., ::-1][rmin:rmax, cmin:cmax, :3]
|
| | if mask is not None:
|
| | rgb = rgb * (mask[:,:,None]>0).astype(np.uint8)
|
| | rgb = cv2.resize(rgb, (img_size, img_size), interpolation=cv2.INTER_LINEAR)
|
| | return rgb
|
| |
|
| |
|
| |
|
| |
|
