GIS面积计算问题

好长时间不更新了，今天说点干货，项目用到的。

1、项目中要用到计算面积的，根据火星坐标；

2、百度找了各种面积计算，google了半天，也没发现那个比较准确；

直接说干货吧。咱也高大上一会，用 ArcGIS

需要的dll有 ESRI.ArcGIS.Client.Toolkit.dll 和 ESRI.ArcGIS.Client.dll 这两个dll即可，不需要那么多的dll，可到官网下载，也可以到dll之家下载（http://www.dllzj.com/ESRI.ArcGIS.Client.dll/）

计算面积的代码，这个代码比较简单

 GeometryService geometryService = new GeometryService("http://tasks.arcgisonline.com/ArcGIS/rest/services/Geometry/GeometryServer");
 Polygon polygon = new Polygon();
 polygon.SpatialReference = new SpatialReference(4326);//球面坐标
 PointCollection GPSpoints = new PointCollection();//保存84坐标的集合
 for (int i = 0; i < arraytemp.Count; i++)
 {
 　　JArray arraystr = (JArray)JsonConvert.DeserializeObject(arraytemp[i].ToString());
 　　GPSpoints.Add(new MapPoint(Convert.ToDouble(arraystr[0].ToString()), Convert.ToDouble(arraystr[1].ToString())));
 }
  polygon.Rings.Add(GPSpoints);

 Graphic graphic = new Graphic();
 graphic.Geometry = polygon;
 IList<Graphic> graphicList = new List<Graphic>(); //构建参数
 graphicList.Add(graphic);
 graphicList = geometryService.Project(graphicList, new SpatialReference(102100));//执行转换
 var args = geometryService.AreasAndLengths(graphicList, LinearUnit.Meter, LinearUnit.Meter, CalculationType.Geodesic);//Geodesic 采用球面面积计算方式 102113
 area = args.Areas[0];

说下其中的注意点，其中4326指的84坐标，但是国内的地图一般都是火星坐标（腾讯和高德，百度更闹心，直接是自己的坐标），就是加了偏移量的，具体的84坐标和火星坐标的转化，这个可能比较常见，代码如下

        public static string BAIDU_LBS_TYPE = "bd09ll";

        public static double pi = 3.1415926535897932384626;
        public static double a = 6378245.0;
        public static double ee = 0.00669342162296594323;

        /**
         * 84 to 火星坐标系 (GCJ-02) World Geodetic System ==> Mars Geodetic System
         *
         * @param lat
         * @param lon
         * @return
         */
        public static Gps gps84_To_Gcj02(double lat, double lon)
        {
            if (outOfChina(lat, lon))
            {
                return null;
            }
            double dLat = transformLat(lon - 105.0, lat - 35.0);
            double dLon = transformLon(lon - 105.0, lat - 35.0);
            double radLat = lat / 180.0 * pi;
            double magic = Math.Sin(radLat);
            magic = 1 - ee * magic * magic;
            double sqrtMagic = Math.Sqrt(magic);
            dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
            dLon = (dLon * 180.0) / (a / sqrtMagic * Math.Cos(radLat) * pi);
            double mgLat = lat + dLat;
            double mgLon = lon + dLon;
            return new Gps(mgLat, mgLon);
        }

        /**
         * * 火星坐标系 (GCJ-02) to 84 * * @param lon * @param lat * @return
         * */
        public static Gps gcj_To_Gps84(double lat, double lon)
        {
            Gps gps = transform(lat, lon);
            double lontitude = lon * 2 - gps.getWgLon();
            double latitude = lat * 2 - gps.getWgLat();
            return new Gps(latitude, lontitude);
        }

        /**
         * 火星坐标系 (GCJ-02) 与百度坐标系 (BD-09) 的转换算法 将 GCJ-02 坐标转换成 BD-09 坐标
         *
         * @param gg_lat
         * @param gg_lon
         */
        public static Gps gcj02_To_Bd09(double gg_lat, double gg_lon)
        {
            double x = gg_lon, y = gg_lat;
            double z = Math.Sqrt(x * x + y * y) + 0.00002 * Math.Sin(y * pi);
            double theta = Math.Atan2(y, x) + 0.000003 * Math.Cos(x * pi);
            double bd_lon = z * Math.Cos(theta) + 0.0065;
            double bd_lat = z * Math.Sin(theta) + 0.006;
            return new Gps(bd_lat, bd_lon);
        }

        /**
         * * 火星坐标系 (GCJ-02) 与百度坐标系 (BD-09) 的转换算法 * * 将 BD-09 坐标转换成GCJ-02 坐标 * * @param
         * bd_lat * @param bd_lon * @return
         */
        public static Gps bd09_To_Gcj02(double bd_lat, double bd_lon)
        {
            double x = bd_lon - 0.0065, y = bd_lat - 0.006;
            double z = Math.Sqrt(x * x + y * y) - 0.00002 * Math.Sin(y * pi);
            double theta = Math.Atan2(y, x) - 0.000003 * Math.Cos(x * pi);
            double gg_lon = z * Math.Cos(theta);
            double gg_lat = z * Math.Sin(theta);
            return new Gps(gg_lat, gg_lon);
        }

        /**
         * (BD-09)-->84
         * @param bd_lat
         * @param bd_lon
         * @return
         */
        public static Gps bd09_To_Gps84(double bd_lat, double bd_lon)
        {

            Gps gcj02 = PositionUtil.bd09_To_Gcj02(bd_lat, bd_lon);
            Gps map84 = PositionUtil.gcj_To_Gps84(gcj02.getWgLat(),
                    gcj02.getWgLon());
            return map84;

        }

        /**
       * 度分秒转84
       * @param lat
       * @param lon
       * @return
       */
        public static Gps dufenmiao_To_Gps84(double lat, double lon)
        {
            return new Gps(convertdufenmiao(lat), convertdufenmiao(lon));
        }
        private static double convertdufenmiao(double num)
        {
            var strlist = num.ToString().Split('.');
            string m_fen = strlist[1].Substring(0, 2);//取分
            string m_miao = strlist[1].Substring(2, 2);//取秒
            double fen = Convert.ToDouble(m_fen) / 60;
            double miao = Convert.ToDouble(int.Parse(m_miao)) / 3600;
            double mn = fen + miao;
            return Convert.ToDouble((Convert.ToDouble(strlist[0]) + mn).ToString("0.00000000"));
        }

        /**
        * 84转度分秒
        * @param lat
        * @param lon
        * @return
        */
        public static Gps gps84_To_Dufenmiao(double lat, double lon)
        {
            return new Gps(convert84(lat), convert84(lon));
        }
        private static double convert84(double num)
        {
            var strlist = num.ToString().Split('.');
            double fentemp = Convert.ToDouble("0." + strlist[1]) * 60;
            string fen = Convert.ToDouble(fentemp).ToString();
            if (fen.Contains("."))
            {
                var fenlist = fen.Split('.');//分
                double miaotemp = Convert.ToDouble("0." + fenlist[1]) * 60;
                string miao = Convert.ToInt32(miaotemp).ToString();
                string temp = strlist[0] + "." + fenlist[0] + Convert.ToInt32(Convert.ToDouble(miao)).ToString();
                return Convert.ToDouble(temp);
            }
            else
            {
                return Convert.ToDouble(strlist[0] + "." + fen);
            }
        }

        public static Boolean outOfChina(double lat, double lon)
        {
            if (lon < 72.004 || lon > 137.8347)
                return true;
            if (lat < 0.8293 || lat > 55.8271)
                return true;
            return false;
        }

        public static Gps transform(double lat, double lon)
        {
            if (outOfChina(lat, lon))
            {
                return new Gps(lat, lon);
            }
            double dLat = transformLat(lon - 105.0, lat - 35.0);
            double dLon = transformLon(lon - 105.0, lat - 35.0);
            double radLat = lat / 180.0 * pi;
            double magic = Math.Sin(radLat);
            magic = 1 - ee * magic * magic;
            double sqrtMagic = Math.Sqrt(magic);
            dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
            dLon = (dLon * 180.0) / (a / sqrtMagic * Math.Cos(radLat) * pi);
            double mgLat = lat + dLat;
            double mgLon = lon + dLon;
            return new Gps(mgLat, mgLon);
        }

        public static double transformLat(double x, double y)
        {
            double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y
                    + 0.2 * Math.Sqrt(Math.Abs(x));
            ret += (20.0 * Math.Sin(6.0 * x * pi) + 20.0 * Math.Sin(2.0 * x * pi)) * 2.0 / 3.0;
            ret += (20.0 * Math.Sin(y * pi) + 40.0 * Math.Sin(y / 3.0 * pi)) * 2.0 / 3.0;
            ret += (160.0 * Math.Sin(y / 12.0 * pi) + 320 * Math.Sin(y * pi / 30.0)) * 2.0 / 3.0;
            return ret;
        }

        public static double transformLon(double x, double y)
        {
            double ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1
                    * Math.Sqrt(Math.Abs(x));
            ret += (20.0 * Math.Sin(6.0 * x * pi) + 20.0 * Math.Sin(2.0 * x * pi)) * 2.0 / 3.0;
            ret += (20.0 * Math.Sin(x * pi) + 40.0 * Math.Sin(x / 3.0 * pi)) * 2.0 / 3.0;
            ret += (150.0 * Math.Sin(x / 12.0 * pi) + 300.0 * Math.Sin(x / 30.0
                    * pi)) * 2.0 / 3.0;
            return ret;
        }

在这里，对于火星坐标，84坐标，还有平面坐标系、大地坐标系，已经高斯平面直角坐标系这类的问题，请自行百度 or google，必经我也不知道很清楚，我就知道他们区别挺大的。

以为到这里就搞定，那么我想着真的是侮辱宝宝的智商了，大爷的，走这个接口的时候，一直让我泪奔呀，10次里面5次的状态吗都是500，也是R了哈士奇了。

经过N次测试，终于确定了一个问题，那就是，原来是点太多了，就是利用gps采集器或者手持设备采集的点太多了，计算的过程中，因为返回的对象是 AreasAndLengths 也就是说返回的不仅仅是面积，还有周长等，那么这时候就需要注意了，如果点太多，就会 over 的，最终得到的结果是180个点以内，是最稳定的。

接下里就开始嘚瑟今天的重要内容。

　　对于N个点来讲，我们怎么让无限趋近于180这个数字，当然，如果是少于180个点，这个可以直接参与运算，如果是300，330，500这样的点数呢。也就是说我们需要一个算法让GPS的点的总数无线趋近于180。

　　1、那么最基本的肯定先取商，也就是说用N来除180，商是多少，当然，是取整数的，但是这个时候我们就要去想需要向上取整还是向下取整，OK，我们来回想一下，如果向下取整的话，那么就意味着这时候，商 × 180 小于 N。那么这时候就会出现这种情况，如果有359个点，我们设置的计算常数是180；359 ÷ 180 取整得到 1，那么这时候怎么取呢？

　　2、比如就这个359个点，我们采取向上取整，也就是每当余数是 0 的时候，我们把这个点加到我们的 计算的点的集合 里面，对于这种情况就已经搞定了。

　　3、那么，如果有240个点呢，怎么办？向上取整是去到的点数还是 2，这是按照 240 ÷ 2 =120，也就是每两个点取一个点的时候，这时候剩下的就有120个点，然而，我们才取了120个点，所以，我们这时候就要注意一个问题，排序的问题。

　　4、关于排序，我们现在想想，如果不排序的话，那么，就上一步从剩下的120个点里面取剩下的60个点的时候是不是和原来的顺序就有可能乱呢？比如本来 A点 采集的索引是 ，但是计算之后成了我们取了list[0]、list[2]之后，然后再取A点，这时候如果再把这个点加入到要参与计算的这个集合中，是不是顺序就乱了呢？这个点应该就成了 list[120] 了；

　　5、所以，我们这里需要排序，也就是说对于传输进来的点，参与计算之前，我们就需要对每个点进行排序，然后用每个点的索引参与计算，最终得到的是参与计算的点的索引的集合，从而取到对应的点，然后参与计算；

　　6、继续刚才的4的问题，如何取剩下的120个点呢，因为之前我们已经取了120个点，而且对于这240个点，这120个点已经参与了计算，那么，如果再次取点的时候，这时候是不能把已经取走的120个点参与计算的，也就是说我们接下来就是从剩下的120个点取出需要的60个点，这个问题就简单了，任然是取余数了。

　　综上所述，其实取点的过程就是一个循环取值的过程。然后需要注意每个点的排序的问题。

        /// <summary>
        ///
        /// </summary>
        /// <param name="all">点的数量</param>
        /// <param name="count">要取的点</param>
        /// <returns></returns>
        private static List<int> CalcPointIndex(int all, int count)
        {
            List<int> beingList = new List<int>();
            List<int> selList = new List<int>();
            count = count - 10;
            //前后各去掉10个值
            for (int i = 10; i < all - 10; i++)
            {
                beingList.Add(i);
            }
            //从前后各去掉10个值中均匀取5个
            int[] nums = { 0, 2, 4, 6, 8 };//取开始的点
            int[] nume = { all - 9, all - 7, all - 5, all - 3, all - 1 };//取结束的点

            selList = ReturnListInt(nums, selList);
            selList = ReturnListInt(nume, selList);

            if (beingList.Count < (BASE_NUM - 10))//如果此时点数已经小于，则直接返回
            {
                foreach (var item in selList)
                {
                    beingList.Add(item);
                }
                selList = null;
                selList = SoftListInt(beingList);
            }
            else
            {
                List<int> sel = new List<int>();
                List<int> temp = reSel(ref beingList, ref sel, count);
                for (int i = 0; i < temp.Count; i++)
                {
                    selList.Add(temp[i]);
                }
                selList = SoftListInt(selList);
            }
            return selList;
        }

        /// <summary>
        /// 均匀采样
        /// </summary>
        /// <param name="beingList"></param>
        /// <param name="sel">当前选择的点</param>
        /// <param name="count">本次需要取的点的总数</param>
        /// <returns></returns>
        private static List<int> reSel(ref List<int> beingList, ref List<int> sel, int count)
        {
            List<int> thistimeAdd = new List<int>();//本次要添加的点
            if (count > 0 && count != 1)
            {
                string t = Math.Ceiling(Convert.ToDouble(beingList.Count / double.Parse(count.ToString()))).ToString();
                int sCount = int.Parse(t);//向上取整
                int n = 0;//取的是临时变量，存储本次循环添加了多少新的点
                for (int i = 0; i < beingList.Count; i++)
                {
                    if (i % sCount == 0 && i != 0)
                    {
                        n++;
                        sel.Add(beingList[i]);
                    }
                    else
                    {
                        thistimeAdd.Add(beingList[i]);
                    }
                }
                beingList = null;
                beingList = thistimeAdd;
                count = count - n;
                if (count > 0)
                {
                    reSel(ref beingList, ref sel, count);
                }
            }
            else
            {
                string t = Math.Ceiling(Convert.ToDouble(beingList.Count / 2)).ToString();
                int sCount = int.Parse(t);//向上取整
                sel.Add(beingList[sCount]);
                beingList.RemoveAt(sCount);
            }
            return sel;
        }

        /// <summary>
        /// 循环加载点
        /// </summary>
        /// <param name="nums"></param>
        /// <param name="list"></param>
        /// <returns></returns>
        private static List<int> ReturnListInt(int[] nums, List<int> list)
        {
            for (int i = 0; i < nums.Count(); i++)
            {
                list.Add(nums[i]);
            }
            return SoftListInt(list);
        }

        /// <summary>
        /// 排序
        /// </summary>
        /// <param name="sel"></param>
        /// <returns></returns>
        private static List<int> SoftListInt(List<int> sel)
        {
            sel.Sort();//Reverse(); 倒序
            return sel;
        }

　　这里，需要提醒一下 其中  int nums[] 和 int nume[] 分别取的是开始的点和结束的点，这个点是固定取值的，为了闭合整个图层；

　　还有对于其中的BASE_NUM这就是常数180　　

if (beingList.Count < (BASE_NUM - 10))

　　这句话的目的真的为了防止浪费资源，因为在我看来，如果有1000个点，去掉，880个点和870点区别不是很大。

　　

　　我觉得，还是再来点实际的吧，必经都是开发项目的不是，你们难道没发现用高德地图的过程中，如果是卫星图，则会出现此区域无卫星图么？其实，人家是提供了解决方案的。直接上代码，这个最简单了，在js里面加入图层就可以了。

    //谷歌地图
    var googleLayerf = new AMap.TileLayer({
        getTileUrl: 'http://mt{1,2,3,0}.google.cn/vt/lyrs=s&hl=zh-CN&gl=cn&x=[x]&y=[y]&z=[z]&s=Galile'
    });//引用谷歌url
    var roadNetLayerf = new AMap.TileLayer.RoadNet(); //

    var map = new AMap.Map("container", {
        resizeEnable: true,
        zoom: 12,
        layers: [googleLayerf, roadNetLayerf],
        center: [longit, latitu]//地图中心点
    });

　　好了，这事情就这么搞定了。虽然装逼挺累的，但是这玩意想出来还有得费点劲的，特别中间的排序和索引的问题。