百度地图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