计算机几何 - 凸包

凸包：在一个实数向量空间V中，对于给定集合X，所有包含X的凸集的交集被称为X的凸包。
啥意思，我也没看懂。通过浏览众多博客文章之后，我对凸包的理解为：
给定一组离散的点，求得包围整个离散点的边的集合。
例如，在墙上随机定了N个钉子，然后用一个足够大的橡皮筋包围这些钉子，那么松开橡皮筋之后，橡皮筋的范围就是凸包。

那么凸包的算法，就是输入一组离散点，返回能够组成凸包的点，将这些点连接起来就是凸包了。
常用的凸包算法是Graham扫描法，和Jarvis步进法
这里我们介绍的是Graham扫描法：
步骤：

1. 从离散点集合S中获取一个y轴最小，x轴最小的点 P0。（如果最小y轴有多个点，就取x轴最小的点）

2. 计算S中其他的点到P0点的极角，并按照从小到大的顺序进行排序的到集合S1（极角相同，取距离最段的排在前），通过排序后可以确定PO点和排序后集合S1 中的第一个点P1点是凸包点，加入凸包列表中。

3. 从S1中取得下一个点（P2），计算P2点位于线段（P0,01）的左边还是右边。

4. 如果是左边，将P2点加入凸包点队列，如果右边，移除上一次加入的点（P1），重新计算P1点与集合中线段的位置关系（这里移除P1后，列表里只有一个，那就直接加入）

5. 重复3到4步骤，知道S1中没有点为止。
   看不懂还麻烦？那直接看张动图：

看图应该很直观了，下面咱们来实现以下，平台的Untiy，语言是C#：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class GrahamScan : MonoBehaviour {
    //离散的点
    public Transform[] Points;
    //组成边的顶点集合
    public List<Transform> ePoint = new List<Transform>();

    private bool IsFinsh = false;
    void Start()
    {
        Aritmetic();
    }

    //算法
    void Aritmetic()
    {
        Transform bp = BasePoint();
        bp.name = "P0";
        ePoint.Add(bp);
        Transform[] polarSort = PolarSort(bp);
        for (int i = 0; i < polarSort.Length; i++)
        {
            if (polarSort[i] == bp) continue;
            polarSort[i].name = "P" + (i + 1);
        }
        //通过排序，而可以得知 第一个点肯定在凸边上
        ePoint.Add(polarSort[0]);
        StartCoroutine(Ia(polarSort));
    }

    IEnumerator Ia(Transform[] polarSort)
    {
        for (int i = 1; i < polarSort.Length; i++)
        {
            yield return new WaitForSeconds(1);
            ePoint.Add(polarSort[i]);
            float d = PointDir(ePoint[ePoint.Count-1].position, ePoint[ePoint.Count - 2].position, ePoint[ePoint.Count - 3].position);
            if (d <= 0)
                continue;
            while (true)
            {
                yield return new WaitForSeconds(1);
                ePoint.RemoveAt(ePoint.Count-2);
                d = PointDir(ePoint[ePoint.Count - 1].position, ePoint[ePoint.Count - 2].position, ePoint[ePoint.Count - 3].position);
                if (d < 0)
                    break;
            }
        }
        IsFinsh = true;
    }

    void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        if (!IsFinsh)
        {
            for (int i = 0; i < ePoint.Count - 1; i++)
                Gizmos.DrawLine(ePoint[i].position, ePoint[i + 1].position);
            return;
        }

        for (int i = 0; i < ePoint.Count; i++)
        {
            if (i == ePoint.Count - 1)
            {
                Gizmos.DrawLine(ePoint[i].position,ePoint[0].position);
                continue;
            }
            Gizmos.DrawLine(ePoint[i].position,ePoint[i+1].position);
        }

    }

    /// <summary>
    /// 获取基点P0
    /// </summary>
    /// <returns></returns>
    Transform BasePoint()
    {
        //取y值最小 如果多个y值相等，去x最小(这里y 我们取z)
        Transform minPoint = Points[0];
        for (int i = 1; i < Points.Length; i++)
        {
            if (Points[i].position.z < minPoint.position.z)
                minPoint = Points[i];
            else if (Points[i].position.z < minPoint.position.z)
                minPoint = Points[i].position.x < minPoint.position.x ? Points[i] : minPoint;
        }
        return minPoint;
    }
    /// <summary>
    /// 获取点的方向 =0 在线上 <0在左侧 >0在右侧
    /// </summary>
    /// <param name="p"></param>
    /// <param name="p1"></param>
    /// <param name="p2"></param>
    /// <returns></returns>
    float PointDir(Vector3 p, Vector3 p1, Vector3 p2)
    {
        Vector3 v1 = p1 - p;
        Vector3 v2 = p2 - p1;
        float f = v1.x * v2.z - v2.x * v1.z;
        return f;
    }

    /// <summary>
    /// 极角排序
    /// </summary>
    /// <param name="bp"></param>
    /// <returns></returns>
    Transform[] PolarSort(Transform bp)
    {
        List<Transform> p = new List<Transform>();
        for (int i = 0; i < Points.Length; i++)
        {
            //如果是自己，则跳过
            if (Points[i] == bp) continue;
            Vector3 v = Vector3.zero;
            float e = GetProlar(Points[i], bp,out v);
            int index = -1;
            for (int j = 0; j < p.Count; j++)
            {
                Vector3 v1 = Vector3.zero;
                float e1 = GetProlar(p[j],bp,out v1);
                if (e1 > e)
                {
                    index = j;
                    break;
                }
                if (e1 == e && v.magnitude < v1.magnitude)
                {
                    index = j;
                    break;
                }
            }
            if (index == -1)
            {
                p.Add(Points[i]);
                continue;
            }
            p.Insert(index,Points[i]);
        }
        return p.ToArray();
    }
    /// <summary>
    /// 获取极角
    /// </summary>
    /// <param name="pos1"></param>
    /// <param name="pos2"></param>
    /// <returns></returns>
    float GetProlar(Transform pos1, Transform pos2,out Vector3 v)
    {
        v = pos1.position - pos2.position;
        return Mathf.Atan2(v.z,v.x);
    }

}

这里只是按照上面步骤实现了一下，排序使用的是插入排序，为了方便观察，使用协程表现出动画的效果。
因为这里使用的Y轴正交视图，所以把上面说的Y轴修改为Z轴。
测试时，将出创建离散点(GameObject)拖拽到Points列表中。