• （9）点云数据处理学习——Global registration（全局注册）

    1、主要参考

    （1）官网的地址

    Global registration — Open3D 0.16.0 documentation

    2、作用和原理

    2.1个人理解

    PS理解：（1）ICP的作用是，2个点云数据在初步转换关系（已知不精确）的情况下进行精细调整。（2）Global registration是不知道2个点云数据的初始关系，直接来一波计算，得到初步转换关系，接下来给ICP计算用。

     2.2 介绍

    ICP配准和彩色点云配准都被称为本地配准方法，因为它们依赖于粗略对齐作为初始化。本教程展示了另一类注册方法，称为全局注册。这一系列算法不需要对初始化进行对齐。它们通常产生不太紧密的对齐结果，并被用作局部方法的初始化。

    2.3 例子中封装的可视化函数

    下面的辅助函数将转换后的源点云与目标点云一起可视化:

    1. def draw_registration_result(source, target, transformation):
    2.     source_temp = copy.deepcopy(source)
    3.     target_temp = copy.deepcopy(target)
    4.     source_temp.paint_uniform_color([1, 0.706, 0])
    5.     target_temp.paint_uniform_color([0, 0.651, 0.929])
    6.     source_temp.transform(transformation)
    7.     o3d.visualization.draw_geometries([source_temp, target_temp],
    8.                                       zoom=0.4559,
    9.                                       front=[0.6452, -0.3036, -0.7011],
    10.                                       lookat=[1.9892, 2.0208, 1.8945],
    11.                                       up=[-0.2779, -0.9482, 0.1556])

    2.4 提取几何特征

    我们对点云进行下采样，估计法线，然后为每个点计算一个FPFH特征。FPFH特征是描述点的局部几何性质的33维向量。在33维空间中的最近邻查询可以返回具有相似局部几何结构的点。详见[Rasu2009]。

    1. def preprocess_point_cloud(pcd, voxel_size):
    2.     print(":: Downsample with a voxel size %.3f." % voxel_size)
    3.     pcd_down = pcd.voxel_down_sample(voxel_size)
    4.  
    5.     radius_normal = voxel_size * 2
    6.     print(":: Estimate normal with search radius %.3f." % radius_normal)
    7.     pcd_down.estimate_normals(
    8.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_normal, max_nn=30))
    9.  
    10.     radius_feature = voxel_size * 5
    11.     print(":: Compute FPFH feature with search radius %.3f." % radius_feature)
    12.     pcd_fpfh = o3d.pipelines.registration.compute_fpfh_feature(
    13.         pcd_down,
    14.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_feature, max_nn=100))
    15.     return pcd_down, pcd_fpfh

     3、测试的例子

    3.1 读取输入的两个点云文件

    下面的代码从两个文件读取一个源点云和一个目标点云。它们与单位矩阵的变换不对齐。

    （1）注意：下面代码中的np.identity(4)，相当于没有进行平移和旋转 

    1. import open3d as o3d
    2. import numpy as np
    3. from copy import deepcopy
    4.  
    5. def draw_registration_result(source, target, transformation):
    6.     # source_temp = copy.deepcopy(source)
    7.     # target_temp = copy.deepcopy(target)
    8.     source_temp = deepcopy(source)
    9.     target_temp = deepcopy(target)
    10.     source_temp.paint_uniform_color([1, 0.706, 0])
    11.     target_temp.paint_uniform_color([0, 0.651, 0.929])
    12.     source_temp.transform(transformation)
    13.     o3d.visualization.draw_geometries([source_temp, target_temp],
    14.                                       zoom=0.4559,
    15.                                       front=[0.6452, -0.3036, -0.7011],
    16.                                       lookat=[1.9892, 2.0208, 1.8945],
    17.                                       up=[-0.2779, -0.9482, 0.1556])
    18.  
    19.  
    20. def preprocess_point_cloud(pcd, voxel_size):
    21.     print(":: Downsample with a voxel size %.3f." % voxel_size)
    22.     pcd_down = pcd.voxel_down_sample(voxel_size)
    23.  
    24.     radius_normal = voxel_size * 2
    25.     print(":: Estimate normal with search radius %.3f." % radius_normal)
    26.     pcd_down.estimate_normals(
    27.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_normal, max_nn=30))
    28.  
    29.     radius_feature = voxel_size * 5
    30.     print(":: Compute FPFH feature with search radius %.3f." % radius_feature)
    31.     pcd_fpfh = o3d.pipelines.registration.compute_fpfh_feature(
    32.         pcd_down,
    33.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_feature, max_nn=100))
    34.     return pcd_down, pcd_fpfh
    35.  
    36.  
    37. def prepare_dataset(voxel_size):
    38.     print(":: Load two point clouds and disturb initial pose.")
    39.  
    40.     demo_icp_pcds = o3d.data.DemoICPPointClouds()
    41.     source = o3d.io.read_point_cloud(demo_icp_pcds.paths[0])
    42.     target = o3d.io.read_point_cloud(demo_icp_pcds.paths[1])
    43.     trans_init = np.asarray([[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0],
    44.                              [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]])
    45.     source.transform(trans_init)
    46.     draw_registration_result(source, target, np.identity(4))
    47.  
    48.     source_down, source_fpfh = preprocess_point_cloud(source, voxel_size)
    49.     target_down, target_fpfh = preprocess_point_cloud(target, voxel_size)
    50.     return source, target, source_down, target_down, source_fpfh, target_fpfh
    51.  
    52.  
    53. if __name__ == "__main__":
    54.     voxel_size = 0.05  # means 5cm for this dataset
    55.     source, target, source_down, target_down, source_fpfh, target_fpfh = prepare_dataset(
    56.         voxel_size)
    57.

    （2）下载后应该用了下面的这个文件

     （3）显示的两个点云初始关系如下

     （4）操作流程

     3.2 RANSAC算法和测试

    3.2.1原理

          我们使用RANSAC进行全局注册。在每次RANSAC迭代中，从源点云中选取ransac_n个随机点。通过在33维FPFH特征空间中查询最近的邻居来检测它们在目标点云中的对应点。修剪步骤需要快速的修剪算法来快速地在早期拒绝错误匹配。

    Open3D提供以下剪枝算法: 

    • CorrespondenceCheckerBasedOnDistance 检查对齐点云是否接近(小于指定的阈值)。
    • CorrespondenceCheckerBasedOnEdgeLength检查从源和目标匹配分别绘制的任意两条边(由两个顶点组成的线)的长度是否相似。本教程检查||edgesource||>0.9带||edgetarget||和||edgetarget||>0.9带||edgesource||是否为真。

    • CorrespondenceCheckerBasedOnNormal考虑任何匹配的顶点法线亲和。它计算两个法向量的点积。它取一个弧度值作为阈值。

          只有通过修剪步骤的匹配才被用于计算转换，并在整个点云上进行验证。核心函数是registration_ransac_based_on_feature_matching。该函数最重要的超参数是RANSACConvergenceCriteria。它定义了RANSAC迭代的最大次数和置信概率。这两个数字越大，结果越准确，但算法花费的时间也越多。

         我们根据[[Choi2015]](../reference.html# Choi2015)提供的经验值设置RANSAC参数。

     3.2.2测试代码

    （1）代码

    1. import open3d as o3d
    2. import numpy as np
    3. from copy import deepcopy
    4.  
    5. def draw_registration_result(source, target, transformation):
    6.     # source_temp = copy.deepcopy(source)
    7.     # target_temp = copy.deepcopy(target)
    8.     source_temp = deepcopy(source)
    9.     target_temp = deepcopy(target)
    10.     source_temp.paint_uniform_color([1, 0.706, 0])
    11.     target_temp.paint_uniform_color([0, 0.651, 0.929])
    12.     source_temp.transform(transformation)
    13.     o3d.visualization.draw_geometries([source_temp, target_temp],
    14.                                       zoom=0.4559,
    15.                                       front=[0.6452, -0.3036, -0.7011],
    16.                                       lookat=[1.9892, 2.0208, 1.8945],
    17.                                       up=[-0.2779, -0.9482, 0.1556])
    18.  
    19.  
    20. def preprocess_point_cloud(pcd, voxel_size):
    21.     print(":: Downsample with a voxel size %.3f." % voxel_size)
    22.     pcd_down = pcd.voxel_down_sample(voxel_size)
    23.  
    24.     radius_normal = voxel_size * 2
    25.     print(":: Estimate normal with search radius %.3f." % radius_normal)
    26.     pcd_down.estimate_normals(
    27.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_normal, max_nn=30))
    28.  
    29.     radius_feature = voxel_size * 5
    30.     print(":: Compute FPFH feature with search radius %.3f." % radius_feature)
    31.     pcd_fpfh = o3d.pipelines.registration.compute_fpfh_feature(
    32.         pcd_down,
    33.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_feature, max_nn=100))
    34.     return pcd_down, pcd_fpfh
    35.  
    36.  
    37. def prepare_dataset(voxel_size):
    38.     print(":: Load two point clouds and disturb initial pose.")
    39.  
    40.     demo_icp_pcds = o3d.data.DemoICPPointClouds()
    41.     source = o3d.io.read_point_cloud(demo_icp_pcds.paths[0])
    42.     target = o3d.io.read_point_cloud(demo_icp_pcds.paths[1])
    43.     trans_init = np.asarray([[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0],
    44.                              [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]])
    45.     source.transform(trans_init)
    46.     draw_registration_result(source, target, np.identity(4))
    47.  
    48.     source_down, source_fpfh = preprocess_point_cloud(source, voxel_size)
    49.     target_down, target_fpfh = preprocess_point_cloud(target, voxel_size)
    50.     return source, target, source_down, target_down, source_fpfh, target_fpfh
    51.  
    52.  
    53. def execute_global_registration(source_down, target_down, source_fpfh,
    54.                                 target_fpfh, voxel_size):
    55.     distance_threshold = voxel_size * 1.5
    56.     print(":: RANSAC registration on downsampled point clouds.")
    57.     print("   Since the downsampling voxel size is %.3f," % voxel_size)
    58.     print("   we use a liberal distance threshold %.3f." % distance_threshold)
    59.     result = o3d.pipelines.registration.registration_ransac_based_on_feature_matching(
    60.         source_down, target_down, source_fpfh, target_fpfh, True,
    61.         distance_threshold,
    62.         o3d.pipelines.registration.TransformationEstimationPointToPoint(False),
    63.         3, [
    64.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnEdgeLength(
    65.                 0.9),
    66.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnDistance(
    67.                 distance_threshold)
    68.         ], o3d.pipelines.registration.RANSACConvergenceCriteria(100000, 0.999))
    69.     return result
    70.  
    71. if __name__ == "__main__":
    72.     #（1）原始，下采样，查看
    73.     voxel_size = 0.05  # means 5cm for this dataset
    74.     source, target, source_down, target_down, source_fpfh, target_fpfh = prepare_dataset(
    75.         voxel_size)
    76.  
    77.     #（2）ransac全局注册
    78.     result_ransac = execute_global_registration(source_down, target_down,
    79.                                                 source_fpfh, target_fpfh,
    80.                                                 voxel_size)
    81.     print(result_ransac)
    82.     draw_registration_result(source_down, target_down, result_ransac.transformation)
    83.

    （2）结果

    （3）发现结果还真不错，看看上一个教程icp中提到的两个指标fitness=6.745798e-01, inlier_rmse=3.051079e-02

    注意：Open3D为全局注册提供了更快的实现。请参考快速全球注册。

    4、局部细化（Local refinement）

    （1）原理

    出于性能的考虑，全局配准只在低采样的点云上执行。结果也不紧绷。我们使用点对面ICP来进一步细化对准。

    （2）注意：下面的方法中使用了上一个教程中的点对面的配准方法

     

    1. import open3d as o3d
    2. import numpy as np
    3. from copy import deepcopy
    4.  
    5. def draw_registration_result(source, target, transformation):
    6.     # source_temp = copy.deepcopy(source)
    7.     # target_temp = copy.deepcopy(target)
    8.     source_temp = deepcopy(source)
    9.     target_temp = deepcopy(target)
    10.     source_temp.paint_uniform_color([1, 0.706, 0])
    11.     target_temp.paint_uniform_color([0, 0.651, 0.929])
    12.     source_temp.transform(transformation)
    13.     o3d.visualization.draw_geometries([source_temp, target_temp],
    14.                                       zoom=0.4559,
    15.                                       front=[0.6452, -0.3036, -0.7011],
    16.                                       lookat=[1.9892, 2.0208, 1.8945],
    17.                                       up=[-0.2779, -0.9482, 0.1556])
    18.  
    19.  
    20. def preprocess_point_cloud(pcd, voxel_size):
    21.     print(":: Downsample with a voxel size %.3f." % voxel_size)
    22.     pcd_down = pcd.voxel_down_sample(voxel_size)
    23.  
    24.     radius_normal = voxel_size * 2
    25.     print(":: Estimate normal with search radius %.3f." % radius_normal)
    26.     pcd_down.estimate_normals(
    27.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_normal, max_nn=30))
    28.  
    29.     radius_feature = voxel_size * 5
    30.     print(":: Compute FPFH feature with search radius %.3f." % radius_feature)
    31.     pcd_fpfh = o3d.pipelines.registration.compute_fpfh_feature(
    32.         pcd_down,
    33.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_feature, max_nn=100))
    34.     return pcd_down, pcd_fpfh
    35.  
    36.  
    37. def prepare_dataset(voxel_size):
    38.     print(":: Load two point clouds and disturb initial pose.")
    39.  
    40.     demo_icp_pcds = o3d.data.DemoICPPointClouds()
    41.     source = o3d.io.read_point_cloud(demo_icp_pcds.paths[0])
    42.     target = o3d.io.read_point_cloud(demo_icp_pcds.paths[1])
    43.     trans_init = np.asarray([[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0],
    44.                              [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]])
    45.     source.transform(trans_init)
    46.     draw_registration_result(source, target, np.identity(4))
    47.  
    48.     source_down, source_fpfh = preprocess_point_cloud(source, voxel_size)
    49.     target_down, target_fpfh = preprocess_point_cloud(target, voxel_size)
    50.     return source, target, source_down, target_down, source_fpfh, target_fpfh
    51.  
    52.  
    53. def execute_global_registration(source_down, target_down, source_fpfh,
    54.                                 target_fpfh, voxel_size):
    55.     distance_threshold = voxel_size * 1.5
    56.     print(":: RANSAC registration on downsampled point clouds.")
    57.     print("   Since the downsampling voxel size is %.3f," % voxel_size)
    58.     print("   we use a liberal distance threshold %.3f." % distance_threshold)
    59.     result = o3d.pipelines.registration.registration_ransac_based_on_feature_matching(
    60.         source_down, target_down, source_fpfh, target_fpfh, True,
    61.         distance_threshold,
    62.         o3d.pipelines.registration.TransformationEstimationPointToPoint(False),
    63.         3, [
    64.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnEdgeLength(
    65.                 0.9),
    66.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnDistance(
    67.                 distance_threshold)
    68.         ], o3d.pipelines.registration.RANSACConvergenceCriteria(100000, 0.999))
    69.     return result
    70.  
    71.  
    72. def refine_registration(source, target, source_fpfh, target_fpfh, voxel_size):
    73.     distance_threshold = voxel_size * 0.4
    74.     print(":: Point-to-plane ICP registration is applied on original point")
    75.     print("   clouds to refine the alignment. This time we use a strict")
    76.     print("   distance threshold %.3f." % distance_threshold)
    77.     result = o3d.pipelines.registration.registration_icp(
    78.         source, target, distance_threshold, result_ransac.transformation,
    79.         o3d.pipelines.registration.TransformationEstimationPointToPlane())
    80.     return result
    81.  
    82.  
    83. if __name__ == "__main__":
    84.     #（1）原始，下采样，查看
    85.     voxel_size = 0.05  # means 5cm for this dataset
    86.     source, target, source_down, target_down, source_fpfh, target_fpfh = prepare_dataset(
    87.         voxel_size)
    88.  
    89.     #（2）ransac全局注册
    90.     result_ransac = execute_global_registration(source_down, target_down,
    91.                                                 source_fpfh, target_fpfh,
    92.                                                 voxel_size)
    93.     print(result_ransac)
    94.     draw_registration_result(source_down, target_down, result_ransac.transformation)
    95.  
    96.     #（3）点对面细调整
    97.     result_icp = refine_registration(source, target, source_fpfh, target_fpfh,
    98.                                     voxel_size)
    99.     print(result_icp)
    100.     draw_registration_result(source, target, result_icp.transformation)

    （3）测试结果

     （4）匹配的参数真漂亮，参数为 fitness=6.210325e-01, inlier_rmse=6.564120e-03

     5、快速全局注册（Fast global registration）

    5.1原理

    （1）描述

    基于RANSAC的全局注册解决方案可能需要很长时间，因为有无数的模型建议和评估。[Zhou2016]提出了一种更快的方法，可以快速优化对应次数较少的线处理过程。由于每次迭代都不涉及模型提出和评估，[Zhou2016]提出的方法可以节省大量的计算时间。

    （2）用到的函数

    o3d.pipelines.registration.registration_fgr_based_on_correspondence(
            source_down, target_down, correspondence_set,
            o3d.pipelines.registration.FastGlobalRegistrationOption())

    本教程将基于RANSAC的全局注册的运行时间与[Zhou2016]的实现进行比较。

     5.2 测试代码

    1. import open3d as o3d
    2. import numpy as np
    3. from copy import deepcopy
    4. import time
    5.  
    6. def draw_registration_result(source, target, transformation):
    7.     # source_temp = copy.deepcopy(source)
    8.     # target_temp = copy.deepcopy(target)
    9.     source_temp = deepcopy(source)
    10.     target_temp = deepcopy(target)
    11.     source_temp.paint_uniform_color([1, 0.706, 0])
    12.     target_temp.paint_uniform_color([0, 0.651, 0.929])
    13.     source_temp.transform(transformation)
    14.     o3d.visualization.draw_geometries([source_temp, target_temp],
    15.                                       zoom=0.4559,
    16.                                       front=[0.6452, -0.3036, -0.7011],
    17.                                       lookat=[1.9892, 2.0208, 1.8945],
    18.                                       up=[-0.2779, -0.9482, 0.1556])
    19.  
    20.  
    21. def preprocess_point_cloud(pcd, voxel_size):
    22.     print(":: Downsample with a voxel size %.3f." % voxel_size)
    23.     pcd_down = pcd.voxel_down_sample(voxel_size)
    24.  
    25.     radius_normal = voxel_size * 2
    26.     print(":: Estimate normal with search radius %.3f." % radius_normal)
    27.     pcd_down.estimate_normals(
    28.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_normal, max_nn=30))
    29.  
    30.     radius_feature = voxel_size * 5
    31.     print(":: Compute FPFH feature with search radius %.3f." % radius_feature)
    32.     pcd_fpfh = o3d.pipelines.registration.compute_fpfh_feature(
    33.         pcd_down,
    34.         o3d.geometry.KDTreeSearchParamHybrid(radius=radius_feature, max_nn=100))
    35.     return pcd_down, pcd_fpfh
    36.  
    37.  
    38. def prepare_dataset(voxel_size):
    39.     print(":: Load two point clouds and disturb initial pose.")
    40.  
    41.     demo_icp_pcds = o3d.data.DemoICPPointClouds()
    42.     source = o3d.io.read_point_cloud(demo_icp_pcds.paths[0])
    43.     target = o3d.io.read_point_cloud(demo_icp_pcds.paths[1])
    44.     trans_init = np.asarray([[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0],
    45.                              [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]])
    46.     source.transform(trans_init)
    47.     draw_registration_result(source, target, np.identity(4))
    48.  
    49.     source_down, source_fpfh = preprocess_point_cloud(source, voxel_size)
    50.     target_down, target_fpfh = preprocess_point_cloud(target, voxel_size)
    51.     return source, target, source_down, target_down, source_fpfh, target_fpfh
    52.  
    53.  
    54. def execute_global_registration(source_down, target_down, source_fpfh,
    55.                                 target_fpfh, voxel_size):
    56.     distance_threshold = voxel_size * 1.5
    57.     print(":: RANSAC registration on downsampled point clouds.")
    58.     print("   Since the downsampling voxel size is %.3f," % voxel_size)
    59.     print("   we use a liberal distance threshold %.3f." % distance_threshold)
    60.     result = o3d.pipelines.registration.registration_ransac_based_on_feature_matching(
    61.         source_down, target_down, source_fpfh, target_fpfh, True,
    62.         distance_threshold,
    63.         o3d.pipelines.registration.TransformationEstimationPointToPoint(False),
    64.         3, [
    65.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnEdgeLength(
    66.                 0.9),
    67.             o3d.pipelines.registration.CorrespondenceCheckerBasedOnDistance(
    68.                 distance_threshold)
    69.         ], o3d.pipelines.registration.RANSACConvergenceCriteria(100000, 0.999))
    70.     return result
    71.  
    72.  
    73. def refine_registration(source, target, source_fpfh, target_fpfh, voxel_size):
    74.     distance_threshold = voxel_size * 0.4
    75.     print(":: Point-to-plane ICP registration is applied on original point")
    76.     print("   clouds to refine the alignment. This time we use a strict")
    77.     print("   distance threshold %.3f." % distance_threshold)
    78.     result = o3d.pipelines.registration.registration_icp(
    79.         source, target, distance_threshold, result_ransac.transformation,
    80.         o3d.pipelines.registration.TransformationEstimationPointToPlane())
    81.     return result
    82.  
    83.  
    84. def execute_fast_global_registration(source_down, target_down, source_fpfh,
    85.                                      target_fpfh, voxel_size):
    86.     distance_threshold = voxel_size * 0.5
    87.     print(":: Apply fast global registration with distance threshold %.3f" \
    88.             % distance_threshold)
    89.     result = o3d.pipelines.registration.registration_fgr_based_on_feature_matching(
    90.         source_down, target_down, source_fpfh, target_fpfh,
    91.         o3d.pipelines.registration.FastGlobalRegistrationOption(
    92.             maximum_correspondence_distance=distance_threshold))
    93.     return result
    94.  
    95.  
    96. if __name__ == "__main__":
    97.     #（1）原始，下采样，查看
    98.     voxel_size = 0.05  # means 5cm for this dataset
    99.     source, target, source_down, target_down, source_fpfh, target_fpfh = prepare_dataset(
    100.         voxel_size)
    101.  
    102.     #（2）ransac全局注册，计算时间
    103.     start = time.time()
    104.     result_ransac = execute_global_registration(source_down, target_down,
    105.                                                 source_fpfh, target_fpfh,
    106.                                                 voxel_size)
    107.     print("Global registration took %.3f sec.\n" % (time.time() - start))
    108.     print(result_ransac)
    109.     draw_registration_result(source_down, target_down, result_ransac.transformation)
    110.  
    111.     # #（3）点对面细调整
    112.     # result_icp = refine_registration(source, target, source_fpfh, target_fpfh,
    113.     #                                 voxel_size)
    114.     # print(result_icp)
    115.     # draw_registration_result(source, target, result_icp.transformation)
    116.  
    117.     # （4）快速全局注册，计算时间
    118.     start = time.time()
    119.     result_fast = execute_fast_global_registration(source_down, target_down,
    120.                                                 source_fpfh, target_fpfh,
    121.                                                 voxel_size)
    122.     print("Fast global registration took %.3f sec.\n" % (time.time() - start))
    123.     print(result_fast)
    124.     draw_registration_result(source_down, target_down, result_fast.transformation)
    125.  
    126.

    5.3 结论

    PS：没仔细看，感觉和官网给的数据结果一样，速度没有快起来啊。大家有空仔细研究一下。

    通过适当的配置，快速全局注册的精度甚至可以与ICP媲美。更多实验结果见[Zhou2016]。

    除了基于fpfh特征的FGR，全局注册还可以通过registration_fgr_based_on_correspondence使用基于通信的FGR执行。如果您的通信前端不同于FPFH，但您仍然希望在给定一组假定通信时使用FGR，则此方法是有用的。调用方法如下：

    注意，该方法和上面的测试方法不同。

     o3d.pipelines.registration.registration_fgr_based_on_correspondence(
            source_down, target_down, correspondence_set,
            o3d.pipelines.registration.FastGlobalRegistrationOption())

  • 相关阅读:
    超图s3m服务加载时添加token
    vue项目使用history模式，打包部署到服务器根目录与二级目录的方法
    集合框架1
    001——体验鸿蒙（基于I.MAX6ULL）
    测试工程师一定要会的Jmeter_性能测试教程：性能测试脚本的优化
    CCC标准——PHY
    Mysql与GoldenDB中如何利用sql脚本添加字段和数据表名的备注
    微信小程序运行机制和生命周期
    一键同步，无处不在的书签体验：探索多电脑Chrome书签同步插件
    ABAP 计算时间差
  • 原文地址：https://blog.csdn.net/chencaw/article/details/128169483