百度地图API 判断点是否在圆形内详解编程语言

 /** 
   * @fileoverview GeoUtils类提供若干几何算法，用来帮助用户判断点与矩形、 
   * 圆形、多边形线、多边形面的关系,并提供计算折线长度和多边形的面积的公式。  
   * 主入口类是<a href="symbols/BMapLib.GeoUtils.html">GeoUtils</a>， 
   * 基于Baidu Map API 1.2。 
   * 
   * @author Baidu Map Api Group  
   * @version 1.2 
   */ 
 
 /**  
  * @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; //返回总面积 
    } 
 
})();//闭包结束

使用方法：

var point = new BMap.Point(x,y) 
var circle = new BMap.Circle(mPoint,1000,{fillColor:"blue", strokeWeight: 1 ,fillOpacity: 0.3, strokeOpacity: 0.3}); 
 
if(BMapLib.GeoUtils.isPointInCircle(point,circle)){ 
    alert("该point在circle内"); 
}

链接：
GeoUtils.js

作者：
blog.ytso.com