使用 GoogleMapAPI V2查找地图上两点之间的距离

我使用谷歌地图 api v2在我的机器人应用程序，我能够显示地图，并把标记在它上面，但现在我陷入了问题，我需要找出两个标记之间的距离或点放在地图上，我已经通过了文档，但没有找到任何有用的东西在这种情况下。

如果有人知道怎么解决这个问题，请帮帮我。

谢谢

190892 次浏览
小开
最佳答案

您可以使用以下方法来得到准确的结果

public double CalculationByDistance(LatLng StartP, LatLng EndP) {
int Radius = 6371;// radius of earth in Km
double lat1 = StartP.latitude;
double lat2 = EndP.latitude;
double lon1 = StartP.longitude;
double lon2 = EndP.longitude;
double dLat = Math.toRadians(lat2 - lat1);
double dLon = Math.toRadians(lon2 - lon1);
double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+ Math.cos(Math.toRadians(lat1))
* Math.cos(Math.toRadians(lat2)) * Math.sin(dLon / 2)
* Math.sin(dLon / 2);
double c = 2 * Math.asin(Math.sqrt(a));
double valueResult = Radius * c;
double km = valueResult / 1;
DecimalFormat newFormat = new DecimalFormat("####");
int kmInDec = Integer.valueOf(newFormat.format(km));
double meter = valueResult % 1000;
int meterInDec = Integer.valueOf(newFormat.format(meter));
Log.i("Radius Value", "" + valueResult + "   KM  " + kmInDec
+ " Meter   " + meterInDec);


return Radius * c;
}
小开

使用 返回文章页面【半正矢公式】哈弗森公式译者:可以找到两个地理坐标之间的距离。这个公式可以有效地计算球体的距离，在我们的例子中就是地球。

小开

您应该使用 android Location

你可以这样做:

location1.distanceTo(location2);

还有:

float[] results = new float[1];
Location.distanceBetween(latLongA.latitude, latLongA.longitude,
latLongB.latitude, latLongB.longitude,
results);

你会得到位置1和位置2之间以米为单位的距离。 在 LatLongA 蚂蚁 latLongB 之间。

使用 位置。

小开

在 Google Map API V2中，你有 LatLng对象，所以你还不能使用 distanceTo。

然后，考虑到 旧职位和 新职位是 LatLng对象，您可以使用以下代码:

// The computed distance is stored in results[0].
//If results has length 2 or greater, the initial bearing is stored in results[1].
//If results has length 3 or greater, the final bearing is stored in results[2].
float[] results = new float[1];
Location.distanceBetween(oldPosition.latitude, oldPosition.longitude,
newPosition.latitude, newPosition.longitude, results);

有关 Location类的更多 资料信息，请参见 这个链接

小开

用于计算两个地理点之间距离的简单 util 函数:

public static long getDistanceMeters(double lat1, double lng1, double lat2, double lng2) {


double l1 = toRadians(lat1);
double l2 = toRadians(lat2);
double g1 = toRadians(lng1);
double g2 = toRadians(lng2);


double dist = acos(sin(l1) * sin(l2) + cos(l1) * cos(l2) * cos(g1 - g2));
if(dist < 0) {
dist = dist + Math.PI;
}


return Math.round(dist * 6378100);
}
小开

@ Salman Khan 乌斯曼 · 库尔德的建议很完美。我发现唯一可以纠正的是“对于谷歌地图 v2，我们使用 拉丁类。下面是可以用于 GoogleMaps v2的 Usman Kurd 代码。我检查过它是完美的。

public double CalculationByDistance(LatLng StartP, LatLng EndP) {
int Radius=6371;//radius of earth in Km
double lat1 = StartP.latitude;
double lat2 = EndP.latitude;
double lon1 = StartP.longitude;
double lon2 = EndP.longitude;
double dLat = Math.toRadians(lat2-lat1);
double dLon = Math.toRadians(lon2-lon1);
double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
Math.sin(dLon/2) * Math.sin(dLon/2);
double c = 2 * Math.asin(Math.sqrt(a));
double valueResult= Radius*c;
double km=valueResult/1;
DecimalFormat newFormat = new DecimalFormat("####");
int kmInDec =  Integer.valueOf(newFormat.format(km));
double meter=valueResult%1000;
int  meterInDec= Integer.valueOf(newFormat.format(meter));
Log.i("Radius Value",""+valueResult+"   KM  "+kmInDec+" Meter   "+meterInDec);


return Radius * c;
}
小开

试试这个

double distance;
Location locationA = new Location("");
locationA.setLatitude(main_Latitude);
locationA.setLongitude(main_Longitude);
Location locationB = new Location("");
locationB.setLatitude(sub_Latitude);
locationB.setLongitude(sub_Longitude);
distance = locationA.distanceTo(locationB)/1000;
kmeter.setText(String.valueOf(distance));
Toast.makeText(getApplicationContext(), ""+distance, Toast.LENGTH_LONG).show();double distance;
小开

所有这些答案都会给你一条直线上的距离。如果您需要通过公路获得距离，则必须解析 Google 在调用其服务后发送给您的 JSON。你可以使用这个方法:

public String getDistance(final double lat1, final double lon1, final double lat2, final double lon2){
String parsedDistance;
String response;
Thread thread=new Thread(new Runnable() {
@Override
public void run() {
try {


URL url = new URL("http://maps.googleapis.com/maps/api/directions/json?origin=" + lat1 + "," + lon1 + "&destination=" + lat2 + "," + lon2 + "&sensor=false&units=metric&mode=driving");
final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
InputStream in = new BufferedInputStream(conn.getInputStream());
response = org.apache.commons.io.IOUtils.toString(in, "UTF-8");


JSONObject jsonObject = new JSONObject(response);
JSONArray array = jsonObject.getJSONArray("routes");
JSONObject routes = array.getJSONObject(0);
JSONArray legs = routes.getJSONArray("legs");
JSONObject steps = legs.getJSONObject(0);
JSONObject distance = steps.getJSONObject("distance");
parsedDistance=distance.getString("text");


} catch (ProtocolException e) {
e.printStackTrace();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
}
}
});
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
return parsedDistance;
}

Lat1和 lon1是原点坐标，lat2和 lon2是目的地坐标。

小开 
public class GoogleDirection {


public final static String MODE_DRIVING = "driving";
public final static String MODE_WALKING = "walking";
public final static String MODE_BICYCLING = "bicycling";


public final static String STATUS_OK = "OK";
public final static String STATUS_NOT_FOUND = "NOT_FOUND";
public final static String STATUS_ZERO_RESULTS = "ZERO_RESULTS";
public final static String STATUS_MAX_WAYPOINTS_EXCEEDED = "MAX_WAYPOINTS_EXCEEDED";
public final static String STATUS_INVALID_REQUEST = "INVALID_REQUEST";
public final static String STATUS_OVER_QUERY_LIMIT = "OVER_QUERY_LIMIT";
public final static String STATUS_REQUEST_DENIED = "REQUEST_DENIED";
public final static String STATUS_UNKNOWN_ERROR = "UNKNOWN_ERROR";


public final static int SPEED_VERY_FAST = 1;
public final static int SPEED_FAST = 2;
public final static int SPEED_NORMAL = 3;
public final static int SPEED_SLOW = 4;
public final static int SPEED_VERY_SLOW = 5;


private OnDirectionResponseListener mDirectionListener = null;
private OnAnimateListener mAnimateListener = null;


private boolean isLogging = false;


private LatLng animateMarkerPosition = null;
private LatLng beginPosition = null;
private LatLng endPosition = null;
private ArrayList<LatLng> animatePositionList = null;
private Marker animateMarker = null;
private Polyline animateLine = null;
private GoogleMap gm = null;
private int step = -1;
private int animateSpeed = -1;
private int zoom = -1;
private double animateDistance = -1;
private double animateCamera = -1;
private double totalAnimateDistance = 0;
private boolean cameraLock = false;
private boolean drawMarker = false;
private boolean drawLine = false;
private boolean flatMarker = false;
private boolean isCameraTilt = false;
private boolean isCameraZoom = false;
private boolean isAnimated = false;


private Context mContext = null;


public GoogleDirection(Context context) {
mContext = context;
}


public String request(LatLng start, LatLng end, String mode) {
final String url = "http://maps.googleapis.com/maps/api/directions/xml?"
+ "origin=" + start.latitude + "," + start.longitude
+ "&destination=" + end.latitude + "," + end.longitude
+ "&sensor=false&units=metric&mode=" + mode;


if(isLogging)
Log.i("GoogleDirection", "URL : " + url);
new RequestTask().execute(new String[]{ url });
return url;
}


private class RequestTask extends AsyncTask<String, Void, Document> {
protected Document doInBackground(String... url) {
try {
HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpPost httpPost = new HttpPost(url[0]);
HttpResponse response = httpClient.execute(httpPost, localContext);
InputStream in = response.getEntity().getContent();
DocumentBuilder builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
return builder.parse(in);
} catch (IOException e) {
e.printStackTrace();
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
}
return null;
}


protected void onPostExecute(Document doc) {
super.onPostExecute(doc);
if(mDirectionListener != null)
mDirectionListener.onResponse(getStatus(doc), doc, GoogleDirection.this);
}


private String getStatus(Document doc) {
NodeList nl1 = doc.getElementsByTagName("status");
Node node1 = nl1.item(0);
if(isLogging)
Log.i("GoogleDirection", "Status : " + node1.getTextContent());
return node1.getTextContent();
}
}


public void setLogging(boolean state) {
isLogging = state;
}


public String getStatus(Document doc) {
NodeList nl1 = doc.getElementsByTagName("status");
Node node1 = nl1.item(0);
if(isLogging)
Log.i("GoogleDirection", "Status : " + node1.getTextContent());
return node1.getTextContent();
}


public String[] getDurationText(Document doc) {
NodeList nl1 = doc.getElementsByTagName("duration");
String[] arr_str = new String[nl1.getLength() - 1];
for(int i = 0 ; i < nl1.getLength() - 1 ; i++) {
Node node1 = nl1.item(i);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "text"));
arr_str[i] = node2.getTextContent();
if(isLogging)
Log.i("GoogleDirection", "DurationText : " + node2.getTextContent());
}
return arr_str;
}


public int[] getDurationValue(Document doc) {
NodeList nl1 = doc.getElementsByTagName("duration");
int[] arr_int = new int[nl1.getLength() - 1];
for(int i = 0 ; i < nl1.getLength() - 1 ; i++) {
Node node1 = nl1.item(i);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "value"));
arr_int[i] = Integer.parseInt(node2.getTextContent());
if(isLogging)
Log.i("GoogleDirection", "Duration : " + node2.getTextContent());
}
return arr_int;
}


public String getTotalDurationText(Document doc) {
NodeList nl1 = doc.getElementsByTagName("duration");
Node node1 = nl1.item(nl1.getLength() - 1);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "text"));
if(isLogging)
Log.i("GoogleDirection", "TotalDuration : " + node2.getTextContent());
return node2.getTextContent();
}


public int getTotalDurationValue(Document doc) {
NodeList nl1 = doc.getElementsByTagName("duration");
Node node1 = nl1.item(nl1.getLength() - 1);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "value"));
if(isLogging)
Log.i("GoogleDirection", "TotalDuration : " + node2.getTextContent());
return Integer.parseInt(node2.getTextContent());
}


public String[] getDistanceText(Document doc) {
NodeList nl1 = doc.getElementsByTagName("distance");
String[] arr_str = new String[nl1.getLength() - 1];
for(int i = 0 ; i < nl1.getLength() - 1 ; i++) {
Node node1 = nl1.item(i);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "text"));
arr_str[i] = node2.getTextContent();
if(isLogging)
Log.i("GoogleDirection", "DurationText : " + node2.getTextContent());
}
return arr_str;
}


public int[] getDistanceValue(Document doc) {
NodeList nl1 = doc.getElementsByTagName("distance");
int[] arr_int = new int[nl1.getLength() - 1];
for(int i = 0 ; i < nl1.getLength() - 1 ; i++) {
Node node1 = nl1.item(i);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "value"));
arr_int[i] = Integer.parseInt(node2.getTextContent());
if(isLogging)
Log.i("GoogleDirection", "Duration : " + node2.getTextContent());
}
return arr_int;
}


public String getTotalDistanceText(Document doc) {
NodeList nl1 = doc.getElementsByTagName("distance");
Node node1 = nl1.item(nl1.getLength() - 1);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "text"));
if(isLogging)
Log.i("GoogleDirection", "TotalDuration : " + node2.getTextContent());
return node2.getTextContent();
}


public int getTotalDistanceValue(Document doc) {
NodeList nl1 = doc.getElementsByTagName("distance");
Node node1 = nl1.item(nl1.getLength() - 1);
NodeList nl2 = node1.getChildNodes();
Node node2 = nl2.item(getNodeIndex(nl2, "value"));
if(isLogging)
Log.i("GoogleDirection", "TotalDuration : " + node2.getTextContent());
return Integer.parseInt(node2.getTextContent());
}


public String getStartAddress(Document doc) {
NodeList nl1 = doc.getElementsByTagName("start_address");
Node node1 = nl1.item(0);
if(isLogging)
Log.i("GoogleDirection", "StartAddress : " + node1.getTextContent());
return node1.getTextContent();
}


public String getEndAddress(Document doc) {
NodeList nl1 = doc.getElementsByTagName("end_address");
Node node1 = nl1.item(0);
if(isLogging)
Log.i("GoogleDirection", "StartAddress : " + node1.getTextContent());
return node1.getTextContent();
}


public String getCopyRights(Document doc) {
NodeList nl1 = doc.getElementsByTagName("copyrights");
Node node1 = nl1.item(0);
if(isLogging)
Log.i("GoogleDirection", "CopyRights : " + node1.getTextContent());
return node1.getTextContent();
}


public ArrayList<LatLng> getDirection(Document doc) {
NodeList nl1, nl2, nl3;
ArrayList<LatLng> listGeopoints = new ArrayList<LatLng>();
nl1 = doc.getElementsByTagName("step");
if (nl1.getLength() > 0) {
for (int i = 0; i < nl1.getLength(); i++) {
Node node1 = nl1.item(i);
nl2 = node1.getChildNodes();


Node locationNode = nl2.item(getNodeIndex(nl2, "start_location"));
nl3 = locationNode.getChildNodes();
Node latNode = nl3.item(getNodeIndex(nl3, "lat"));
double lat = Double.parseDouble(latNode.getTextContent());
Node lngNode = nl3.item(getNodeIndex(nl3, "lng"));
double lng = Double.parseDouble(lngNode.getTextContent());
listGeopoints.add(new LatLng(lat, lng));


locationNode = nl2.item(getNodeIndex(nl2, "polyline"));
nl3 = locationNode.getChildNodes();
latNode = nl3.item(getNodeIndex(nl3, "points"));
ArrayList<LatLng> arr = decodePoly(latNode.getTextContent());
for(int j = 0 ; j < arr.size() ; j++) {
listGeopoints.add(new LatLng(arr.get(j).latitude
, arr.get(j).longitude));
}


locationNode = nl2.item(getNodeIndex(nl2, "end_location"));
nl3 = locationNode.getChildNodes();
latNode = nl3.item(getNodeIndex(nl3, "lat"));
lat = Double.parseDouble(latNode.getTextContent());
lngNode = nl3.item(getNodeIndex(nl3, "lng"));
lng = Double.parseDouble(lngNode.getTextContent());
listGeopoints.add(new LatLng(lat, lng));
}
}


return listGeopoints;
}


public ArrayList<LatLng> getSection(Document doc) {
NodeList nl1, nl2, nl3;
ArrayList<LatLng> listGeopoints = new ArrayList<LatLng>();
nl1 = doc.getElementsByTagName("step");
if (nl1.getLength() > 0) {
for (int i = 0; i < nl1.getLength(); i++) {
Node node1 = nl1.item(i);
nl2 = node1.getChildNodes();


Node locationNode = nl2.item(getNodeIndex(nl2, "end_location"));
nl3 = locationNode.getChildNodes();
Node latNode = nl3.item(getNodeIndex(nl3, "lat"));
double lat = Double.parseDouble(latNode.getTextContent());
Node lngNode = nl3.item(getNodeIndex(nl3, "lng"));
double lng = Double.parseDouble(lngNode.getTextContent());
listGeopoints.add(new LatLng(lat, lng));
}
}


return listGeopoints;
}


public PolylineOptions getPolyline(Document doc, int width, int color) {
ArrayList<LatLng> arr_pos = getDirection(doc);
PolylineOptions rectLine = new PolylineOptions().width(dpToPx(width)).color(color);
for(int i = 0 ; i < arr_pos.size() ; i++)
rectLine.add(arr_pos.get(i));
return rectLine;
}


private int getNodeIndex(NodeList nl, String nodename) {
for(int i = 0 ; i < nl.getLength() ; i++) {
if(nl.item(i).getNodeName().equals(nodename))
return i;
}
return -1;
}


private ArrayList<LatLng> decodePoly(String encoded) {
ArrayList<LatLng> poly = new ArrayList<LatLng>();
int index = 0, len = encoded.length();
int lat = 0, lng = 0;
while (index < len) {
int b, shift = 0, result = 0;
do {
b = encoded.charAt(index++) - 63;
result |= (b & 0x1f) << shift;
shift += 5;
} while (b >= 0x20);
int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lat += dlat;
shift = 0;
result = 0;
do {
b = encoded.charAt(index++) - 63;
result |= (b & 0x1f) << shift;
shift += 5;
} while (b >= 0x20);
int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
lng += dlng;


LatLng position = new LatLng((double)lat / 1E5, (double)lng / 1E5);
poly.add(position);
}
return poly;
}


private int dpToPx(int dp) {
DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();
int px = Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
return px;
}


public void setOnDirectionResponseListener(OnDirectionResponseListener listener) {
mDirectionListener = listener;
}


public void setOnAnimateListener(OnAnimateListener listener) {
mAnimateListener = listener;
}


public interface OnDirectionResponseListener {
public void onResponse(String status, Document doc, GoogleDirection gd);
}


public interface OnAnimateListener {
public void onFinish();
public void onStart();
public void onProgress(int progress, int total);
}


public void animateDirection(GoogleMap gm, ArrayList<LatLng> direction, int speed
, boolean cameraLock, boolean isCameraTilt, boolean isCameraZoom
, boolean drawMarker, MarkerOptions mo, boolean flatMarker
, boolean drawLine, PolylineOptions po) {
if(direction.size() > 1) {
isAnimated = true;
animatePositionList = direction;
animateSpeed = speed;
this.drawMarker = drawMarker;
this.drawLine = drawLine;
this.flatMarker = flatMarker;
this.isCameraTilt = isCameraTilt;
this.isCameraZoom = isCameraZoom;
step = 0;
this.cameraLock = cameraLock;
this.gm = gm;


setCameraUpdateSpeed(speed);


beginPosition = animatePositionList.get(step);
endPosition = animatePositionList.get(step + 1);
animateMarkerPosition = beginPosition;


if(mAnimateListener != null)
mAnimateListener.onProgress(step, animatePositionList.size());


if(cameraLock) {
float bearing = getBearing(beginPosition, endPosition);
CameraPosition.Builder cameraBuilder = new CameraPosition.Builder()
.target(animateMarkerPosition).bearing(bearing);


if(isCameraTilt)
cameraBuilder.tilt(90);
else
cameraBuilder.tilt(gm.getCameraPosition().tilt);


if(isCameraZoom)
cameraBuilder.zoom(zoom);
else
cameraBuilder.zoom(gm.getCameraPosition().zoom);


CameraPosition cameraPosition = cameraBuilder.build();
gm.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));
}


if(drawMarker) {
if(mo != null)
animateMarker = gm.addMarker(mo.position(beginPosition));
else
animateMarker = gm.addMarker(new MarkerOptions().position(beginPosition));


if(flatMarker) {
animateMarker.setFlat(true);


float rotation = getBearing(animateMarkerPosition, endPosition) + 180;
animateMarker.setRotation(rotation);
}
}




if(drawLine) {
if(po != null)
animateLine = gm.addPolyline(po.add(beginPosition)
.add(beginPosition).add(endPosition)
.width(dpToPx((int)po.getWidth())));
else
animateLine = gm.addPolyline(new PolylineOptions()
.width(dpToPx(5)));
}


new Handler().postDelayed(r, speed);
if(mAnimateListener != null)
mAnimateListener.onStart();
}
}


public void cancelAnimated() {
isAnimated = false;
}


public boolean isAnimated() {
return isAnimated;
}


private Runnable r = new Runnable() {
public void run() {


animateMarkerPosition = getNewPosition(animateMarkerPosition, endPosition);


if(drawMarker)
animateMarker.setPosition(animateMarkerPosition);




if(drawLine) {
List<LatLng> points = animateLine.getPoints();
points.add(animateMarkerPosition);
animateLine.setPoints(points);
}


if((animateMarkerPosition.latitude == endPosition.latitude
&& animateMarkerPosition.longitude == endPosition.longitude)) {
if(step == animatePositionList.size() - 2) {
isAnimated = false;
totalAnimateDistance = 0;
if(mAnimateListener != null)
mAnimateListener.onFinish();
} else {
step++;
beginPosition = animatePositionList.get(step);
endPosition = animatePositionList.get(step + 1);
animateMarkerPosition = beginPosition;


if(flatMarker && step + 3 < animatePositionList.size() - 1) {
float rotation = getBearing(animateMarkerPosition, animatePositionList.get(step + 3)) + 180;
animateMarker.setRotation(rotation);
}


if(mAnimateListener != null)
mAnimateListener.onProgress(step, animatePositionList.size());
}
}


if(cameraLock && (totalAnimateDistance > animateCamera || !isAnimated)) {
totalAnimateDistance = 0;
float bearing = getBearing(beginPosition, endPosition);
CameraPosition.Builder cameraBuilder = new CameraPosition.Builder()
.target(animateMarkerPosition).bearing(bearing);


if(isCameraTilt)
cameraBuilder.tilt(90);
else
cameraBuilder.tilt(gm.getCameraPosition().tilt);


if(isCameraZoom)
cameraBuilder.zoom(zoom);
else
cameraBuilder.zoom(gm.getCameraPosition().zoom);


CameraPosition cameraPosition = cameraBuilder.build();
gm.animateCamera(CameraUpdateFactory.newCameraPosition(cameraPosition));


}


if(isAnimated) {
new Handler().postDelayed(r, animateSpeed);
}
}
};


public Marker getAnimateMarker() {
return animateMarker;
}


public Polyline getAnimatePolyline() {
return animateLine;
}


private LatLng getNewPosition(LatLng begin, LatLng end) {
double lat = Math.abs(begin.latitude - end.latitude);
double lng = Math.abs(begin.longitude - end.longitude);


double dis = Math.sqrt(Math.pow(lat, 2) + Math.pow(lng, 2));
if(dis >= animateDistance) {
double angle = -1;


if(begin.latitude <= end.latitude && begin.longitude <= end.longitude)
angle = Math.toDegrees(Math.atan(lng / lat));
else if(begin.latitude > end.latitude && begin.longitude <= end.longitude)
angle = (90 - Math.toDegrees(Math.atan(lng / lat))) + 90;
else if(begin.latitude > end.latitude && begin.longitude > end.longitude)
angle = Math.toDegrees(Math.atan(lng / lat)) + 180;
else if(begin.latitude <= end.latitude && begin.longitude > end.longitude)
angle = (90 - Math.toDegrees(Math.atan(lng / lat))) + 270;


double x = Math.cos(Math.toRadians(angle)) * animateDistance;
double y = Math.sin(Math.toRadians(angle)) * animateDistance;
totalAnimateDistance += animateDistance;
double finalLat = begin.latitude + x;
double finalLng = begin.longitude + y;


return new LatLng(finalLat, finalLng);
} else {
return end;
}
}


private float getBearing(LatLng begin, LatLng end) {
double lat = Math.abs(begin.latitude - end.latitude);
double lng = Math.abs(begin.longitude - end.longitude);
if(begin.latitude < end.latitude && begin.longitude < end.longitude)
return (float)(Math.toDegrees(Math.atan(lng / lat)));
else if(begin.latitude >= end.latitude && begin.longitude < end.longitude)
return (float)((90 - Math.toDegrees(Math.atan(lng / lat))) + 90);
else if(begin.latitude >= end.latitude && begin.longitude >= end.longitude)
return  (float)(Math.toDegrees(Math.atan(lng / lat)) + 180);
else if(begin.latitude < end.latitude && begin.longitude >= end.longitude)
return (float)((90 - Math.toDegrees(Math.atan(lng / lat))) + 270);
return -1;
}


public void setCameraUpdateSpeed(int speed) {
if(speed == SPEED_VERY_SLOW) {
animateDistance = 0.000005;
animateSpeed = 20;
animateCamera = 0.0004;
zoom = 19;
} else if(speed == SPEED_SLOW) {
animateDistance = 0.00001;
animateSpeed = 20;
animateCamera = 0.0008;
zoom = 18;
} else if(speed == SPEED_NORMAL) {
animateDistance = 0.00005;
animateSpeed = 20;
animateCamera = 0.002;
zoom = 16;
} else if(speed == SPEED_FAST) {
animateDistance = 0.0001;
animateSpeed = 20;
animateCamera = 0.004;
zoom = 15;
} else if(speed == SPEED_VERY_FAST) {
animateDistance = 0.0005;
animateSpeed = 20;
animateCamera = 0.004;
zoom = 13;
} else {
animateDistance = 0.00005;
animateSpeed = 20;
animateCamera = 0.002;
zoom = 16;
}
}
}

主要活动

public class MapActivity extends ActionBarActivity {


GoogleMap map = null;
GoogleDirection gd;


LatLng start,end;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_map);


start = new LatLng(13.744246499553903, 100.53428772836924);
end = new LatLng(13.751279688694071, 100.54316081106663);




map = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();
map.animateCamera(CameraUpdateFactory.newLatLngZoom(start, 15));


gd = new GoogleDirection(this);
gd.setOnDirectionResponseListener(new GoogleDirection.OnDirectionResponseListener() {
public void onResponse(String status, Document doc, GoogleDirection gd) {
Toast.makeText(getApplicationContext(), status, Toast.LENGTH_SHORT).show();


gd.animateDirection(map, gd.getDirection(doc), GoogleDirection.SPEED_FAST
, true, true, true, false, null, false, true, new PolylineOptions().width(8).color(Color.RED));


map.addMarker(new MarkerOptions().position(start)
.icon(BitmapDescriptorFactory.fromResource(R.drawable.markera)));


map.addMarker(new MarkerOptions().position(end)
.icon(BitmapDescriptorFactory.fromResource(R.drawable.markerb)));


String TotalDistance = gd.getTotalDistanceText(doc);
String TotalDuration = gd.getTotalDurationText(doc);
}
});


gd.request(start, end, GoogleDirection.MODE_DRIVING);
}
}
小开

为了得到两点之间的距离，试试这个代码。。

public static float GetDistanceFromCurrentPosition(double lat1,double lng1, double lat2, double lng2)
{
double earthRadius = 3958.75;


double dLat = Math.toRadians(lat2 - lat1);


double dLng = Math.toRadians(lng2 - lng1);


double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+ Math.cos(Math.toRadians(lat1))
* Math.cos(Math.toRadians(lat2)) * Math.sin(dLng / 2)
* Math.sin(dLng / 2);


double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));


double dist = earthRadius * c;


int meterConversion = 1609;


return new Float(dist * meterConversion).floatValue();


}
小开

你可以使用这个函数。我已经在我的项目中使用了它。

public String getDistance(LatLng my_latlong, LatLng frnd_latlong) {
Location l1 = new Location("One");
l1.setLatitude(my_latlong.latitude);
l1.setLongitude(my_latlong.longitude);


Location l2 = new Location("Two");
l2.setLatitude(frnd_latlong.latitude);
l2.setLongitude(frnd_latlong.longitude);


float distance = l1.distanceTo(l2);
String dist = distance + " M";


if (distance > 1000.0f) {
distance = distance / 1000.0f;
dist = distance + " KM";
}
return dist;
}
小开

在 android 谷歌地图应用程序有一个非常简单的方法来找到两个位置之间的距离，这样做遵循以下简单的步骤:

  1. 当你第一次打开应用程序去“你的时间线”从下降 菜单在左上角

  2. 一旦新窗口打开，从右上角菜单的设置中选择，然后选择“添加位置”。

  3. 添加您的地方，并命名他们像点1，点2，或任何容易记住的名字。
  4. 一旦你的地方被添加和标记回到主窗口在您的谷歌应用程序。
  5. 点击右下角有箭头的蓝色圆圈。
  6. 一个新的窗口将打开，你可以看到在顶部有两个文本字段，您可以添加您的“从位置”和“距离位置”。
  7. 点击任何文本字段，然后在第3点输入你保存的位置。
  8. 单击其他文本字段并添加下一个保存的位置。
  9. 通过这样做，谷歌地图将计算两个位置之间的距离，并显示在地图上的蓝色路径。.

祝你好运

小开

虽然来得有点晚，但是看到这是 Google 搜索这个话题的最佳结果之一，我将以另一种方式与大家分享:

在 Google工具类 SphericalUtil中使用一行程序

SphericalUtil.computeDistanceBetween(latLngFrom, latLngTo)

你需要 公用事业类别。

您可以简单地使用 gradle 将它们包括在您的项目中:

implementation 'com.google.maps.android:android-maps-utils:0.5+'
小开

这是一个古老的问题，有着古老的答案。我想强调一种计算两点之间距离的更新方法。现在我们应该熟悉了实用程序类“ SphericalUtil”。你可以用它来检索距离。

double distance = SphericalUtil.computeDistanceBetween(origin, dest);
小开

这是简单和完美的代码，持续时间和距离发现

  • 步骤1; (添加这个并在分级中同步)

     implementation 'com.android.volley:volley:1.0.0'

  • 步骤2: (在触发器方法中编写此代码)

     public void clicked(View view) throws JSONException {


JSONObject locationJsonObject = new JSONObject();
locationJsonObject.put("origin", "54.406505,18.67708");
locationJsonObject.put("destination", "54.446251,18.570993");
LatlngCalc(locationJsonObject);
}

  • 第三步: (复制粘贴在您的类)

     private void LatlngCalc(JSONObject locationJsonObject) throws JSONException {


RequestQueue queue = Volley.newRequestQueue(MainActivity.this);
String url = "https://maps.googleapis.com/maps/api/distancematrix/" +
"json?origins=" + locationJsonObject.getString("origin") + "&destinations=" + locationJsonObject.getString("destination") + "&mode=driving&" +
"language=en-EN&sensor=false" + "&key=" + /*Insert Your API Key Here */;


StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {


mTextView.setText("Response is: " + response.substring(0, 500));
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
mTextView.setText("That didn't work!");
}
});
queue.add(stringRequest);
}
小开

使用谷歌指南

Https://maps.googleapis.com/maps/api/directions/json?origin=00.00,00.004&destination=00.00,00.00&key=your_map_key

Parse Api 响应:

JSONArray jsonArrayRoutes = jObject.getJSONArray("routes");
if (jsonArrayRoutes.length() > 0) {
JSONObject jsonObjectRoutes = jsonArrayRoutes.getJSONObject(0);


if (!jObject.isNull("bounds")) {
JSONObject jsonObjectBounds = jObject.getJSONObject("bounds");
if (!jsonObjectBounds.isNull("northeast")) {
JSONObject jsonObjectNorthEast = jsonObjectBounds.getJSONObject("northeast");
LatLng latLngNorthEast = new LatLng(Double.parseDouble(jsonObjectNorthEast.getString("lat")), Double.parseDouble(jsonObjectNorthEast.getString("lng")));
}
if (!jsonObjectBounds.isNull("southwest")) {
JSONObject jsonObjectSouthWest = jsonObjectBounds.getJSONObject("southwest");
LatLng latLngSouthWest = new LatLng(Double.parseDouble(jsonObjectSouthWest.getString("lat")), Double.parseDouble(jsonObjectSouthWest.getString("lng")));
}
}


//Distance & Duration
JSONArray jsonArrayLegs = jsonObjectRoutes.getJSONArray("legs");
if (jsonArrayLegs.length() > 0) {
JSONObject jsonObjectLegs = jsonArrayLegs.getJSONObject(0);


JSONObject jsonObjectDistance = jsonObjectLegs.getJSONObject("distance");
String distKM = jsonObjectDistance.getString("text");
System.out.println("Distance in KM: " + distKM);
JSONObject jsonObjectDuration = jsonObjectLegs.getJSONObject("duration");
String durTime = jsonObjectDuration.getString("text");
System.out.println("Duration: " + durTime);
}
}

提交答案