Tag Archives: openstreetmap

GTALUG OSM Talk last week

Title OpenStreetMap: Building a great map while everyone tells you you’re doing it wrong.


  1. ‘The Map’ — http://www.openstreetmap.org . It supports routing now, too.
  2. QGIS, an open GIS manager. It’s rather good — http://qgis.org/
  3. The OSM Wiki; ridiculously complete documentation: https://wiki.openstreetmap.org/wiki/
  4. OSM Help Stack Exchange-style question/answer: https://help.openstreetmap.org/
  5. All of the OSM stats! — https://wiki.openstreetmap.org/wiki/Stats
  6. Toronto map growth animation — http://www.geofabrik.de/gallery/history/index.html#toronto
  7. Crowdsourced geocoding (+ lawsuit from Canada Post) — http://geocoder.ca/
  8. Open Data Commons Open Database License (ODbL) — http://opendatacommons.org/licenses/odbl/
  9. Canada’s new Open Government portal — http://open.canada.ca related: Toronto Open Data — http://toronto.ca/open
  10. CIPPIC Open Licensing Project (CLIP) — http://clipol.org/
  11. Humanitarian OpenStreetMap Team [HOT] — http://hotosm.org/
  12. OpenCycleMap — http://www.openstreetmap.org/#map=13/43.6666/-79.3785&layers=C
  13. The rather wonderful /uMap/https://umap.openstreetmap.fr/en/

Original GTALUG note: OpenStreetMap links from the other night.

Bitcoin Map spams OpenStreetMap

It looks like the Bitcoin Map website adds points illicitly to OSM through a Google Maps interface. This is rather bad.

Update: they’re fixing this …

Here’s a test run I took to see if the data was really being added to OSM:

Screenshot from 2015-03-04 21:52:38
Bitcoin Map website showing a location near me in Google Maps
Screenshot from 2015-03-04 21:56:34
Adding fake POI info (including massively fake city address, for lulz)
Screenshot from 2015-03-04 21:57:05
Confirmation that Bitcoin Map has accepted my edit
Screenshot from 2015-03-04 21:58:26
Checking the details on the website

Here’s the POI data, in raw OSM XML:

<?xml version="1.0" encoding="UTF-8"?>
<osm version="0.6" generator="CGImap 0.3.3 (28262 thorn-02.openstreetmap.org)" copyright="OpenStreetMap and contributors" attribution="http://www.openstreetmap.org/copyright" license="http://opendatacommons.org/licenses/odbl/1-0/">
 <node id="3383877893" visible="true" version="1" changeset="29257856" timestamp="2015-03-05T02:56:47Z" user="BitcoinMaps" uid="2135320" lat="43.7298277" lon="-79.2721787">
  <tag k="addr:city" v="Bemidji"/>
  <tag k="addr:housenumber" v="134"/>
  <tag k="addr:street" v="Woodfern Drive"/>
  <tag k="contact:email" v="name@example.com"/>
  <tag k="contact:phone" v="+1 416 555 1234"/>
  <tag k="contact:website" v="http://example.com/"/>
  <tag k="description" v="i have totally made this up to see if it will be added to OSM even though the location was derived from Google Maps"/>
  <tag k="name" v="Entirely FictitiousName"/>
  <tag k="payment:litecoin" v="yes"/>
  <tag k="shop" v="books"/>
Screenshot from 2015-03-04 22:24:41
The node is still (temporarily) on the map, despite deleting it. It’ll be gone soon.


Sometimes, you just have to roll your own…

It was Doors Open Toronto last weekend, and the city published the locations as open data: Doors Open Toronto 2013. I thought I’d try to geocode it after Richard suggested we take a look. OpenStreetMap has the Nominatim geocoder, which you can use freely as long as you accept restrictions on bulk queries.

As a good and lazy programmer, I first tried to find pre-built modules. Mistake #1; they weren’t up to snuff:

  • Perl’s Geo::Coder::Many::OSM would only read from OSM‘s server. MapQuest run their own mirror as part of their great MapQuest Open Platform Web Services suite, and they have almost no limitation on query volume. OSM runs their operation on a shoestring, and too many queries gets you the disapproval face, or worse.
  • Python’s geopy gave spurious results amid copious whiny error messages.
    (Standard operational procedure for python, then… ☺)

So I rolled my own, using nowt but the Nominatim Search Service Developer’s Guide, and good old simple modules like URI::Escape, LWP::Simple, and JSON::XS. Much to my surprise, it worked!

Much as I love XML, it’s a bit hard to read as a human, so I smashed the Doors Open data down to simple pipe-separated text: dot.txt. Here’s my code, ever so slightly specialized for searching in Toronto:

#!/usr/bin/perl -w
# geonom.pl - geocode pipe-separated addresses with nominatim
# created by scruss on 02013/05/28

use strict;
use URI::Escape;
use LWP::Simple;
use JSON::XS;

# the URL for OpenMapQuest's Nominatim service
use constant BASEURI =&amp;gt; 'http://open.mapquestapi.com/nominatim/v1/search.php';

# read pipe-separated values from stdin
# two fields: Site Name, Street Address
while (&amp;lt;&amp;gt;) {
    my ( $name, $address ) = split( '\|', $_, 2 );
    my %query_hash = (
        format  =&amp;gt; 'json',
        street  =&amp;gt; cleanaddress($address),    # decruft address a bit
                                              # You'll want to change these ...
        city    =&amp;gt; 'Toronto',                 # fixme
        state   =&amp;gt; 'ON',                      # fixme
        country =&amp;gt; 'Canada',                  # fixme
        addressdetails =&amp;gt; 0,                  # just basic results
        limit          =&amp;gt; 1,                  # only want first result
             # it's considered polite to put your e-mail address in to the query
             # just so the server admins can get in touch with you
        email =&amp;gt; 'me@mydomain.com',    # fixme

        # limit the results to a box (quite a bit) bigger than Toronto
        bounded =&amp;gt; 1,
        viewbox =&amp;gt; '-81.0,45.0,-77.0,41.0'    # left,top,right,bottom - fixme

    # get the result from Nominatim, and decode it to a hashref
    my $json = get( join( '?', BASEURI, escape_hash(%query_hash) ) );
    my $result = decode_json($json);
    if ( scalar(@$result) &amp;gt; 0 ) {             # if there is a result
        print join(
            '|',    # print result as pipe separated values
            $name, $address,
    else {          # no result; just echo input
        print join( '|', $name, $address ), &amp;quot;\n&amp;quot;;

sub escape_hash {

    # turn a hash into escaped string key1=val1&amp;amp;key2=val2...
    my %hash = @_;
    my @pairs;
    for my $key ( keys %hash ) {
        push @pairs, join( &amp;quot;=&amp;quot;, map { uri_escape($_) } $key, $hash{$key} );
    return join( &amp;quot;&amp;amp;&amp;quot;, @pairs );

sub cleanaddress {

    # try to clean up street addresses a bit
    # doesn't understand proper 'Unit-Number' Canadian addresses tho.
    my $_ = shift;
    s/Unit.*//;     # shouldn't affect result
    s/Floor.*//;    # won't affect result
    s/\s+/ /g;      # remove extraneous whitespace
    s/ $//;
    s/^ //;
    return $_;

It quickly became apparent that the addresses had been entered by hand, and weren’t going to geocode neatly. Here are some examples of the bad ones:

  • 200 University Ave St W — it’s an avenue, not a street, and it runs north-south
  • 2087 Davenport Road (Rear House) Rd Unit: Rear — too many rears
  • 21 Colonel Sameul Smith Park Dr — we can’t fix typos
  • 0 Construction Trailer:Lower Simcoe at Lakeshore Blvd — 0? Zero??? What are you, some kinda python programmer?

Curiously, some (like the address for Black Creek Pioneer Village) were right, but just not found. Since the source was open data, I put the right address into OpenStreetMap, so for next year, typos aside, we should be able to find more events.

Now, how accurate were the results? Well, you decide:

Ham Radio log to interactive OpenStreetMap

You might notice that there’s now a Ham Radio QSO Map lurking on the front page. Thanks to the WordPress OpenStreetMap plugin (which I’ve slightly abused before). Here’s a small piece of Perl which will take your ADIF log and convert it to a WP-OSM marker file.

Note that this program assumes you’ve downloaded your log from QRZ.com, as it requires the locator field for both inbound and outbound stations.

#!/usr/bin/perl -w
# adif2osm - convert ADIF log to OSM map file
# scruss.com / VA3PID - 2011/06/19

use strict;
use constant MARKERDIR =>
use constant QRZURL => 'http://qrz.com/db/';
sub maidenhead2latlong;

my ( $temp, @results ) = '';

### Fast forward past header
while (<>) {
  last if m/<eoh>\s+$/i;

### While there are records remaining...
while (<>) {
  $temp .= $_;

  ### Process if end of record tag reached
  if (m/<eor>\s+$/i) {
    my %hash;
    $temp =~ s/\n//g;
    $temp =~ s/<eoh>.*//i;
    $temp =~ s/<eor>.*//i;
    my @arr = split( '<', $temp );
    foreach (@arr) {
      next if (/^$/);
      my ( $key, $val ) = split( '>', $_ );
      $key =~ s/:.*$//;
      $hash{ lc($key) } = $val unless ( $key eq '' );
    push @results, \%hash;
    $temp = '';

# generate OSM plugin file
my @data = ();
my ( $mygrid, $station_callsign ) = '';

# output header
  join( "\t", qw/lat lon title description icon iconSize iconOffset/ ),
foreach (@results) {
  next unless ( exists( $_->{gridsquare} ) && exists( $_->{call} ) );
  $mygrid = $_->{my_gridsquare}
    if ( exists( $_->{my_gridsquare} ) );
  $station_callsign = $_->{station_callsign}
    if ( exists( $_->{station_callsign} ) );

  push @data, $_->{freq} . ' MHz' if ( exists( $_->{freq} ) );
  $data[$#data] .= ' (' . $_->{band} . ')' if ( exists( $_->{band} ) );
  push @data, $_->{mode} if ( exists( $_->{mode} ) );
  push @data, $_->{qso_date} . ' ' . $_->{time_on} . 'Z'
    if ( exists( $_->{qso_date} ) && exists( $_->{time_on} ) );
  my ( $lat, $long ) = maidenhead2latlong( $_->{gridsquare} );
  print join( "\t",
    '<a href="' . QRZURL . $_->{call} . '">' . $_->{call} . '</a>',
    join( ' - ', @data ),
    MARKERDIR . 'wpttemp-green.png',
    '0,-24' ),

  @data = ();

# show home station last, so it's on top
my ( $lat, $long ) = maidenhead2latlong($mygrid);
print join( "\t",
  '<a href="'
    . QRZURL
    . $station_callsign . '">'
    . $station_callsign . '</a>',
  'Home Station',
  MARKERDIR . 'wpttemp-red.png',
  '0,-24' ),


sub maidenhead2latlong {

  # convert a Maidenhead Grid location (eg FN03ir)
  #  to decimal degrees
  # this code could be cleaner/shorter/clearer
  my @locator =
    split( //, uc(shift) );    # convert arg to upper case array
  my $lat      = 0;
  my $long     = 0;
  my $latdiv   = 0;
  my $longdiv  = 0;
  my @divisors = ( 72000, 36000, 7200, 3600, 300, 150 )
    ;                          # long,lat field size in seconds
  my $max = ( $#locator > $#divisors ) ? $#divisors : $#locator;

  for ( my $i = 0 ; $i <= $max ; $i++ ) {
    if ( int( $i / 2 ) % 2 ) {    # numeric
      if ( $i % 2 ) {             # lat
        $latdiv = $divisors[$i];    # save for later
        $lat += $locator[$i] * $latdiv;
      else {                        # long
        $longdiv = $divisors[$i];
        $long += $locator[$i] * $longdiv;
    else {                          # alpha
      my $val = ord( $locator[$i] ) - ord('A');
      if ( $i % 2 ) {               # lat
        $latdiv = $divisors[$i];    # save for later
        $lat += $val * $latdiv;
      else {                        # long
        $longdiv = $divisors[$i];
        $long += $val * $longdiv;
  $lat  += ( $latdiv / 2 );         # location of centre of square
  $long += ( $longdiv / 2 );
  return ( ( $lat / 3600 ) - 90, ( $long / 3600 ) - 180 );

You’ll need to update MARKERDIR to reflect your own WP-OSM installation. Mine might move, so if you don’t change it, and you don’t get markers, please don’t blame me.

The basic code to include a map is like this:

You’ll need to change the marker_file URL, too.

Note that, while this script generates links into the QRZ callsign database, it doesn’t hit that site unless you click a link.

making of the Canada Day post

Making the My Neighbourhood, Canada Day 2010 post took a bit of planning.


I attached an Ultrapod to the stem of my bike, and added another velcro wrap for security. The GPSMAP 60CSx fitted quite nicely under the bungees on the rear rack. The Ultrapod didn’t quite have enough stability to stay in place without drooping sometimes. I bought (but haven’t tried) the KODAK Adventure Mount, which might be more stable.

The Camera

… is a fairly basic Canon PowerShot SD790IS. What’s important is that it can run CHDK. I’d set it to take a 6MP picture approximately every 20s using the Ultra Intervalometer script.

Synching the camera to the GPS for geotagging

At the end of the trip, I took a picture of my GPS clock screen:

and then compared the time to the camera’s timestamp using jhead:

$ jhead IMG_0316.JPG
Date/Time    : 2010:07:01 16:59:50

So if the GPS time is 16:58:55, we need to subtract 55s from the camera time to make them match:

$ jhead -ta-0:00:55 IMG*JPG

And let’s check the result:

$ jhead IMG_0316.JPG
Date/Time    : 2010:07:01 16:58:55


Geotagging the pictures

I used ExifTool. You could also use Prune if you prefer something more graphical. Exiftool does this with minimal fuss:

$ exiftool -geotag canadaday2010-0.gpx IMG_0*JPG

(I realize I could have used exiftool instead of jhead for the timestamp check, but I’ve been using jhead for about a decade, so I know it well and like its compact output.)

You probably want to make use of a WordPress plugin like Add From Server to speed the upload process.

Adding the OpenStreetMap map

The www.Fotomobil.at » wordpress openstreetmap plugin is very flexible, but rather complex to work with. Here I’m calling the map with both markers (and lots of them) and a GPX trace:

[ osm_map lat=&amp;quot;43.729&amp;quot; long=&amp;quot;-79.275&amp;quot; zoom=&amp;quot;14&amp;quot; width=&amp;quot;640&amp;quot; height=&amp;quot;480&amp;quot; marker_file=&amp;quot;http://glaikit.org/wp-content/uploads/2010/07/canadaday2010marker.txt&amp;quot; gpx_file=&amp;quot;http://glaikit.org/wp-content/uploads/2010/07/canadaday2010.gpx&amp;quot; ]

(Note that in the example, in order to stop WordPress from interpreting the shortcode, I’ve had to introduce a space after the [ and before the ]; in real life, they’re not there.)

The gpx file is just plain vanilla (canadaday2010.gpx) but the marker file (canadaday2010marker.txt) is a bit special. I must admit to have slightly misused the format, as I discovered that the fourth column, the description, is free-form HTML. As the default is to popup a small image thumbnail, I wedged in code to link to the full-sized image when the thumbnail was clicked. This required me to work out what attachment ID WordPress thought each picture would be. If you’re careful to upload sequentially to a single-user blog installation, you should be okay hitting the right links.

Each line of the marker file was made with a (loooong) shell one liner, an unholy mess of backticks and awk. I’m glad I can’t find it. It really wasn’t pretty at all.