As a diehard lover of old maps, I have been especially excited by Map Dorkia’s recent rediscovery of the charm of bygone cartography. I came to GIS via history and archaeology, so my generalized love of maps stems from an earlier, more specific love of old maps. I think this also accounts for the fact that while maps come in many shapes, I am most fond of the ones that depict an actual physical landscape. So I was thrilled a short while ago when Kartograph arrived on the scene (skillfully showcasing a stunning map of Italy), and I was equally happy when MapBox debuted AJ Ashton’s “Pirate Map”.
While both these maps are quite beautiful and therefore just plain nice to look at, they seem to be laboring under the misconception that beauty was the only strong point of old cartography. Because of this, they are missing an important point (in my opinion the most important point) of old maps.
This shortcoming was perfectly illuminated by my wife when she entered my office just after I encountered the aforementioned Kartograph map of Italy.
“What’s that?” she asked.
“A very pretty map,” I answered.
“It is pretty,” my wife agreed. “But there isn’t very much information on it, is there?”
As usual (although don’t tell her I said so) my wife was exactly correct. The map sure is pretty, but it conveys very little information (the same can be said of the “Pirate Map”). As I’ve said before, the whole point of a map is to convey information. Beauty can certainly serve as part of the means toward this end, but we should be careful to remember that it is not the end in and of itself.
Take a look at this map, created in 1733 by Henry Popple (click on the link or the image to see the whole map at the Rumsey Collection):
As easy to read as it is easy to look at, isn’t it? Anyone have any trouble figuring out where the forests are? The mountains? Delightfully easy to tell the difference between large cities and small towns, isn’t it? The only issue I can find with this map of any sort is that it’s a bit overcrowded in the label department. This, however, is simply a shortcoming of the medium, one which we can easily overcome. More on this in a bit.
Modern maps, on the other hand, tend to be much less easy to read. Often, features like forests are depicted with colored blobs, the explanation of which are necessarily supplied in a legend of some sort (clearly, if we’re lucky. If we’re not lucky, we may be wasting our time trying to differentiate between the green blobs that are forests and the blobs of a slightly different shade of green which are parks). While techniques such as this do (technically) suffice, they are rather inelegant. I have long felt (and often remarked) that every entry in a legend represents a failure on the part of the cartographer.
The ideal solution lies in a mixture of modern data and tools coupled with classical cartographic techniques. Why represent a forest as a green blob instead of populating it with trees? The capability certainly exists – it’s easy enough to convert a forest polygon into a teeming mass of randomly placed points. Points which can then be represented graphically as trees.
But then we run into the problem of numbers. A forest measuring in acres (or even square miles) can take a lot of points to fill. This means a boat-load of tiny little pictures of trees that need to be drawn. The problem isn’t so bad if we’re just producing a static map – then it’s just my machine that has to do all the work, and it only has to do it once. But what if we want to serve this up as a web map? Then we’re talking about rendering insane numbers of little trees at both ends of the exchange. A ridiculous expenditure of resources under the best of circumstances.
Until TileMill came along, that is. I’ve talked about TileMill before, and it’s long past time I revisited the subject. When last we discussed it, TileMill only ran in Apple and Linux machines, and it was no small task to get it up and running (and it tended to be a little buggy at that). Now it’s a simple matter of searching the Ubuntu repositories (for Linux) or just downloading an installer (for Windows). I assume it’s equally as simple to set up TileMill for OS X. And today the bugs are few and far between (and tend to be squashed with great alacrity and enthusiasm).
Using TileMill, we can take current data and old cartographic techniques and join them into an accurate, attractive and (above all) easy to read basemap:
Do click on the map and check out the fully functional version. Please be aware that I created this map simply as a proof of concept, so there are a few limitations: 1)
The map is running on a crappy little server on the floor in my office, and it’s being hosted on a stupid little web page my ISP provides free of charge. So please don’t hit it too hard [Update: After posting this last night, I was contacted by Eric from MapBox (thanks, Bill). Eric offered me a sweet deal for MapBox hosting, and by sweet I’m referring to another word with a double ‘ee’ (no – not ‘beer’). While I believe in the abilities of my little server, I am also not stupid. So I happily took Eric up on his offer. The upshot of this is that the map is now being served by MapBox and therefore you should all feel free to kick the crap out of it]. 2) Even though I largely confined the map to geographic features, we’re still talking enormous amounts of data here. Because of this, I restricted the map to 7 levels of zoom and a geographic area that represents roughly the central third of Massachusetts. And we’re still talking an MBTiles file that takes up well over a gigabyte. 3) I am certain there are numerous errors on the map. If I had been making this map for a client rather than as an experiment I would have spent more time seeking them out and removing them. 4) I did not (nor do I now) give a crap about the page surrounding the map. I simply slapped together a fast and dirty container for the map itself, literally in less time than it has taken me to write this sentence. If you have any criticisms regarding it, know that I am completely and blissfully indifferent toward them.
While I am less than completely pleased with the end result, I am quite happy with what the result represents. I don’t feel the techniques I employed are terribly far removed from those employed by Popple and his contemporaries (although I did freely use some colors, I could have achieved much the same effect in greyscale), and in the cases where I diverged I’m sure they would have approved (since I have the luxury of scale and zoom control, my ability to comprehensively label a map without overcrowding it would probably make Popple green with envy). Mostly, I’m pleased by the fact that the map is almost completely self-explanatory. In fact, the only explanations of any kind on the map are the labels, all of which are simply placenames.
All things considered, I think I’ll put this project in the ‘win’ column.
Notes: There are a few changes I would make to the map if I were producing it “for real”. Besides the aforementioned data cleansing, the most important of these would be the labels. For this project, I baked the labels directly into the tiles, simply because I felt the map needed some sort of labels. Ideally, though, the basemap wouldn’t contain any labels at all. Instead, I would apply all labels over the basemap, well after the fact (I’ve heard that CartoDB plans to eventually allow home-brewed MBTiles to serve as basemaps on their platform. I can’t think of a better scenario for serving up my nefarious schemes). And I would most certainly include more labels than are currently present on the map (streets, for example).
The “trees” on the map are placed randomly within the confines of forest polygons. If the polygon data differentiated between deciduous, coniferous and mixed stands, it would be a simple matter for the graphics to represent them accurately.
Nuts And Bolts: The data I used for this map came mostly from MassGIS. I also availed myself of some data from USGS and OpenStreetMap. The data was tweaked and altered and arranged and (in some cases) soundly beaten using Quantum GIS and ArcGIS Desktop. Graphics were produced and/or altered using Photoshop and Inkscape. The font used for the labels is called Essays 1743. TileMill was (of course) used to bake the tiles. TileStream is serving the tiles from my hapless little server (it was a bit of a bear to get TileStream up and running. These instructions by Nathaniel Kelso finally got me where I needed to be). If I were going to serve up maps like this “for real”, I would avail myself of MapBox hosting rather than using my own server. [Update 2: I unforgivably forgot to mention Leaflet, which played a major role in the speed with which I was able to deploy my map on a web page. Since switching the map over to MapBox hosting, Wax has also played a part in the process.]