Unlike the server-side boundary method, the server-side common point method relies on a known point, one around which you can centralize your data, and retrieves the maximum number of points relative to that known point. This method is useful for location-based appli-cations where you are asking your users to search for things relative to other things, or possibly even relative to themselves. It works for any zoom level and any data set, whether it’s a few hundred points or thousands of points, but larger data sets may require more time to process the relative distance to each point.
For example, suppose you want to create a map of all the FCC towers relative to someone’s position so he can determine which towers are within range of his location. Simply browsing the map using the server-side boundary method won’t be useful because the data is fairly dense and you would need to maintain a very close zoom. What you really want is to find towers rel-ative to the person’s street address or geographic location. You could have him enter an address on your map, and then you could create the central point by geocoding the address using the methods you learned in Chapter 4.
The difficulty with the common point method is calculating the distance between the central point and all the other points. The calculation itself is fairly simple and can be done using kilometers, miles, or nautical miles, as shown in the PHP surfaceDistance()function in Listing 7-3.
Listing 7-3. Surface Distance Calculation Function in PHP
<?php
function surfaceDistance($lat1,$lng1,$lat2,$lng2,$type='km'){
$a1 = deg2rad($lat1); //lat 1 in radians
$a2 = deg2rad($lat2); //lat 2 in radians
$b1 = deg2rad($lng1); //lng 1 in radians
$b2 = deg2rad($lng2); //lng 2 in radians
//earth radius = 6378.8 kilometers or 3963 miles switch(strtolower($type)) {
case 'km': $r = 6378.8; break; //kilometers case 'm': $r = 3963; break; //miles
case 'n': $r = 3443.9; break; //nautical }
return acos(cos($a1)*cos($b1)*cos($a2)*cos($b2) + cos($a1)*sin($b1)*cos($a2)*sin($b2) +
sin($a1)*sin($a2)) * $r;
}
?>
The problem arises when you need to calculate the distance to every point in your data-base. Looping through each point is fine for a relatively small database, but when you are dealing with hundreds of thousands of points, you should first reduce your data set using other meth-ods. For example, you could limit the search to a certain range from the central point and construct a latitude/longitude boundary, as you did with the server-side boundary method in Listing 7-2. This would limit the surface distance calculation to each point in the bound-ary rather than the entire database. You could also look up the city or state when you geocode the address and filter your SQL query to points only in that city or state. Either way, it’s best to provide some level of additional search criteria so you don’t waste resources by calculat-ing distances to points on the other side of the world.
If you choose to use this method, also be aware that user interface problems may arise if you don’t design your interface correctly. The problem may not be obvious at first, but what hap-pens when you slide the map away from the common central point? Using strictly this method means no additional markers are shown outside those closest to the common point. Your users could be dragging the map around looking for the other markers that they know are there, but aren’t shown due to the restrictions of the central point location, as shown in Figure 7-3.
Figure 7-3. A map missing the available data outside the viewable area C H A P T E R 7■ O P T I M I Z I N G A N D S C A L I N G F O R L A R G E D ATA S E T S
156
Some maps we’ve seen use “closest to the center” of the map to filter points. This imposes the same ambiguity, as the map actually contains much more information but it’s simply ignored.
When using the server-side common point method, be sure to indicate to the users that the information on the map is filtered relative to the known point. That way, they are aware they must perform an additional search to retrieve more information.
Listings 7-4 and 7-5 show a working example of the common point method (http://
googlemapsbook.com/chapter7/ServerClosest/). To provide a simpler example, we’ve made the map clickable. The latitude and longitude of the clicked point is sent back to the server as the known point. Then, using the FCC tower database, the map will plot the closest 20 towers to the click. You could easily modify the example to send an address in the request and use a server-side geocoding application to encode the address into latitude and longitude coordi-nates, or you could use the API’s GClientGeocoderobject to geocode an address.
Listing 7-4. Client-Side JavaScript for the Closest to Common Point Method var map;
//pass in an initial point for the center
updateMarkers(new GLatLng(centerLatitude, centerLongitude));
GEvent.addListener(map,'click',function(overlay,point) { //pass in the point for the center
updateMarkers(point);
//create the boundary for the data to provide //initial filtering
var bounds = map.getBounds();
var southWest = bounds.getSouthWest();
var northEast = bounds.getNorthEast();
var getVars = 'ne=' + northEast.toUrlValue() + '&sw=' + southWest.toUrlValue()
+ '&known=' + point.toUrlValue();
//log the URL for testing
//create each point from the list for (i in points) {
Listing 7-5. Server-Side PHP for the Closest to Common Point Method
<?php
//surface distance calculation from Listing 7-3
function surfaceDistance($lat1,$lng1,$lat2,$lng2,$type='km'){
$a1 = deg2rad($lat1); //lat 1 in radians
$a2 = deg2rad($lat2); //lat 2 in radians
$b1 = deg2rad($lng1); //lng 1 in radians
$b2 = deg2rad($lng2); //lng 2 in radians
//earth radius = 6378.8 kilometers or 3963 miles switch(strtolower($type)) {
case 'km': $r = 6378.8; break; //kilometers case 'm': $r = 3963; break; //miles
case 'n': $r = 3443.9; break; //nautical }
C H A P T E R 7■ O P T I M I Z I N G A N D S C A L I N G F O R L A R G E D ATA S E T S 158
return acos(cos($a1)*cos($b1)*cos($a2)*cos($b2) + cos($a1)*sin($b1)*cos($a2)*sin($b2) + sin($a1)*sin($a2)) * $r;
}
//retrieve the variables from the GET vars
list($knownLat,$knownLng) = explode(',',$_GET['known']);
* Retrieve the points within the boundary of the map.
* For the FCC data, all the points are within the US so we
* don't need to worry about the meridian problem.
*/
(longitude > $swlng AND longitude < $nelng) AND (latitude <= $nelat AND latitude >= $swlat) ORDER BY
$list[$i] = "p{$i}:{lat:{$lat},lng:{$lng}}";
$distanceList[$i] = surfaceDistance($lat,$lng,$knownLat,$knownLng,'km');
$row = mysql_fetch_assoc($result);
}
//sort the arrays by distance
array_multisort($distanceList,$list);
//free the distance list unset($distanceList);
//slice the array to the desired number of points //20 in this case
$list = array_slice($list,0,20);
//echo back the JavaScript object header('content-type:text/plain;');
echo "var points = {\n\t".join(",\n\t",$list)."\n}";
?>
You may notice the GETvariables for the request in Listing 7-4 contain the bounds of the viewable area along with the clicked point:
var getVars = 'ne=' + northEast.toUrlValue() + '&sw=' + southWest.toUrlValue()
+ '&known=' + point.toUrlValue();
As mentioned earlier, sending the bounds allows you to filter the points to the viewable area first, reducing the number of distance calculations. In Listing 7-5, the script simply records all the distances into the distanceListarray, and then sorts and slices the array by distance to the known point before returning the request.
The closest to common point method offers the following advantages:
• It works at any zoom level.
• It works for any sized data provided you add additional filtering.
• This method is great for relative location-based searches.
Its disadvantages are as follows:
• Each request must be calculated and can’t be easily cached.
• Not all available data points appear on the map.
• It requires a relative location.
• It may require server resources for larger/dense data sets.
C H A P T E R 7■ O P T I M I Z I N G A N D S C A L I N G F O R L A R G E D ATA S E T S 160