update scan_points strategy

utils/reconstruction.py

@@ -8,7 +8,7 @@ class ReconstructionUtil:
     def compute_coverage_rate(target_point_cloud, combined_point_cloud, threshold=0.01):
         kdtree = cKDTree(combined_point_cloud)
         distances, _ = kdtree.query(target_point_cloud)
-        covered_points = np.sum(distances < threshold)
+        covered_points = np.sum(distances < threshold*2)
         coverage_rate = covered_points / target_point_cloud.shape[0]
         return coverage_rate
     
@@ -17,7 +17,10 @@ class ReconstructionUtil:
         kdtree = cKDTree(combined_point_cloud)
         distances, _ = kdtree.query(new_point_cloud)
         overlapping_points = np.sum(distances < threshold)
-        overlap_rate = overlapping_points / new_point_cloud.shape[0]
+        if new_point_cloud.shape[0] == 0:
+            overlap_rate = 0
+        else:
+            overlap_rate = overlapping_points / new_point_cloud.shape[0]
         return overlap_rate
     
     @staticmethod
@@ -43,12 +46,23 @@ class ReconstructionUtil:
                 best_view = view_index
         return best_view, best_coverage_increase
 
+    @staticmethod
+    def get_new_added_points(old_combined_pts, new_pts, threshold=0.005):
+        if old_combined_pts.size == 0:
+            return new_pts
+        if new_pts.size == 0:
+            return np.array([])
+
+        tree = cKDTree(old_combined_pts)
+        distances, _ = tree.query(new_pts, k=1)
+        new_added_points = new_pts[distances > threshold]
+        return new_added_points
     
     @staticmethod
-    def compute_next_best_view_sequence_with_overlap(target_point_cloud, point_cloud_list, scan_points_indices_list, threshold=0.01, overlap_threshold=0.3, init_view = 0, status_info=None):
+    def compute_next_best_view_sequence_with_overlap(target_point_cloud, point_cloud_list, scan_points_indices_list, threshold=0.01, soft_overlap_threshold=0.5, hard_overlap_threshold=0.7, init_view = 0, scan_points_threshold=5, status_info=None):
         selected_views = [point_cloud_list[init_view]]
         combined_point_cloud = np.vstack(selected_views)
-        combined_scan_points_indices = scan_points_indices_list[init_view]
+        history_indices = [scan_points_indices_list[init_view]]
         down_sampled_combined_point_cloud = PtsUtil.voxel_downsample_point_cloud(combined_point_cloud,threshold)
         new_coverage = ReconstructionUtil.compute_coverage_rate(target_point_cloud, down_sampled_combined_point_cloud, threshold)
         current_coverage = new_coverage
@@ -62,16 +76,23 @@ class ReconstructionUtil:
             best_coverage_increase = -1
         
             for view_index in remaining_views:
-                
+                if point_cloud_list[view_index].shape[0] == 0:
+                    continue
+
                 if selected_views:
                     new_scan_points_indices = scan_points_indices_list[view_index]
-                    if not ReconstructionUtil.check_scan_points_overlap(combined_scan_points_indices, new_scan_points_indices):
-                        combined_old_point_cloud = np.vstack(selected_views)
-                        down_sampled_old_point_cloud = PtsUtil.voxel_downsample_point_cloud(combined_old_point_cloud,threshold)
-                        down_sampled_new_view_point_cloud = PtsUtil.voxel_downsample_point_cloud(point_cloud_list[view_index],threshold)
-                        overlap_rate = ReconstructionUtil.compute_overlap_rate(down_sampled_new_view_point_cloud,down_sampled_old_point_cloud, threshold)
-                        if overlap_rate < overlap_threshold:
-                            continue
+                    
+                    if not ReconstructionUtil.check_scan_points_overlap(history_indices, new_scan_points_indices, scan_points_threshold):
+                        overlap_threshold = hard_overlap_threshold
+                    else:
+                        overlap_threshold = soft_overlap_threshold
+                        
+                    combined_old_point_cloud = np.vstack(selected_views)
+                    down_sampled_old_point_cloud = PtsUtil.voxel_downsample_point_cloud(combined_old_point_cloud,threshold)
+                    down_sampled_new_view_point_cloud = PtsUtil.voxel_downsample_point_cloud(point_cloud_list[view_index],threshold)
+                    overlap_rate = ReconstructionUtil.compute_overlap_rate(down_sampled_new_view_point_cloud,down_sampled_old_point_cloud, threshold)
+                    if overlap_rate < overlap_threshold:
+                        continue
                     
                 candidate_views = selected_views + [point_cloud_list[view_index]]
                 combined_point_cloud = np.vstack(candidate_views)
@@ -88,7 +109,7 @@ class ReconstructionUtil:
                     break
                 selected_views.append(point_cloud_list[best_view])
                 remaining_views.remove(best_view)
-                combined_scan_points_indices = ReconstructionUtil.combine_scan_points_indices(combined_scan_points_indices, scan_points_indices_list[best_view])
+                history_indices.append(scan_points_indices_list[best_view])
                 current_coverage += best_coverage_increase
                 cnt_processed_view += 1
                 if status_info is not None:
@@ -110,7 +131,7 @@ class ReconstructionUtil:
         return view_sequence, remaining_views, down_sampled_combined_point_cloud
     
     @staticmethod
-    def filter_points(points, points_normals, cam_pose,  voxel_size=0.005, theta=45):
+    def filter_points(points, points_normals, cam_pose,  voxel_size=0.005, theta=75):
         sampled_points = PtsUtil.voxel_downsample_point_cloud(points, voxel_size)
         kdtree = cKDTree(points_normals[:,:3])
         _, indices = kdtree.query(sampled_points)
@@ -143,6 +164,7 @@ class ReconstructionUtil:
     
     @staticmethod
     def compute_covered_scan_points(scan_points, point_cloud, threshold=0.01):
+        
         tree = cKDTree(point_cloud)
         covered_points = []
         indices = []
@@ -153,10 +175,10 @@ class ReconstructionUtil:
         return covered_points, indices
     
     @staticmethod
-    def check_scan_points_overlap(indices1, indices2, threshold=5):
-        return len(set(indices1).intersection(set(indices2))) > threshold
-    
-    @staticmethod
-    def combine_scan_points_indices(indices1, indices2):
-        combined_indices = set(indices1) | set(indices2)
-        return sorted(combined_indices)
+    def check_scan_points_overlap(history_indices, indices2, threshold=5):
+        for indices1 in history_indices:
+            if len(set(indices1).intersection(set(indices2))) >= threshold:
+                return True
+        return False
+
+