• 2014-06-24 10:00:35
android计算地图上两点距离的算法

接口：

package com.computedistance;
public interface DistanceComputeInterface {

double getDistance(double lat1, double lng1, double lat2, double lng2);

double getShortDistance(double lat1, double lon1, double lat2, double lon2);

double getLongDistance(double lat1, double lon1, double lat2, double lon2);

double getDistanceBySpeed(double speed, double timeSpace);

double getAccurancyDistance(double lat_a, double lng_a, double lat_b, double lng_b);

}


实现类：

package com.computedistance.impl;
import java.security.InvalidParameterException;
import com.baidu.mapapi.utils.DistanceUtil;
import com.baidu.platform.comapi.basestruct.GeoPoint;
import com.computedistance.DistanceComputeInterface;
public class DistanceComputeImpl implements DistanceComputeInterface{

private final static double DEF_PI = 3.14159265359; // PI
private final static double DEF_2PI= 6.28318530712; // 2*PI
private final static double DEF_PI180= 0.01745329252; // PI/180.0
private final static double DEF_R =6370693.5; // radius of earth
private static DistanceComputeImpl instance = null;

public synchronized static DistanceComputeImpl getInstance(){
if (instance == null) {
instance = new DistanceComputeImpl();
}
return instance;
}

private DistanceComputeImpl(){}

@Override
public double getDistance(double lat1, double lng1, double lat2, double lng2) {
GeoPoint p1LL = new GeoPoint((int) (lat1*1e6), (int) (lng1*1e6));
GeoPoint p2LL = new GeoPoint((int) (lat2*1e6), (int) (lng2*1e6));
double distance = DistanceUtil.getDistance(p1LL, p2LL);
return distance/1000;
}

@Override
public double getShortDistance(double lat1, double lon1, double lat2,double lon2) {
double ew1, ns1, ew2, ns2;
double dx, dy, dew;
double distance;
// 角度转换为弧度
ew1 = lon1 * DEF_PI180;
ns1 = lat1 * DEF_PI180;
ew2 = lon2 * DEF_PI180;
ns2 = lat2 * DEF_PI180;
// 经度差
dew = ew1 - ew2;
// 若跨东经和西经180 度，进行调整
if (dew > DEF_PI)
dew = DEF_2PI - dew;
else if (dew < -DEF_PI)
dew = DEF_2PI + dew;
dx = DEF_R * Math.cos(ns1) * dew; // 东西方向长度(在纬度圈上的投影长度)
dy = DEF_R * (ns1 - ns2); // 南北方向长度(在经度圈上的投影长度)
// 勾股定理求斜边长
distance = Math.sqrt(dx * dx + dy * dy);
return distance/1000;
}

@Override
public double getLongDistance(double lat1, double lon1, double lat2,double lon2) {
double ew1, ns1, ew2, ns2;
double distance;
// 角度转换为弧度
ew1 = lon1 * DEF_PI180;
ns1 = lat1 * DEF_PI180;
ew2 = lon2 * DEF_PI180;
ns2 = lat2 * DEF_PI180;
// 求大圆劣弧与球心所夹的角(弧度)
distance = Math.sin(ns1) * Math.sin(ns2) + Math.cos(ns1) * Math.cos(ns2) * Math.cos(ew1 - ew2);
// 调整到[-1..1]范围内，避免溢出
if (distance > 1.0){
distance = 1.0;
} else if (distance < -1.0){
distance = -1.0;
}
// 求大圆劣弧长度
distance = DEF_R * Math.acos(distance);
return distance/1000;
}

@Override
public double getDistanceBySpeed(double speed, double timeSpace) {
if (speed  < 0 || timeSpace <= 0) {
throw new InvalidParameterException();
}
return speed * timeSpace;
}

@Override
public double getAccurancyDistance(double lat_a, double lng_a,double lat_b, double lng_b) {
double pk = (double) (180 / 3.14169);
double a1 = lat_a / pk;
double a2 = lng_a / pk;
double b1 = lat_b / pk;
double b2 = lng_b / pk;

double t1 = Math.cos(a1) * Math.cos(a2) * Math.cos(b1) * Math.cos(b2);
double t2 = Math.cos(a1) * Math.sin(a2) * Math.cos(b1) * Math.sin(b2);
double t3 = Math.sin(a1) * Math.sin(b1);
double tt = Math.acos(t1 + t2 + t3);
return 6366000 * tt / 1000;
}
}


更多相关内容
• # 计算距离 def getDistance ( latA , lonA , latB , lonB ) : ra = 6378140 # radius of equator: meter rb = 6356755 # radius of polar: meter flatten = ( ra - rb ) / ra # ...
# coding: utf-8

import math

# 参看：http://blog.csdn.net/zengmingen/article/details/68490497

# 大地坐标系资料WGS-84 长半径a=6378137 短半径b=6356752.3142 扁率f=1/298.2572236
# 长半径a=6378137
a = 6378137
# 短半径b=6356752.3142
b = 6356752.3142
# 扁率f=1/298.2572236
f = 1 / 298.257223563

#  角度转弧度
return d * math.pi / 180.0

# 弧度转角度
def deg(x):
return x * 180.0 / math.pi

def computerThatLonLat(lon, lat, brng, dist):
"""
取边界值请注意，程序未验证。实际情况出现请人工验证边界值的情况。

:param lon: 经度, 正东为正方向。取值：[0, 360)
:param lat: 纬度，正北为正方向。取值：[-90, 90]
:param brng: 方位角，和真北方向的夹角，顺时针方向是正方向。取值[0, 360]，正北：0，正东：90，正南：180，正西：270
:param dist: 距离。单位：米
:return: 一个数组：[经度，纬度]
"""

sinAlpha1 = math.sin(alpha1)
cosAlpha1 = math.cos(alpha1)
# print("alpha1:{1}, sinAlpha1:{1}, cosAlpha1:{2}".format(alpha1, sinAlpha1, cosAlpha1))

tanU1 = (1 - f) * math.tan(rad(lat))
cosU1 = 1 / math.sqrt((1 + tanU1 * tanU1))
sinU1 = tanU1 * cosU1
sigma1 = math.atan2(tanU1, cosAlpha1)
sinAlpha = cosU1 * sinAlpha1
cosSqAlpha = 1 - sinAlpha * sinAlpha
uSq = cosSqAlpha * (a * a - b * b) / (b * b)
A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))
B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))
# print("tanU1:{0}, cosU1:{1}, sinU1:{2}, sigma1:{3}, sinAlpha:{4}, cosSqAlpha{5}, uSq:{6}, A:{7}, B:{8}".format(tanU1, cosU1, sinU1, sigma1, sinAlpha, cosSqAlpha, uSq, A, B))

cos2SigmaM = 0
sinSigma = 0
cosSigma = 0
sigma = dist / (b * A)
sigmaP = 2 * math.pi

while math.fabs(sigma - sigmaP) > 1e-12:
cos2SigmaM = math.cos(2 * sigma1 + sigma)
sinSigma = math.sin(sigma)
cosSigma = math.cos(sigma)

deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (
cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (
-3 + 4 * cos2SigmaM * cos2SigmaM)))

sigmaP = sigma
sigma = dist / (b * A) + deltaSigma

tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1
# print("sinU1:{0}, tmp:{1}".format(sinU1, tmp))
lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1,
(1 - f) * math.sqrt(sinAlpha * sinAlpha + tmp * tmp))

lambdas = math.atan2(sinSigma * sinAlpha1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1)
C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha))
L = lambdas - (1 - C) * f * sinAlpha * (
sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)))
revAz = math.atan2(sinAlpha, -tmp)

# print("revAz:{0}.".format(revAz))
# print("lon:{0}, lat:{1}.".format(lon+deg(L), deg(lat2) ))
return [lon + deg(L), deg(lat2)]

"""
lon = 0
lat = 0
brng = 90
dist = 2000000

print(computerThatLonLat(lon, lat, brng, dist))
"""

def getRightUp(lon, lat, dist):
res = computerThatLonLat(lon, lat, 90, dist)
res = computerThatLonLat(res[0], res[1], 0, dist)
return res

def getLeftBottom(lon, lat, dist):
res = computerThatLonLat(lon, lat, 270, dist)
res = computerThatLonLat(res[0], res[1], 180, dist)
return res

def getRectangle(clon, clat, n, m):
ru = getRightUp(clon, clat, 1.0 * n * m / 2.0)
lb = getLeftBottom(clon, clat, 1.0 * n * m / 2.0)
return [lb, ru]

clon = 0
clat = 0
n = 100
m = 100

# print(getRectangle(clon, clat, n, m))

"""
if __name__ == "__main__":
if len(sys.argv) != 5:
print("please input 4 parameter: centerlon centerlat n(一行格子个数) m(单个格子的宽度,单位:米).")
else:
print(getRectangle(float(sys.argv[1]), float(sys.argv[2]), float(sys.argv[3]), float(sys.argv[4])))
"""

# 参考：http://blog.csdn.net/zhuqiuhui/article/details/53180395

# 计算方位角
def getDegree(latA, lonA, latB, lonB):
"""
Args:
point p1(latA, lonA)
point p2(latB, lonB)
Returns:
bearing between the two GPS points,
default: the basis of heading direction is north
"""
brng = deg(math.atan2(y, x))
brng = (brng + 360) % 360
return brng

# print(getDegree(39.997559, 116.537327, 39.944033, 116.474661))

# 计算距离
def getDistance(latA, lonA, latB, lonB):
ra = 6378140  # radius of equator: meter
rb = 6356755  # radius of polar: meter
flatten = (ra - rb) / ra  # Partial rate of the earth

pA = math.atan(rb / ra * math.tan(radLatA))
pB = math.atan(rb / ra * math.tan(radLatB))
x = math.acos(math.sin(pA) * math.sin(pB) + math.cos(pA) * math.cos(pB) * math.cos(radLonA - radLonB))
c1 = (math.sin(x) - x) * (math.sin(pA) + math.sin(pB)) ** 2 / math.cos(x / 2) ** 2
c2 = (math.sin(x) + x) * (math.sin(pA) - math.sin(pB)) ** 2 / math.sin(x / 2) ** 2
dr = flatten / 8 * (c1 - c2)
distance = ra * (x + dr)
return distance

# print(getDistance(-0.0452184737581234, -0.04491576420631404, 0.04521847375812339, 0.044915764206314046))

"""
inputf = open("outputj.txt")

exps = 1e-10

for i in range(0,360):
for j in range(-90,91):
res = computerThatLonLat(i,j,brng, dist)

if math.fabs(res[0] - float(line[0])) > exps or math.fabs(res[1] - float(line[1])) > exps or math.fabs(res[2] - float(line[2])) > exps :
print(i,j)
print(res)
print(line)

if math.fabs(getDegree(j,i, res[2], res[1]) - 63) > 2:
print(i,j)
if math.fabs(getDistance(j,i,res[2],res[1]) - 47 ) > 2:
print("aaaa",i,j)

"""


展开全文
• C# 高德地图百度地图计算两点坐标距离，返回两点之间的距离
• Java地图工具类计算地球上两点之间的距离，工具类系Java程序，输入两个坐标的经纬度，获得距离返回值
• 分享一个php计算地图上两点间的距离的类。需要的朋友可以下载使用参考，如果朋友们有更好的此类可以传来我们php中文网大家一起学习分享。
• 三方库 此库提供计算两点距离的方法 引用此库使用 返回（米） BMapLib.GeoUtils.getDistance（point1 ,point2） 当然如果只想计算距离也可以直接用下面的代码： 注：BMap需要导入，使用如下： BMapLib.
• 主要介绍了PHP计算百度地图两个GPS坐标之间距离的方法,是针对百度地图接口开发的典型应用,需要的朋友可以参考下
• java版百度地图测量两点之间距离，查看使用方法，原文地址：http://blog.csdn.net/u013271384/article/details/77914778
• 一个php计算地图上两点间的距离的类。需要的朋友可以下载使用参考
• AE开发：实现将地图导入，并且点击鼠标即可测量地图上两点距离，适合AE初学者使用
• 最近因为工作的需求，需要计算出高德地图个坐标的距离，通过查找相关资料发现了多种实现的方法，下面这篇文章主要给大家介绍了关于利用java、js或mysql计算高德地图坐标之间距离的相关资料，文中通过示例...
• 输入两地的gps坐标，可以根据gis算法，计算出两地之间的实际距离
• java根据两点的经纬度计算直线距离，以及百度地图、高德地图、谷歌地图不同调用方法
• 百度地图API获取屏幕中心点坐标，计算两点距离定位当前位置，
• 根据经纬度坐标计算实际两点距离C/C++实现。输入： lat1,lng1:第一点纬度、经度 lat2,lng2:第二点纬度、经度 输出： 返回两点距离
• 一篇没来得及说，之所以把百度地图换成腾讯地图，是因为在IOS中，小程序不能正确显示，具体出错如下图（我真是费老大劲找出来的），网上百度了好多，也有出现类似情况的，心痛，在小程序官方也没找到解决方案，若...

上一篇没来得及说，之所以把百度地图换成腾讯地图，是因为在IOS中，小程序不能正确显示，具体出错如下图（我真是费老大劲找出来的），网上百度了好多，也有出现类似情况的，心痛，在小程序官方也没找到解决方案，若有人知道，望周知，定感激不尽。

换成腾讯地图后，出现定位偏差，而且而且，偏差很大，老板在濮阳，竟然显示的是上海，好吧，他过年的时候在上海。没办法，还是换成了H5定位。

具体的H5定位，已经在H5定位+腾讯地图逆地址解析 = 定位到区县这篇中写到了，有指教请移步该篇。

本篇说的是利用腾讯地图计算两点间的距离，是获取用户当前位置并计算一个固定位置。

在这个链接里，可以查看腾讯地图JavaScript API方法 ：https://lbs.qq.com/javascript_v2/demo.html

具体实现逻辑：

//获取当前用户经纬度

//设定已有经纬度

//判断距离

代码如下(接H5定位+腾讯地图逆地址解析 = 定位到区县这个JS写)：

function showPosition(position){
lat=position.coords.latitude;
lng=position.coords.longitude;
qq.maps.convertor.translate(new qq.maps.LatLng(lat,lng), 1, function(res){
//取出经纬度并且赋值
center = res[0];
map = new qq.maps.Map(document.getElementById("container"),{
center:  center,
zoom: 12
});
//逆地址解析
geocoder = new qq.maps.Geocoder({
complete : function(result){
document.getElementById(dwTxt).value(district);
}
});

//计算两点间的距离
var start = new qq.maps.LatLng(lat, lng);
var endA = new qq.maps.LatLng(38, 115);
var endB = new qq.maps.LatLng(34, 118);
var distanceA = Math.round(qq.maps.geometry.spherical.computeDistanceBetween(start, endA)*10)/10;
var distanceB = Math.round(qq.maps.geometry.spherical.computeDistanceBetween(start, endB)*10)/10;
//判断距离是否大于20000m
if(parseInt(distanceA) <= 20000 && parseInt(distanceB) > 20000){
bababbabababablllalallalala
});
}else if(parseInt(distanceB) <= 20000 && parseInt(distanceA) > 20000){
balbalbalabalbalbalbalbalabalabalabalabalba
});
}else{
aaaaaaaaaaaaaaaaaaa
}
});
}

展开全文
• /** * 根据个位置的经纬度，来计算两地的距离（单位为KM） * 参数为String类型 * @param lat1 用户经度 * @param lng1 用户纬度 * @param lat2 商家经度 * @param lng2 商家纬度 * @return */ public static ...
参数是经纬度，
C#版： 千米
private  const  double  EARTH_RADIUS = 6378.137; //地球半径
private  static  double  rad( double  d)
{
    return  d * Math.PI / 180.0;
}

public  static  double  GetDistance( double  lat1, double  lng1, double  lat2, double  lng2)
{
    double  radLat1 = rad(lat1);
    double  radLat2 = rad(lat2);
    double  a = radLat1 - radLat2;
    double  b = rad(lng1) - rad(lng2);

    double  s = 2 * Math.Asin(Math.Sqrt(Math.Pow(Math.Sin(a/2),2) +
     Math.Cos(radLat1)*Math.Cos(radLat2)*Math.Pow(Math.Sin(b/2),2)));
    s = s * EARTH_RADIUS;
    s = Math.Round(s * 10000) / 10000;
    return  s;
}
java2版： 千米)

//private static double EARTH_RADIUS = 6378137.0;(米)
private static double EARTH_RADIUS = 6378.137;
private static double rad(double d) {
return d * Math.PI / 180.0;
}
/**     * 根据两个位置的经纬度，来计算两地的距离（单位为KM）     * 参数为String类型     * @param lat1 用户经度     * @param lng1 用户纬度     * @param lat2 商家经度     * @param lng2 商家纬度     * @return     */
public static String getDistance(String lat1Str, String lng1Str, String lat2Str, String lng2Str) {
Double lat1 = Double.parseDouble(lat1Str);
Double lng1 = Double.parseDouble(lng1Str);
Double lat2 = Double.parseDouble(lat2Str);
Double lng2 = Double.parseDouble(lng2Str);
double distance = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(difference / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2)              * Math.pow(Math.sin(mdifference / 2), 2)));
distance = Math.round(distance * 10000) / 10000;
String distanceStr = distance+"";
distanceStr = distanceStr.substring(0, distanceStr.indexOf("."));
return distanceStr;
}
展开全文
• 这是我最近参赛作品，Android健身应用 ，一等奖作品，Android源码资料，共享一下 ...但愿后来人在此基础，更进一步 ，更希望获取荣誉更胜于我！我相信！我能做到的事情，同样你也能做到，或许还能做得更好！
• 比如A点经纬度（110.0123, 23.32435），B点经纬度（129.1344,25.5465），求AB两点之间的距离。我们可以用haversine()函数求出距离结果。Python版本的haversine()如下所示： from math import radians, cos, sin, ...
• 百度地图测量两点距离（行车距离）测量，使用方法详见https://blog.csdn.net/u013271384/article/details/77914778
• 最近项目要用到定位地图上两个坐标的位置，网上找了一下发现： 在android中可采用如下代码获取距离:  public double getDistance(double lat1, double lon1, double lat2, double lon2) { float[] results=...
• 已知地球任意两点（lng1，lat1），（lng2， lat2）的经纬度坐标，求两点间的距离可以利用 haversine 公式： 首先先将经纬度坐标的角度化成弧度（rlng1，rlat1），（rlng2，rlat2) 利用如下公式： 其中 a ...
• 计算两地图坐标的直线距离计算两地图坐标的直线距离
• 两者相差无几，取整后所得数值一致，所以可以认为这个计算函数就是高德用来计算两点距离的函数。 <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <title></...
• * 计算地图上两点之间的距离 * @param longitude * @param latitude * @param long2 * @param lat2 * @return */ public Double Distance(double longitude, double latitude, double long2, double lat2) ...
• 作者：xxw9485 时间：2017/6/20 参考资料：参考资料1、参考资料2 之前遇到过这样的问题：手里有一批患者的具体居住地点以及对应...球面任意两点距离计算公式可以参考维基百科的下述文章。 Great-circle...
• 正常在使用百度地图时，我们可以通过BMap的实例对象提供的方法计算距离： var map = new BMap.Map('map_canvas'); map.getDistance(point1 ,point2);...三方库 此库提供计算两点距离的方法   ...
• 本文给大家介绍分别使用js和c#种语言实现根据百度地图计算出两地之间的驾驶距离，需要用户指定出发城市和到达城市。对百度地图计算两地距离感兴趣的朋友可以参考下本

...