tracking/utils/init_pcd.py

import os
import cv2
import numpy as np
import open3d as o3d
import argparse
from my_utils import depth2fgpcd, np2o3d,depth2fgpcd_w

SHOW=True

def pcd_axis(axis_length=2):
    point=np.linspace(0,axis_length,1000)
    axis_points=np.zeros((3000,3))
    axis_points[:1000,0]=point
    axis_points[1000:2000,1]=point
    axis_points[2000:,2]=point
    axis_colors=np.zeros((3000,3))
    axis_colors[:1000,0]=1.0
    axis_colors[1000:2000,1]=1.0
    axis_colors[2000:,2]=1.0
    axis_pcd=o3d.geometry.PointCloud()
    axis_pcd.points=o3d.utility.Vector3dVector(axis_points)
    axis_pcd.colors=o3d.utility.Vector3dVector(axis_colors)
    return axis_pcd

def aggr_point_cloud_from_data(colors, depths, segs, Ks, poses, downsample=False, masks=None, boundaries=None):
    # colors: [N, H, W, 3] numpy array in uint8
    # depths: [N, H, W] numpy array in meters
    # segs: [N, H, W, 3] numpy array in uint8
    # Ks: [N, 3, 3] numpy array
    # poses: [N, 4, 4] numpy array
    # masks: [N, H, W] numpy array in bool
    N, H, W, _ = colors.shape
    colors = colors / 255.
    segs = np.squeeze(segs)

    start = 0
    end = N
    step = 1
    pcds = []
    pcds_all = []
    for i in range(start, end, step):
        depth = depths[i]
        color = colors[i]
        seg = segs[i]
        K = Ks[i]
        cam_param = [K[0,0], K[1,1], K[0,2], K[1,2]] # fx, fy, cx, cy
        if masks is None:
            mask = (depth > 0) & (depth < 10)
        else:
            mask = masks[i] & (depth > 0)

        pose = poses[i]
        t_wc=pose[:3,3]
        R_wc=pose[:3,:3]

        # print(pose)
        r2c_mat=np.load("/home/ubuntu/magicsim/gs-dynamics/data/r2c0.npy")
        
        R_rc=r2c_mat[:3,:3]
        U,S,Vt=np.linalg.svd(R_rc)
        R_rc=U @ Vt

        t_rc=r2c_mat[3,:3]

        # pcd = depth2fgpcd(depth, mask, cam_param)

        pcd_r = depth2fgpcd_w(depth, mask, K)

        pcd_c = ( R_rc @ pcd_r.T + t_rc.reshape(3,1) ).T

        pcd_w = (R_wc @ pcd_c.T).T + t_wc

        trans_pcd= pcd_w

        
        if boundaries is not None:
            x_lower = boundaries['x_lower']
            x_upper = boundaries['x_upper']
            y_lower = boundaries['y_lower']
            y_upper = boundaries['y_upper']
            z_lower = boundaries['z_lower']
            z_upper = boundaries['z_upper']
            
            trans_pcd_mask = (trans_pcd[:, 0] > x_lower) & (trans_pcd[:, 0] < x_upper) &\
                             (trans_pcd[:, 1] > y_lower) & (trans_pcd[:, 1] < y_upper) &\
                             (trans_pcd[:, 2] > z_lower) & (trans_pcd[:, 2] < z_upper)
                                
            
            pcd_o3d, pcd_dicts = np2o3d(trans_pcd[trans_pcd_mask], color[mask][trans_pcd_mask], seg[mask][trans_pcd_mask])
        else:
            pcd_o3d, pcd_dicts = np2o3d(trans_pcd, color[mask], seg[mask])
        # downsample
        if downsample:
            radius = 0.01
            pcd_o3d = pcd_o3d.voxel_down_sample(radius)
            idx = pcd_o3d.volume_down_sample_and_trace(radius)
            pcd_dicts = pcd_dicts[idx]

        if SHOW:
            o3d.visualization.draw_geometries([pcd_o3d,pcd_axis()], window_name=f'Camera {i} point cloud')
        pcds.append(pcd_o3d)
        pcds_all.append(pcd_dicts)
    aggr_pcd = o3d.geometry.PointCloud()
    aggr_pcd_dicts = []
    for pcd in pcds:
        aggr_pcd += pcd
    for pcd_dicts in pcds_all:
        aggr_pcd_dicts.append(pcd_dicts)
    if SHOW:
        o3d.visualization.draw_geometries([aggr_pcd,pcd_axis()], window_name='Aggregated point cloud')
    return aggr_pcd, aggr_pcd_dicts

def read_camera_data(data_path, num_cam, t , norm=True):
    colors = np.stack([cv2.imread(os.path.join(data_path, f'camera_{i}', f'{t:06}.jpg')) for i in range(num_cam)], axis=0) 
    depths = np.stack([cv2.imread(os.path.join(data_path, f'camera_{i}', f'{t:06}_depth.png'), cv2.IMREAD_ANYDEPTH) for i in range(num_cam)], axis=0)
    if norm:
        depths = depths/1000.0
    segs = np.stack([cv2.imread(os.path.join(data_path, f'camera_{i}', 'seg', f'seg_{t:06}.png')) for i in range(num_cam)], axis=0)
    return colors, depths, segs

def load_camera_parameters(data_path, num_cam):
    extrinsics = np.stack([np.load(os.path.join(data_path, f'camera_{i}', 'camera_extrinsics.npy')) for i in range(num_cam)])
    cam_param = np.stack([np.load(os.path.join(data_path, f'camera_{i}', 'camera_params.npy')) for i in range(num_cam)])
    intrinsics = np.zeros((num_cam, 3, 3))
    intrinsics[:, 0, 0] = cam_param[:, 0]
    intrinsics[:, 1, 1] = cam_param[:, 1]
    intrinsics[:, 0, 2] = cam_param[:, 2]
    intrinsics[:, 1, 2] = cam_param[:, 3]
    intrinsics[:, 2, 2] = 1
    return extrinsics, intrinsics

def process_point_cloud(colors, depths, segs, intrinsics, extrinsics, boundaries):
    # Assuming aggr_point_cloud_from_data is a pre-defined function
    pcd, aggr_pcd_dicts = aggr_point_cloud_from_data(colors[..., ::-1], depths, segs, intrinsics, extrinsics, downsample=False, boundaries=boundaries)
    # pcd.remove_statistical_outlier(nb_neighbors=600, std_ratio=0.2)
    pcd.remove_radius_outlier(nb_points=200, radius=0.01)
    return pcd, aggr_pcd_dicts

def initialize_point_cloud_struct(aggr_pcd_dicts):
    len_of_data = sum(len(aggr_pcds) for aggr_pcds in aggr_pcd_dicts)
    init_pt_cld = np.zeros((len_of_data, 7))
    init_pcd = o3d.geometry.PointCloud()
    return init_pt_cld, init_pcd

def update_point_cloud(aggr_pcd_dicts, init_pt_cld, init_pcd):
    current_index = 0
    for aggr_pcds in aggr_pcd_dicts:
        for point, attributes in aggr_pcds.items():
            init_pcd.points.append(point)
            init_pt_cld[current_index, :3] = np.asarray(point)
            color = attributes['color']
            init_pcd.colors.append(color)
            init_pt_cld[current_index, 3:6] = np.asarray(color)
            seg_value = 0 if attributes['seg'].all() == 0 else 1
            init_pt_cld[current_index, 6] = seg_value
            current_index += 1
    return init_pt_cld, init_pcd

def save_point_clouds(data_path, point_clouds, i):
    for name, pcd in point_clouds.items():
        
        o3d.io.write_point_cloud(os.path.join(data_path, f'{name}_{i}.ply'), pcd)
        print(f"{name}.ply saved!")

def save_npz_file(data_path, file_name, data):
    np.savez(os.path.join(data_path, file_name), data=data)
    print(f"{file_name} saved!")

def add_colors_to_point_cloud(point_cloud, colors):
    point_cloud.colors = o3d.utility.Vector3dVector(colors)


def main(data_path, num_cam, t, boundaries=None, seg_flag=False):
    colors, depths, segs = read_camera_data(data_path, num_cam, t)
    extrinsics, intrinsics = load_camera_parameters(data_path, num_cam)
    pcd, aggr_pcd_dicts = process_point_cloud(colors, depths, segs, intrinsics, extrinsics, boundaries)
    init_pt_cld, init_pcd = initialize_point_cloud_struct(aggr_pcd_dicts)
    init_pt_cld, init_pcd = update_point_cloud(aggr_pcd_dicts, init_pt_cld, init_pcd)

    segmented_points = init_pt_cld[init_pt_cld[:, 6] == 1]
    if segmented_points.shape[0] == 0:
        raise ValueError("No points found with seg_value of 1")

    if seg_flag:
        convert_pcd = o3d.geometry.PointCloud()
        convert_pcd.points = o3d.utility.Vector3dVector(segmented_points[:, :3])
        convert_pcd.colors = o3d.utility.Vector3dVector(segmented_points[:, 3:6])
    else:
        convert_pcd = o3d.geometry.PointCloud()
        convert_pcd.points = o3d.utility.Vector3dVector(init_pt_cld[:, :3])

    convert_pcd.remove_radius_outlier(nb_points=600, radius=0.01)

    convert_pcd_seg = o3d.geometry.PointCloud()
    convert_pcd_seg.points = o3d.utility.Vector3dVector(segmented_points[:, :3])
    convert_pcd_seg.colors = o3d.utility.Vector3dVector(segmented_points[:, 3:6])

    if SHOW:
        o3d.visualization.draw_geometries([convert_pcd_seg,pcd_axis()],window_name=f"seg pcd")


    point_clouds = {
        'pcd': convert_pcd,
        'pcd_seg': convert_pcd_seg,
    }
    save_point_clouds(data_path, point_clouds, t)

    if seg_flag:
        save_npz_file(data_path, f'init_pt_cld_{t:04}.npz', segmented_points)
    else:
        save_npz_file(data_path, 'init_pt_cld.npz', init_pt_cld)

if __name__ == "__main__":
    argparser = argparse.ArgumentParser()
    argparser.add_argument('--data_path', type=str, default="/home/ubuntu/magicsim/gs-dynamics/data/episode_rope/episode_00")
    # argparser.add_argument('--num_cam', type=int, default=4)
    # argparser.add_argument('--t', type=int, required=True, help='timestamp')
    # argparser.add_argument('--seg_flag', default=False, help='whether to use segmentation')
    args = argparser.parse_args()
    data_path = args.data_path
    num_cam = 4
    seg_flag = True
    # boundaries = {'x_lower': x_lower,
    #             'x_upper': x_upper,
    #             'y_lower': y_lower,
    #             'y_upper': y_upper,
    #             'z_lower': z_lower,
    #             'z_upper': z_upper,}

    boundaries = {
        'x_lower': -5,
        'x_upper': 5,
        'y_lower': -5,
        'y_upper': 5,
        'z_lower': 0.1,
        'z_upper': 10,
        }

    main(data_path, num_cam, 0, boundaries=None, seg_flag=seg_flag)