获取android中两个位置之间的距离？

Question

我需要得到两个位置之间的距离，但我需要像图片中的蓝线那样获得距离。

下一个我尝试：

public double getDistance(LatLng LatLng1, LatLng LatLng2) { 
    double distance = 0; 
    Location locationA = new Location("A"); 
    locationA.setLatitude(LatLng1.latitude); 
    locationA.setLongitude(LatLng1.longitude); 
    Location locationB = new Location("B"); 
    locationB.setLatitude(LatLng2.latitude); 
    locationB.setLongitude(LatLng2.longitude); 
    distance = locationA.distanceTo(locationB); 

    return distance; 
} 

，但我得到的红线距离。

Answer 1

使用Google Maps Directions API。您需要通过HTTP请求方向。您可以直接从Android或通过您自己的服务器执行此操作。从Montreal to Toronto

例如，方向：

GET http://maps.googleapis.com/maps/api/directions/json?origin=Toronto&destination=Montreal&sensor=false 

你会与一些JSON结束。在routes[].legs[].distance，你会得到一个对象是这样的：

 "legs" : [ 
     { 
      "distance" : { 
       "text" : "542 km", 
       "value" : 542389 
      }, 

您也可以直接从响应对象获取折线信息。

Answer 2

试试这个：

private double calculateDistance(double fromLong, double fromLat, 
      double toLong, double toLat) { 
     double d2r = Math.PI/180; 
     double dLong = (toLong - fromLong) * d2r; 
     double dLat = (toLat - fromLat) * d2r; 
     double a = Math.pow(Math.sin(dLat/2.0), 2) + Math.cos(fromLat * d2r) 
       * Math.cos(toLat * d2r) * Math.pow(Math.sin(dLong/2.0), 2); 
     double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); 
     double d = 6367000 * c; 
     return Math.round(d); 
    } 

希望这有助于。

Answer 3

由于克里斯布罗德福特是正确的，解析返回的JSON routes[].legs[].distance

"legs" : [ 
     { 
      "distance" : { 
       "text" : "542 km", 
       "value" : 542389 
      } 

用途：

final JSONObject json = new JSONObject(result); 
    JSONArray routeArray = json.getJSONArray("routes"); 
    JSONObject routes = routeArray.getJSONObject(0); 

    JSONArray newTempARr = routes.getJSONArray("legs"); 
    JSONObject newDisTimeOb = newTempARr.getJSONObject(0); 

    JSONObject distOb = newDisTimeOb.getJSONObject("distance"); 
    JSONObject timeOb = newDisTimeOb.getJSONObject("duration"); 

    Log.i("Diatance :", distOb.getString("text")); 
    Log.i("Time :", timeOb.getString("text")); 

Answer 4

使用：

private String getDistanceOnRoad(double latitude, double longitude, 
      double prelatitute, double prelongitude) { 
     String result_in_kms = ""; 
     String url = "http://maps.google.com/maps/api/directions/xml?origin=" 
       + latitude + "," + longitude + "&destination=" + prelatitute 
       + "," + prelongitude + "&sensor=false&units=metric"; 
     String tag[] = { "text" }; 
     HttpResponse response = null; 
     try { 
      HttpClient httpClient = new DefaultHttpClient(); 
      HttpContext localContext = new BasicHttpContext(); 
      HttpPost httpPost = new HttpPost(url); 
      response = httpClient.execute(httpPost, localContext); 
      InputStream is = response.getEntity().getContent(); 
      DocumentBuilder builder = DocumentBuilderFactory.newInstance() 
        .newDocumentBuilder(); 
      Document doc = builder.parse(is); 
      if (doc != null) { 
       NodeList nl; 
       ArrayList args = new ArrayList(); 
       for (String s : tag) { 
        nl = doc.getElementsByTagName(s); 
        if (nl.getLength() > 0) { 
         Node node = nl.item(nl.getLength() - 1); 
         args.add(node.getTextContent()); 
        } else { 
         args.add(" - "); 
        } 
       } 
       result_in_kms = String.format("%s", args.get(0)); 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return result_in_kms; 
    } 

Answer 5

您可以使用位置类的以下方法中的Android（如果u有经纬度，两个位置的多头）方法返回以米为单位的大致距离。

公共静态无效distanceBetween（双startLatitude，双startLongitude，双endLatitude，双endLongitude，浮法[]结果）

说明：

计算以米为单位的两个位置之间的近似距离，并任选地它们之间最短路径的初始和最终方位。距离和方位使用WGS84椭球定义。

计算出的距离存储在结果[0]中。如果结果长度大于或等于2，则初始方位将存储在结果[1]中。如果结果长度为3或更大，则最终方位将存储在结果[2]中。 参数：

startLatitude - 起点纬度

startLongitude起始经度

endLatitude结束纬度

endLongitude结束经度

结果float数组中举行结果

Answer 6

试试这个代码

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; 
} 

Answer 7

private String getDistance(double lat2, double lon2){ 
    Location loc1 = new Location("A"); 
    loc1.setLatitude("A1"); 
    loc1.setLongitude("B1"); 
    Location loc2 = new Location("B"); 
    loc2.setLatitude(lat2); 
    loc2.setLongitude(lon2); 
    float distanceInMeters = loc1.distanceTo(loc2); 
    float mile = distanceInMeters/1609.34f; 
    String sm = String.format("%.2f", mile); 
    return sm; 
} 

Answer 8

找出2点位置之间的距离：

1. 当你第一次打开应用程序，进入到“时间轴”，从下拉菜单左上角。

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

3. 添加您的地点，并将它们命名为点1，点2或任何易于记忆的名称。

4. 一旦您的地点被添加并标记，请返回到Google应用的主窗口。

5. 点击右下角带有箭头的蓝色圆圈。

6. 将打开一个新窗口，您可以在顶部看到有两个文本字段，您可以在其中添加“从位置”和“距离位置”。

7. 在点按在您保存的位置的任何文本字段，类型3

8. 依次点击文本字段，并添加你的下一个保存的位置。

9. 通过这样做，Google地图将计算两个位置之间的距离，并向您显示地图上的蓝色路径。

Answer 9

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; 
}