AnyBox / project /grasp_box /perception_function.py

Add files using upload-large-folder tool

b24c748 verified 8 months ago

12.7 kB

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,intrinsic, extrinsic):   
        self.intrinsic_matrix = intrinsic
        self.pose_estimator = SAM6DPoseEstimator(
                config=None,
                self.intrinsic_matrix,
                "/home/kyber/charles/project/grasp_box/submodules/SAM6D/config/base.yaml",
                True
            )
        self.extrinsic = extrinsic
        
    def binary_search_scale(self, rgb,depth, mask, 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, self.intrinsic_matrix, w, h)
            if debug:
                self.vis_3d(rgb, depth, [pose],self.intrinsic_matrix,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 = (self.intrinsic_matrix @ 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,debug = False, gt = False):
       
        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)
        pose_word = self.extrinsic @ output_pose
        return pose_word, output_scores, output_scale

    
if __name__ == '__main__':

    config = '/home/kyber/charles/project/grasp_box/config/config_perception.yaml'
    
    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)  
    intrinsic = np.eye(3)
    extrinsic = np.eye(4)
    perception = Perception(intrinsic,extrinsic )
    pose,scores, extents = perception.run(depth_img = depth_img, color_img = color_img,  mask_img=mask)

	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,intrinsic, extrinsic):
	self.intrinsic_matrix = intrinsic
	self.pose_estimator = SAM6DPoseEstimator(
	config=None,
	self.intrinsic_matrix,
	"/home/kyber/charles/project/grasp_box/submodules/SAM6D/config/base.yaml",
	True
	)
	self.extrinsic = extrinsic

	def binary_search_scale(self, rgb,depth, mask, 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, self.intrinsic_matrix, w, h)
	if debug:
	self.vis_3d(rgb, depth, [pose],self.intrinsic_matrix,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 = (self.intrinsic_matrix @ 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,debug = False, gt = False):

	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)
	pose_word = self.extrinsic @ output_pose
	return pose_word, output_scores, output_scale


	if __name__ == '__main__':

	config = '/home/kyber/charles/project/grasp_box/config/config_perception.yaml'

	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)
	intrinsic = np.eye(3)
	extrinsic = np.eye(4)
	perception = Perception(intrinsic,extrinsic )
	pose,scores, extents = perception.run(depth_img = depth_img, color_img = color_img, mask_img=mask)