Upload align_scannetpp.py

align_scannetpp.py

@@ -0,0 +1,227 @@
+import open3d as o3d
+import numpy as np
+import os
+
+def align_scene_to_z_up(pcd, save_pcd_path=None, save_transform_path=None, visualize=False, fit_ground=True):
+    """
+    将点云扫描转换为Z轴向上对齐，并尝试将墙壁对齐到X-Y平面
+    
+    参数:
+        points (np.ndarray): (N, 3) 点云数据
+        visualize (bool): 是否可视化结果
+        
+    返回:
+        aligned_points (np.ndarray): 对齐后的点云
+        transform_matrix (np.ndarray): 应用的4x4变换矩阵
+    """
+    points = np.asarray(pcd.points)
+    centroid = np.mean(points, axis=0)
+    distance_threshold = 0.02  # 动态距离阈值
+    R_ground = np.eye(3)  # Initialize ground rotation matrix
+    if fit_ground:
+        plane_model, ground_inliers = pcd.segment_plane(
+            distance_threshold=distance_threshold,
+            ransac_n=3,
+            num_iterations=1000
+        )
+        [a, b, c, d] = plane_model
+        ground_normal = np.array([a, b, c])
+        # print('ground_normal:', ground_normal)
+        # 可视化地面点云
+        ground_cloud = pcd.select_by_index(ground_inliers)
+        ground_cloud.paint_uniform_color([1, 0, 0])  # 红色表示地面
+        if visualize:
+            o3d.visualization.draw_geometries([ground_cloud])
+        
+        # 3. 计算旋转矩阵使地面法向量对齐到Z轴
+        z_axis = np.array([0, 0, 1])
+        ground_normal = ground_normal / np.linalg.norm(ground_normal)
+        
+        # 计算旋转轴和角度
+        rotation_axis = np.cross(ground_normal, z_axis)
+        if np.linalg.norm(rotation_axis) < 1e-6:
+            rotation_axis = np.array([0, 1, 0])  # 避免零向量
+        else:
+            rotation_axis = rotation_axis / np.linalg.norm(rotation_axis)
+        
+        cos_theta = np.dot(ground_normal, z_axis)
+        angle = np.arccos(np.clip(cos_theta, -1.0, 1.0))
+
+        # 使用罗德里格斯公式计算旋转矩阵
+        K = np.array([
+            [0, -rotation_axis[2], rotation_axis[1]],
+            [rotation_axis[2], 0, -rotation_axis[0]],
+            [-rotation_axis[1], rotation_axis[0], 0]
+        ])
+        R_ground = np.eye(3) + np.sin(angle) * K + (1 - np.cos(angle)) * (K @ K)
+        
+        # [Alternate] concise method
+        # from scipy.spatial.transform import Rotation as R
+        # R_ground = R.from_rotvec(rotation_axis * angle).as_matrix()
+
+        # 4. 应用地面旋转
+        centered_points = points - centroid
+        ground_rotated = (R_ground @ centered_points.T).T
+        
+        # 5. 检测墙壁平面（垂直平面）
+        all_indices = np.arange(len(points))
+        non_ground_indices = np.setdiff1d(all_indices, ground_inliers)
+        non_ground_points = ground_rotated[non_ground_indices]
+        
+        # 创建临时点云用于墙壁检测
+        temp_pcd = o3d.geometry.PointCloud()
+        temp_pcd.points = o3d.utility.Vector3dVector(non_ground_points)
+        remaining_pcd = temp_pcd
+    else:
+        # already z up
+        remaining_pcd = pcd
+    
+    wall_planes = []
+    wall_directions = []
+    max_points = 0
+    best_direction = None
+    R_walls = np.eye(3)
+    # 检测多个墙壁平面
+    for _ in range(6):
+        if len(remaining_pcd.points) < 100:
+            break
+            
+        plane_model, inliers = remaining_pcd.segment_plane(
+            distance_threshold=distance_threshold,
+            ransac_n=3,
+            num_iterations=1000
+        )
+        
+        wall_cloud = remaining_pcd.select_by_index(inliers)
+        wall_cloud.paint_uniform_color([1, 0, 0])  # 红色表示地面
+        if visualize:
+            o3d.visualization.draw_geometries([wall_cloud])
+
+        [a, b, c, d] = plane_model
+        normal = np.array([a, b, c])
+        
+        # 检查是否为垂直平面（法向量的Z分量接近0）
+        if abs(normal[2]) < 0.1 and np.linalg.norm(normal[:2]) > 0.5:
+            # 提取水平方向
+            horizontal_dir = normal[:2] / np.linalg.norm(normal[:2])
+            wall_directions = horizontal_dir
+            # print('wall direction',normal)
+            if max_points < len(inliers):
+                max_points = len(inliers)
+                # print(max_points)
+                best_direction = wall_directions
+                 # 计算最佳方向的旋转角度
+                angle = np.arctan2(best_direction[1], best_direction[0])
+                
+                # 创建最终的旋转矩阵
+                R_walls = np.array([
+                    [np.cos(-angle), -np.sin(-angle), 0],
+                    [np.sin(-angle), np.cos(-angle), 0],
+                    [0, 0, 1]
+                ])
+        
+        remaining_pcd = remaining_pcd.select_by_index(inliers, invert=True)
+
+    
+    # 8. 创建变换矩阵（旋转 + 平移）
+    if fit_ground:
+        # Compose the transformations: first ground rotation, then wall rotation
+        combined_rotation = R_walls @ R_ground
+        transform_matrix = np.eye(4)
+        transform_matrix[:3, :3] = combined_rotation
+        transform_matrix[:3, 3] = -combined_rotation @ centroid
+    else:
+        # Only wall rotation
+        transform_matrix = np.eye(4)
+        transform_matrix[:3, :3] = R_walls
+        transform_matrix[:3, 3] = -R_walls @ centroid  # 平移使中心到原点
+    
+    # 9. 应用变换
+    aligned_points = (transform_matrix[:3, :3] @ points.T + transform_matrix[:3, 3:4]).T
+    
+    # 10. 创建对齐后的点云
+    aligned_pcd = o3d.geometry.PointCloud()
+    aligned_pcd.points = o3d.utility.Vector3dVector(aligned_points)
+
+    if pcd.colors:
+        aligned_pcd.colors = pcd.colors
+    
+    # 11. 保存结果
+    if save_pcd_path:
+        o3d.io.write_point_cloud(save_pcd_path, aligned_pcd)
+    
+    if save_transform_path:
+        np.savetxt(save_transform_path, transform_matrix, fmt='%.8f')
+    
+
+    
+    return aligned_pcd, transform_matrix
+
+    """创建4x4变换矩阵"""
+    transform = np.eye(4)
+    transform[:3, :3] = rotation_matrix
+    return transform
+
+def visualize_alignment(pcd_orig, pcd_aligned):
+    """可视化原始点云和对齐后的点云"""
+    pcd_orig.paint_uniform_color([1, 0, 0])  # 红色为原始点云
+    pcd_aligned.paint_uniform_color([0, 1, 0])  # 绿色为对齐后点云
+    
+    # 创建坐标系
+    coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=1.0)
+    
+    o3d.visualization.draw_geometries([pcd_orig, pcd_aligned, coord_frame])
+
+
+
+npy_dir = '/media/vivo/vivo/Datasets/ScanNetpp/ScanNetpp_preprocessed/train/'
+scene_names = os.listdir(npy_dir)
+
+for scene_name in scene_names:
+    if scene_name.endswith('.zip'): 
+        continue
+
+    print(scene_name)
+
+    scene_dir = os.path.join(npy_dir, scene_name)
+
+    npy_path = os.path.join(scene_dir, 'coord.npy')
+    points = np.load(npy_path)  # (N, 3) 或 (N, 6)
+
+    # 创建点云对象
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points[:, :3])
+
+    if points.shape[1] == 6:
+        pcd.colors = o3d.utility.Vector3dVector(points[:, 3:6])  # 如果包含 RGB
+    
+    
+    # 执行对齐
+    transformed_pcd, transform = align_scene_to_z_up(
+        pcd,
+        # save_transform_path=os.path.join(scene_dir, "transform.txt"),
+        visualize=False,
+        fit_ground=False
+    )
+
+    aligned_points = np.asarray(transformed_pcd.points)
+
+    # scale point cloud
+    # min_z = np.min(aligned_points[:, 2])
+    # max_z = np.max(aligned_points[:, 2])
+    # height = max_z - min_z
+    # print(f"Original height: {height}")
+    # estimated_height = 2.5
+    # scale = estimated_height / height
+    # print(f"Scale factor: {scale}")
+
+    # aligned_points_scaled = aligned_points * scale
+
+    transformed_pcd.points = o3d.utility.Vector3dVector(aligned_points)
+
+    # 保存为对齐后的 PLY 文件
+    # aligned_ply_path = os.path.join(scene_dir, scene_name + ".ply")
+    # o3d.io.write_point_cloud(aligned_ply_path, transformed_pcd)
+
+    # 也可以保存为对齐后的 npy
+    np.save(os.path.join(scene_dir, "coord_align.npy"), aligned_points)