Axis maps blog is sharing an interesting technique for adding another dimension of data to maps by using transparency.  Somewhat like a cartogram, they’ve taken each county in the US and modified it based on population density, but instead of stretching it to a new size, they’ve increased the alpha transparency to make more populated areas brighter and less populated areas faded out.

It looks like a challenge to get the color mapping right, especially in light of data that has a few outliers compared to a large area of uniform low density like population.  Perhaps a logarithmic scale would be more useful for data like this.

Regardless it’s a novel highlighting method, and definitely one to keep in the toolbox in the future.  I could also see this being useful for highlighting in non-map visualizations such as treemaps.

There are a few more examples over at the original post, so check it out!

A Standard 2008 Election Map (Upper), and a Cartogram skewed by Population (Lower)

Cartograms, or visualizations of an area skewed by some variable, are a powerful tool to control for disparities over a large area, especially with respect to politics.

A relatively large but sparsely populated area will dominate a standard projection, whereas a cartogram allows populated areas to be warped to show their true influence (See sidebar).

Applications of Cartograms:

Socio-economic data is the most obvious use case for cartograms, particularly data from the United Nations and National Elections.

The cartogram strategy can be applied to just about any area visualization, and works particularly well where there are major disparities between area size and overall effect.

Algorithms and Tools:

A general outline of the cartogram creation process, as well as some excellent alternatives to the standard ’skewed border’ approach can be found at “Scaling Counties in a Checkerboard State” over at style.org.

Actual implementation of cartograms seems to often follow the algorithm first published here. Desktop versions in Java (with code) are available here and here.  There’s a rundown of more methods at indiemaps.

A Rescaled Election Cartogram. Can You Identify the State?

Another post at style.org looks at alternate skewing methods, namely squarifying the areas in question, and then expanding them by a fixed ratio with respect to the data.

Non-Standard Cartograms:

Some of the most beautiful work in cartograms comes from the SASI group and Dr. Daniel Dorling.

Indiemaps blog has a number of posts on cartograms, including the promise of python source code, and some great visuals.

I think cartograms are an untapped resource for commerical data, especially for geographically disbursed figures like sales or conversion rates. Hopefully in the future we’ll see more tools centered around this resource, as well as a decent online generator.

What you may not know is that the folks at google exposed this geocoding as a regular old URL-based webservice, which means that whatever Nifty mashups your devious little minds can come up with (as long as they fly with google’s TOS) can be powered on the backend without ever loading a google map!

So lets cut the chit-chat and jump to some code… I’m going to use PHP here, but do whatever fuels your nerding.

First, sign up for a key, put in whatever URL you happen to own, it won’t matter (i’ll explain later).

next, add this to your php file, making SURE to replace the key with your own:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?
//Three parts to the querystring: q is address, output is the format, key is the GAPI key
$key = "YOUR KEY HERE";
$address = urlencode("columbia MO");
 
//If you want an extended data set, change the output to "xml" instead of csv
$url = "http://maps.google.com/maps/geo?q=".$address."&output=csv&key=".$key;
//Set up a CURL request, telling it not to spit back headers, and to throw out a user agent.
$ch = curl_init();
 
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER,0); //Change this to a 1 to return headers
curl_setopt($ch, CURLOPT_USERAGENT, $_SERVER["HTTP_USER_AGENT"]);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 
$data = curl_exec($ch);
curl_close($ch);
 
echo "Data: ". $data;
?>

Supposing all goes well you should see the following: (if not check the PHP CURL manual)

Data: 200,4,38.951667,-92.333889

You’ll notice that the first number is the return code, the second the relative accuracy (there 4 we see here is quite low as a result of the broad input. 8 is street-level address accuracy), third the latitude, and fourth the longitude.

So now that we’ve seen the magic.. let’s get it all nicely formatted:

1
2
3
4
5
6
7
8
9
10
11
12

//Check our Response code to ensure success
if (substr($data,0,3) == "200")
{
$data = explode(",",$data);
 
$precision = $data[1];
$latitude = $data[2];
$longitude = $data[3];
 
} else {
echo "Error in geocoding! Http error ".substr($data,0,3);
}

And that’s it! Less than 40 lines of code to give you a powerful resource for mapping and usability. Just how powerful? You’ll have to wait for part two to find out…

*Note on locations and API keys: In my experience thus far, the Geocoding service doesn’t actually check that the api key is being called from the originating server. This may change in the future at some point, so keep your eyes open.
FULL CODE LISTING:

<?
//Set up our variables
$longitude = "";
$latitude = "";
$precision = "";
 
//Three parts to the querystring: q is address, output is the format (
$key = "YOUR KEY HERE";
$address = urlencode("columbia MO");
$url = "http://maps.google.com/maps/geo?q=".$address."&amp;output=csv&amp;key=".$key;
 
$ch = curl_init();
 
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER,0);
curl_setopt($ch, CURLOPT_USERAGENT, $_SERVER["HTTP_USER_AGENT"]);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 
$data = curl_exec($ch);
curl_close($ch);
 
echo "Data: ". $data."&lt;br&gt;";
//Check our Response code to ensure success
if (substr($data,0,3) == "200")
{
$data = explode(",",$data);
 
$precision = $data[1];
$latitude = $data[2];
$longitude = $data[3];
 
echo "Latutide: ".$latitude."&lt;br&gt;";
 
echo "Longitude: ".$longitude."&lt;br&gt;";
 
} else {
echo "Error in geocoding! Http error ".substr($data,0,3);
}
 
?>

Update:

A few people have mentioned that after some number of requests (between 100-300) in quick succession google will kill your access for the day, so you may want to insert a

sleep(1);

To stagger the requests a little.