Question

给定一个坐标（lat，long），我试图计算一个与坐标相距给定距离（例如50km）的方形边界框。所以作为输入我有lat，long和distance，作为输出，我想要两个坐标;一个是西南（左下角），另一个是东北（右上角）。我在这里看到了几个试图用Python解决这个问题的答案，但我特别想找一个Java实现。

为了清楚起见，我打算仅在地球上使用该算法，因此我不需要容纳可变半径。

它不一定非常准确（+/- 20％很好），它只能用于计算小距离（不超过150公里）的边界框。所以我很高兴为一个有效的算法牺牲一些准确性。非常感谢任何帮助。

编辑：我应该更清楚，我真的是在一个正方形之后，而不是一个圆形。我知道正方形的中心和沿着正方形周长的各个点之间的距离不是像圆圈一样的恒定值。我想我的意思是一个正方形，如果你从中心画一条直线到周长上的四个点中的任何一个点，导致一条线垂直于周边的边，那么这四条线的长度相同。 / p>

Answer 1

我写了一篇关于找到边界坐标的文章：

http://JanMatuschek.de/LatitudeLongitudeBoundingCoordinates

本文解释了这些公式，并提供了Java实现。（这也说明了为什么IronMan的最小/最大经度公式是不准确的。）

Answer 2

double R = 6371;  // earth radius in km

double radius = 50; // km

double x1 = lon - Math.toDegrees(radius/R/Math.cos(Math.toRadians(lat)));

double x2 = lon + Math.toDegrees(radius/R/Math.cos(Math.toRadians(lat)));

double y1 = lat + Math.toDegrees(radius/R);

double y2 = lat - Math.toDegrees(radius/R);

虽然我也推荐JTS。

Answer 3

import com.vividsolutions.jts.geom.Envelope;

...
Envelope env = new Envelope(centerPoint.getCoordinate());
env.expandBy(distance_in_degrees); 
...

现在env包含你的信封。它实际上不是一个“正方形”（无论在球体表面上是什么意思），但它应该这样做。

您应该注意，以度为单位的距离取决于中心点的纬度。在赤道，1度纬度约为111公里，但在纽约，它只有约75公里。

非常酷的是，您可以将所有积分投入com.vividsolutions.jts.index.strtree.STRtree，然后使用它快速计算该信封内的点数。

Answer 4

之前的所有答案都只是部分正确。特别是在像澳大利亚这样的地区，他们总是包括极点并计算一个非常大的矩形，甚至10kms。

特别是Jan Philip Matuschek在http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates#UsingIndex的算法包括了一个非常大的矩形（-37，-90，-180,180），几乎在澳大利亚的每一个点。这会影响数据库中的大量用户，并且必须为全国近一半的所有用户计算距离。

我发现罗彻斯特理工学院的 Drupal API地球算法在极点和其他地方都能更好地工作，并且更容易实现。

https://www.rit.edu/drupal/api/drupal/sites%21all%21modules%21location%21earth.inc/7.54

使用上述算法中的earth_latitude_range和earth_longitude_range来计算边界矩形

这里的实现是Java

    /**
 * Get bouding rectangle using Drupal Earth Algorithm
 * @see https://www.rit.edu/drupal/api/drupal/sites%21all%21modules%21location%21earth.inc/7.54
 * @param lat
 * @param lng
 * @param distance
 * @return
 */
default BoundingRectangle getBoundingRectangleDrupalEarthAlgo(double lat, double lng, int distance) {
    lng = Math.toRadians(lng);
    lat = Math.toRadians(lat);
    double radius = earth_radius(lat);
    List<Double> retLats = earth_latitude_range(lat, radius, distance);
    List<Double> retLngs = earth_longitude_range(lat, lng, radius, distance);
    return new BoundingRectangle(retLats.get(0), retLats.get(1), retLngs.get(0), retLngs.get(1));
}


/**
 * Calculate latitude range based on earths radius at a given point
 * @param latitude
 * @param longitude
 * @param distance
 * @return
 */
default List<Double> earth_latitude_range(double lat, double radius, double distance) {
      // Estimate the min and max latitudes within distance of a given location.

      double angle = distance / radius;
      double minlat = lat - angle;
      double maxlat = lat + angle;
      double rightangle = Math.PI / 2;
      // Wrapped around the south pole.
      if (minlat < -rightangle) {
        double overshoot = -minlat - rightangle;
        minlat = -rightangle + overshoot;
        if (minlat > maxlat) {
          maxlat = minlat;
        }
        minlat = -rightangle;
      }
      // Wrapped around the north pole.
      if (maxlat > rightangle) {
        double overshoot = maxlat - rightangle;
        maxlat = rightangle - overshoot;
        if (maxlat < minlat) {
          minlat = maxlat;
        }
        maxlat = rightangle;
      }
      List<Double> ret = new ArrayList<>();
      ret.add((minlat));
      ret.add((maxlat));
      return ret;
    }

/**
 * Calculate longitude range based on earths radius at a given point
 * @param lat
 * @param lng
 * @param earth_radius
 * @param distance
 * @return
 */
default List<Double> earth_longitude_range(double lat, double lng, double earth_radius, int distance) {
      // Estimate the min and max longitudes within distance of a given location.
      double radius = earth_radius * Math.cos(lat);

      double angle;
      if (radius > 0) {
        angle = Math.abs(distance / radius);
        angle = Math.min(angle, Math.PI);
      }
      else {
        angle = Math.PI;
      }
      double minlong = lng - angle;
      double maxlong = lng + angle;
      if (minlong < -Math.PI) {
        minlong = minlong + Math.PI * 2;
      }
      if (maxlong > Math.PI) {
        maxlong = maxlong - Math.PI * 2;
      }

      List<Double> ret = new ArrayList<>();
      ret.add((minlong));
      ret.add((maxlong));
      return ret;
    }

/**
 * Calculate earth radius at given latitude
 * @param latitude
 * @return
 */
default Double earth_radius(double latitude) {
      // Estimate the Earth's radius at a given latitude.
      // Default to an approximate average radius for the United States.
      double lat = Math.toRadians(latitude);

      double x = Math.cos(lat) / 6378137.0;
      double y = Math.sin(lat) / (6378137.0 * (1 - (1 / 298.257223563)));

      //Make sure earth's radius is in km , not meters
      return (1 / (Math.sqrt(x * x + y * y)))/1000;
    }

并使用谷歌地图记录的距离计算公式来计算距离

https://developers.google.com/maps/solutions/store-locator/clothing-store-locator#outputting-data-as-xml-using-php

要以公里而不是里程搜索，请将3959替换为6371。 对于（Lat，Lng）=（37，-122）和带有列lat和lng 的Markers表，公式为：

SELECT id, ( 3959 * acos( cos( radians(37) ) * cos( radians( lat ) ) * cos( radians( lng ) - radians(-122) ) + sin( radians(37) ) * sin( radians( lat ) ) ) ) AS distance FROM markers HAVING distance < 25 ORDER BY distance LIMIT 0 , 20;

Answer 5

这是一个简单的解决方案，我用它来生成与GeoNames citieJSON API一起使用的边界框坐标，以便从gps十进制坐标获取附近的大城市。

这是我的GitHub存储库中的Java方法：FusionTableModifyJava

我有一个十进制GPS位置，我需要找到最大的城市/州＆＃34;附近＆＃34;那个位置。我需要一个相对准确的边界框来传递到citiesJSON GeoNames webservice以获取该边界框中最大的城市。我通过了位置和＃34;半径＆＃34;我感兴趣的是（以km为单位）它会返回传递给citiesJSON所需的北，南，东，西十进制坐标。

（我发现这些资源对我的研究很有用：

Calculate distance, bearing and more between Latitude/Longitude points.

Longitude - Wikipedia）

它不是超级准确，但足够准确，我正在使用它：

    // Compute bounding Box coordinates for use with Geonames API.
    class BoundingBox
    {
        public double north, south, east, west;
        public BoundingBox(String location, float km)
        {
             //System.out.println(location + " : "+ km);
            String[] parts = location.replaceAll("\\s","").split(","); //remove spaces and split on ,

            double lat = Double.parseDouble(parts[0]);
            double lng = Double.parseDouble(parts[1]);

            double adjust = .008983112; // 1km in degrees at equator.
            //adjust = 0.008983152770714983; // 1km in degrees at equator.

            //System.out.println("deg: "+(1.0/40075.017)*360.0);


            north = lat + ( km * adjust);
            south = lat - ( km * adjust);

            double lngRatio = 1/Math.cos(Math.toRadians(lat)); //ratio for lng size
            //System.out.println("lngRatio: "+lngRatio);

            east = lng + (km * adjust) * lngRatio;
            west = lng - (km * adjust) * lngRatio;
        }

    }

Answer 6

基于IronMan的响应：

[{
"materia": "Desarrollo Energético Sostenible",
data: [
 //array with all the days and times (3 for each 'materia')
]
}]

计算与Java中的纬度/经度坐标相距一定距离的边界框

6 个答案: