如何使用Python的Open3D开源库进行三维数据处理

简介

在本文中，我提供了一个关于如何使用Python的Open3D库（一个用于3D数据处理的开源库）来探索、处理和可视化3D模型的快速演练。

使用Open3D可视化的3D模型（链接https://sketchfab.com/3d-models/tesla-model-s-plaid-9de8855fae324e6cbbb83c9b5288c961处可找到原始3D模型）

如果您正在考虑处理特定任务的3D数据/模型，例如训练3D模型分类和/或分割AI模型，那么您会发现本演练是很有帮助的。互联网上的3D模型（在ShapeNet等数据集中）有多种格式，如.obj、.glb、.gltf等。使用Open3D等库，可以轻松处理、可视化这些模型，并将其转换为其他格式，如点云，因为这些格式更容易理解和解释。

注意，这篇文章也可以作为Jupyter笔记本提供给那些希望跟随并在本地运行代码的人。包含Jupyter笔记本以及所有其他数据和有关资源的zip文件可以从下面的链接下载。

3D Data Processing with Open3D.zip。

在本教程中，我将完成以下任务：

  1. 将三维模型加载为网格并将其可视化
  2. 通过采样点将网格转换为点云
  3. 从点云中删除隐藏点
  4. 将点云转换为数据帧
  5. 保存点云和数据帧

下面，让我们从导入所有必要的库开始：

  1. # 导入open3d和所有其他必要的库。
  2.  
  3. import open3d as o3d
  4. import os
  5. import copy
  6. import numpy as np
  7. import pandas as pd
  8. from PIL import Image
  9.  
  10. np.random.seed(42)
  11. #正在检查open3d上安装的版本。
  12.  
  13. o3d.__version__
  14. # Open3D version used in this exercise: 0.16.0
将三维模型加载为网格并将其可视化

通过运行以下代码行，可以将3D模型读取为网格：

  1. #定义三维模型文件的路径。
  2. mesh_path = "data/3d_model.obj"
  3.  
  4. # 使用open3d将三维模型文件读取为三维网格。
  5. mesh = o3d.io.read_triangle_mesh(mesh_path)

要可视化网格，请运行以下代码行：

  1. #可视化网格。
  2. draw_geoms_list = [mesh]
  3. o3d.visualization.draw_geometries(draw_geoms_list)

网格应该在一个新窗口中打开，看起来应该像下面的图像（请注意，网格打开时是静态图像，而不是像这里显示的动画图像）。可以使用鼠标指针根据需要旋转网格图像。

可视化为网格的3D模型（在估计曲面法线之前）

如上所述，汽车网格看起来不像典型的3D模型，而是渲染成了统一的灰色。这是因为网格没有任何关于三维模型中顶点和曲面的法线的信息。

什么是法线呢？-曲面在给定点处的法向量是垂直于该点处曲面的向量。法向量通常简称为“法线”。要阅读更多关于此主题的内容，可以参考以下两个链接：法线向量和估计点云中的曲面法线。

可以通过运行以下代码行来估计上面三维网格的法线：

  1. # 计算网格的法线。
  2. mesh.compute_vertex_normals()
  3.  
  4. #可视化网格。
  5. draw_geoms_list = [mesh]
  6. o3d.visualization.draw_geometries(draw_geoms_list)

一旦可视化，网格应该如下图所示出现。计算法线后，汽车将正确渲染，看起来像一个3D模型。

可视化为网格的3D模型（在估计表面法线之后）

现在，让我们创建一个XYZ坐标系，以了解这个汽车模型在欧几里得空间中的方向。XYZ坐标系可以覆盖在上面的3D网格上，并通过运行以下代码行进行可视化：

  1. # 创建XYZ轴笛卡尔坐标系的网格。
  2. # 该网格将显示X、Y和Z轴指向的方向，并且可以覆盖在3D网格上，以可视化其在欧几里得空间中的方向。
  3. # X-axis : 红色箭头
  4. # Y-axis : 绿色箭头
  5. # Z-axis : 蓝色箭头
  6. mesh_coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=5, origin=[0, 0, 0])
  7.  
  8. #使用坐标系可视化网格，以了解方向。
  9. draw_geoms_list = [mesh_coord_frame, mesh]
  10. o3d.visualization.draw_geometries(draw_geoms_list)

使用XYZ坐标系可视化的三维网格（X轴：红色箭头，Y轴：绿色箭头，Z轴：蓝色箭；[简记为——XYZ：：RGB]）

从上面的可视化中，我们可以看到这个汽车网格的方向如下：

  • XYZ轴的原点：在汽车模型的体积中心（在上图中看不到，因为它在汽车网格内）。
  • X轴（红色箭头）：沿着汽车的长度尺寸，正X轴指向汽车的发动机罩（在上图中看不到，因为它在汽车网格内）。
  • Y轴（绿色箭头）：沿着汽车的高度尺寸，正Y轴指向汽车的车顶。
  • Z轴（蓝色箭头）：沿着汽车的宽度尺寸，正Z轴指向汽车的右侧。

现在，让我们来看看这个汽车模型里面有什么。为此，我们将在Z轴上裁剪网格，并移除汽车的右半部分（正Z轴）。

  1. #使用其束框裁剪汽车网格以移除其右半部分（正Z轴）。
  2. bbox = mesh.get_axis_aligned_bounding_box()
  3. bbox_points = np.asarray(bbox.get_box_points())
  4. bbox_points[:, 2] = np.clip(bbox_points[:, 2], a_min=None, a_max=0)
  5. bbox_cropped = o3d.geometry.AxisAlignedBoundingBox.create_from_points(o3d.utility.Vector3dVector(bbox_points))
  6. mesh_cropped = mesh.crop(bbox_cropped)
  7.  
  8. # 可视化裁剪的网格。
  9. draw_geoms_list = [mesh_coord_frame, mesh_cropped]
  10. o3d.visualization.draw_geometries(draw_geoms_list)

在移除汽车右半部分的情况下，在Z轴上裁剪三维网格（正Z轴）。裁剪后的网格显示了此3D汽车模型中的详细内部

从上面的可视化中，我们可以看到这款车型有着详细的内饰。现在我们已经看到了这个3D网格内部的内容，我们可以在移除属于汽车内部的“隐藏”点之前将其转换为点云。

通过采样点将网格转换为点云

通过定义，我们希望从网格中采样的点的数量，可以在Open3D中轻松地将网格转换为点云。

  1. #从网格中均匀采样100000个点，将其转换为点云。
  2. n_pts = 100_000
  3. pcd = mesh.sample_points_uniformly(n_pts)
  4.  
  5. #可视化点云。
  6. draw_geoms_list = [mesh_coord_frame, pcd]
  7. o3d.visualization.draw_geometries(draw_geoms_list)

通过从三维网格中均匀采样100000个点创建的三维点云

请注意，上面点云中的颜色仅指示点沿Z轴的位置。

如果我们像裁剪上面的网格一样裁剪点云，它会是这样的：

  1. #使用边界框裁剪汽车点云以移除其右半部分（正Z轴）。
  2. pcd_cropped = pcd.crop(bbox_cropped)
  3.  
  4. #可视化裁剪的点云。
  5. draw_geoms_list = [mesh_coord_frame, pcd_cropped]
  6. o3d.visualization.draw_geometries(draw_geoms_list)

在移除汽车右半部分的情况下在Z轴上裁剪的三维点云（正Z轴）。与上面裁剪的网格一样，裁剪的点云也显示了此3D汽车模型中的详细内部

我们在裁剪点云的可视化中看到，它还包含属于汽车模型内部的点。这是意料之中的，因为该点云是通过对整个网格中的点进行均匀采样而创建的。在下一节中，我们将删除这些属于汽车内部且不在点云外表面的“隐藏”点。

从点云中删除隐藏点

想象一下，你把一盏灯指向汽车模型的右侧。落在三维模型右外表面上的所有点都将被照亮，而点云中的所有其他点则不会被照亮。

显示Open3D的隐藏点移除如何从给定的视点处理点云的插图。所有被照亮的点都被视为“可见”，而所有其他点都被认为是“隐藏”

现在，让我们将这些照明点标记为“可见”，将所有未照明点标记“隐藏”。这些“隐藏”点还将包括属于汽车内部的所有点。

此操作在Open3D中称为“隐藏点删除”。为了使用Open3D在点云上执行此操作，请运行以下代码行：

  1. # 定义隐藏点删除操作的摄影机和半径参数。
  2. diameter = np.linalg.norm(np.asarray(pcd.get_min_bound()) - np.asarray(pcd.get_max_bound()))
  3. camera = [0, 0, diameter]
  4. radius = diameter * 100
  5.  
  6. # 使用上面定义的摄影机和半径参数对点云执行隐藏点删除操作。
  7. #输出是可见点的索引列表。
  8. _, pt_map = pcd.hidden_point_removal(camera, radius)

使用上面的可见点索引输出列表，我们可以在可视化点云之前将可见点和隐藏点涂成不同的颜色。

  1. # 将点云中的所有可见点绘制为蓝色，将所有隐藏点绘制为红色。
  2.  
  3. pcd_visible = pcd.select_by_index(pt_map)
  4. pcd_visible.paint_uniform_color([0, 0, 1]) #蓝色点是可见点（需要保留）。
  5. print("No. of visible points : ", pcd_visible)
  6.  
  7. pcd_hidden = pcd.select_by_index(pt_map, invert=True)
  8. pcd_hidden.paint_uniform_color([1, 0, 0]) # 红色点是隐藏点（要删除）。
  9. print("No. of hidden points : ", pcd_hidden)
  10.  
  11. # 可视化点云中的可见（蓝色）和隐藏（红色）点。
  12. draw_geoms_list = [mesh_coord_frame, pcd_visible, pcd_hidden]
  13. o3d.visualization.draw_geometries(draw_geoms_list)

从上图所示的摄影机视点移除隐藏点操作后的点云。“可见”点为蓝色，而“隐藏”点为红色

从上面的可视化中，我们可以看到隐藏点移除操作是如何从给定的相机视点工作的。该操作消除了背景中被来自给定相机视点的前景中的点遮挡的所有点。

为了更好地理解这一点，我们可以再次重复相同的操作，但这次是在稍微旋转点云之后。实际上，我们正在努力改变这里的观点。但是，我们将旋转点云本身，而不是通过重新定义相机参数来改变它。

复制

  1. #定义将度数转换为弧度的函数。
  2. def deg2rad(deg):
  3.  return deg * np.pi/180
  4.  
  5. #将点云绕X轴旋转90度。
  6. x_theta = deg2rad(90)
  7. y_theta = deg2rad(0)
  8. z_theta = deg2rad(0)
  9. tmp_pcd_r = copy.deepcopy(pcd)
  10. R = tmp_pcd_r.get_rotation_matrix_from_axis_angle([x_theta, y_theta, z_theta])
  11. tmp_pcd_r.rotate(R, center=(0, 0, 0))
  12.  
  13. #可视化旋转的点云。
  14. draw_geoms_list = [mesh_coord_frame, tmp_pcd_r]
  15. o3d.visualization.draw_geometries(draw_geoms_list)

围绕X轴旋转90度的三维点云。请注意，与以前不同的是，现在Y轴（绿色箭头）沿着汽车的宽度尺寸运行，Z轴（蓝色箭头）沿着车辆的高度尺寸运行。X轴（红色箭头）没有变化，它仍然沿着汽车的长度方向运行

图示显示了隐藏点删除操作如何从与前面相同的给定视点对旋转的点云进行操作。如前所述，所有照明点都被视为“可见”，而所有其他点都被认为是“隐藏”。

通过对旋转的汽车模型再次重复相同的过程，我们可以看到，这一次，落在3D模型（车顶）上外表面的所有点都会被照亮，而点云中的所有其他点都不会被照亮。

我们可以通过运行以下代码行，对旋转的点云重复隐藏点删除操作：

  1. # 使用上面定义的相同摄影机和半径参数对旋转的点云执行隐藏点移除操作。
  2. #输出是可见点的索引列表。
  3. _, pt_map = tmp_pcd_r.hidden_point_removal(camera, radius)
  4.  
  5. # 将旋转的点云中的所有可见点绘制为蓝色，将所有隐藏点绘制为红色。
  6.  
  7. pcd_visible = tmp_pcd_r.select_by_index(pt_map)
  8. pcd_visible.paint_uniform_color([0, 0, 1]) # 蓝色点是可见点（需要保留）。
  9. print("No. of visible points : ", pcd_visible)
  10.  
  11. pcd_hidden = tmp_pcd_r.select_by_index(pt_map, invert=True)
  12. pcd_hidden.paint_uniform_color([1, 0, 0]) #红色点是隐藏点（要删除）。
  13. print("No. of hidden points : ", pcd_hidden)
  14.  
  15. #可视化旋转的点云中的可见（蓝色）和隐藏（红色）点。
  16. draw_geoms_list = [mesh_coord_frame, pcd_visible, pcd_hidden]
  17. o3d.visualization.draw_geometries(draw_geoms_list)

从上图所示的摄影机视点移除隐藏点操作后旋转的点云。同样，“可见”点为蓝色，而“隐藏”点为红色

上面旋转的点云的可视化清楚地说明了隐藏点移除操作是如何工作的。因此，现在，为了从这个汽车点云中移除所有“隐藏”点，我们可以通过将点云围绕所有三个轴从-90度到+90度稍微旋转来依次执行隐藏点移除操作。在每次删除隐藏点操作之后，我们可以聚合点的索引的输出列表。在所有隐藏点移除操作之后，点索引的聚合列表将包含所有未隐藏的点（即，位于点云的外表面上的点）。以下代码执行此顺序隐藏点删除操作：

  1. # 定义一个函数以在X、Y和Z轴上旋转点云。
  2. def get_rotated_pcd(pcd, x_theta, y_theta, z_theta):
  3.  pcd_rotated = copy.deepcopy(pcd)
  4.  R = pcd_rotated.get_rotation_matrix_from_axis_angle([x_theta, y_theta, z_theta])
  5.  pcd_rotated.rotate(R, center=(0, 0, 0))
  6.  return pcd_rotated
  7.  
  8. # 定义一个函数以获取隐藏点移除操作的点云的相机和半径参数。
  9. def get_hpr_camera_radius(pcd):
  10.  diameter = np.linalg.norm(np.asarray(pcd.get_min_bound()) - np.asarray(pcd.get_max_bound()))
  11.  camera = [0, 0, diameter]
  12.  radius = diameter * 100
  13.  return camera, radius
  14.  
  15. # 定义一个函数，使用前面定义的摄影机和半径参数对点云执行隐藏点删除操作。
  16. #输出是未隐藏的点的索引列表。
  17. def get_hpr_pt_map(pcd, camera, radius):
  18.  _, pt_map = pcd.hidden_point_removal(camera, radius) 
  19.  return pt_map
  20. # 通过在三个轴中的每一个轴上将点云从-90度略微旋转到+90度，依次执行隐藏点移除操作，并在每次操作后聚合未隐藏的点的索引列表。
  21.  
  22. # 定义一个列表来存储每个隐藏点删除操作的聚合输出列表。
  23. pt_map_aggregated = []
  24.  
  25. # 定义旋转点云的步长和角度值范围。
  26. theta_range = np.linspace(-90, 90, 7)
  27.  
  28. # 对顺序操作的次数进行计数。
  29. view_counter = 1
  30. total_views = theta_range.shape[0] ** 3
  31.  
  32. # 获取隐藏点移除操作的相机和半径参数。
  33. camera, radius = get_hpr_camera_radius(pcd)
  34.  
  35. # 循环使用上面为每个轴定义的角度值。
  36. for x_theta_deg in theta_range:
  37.  for y_theta_deg in theta_range:
  38.  for z_theta_deg in theta_range:
  39.  
  40.  print(f"Removing hidden points - processing view {view_counter} of {total_views}.")
  41.  
  42.  #按给定的角度值旋转点云。
  43.  x_theta = deg2rad(x_theta_deg)
  44.  y_theta = deg2rad(y_theta_deg)
  45.  z_theta = deg2rad(z_theta_deg)
  46.  pcd_rotated = get_rotated_pcd(pcd, x_theta, y_theta, z_theta)
  47.  
  48.  # 使用上面定义的摄影机和半径参数对旋转的点云执行隐藏点移除操作。
  49.  pt_map = get_hpr_pt_map(pcd_rotated, camera, radius)
  50.  
  51.  # 聚合未隐藏的点的索引的输出列表。
  52.  pt_map_aggregated += pt_map
  53.  
  54.  view_counter += 1
  55.  
  56. # 通过将聚合列表转换为集合，从聚合列表中删除所有重复的点。
  57. pt_map_aggregated = list(set(pt_map_aggregated))
  58. # 将点云中的所有可见点绘制为蓝色，将所有隐藏点绘制为红色。
  59.  
  60. pcd_visible = pcd.select_by_index(pt_map_aggregated)
  61. pcd_visible.paint_uniform_color([0, 0, 1]) # 蓝色点是可见点（需要保留）。
  62. print("No. of visible points : ", pcd_visible)
  63.  
  64. pcd_hidden = pcd.select_by_index(pt_map_aggregated, invert=True)
  65. pcd_hidden.paint_uniform_color([1, 0, 0]) # 红色点是隐藏点（要删除）。
  66. print("No. of hidden points : ", pcd_hidden)
  67.  
  68. # 可视化点云中的可见（蓝色）和隐藏（红色）点。
  69. draw_geoms_list = [mesh_coord_frame, pcd_visible, pcd_hidden]
  70. # draw_geoms_list = [mesh_coord_frame, pcd_visible]
  71. # draw_geoms_list = [mesh_coord_frame, pcd_hidden]
  72. o3d.visualization.draw_geometries(draw_geoms_list)

从同一摄影机视点执行所有顺序隐藏点移除操作后的点云。聚合的“可见”点（即点云外表面上的点）为蓝色，而“隐藏”点（如不在点云外表面对的点）则为红色

让我们再次裁剪点云，看看属于汽车内部的点。

  1. #使用先前定义的边界框裁剪可见点的点云，以移除其右半部分（正Z轴）。
  2. pcd_visible_cropped = pcd_visible.crop(bbox_cropped)
  3.  
  4. # 使用先前定义的边界框裁剪隐藏点的点云，以移除其右半部分（正Z轴）。
  5. pcd_hidden_cropped = pcd_hidden.crop(bbox_cropped)
  6.  
  7. # 可视化裁剪的点云。
  8. draw_geoms_list = [mesh_coord_frame, pcd_visible_cropped, pcd_hidden_cropped]
  9. o3d.visualization.draw_geometries(draw_geoms_list)

在所有顺序的隐藏点移除操作之后裁剪的点云，以红色显示属于3D汽车模型内部的所有“隐藏”点

从隐藏点移除操作后裁剪的点云的上述可视化中，我们可以看到，属于汽车模型内部的所有“隐藏”点（红色）现在都与点云外表面的“可见”点（蓝色）分离。

将点云转换为数据帧

正如人们所期望的那样，点云中每个点的位置可以由三个数值定义——X、Y和Z坐标。请记住，在上面的部分中，我们还估计了3D网格中每个点的曲面法线。当我们从该网格中采样点以创建点云时，点云中的每个点还包含与这些曲面法线相关的三个附加属性——X、Y和Z方向上的法线单位向量坐标。

因此，为了将点云转换为数据帧，点云中的每个点都可以用以下七个属性列在一行中来表示：

  1. X坐标（浮动）
  2. Y坐标（浮动）
  3. Z坐标（浮动）
  4. X方向上的法向量坐标（浮点）
  5. Y方向上的法向量坐标（浮点）
  6. Z方向上的法向量坐标（浮动）
  7. 可见点（布尔值True或False）

通过运行以下代码行，可以将点云转换为数据帧：

  1. # 为点云创建一个数据帧，其中包含所有点的X、Y和Z位置坐标以及X、Y、Z方向上的法向单位向量坐标。
  2. pcd_df = pd.DataFrame(np.concatenate((np.asarray(pcd.points), np.asarray(pcd.normals)), axis=1),
  3.  columns=["x", "y", "z", "norm-x", "norm-y", "norm-z"]
  4.  )
  5.  
  6. # 使用上面隐藏点删除操作中的点索引聚合列表，添加一列以指示点是否可见。
  7. pcd_df["point_visible"] = False
  8. pcd_df.loc[pt_map_aggregated, "point_visible"] = True

这将返回如下所示的数据帧，其中每个点都是由上面解释的七个属性列表示的行。

转换为数据帧的三维点云

保存点云和数据帧

现在可以通过运行以下代码行来保存点云（删除隐藏点之前和之后）和数据帧：

  1. # 将整个点云保存为.pcd文件。
  2. pcd_save_path = "data/3d_model.pcd"
  3. o3d.io.write_point_cloud(pcd_save_path, pcd)
  4.  
  5. # 将删除了隐藏点的点云保存为.pcd文件。
  6. pcd_visible_save_path = "data/3d_model_hpr.pcd"
  7. o3d.io.write_point_cloud(pcd_visible_save_path, pcd_visible)
  8.  
  9. # 将点云数据帧保存为.csv文件。
  10. pcd_df_save_path = "data/3d_model.csv"
  11. pcd_df.to_csv(pcd_df_save_path, index=False)

三维模型（顶部：整体，底部：裁剪）可视化为：1——网格；2——一个点云；3——删除隐藏点后的点云

注：本文转载自blog.csdn.net的lock cylinder的文章"https://blog.csdn.net/qq_34144750/article/details/134713584"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！