传统方法分割三维点云——几何分割

最新推荐文章于 2024-09-13 08:22:36 发布
最新推荐文章于 2024-09-13 08:22:36 发布
阅读量778 收藏 5
点赞数 4
分类专栏： open3d点云处理专栏 文章标签： python 几何学 3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zwy123987/article/details/134451427
版权

基于几何特征的分割方法


        基于几何特征的分割方法是最早被提出和广泛应用的方法之一。它通过计算点云中的几何属性，如法向量、曲率等，来进行分割。其中，最常用的方法包括:


1.1 基干法向量的分割方法

        该方法假设同一区域的法向量相似，通过计算点云中每个点的法向量，将相似法向量的点划分为同一区域。优点是简单易实现，但对于复杂场景或存在噪声的点云效果较差。


1.2 基于曲率的分割方法

        该方法通过计算点云中每个点的曲率，将曲率变化较大的点划分为不同区域。优点是对于不同形状的物体有较好的分割效果，但对于噪声点较敏感。

        传统方法对于噪声比较多的点云数据处理起来都较为复杂的，而在降噪过程中由于点云的无序性和无规则性，对于去噪后的结果无法保证，因此，传统方法分割点云的困难重重。

        本文从几何分割的角度出发，充分利用物体几何特征，对于矩形物体进行了几何分割，以下是算法过程：

最后得到的数据分割情况如下，可以分割出三个面的点云数据，正上方的点云数据粉色块部分，是该程序也适用于四个面的矩形点云数据。

结果如下：

代码附上：

import open3d as o3d
import numpy as np
import pyransac3d as pyrsc

def line_fit(pcd,classified_points):
    """
    直线拟合
    """
    for i, points in classified_points.items():
        # 创建点云对象
        point_cloud = o3d.geometry.PointCloud()
        # 将numpy点云数据赋值给点云对象
        point_cloud.points = o3d.utility.Vector3dVector(points)
        print("->正在直线拟合...")
        mesh_cylinders = []
        line = pyrsc.Line()
        # A:直线的斜率，B：直线的截距，inliers：内点索引，
        # thresh：内点的距离阈值
        # maxIteration：RANSAC算法的拟合次数
        A, B, inliers = line.fit(points, thresh=500, maxIteration=500)
        print('直线的三维斜率为：', A)
        print('直线的截距为：', B)
        R = pyrsc.get_rotationMatrix_from_vectors([0, 0, 1], A)
        ransac_line = point_cloud.select_by_index(inliers)

        mesh_cylinder = o3d.geometry.TriangleMesh.create_cylinder(radius=20, height=10000)
        mesh_cylinder.compute_vertex_normals()
        mesh_cylinder.paint_uniform_color([1, 0, 0])
        mesh_cylinder = mesh_cylinder.rotate(R, center=[0, 0, 0])
        mesh_cylinder = mesh_cylinder.translate((B[0], B[1], B[2]))
        o3d.visualization.draw_geometries([point_cloud, ransac_line, mesh_cylinder])
def classifiction_points(pcd,wall_corners):
    '''
    根据四面墙的四个角点，将四面墙的点云数据分为四块。
    '''
    # 计算中心点
    center_point = np.mean(wall_corners, axis=0)
    # 将每个角点向中心点移动1cm
    moved_corners = []
    for corner in wall_corners:
        direction_to_center = center_point - corner
        # 单位化方向向量
        unit_direction = direction_to_center / np.linalg.norm(direction_to_center)
        # 移动1cm
        moved_corner = corner + unit_direction * 1
        moved_corners.append(moved_corner)

    moved_corners = np.array(moved_corners)
    # points_cloud是一个Numpy数组，包含点云数据
    points_cloud = np.array(pcd.points)

    # 分类点云数据
    classified_points = {i: [] for i in range(4)}
    for point in points_cloud:
        # 对每个点，找到最近的延长线
        min_distance = float('inf')
        min_index = -1
        for i in range(4):
            corner1 = moved_corners[i]
            corner2 = moved_corners[(i + 1) % 4]
            # 计算点到延长线的距离
            distance = np.linalg.norm(np.cross(corner2 - corner1, corner1 - point)) / np.linalg.norm(corner2 - corner1)
            if distance < min_distance:
                min_distance = distance
                min_index = i
        # 添加到对应分类中
        classified_points[min_index].append(point)

    # 将分类转换为Numpy数组
    for i in range(4):
        classified_points[i] = np.array(classified_points[i])
    # 定义每个分类的颜色 (r, g, b)
    colors = [
        [1, 0, 0],  # 红色
        [0, 1, 0],  # 绿色
        [0, 0, 1],  # 蓝色
        [1, 1, 0]  # 黄色
    ]
    # 创建一个Open3D的点云对象列表
    point_cloud_objects = []
    for i, points in classified_points.items():
        # 创建点云对象
        point_cloud = o3d.geometry.PointCloud()
        # 将numpy点云数据赋值给点云对象
        point_cloud.points = o3d.utility.Vector3dVector(points)
        # 为点云赋予颜色
        point_cloud.paint_uniform_color(colors[i])
        # 将点云对象添加到列表中
        point_cloud_objects.append(point_cloud)

    # 可视化所有分类的点云
    o3d.visualization.draw_geometries(point_cloud_objects)
    return classified_points

def find_farthest_points_in_quadrants(points, center):
    # 初始化四个象限的最远点信息
    quadrants = {
        'upper_left': (-np.inf, None),
        'upper_right': (-np.inf, None),
        'lower_right': (-np.inf, None),
        'lower_left': (-np.inf, None)
    }

    for point in points:
        # 计算点到中心点的角度和距离
        angle = np.arctan2(point[1] - center[1], point[0] - center[0])
        distance = np.linalg.norm(point - center)

        # 确定点所在的象限，并更新该象限的最远点
        if -np.pi <= angle < -np.pi / 2:
            if distance > quadrants['lower_left'][0]:
                quadrants['lower_left'] = (distance, point)
        elif -np.pi / 2 <= angle < 0:
            if distance > quadrants['lower_right'][0]:
                quadrants['lower_right'] = (distance, point)
        elif 0 <= angle < np.pi / 2:
            if distance > quadrants['upper_right'][0]:
                quadrants['upper_right'] = (distance, point)
        elif np.pi / 2 <= angle <= np.pi:
            if distance > quadrants['upper_left'][0]:
                quadrants['upper_left'] = (distance, point)

    # 从四个象限中提取最远的点
    farthest_points = [quadrants[q][1] for q in quadrants]
    return np.array(farthest_points)


def visualize_points_and_lines(pcd_clap,points, lines):
    # 从点集创建点云对象
    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(points)

    # 从点集和线集创建线集对象
    line_set = o3d.geometry.LineSet(
        points=o3d.utility.Vector3dVector(points),
        lines=o3d.utility.Vector2iVector(lines)
    )

    # 可视化点云和线集
    o3d.visualization.draw_geometries([pcd_clap,pcd, line_set])


class Ransac_fit():
    def __init__(self,pointcloud):
        """
        初始化参数
        """
        self.pcd = pointcloud  # 输入点云
        self.NPt = 0  # 输入点云
        self.NpPoints = np.asarray(self.pcd.points) # 点云numpy数组
        self.min_height = 0 # 点云最小高度
        self.max_height = 0 # 点云最大高度

    def get_min_max_horizontal_height(self):
        """
        求得点云的最低和最高的Z值
        """
        obb = self.pcd.get_axis_aligned_bounding_box()
        # 从包围盒坐标中获取最高和最低水平高度
        obb_points = np.asarray(obb.get_box_points())
        self.min_height = np.min(obb_points[:, 2])  # 最低水平高度
        self.max_height = np.max(obb_points[:, 2])  # 最高水平高度

    def clap_top_bottom(self):
        """
        沿着z轴拍平点云数据
        """
        pointsID_Window = []
        # 遍历所有点，并记录符合条件的点的索引
        for idx, point in enumerate(self.NpPoints):
            if self.min_height <= point[2] <= self.max_height:
                point[2] = 0
                pointsID_Window.append(idx)

        pcd_clap = self.pcd.select_by_index(pointsID_Window).voxel_down_sample(3)
        return pcd_clap

    def plane_fit(self,distance_threshold,ransac_n,num_iterations):
        """
        拍平平面到原来的平面
        """
        distance_threshold = 5 if distance_threshold == 0 else distance_threshold
        ransac_n = 5 if ransac_n == 0 else ransac_n
        num_iterations = 1000 if num_iterations == 0 else num_iterations
        segment_models, inliers = self.pcd.segment_plane(distance_threshold, ransac_n, num_iterations)
        # 获取平面的法向量并归一化
        normal_vector = np.array(segment_models[:3])
        normal_vector /= np.linalg.norm(normal_vector)
        # 计算每个点在法向量方向上的分量
        dot_products = np.dot(self.NpPoints, normal_vector)
        # 计算投影点
        projected_points = self.NpPoints -  0.8 * dot_products[:, np.newaxis] * normal_vector
        # 创建新的PointCloud对象
        projected_pcd = o3d.geometry.PointCloud()
        projected_pcd.points = o3d.utility.Vector3dVector(projected_points)
        return projected_pcd

def main():
    # 确保文件路径是正确的
    file_path = r"C:\Users\zhaojunzhe\Desktop\点云数据存储\钢梁.pts"
    # 读取点云数据
    pcd = o3d.io.read_point_cloud(file_path)
    o3d.visualization.draw_geometries([pcd])
    # 点云滤波
    cl, ind = pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=2.0)
    pcd = pcd.select_by_index(ind)
    # 创建拍平点云数据去拟合
    RANSAC = Ransac_fit(pcd)
    RANSAC.get_min_max_horizontal_height()
    clap_pointcloud = RANSAC.plane_fit(distance_threshold = 0,ransac_n = 0,num_iterations = 0)
    # 给点云上色
    colored_pcd = clap_pointcloud.paint_uniform_color([0, 0, 1])
    # 给定点云数据
    points = np.array(colored_pcd.points)
    # 计算点云数据的中心
    point_cloud_center = np.mean(points,axis = 0)
    # 找到相对于中心点在四个象限中距离最远的四个点
    farthest_points = find_farthest_points_in_quadrants(points[:, :3], point_cloud_center[:3])
    # 点云数据分类
    classified_points = classifiction_points(colored_pcd,farthest_points)
    # 最后三部分未来得及根据分割后的物体修改完善，请读者自行完善修改！
    # RANSAC线拟合
    line_fit(colored_pcd,classified_points)
    # 定义连接最远点的线集
    lines = [[i, (i + 1) % 4] for i in range(4)]
    # 可视化中心点、最远点和连接线
    visualize_points_and_lines(colored_pcd,farthest_points, lines)

if __name__ == '__main__':
    main()

数据已上传到百度网盘，链接地址如下，自取。

链接：https://pan.baidu.com/s/1qqX-J3WTecIbWPE6vvvCfw?pwd=142t 
提取码：142t 
--来自百度网盘超级会员V2的分享

山野万里__
关注
专栏目录
基于几何特征的地面点云分割方法（汇总）
周吴郑王
09-04 8108
欢迎访问我的个人博客： zengzeyu.com   前言 激光雷达扫描得到的点云含有大部分地面点，这对后续障碍物点云的分类、识别和跟踪带来麻烦，所以需要首先滤波滤掉。传统的基于几何特征的滤波是最基本最简单的方法，目前本文尝试的有如下几种： 水平面校准 法向量 栅格高度差 栅格最低高度以上0.2米 绝对高度 平均高度 以上方法基于假设是地面点云所构成的地面为平面，而不是弧面，当然...
传统算法中的点云分割方法
SmallPink0713的博客
02-10 435
传统方法中的五类点云分割方法
登山第九梯：稀疏点云实例分割——又快又准
最新发布
qq625924821的博客
09-13 1037
从 3D 距离数据中分割对象是移动机器人领域的一个重要主题。在动态环境中导航的机器人需要注意可能发生变化或移动的物体。将激光扫描分割成单个对象通常是执行进一步分析之前的第一个处理步骤。在本文中，我们提出了一种快速方法，该方法将 3D 范围数据分割成不同的对象，在线运行，并且计算需求很小。该方法避免了 3D 点云的显式计算，而是直接在 2D 距离图像上执行所有计算，从而可以对每次扫描进行快速分割。该方法的另一个相关方面是，即使 3D 数据稀疏，也可以分割对象。
三维点云分割综述
点云PCL
10-20 1万+
点云PCL免费知识星球，点云论文速读。标题：三维点云分割综述（上）排版：particle欢迎各位加入免费知识星球，获取PDF文档，欢迎转发朋友圈，分享快乐。这是一篇综述性论文，以下只做概...
传统点云分割三部曲（一）——VCCS（Voxel Cloud Connectivity Segmentation）
weixin_44368569的博客
11-12 1110
我之前狭隘地以为只有点云深度学习才能处理分割问题，偶然发现传统方法的分割结果一样可以令我眼前一亮。VCCS原文LCCP原文CPC原文其中VCCS是分割前的准备工作，LCCP和CPC是分割的方法，二者论文中的效果图如下，有点出乎我的意料。。。。传统方法我认为最好的点在于通用性很强，并且可解释，应用起来比较友好。这三篇论文出自同一实验室，并且算法实现均已发布到PCL中，所以我准备学习这三篇论文的方法，并整理成笔记与大家交流。
点云区域生长分割
taifyang的博客
04-11 2317
原理介绍： （1）首先计算出来各点的曲率值，将曲率值按照从小到大的顺序进行排序。 （2）设置一空的种子点序列和一个空的聚类数组。 （3）选取曲率最小的点放入上述种子点序列中。 （4）从序列中拿出来一个种子点搜索其邻域。 （5）搜索到邻域后，这些点先过法线夹角阈值，通过的保留到聚类数据，然后再从这些通过法线夹角阈值的点中，检查是否通过曲率阈值，通过的加入种子点序列。即比较邻域点的法线与当前种子点法线之间的夹角，如果小于阈值将该邻域点加入聚类数组。再从这些小于法线阈值的点中判断是否小于曲率阈值，如果小于则将该邻
基于曲率的体素聚类的三维激光雷达点云实时鲁棒分割方法
点云PCL
02-07 3813
点云PCL免费知识星球，点云论文速读。文章：Curved-Voxel Clustering for Accurate Segmentation of 3D LiDAR Point Clou...
三维点云pcd测试数据下载
06-19
PCD（Point Cloud Data）格式是存储这些三维点云数据的常见方式，由PCL（Point Cloud Library）库支持。本资源包提供了多种PCD格式的点云测试数据，包括斯坦福兔子、飞机以及森林场景，非常适合于点云处理算法的开发...
PCL_supervoxelclustering.zip_PCL 分割_supervoxel_点云_点云分割_点云超体素
09-20
在本项目"**PCL_supervoxelclustering.zip**"中，我们将探讨点云分割的一个关键方法——超体素（Supervoxel）聚类。这个压缩包包含了一个使用C++与PCL（Point Cloud Library）库实现的点云超体素分割程序。 首先，...
三维点云语义分割【综述】 ——Deep Learning for 3D Point Clouds: A Survey
Dujing2019的博客
02-16 1万+
3D POINT CLOUD SEGMENTATION3D Semantic SegmentationProjection-based NetworksPoint-based NetworksInstance SegmentationProposal-based MethodsProposal-free MethodsPart SegmentationSummary 3D点云分割需要了解全局几何结...
三维点云数据处理软件供技术原理说明_基于三维点云处理技术的工件识别和匹配...
weixin_31897613的博客
12-24 3272
1. 引言目前，随着自动化程度的提高，机器人导航、工业零件检测及抓取等众多领域对计算机视觉系统的要求越来越高 [1]，基于二维图像的物体识别已经无法满足日常作业的需求。而由于三维扫描技术的发展，结构光测量和激光扫描能够快速且精确地获取被测对象表面的三维坐标数据，为获取场景的点云数据提供了全新的技术手段。加之点云数据具备不受光照、阴影、纹理的影响等优势，基于三维点云数据的物体识别已成为近年来计算机视...
点云从入门到精通技术详解100篇-融合二维图像特征的三维点云语义分割
getusushu的博客
09-10 438
像数据在物体边缘部分往往存在特征“突变”现象，且往往具有丰富、清晰的纹理信息，接着，通过设计合理的融合机制实现图像与点云特征空间的融合。特征的提取，再借助合适的中间数据将图像与点云的高维度特征融合至同一特征空间中，不同的融合特征将用于生成不同类型的成果，如：物体识别框的生成、语义掩膜的生成、确空间结构信息的优势互补，以提升现有三维空间感知手段的性能。又恰好对应彼此的劣势，图像数据的维度限制了表达三维信息的能力，而点云也因数据。图像与点云信息融合机制的相关研究逐渐增加，希望在空间感知技术上让两种数据形成。
点云处理【六】(点云分割)
略知12的博客
10-20 1695
2.用1中得到的模型去测试所有的其它数据，如果某个点与模型的误差小于某个阈值，则该点适用于这个模型，认为它也是局内点。随机种下曲率较小的种子后进行延申，根据种子邻域与法线之间的角度与阈值比较，从而判断是否处于哪个领域。1.从一个样本集S中，随机抽取n个样本，拟合出一个模型，n是能够初始化模型的最小样本数。4.用所有假设的局内点去重新执行1,2，估计模型，因为它仅仅被初始的假设局内点估计过。3.如果模型内的局内点达到一定个数，那么估计的模型就足够合理。类RegionGrowing.py。
从传统到深度学习：浅谈点云分割中的图结构
3D视觉工坊
07-16 366
随着3D扫描技术的进步，如何将点云的前景和背景正确分离成为点云处理的一个具有挑战性的问题。具体来说，就是给定一个对象位置的估计，目标是识别属于该对象的那些点，并将它们与背景点分开。除了将前...
点云数据的语义分割算法综述总结大全（传统方法+基于深度学习的方法）
Mluoo的博客
01-19 1万+
近些年基于深度学习的点云语义分割研究开始被广泛关注，并取得了极大的进展。我围绕点云数据的语义分割，从传统方法和基于深度学习方法两方面，来对近些年点云语义分割的研究做出系统的归纳和总结。因此恬不知耻的取名未——点云数据的语义分割算法综述总结大全（传统方法+基于深度学习的方法）哈哈哈哈。
PCL点云分割（2）
点云PCL
04-11 3621
关于点云的分割算是我想做的机械臂抓取中十分重要的俄一部分，所以首先学习如果使用点云库处理我用kinect获取的点云的数据，本例程也是我自己慢慢修改程序并结合官方API 的解说实现的，其中有很多细节如果直接更改源程序，可能会因为数据类型，或者头文件等各种原因编译不过，会导致我们比较难得找出其中的错误，首先我们看一下我自己设定的一个场景，然后我用kinect获取数据 观察到kinect获取...
常见点云分割技术
热门推荐
知识搬运工的博客
06-08 3万+
转载自博客园IronStark点云分割系列：https://www.cnblogs.com/ironstark/p/5027269.html 点云分割 　　点云分割可谓点云处理的精髓，也是三维图像相对二维图像最大优势的体现。 　　点云分割的目的是提取点云中的不同物体，从而实现分而治之，突出重点，单独处理的目的。而在现实点云数据中，往往对场景中的物体有一定先验知识。比如：桌面墙面多半是大平面，...
Open3D 点云按网格划分（点云分幅）
dayuhaitang1的博客
08-14 974
Open3D 点云按网格划分（点云分幅）
open3d点云划分与分割
微小冷的学习笔记
04-10 1433
本文介绍了两种点云划分方法，kd树和oc树；以及两种点云分割算法DBSCAN和RANSAC。
python利用八叉树分割三维点云代码
04-04
以下是利用八叉树分割三维点云的Python代码示例： ```python import numpy as np from sklearn.neighbors import KDTree class Octree: def __init__(self, points, max_points_per_node=16, max_depth=8): self.points = points self.max_points_per_node = max_points_per_node self.max_depth = max_depth self.min_bounds = np.min(points, axis=0) self.max_bounds = np.max(points, axis=0) self.center = (self.min_bounds + self.max_bounds) / 2 self.children = None self.depth = 0 if len(points) > max_points_per_node and max_depth > 0: self.split() def split(self): self.children = [] for i in range(8): mask = np.array([i & 1, i & 2, i & 4]) bounds_min = np.where(mask, self.center, self.min_bounds) bounds_max = np.where(mask, self.max_bounds, self.center) indices = self.get_indices(bounds_min, bounds_max) if len(indices) > 0: child = Octree(self.points[indices], self.max_points_per_node, self.max_depth - 1) child.min_bounds = bounds_min child.max_bounds = bounds_max child.depth = self.depth + 1 self.children.append(child) def get_indices(self, min_bounds, max_bounds): indices = [] for i, point in enumerate(self.points): if (point >= min_bounds).all() and (point <= max_bounds).all(): indices.append(i) return indices def get_points_in_sphere(self, center, radius): indices = self.get_indices(center - radius, center + radius) if self.children is None: return indices else: result = [] for child in self.children: if (center - child.center).dot(center - child.center) < radius * radius: result += child.get_points_in_sphere(center, radius) return result def get_points_in_box(self, min_bounds, max_bounds): indices = self.get_indices(min_bounds, max_bounds) if self.children is None: return indices else: result = [] for child in self.children: if (min_bounds <= child.max_bounds).all() and (max_bounds >= child.min_bounds).all(): result += child.get_points_in_box(min_bounds, max_bounds) return result def get_points_in_cube(self, center, size): return self.get_points_in_box(center - size / 2, center + size / 2) def octree_from_points(points, max_points_per_node=16, max_depth=8): return Octree(points, max_points_per_node, max_depth) def octree_from_kd_tree(kd_tree, max_points_per_node=16, max_depth=8): return Octree(kd_tree.data, max_points_per_node, max_depth) def octree_from_file(filename, max_points_per_node=16, max_depth=8): points = np.loadtxt(filename) return Octree(points, max_points_per_node, max_depth) def kd_tree_from_points(points): return KDTree(points) def kd_tree_from_file(filename): points = np.loadtxt(filename) return KDTree(points) ``` 这个Octree类实现了八叉树的基本功能，包括分割点云、获取半径内的点、获取包含在指定盒子中的点等。可以使用octree_from_points、octree_from_kd_tree和octree_from_file函数来创建Octree对象。也可以使用kd_tree_from_points和kd_tree_from_file函数来创建KDTree对象。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值