(written in response to the discussions here and elsewhere, prompted by this blog post, which was in itself presumably prompted by this HN item)

Yesterday was a nice day, so I decided to walk from Derby to Alfreton (roughly here). The criteria were pretty simple:

• No muddy paths
• Only roads with footpaths alongside (sidewalks in OSM terms), or if necessary, grass verges (or very minor roads)
• Somewhere to stop for something decent to drink and a bite to eat.

Ignoring “automatic routing” altogether, what map provider in the UK has that data? OSM does (at least in the area that I’m interested in). Google sort-of does - I’m sticking to roads here, and via their StreetView I can see that e.g. Codnor Denby Lane does have somewhere to safely walk, but it’s not really practical to “virtually walk” an entire route in Google’s StreetView to check it before setting off. HERE has some aerial imagery but not with enough detail. The UK’s Ordnance Survey surely has most of the data, but getting at it is hard (even if you pay them money). The small map on this page can be zoomed in to hint at sidewalk info, but neither the buyable OS Explorer map (which I have a copy of) nor this page which I presume is based on OS OpenData, do. Bing can show basic road info and their own or OS Explorer’s map style, but no “is this walkable” information.

With regard to POI data, Google was (until yesterday) the only one that had the correct name for this pub, and does link through to food and beer details (even CAMRA, usually the go-to guide for this sort of thing, are out of date). However, there’s no differentiation on the map beyond a “place that serves food” icon and a mousover blurb (“family friendly chain pub and restaurant”).

So am I missing something - is there anyone out there with this level of data that’s available in an accessible format, other than OSM?

There’s a discussion over on talk about contributions to OSM’s Standard map style. This diary entry explains what I did in order for a change to fix a problem with bus guideways that was visible in that style. It’s provided here so that hopefully it can help more people that want to (but don’t necessarily know how to) to contribute.

The first thing I did was log an issue for the problem that needed to be fixed. As well as describing the problem that also outlined the fix (actually I referenced some code in a different map style where I’d already fixed the problem). The initial discussion on the issue was helpful in that other people said that yes, they thought that it was a problem too.

However, describing the problem is only part of the way towards actually fixing it. In order to do that, I started by reading the “contributing” guidelines and the links from there.

I already had a github account. I forked OSM Carto into my area to create this. Within there, I created a new branch “guideways_low_zoom” (since deleted) just by typing the name in into the github UI.

I already had a virtual machine running Ubuntu 16.04.3 LTS (server) with all the pre-requisites in place. I’d set it up as per the switch2osm guide, but mainly use it for developing a different map style based on an older version of OSM Carto. Another option is to follow the recommendation in the OSM Carto repository and use Docker.

I then had to “git clone” my forked repository to set it up on that machine, and I then did:

git fetch --all
git checkout --track origin/guideways_low_zoom

to get the correct branch there.

In order to actually get the vanilla copy of OSM Carto working, I had to follow the instructions in the “Shapefile download” section of the switch2osm instructions (essentially running “scripts/get-shapefiles.py”).

… See full entry

I’ve finally got a reasonable rendering of linear barriers working - like the cattle grid in this picture:

That’s here in OSM and you can see a zoomable map here.

The key to getting it working was to ensure that the width of lines used at high zooms mostly matched the real width of the feature on the map (see here for cattle grids), except for gates and stiles which are designed to stand out slightly. Walls and fences are slightly different, allowing you to tell them apart.

It’s been possible to run Linux software on Windows for some time using Microsoft’s “Windows Subsystem for Linux”. Here’s what needs to be done to run a simple tile server there, based on the existing instructions here .

Firstly, install “Bash on Ubuntu on Windows”. There’s are some intructions here (but don’t worry where that says “This won’t work with server software”). Continue down to where it says “You’ll be asked to create a user account and password for use in the Bash environment”. It’s easiest if that user account is the one that you use in the rest of the switch2osm instructions.

Once installed, at a shell prompt “lsb_release -a” should say:

No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 16.04.3 LTS
Release:        16.04
Codename:       xenial

What you get is surprisingly similar to a standard Ubuntu server machine. Some things don’t work (e.g. “screen”), and you’ll have to manually start some of the services that will need, but otherwise things are very familiar.

Run “sudo apt update” and “sudo apt upgrade” to upgrade to the latest version of everything.

Next, go over to the switch2osm instructions and follow those as normal, except for the caveats pointed out below:

If you want to ssh in (you probably will) you’ll need to “sudo service ssh start”.

You’ll likely want to allow access to ports 22 (for ssh) and 80 (for http) and possibly others at the Windows Firewall (inbound rules / new rule / port / tcp port 80 / allow / all / “name”).

After installing postgresql but before doing e.g. “createuser renderaccount” you’ll need to start postgresql manually. “sudo service postgresql status” will say “down”, but after “sudo service postgresql start” it will say “Starting PostgreSQL 9.5 database server” and “service postgresql status” will then say “9.5/main (port 5432): online”.

… See full entry

A previous diary entry explains how I created a basic map legend for a map that I maintain that highlights various things common near me that tend not to get shown very well elsewhere - public footpaths, hiking trails, offices, that sort of thing. It struck me that a lot more things had names than almost any other map (other than OSM Bright) actually shows.

I therefore went through a process of looking to see what tags people used names with (it’s almost everything - here’s a named cattle grid), and what they used as the “naming tag” for various things (mostly “name”, obviously). The result is here:

although to get a better idea of things click here and zoom around.

Why might you want to do this?

You might want to set up a rendering server for a short period of time, or you might want a server that has lots of memory while you’re importing data, but much less afterwards. An “always on” Azure server will probably cost more that a comparable VPS somewhere else, but if you only want it for an hour or two at a time, it may cost considerably less.

This page describes using Microsoft Azure to do this, but of course other cloud providers are available, and depending on what you want to do may be better suited to your needs.

I have no commercial relationship with Microsoft (beyond occasionally buying hardware with Windows preinstalled and then later removing it) and this isn’t a “recommendation”, beyond providing another option to setting up a server yourself.

Sign up to Azure

If you haven’t already got one that you want to use, create a Microsoft account. Jump through whatever validation hoops you have to (for me that was an email address or a phone number, but this may vary depending on where you are).

Next, go to portal.azure.com and sign in. There will probably be a few “free trial” buttons around; click one of them to get a 30-day trial of up to £150 / $200. You’ll need to provide the Microsoft account details (from above), a phone number (again) and a credit card. If you’re in Germany and want to keep your data there see here.

Create a virtual machine

This page is a good starting point. You’ll want to install the Azure CLI because it’s a lot less fiddly than than the alternatives, though there is a “Cloud Shell” option in the portal (actually that’s an account on a remote Ubuntu 16.04.2 LTS VM!) and a “clicky pointy” interface in there too.

First, create a “resource group” to tie everything associated with this machine together, and make it easier to tidy up later. I created this in “uk south”, you can pick somewhere closed to you:

az group create -n MyResourceGroup -l uksouth

… See full entry

There’s recently been a thread on the talk-gb mailing list where someone has decided that, despite previous custom and practice there, the “name” field in both English- and Welsh-speaking areas of Wales should be a compound of both the English and Welsh names. No-one says “I’m climbing up Snowdon / Yr Wyddfa today”, they’ll use one name or the other, not both together.

In the Welsh-speaking areas the Welsh names are more likely to be used; in the English-speaking areas the English names. It’s not a hard-and-fast rule; this peak in the Black Mountains is referred to about equally by both the Welsh and English names, despite it being in a predominantly English-speaking area.

Wikipedia gives an idea of Welsh-language take-up here. That’s a bit broad-brush; for example I don’t think there’s an isogloss between Carmarthenshire and Swansea where people gain/lose the ability to speak Welsh.

So how is it possible to extract data from OSM with the Welsh name in the Welsh-speaking areas and the English name in English-speaking ones, both when creating e.g. a rendering database for the first time and when updating it as people update OSM? Firstly we’ll just consider the “loading the database” part.

There are a couple of possible solutions to the problem. I used “osmosis”, which has a handy “tag transform” feature. The Welsh one is here; the English one is similar.

Very roughly, the Welsh-speaking area of Wales corresponds to this area. That’s not perfect, but it’s not a bad approximation for a rectangle. I downloaded the latest Welsh data from Geofabrik and cut that area out of it:

osmosis  --read-pbf wales-latest.osm.pbf  --bounding-box https://wiki.openstreetmap.org/wiki/Tag:left=-4.82 https://wiki.openstreetmap.org/wiki/Tag:bottom=52.02 https://wiki.openstreetmap.org/wiki/Tag:right=-3.34 https://wiki.openstreetmap.org/wiki/Tag:top=53.69 --write-pbf wales_cy_before.pbf

Convert the “Welsh-speaking” part to names based on “name:cy”:

… See full entry

I’ve updated the switch2osm “Manually building a tile server (16.04.2 LTS)” page to use the latest version of the osm-carto style, now that the issues underlying this problem have been fixed.

This means that it should be possible to follow these instructions to set up a tileserver from scratch that creates tiles in the same style as OpenStreetMap’s “standard” style in just a few hours (for small areas the longest period of the setup is waiting for the shapefiles used by the style to download).

What would be really useful would be if people could test that these notes do actually work for them - is there anything that should be made clearer, especially to someone who might not be familiar with Linux at all?

I’ve created a map legend for the map style that I use. It’s a set of map data that can be appended to a rendering database to create a map legend in a blank bit of map (actually in the middle of Australia).

There are currently two parts - linear features and POIs. As far as the map is concerned these are “real POIs” (though they’re never added to OSM itself of course - just added to the rendering database) so you need to zoom in to see some of the POIs such as the one for vending machines, which only appears in this map style from zoom level 19. You could use it with other map styles, but some of the features are dependent on this lua script.

Here’s a preview of what the “roads” part of the legend looks like:

but to use it properly follow the link and move around.

I’ve written before about the changes needed to render more zoom levels than 18 with a “Switch2Osm-style” tile server.

However, sometimes zoom level 20 isn’t enough. Here:

is part of Nottingham at zoom level 20. At least one of the office names doesn’t appear (it corresponds to here in OSM). The problem is that the way that the “standard” renderd stores metatiles means that only a certain number of tiles can be stored for each zoom level (see this list post for the details). In order to store more I changed renderd slightly so that more zoom levels can be stored - see here and here for the details.

Rendering works fine at higher zoom levels (up to 28 in my example) so that all of those office names now appear. Here’s the same area at zoom level 21:

… See full entry

Although plenty of maps have displayed long distance footpath information for ages, I’d always assumed that it would take a lot of extra processing to get working. Turns out I was wrong:

Because of the way that relations are handled within osm2pgsql, converting route relations into “just another highway type” is pretty straightforward, and once created that new “highway=ldpnwn” can be added to the stylesheet.

In this case the two things to think about are the fill and the text. The “fill” is a short wide purple dot separated by a long gap from the next one. In the code (see the links above) at “line-dasharray” the “1” says “short and the “60” says “separated by a long gap” and further down the “line-width: 4” says “wide”.

… See full entry

On many occasions in the past I’ve said “it’s really easy to create your own Garmin maps” but I don’t think I’ve ever documented the procedure. This is an attempt to do that.

Assumptions:

You’ve got some sort of Garmin device with an SD card in it with some maps that you’ve downloaded from somewhere on it.

You want to replace those with a map you’ve created yourself.

You’ve got a PC with “enough” memory in it. The one I used for the examples below had 4Gb; it’s possible that less may be needed for a small file such as the one used in the examples below.

All the path examples below for for Windows (actually tested on Windows 7), but it should be relatively straightforward to adapt them to work on other operating systems.

What you need to do

The easiest way to create Garmin maps from OSM data is to use “mkgmap”. That’s available from:

http://www.mkgmap.org.uk/

The download page for the latest mkgmap is http://www.mkgmap.org.uk/download/mkgmap.html and the current version is “3676”.

Unzip the zip file and move the folders intact to a known location. In my case I moved it so that “mkgmap.jar” file was in: C:\Utils\mkgmap-r3676

I didn’t use a path with a space in it or a path that Windows recognises as “special” to avoid any possible confusion later.

“Splitter” is a separate program used to split a large OSM data file into portions small enough for mkgmap to work with (the resultant Garmin map can still route between portions).

The latest Splitter is here: http://www.mkgmap.org.uk/download/splitter.html and the current version is “437”.

Unzip the zip file and move the folders intact to a known location. In my case I moved it so that splitter.jar was in: C:\Utils\splitter-r437

Next, we need to download an OSM extract to use to create maps from. As an example I’ll use Romania, and extract for which can be downloaded from here:

http://download.geofabrik.de/europe/romania.html

That page currently says:

… See full entry

A while back I described how I was showing tree types in woodland. The “unfinished business” there was “what about forest areas where the trees have been cleared?”. Mapping of that is a bit hit and miss. “Forestry” has been suggested, but doesn’t have many takers, and “forest” is actually often used for “the entire forestry area” (at least where I’m interested in rendering tiles for - I suspect it varies considerably worldwide). The wiki page and the standard style rendering discussion don’t distinguish, but I thought it was worth trying to separate out “natural=wood” and “landuse=forest” where the latter is used for “the entire forestry area, including where there are currently no trees”.

Here’s the result:

… See full entry

(or if you’re English, “Pavements!”)

I finally got this working for tertiary and secondary roads:

That location corresponds to here in OSM.

There were three bits to it:

1) Determining which roads should have a sidewalk rendered. This is done in lua, and creates e.g. a road type “tertiary_sidewalk” to go with “tertiary” and “tertiary_link”:

https://github.com/SomeoneElseOSM/SomeoneElse-style/blob/sidewalk/style.lua#L230

2) Handle “tertiary_link” the same as “tertiary” in the style’s MML, e.g.:

https://github.com/SomeoneElseOSM/openstreetmap-carto-AJT/blob/sidewalk/project.mml#L403

3) Handle “tertiary_link” the same as “tertiary” in the style’s roads.mss, e.g.:

https://github.com/SomeoneElseOSM/openstreetmap-carto-AJT/blob/sidewalk/roads.mss#L2363

… except where we want to do something different:

https://github.com/SomeoneElseOSM/openstreetmap-carto-AJT/blob/sidewalk/roads.mss#L1114

“sidewalk_width-z13” etc. are declared at the top:

… See full entry

As you may be aware, mapping of areas of trees in OSM is complicated. It’s not possible to tell just by looking at the data which of the four(!) approaches described on that page someone is using “natural=wood” and/or “landuse=forest” to mean. It therefore didn’t make a lot of sense to me to display them differently on a map created from OSM data.

… See full entry

A while back I wrote https://github.com/SomeoneElseOSM/Notes01 to enable OSM notes to be converted to a useful Garmin format so that you can actually check them when out and about.

A week ago I added support for extracting “fixme” tags from Overpass. There are about 20 notes within 9km of my house, so I was interested to see how many fixmes there were. It turned out that there were 430! As someone said on IRC, “that’ll keep you busy over Christmas”.

Best Regards,

Andy

.