init from mihai generated h5 files

.gitattributes

@@ -53,3 +53,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+*.hdf5 filter=lfs diff=lfs merge=lfs -text

bbox_dataset.py

@@ -0,0 +1,166 @@
+""" GraspNet dataset processing.
+"""
+
+import os
+import sys
+import numpy as np
+import numpy.ma as ma
+import scipy.io as scio
+from scipy.optimize import linear_sum_assignment
+from PIL import Image
+from skimage.measure import label, regionprops
+import cv2
+
+import torch
+from collections import abc as container_abcs
+from torch.utils.data import Dataset
+from tqdm import tqdm
+from torch.utils.data import DataLoader
+from time import time
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+from .data_utils import CameraInfo, transform_point_cloud, create_point_cloud_from_depth_image, \
+    get_workspace_mask, remove_invisible_grasp_points
+import h5py
+
+
+class GraspNetDataset(Dataset):
+    def __init__(self, root, valid_obj_idxs, camera='kinect', split='train', remove_invisible=True,
+                 augment=False, limited_data=False, overfitting=False, k_grasps=1, ground_truth_type="topk", caching=True):
+        self.root = root
+        self.split = split
+        self.remove_invisible = remove_invisible
+        self.valid_obj_idxs = valid_obj_idxs
+        self.camera = camera
+        self.augment = augment
+        self.k_grasps = k_grasps
+        self.ground_truth_type = ground_truth_type
+        self.overfitting = overfitting
+        self.caching = caching
+
+        if overfitting:
+            limited_data = True
+        self.limited_data = limited_data
+
+        if split == 'train':
+            self.sceneIds = list(range(100))
+        elif split == 'test':
+            self.sceneIds = list(range(100, 190))
+        elif split == 'test_seen':
+            self.sceneIds = list(range(100, 130))
+        elif split == 'test_similar':
+            self.sceneIds = list(range(130, 160))
+        elif split == 'test_novel':
+            self.sceneIds = list(range(160, 190))
+        if limited_data:
+            self.sceneIds = self.sceneIds[:10]
+        self.sceneIds = ['scene_{}'.format(str(x).zfill(4)) for x in self.sceneIds]
+
+        filename = f"dataset/{split}_labels"
+        if limited_data and not overfitting:
+            filename += "_limited"
+        if overfitting:
+            filename += "_overfitting"
+        filename += ".hdf5"
+        self.h5_filename = filename
+        self.h5_file = None
+        self.grasp_labels_filename = "dataset/grasp_labels.hdf5"
+        self.grasp_labels_file = None
+
+        with h5py.File(self.h5_filename, 'r') as f:
+            self.len = f['depthpath'].shape[0]
+
+    def __len__(self):
+        return self.len
+
+    def __getitem__(self, index):
+        if self.h5_file is None:
+            self.h5_file = h5py.File(self.h5_filename, 'r')
+
+        ann_id = int(str(self.h5_file['metapath'][index], 'utf-8').split("meta")[1][1:-4])
+
+        color = np.array(Image.open(self.h5_file['colorpath'][index]), dtype=np.float32) / 255.0
+        depth = np.array(Image.open(self.h5_file['depthpath'][index]))
+
+        # fixing depth image where value is 0
+        p99 = np.percentile(depth[depth != 0], 99)
+        # p1 = abs(np.percentile(depth[depth != 0], 1))
+        depth[depth > p99] = p99
+        depth[depth == 0] = p99
+
+        seg = np.array(Image.open(self.h5_file['labelpath'][index]))
+        meta = scio.loadmat(self.h5_file['metapath'][index])
+        scene = self.h5_file['scenename'][index]
+
+        main_path = str(self.h5_file['metapath'][index], 'utf-8').split("meta")[0]
+        cam_extrinsics = np.load(os.path.join(str(self.h5_file['metapath'][index], 'utf-8').split("meta")[0],
+                                              'camera_poses.npy'))[ann_id]
+        cam_wrt_table = np.load(os.path.join(str(self.h5_file['metapath'][index], 'utf-8').split("meta")[0],
+                                             'cam0_wrt_table.npy'))
+        cam_extrinsics = cam_wrt_table.dot(cam_extrinsics).astype(np.float32)
+
+        try:
+            obj_idxs = meta['cls_indexes'].flatten().astype(np.int32)
+            poses = meta['poses']
+            intrinsic = meta['intrinsic_matrix']
+            factor_depth = meta['factor_depth']
+        except Exception as e:
+            print(repr(e))
+            print(scene)
+
+        # h_ratio = 800 / 720
+        # w_ratio = 1333 / 1280
+
+        camera = CameraInfo(1280.0, 720.0, intrinsic[0][0], intrinsic[1][1], intrinsic[0][2], intrinsic[1][2], factor_depth)
+
+        ## generate cloud required to remove invisible grasp points
+        #cloud = create_point_cloud_from_depth_image(depth, camera, organized=True)
+
+        obj_bounding_boxes = []
+        for i, obj_idx in enumerate(obj_idxs):
+            if obj_idx not in self.valid_obj_idxs:
+                continue
+            if (seg == obj_idx).sum() < 50:
+                continue
+
+            seg_cpy = seg.copy()
+            seg_cpy[seg != obj_idx] = 0
+            seg_cpy[seg == obj_idx] = 1
+            seg_labels = label(seg_cpy)
+            regions = regionprops(seg_labels)
+
+            # b has start_height, start_width, end_height, end_width = (x_min, y_min, x_max, y_max)
+            b = regions[0].bbox
+            # saved bbox has xyxy
+            H, W = seg.shape[0], seg.shape[1]
+
+            obj_bounding_boxes.append(np.array([b[1] / W, b[0] / H, b[3] / W, b[2] / H])[None].repeat(self.k_grasps, 0))
+        obj_bounding_boxes = np.concatenate(obj_bounding_boxes, axis=0).astype(np.float32)
+
+        ret_dict = {}
+        #ret_dict['point_cloud'] = cloud.transpose((2, 0, 1)).astype(np.float32)
+        ret_dict['color'] = color.transpose((2, 0, 1)).astype(np.float32)
+        ret_dict['depth'] = (depth / camera.scale).astype(np.float32)
+        ret_dict['objectness_label'] = seg.astype(np.int32)
+        ret_dict['obj_bounding_boxes'] = obj_bounding_boxes
+        ret_dict['camera_intrinsics'] = np.expand_dims(np.concatenate([intrinsic.reshape(-1), factor_depth[0]]), -1).astype(np.float32)
+        ret_dict['camera_extrinsics'] = cam_extrinsics.astype(np.float32)
+        #ret_dict['transformed_points'] = transformed_points.astype(np.float32)
+        ret_dict['obj_idxs'] = obj_idxs
+
+        return ret_dict
+
+
+def load_valid_obj_idxs():
+    obj_names = list(range(88))
+    valid_obj_idxs = []
+    for i, obj_name in enumerate(obj_names):
+        if i == 18: continue
+        valid_obj_idxs.append(i + 1)  # here align with label png
+
+    return valid_obj_idxs
+
+
+def my_worker_init_fn(worker_id):
+    np.random.seed(np.random.get_state()[1][0] + worker_id)
+    pass

data_utils.py

@@ -0,0 +1,149 @@
+""" Tools for data processing.
+    Author: chenxi-wang
+"""
+
+import numpy as np
+
+class CameraInfo():
+    """ Camera intrisics for point cloud creation. """
+    def __init__(self, width, height, fx, fy, cx, cy, scale):
+        self.width = width
+        self.height = height
+        self.fx = fx
+        self.fy = fy
+        self.cx = cx
+        self.cy = cy
+        self.scale = scale
+
+def create_point_cloud_from_depth_image(depth, camera, organized=True):
+    """ Generate point cloud using depth image only.
+
+        Input:
+            depth: [numpy.ndarray, (H,W), numpy.float32]
+                depth image
+            camera: [CameraInfo]
+                camera intrinsics
+            organized: bool
+                whether to keep the cloud in image shape (H,W,3)
+
+        Output:
+            cloud: [numpy.ndarray, (H,W,3)/(H*W,3), numpy.float32]
+                generated cloud, (H,W,3) for organized=True, (H*W,3) for organized=False
+    """
+    assert(depth.shape[0] == camera.height and depth.shape[1] == camera.width)
+    xmap = np.arange(camera.width)
+    ymap = np.arange(camera.height)
+    xmap, ymap = np.meshgrid(xmap, ymap)
+    points_z = depth / camera.scale
+    points_x = (xmap - camera.cx) * points_z / camera.fx
+    points_y = (ymap - camera.cy) * points_z / camera.fy
+    cloud = np.stack([points_x, points_y, points_z], axis=-1)
+    if not organized:
+        cloud = cloud.reshape([-1, 3])
+    return cloud
+
+def transform_point_cloud(cloud, transform, format='4x4'):
+    """ Transform points to new coordinates with transformation matrix.
+
+        Input:
+            cloud: [np.ndarray, (N,3), np.float32]
+                points in original coordinates
+            transform: [np.ndarray, (3,3)/(3,4)/(4,4), np.float32]
+                transformation matrix, could be rotation only or rotation+translation
+            format: [string, '3x3'/'3x4'/'4x4']
+                the shape of transformation matrix
+                '3x3' --> rotation matrix
+                '3x4'/'4x4' --> rotation matrix + translation matrix
+
+        Output:
+            cloud_transformed: [np.ndarray, (N,3), np.float32]
+                points in new coordinates
+    """
+    if not (format == '3x3' or format == '4x4' or format == '3x4'):
+        raise ValueError('Unknown transformation format, only support \'3x3\' or \'4x4\' or \'3x4\'.')
+    if format == '3x3':
+        cloud_transformed = np.dot(transform, cloud.T).T
+    elif format == '4x4' or format == '3x4':
+        ones = np.ones(cloud.shape[0])[:, np.newaxis]
+        cloud_ = np.concatenate([cloud, ones], axis=1)
+        cloud_transformed = np.dot(transform, cloud_.T).T
+        cloud_transformed = cloud_transformed[:, :3]
+    return cloud_transformed
+
+def compute_point_dists(A, B):
+    """ Compute pair-wise point distances in two matrices.
+
+        Input:
+            A: [np.ndarray, (N,3), np.float32]
+                point cloud A
+            B: [np.ndarray, (M,3), np.float32]
+                point cloud B
+
+        Output:
+            dists: [np.ndarray, (N,M), np.float32]
+                distance matrix
+    """
+    A = A[:, np.newaxis, :]
+    B = B[np.newaxis, :, :]
+    dists = np.linalg.norm(A-B, axis=-1)
+    return dists
+
+def remove_invisible_grasp_points(cloud, grasp_points, pose, th=0.01):
+    """ Remove invisible part of object model according to scene point cloud.
+
+        Input:
+            cloud: [np.ndarray, (N,3), np.float32]
+                scene point cloud
+            grasp_points: [np.ndarray, (M,3), np.float32]
+                grasp point label in object coordinates
+            pose: [np.ndarray, (4,4), np.float32]
+                transformation matrix from object coordinates to world coordinates
+            th: [float]
+                if the minimum distance between a grasp point and the scene points is greater than outlier, the point will be removed
+
+        Output:
+            visible_mask: [np.ndarray, (M,), np.bool]
+                mask to show the visible part of grasp points
+    """
+    grasp_points_trans = transform_point_cloud(grasp_points, pose)
+    dists = compute_point_dists(grasp_points_trans, cloud)
+    min_dists = dists.min(axis=1)
+    visible_mask = (min_dists < th)
+    return visible_mask
+
+def get_workspace_mask(cloud, seg, trans=None, organized=True, outlier=0):
+    """ Keep points in workspace as input.
+
+        Input:
+            cloud: [np.ndarray, (H,W,3), np.float32]
+                scene point cloud
+            seg: [np.ndarray, (H,W,), np.uint8]
+                segmantation label of scene points
+            trans: [np.ndarray, (4,4), np.float32]
+                transformation matrix for scene points, default: None.
+            organized: [bool]
+                whether to keep the cloud in image shape (H,W,3)
+            outlier: [float]
+                if the distance between a point and workspace is greater than outlier, the point will be removed
+                
+        Output:
+            workspace_mask: [np.ndarray, (H,W)/(H*W,), np.bool]
+                mask to indicate whether scene points are in workspace
+    """
+    if organized:
+        h, w, _ = cloud.shape
+        cloud = cloud.reshape([h*w, 3])
+        seg = seg.reshape(h*w)
+    if trans is not None:
+        cloud = transform_point_cloud(cloud, trans)
+    foreground = cloud[seg>0]
+    xmin, ymin, zmin = foreground.min(axis=0)
+    xmax, ymax, zmax = foreground.max(axis=0)
+    mask_x = ((cloud[:,0] > xmin-outlier) & (cloud[:,0] < xmax+outlier))
+    mask_y = ((cloud[:,1] > ymin-outlier) & (cloud[:,1] < ymax+outlier))
+    mask_z = ((cloud[:,2] > zmin-outlier) & (cloud[:,2] < zmax+outlier))
+    workspace_mask = (mask_x & mask_y & mask_z)
+    if organized:
+        workspace_mask = workspace_mask.reshape([h, w])
+
+    return workspace_mask

grasp_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c2cb4478af68123236739f784c430432558bb1984240c810519501b43e5ba73
+size 27649926048

test_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cce93092c5d48ace0ffbc34a800a0c8997cc12fd9161382ea9dca36187d26d0b
+size 13738218528

test_labels_limited.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57f845819b33566b49137e16669fb21a47d193310d9229b9ed94e03707f5948b
+size 1847477632

test_novel_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b6ab6d23ba11440f2c37d895bec769751841551796ffbf19e9a09f8b3e760e4
+size 3820886464

test_novel_labels_limited.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e99e19baddac4480def00e03cc3a5829abce9e06266b4190478f21ef23554399
+size 1221612544

test_seen_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a56ab3f596b08bdcee0b55eb90b52193f0f18463f7aed58e37c7b1b98b0865fa
+size 5767926784

test_seen_labels_limited.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57f845819b33566b49137e16669fb21a47d193310d9229b9ed94e03707f5948b
+size 1847477632

test_seen_labels_overfitting.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4accd843326975e7ba805ee390104c19f671617991c73ec814aaaadca9f0ce36
+size 1845877136

test_similar_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37698bc1d5568b85eccf659cc568796865a50e2b1973f224741cf571324977f5
+size 4149426496

test_similar_labels_limited.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ad322ac599799601be38ce79dce25955e33a01641d178cfa1efd2c89977e7d1
+size 1699060928

train_labels.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a5ff1adba287d590d364ecd38d4d28679d998e1fe56143cdb2d5a3aec9123e
+size 17807294464

train_labels_limited.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3bc086730b39a2c2957d4d029adc30fcb87a3791f6f3968eb1a5a181d447dd3
+size 1623629632

train_labels_overfitting.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0216e80f3596d8050ed4113e7d3176398356ba313b47ceca3f86eed6e51d53d7
+size 1622029136