optimize preprocessor

utils/data_load.py

@@ -204,7 +204,9 @@ class DataLoadUtil:
                 os.path.dirname(path), "normal", os.path.basename(path) + "_R.png"
             )
             normal_image_R = cv2.imread(normal_path_R, cv2.IMREAD_COLOR)
-            return normal_image_L[:3,:3], normal_image_R[:3,:3]
+            normalized_normal_image_L = normal_image_L / 255.0 * 2.0 - 1.0
+            normalized_normal_image_R = normal_image_R / 255.0 * 2.0 - 1.0
+            return normalized_normal_image_L, normalized_normal_image_R
         else:
             if binocular and left_only:
                 normal_path = os.path.join(
@@ -215,7 +217,8 @@ class DataLoadUtil:
                     os.path.dirname(path), "normal", os.path.basename(path) + ".png"
                 )
             normal_image = cv2.imread(normal_path, cv2.IMREAD_COLOR)
-            return normal_image
+            normalized_normal_image = normal_image / 255.0 * 2.0 - 1.0
+            return normalized_normal_image
 
     @staticmethod
     def load_label(path):

utils/pts.py

@@ -1,6 +1,7 @@
 import numpy as np
 import open3d as o3d
 import torch
+from scipy.spatial import cKDTree
 
 class PtsUtil:
 
@@ -56,17 +57,36 @@ class PtsUtil:
         return overlapping_points
     
     @staticmethod
-    def filter_points(points, normals, cam_pose, theta=75, require_idx=False):
+    def new_filter_points(points, normals, cam_pose, theta=75, require_idx=False):
         camera_axis = -cam_pose[:3, 2] 
         normals_normalized = normals / np.linalg.norm(normals, axis=1, keepdims=True)
         cos_theta = np.dot(normals_normalized, camera_axis)
         theta_rad = np.deg2rad(theta)
         idx = cos_theta > np.cos(theta_rad)
-        print(cos_theta, theta_rad)
         filtered_points= points[idx]
-        # ------  Debug Start ------
-        import ipdb;ipdb.set_trace()
-        # ------  Debug End ------
         if require_idx:
             return filtered_points, idx
-        return filtered_points
+        return filtered_points
+    
+    @staticmethod
+    def filter_points(points, points_normals, cam_pose,  voxel_size=0.002, theta=45, z_range=(0.2, 0.45)):
+        
+        """ filter with z range """
+        points_cam = PtsUtil.transform_point_cloud(points, np.linalg.inv(cam_pose))
+        idx = (points_cam[:, 2] > z_range[0]) & (points_cam[:, 2] < z_range[1])
+        z_filtered_points = points[idx]
+        
+        """ filter with normal """
+        sampled_points = PtsUtil.voxel_downsample_point_cloud(z_filtered_points, voxel_size)
+        kdtree = cKDTree(points_normals[:,:3])
+        _, indices = kdtree.query(sampled_points)
+        nearest_points = points_normals[indices]
+
+        normals = nearest_points[:, 3:]
+        camera_axis = -cam_pose[:3, 2] 
+        normals_normalized = normals / np.linalg.norm(normals, axis=1, keepdims=True)
+        cos_theta = np.dot(normals_normalized, camera_axis)
+        theta_rad = np.deg2rad(theta)
+        idx = cos_theta > np.cos(theta_rad)
+        filtered_sampled_points= sampled_points[idx] 
+        return filtered_sampled_points[:, :3]

utils/reconstruction.py

@@ -132,7 +132,7 @@ class ReconstructionUtil:
 
     
     @staticmethod
-    def generate_scan_points(display_table_top, display_table_radius, min_distance=0.03, max_points_num = 100, max_attempts = 1000):
+    def generate_scan_points(display_table_top, display_table_radius, min_distance=0.03, max_points_num = 500, max_attempts = 1000):
         points = []
         attempts = 0
         while len(points) < max_points_num and attempts < max_attempts: