Point[] poin = new Point[gpsList.Count()];

for (int i = 0; i < gpsList.Count(); i++)
{
    string[] xy = gpsList[i].Split(\',\');
    double x = ConvertHelp.obj2Double(xy[0], 0);
    double y = ConvertHelp.obj2Double(xy[1], 0);
    poin[i].X = (int)(x * 1000000);
    poin[i].Y = (int)(y * 1000000);
}

IntPtr orginRgn = IntPtr.Zero;
orginRgn = CreatePolygonRgn(poin, poin.Count(), 1);

    /// <summary>
        /*
         * CombineRgn(
              p1: HRGN;     {合成后的区域}
              p2, p3: HRGN; {两个原始区域}
              p4: Integer   {合并选项; 见下表}
            ): Integer;     {有四种可能的返回值}

            //合并选项:
            RGN_AND  = 1;
            RGN_OR   = 2;
            RGN_XOR  = 3;
            RGN_DIFF = 4;
            RGN_COPY = 5; {复制第一个区域}

            //返回值:
            ERROR         = 0; {错误}
            NULLREGION    = 1; {空区域}
            SIMPLEREGION  = 2; {单矩形区域}
            COMPLEXREGION = 3; {多矩形区域}
         */
        /// </summary>
        /// <param name="dest"></param>
        /// <param name="src1"></param>
        /// <param name="src2"></param>
        /// <param name="flags"></param>
        /// <returns></returns>
        [DllImport("gdi32.dll", CharSet = CharSet.Auto)]
        public static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);

int nMix = CombineRgn(nextRgn, orginRgn, nextRgn, 1);
if (nMix != 1 && nMix != 0)
{
    //有交集
}                    

        public struct RGNDATAHEADER
        {
            public int dwSize;
            public int iType;
            public int nCount;
            public int nRgnSize;
            public RECT rcBound;
        }

        public struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }
        /// <summary>
        /// 获取数据参考：http://www.pinvoke.net/default.aspx/gdi32/GetRegionData.html
        /// 数据结构参考：http://www.cnblogs.com/del/archive/2008/05/20/1203446.html
        /// </summary>
        /// <param name="hRgn"></param>
        /// <param name="size"></param>
        /// <param name="lpRgnData"></param>
        /// <returns></returns>
        [DllImport("gdi32.dll", CharSet = CharSet.Auto, SetLastError = true, ExactSpelling = true)]
        public static extern int GetRegionData(HandleRef hRgn, int size, IntPtr lpRgnData);

        
	const int RDH_RECTANGLES = 1;

        /// <summary>
        /// 分割多边形，获取多边形内所有的矩形
        /// </summary>
        /// <param name="hRgn"></param>
        /// <returns></returns>
        public unsafe static RECT[] RectsFromRegion(IntPtr hRgn)
        {
            RECT[] rects = null;
            var hr = new HandleRef(null, hRgn);
            // First we call GetRegionData() with a null buffer.
            // The return from this call should be the size of buffer
            // we need to allocate in order to receive the data. 
            int dataSize = GetRegionData(hr, 0, IntPtr.Zero);

            if (dataSize != 0)
            {
                IntPtr bytes = IntPtr.Zero;

                // Allocate as much space as the GetRegionData call 
                // said was needed
                bytes = Marshal.AllocCoTaskMem(dataSize);

                // Now, make the call again to actually get the data
                int retValue = GetRegionData(hr, dataSize, bytes);

                // From here on out, we have the data in a buffer, and we 
                // just need to convert it into a form that is more useful
                // Since pointers are used, this whole routine is \'unsafe\'
                // It\'s a small sacrifice to make in order to get this to work.
                // [RBS] Added missing second pointer identifier
                RGNDATAHEADER* header = (RGNDATAHEADER*)bytes;

                if (header->iType == RDH_RECTANGLES)
                {
                    rects = new RECT[header->nCount];

                    // The rectangle data follows the header, so we offset the specified
                    // header size and start reading rectangles.
                    //获取偏移
                    int rectOffset = header->dwSize;
                    for (int i = 0; i < header->nCount; i++)
                    {
                        // simple assignment from the buffer to our array of rectangles
                        // will give us what we want.
                        //首先把bytes转换成指针，得到bytes的地址，然后加上偏移，再转换为RECT类型的指针。
                        rects[i] = *((RECT*)((byte*)bytes + rectOffset + (Marshal.SizeOf(typeof(RECT)) * i)));
                    }
                }

            }

            // Return the rectangles
            return rects;

        }

        /// <summary>
        /// 计算多边形的面积
        /// </summary>
        /// <param name="rgn"></param>
        /// <returns></returns>
        public static int CalculateAreas(IntPtr rgn)
        {
            RECT[] rectData = RectsFromRegion(rgn);
            int ret = 0;
            foreach (var rect in rectData)
            {
                int areas = (rect.Bottom - rect.Top) * (rect.Right - rect.Left);
                if (areas < 0)
                    areas = areas * -1;
                ret += areas;
                //Console.WriteLine("{0},{1},{2},{3},{4}", rect.Top, rect.Left, rect.Right, rect.Bottom, areas);
            }
            return ret;
        }