百度地图API画多边型,测面积
时间: 2015-06-12 11:00:40     来源: 广西方术科技有限公司

脚本:


 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
      
    <html>  
    <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />  
    <title>耕地分布图</title>  
    <script type="text/javascript" src="http://api.map.baidu.com/api?v=1.3"></script>  
    <script src="Js/jquery-1.3.2.js" type="text/javascript"></script>  
    <script src="Js/GeoUtils.js" type="text/javascript"></script>  
    <style type="text/css">  
      html,body  
        {  
            height:100%;  
            margin:0;  
        }  
    </style>  
    </head>  
      
    <body>  
    <div style="width:100%; height:100%;z-index:9;border:1px solid gray" id="container"></div>  
    </body>  
    </html>  
    <script type="text/javascript">  
        var map = new BMap.Map("container", { mapType: BMAP_HYBRID_MAP });      //设置卫星图为底图  
        map.centerAndZoom(new BMap.Point(112.244629, 32.094896), 15);                     // 初始化地图,设置中心点坐标和地图级别。  
        map.enableScrollWheelZoom();                            //启用滚轮放大缩小  
        map.addControl(new BMap.NavigationControl());  //添加鱼骨控件  
        map.addControl(new BMap.MapTypeControl());          //添加地图类型控件  
        map.setCurrentCity("襄阳");          // 设置3D地图显示的城市 此项是必须设置的  
      
      
        fun(1, "112.254474,32.088357", "new BMap.Point(112.25221,32.091263),new BMap.Point(112.252785,32.091202),new BMap.Point(112.252929,32.090621),new BMap.Point(112.253576,32.090407),new BMap.Point(112.253576,32.090896),new BMap.Point(112.256199,32.090468),new BMap.Point(112.256558,32.091416),new BMap.Point(112.258319,32.091355),new BMap.Point(112.256055,32.085114),new BMap.Point(112.254007,32.085451),new BMap.Point(112.252785,32.085512),new BMap.Point(112.252282,32.085145),new BMap.Point(112.251851,32.085145),new BMap.Point(112.251635,32.084625),new BMap.Point(112.251025,32.084533),new BMap.Point(112.252138,32.091018)", '已播', 'green');  
        fun(2, "112.244543,32.085696", "new BMap.Point(112.24086,32.087332),new BMap.Point(112.244561,32.087669),new BMap.Point(112.248065,32.087791),new BMap.Point(112.248658,32.087883),new BMap.Point(112.249125,32.086047),new BMap.Point(112.24952,32.086063),new BMap.Point(112.250023,32.084258),new BMap.Point(112.241435,32.082973),new BMap.Point(112.240609,32.084548)", '未播', 'blue');  
        fun(3, "112.248244,32.088342", "new BMap.Point(112.247737,32.087975),new BMap.Point(112.248442,32.089149),new BMap.Point(112.248536,32.089149),new BMap.Point(112.248572,32.088036)", '未播', 'green');  
      
        //变量名,标签坐标,多边形坐标,文本,边框颜色  
        function fun(i,xy,arr,wb,ys) {  
            //创建经纬度数组  
            eval("var secRingCenter" + i+" = new BMap.Point("+xy+")");  
            eval("var secRing"+i+" = ["+arr+"]");  
            //创建多边形  
            eval("var secRingPolygon" + i + "= new BMap.Polygon(secRing" + i + ", { strokeColor: \"" + ys + "\", strokeWeight: 4})");  
            //eval("var secRingPolygon" + i + "= new BMap.Polygon(secRing" + i + ", { FillColor:\"red\", strokeColor: \"blue\", strokeWeight: 2, strokeOpacity: 0.3 })");  
      
            //添加多边形到地图上  
            map.addOverlay(eval("secRingPolygon"+i));  
      
            var resultArea = BMapLib.GeoUtils.getPolygonArea(eval("secRingPolygon" + i)); //计算多边形的面积(单位米)  
      
            //给多边形添加鼠标事件  
            eval("secRingPolygon"+i).addEventListener("mouseover", function () {//鼠标经过时  
                eval("secRingPolygon" + i).setStrokeColor("red"); //多边形边框为红色  
                //eval("secRingPolygon" + i).setFillColor(ys);   
                map.addOverlay(eval("secRingLabel"+i)); //添加多边形遮照  
                //map.panTo(eval("secRingCenter"+i)); //将地图移动到指定点  
            });  
            eval("secRingPolygon"+i).addEventListener("mouseout", function () {  
                eval("secRingPolygon" + i).setStrokeColor(ys);  
                //eval("secRingPolygon" + i).setFillColor("");   
                map.removeOverlay(eval("secRingLabel"+i));  
            });  
            eval("secRingPolygon"+i).addEventListener("click", function () {  
                map.zoomIn();  
                eval("secRingPolygon" + i).setStrokeColor(ys);  
                //eval("secRingPolygon" + i).setFillColor("");   
                map.setCenter(eval("secRingCenter"+i));  
            });  
            //创建标签  
            eval("var secRingLabel" + i + "= new BMap.Label(\"<b>" + wb + " 面积(㎡):" + Math.floor(resultArea) + "</b>\", { offset: new BMap.Size(0, 0), position: secRingCenter" + i + "})");  
            eval("secRingLabel"+i).setStyle({ "z-index": "999999", "padding": "2px",  "border": "1px solid #ccff00" });  
        }  
    </script>  


GeoUtils.js


    /** 
    * @fileoverview GeoUtils类提供若干几何算法,用来帮助用户判断点与矩形、 
    * 圆形、多边形线、多边形面的关系,并提供计算折线长度和多边形的面积的公式。  
    * 主入口类是<a href="symbols/BMapLib.GeoUtils.html">GeoUtils</a>, 
    * 基于Baidu Map API 1.2。 
    * 
    * @author Baidu Map Api Group  
    * @version 1.2 
    */  
      
    //BMapLib.GeoUtils.degreeToRad(Number)  
    //将度转化为弧度  
      
    //BMapLib.GeoUtils.getDistance(Point, Point)  
    //计算两点之间的距离,两点坐标必须为经纬度  
      
    //BMapLib.GeoUtils.getPolygonArea(polygon)  
    //计算多边形面或点数组构建图形的面积,注意:坐标类型只能是经纬度,且不适合计算自相交多边形的面积(封闭的面积)  
      
    //BMapLib.GeoUtils.getPolylineDistance(polyline)  
    //计算折线或者点数组的长度  
      
    //BMapLib.GeoUtils.isPointInCircle(point, circle)  
    //判断点是否在圆形内  
      
    //BMapLib.GeoUtils.isPointInPolygon(point, polygon)  
    //判断点是否多边形内  
      
    //BMapLib.GeoUtils.isPointInRect(point, bounds)  
    //判断点是否在矩形内  
      
    //BMapLib.GeoUtils.isPointOnPolyline(point, polyline)  
    //判断点是否在折线上  
      
    //BMapLib.GeoUtils.radToDegree(Number)  
    //将弧度转化为度  
      
    /**  
    * @namespace BMap的所有library类均放在BMapLib命名空间下 
    */  
    var BMapLib = window.BMapLib = BMapLib || {};  
    (function () {  
      
        /** 
        * 地球半径 
        */  
        var EARTHRADIUS = 6370996.81;  
      
        /**  
        * @exports GeoUtils as BMapLib.GeoUtils  
        */  
        var GeoUtils =  
        /** 
        * GeoUtils类,静态类,勿需实例化即可使用 
        * @class GeoUtils类的<b>入口</b>。 
        * 该类提供的都是静态方法,勿需实例化即可使用。      
        */  
         BMapLib.GeoUtils = function () {  
         }  
      
        /** 
        * 判断点是否在矩形内 
        * @param {Point} point 点对象 
        * @param {Bounds} bounds 矩形边界对象 
        * @returns {Boolean} 点在矩形内返回true,否则返回false 
        */  
        GeoUtils.isPointInRect = function (point, bounds) {  
            //检查类型是否正确  
            if (!(point instanceof BMap.Point) ||  
                 !(bounds instanceof BMap.Bounds)) {  
                return false;  
            }  
            var sw = bounds.getSouthWest(); //西南脚点  
            var ne = bounds.getNorthEast(); //东北脚点  
            return (point.lng >= sw.lng && point.lng <= ne.lng && point.lat >= sw.lat && point.lat <= ne.lat);  
        }  
      
        /** 
        * 判断点是否在圆形内 
        * @param {Point} point 点对象 
        * @param {Circle} circle 圆形对象 
        * @returns {Boolean} 点在圆形内返回true,否则返回false 
        */  
        GeoUtils.isPointInCircle = function (point, circle) {  
            //检查类型是否正确  
            if (!(point instanceof BMap.Point) ||  
                !(circle instanceof BMap.Circle)) {  
                return false;  
            }  
      
            //point与圆心距离小于圆形半径,则点在圆内,否则在圆外  
            var c = circle.getCenter();  
            var r = circle.getRadius();  
      
            var dis = GeoUtils.getDistance(point, c);  
            if (dis <= r) {  
                return true;  
            } else {  
                return false;  
            }  
        }  
      
        /** 
        * 判断点是否在折线上 
        * @param {Point} point 点对象 
        * @param {Polyline} polyline 折线对象 
        * @returns {Boolean} 点在折线上返回true,否则返回false 
        */  
        GeoUtils.isPointOnPolyline = function (point, polyline) {  
            //检查类型  
            if (!(point instanceof BMap.Point) ||  
                 !(polyline instanceof BMap.Polyline)) {  
                return false;  
            }  
      
            //首先判断点是否在线的外包矩形内,如果在,则进一步判断,否则返回false  
            var lineBounds = polyline.getBounds();  
            if (!this.isPointInRect(point, lineBounds)) {  
                return false;  
            }  
      
            //判断点是否在线段上,设点为Q,线段为P1P2 ,  
            //判断点Q在该线段上的依据是:( Q - P1 ) × ( P2 - P1 ) = 0,且 Q 在以 P1,P2为对角顶点的矩形内  
            var pts = polyline.getPath();  
            for (var i = 0; i < pts.length - 1; i++) {  
                var curPt = pts[i];  
                var nextPt = pts[i + 1];  
                //首先判断point是否在curPt和nextPt之间,即:此判断该点是否在该线段的外包矩形内  
                if (point.lng >= Math.min(curPt.lng, nextPt.lng) && point.lng <= Math.max(curPt.lng, nextPt.lng) &&  
                     point.lat >= Math.min(curPt.lat, nextPt.lat) && point.lat <= Math.max(curPt.lat, nextPt.lat)) {  
                    //判断点是否在直线上公式  
                    var precision = (curPt.lng - point.lng) * (nextPt.lat - point.lat) - (nextPt.lng - point.lng) * (curPt.lat - point.lat);  
                    if (precision < 2e-10 && precision > -2e-10) {//实质判断是否接近0  
                        return true;  
                    }  
                }  
            }  
            return false;  
        }  
      
        /** 
        * 判断点是否多边形内 
        * @param {Point} point 点对象 
        * @param {Polyline} polygon 多边形对象 
        * @returns {Boolean} 点在多边形内返回true,否则返回false 
        */  
        GeoUtils.isPointInPolygon = function (point, polygon) {  
            //检查类型  
            if (!(point instanceof BMap.Point) ||  
                 !(polygon instanceof BMap.Polygon)) {  
                return false;  
            }  
      
            //首先判断点是否在多边形的外包矩形内,如果在,则进一步判断,否则返回false  
            var polygonBounds = polygon.getBounds();  
            if (!this.isPointInRect(point, polygonBounds)) {  
                return false;  
            }  
      
            var pts = polygon.getPath(); //获取多边形点  
      
            //下述代码来源:http://paulbourke.net/geometry/insidepoly/,进行了部分修改  
            //基本思想是利用射线法,计算射线与多边形各边的交点,如果是偶数,则点在多边形外,否则  
            //在多边形内。还会考虑一些特殊情况,如点在多边形顶点上,点在多边形边上等特殊情况。  
      
            var N = pts.length;  
            var boundOrVertex = true; //如果点位于多边形的顶点或边上,也算做点在多边形内,直接返回true  
            var intersectCount = 0; //cross points count of x   
            var precision = 2e-10; //浮点类型计算时候与0比较时候的容差  
            var p1, p2; //neighbour bound vertices  
            var p = point; //测试点  
      
            p1 = pts[0]; //left vertex          
            for (var i = 1; i <= N; ++i) {//check all rays              
                if (p.equals(p1)) {  
                    return boundOrVertex; //p is an vertex  
                }  
      
                p2 = pts[i % N]; //right vertex              
                if (p.lat < Math.min(p1.lat, p2.lat) || p.lat > Math.max(p1.lat, p2.lat)) {//ray is outside of our interests               
                    p1 = p2;  
                    continue; //next ray left point  
                }  
                if (p.lat > Math.min(p1.lat, p2.lat) && p.lat < Math.max(p1.lat, p2.lat)) {//ray is crossing over by the algorithm (common part of)  
                    if (p.lng <= Math.max(p1.lng, p2.lng)) {//x is before of ray                      
                        if (p1.lat == p2.lat && p.lng >= Math.min(p1.lng, p2.lng)) {//overlies on a horizontal ray  
                            return boundOrVertex;  
                        }  
      
                        if (p1.lng == p2.lng) {//ray is vertical           
      
      
                            if (p1.lng == p.lng) {//overlies on a vertical ray  
                                return boundOrVertex;  
                            } else {//before ray  
                                ++intersectCount;  
                            }  
                        } else {//cross point on the left side             
      
      
                            var xinters = (p.lat - p1.lat) * (p2.lng - p1.lng) / (p2.lat - p1.lat) + p1.lng; //cross point of lng                
      
      
                            if (Math.abs(p.lng - xinters) < precision) {//overlies on a ray  
                                return boundOrVertex;  
                            }  
      
                            if (p.lng < xinters) {//before ray  
                                ++intersectCount;  
                            }  
                        }  
                    }  
                } else {//special case when ray is crossing through the vertex                  
                    if (p.lat == p2.lat && p.lng <= p2.lng) {//p crossing over p2                      
                        var p3 = pts[(i + 1) % N]; //next vertex           
      
      
                        if (p.lat >= Math.min(p1.lat, p3.lat) && p.lat <= Math.max(p1.lat, p3.lat)) {//p.lat lies between p1.lat & p3.lat  
                            ++intersectCount;  
                        } else {  
                            intersectCount += 2;  
                        }  
                    }  
                }  
                p1 = p2; //next ray left point  
            }  
      
            if (intersectCount % 2 == 0) {//偶数在多边形外  
                return false;  
            } else { //奇数在多边形内  
                return true;  
            }  
        }  
      
        /** 
        * 将度转化为弧度 
        * @param {degree} Number 度      
        * @returns {Number} 弧度 
        */  
        GeoUtils.degreeToRad = function (degree) {  
            return Math.PI * degree / 180;  
        }  
      
        /** 
        * 将弧度转化为度 
        * @param {radian} Number 弧度      
        * @returns {Number} 度 
        */  
        GeoUtils.radToDegree = function (rad) {  
            return (180 * rad) / Math.PI;  
        }  
      
        /** 
        * 将v值限定在a,b之间,纬度使用 
        */  
        function _getRange(v, a, b) {  
            if (a != null) {  
                v = Math.max(v, a);  
            }  
            if (b != null) {  
                v = Math.min(v, b);  
            }  
            return v;  
        }  
      
        /** 
        * 将v值限定在a,b之间,经度使用 
        */  
        function _getLoop(v, a, b) {  
            while (v > b) {  
                v -= b - a  
            }  
            while (v < a) {  
                v += b - a  
            }  
            return v;  
        }  
      
        /** 
        * 计算两点之间的距离,两点坐标必须为经纬度 
        * @param {point1} Point 点对象 
        * @param {point2} Point 点对象 
        * @returns {Number} 两点之间距离,单位为米 
        */  
        GeoUtils.getDistance = function (point1, point2) {  
            //判断类型  
            if (!(point1 instanceof BMap.Point) ||  
                 !(point2 instanceof BMap.Point)) {  
                return 0;  
            }  
      
            point1.lng = _getLoop(point1.lng, -180, 180);  
            point1.lat = _getRange(point1.lat, -74, 74);  
            point2.lng = _getLoop(point2.lng, -180, 180);  
            point2.lat = _getRange(point2.lat, -74, 74);  
      
            var x1, x2, y1, y2;  
            x1 = GeoUtils.degreeToRad(point1.lng);  
            y1 = GeoUtils.degreeToRad(point1.lat);  
            x2 = GeoUtils.degreeToRad(point2.lng);  
            y2 = GeoUtils.degreeToRad(point2.lat);  
      
            return EARTHRADIUS * Math.acos((Math.sin(y1) * Math.sin(y2) + Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1)));  
        }  
      
        /** 
        * 计算折线或者点数组的长度 
        * @param {Polyline|Array<Point>} polyline 折线对象或者点数组 
        * @returns {Number} 折线或点数组对应的长度 
        */  
        GeoUtils.getPolylineDistance = function (polyline) {  
            //检查类型  
            if (polyline instanceof BMap.Polyline ||  
                 polyline instanceof Array) {  
                //将polyline统一为数组  
                var pts;  
                if (polyline instanceof BMap.Polyline) {  
                    pts = polyline.getPath();  
                } else {  
                    pts = polyline;  
                }  
      
                if (pts.length < 2) {//小于2个点,返回0  
                    return 0;  
                }  
      
                //遍历所有线段将其相加,计算整条线段的长度  
                var totalDis = 0;  
                for (var i = 0; i < pts.length - 1; i++) {  
                    var curPt = pts[i];  
                    var nextPt = pts[i + 1]  
                    var dis = GeoUtils.getDistance(curPt, nextPt);  
                    totalDis += dis;  
                }  
      
                return totalDis;  
      
            } else {  
                return 0;  
            }  
        }  
      
        /** 
        * 计算多边形面或点数组构建图形的面积,注意:坐标类型只能是经纬 
     
        度,且不适合计算自相交多边形的面积 
        * @param {Polygon|Array<Point>} polygon 多边形面对象或者点数 
     
        组 
        * @returns {Number} 多边形面或点数组构成图形的面积 
        */  
        GeoUtils.getPolygonArea = function (polygon) {  
            //检查类型  
            if (!(polygon instanceof BMap.Polygon) &&  
                 !(polygon instanceof Array)) {  
                return 0;  
            }  
            var pts;  
            if (polygon instanceof BMap.Polygon) {  
                pts = polygon.getPath();  
            } else {  
                pts = polygon;  
            }  
      
            if (pts.length < 3) {//小于3个顶点,不能构建面  
                return 0;  
            }  
      
            var totalArea = 0; //初始化总面积  
            var LowX = 0.0;  
            var LowY = 0.0;  
            var MiddleX = 0.0;  
            var MiddleY = 0.0;  
            var HighX = 0.0;  
            var HighY = 0.0;  
            var AM = 0.0;  
            var BM = 0.0;  
            var CM = 0.0;  
            var AL = 0.0;  
            var BL = 0.0;  
            var CL = 0.0;  
            var AH = 0.0;  
            var BH = 0.0;  
            var CH = 0.0;  
            var CoefficientL = 0.0;  
            var CoefficientH = 0.0;  
            var ALtangent = 0.0;  
            var BLtangent = 0.0;  
            var CLtangent = 0.0;  
            var AHtangent = 0.0;  
            var BHtangent = 0.0;  
            var CHtangent = 0.0;  
            var ANormalLine = 0.0;  
            var BNormalLine = 0.0;  
            var CNormalLine = 0.0;  
            var OrientationValue = 0.0;  
            var AngleCos = 0.0;  
            var Sum1 = 0.0;  
            var Sum2 = 0.0;  
            var Count2 = 0;  
            var Count1 = 0;  
            var Sum = 0.0;  
            var Radius = EARTHRADIUS; //6378137.0,WGS84椭球半径   
            var Count = pts.length;  
            for (var i = 0; i < Count; i++) {  
                if (i == 0) {  
                    LowX = pts[Count - 1].lng * Math.PI / 180;  
                    LowY = pts[Count - 1].lat * Math.PI / 180;  
                    MiddleX = pts[0].lng * Math.PI / 180;  
                    MiddleY = pts[0].lat * Math.PI / 180;  
                    HighX = pts[1].lng * Math.PI / 180;  
                    HighY = pts[1].lat * Math.PI / 180;  
                }  
                else if (i == Count - 1) {  
                    LowX = pts[Count - 2].lng * Math.PI / 180;  
                    LowY = pts[Count - 2].lat * Math.PI / 180;  
                    MiddleX = pts[Count - 1].lng * Math.PI / 180;  
                    MiddleY = pts[Count - 1].lat * Math.PI / 180;  
                    HighX = pts[0].lng * Math.PI / 180;  
                    HighY = pts[0].lat * Math.PI / 180;  
                }  
                else {  
                    LowX = pts[i - 1].lng * Math.PI / 180;  
                    LowY = pts[i - 1].lat * Math.PI / 180;  
                    MiddleX = pts[i].lng * Math.PI / 180;  
                    MiddleY = pts[i].lat * Math.PI / 180;  
                    HighX = pts[i + 1].lng * Math.PI / 180;  
                    HighY = pts[i + 1].lat * Math.PI / 180;  
                }  
                AM = Math.cos(MiddleY) * Math.cos(MiddleX);  
                BM = Math.cos(MiddleY) * Math.sin(MiddleX);  
                CM = Math.sin(MiddleY);  
                AL = Math.cos(LowY) * Math.cos(LowX);  
                BL = Math.cos(LowY) * Math.sin(LowX);  
                CL = Math.sin(LowY);  
                AH = Math.cos(HighY) * Math.cos(HighX);  
                BH = Math.cos(HighY) * Math.sin(HighX);  
                CH = Math.sin(HighY);  
                CoefficientL = (AM * AM + BM * BM + CM * CM) / (AM * AL + BM * BL + CM * CL);  
                CoefficientH = (AM * AM + BM * BM + CM * CM) / (AM * AH + BM * BH + CM * CH);  
                ALtangent = CoefficientL * AL - AM;  
                BLtangent = CoefficientL * BL - BM;  
                CLtangent = CoefficientL * CL - CM;  
                AHtangent = CoefficientH * AH - AM;  
                BHtangent = CoefficientH * BH - BM;  
                CHtangent = CoefficientH * CH - CM;  
                AngleCos = (AHtangent * ALtangent + BHtangent * BLtangent + CHtangent * CLtangent) / (Math.sqrt(AHtangent * AHtangent + BHtangent * BHtangent + CHtangent * CHtangent) * Math.sqrt(ALtangent * ALtangent + BLtangent * BLtangent + CLtangent * CLtangent));  
                AngleCos = Math.acos(AngleCos);  
                ANormalLine = BHtangent * CLtangent - CHtangent * BLtangent;  
                BNormalLine = 0 - (AHtangent * CLtangent - CHtangent * ALtangent);  
                CNormalLine = AHtangent * BLtangent - BHtangent * ALtangent;  
                if (AM != 0)  
                    OrientationValue = ANormalLine / AM;  
                else if (BM != 0)  
                    OrientationValue = BNormalLine / BM;  
                else  
                    OrientationValue = CNormalLine / CM;  
                if (OrientationValue > 0) {  
                    Sum1 += AngleCos;  
                    Count1++;  
                }  
                else {  
                    Sum2 += AngleCos;  
                    Count2++;  
                }  
            }  
            var tempSum1, tempSum2;  
            tempSum1 = Sum1 + (2 * Math.PI * Count2 - Sum2);  
            tempSum2 = (2 * Math.PI * Count1 - Sum1) + Sum2;  
            if (Sum1 > Sum2) {  
                if ((tempSum1 - (Count - 2) * Math.PI) < 1)  
                    Sum = tempSum1;  
                else  
                    Sum = tempSum2;  
            }  
            else {  
                if ((tempSum2 - (Count - 2) * Math.PI) < 1)  
                    Sum = tempSum2;  
                else  
                    Sum = tempSum1;  
            }  
            totalArea = (Sum - (Count - 2) * Math.PI) * Radius * Radius;  
            return totalArea; //返回总面积  
        }  
      
    })(); //闭包结束