PclSharp--贪婪投影三角算法

1、PCL点云三角化
1.1 Delaunay三角剖分
定义:假设点集中的一条边e(两个端点为a,b),e若满足下列条件,则称之为Delaunay边:存在一个圆经过a,b两点,圆内(圆上最多三点共圆)不含点集中任何其他的点。而Delaunay三角化就是指三角网格均是由Delaunay边组成,并满足最小角最大原则(在点集可能形成的三角剖分中,Delaunay三角剖分所形成的三角形的最小角最大)。

1.2 贪婪三角化
PCL中采用将三维点云投影到二维平面的方法来实现三角剖分, 具体采用贪婪三角化算法。
其过程为:
1:计算点云中点的法线,再将点云通过法线投影到二维坐标平面。
2:使用基于Delaunay三角剖分的空间区域增长算法完成平面点集的三角化。
3:根据投影点云的连接关系确定原始三维点云间的拓扑关系,最终得到曲面模型。

2、代码:

using PclSharp;
using PclSharp.Features;
using PclSharp.Helpers;
using PclSharp.IO;
using PclSharp.Search;
using PclSharp.Struct;
using PclSharp.Surface;
using System;


namespace PclSharpTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine($"C#--PclSharp算法库测试:");

            //读取点云数据
            var cloud = new PointCloudOfXYZ();
            using (var reader = new PCDReader())
                reader.Read(AppDomain.CurrentDomain.BaseDirectory + $"//pcd//bun0.pcd", cloud);

            // 计算法向量
            var normals = new PointCloudOfNormal();//法线点云
            using (var ne = new NormalEstimationOfPointXYZAndNormal())//法线估计对象
            using (var tree = new KdTreeOfXYZ()) //创建用于最近邻搜索的KD-Tree
            {
                //法线估计
                ne.SetSearchMethod(tree);
                ne.SetInputCloud(cloud);
                ne.KSearch = 10;// 使用当前点周围最近的10个点
                ne.Compute(normals);//计算法线
            }

            //将点云与法线进行字段拼接
            PointCloudOfPointNormal cloud_with_normals = new PointCloudOfPointNormal(); //法向量点云对象
            //将点云和法线拼接一起
            PclHelper.concatenateFields(cloud, normals, cloud_with_normals);
            //创建搜索树
            KdTree<PointNormal> tree2 = new KdTreeOfXYZNormal();
            tree2.SetInputCloud(cloud_with_normals);


            // 初始化贪婪三角形的对象
            GreedyProjectionTriangulationOfPointNormal gp3 = new GreedyProjectionTriangulationOfPointNormal();
            //创建多变形网格,用于存储结果
            PolygonMesh triangles = new PolygonMesh();
            gp3.SearchRadius = 0.025f; //设置连接点之间的最大距离用于确定k近邻的球半径
            gp3.Mu = 2.5f; //设置最近邻距离的乘子,以得到每个点的最终搜索半径
            gp3.MaximumNearestNeighbors = 100; //设置搜索的最近邻点的最大数量
            gp3.MaximumSurfaceAngle = (Math.PI / 4); // 45 degrees(pi)最大平面角
            gp3.MinimumAngle = (Math.PI / 18); // 10 degrees 每个三角的最小角度
            gp3.MaximumAngle = (2 * Math.PI / 3); // 120 degrees 每个三角的最大角度
            gp3.NormalConsistency = false; //如果法向量一致,设置为true

            //设置搜索方法和输入点云
            gp3.SetInputCloud(cloud_with_normals);
            gp3.SetSearchMethod(tree2);

            //执行重构,结果保存在triangles中
            gp3.Reconstruct(triangles);


            using (var visualizer = new PclSharp.Vis.Visualizer("a window"))
            {
                //创建两个观察视点
                int v1 = 1;
                int v2 = 2;
                visualizer.CreateViewPort(0.0, 0.0, 0.5, 1.0, v1);
                visualizer.CreateViewPort(0.5, 0.0, 1.0, 1.0, v2);

                visualizer.SetBackgroundColor_ViewPort(0f, 0f, 0f, v1);
                visualizer.SetBackgroundColor_ViewPort(0.05f, 0f, 0f, v2);

                visualizer.AddPointCloud(cloud, "v1", v1);
                visualizer.AddPolygonMesh(triangles, "v2",v2);

                visualizer.SetPointCloudColor(0.5, 1, 1, "v1");//原始点云附色
                while (!visualizer.WasStopped)
                    visualizer.SpinOnce(100);
            }

            Console.ReadKey();
        }

    }
}

3、编译结果:

以下是一个简单的 C++ 实现红枣贪婪投影三角剖分算法的示例代码: ```cpp #include <iostream> #include <vector> struct Point { double x, y; }; // 计算两个点之间的距离 double distance(const Point& p1, const Point& p2) { double dx = p1.x - p2.x; double dy = p1.y - p2.y; return std::sqrt(dx * dx + dy * dy); } // 判断点是否在三角形内部 bool pointInTriangle(const Point& p, const Point& p1, const Point& p2, const Point& p3) { double d1 = (p1.x - p.x) * (p2.y - p.y) - (p2.x - p.x) * (p1.y - p.y); double d2 = (p2.x - p.x) * (p3.y - p.y) - (p3.x - p.x) * (p2.y - p.y); double d3 = (p3.x - p.x) * (p1.y - p.y) - (p1.x - p.x) * (p3.y - p.y); return (d1 >= 0 && d2 >= 0 && d3 >= 0) || (d1 <= 0 && d2 <= 0 && d3 <= 0); } // 计算三角形的投影长度 double computeProjectionLength(const Point& p1, const Point& p2, const Point& p3) { double a = distance(p2, p3); double b = distance(p1, p3); double c = distance(p1, p2); double s = (a + b + c) / 2.0; // 半周长 double area = std::sqrt(s * (s - a) * (s - b) * (s - c)); // 海伦公式计算面积 return 2.0 * area / c; // 投影长度 } // 进行红枣贪婪投影三角剖分算法 std::vector<std::vector<Point>> greedyProjectionTriangulation(std::vector<Point>& points) { std::vector<std::vector<Point>> triangles; // 只有三个点时,形成一个三角形 if (points.size() == 3) { triangles.push_back(points); return triangles; } // 找到包围盒的左下角和右上角的点 double min_x = points[0].x; double min_y = points[0].y; double max_x = points[0].x; double max_y = points[0].y; for (const auto& point : points) { min_x = std::min(min_x, point.x); min_y = std::min(min_y, point.y); max_x = std::max(max_x, point.x); max_y = std::max(max_y, point.y); } // 计算包围盒的中心点 Point center; center.x = (min_x + max_x) / 2.0; center.y = (min_y + max_y) / 2.0; // 根据红枣贪婪投影三角剖分算法进行剖分 while (points.size() > 3) { double max_projected_length = 0.0; int max_projected_index = 0; // 找到具有最大投影长度的点 for (int i = 0; i < points.size(); ++i) { double projected_length = computeProjectionLength(points[i], center, points[(i + 1) % points.size()]); if (projected_length > max_projected_length) { max_projected_length = projected_length; max_projected_index = i; } } // 形成一个三角形 std::vector<Point> triangle; triangle.push_back(points[max_projected_index]); triangle.push_back(center); triangle.push_back(points[(max_projected_index + 1) % points.size()]); triangles.push_back(triangle); // 删除已使用的点 points.erase(points.begin() + max_projected_index); // 更新包围盒的中心点 center.x = (center.x + triangle[0].x + triangle[2].x) / 3.0; center.y = (center.y + triangle[0].y + triangle[2].y) / 3.0; } // 添加最后一个三角形 triangles.push_back(points); return triangles; } int main() { // 示例用法 std::vector<Point> points = { {0.0, 0.0}, {1.0, 0.0}, {0.5, 1.0}, {0.5, 0.5} }; std::vector<std::vector<Point>> triangles = greedyProjectionTriangulation(points); // 输出结果 for (const auto& triangle : triangles) { std::cout << "Triangle: "; for (const auto& point : triangle) { std::cout << "(" << point.x << ", " << point.y << ") "; } std::cout << std::endl; } return 0; } ``` 这段代码实现了红枣贪婪投影三角剖分算法,通过传入一组点坐标,将其剖分为多个三角形。在示例中,我们定义了四个点,然后使用算法进行剖分,并输出每个三角形的顶点坐标。你可以根据自己的需求修改和扩展这段代码。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

西~风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值