Вычисление ограничительной рамки на определенном расстоянии от координаты широты / долготы в Java
Учитывая координаты (широта, длина), я пытаюсь вычислить квадратную ограничительную рамку, которая находится на заданном расстоянии (например, 50 км) от координаты. В качестве входных данных у меня есть широта, длина и расстояние, а в качестве выходных данных я бы хотел две координаты; один - юго-западный (нижний левый) угол, а другой - северо-восточный (верхний правый) угол. Я видел несколько ответов здесь, которые пытаются ответить на этот вопрос в Python, но я ищу реализацию Java в частности.
Просто чтобы прояснить, я намерен использовать алгоритм только на Земле, и поэтому мне не нужно приспосабливать переменный радиус.
Он не должен быть очень точным (+/-20% - хорошо), и он будет использоваться только для расчета ограничивающих рамок на небольших расстояниях (не более 150 км). Поэтому я рад пожертвовать некоторой точностью ради эффективного алгоритма. Буду признателен за любую оказанную помощь.
Изменить: я должен был быть более ясным, я действительно за квадрат, а не круг. Я понимаю, что расстояние между центром квадрата и различными точками по периметру квадрата не является постоянной величиной, как с кругом. Я предполагаю, что я имею в виду квадрат, в котором, если вы проведете линию от центра к любой из четырех точек периметра, которая приведет к линии, перпендикулярной стороне периметра, то эти 4 линии будут иметь одинаковую длину.
7 ответов
Я написал статью о поиске ограничивающих координат:
http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates
Статья объясняет формулы, а также предоставляет реализацию Java. (Это также показывает, почему формула IronMan для минимальной / максимальной долготы является неточной.)
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.
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 а затем использовать его, чтобы быстро рассчитать точки внутри этого конверта.
Все предыдущие ответы верны лишь частично. Особенно в таких регионах, как Австралия, они всегда включают полюс и рассчитывают очень большой прямоугольник даже для 10 км.
В частности, алгоритм Яна Филипа Матушека по адресу http://janmatuschek.de/LatitudeLongitudeBoundingCoordinates включал очень большой прямоугольник из (-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;
}
И используйте формулу расчета расстояния, задокументированную Google Maps для расчета расстояния
https://developers.google.com/maps/solutions/store-locator/clothing-store-locator
Для поиска по километрам вместо миль замените 3959 на 6371.Для (Lat, Lng) = (37, -122) и таблицы маркеров со столбцами lat и lng формула имеет вид:
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;
У меня есть сценарий PHP и пример, который делает это. Учитывая заданную точку, он вычисляет углы прямоугольника вокруг него на определенное расстояние. Это специально для Google Maps, но это может работать для всего остального:
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.
Это вычисляет, но Google Earth не принимает и не отображает 3D-модель.
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package assetmap;
public class Main {
public double degrees;
public double pi= 3.1416;
public static double lon=80.304737;
public static double lat=26.447521;
public static double x1,x2,y1,y2;
public static void main(String[] args) {
double R = 6371; // earth radius in km 26.447521
double radius = 0.300; // km
x1 = (lon - Math.toDegrees(radius / R / Math.cos(Math.toRadians(lat))));
x2 = (lon + Math.toDegrees(radius / R / Math.cos(Math.toRadians(lat))));
y1 = (lat + Math.toDegrees(radius / R));
y2 = (lat - Math.toDegrees(radius / R));
System.out.println(x1+"---|"+x2+"---|"+y1+"|---|"+y2);
}
}
Это печатает
80.30172366789824---|80.30775033210176---|26.450218964817754|---|26.444823035182242
KML:
<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2" xmlns:gx="http://www.google.com/kml/ext/2.2" xmlns:kml="http://www.opengis.net/kml/2.2" xmlns:atom="http://www.w3.org/2005/Atom">
<Placemark>
<name>United Nations Headquarters</name>
<Region>
<LatLonAltBox>
<north>26.447251203518224</north>
<south>26.447790796481772</south>
<east>80.30503833321018</east>
<west>80.30443566678983</west>
<minAltitude>0</minAltitude>
<maxAltitude>30</maxAltitude>
<altitudeMode>absolute</altitudeMode>
</LatLonAltBox>
<Lod>
<minLodPixels>128</minLodPixels>
<maxLodPixels>-1</maxLodPixels>
<minFadeExtent>0</minFadeExtent>
<maxFadeExtent>0</maxFadeExtent>
</Lod>
</Region>
<Model id="model_1">
<altitudeMode>absolute</altitudeMode>
<Location>
<longitude>80.304737</longitude>
<latitude>26.447521</latitude>
<altitude>0.406173708576</altitude>
</Location>
<Orientation>
<heading>0</heading>
<tilt>0</tilt>
<roll>0</roll>
</Orientation>
<Scale>
<x>10</x>
<y>10</y>
<z>10</z>
</Scale>
<Link>
<href>un.dae</href>
</Link>
<ResourceMap>
<Alias>
<targetHref>_01.jpg</targetHref>
<sourceHref>../images/_01.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_02.jpg</targetHref>
<sourceHref>../images/_02.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_04.jpg</targetHref>
<sourceHref>../images/_04.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_05.jpg</targetHref>
<sourceHref>../images/_05.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_06.jpg</targetHref>
<sourceHref>../images/_06.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_07.jpg</targetHref>
<sourceHref>../images/_07.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_08.jpg</targetHref>
<sourceHref>../images/_08.jpg</sourceHref>
</Alias>
<Alias>
<targetHref>_09.jpg</targetHref>
<sourceHref>../images/_09.jpg</sourceHref>
</Alias>
</ResourceMap>
</Model>
</Placemark>
</kml>
На основании ответа IronMan:
/**
* Calculate the lat and len of a square around a point.
* @return latMin, latMax, lngMin, lngMax
*/
public static double[] calculateSquareRadius(double lat, double lng, double radius) {
double R = 6371; // earth radius in km
double latMin = lat - Math.toDegrees(radius/R);
double latMax = lat + Math.toDegrees(radius/R);
double lngMin = lng - Math.toDegrees(radius/R/Math.cos(Math.toRadians(lat)));
double lngMax = lng + Math.toDegrees(radius/R/Math.cos(Math.toRadians(lat)));
return new double[] {latMin, latMax, lngMin, lngMax};
}
Вот простое решение, которое я использовал для генерации координат ограничивающего прямоугольника, который я использую с GeoNames citieJSON API для получения больших городов поблизости от десятичной координаты GPS.
Это метод Java из моего репозитория GitHub: FusionTableModifyJava
У меня было десятичное местоположение GPS, и мне нужно было найти самый большой город / штат "рядом" с этим местоположением. Мне нужно было относительно точную ограничивающую рамку, чтобы перейти на веб-сервис cityJSON GeoNames, чтобы вернуть самый большой город в этой ограничительной рамке. Я передаю местоположение и интересующий меня "радиус" (в км), и он возвращает десятичные координаты севера, юга, востока и запада, необходимые для передачи в города JSON.
(Я нашел эти ресурсы полезными для моих исследований:
Рассчитать расстояние, направление и многое другое между точками широты и долготы.
Это не супер точно, но достаточно точно для того, что я использовал для:
// 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;
}
}