Calculating Lat Lon Spans

I shared this algorithm on the Android Developers Group when I was writing it. It wasn't finished at the time. I had worked through the logic by writing the code one step at a time, checking the results at each step, and then figuring out if those results were within the realm of possibility. Since then I have received numerous emails from other developers asking for my final solution. It turns out that my first solution was almost my final solution. The only thing I have done to the alrorithm since was to shorten it, and get rid of some redundancy. It really didn't make much difference to my program as it is only used when a user makes a new search, and therefore is only called an average of 2 or 3 times a day.

Anyway.... I'll show my original code first, because it walks through the logic. The second implementation is a little faster, but not as easy to follow the logic.

 
 
private class LatLonSpans 
{ 
@SuppressWarnings("unused") 
public double LatSpan = 0.0; 
@SuppressWarnings("unused") 
public double LonSpan = 0.0; 
} 
 
private LatLonSpans getSpans() 
{ 
LatLonSpans latLonSpans = new LatLonSpans(); 
Display display = getWindowManager().getDefaultDisplay(); 
 
int zoomLevel = mapView.getZoomLevel(); 
// zoomToPower times 256 should be equal to the pixels required to view 
// the entire world 
// at the resolution I've set. 
double zoomToPower = Math.pow(2, zoomLevel - 1); 
 
// it takes 256 pixels to view the entire world at resolution 1, so this 
// should be the pixels required to view the entire world 
// at the resolution I've set. 
double entireWorld = zoomToPower * 256; 
// Now I need to scale the zoomToPower to my screen size to figure 
// out what I'm really going to see. 
// 
// this is how many pixels to see 1 degree. 
double OneDegree = entireWorld / 360; 
// and for height we have x pixels minus 40???? to account for top 
// bars..... so we will see this much of a degree. 
double heightSpan = (display.getHeight() - 40) / OneDegree; 
double widthSpan = display.getWidth() / OneDegree; 
 
latLonSpans.LatSpan = heightSpan; 
latLonSpans.LonSpan = widthSpan; 
 
return latLonSpans; 
} 
 

Below is what I am actually using in production. It's really not much faster, but it does allocate less variables.

 
 
private class LatLonSpans 
{ 
@SuppressWarnings("unused") 
public double LatSpan = 0.0; 
@SuppressWarnings("unused") 
public double LonSpan = 0.0; 
} 
 
 
private LatLonSpans getSpansFinal() 
{ 
LatLonSpans latLonSpans = new LatLonSpans(); 
Display display = getWindowManager().getDefaultDisplay(); 
 
// it takes 256 pixels to view the entire world at resolution 1, so this 
// is the pixels required to see one Degree  
// at the resolution the map is set at. 
double OneDegree = Math.pow(2, mapView.getZoomLevel() - 1) / (256 * 360); 
// and for height we have x pixels minus 40???? to account for top 
// bars..... so we will see this much of a degree. 
 
// NOTE - For my display, I am using about 40 pixels for the title bar.  
// - Adjust the 40 for your own display, or if you have the Map View already 
// inflated (I don't when I run this) then just change  
// this "(display.getHeight() - 40)" to MapView Height.  
latLonSpans.LatSpan = (display.getHeight() - 40) / OneDegree; 
latLonSpans.LonSpan = display.getWidth() / OneDegree; 
 
// make sure everything gets GC'd 
display = null; 
 
return latLonSpans; 
} 
 

If you come up with a more efficient formula, please let me know. I'm sure there are other ways to do this, but this has worked very well for me.

Good luck with it.