add get_real_cam_O_from_cam_L()

runners/inferencer.py

@@ -75,7 +75,7 @@ class Inferencer(Runner):
                     status_manager.set_progress("inference", "inferencer", f"Batch[{test_set_name}]", i+1, total)
                     test_set.process_batch(data, self.device)
                     output = self.predict_sequence(data)
-                    self.save_inference_result(output, data)
+                    self.save_inference_result(test_set_name, data["scene_name"][0], output)
                     
             status_manager.set_progress("inference", "inferencer", f"dataset", len(self.test_set_list), len(self.test_set_list))
         
@@ -129,9 +129,10 @@ class Inferencer(Runner):
 
             pred_cr = self.compute_coverage_rate(scanned_view_pts, new_target_pts_world, down_sampled_model_pts, threshold=voxel_threshold)
             pred_cr_seq.append(pred_cr)
+            print(pred_cr, last_pred_cr)
             if pred_cr >= data["max_coverage_rate"]:
                 break
-            if pred_cr < last_pred_cr + cr_increase_threshold:
+            if pred_cr <= last_pred_cr + cr_increase_threshold:
                 break
             scanned_view_pts.append(new_target_pts_world)
             down_sampled_new_pts_world = PtsUtil.random_downsample_point_cloud(new_pts_world, input_pts_N)
@@ -144,10 +145,7 @@ class Inferencer(Runner):
             input_data["scanned_n_to_world_pose_9d"] = [torch.cat([input_data["scanned_n_to_world_pose_9d"][0], next_pose_9d], dim=0)]
             
             last_pred_cr = pred_cr
-            # ------  Debug Start ------
-            import ipdb;ipdb.set_trace()
-            # ------  Debug End ------
-            
+            print(last_pred_cr)
         
         input_data["scanned_pts"] = input_data["scanned_pts"][0].cpu().numpy().tolist()
         input_data["scanned_n_to_world_pose_9d"] = input_data["scanned_n_to_world_pose_9d"][0].cpu().numpy().tolist()
@@ -175,7 +173,8 @@ class Inferencer(Runner):
         dataset_dir = os.path.join(self.output_dir, dataset_name)
         if not os.path.exists(dataset_dir):
             os.makedirs(dataset_dir)
-        pickle.dump(output, open(f"result_{scene_name}.pkl", "wb"))
+        output_path = os.path.join(dataset_dir, f"{scene_name}.pkl")
+        pickle.dump(output, open(output_path, "wb"))
     
 
     def get_checkpoint_path(self, is_last=False):

utils/data_load.py

@@ -189,6 +189,16 @@ class DataLoadUtil:
             cam_info["cam_to_world_R"] = cam_to_world_R
         return cam_info
     
+    @staticmethod
+    def get_real_cam_O_from_cam_L(cam_L, cam_O_to_cam_L, display_table_as_world_space_origin=True):
+        nO_to_display_table_pose = cam_L.cpu().numpy()  @ cam_O_to_cam_L
+        if display_table_as_world_space_origin:
+            display_table_to_world = np.eye(4)
+            display_table_to_world[:3, 3] = DataLoadUtil.DISPLAY_TABLE_POSITION
+            nO_to_world_pose = np.dot(display_table_to_world, nO_to_display_table_pose)
+        nO_to_world_pose = DataLoadUtil.cam_pose_transformation(nO_to_world_pose)
+        return nO_to_world_pose
+    
     @staticmethod
     def get_target_point_cloud(depth, cam_intrinsic, cam_extrinsic, mask, target_mask_label=(0,255,0,255)):
         h, w = depth.shape

utils/render.py

@@ -10,8 +10,8 @@ class RenderUtil:
 
     @staticmethod
     def render_pts(cam_pose, scene_path,script_path, model_points_normals, voxel_threshold=0.005, filter_degree=75, nO_to_nL_pose=None, require_full_scene=False):
-        nO_to_world_pose = cam_pose.cpu().numpy()  @ nO_to_nL_pose
-        nO_to_world_pose = DataLoadUtil.cam_pose_transformation(nO_to_world_pose)
+        
+        nO_to_world_pose = DataLoadUtil.get_real_cam_O_from_cam_L(cam_pose, nO_to_nL_pose)
         
         
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -30,14 +30,13 @@ class RenderUtil:
                 print(result.stderr)
                 return None
             path = os.path.join(temp_dir, "tmp")
-            # ------  Debug Start ------
-            import ipdb;ipdb.set_trace()
-            # ------  Debug End ------
             
             point_cloud = DataLoadUtil.get_target_point_cloud_world_from_path(path, binocular=True)
             cam_params = DataLoadUtil.load_cam_info(path, binocular=True)
             filtered_point_cloud = ReconstructionUtil.filter_points(point_cloud, model_points_normals, cam_pose=cam_params["cam_to_world"], voxel_size=voxel_threshold, theta=filter_degree)
-            
+            # ------  Debug Start ------
+            import ipdb;ipdb.set_trace()
+            # ------  Debug End ------
             full_scene_point_cloud = None
             if require_full_scene:
                 depth_L, depth_R = DataLoadUtil.load_depth(path, cam_params['near_plane'], cam_params['far_plane'], binocular=True)