devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

凹包-滚球算法（C#代码）_凹包算法

作者：小蓝xlanll | 2024-06-04 11:42:05

赞

踩

凹包算法

一、什么是凹包

在计算几何中，凹包（Concave Hull）是一种几何形状，它包围一组点，形状的外部是凹凸不平的。与凸包（Convex Hull）相反，凹包允许形状沿着内部有一些凹陷。

具体来说，凹包是包围一组点的一个多边形，该多边形的边界是点的一个子集，而不是全部。凹包的外形可能会有凹陷的部分，而不是完全凸起。

凹包在计算机图形学、计算机辅助设计（CAD）、地理信息系统（GIS）等领域中都有应用。例如，在路径规划、物体识别、图像处理等任务中，需要找到一组点的凹包以描述它们的整体形状。

二、凹包的应用场景

凹包在计算机科学和工程中有许多应用场景，其中一些包括：

  1. 图形处理和计算机图形学： 在图形学中，凹包常用于表示和处理复杂的形状。例如，计算机游戏中的地形建模、虚拟现实环境中的场景建模等都可能涉及凹包的计算。

  2. 路径规划： 在机器人学、自动驾驶等领域，路径规划是一个关键问题。凹包可以用于表示障碍物的形状，帮助规划避障路径。

  3. 物体识别： 在计算机视觉中，物体识别可能涉及到对物体轮廓的建模，而凹包可以用于更准确地描述物体的形状。

  4. 地理信息系统（GIS）： 在地理信息系统中，地图的边界可以通过凹包来表示，以更精确地捕捉地理区域的形状。

  5. CAD（计算机辅助设计）： 在设计领域，CAD软件中的形状建模和分析可能需要使用凹包。

  6. 数据可视化： 在数据可视化中，凹包可以用于突出数据点的集中趋势和形状。

这些应用场景只是冰山一角，凹包的概念和算法在各种计算和工程领域都有广泛的应用。

三、滚球算算法总体思路

3.1 滚球算法思路

滚球法（Rolling Ball Algorithm）是一种凹包算法，其基本思路是从凸包的角度来考虑。该算法的步骤可以概括为以下几点：

  1. 排序： 首先，对输入的点集按照一定的规则进行排序。通常可以选择按照点的坐标，先按照 y 坐标升序排序，然后在同样 y 坐标的情况下按照 x 坐标升序排序。

  2. 初始化： 初始化一个空的凹包，以及一个标记数组，用来标记哪些点已经被加入凹包中。初始时，凹包为空，标记数组中所有元素为未标记。

  3. 选取起始点： 从排序后的点集中选择一个起始点（通常是排序后的第一个点），将其加入凹包，并标记为已加入。

  4. 滚动球： 从起始点开始，采用滚球的方式寻找下一个凹包点。滚球的过程中，维护一个当前滚球半径。对于每个未加入凹包的点，判断是否在当前滚球半径内，如果是，则将其加入凹包，并将滚球半径设置为该点到凹包中已有点的最大距离。

  5. 迭代： 重复滚动球的过程，直到无法再加入新的点为止。这通常意味着所有的点都被包含在凹包中。

整体来说，滚球法是一种基于贪心策略的算法，通过不断扩展当前的凹包，直至包含所有的点。该算法相对简单，但需要注意的是滚球的半径的选择，这会影响算法的性能和结果。通常，滚球的半径可以根据数据的特点动态调整。

3.2 滚球法半径R对结果的影响

滚球算法中的半径R对算法的性能和输出结果具有一定的影响。推荐的半径R的计算通常需要根据具体的数据集和应用场景进行调整。以下是一些影响半径R选择的因素以及推荐半径的分析方法：

  1. 点的分布密度： 如果点的分布比较密集，适当增大半径R可能有助于将更多的点纳入同一个凹包，避免遗漏一些凹包的点。相反，如果点的分布比较稀疏，减小半径R可能更合适，以避免将不相关的点包含在同一个凹包中。

  2. 数据集的大小： 对于较大的数据集，可能需要更大的半径R，以确保覆盖整个数据集的关键几何特征。对于较小的数据集，较小的半径R可能足以捕捉到数据的主要形状。

  3. 应用需求： 不同的应用场景可能对凹包的定义有不同的要求。某些情况下，需要较大的凹包，而在其他情况下，可能需要更加精细的凹包。根据应用需求调整半径R可以满足不同的要求。

  4. 算法性能： 较小的半径R可能导致算法更为敏感，可能会在数据噪声较大或几何形状变化较为复杂的情况下产生不稳定的结果。较大的半径R可能使算法更加稳定，但可能会损失一些细节。

  5. 可视化效果： 在一些可视化应用中，推荐半径R的选择可能受到视觉效果的影响。合适的半径R应该能够清晰地展示数据的结构，而不至于使可视化失真或过于拥挤。

推荐半径R的计算通常需要在实际应用中进行试验和调整。可以通过尝试不同的半径值，观察凹包的质量和算法的性能，以及与特定应用场景的契合程度，来确定最合适的半径R。

要想顺利实现滚球法 ，需保证R大于最小半径，最小半径即至少能保证，以此为半径的圆能包含住2个点。

总的来说：R越大，则圆球所能滚到的下一个点就越远，凹包边界所包含的点集就越稀疏；R越小，则圆球所能滚到的下一个点就越近，凹包边界所包含的点集就越稠密。

左图为R=20000mm时的凹包边界，右图为R=10000mm时的凹包边界。

四、主要代码段介绍

4.1 首先定义一个二位坐标点类

每个点有 X 和 Y 坐标，Id 是点的编号，Distance 表示到其他点的距离。

  1. public class Point
  2. {
  3.     public double X { get; set; }
  4.     public double Y { get; set; }
  5.     public int Id { get; set; }
  6.     public double Distance { get; set; }
  7.  
  8.     public Point(double x, double y)
  9.     {
  10.         X = x;
  11.         Y = y;
  12.     }
  13. }

4.2 定义一个实现凹包算法的类

主要包含了初始化邻居列表和点之间距离的方法，计算默认半径的方法，以及使用滚球法获取凹包的方法。在这个类中，也有一些辅助方法，比如根据角度对邻居列表进行排序、检查圆内是否存在其他点等。

  1. public class ConcaveHull
  2. {
  3.   //...略
  4. }

4.3 类的构造函数

它接收一个 List<Point> 参数，对这些点进行排序，然后初始化一些数据结构，包括 _signs 数组（用于标记点是否已被使用）、点之间的距离 _distances 数组，以及按距离排序的邻居列表 _neigbours。

  1. public ConcaveHull(List<Point> list)
  2. {
  3.     this._points = list;
  4.     _points = _points.OrderBy(p => p.Y).ThenBy(p => p.X).ToList();
  5.     _signs = new bool[_points.Count];
  6.     for (int i = 0; i < _signs.Length; i++)
  7.     {
  8.         _signs[i] = false;
  9.     }
  10.     InitDistance();
  11.     InitNeighbours();
  12. }

4.4 核心计算方法

使用滚球法获取凹包，如果不提供半径，会使用 CalDefaultRadius 计算默认半径。在循环中，通过 GetNextPoint 方法找到下一个凹包点，计算该点到当前点的圆心，并将该点加入结果列表。

  1. public List<Point> Compute(double radius = -1)
  2. {
  3.     if (radius == -1)
  4.     {
  5.         radius = CalDefaultRadius();
  6.     }
  7.     List<Point> results = new List<Point>();
  8.     List<int>[] neighs = GetNeighbourList(2 * radius);
  9.     results.Add(_points[0]);
  10.     int i = 0, j = -1, pre = -1;
  11.     while (true)
  12.     {
  13.         j = GetNextPoint(pre, i, neighs[i], radius);
  14.         if (j == -1)
  15.         {
  16.             break;
  17.         }
  18.         Point p = CalCenterByPtsAndRadius(_points[i], _points[j], radius);
  19.         results.Add(_points[j]);
  20.         _signs[j] = true;
  21.         pre = i;
  22.         i = j;
  23.     }
  24.     return results;
  25. }

CalDefaultRadius方法计算默认的半径，即选择每个点的第二个邻居与其距离最大的点之间的距离最大值。

  1. public double CalDefaultRadius()
  2. {
  3.     double r = double.MinValue;
  4.     for (int i = 0; i < _points.Count; i++)
  5.     {
  6.         if (_distances[i, _neigbours[i][1]] > r)
  7.         {
  8.             r = _distances[i, _neigbours[i][1]];
  9.         }
  10.     }
  11.     return r;
  12. }

五、完整代码

  1.     /// <summary>
  2.     /// 二维平面上的一个点
  3.     /// </summary>
  4.     /// </summary>
  5.     public class Point
  6.     {
  7.         /// <summary>
  8.         /// x坐标
  9.         /// </summary>
  10.         public double X { get; set; }
  11.         /// <summary>
  12.         /// y坐标
  13.         /// </summary>
  14.         public double Y { get; set; }
  15.         /// <summary>
  16.         /// 编号
  17.         /// </summary>
  18.         public int Id { get; set; }
  19.         /// <summary>
  20.         /// 到其他点的距离
  21.         /// </summary>
  22.         public double Distance { get; set; }
  23.         public Point(double x, double y)
  24.         {
  25.             X = x;
  26.             Y = y;
  27.         }
  28.     }
  29.     /// <summary>
  30.     /// 凹包类
  31.     /// </summary>
  32.     public class ConcaveHull
  33.     {
  34.      
  35.         //点点之间距离列表
  36.         private double[,] _distances;
  37.         //邻居列表
  38.         private List<int>[] _neigbours;
  39.         private bool[] _signs;
  40.         private List<Point> _points;
  41.  
  42.         public ConcaveHull(List<Point> list)
  43.         {
  44.             this._points = list;
  45.             _points = _points.OrderBy(p => p.Y).ThenBy(p => p.X).ToList();
  46.             _signs = new bool[_points.Count];
  47.             for (int i = 0; i < _signs.Length; i++)
  48.             {
  49.                 _signs[i] = false;
  50.             }
  51.             InitDistance();
  52.             InitNeighbours();
  53.         }
  54.  
  55.  
  56.         /// <summary>
  57.         /// 计算默认的半径
  58.         /// </summary>
  59.         /// <returns></returns>
  60.         public double CalDefaultRadius()
  61.         {
  62.             double r = double.MinValue;
  63.             for (int i = 0; i < _points.Count; i++)
  64.             {
  65.                 if (_distances[i, _neigbours[i][1]] > r)
  66.                 {
  67.                     r = _distances[i, _neigbours[i][1]];
  68.                 }
  69.             }
  70.             return r;
  71.         }
  72.         /// <summary>
  73.         /// 使用滚球法获取凹包
  74.         /// 不输入半径时，用默认计算半径代替
  75.         /// </summary>
  76.         /// <param name="radius"></param>
  77.         /// <returns></returns>
  78.         public List<Point> Compute(double radius=-1)
  79.         {
  80.             //计算默认半径
  81.             if (radius == -1)
  82.             {
  83.                 radius = CalDefaultRadius();
  84.             }
  85.             List<Point> results = new List<Point>();
  86.             List<int>[] neighs = GetNeighbourList(2 * radius);
  87.             results.Add(_points[0]);
  88.             int i = 0, j = -1, pre = -1;
  89.             while (true)
  90.             {
  91.                 j = GetNextPoint(pre, i, neighs[i], radius);
  92.                 if (j == -1)
  93.                 {
  94.                     break;
  95.                 }
  96.                 Point p = CalCenterByPtsAndRadius(_points[i], _points[j], radius);
  97.                 results.Add(_points[j]);
  98.                 _signs[j] = true;
  99.                 pre = i;
  100.                 i = j;
  101.             }
  102.             return results;
  103.         }
  104.  
  105.  
  106.         /// <summary>
  107.         /// 初始化每个点的按距离排序的邻居列表
  108.         /// </summary>
  109.         private void InitNeighbours()
  110.         {
  111.             _neigbours = new List<int>[_points.Count];
  112.             for (int i = 0; i < _neigbours.Length; i++)
  113.             {
  114.                 _neigbours[i] = SortNeighboursByDis(i);
  115.             }
  116.         }
  117.         /// <summary>
  118.         /// 初始化点之间的距离
  119.         /// </summary>
  120.         private void InitDistance()
  121.         {
  122.             _distances = new double[_points.Count, _points.Count];
  123.             for (int i = 0; i < _points.Count; i++)
  124.             {
  125.                 for (int j = 0; j < _points.Count; j++)
  126.                 {
  127.                     _distances[i, j] = CalDistanceToPts(_points[i], _points[j]);
  128.                 }
  129.             }
  130.         }
  131.         /// <summary>
  132.         /// 获取下一个凹包点
  133.         /// </summary>
  134.         /// <param name="pre"></param>
  135.         /// <param name="cur"></param>
  136.         /// <param name="list"></param>
  137.         /// <param name="radius"></param>
  138.         /// <returns></returns>
  139.         private int GetNextPoint(int pre, int cur, List<int> list, double radius)
  140.         {
  141.             SortNeighbours(list, pre, cur);
  142.             for (int j = 0; j < list.Count; j++)
  143.             {
  144.                 if (_signs[list[j]])
  145.                 {
  146.                     continue;
  147.  
  148.                 }
  149.                 int adjIndex = list[j];
  150.                 Point xianp = _points[adjIndex];
  151.                 Point rightCirleCenter = CalCenterByPtsAndRadius(_points[cur], xianp, radius);
  152.                 if (!IsPointsInCircle(list, rightCirleCenter, radius, adjIndex))
  153.                 {
  154.                     return list[j];
  155.                 }
  156.             }
  157.             return -1;
  158.         }
  159.         /// <summary>
  160.         /// 根据角度对邻居列表进行排序
  161.         /// </summary>
  162.         /// <param name="list"></param>
  163.         /// <param name="pre"></param>
  164.         /// <param name="cur"></param>
  165.         private void SortNeighbours(List<int> list, int pre, int cur)
  166.         {
  167.             Point origin = _points[cur];
  168.             Point df;
  169.             if (pre != -1)
  170.             {
  171.                 df = new Point(_points[pre].X - origin.X, _points[pre].Y - origin.Y);
  172.             }
  173.             else
  174.             {
  175.                 df = new Point(1, 0);
  176.             }
  177.             int temp = 0;
  178.             for (int i = list.Count; i > 0; i--)
  179.             {
  180.                 for (int j = 0; j < i - 1; j++)
  181.                 {
  182.                     if (CompareAngle(_points[list[j]], _points[list[j + 1]], origin, df))
  183.                     {
  184.                         temp = list[j];
  185.                         list[j] = list[j + 1];
  186.                         list[j + 1] = temp;
  187.                     }
  188.                 }
  189.             }
  190.         }
  191.         /// <summary>
  192.         /// 检查圆内是否存在其他点
  193.         /// </summary>
  194.         /// <param name="roundPts"></param>
  195.         /// <param name="center"></param>
  196.         /// <param name="radius"></param>
  197.         /// <param name="roundId"></param>
  198.         /// <returns></returns>
  199.         private bool IsPointsInCircle(List<int> roundPts, Point center, double radius, int roundId)
  200.         {
  201.             for (int k = 0; k < roundPts.Count; k++)
  202.             {
  203.                 if (roundPts[k] != roundId)
  204.                 {
  205.                     int index2 = roundPts[k];
  206.                     if (IsPtInCircle(_points[index2], center, radius))
  207.                     {
  208.                         return true;
  209.                     }
  210.                 }
  211.             }
  212.             return false;
  213.         }
  214.         /// <summary>
  215.         /// 根据两点及半径计算圆心
  216.         /// </summary>
  217.         /// <param name="a"></param>
  218.         /// <param name="b"></param>
  219.         /// <param name="r"></param>
  220.         /// <returns></returns>
  221.         private static Point CalCenterByPtsAndRadius(Point a, Point b, double r)
  222.         {
  223.             double dx = b.X - a.X;
  224.             double dy = b.Y - a.Y;
  225.             double cx = 0.5 * (b.X + a.X);
  226.             double cy = 0.5 * (b.Y + a.Y);
  227.             if (r * r / (dx * dx + dy * dy) - 0.25 < 0)
  228.             {
  229.                 return new Point(-1, -1);
  230.             }
  231.             double sqrt = Math.Sqrt(r * r / (dx * dx + dy * dy) - 0.25);
  232.             return new Point(cx - dy * sqrt, cy + dx * sqrt);
  233.         }
  234.         /// <summary>
  235.         /// 检查点是否在圆内
  236.         /// </summary>
  237.         /// <param name="p"></param>
  238.         /// <param name="center"></param>
  239.         /// <param name="r"></param>
  240.         /// <returns></returns>
  241.         private static bool IsPtInCircle(Point p, Point center, double r)
  242.         {
  243.             double dis2 = (p.X - center.X) * (p.X - center.X) + (p.Y - center.Y) * (p.Y - center.Y);
  244.             return dis2 < r * r;
  245.         }
  246.         /// <summary>
  247.         /// 获取半径范围内的邻居列表
  248.         /// </summary>
  249.         /// <param name="radius"></param>
  250.         /// <returns></returns>
  251.         private List<int>[] GetNeighbourList(double radius)
  252.         {
  253.             List<int>[] adjs = new List<int>[_points.Count];
  254.             for (int i = 0; i < _points.Count; i++)
  255.             {
  256.                 adjs[i] = new List<int>();
  257.             }
  258.             for (int i = 0; i < _points.Count; i++)
  259.             {
  260.  
  261.                 for (int j = 0; j < _points.Count; j++)
  262.                 {
  263.                     if (i < j && _distances[i, j] < radius)
  264.                     {
  265.                         adjs[i].Add(j);
  266.                         adjs[j].Add(i);
  267.                     }
  268.                 }
  269.             }
  270.             return adjs;
  271.         }
  272.         /// <summary>
  273.         /// 按距离排序的邻居列表
  274.         /// </summary>
  275.         /// <param name="index"></param>
  276.         /// <returns></returns>
  277.         private List<int> SortNeighboursByDis(int index)
  278.         {
  279.             List<Point> pts = new List<Point>();
  280.  
  281.             for (int i = 0; i < _points.Count; i++)
  282.             {
  283.                 Point pt = _points[i];
  284.                 pt.Id = i;
  285.                 pt.Distance = _distances[index,i];
  286.                 pts.Add(pt);
  287.             }
  288.             pts= pts.OrderBy(p=>p.Distance).ToList();
  289.  
  290.             List<int> adj = new List<int>();
  291.             for (int i = 1; i < pts.Count; i++)
  292.             {
  293.                 adj.Add(pts[i].Id);
  294.             }
  295.             return adj;
  296.         }
  297.         /// <summary>
  298.         /// 比较两个点相对于参考点的角度
  299.         /// </summary>
  300.         /// <param name="a"></param>
  301.         /// <param name="b"></param>
  302.         /// <param name="origin"></param>
  303.         /// <param name="reference"></param>
  304.         /// <returns></returns>
  305.         private bool CompareAngle(Point a, Point b, Point origin, Point reference)
  306.         {
  307.  
  308.             Point da = new Point(a.X - origin.X, a.Y - origin.Y);
  309.             Point db = new Point(b.X - origin.X, b.Y - origin.Y);
  310.             //b相对于参考向量的叉积
  311.             double detb = CalCrossProduct(reference, db);
  312.             // 如果 b 的叉积为零且 b 与参考向量的夹角大于等于零度，则返回 false
  313.             if (detb == 0 && db.X * reference.X + db.Y * reference.Y >= 0)
  314.             {
  315.                 return false;
  316.             }
  317.             //a 相对于参考向量的叉积
  318.             double deta = CalCrossProduct(reference, da);
  319.             //如果 a 的叉积为零且 a 与参考向量的夹角大于等于零度，则返回 true
  320.             if (deta == 0 && da.X * reference.X + da.Y * reference.Y >= 0)
  321.             {
  322.                 return true;
  323.             }
  324.             // 如果 a 和 b 在参考向量的同一侧，则比较它们之间的叉积大小
  325.             if (deta * detb >= 0)
  326.             {
  327.                 //如果叉积大于零，返回 true；否则返回 false
  328.                 return CalCrossProduct(da, db) > 0;
  329.             }
  330.  
  331.             //向量小于零度实际上是很大的，接近 2pi
  332.             return deta > 0;
  333.         }
  334.  
  335.         /// <summary>
  336.         /// 计算两点之间的距离
  337.         /// </summary>
  338.         /// <param name="p1"></param>
  339.         /// <param name="p2"></param>
  340.         /// <returns></returns>
  341.         private static double CalDistanceToPts(Point p1, Point p2)
  342.         {
  343.             return Math.Sqrt((p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y));
  344.         }
  345.         /// <summary>
  346.         /// 计算两个向量的叉积
  347.         /// </summary>
  348.         /// <param name="a"></param>
  349.         /// <param name="b"></param>
  350.         /// <returns></returns>
  351.         private static double CalCrossProduct(Point a, Point b)
  352.         {
  353.             return a.X * b.Y - a.Y * b.X;
  354.         }
  355.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/671688
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号