I recently stated working on gps maps. I have a database with list of lat and longitudes. when a user access my web app, I want to display places with in 1km or specified radius from user point.
I tried using mysql query
SELECT * FROM Locations
WHERE (latitude between MINLATITUDE and MAXLATITUDE )
and (longitude between MINLONGITUDE and MAXLONGITUDE)
but it displays lat and longitudes between min and max, could some one tell me how to show lat and longitudes which are only with in 1km radius from user point.
Thanks.
For distances around 1km, Haversine is overkill. Use the much simpler equirectangular projection to get familiar x and y. Remember, the formula below lat and lon are IN RADIANS. The distance, d, is in km because the radius of the earth (R) is in km. And lat/lon are in radians (yes, I said it again). This eliminates several trig functions compared to Haversine which should make your queries faster.
var R = 6371; // radius of the earth in km
var x = (lon2-lon1) * Math.cos((lat1+lat2)/2);
var y = (lat2-lat1);
var d = Math.sqrt(x*x + y*y) * R; // distance in km
Now, this is a web app so I'm going to assume that Santa (north pole) and the people at the Antarctica station will not use your app. With this assumption, you can organize your lat/lon points in your database on longitude. So, if someone has a lon of -76.1, you know that longitudes in your database that are less than -78 degrees are farther than 1 km. You also know longitudes greater than -74 degrees are far away as well. This will reduce the number of points you need to check in your database.
Related
Basically I am getting answers with only 2 GPS coordinates sometimes with bearing or altitude. But how do I combine all three together to get the distance between two points?
Edit:
All my points are pretty close, i.e. distance lie between few meters to 10 km max. Can I optimize by removing some of the above parameters for such close points?
Some similar questions, although not exact:-
Calculate distance between 2 GPS coordinates: There is an answer taking bearing in consideration, way below.
Taking altitude into account when calculating geodesic distance: Altitude in the calculation
I know there are tons of questions (and answers) on how to get the distance between two CLLocations. But I didn't find one single hint on how to do this the other way round.
Here's the concrete situation: I have one CLLocation, one distance (let's say 200 meters) and one direction. Now I need to know how to calculate the location that is 200 meters away (in a specified direction) from the first location. I don't know what could be the best format for the direction. Maybe the best would be in degrees (north = 0, east = 90, south = 180, west = 270).
In a nutshell, I need a method that could be defined like
-(CLLocation*)locationWithDistance:(int)meters inDirection:(int)degrees fromLocation:(CLLocation*)origin;
Thanks a lot for your help.
For more accurate method use this formula in the link
http://www.movable-type.co.uk/scripts/latlong.html
Please find the section "Destination point given distance and bearing from start point". Apply it in your code
There is C code already written to do exactly that. It is posted on github here. There is a degrees and radians version of the function in UtilitiesGeo.c/.h files. It could have been written with an Objective-C style but I wanted it to be portable to any C based project.
/*-------------------------------------------------------------------------
* Given a starting lat/lon point on earth, distance (in meters)
* and bearing, calculates destination coordinates lat2/lon2.
*
* all params in degrees
*-------------------------------------------------------------------------*/
void destCoordsInDegrees(double lat1, double lon1,
double distanceMeters, double bearing,
double* lat2, double* lon2);
I'm trying to iteratively traverse the United States in 1 mile increments using latitude and longitude coordinates. Essentially, once I start (lets say in Portland, OR), I want to move south in one mile increments until I reach the southernmost boundary of the United States that is of the same latitude as Portland, OR. At this point, I want to start back at the northernmost part and move one mile east, repeating the entire process until I get to the east coast. I need to aggrigate these longitude/latitude points in a database.
My question is: Is it accurate to step through latitude and longitude by calculating the next lat/long pair using a delta of 1 mile each time, or are there simpler and more elegant methods to achieve my end goal?
I suppose you could start with the lat/lon of Portland, OR and the lat/lon of the bottom boundary. Compute the distance using Haversine found here: http://www.movable-type.co.uk/scripts/latlong.html
Using the distance above, loop through each mile using a the section Destination point given distance and bearing from start point from the website above. For moving south, your bearing will 180 deg (use π in the formula as they expect radians). For moving east, your bearing will be 90 deg (π/2).
In my project my users can choose to be put in a random position inside a given, circular area.
I have the latitude and longitude of the center and the radius: how can I calculate the latitude and longitude of a random point inside the given area?
(I use PHP but examples in any language will fit anyway)
You need two randomly generated numbers.
Thinking about this using rectangular (Cartesian) (x,y) coordinates is somewhat unnatural for the problem space. Given a radius, it's somewhat difficult to think about how to directly compute an (Δx,Δy) delta that falls within the circle defined by the center and radius.
Better to use polar coordinates to analyze the problem - in which the dimensions are (r1, Θ). Compute one random distance, bounded by the radius. Compute a random angle, from 0 to 360 degrees. Then convert the (r,Θ) to Cartesian (Δx,Δy), where the Cartesian quantities are simply offsets from your circle center, using the simple trigonometry relations.
Δx = r * cos(Θ)
Δy = r * sin(Θ)
Then your new point is simply
xnew = x + Δx
ynew = y + Δy
This works for small r, in which case the geometry of the earth can be approximated by Euclidean (flat plane) geometry.
As r becomes larger, the curvature of the earth means that the Euclidean approximation does not match the reality of the situation. In that case you will need to use the formulas for geodesic distance, which take into account the 3d curvature of the earth. This begins to make sense, let's say, above distances of 100 km. Of course it depends on the degree of accuracy you need, but I'm assuming you have quite a bit of wiggle room.
In 3d-geometry, you once again need to compute 2 quantities - the angle and the distance. The distance is again bound by your r radius, except in this case the distance is measured on the surface of the earth, and is known as a "great circle distance". Randomly generate a number less than or equal to your r, for the first quantity.
The great-circle geometry relation
d = R Δσ
...states that d, a great-circle distance, is proportional to the radius of the sphere and the central angle subtended by two points on the surface of the sphere. "central angle" refers to an angle described by three points, with the center of the sphere at the vertex, and the other two points on the surface of the sphere.
In your problem, this d must be a random quantity bound by your original 'r'. Calculating a d then gives you the central angle, in other words Δσ , since the R for the earth is known (about 6371.01 km).
That gives you the absolute (random) distance along the great circle, away from your original lat/long. Now you need the direction, quantified by an angle, describing the N/S/E/W direction of travel from your original point. Again, use a 0-360 degree random number, where zero represents due east, if you like.
The change in latitude can be calculated by d sin(Θ) , the change in longitude by d cos(Θ). That gives the great-circle distance in the same dimensions as r (presumably km), but you want lat/long degrees, so you'll need to convert. To get from latitudinal distance to degrees is easy: it's about 111.32 km per degree regardless of latitude. The conversion from longitudinal distance to longitudinal degrees is more complicated, because the longitudinal lines are closer to each other nearer the poles. So you need to use some more complex formulae to compute the change in longitude corresponding to the selected d (great distance) and angle. Remember you may need to hop over the +/- 180° barrier. (The designers of the F22 Raptor warplane forgot this, and their airplanes nearly crashed when attempting to cross the 180th meridian.)
Because of the error that may accumulate in successive approximations, you will want to check that the new point fits your constraints. Use the formula
Δσ = arccos( cos(Δlat) - cos(lat1)*cos(lat2)*(1 - cos(Δlong) ) .
where Δlat is the change in latitude, etc.
This gives you Δσ , the central angle between the new and old lat/long points. Verify that the central angle you've calcuated here is the same as the central angle you randomly selected previously. In other words verify that the computed d (great-circle-distance) between the calculated points is the same as the great circle distance you randomly selected. If the computed d varies from your selected d, you can use numerical approximation to improve the accuracy, altering the latitude or longitude slightly until it meets your criterion.
This can simply be done by calculating a random bearing (between 0 and 2*pi) and a random distance between 0 and your desired maximum radius. Then compute the new (random) lat/lon using the random bearing/range from your given lat/lon center point. See the section 'Destination point given distance and bearing from start point' at this web site: http://www.movable-type.co.uk/scripts/latlong.html
Note: the formula given expects all angles as radians (including lat/lon). The resulting lat/lon with be in radians also so you will need to convert to degrees.
I have a series of lat/lon which represents the center of some object. I need to draw a line through this point that is x meters on either side of the center and it needs to be perpendicular to the heading (imagine a capital T)
Ultimately I want to get the lat/lon of this line's endpoints.
Thanks!
The basic calculation is in this similar question's answer: Calculate second point knowing the starting point and distance. Calculate the points for the two headings perpendicular to the main heading the distance away you want.
Have a look at: Core Location extensions for bearing and distance
With those extensions and two points on the initial line you should be able to get the bearing, add/subtract pi/2 and find points to either side like this:
double bearing = [bottomOfT bearingInRadiansTowardsLocation:topOfT];
CLLocation *left = [topOfT newLocationAtDistance:meters
alongBearingradians:bearing+M_PI/2];
CLLocation *right = [topOfT newLocationAtDistance:meters
alongBearingradians:bearing-M_PI/2];