計算機幾何 - 凸包

凸包：在一個實數向量空間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列表中。