using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DfdIO;
using NetTopologySuite.Geometries;

namespace Construction.BatchCreateMap
{
    /// <summary>
    /// 凸包算法
    /// </summary>
    public class PointsHull
    {
        private static double ToleranceFactor = 1e-30;
        /**
* 下面实现一下正规的braham算法
* 1，将满足要求的点放在[0]位置处
* 2，按照与[0]点的极角大小，对其它点排序，从小到达排序
* 3，将[0][1][2]点放入栈中，然后判断所有其它点是不是都在[top-1][top]向量的逆时针方向
* 	3.1 如果是，则取下一点放入栈中，并继续判断，直到没有更多点再放入栈中
* 	3.2 如果不是，则弹出[top]点，并加入下一点，继续判断
* */
        /// <summary>
        /// 凸包算法－braham扫描
        /// </summary>
        public static CoordinateList Brahamscan(Coordinate[] set, double distanceStep)
        {
            //记录下来满足起始点要求的元素的下标
            int nCount = set.Length;
            int unum = 0;
            for (int i = 1; i < nCount; i++)
            {
                if (set[unum].Y > set[i].Y ||
                        (set[unum].Y == set[i].Y && set[unum].X > set[i].X))
                {
                    unum = i;
                }
            }
            //将满足要求的元素放在第一位
            if (unum != 0)
            {
                Coordinate tmp = set[0];
                set[0] = set[unum];
                set[unum] = tmp;
            }
            //对set进行排序，快速排序
            QSort(set, 1, nCount - 1);

            CoordinateList lstReturn = new CoordinateList();
            lstReturn.Add(set[0]);
            for (int i = 1; i < nCount; i++)
            {
                if (isok(set, lstReturn[lstReturn.Count - 1], set[i]))
                {
                    lstReturn.Add(set[i]);
                }
            }
            lstReturn.Add(lstReturn[0]);
            // 重新以中心点进行排序
            //DfPoint dfpCenter = getCenterPoint(set);
            //set.Insert(0, dfpCenter);
            //QSort(set, 1, set.Count - 1);

            //DfPoint dpStart, dpEnd;
            //for (int i = 0; i < lstReturn.Count - 1; i++)
            //{
            //    dpStart = lstReturn[i];
            //    dpEnd = lstReturn[i + 1];
            //    for (int j = 0; j < set.Count; j++)
            //    {
            //        if ((set[j].X == dpStart.X && set[j].Y == dpStart.Y)
            //            || (set[j].X == dpEnd.X && set[j].Y == dpEnd.Y))
            //        {
            //            continue;
            //        }
            //        double h = Math.Abs(Multi(dpStart, set[j], dpEnd)) / Dist(dpStart, dpEnd);
            //        // 距离小于步长，并且垂足在线段内部
            //        if (h < distanceStep && isPedalIn(dpStart, dpEnd, set[j]))
            //        {
            //            lstReturn.Insert(i + 1, set[j]);
            //            set.RemoveAt(j);
            //            j--;
            //            i++;
            //        }
            //    }
            //}
            return lstReturn;
        }
        /// <summary>
        /// 两点距离
        /// </summary>
        /// <param name="arg1"> </param>
        /// <param name="arg2"> </param>
        /// <returns> </returns>
        static double Dist(DfPoint arg1, DfPoint arg2)
        {
            return Math.Sqrt((arg1.X - arg2.X) * (arg1.X - arg2.X)
                + (arg1.Y - arg2.Y) * (arg1.Y - arg2.Y));
        }

        /// <summary>
        /// 获得中心点
        /// </summary>
        /// <param name="trackPoints"> </param>
        /// <returns> </returns>
        private static DfPoint getCenterPoint(List<DfPoint> trackPoints)
        {
            DfPoint dfpReturn = new DfPoint();
            int nLength = trackPoints.Count;
            for (int i = 0; i < nLength; i++)
            {
                dfpReturn.X += trackPoints[i].X / nLength;
                dfpReturn.Y += trackPoints[i].Y / nLength;
            }
            return dfpReturn;
        }
        /// <summary>
        /// 计算垂足
        /// </summary>
        /// <param name="startPoint"> </param>
        /// <param name="endPoint"> </param>
        /// <param name="outPoint"> </param>
        /// <returns> </returns>
        private static DfPoint getPedal(DfPoint startPoint, DfPoint endPoint, DfPoint outPoint)
        {
            DfPoint dfpReturn = new DfPoint();
            double dA, dB, dC;// 直线方程系数
            dA = (endPoint.Y - startPoint.Y);
            dB = startPoint.X - endPoint.X;
            dC = dA * startPoint.X + dB * startPoint.Y;
            double dC2 = outPoint.Y * dA - outPoint.X * dB;
            dfpReturn.Y = (dB * dC + dC2 * dA) / (dA * dA + dB * dB);
            dfpReturn.X = (dA * dC - dB * dC2) / (dA * dA + dB * dB);
            return dfpReturn;
        }
        /// <summary>
        /// 扫描并插入接近边界的点
        /// </summary>
        /// <param name="set"> </param>
        /// <param name="distanceStep"> </param>
        /// <returns> </returns>
        private static List<DfPoint> insertScan(List<DfPoint> set, double distanceStep)
        {
            List<DfPoint> lstReturn = new List<DfPoint>();

            return lstReturn;
        }

        private static bool isok(Coordinate[] set, Coordinate start, Coordinate end)
        {
            bool flag = true;
            int nCount = set.Length;
            for (int i = 0; i < nCount; i++)
            {
                //if((end.Y> start.Y && set[i].Y < end.Y)                    
                //   || (end.Y < start.Y && set[i].Y > end.Y))
                //{
                //    continue;
                //}
                //<0 : 说明set[i] 在start->end向量的顺时针方向,退出
                if (Multi(start, end, set[i]) < -ToleranceFactor)
                {
                    flag = false;
                    break;
                }
            }
            return flag;
        }

        /// <summary>
        /// 判断垂足是否在线段内部
        /// </summary>
        /// <param name="startPoint"> </param>
        /// <param name="endPoint"> </param>
        /// <param name="outPoint"> </param>
        /// <returns> </returns>
        private static bool isPedalIn(DfPoint startPoint, DfPoint endPoint, DfPoint outPoint)
        {
            bool isIn = false;
            double dA, dB, dC;// 直线方程系数
            dA = (endPoint.Y - startPoint.Y);
            dB = startPoint.X - endPoint.X;
            dC = dA * startPoint.X + dB * startPoint.Y;
            double dC2 = outPoint.Y * dA - outPoint.X * dB;
            double dCrossX, dCrossY;
            dCrossY = (dB * dC + dC2 * dA) / (dA * dA + dB * dB);
            dCrossX = (dA * dC - dB * dC2) / (dA * dA + dB * dB);
            if ((dCrossY - startPoint.Y) * (dCrossY - endPoint.Y) < 0
                && (dCrossX - startPoint.X) * (dCrossX - endPoint.X) < 0)
            {
                isIn = true;
            }

            return isIn;
        }
        /**
         * isok:
         * 判断set中的点是否全部都在start->end 构成的向量的逆时针方向
         * */
        /**
 * 
 * 以set[0]为基点，对set[1]..set[length-1]排序
 * 如果multi(set[0],set[i],set[j])<0，说明set[j]在set[0]->set[i]的顺时针方向，
 * 那么set[0]->set[j]的极角就比set[0]->set[i]的极角小，那么set[j]就应该排在set[i]的前面
 * */
        /**
         * 快速排序：
         * */
        //通过矢量叉积求极角关系(p0p1)(p0p2)
        // 叉积可以用来判断平面向量夹角的正负。对于向量a、b，a×b=axby-bxay，其值大于0则夹角为正
        //P*Q > 0,P在Q的顺时针方向... ...
        /// <summary>
        /// 叉积运算
        /// </summary>
        /// <param name="p0"> </param>
        /// <param name="p1"> </param>
        /// <param name="p2"> </param>
        /// <returns> </returns>
        static double Multi(Coordinate p0, Coordinate p1, Coordinate p2)
        {
            return (p1.X - p0.X) * (p2.Y - p0.Y) - (p2.X - p0.X) * (p1.Y - p0.Y);
        }

        /// <summary>
        /// 快速排序 以set[0]为基点，对set[1]..set[length-1]排序
        /// </summary>
        /// <param name="set"> </param>
        /// <param name="start"> </param>
        /// <param name="end"> </param>
        private static void QSort(Coordinate[] set, int start, int end)
        {
            if (start < end)
            {
                int x = start;
                int j = end;
                int i = start + 1;
                //当i=j时，所有大于set[x]的元素都在set[x]的右面，所有小于set[x]的元素都在set[x]的左面
                while (i <= j)
                {
                    //找到一个set[j]<set[x]，并交换
                    while (j >= i)
                    {
                        //<0 : set[j]点在set[0]->set[x]向量的顺时针方向
                        //set[j]与set[x]交换
                        //==0 ： 三点共线，判断距离
                        //距离近的小OrientationIndex
                        int flag = (int)Multi(set[0], set[x], set[j]);
                        if (flag < 0 || (flag == 0 && (set[j].Distance(set[0]) < set[x].Distance(set[0]))))
                            //if (flag < 0 || (flag == 0 && (Dist(set[j], set[0]) < Dist(set[x], set[0]))))
                        {
                            Coordinate tmp = set[x];
                            set[x] = set[j];
                            set[j] = tmp;
                            x = j;
                            j--;
                            break;
                        }
                        j--;
                    }
                    //找到set[i]>set[x]，并交换
                    while (i <= j)
                    {
                        //>0 : set[i]点在set[0]->set[x]向量的逆时针方向
                        //set[i]与set[x]交换
                        //==0 ： 三点共线，判断距离
                        //距离大的大
                        double flag = Multi(set[0], set[x], set[i]);
                        //if (flag > 0.0 || (flag == 0.0 && (Dist(set[i], set[0]) > Dist(set[x], set[0]))))
                        if (flag > 0.0 || (flag == 0.0 && (set[i].Distance(set[0]) > set[x].Distance(set[0]))))
                        {
                            Coordinate tmp = set[x];
                            set[x] = set[i];
                            set[i] = tmp;
                            x = i;
                            i++;
                            break;
                        }
                        i++;
                    }
                }
                QSort(set, start, x - 1);
                QSort(set, x + 1, end);
            }
        }
    }
}