import sys sys.path.append("/home/kyber/charles/project/grasp_box") from submodules.SAM6D.pose_estimator import SAM6DPoseEstimator import numpy as np import argparse import json import yaml import cv2 import matplotlib.pyplot as plt import copy from tqdm import tqdm import glob import pickle import open3d as o3d import time import trimesh import os from pathlib import Path from utilis import render_cad_mask, find_matched_points,count_lines_passing_points, get_connected_vertices, intersection_in_xyz_axis class Perception: def __init__(self,config): self.config_path = config self.config = self.load_config(config) self.intrinsic_matrix = np.array( [ [ self.config["camera"]["intrinsic_matrix"]["f_x"], 0.0, self.config["camera"]["intrinsic_matrix"]["c_x"], ], [ 0.0, self.config["camera"]["intrinsic_matrix"]["f_y"], self.config["camera"]["intrinsic_matrix"]["c_y"], ], [0.0, 0.0, 1.0], ] ) self.pose_estimator = SAM6DPoseEstimator( config, self.intrinsic_matrix, "/home/kyber/charles/project/grasp_box/submodules/SAM6D/config/base.yaml", True ) def load_config(self, config_path): with open(config_path, "r") as file: return yaml.safe_load(file) def binary_search_scale(self, rgb,depth, mask, K, cad_name,debug=False,scale_min=[0.1, 0.15,0.15], scale_max=[0.3,0.18,0.5], threshold=15): h, w, _ = rgb.shape [low_x, low_y, low_z]=scale_min [high_x, high_y, high_z]=scale_max if set(np.unique(mask) ).issubset({0, 255}): mask = (mask // 255).astype(np.uint8) while low_x<=high_x and low_y <= high_y and low_z <= high_z: mid_x = (low_x+high_x)/2 mid_y = (low_y+high_y)/2 mid_z = (low_z+high_z)/2 self.pose_estimator.K = self.intrinsic_matrix pose_scores, pred_rot, pred_trans,color_vis,_ = self.pose_estimator.inference(rgb.copy(), mask.copy(), depth.copy(), cad_name, scale= [mid_x, mid_y,mid_z]) pose = np.eye(4) pose[:3,3] = pred_trans pose[:3,:3] = pred_rot mesh_c = self.pose_estimator.cad_cache['tmp']['mesh'] mask_r= render_cad_mask(pose, mesh_c, K, w, h) if debug: self.vis_3d(rgb, depth, [pose],K,mesh_c) breakpoint() # find nearset vertices, and project get length between vertices half_extents = mesh_c.extents / 2.0 signs = np.array([[x, y, z] for x in [-1, 1] for y in [-1, 1] for z in [-1, 1]]) vertices = signs * half_extents transformed_points = (pose @ np.hstack((vertices, np.ones((vertices.shape[0], 1)))).T).T[:, :3] projected_points = (K @ transformed_points.T).T projected_points[:, :2] /= projected_points[:, 2:3] condition = (projected_points[:, 0] < w) & (projected_points[:, 1] < h) filtered_points = projected_points[condition] filtered_indices = np.where(condition)[0] min_idx_in_filtered = np.argmin(np.linalg.norm(filtered_points)) original_index = filtered_indices[min_idx_in_filtered] nearest_index = original_index projected_points = projected_points[...,:2].astype(int) # if two vertices are matched, use this vertex as starting point and find intersection value, then get box extents directly gt_contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) gt_cnt = max(gt_contours, key=cv2.contourArea) gt_vertex = cv2.approxPolyDP(gt_cnt, epsilon=5, closed=True).reshape(-1,2) obs_contours, _ = cv2.findContours(mask_r.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) obs_cnt = max(obs_contours, key=cv2.contourArea) obs_vertex = cv2.approxPolyDP(obs_cnt, epsilon=5, closed=True).reshape(-1,2) vis = rgb.copy() for u, v in gt_vertex: cv2.circle(vis, tuple([u,v]), 5, (255, 0, 0), -1) # cv2.imwrite('a.png', vis) pair_match = find_matched_points(projected_points, gt_vertex, threshold=50) # early stopping, if key point matched, stop searching and return scale based on similarity for start_pt_index in range(8): start_pt = projected_points[start_pt_index] connected = get_connected_vertices(start_pt_index) norm_vectors = (projected_points[connected] - start_pt)/ np.linalg.norm(projected_points[connected] - start_pt) count = count_lines_passing_points(start_pt, norm_vectors, gt_vertex, threshold=threshold/2, rgb=rgb,vis = False) if count == 3: # lines start from start pt and project to xyz axis, all hits the vertex of gt mask, return the scale arr_gt, arr_obs = intersection_in_xyz_axis(norm_vectors, start_pt, mask_r, mask, threshold = threshold//2,vis = False, save = False) output_scale = [None] * 3 for axis_index,norm_vector in enumerate(norm_vectors): axis = np.nonzero(signs[connected[axis_index]] - signs[start_pt_index])[0][0] length_gt = arr_gt[axis_index] end_pt_obs = projected_points[connected[axis_index]] if end_pt_obs[0] not in range(0,rgb.shape[1]) or end_pt_obs[1] not in range(0,rgb.shape[0]): # out of boundary. get pixel distance directly from start and end point. add threshold for tolerance length_obs = np.linalg.norm(end_pt_obs - start_pt).astype(np.uint32) + threshold else: length_obs = arr_obs[axis_index] output_scale[axis] = round(length_gt * mesh_c.extents[axis]/length_obs,2) return output_scale if len(pair_match) == 0: start_pt_index = nearest_index else: pair_match = pair_match[0] start_pt_index = pair_match[0] start_pt = projected_points[start_pt_index] connected = get_connected_vertices(start_pt_index) norm_vectors = (projected_points[connected] - start_pt)/ np.linalg.norm(projected_points[connected] - start_pt) arr_gt, arr_obs = intersection_in_xyz_axis(norm_vectors, start_pt, mask_r, mask,threshold,vis = False, save = False) if abs(arr_gt-arr_obs)[0] <= 20 and abs(arr_gt-arr_obs)[1] <= 20 and abs(arr_gt-arr_obs)[2] <= 20: break if abs(high_x-low_x) < 0.1 and abs(high_y-low_y) < 1 and abs(high_z-low_z) < 0.1: break if (arr_obs[0] - arr_gt[0]) > 0: high_x = mid_x elif (arr_obs[0] - arr_gt[0]) < 0: low_x = mid_x if (arr_obs[1] - arr_gt[1]) > 0: high_y = mid_y elif (arr_obs[1] - arr_gt[1]) < 0: low_y = mid_y if (arr_obs[2] - arr_gt[2]) > 0: high_z = mid_z elif (arr_obs[2] - arr_gt[2]) < 0: low_z = mid_z final_scale = self.pose_estimator.cad_cache['tmp']['mesh'].extents return final_scale def vis_3d(self, rgb_img, depth_img, pose_list,intrinsic,mesh, mask = None): vis = o3d.visualization.Visualizer() vis.create_window() if mask is not None: rgb_img = rgb_img * mask[:,:,None] depth_img = depth_img * mask rgb = o3d.geometry.Image(rgb_img) # for uinit16 use depth = o3d.geometry.Image((depth_img).astype(np.uint16)) # mask = (mask > 0).astype(np.uint8) rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth, depth_scale=1000.0) width = rgb_img.shape[1] height = rgb_img.shape[0] cx = int(intrinsic[0,2]) cy = int(intrinsic[1,2]) fx = int(intrinsic[0,0]) fy = int(intrinsic[1,1]) intri = o3d.camera.PinholeCameraIntrinsic(width=width, height=height, fx=fx, fy=fy, cx=cx, cy=cy) o3d_points = o3d.geometry.PointCloud.create_from_rgbd_image(rgbd, intrinsic=intri) vis.add_geometry(o3d_points) # vis.add_geometry(o3d.geometry.TriangleMesh.create_coordinate_frame(1)) vis.update_geometry(o3d_points) for i,pose in enumerate(pose_list): # mesh = trimesh.load(self.config['cad_database'][f'{box_name[i]}'], force='mesh') # mesh_o3d = o3d.io.read_triangle_mesh(f"/media/kyber/Data1/SAM-6D/SAM-6D/Data/Storage_hq_test/model/{box_name}/model.obj",enable_post_processing=True) mesh_o3d = o3d.geometry.TriangleMesh() mesh_o3d.vertices = o3d.utility.Vector3dVector(mesh.vertices) mesh_o3d.triangles = o3d.utility.Vector3iVector(mesh.faces) aabb = mesh_o3d.get_axis_aligned_bounding_box() extents = aabb.get_extent() mesh_o3d.transform(pose) # print('----------------------------->',extents) mesh_o3d.paint_uniform_color([1.0, 0.0, 0.0]) mesh_o3d = o3d.geometry.TriangleMesh(o3d.utility.Vector3dVector(mesh.vertices), o3d.utility.Vector3iVector(mesh.faces)) pcd_obj = mesh_o3d.sample_points_uniformly(number_of_points=5000) pcd_obj_trans = copy.deepcopy(pcd_obj).transform(pose) pcd_obj_trans.paint_uniform_color([1.0, 0.0, 0.0]) vis.add_geometry(pcd_obj_trans) vis.update_geometry(pcd_obj_trans) vis.run() def run(self, depth_img, color_img, mask_img, K = None,debug = False, gt = False): if K is not None: self.intrinsic_matrix = K color_vis = copy.deepcopy(color_img) assert len(mask_img.shape) == 2 # vis the GT # box = trimesh.load(f'/workspace/PACE/models/obj_{str(obj_id).zfill(6)}.ply', force='mesh') # box_rescale = box.copy() # box_rescale.vertices = box_rescale.vertices/1000 # self.vis_3d(color_img, depth_img, [gt_pose],self.intrinsic_matrix,box_rescale) # use box infer module to infer the scale & pose tmp_scores = -1 output_pose = None output_scores = None output_scale = None self.pose_estimator.K = self.intrinsic_matrix assert np.isin(mask_img, [0,1]).all() for run_idx in range(2): scale = self.binary_search_scale(color_img,depth_img, mask_img*255, self.intrinsic_matrix, 'R306',debug=False,scale_min=[0.1, 0.15,0.15], scale_max=[0.3,0.18,0.5],threshold=10) box_ori_scale = self.pose_estimator.cad_cache['R306']['mesh'].extents new_scale = np.round(scale/box_ori_scale,2) pose_scores, pred_rot, pred_trans,color_vis, _ = self.pose_estimator.inference(color_img.copy(), mask_img*255, depth_img.copy(), 'R306', new_scale) pose6d = np.eye(4) pose6d[:3,:3] = pred_rot pose6d[:3,3] = pred_trans mesh = copy.deepcopy(self.pose_estimator.cad_cache['tmp']['mesh']) print('scores:', pose_scores) if pose_scores is None: continue if pose_scores > tmp_scores: output_pose = pose6d output_scores = pose_scores output_scale = mesh.extents tmp_scores = pose_scores self.vis_3d(color_img, depth_img, [pose6d],self.intrinsic_matrix,mesh) # IoU = iou_3d_boxes(box.extents/1000, gt_pose, mesh.extents, pose6d, grid_n=100) # IoU = compute_3d_iou_new(gt_pose, pose6d, box.extents/1000, mesh.extents,0,'box','box') # vis example from cpff++ # box_ori_scale = self.pose_estimator.cad_cache['R306']['mesh'].extents # new_scale = np.round(cpf_scale/box_ori_scale,2) # mesh = copy.deepcopy(self.pose_estimator.cad_cache['tmp']['mesh']) # self.vis_3d(color_img, depth_img, [cpf_pose],self.intrinsic_matrix,mesh) return output_pose, output_scores, output_scale if __name__ == '__main__': config = '/home/kyber/charles/project/grasp_box/config/config_perception.yaml' perception = Perception(config) color_img = cv2.imread('/home/kyber/charles/project/grasp_box/data/000000_rgb.png', cv2.IMREAD_COLOR) depth_img = cv2.imread('/home/kyber/charles/project/grasp_box/data/000000_depth.png', -1) # unit mm mask = ~cv2.imread('/home/kyber/charles/project/grasp_box/data/000000_box-colgate.png', -1) mask = mask.astype(bool) mask = mask.astype(np.uint8) pose,scores, extents = perception.run(depth_img = depth_img, color_img = color_img, mask_img=mask)