During making documentation of OSM tools and software it is frequently useful to add screenshots. Especially tutorials are often featuring multiple ones. I always disliked that such images are frequently getting outdated. It may caused by interface changes, map style changes and edits to OSM data.

Sometimes it requires more significant update of documentation, sometimes updating images is enough. But it may be very time-consuming.

When I was making my Overpass Turbo Tutorial for newbies* I wanted to find a way to make such images easy to recreate.

I found an interesting solution. Selenium is a software usually used for testing websites. It has plenty of features but interesting here is is that one may write a simple script that will

• open a website
• wait for it to load
• take a screeenshot

This way it may be possible to generate and recreate screenshots without manually taking them.

There is plenty of way how Selenium may be used, I am using Python bindings connected to Firefox using geckodriver.

Time-saving code is relatively simple.

imports:

from selenium import webdriver
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

Lets say that I wanted an example of a simple website. This code will take a picture of googling results and save it to a specified file.

driver.get('https://duckduckgo.com/?q=wetland+OSM+Wiki&ia=web')
driver.save_screenshot('wetland-search-results.png')

Following code sample will modify vieport size and interact with page to hide irritating banners, then take a picture of site (note that such use is also subject of Tile Usage Policy like other automated tile downloading, but for regular tutorial updates use will be not higher than human doing the same):

driver.set_window_size(1024, 768)
driver.get('https://www.openstreetmap.org/#map=10/54.2066/-4.5782')
#hide banners about SOtM and other spam
for popup in driver.find_elements_by_class_name("close-wrap"):
    popup.click()
driver.save_screenshot('Isle-of-Man.png')

overpass turbo screenshots are a bit trickier when we want to display query results

def smart_overpass_capture(url, image_file, driver):
    driver.get(url)
    element = WebDriverWait(driver, 10).until_not(
        EC.presence_of_element_located((By.CLASS_NAME, "loading"))
     )
    driver.save_screenshot(image_file)

smart_overpass_capture('http://overpass-turbo.eu/s/zNL', "Nepal-glaciers.png", driver)

Overall it turned out to be much easier than expected, and now to update all images I need to run just a python script rather than fiddle with pixel alignment and crop images to an exact size.

One nice part is to add proper image comparison to git - I used method described at http://www.akikoskinen.info/image-diffs-with-git/. It is not ideal, but it is good enough for me.

I still have to figure out how to automate generation of animated images showing usage of interface. This would allow to easily tweak and improve such animations without manually recreating everything.

*if you have time or are interested in how on may extract data from Overpass Turbo - feel free to write to me how it may be improved (by OSM message or by comments of this entry).

"Pentargon" is my (36') narrowboat which has been on a hardstand since Dec 2017. It is due to be immersed on Sat 13th July to cruise initially down river to Kingston ...

It seemed like a good idea on the face of it. Stops on the highway became public_transport=stop_position, stops next to it public_transport=platform.

But then it was suddenly necessary to add both these objects to the route relations. Already the fact that more than one object became necessary to describe a single bus stop, should have raised alarm bells.

There are, of course, some positive things to say about to say about the new scheme. A route_master relation for a whole line. route relations to describe the various itineraries and stops.

But the stops, that's where it goes seriously wrong. Why on earth is it necessary to add 2 objects to those route relations? As they describe all the variations, there are a lot of them. Lots of work to maintain them. And they break easily.

After the scheme was voted, I was trying my best to map stops according to it. I had my highway=bus_stop nodes which were all nicely positioned next to the highways, so it's clear on which side of the road they are located.

So I asked on the mailing list: hey what public_transport to use for them? The answer was public_transport=platform. So far, so good.

Since I had 40000 stops to add for half of a small country, I was not going to bother with adding stop_position nodes as well. So I trudged along for a few years.

In the mean time in Germany and France they had a different idea, let's convert those nodes next to the highway to platform ways (regardless of whether there was an actual platform present in some cases), oh and those stop_position nodes, let's duplicate all the details for the stops.

So, for the sake of simplicity, I would like us all to come back to our senses. Map each bus stop, exactly once on a node next to the highways and only add these nodes to the route relations. That's how I will continue to do it in Belgium, although unfortunately in Brussels somebody already started adding stop_position nodes everywhere and adding them to the route relations. Oh well.

So I'm not sure if it will ever happen that we all move to a more sensible scheme, but in case it doesn't, I promise to continue moaning and bitching about this overly complex way of mapping public transport.

Polyglot

I have been unable to find an authoritative official list of the districts (''etraplar'') in Turkmenistan's five provinces, so have cobbled together a list for each province based on whatever official press releases, news items, and other sources (including personal travel to some of them) I could find. The results have now been typed into the wiki pages for each of the provinces:

• Ahal Province
• Balkan Province
• Dashoguz Province
• Lebap Province
• Mary Province

If anybody has corrections to any errors of omission or commission, please make them and let me know! These lists are accurate and up to date so far as I can tell, but nobody's perfect.

This and future diary posts also appear on my blog.

MapRoulette lets anyone contribute to OpenStreetMap by fixing small mistakes on the map. It works like a roulette wheel: once you select something you want to work on, MapRoulette will give you a random task to work on. Once you fix it, you return to MapRoulette for the next task. Do as few or as many as you like. Be careful, people have been known to get hooked on it!

Since 2013, MapRoulette has been used by thousands of mappers to complete well over 1.5 million small tasks to improve OpenStreetMap. We have put all the feedback we have received and lessons we learned into the latest version: MapRoulette v3.

In a series of posts, I will highlight some great new features of this new version. This is the first post. Enjoy!

Filters

I heard from some mappers that they couldn't find anything interesting to work on. We spent a lot of time making that easier, by adding different filters.

Location

You can quickly narrow down the list of available Challenges by zooming and panning the map, and selecting 'Within Map Bounds' or 'Intersecting Map Bounds' from the 'Location' dropdown menu. 'Within Map Bounds' will only show you Challenges that only have tasks within the current map view. 'Intersecting Map Bounds' will also show you Challenges that have some, but not all, their Tasks in the current map view. Additionally, you can narrow down the list to Challenges near your current location. This requires allowing browser access to your location.

Categories

Challenges are now grouped into Categories, like 'Roads / Pedestrian / Cycleways', or 'Buildings'. You can filter the list of available Challenges by selecting a Category from the 'Work on' dropdown menu.

Text

You can enter any text in the search box, and MapRoulette will only show you the Challenges that have a name or description containing that text.

You can clear any filters you have set with using 'Clear Filters'.

Stay tuned for future posts about the all new MapRoulette 3! I hope you will give it a(nother) try and let me know what you think.

Students from Forsyth Central High School utilizing their geography skills and creating maps through their travel in Europe. The students utilized their gps watches to construct these maps.

/Users/michaelmeyer/Pictures/Photos Library.photoslibrary/Thumbnails/2016/06/23/20160623-143505/j4E7HIzLRamNBnnJsdsMBA/thumb_IMG_3640_1024.jpg

Recently at Mapbox we open sourced RoboSat our end-to-end pipeline for feature extraction from aerial and satellite imagery. In the following I will show you how to run the full RoboSat pipeline on your own imagery using drone imagery from the OpenAerialMap project in the area of Tanzania as an example.

Goal

For this step by step guide let's extract buildings in the area around Dar es Salaam and Zanzibar. I encourage you to check out the amazing Zanzibar Mapping Initiative and OpenAerialMap for context around the drone imagery and where these projects are heading.

High-level steps

To extract buildings from drone imagery we need to run the RoboSat pipeline consisting of

• data preparation: creating a dataset for training feature extraction models
• training and modeling: segmentation models for feature extraction in images
• post-processing: turning segmentation results into cleaned and simple geometries

I will first walk you through creating a dataset based on drone imagery available on OpenAerialMap and corresponding building masks bootstrapped from OpenStreetMap geometries. Then I will show you how to train the RoboSat segmentation model to spot buildings in new drone imagery. And in the last step I will show you how to use the trained model to predict simplified polygons for detected buildings not yet mapped in OpenStreetMap.

Data Preparation

The Zanzibar Mapping Initiative provides their drone imagery through OpenAerialMap.

Here is a map where you can manually navigate this imagery.

To train RoboSat's segmentation model we need a dataset consisting of Slippy Map tiles for drone images and corresponding building masks. You can think of these masks are binary images which are zero where there is no building and one for building areas.

Let's give it a try for Dar es Salaam and Zanzibar, fetching a bounding box to start with.

Let's start with extracting building geometries from OpenStreetMap and figuring out where we need drone imagery for training dataset. To do this we need to cut out the area we are interested in from OpenStreetMap.

Our friends over at GeoFabrik provide convenient and up-to-date extracts we can work with. The osmium-tool then allows us to cut out the area we are interested in.

wget --limit-rate=1M http://download.geofabrik.de/africa/tanzania-latest.osm.pbf

osmium extract --bbox '38.9410400390625,-7.0545565715284955,39.70458984374999,-5.711646879515092' tanzania-latest.osm.pbf --output map.osm.pbf

Perfect, now we have a map.osm.pbf for Dar es Salaam and Zanzibar to extract building geometries from!

RoboSat comes with a tool rs extract to extract geometries from an OpenStreetMap base map.

rs extract --type building map.osm.pbf buildings.geojson

Now that we have a buildings.geojson with building geometries we need to generate all Slippy Map tiles which have buildings in them. For buildings zoom level 19 or 20 seems reasonable.

rs cover --zoom 20 buildings.geojson buildings.tiles

Based on the generated buildings.tiles file we then can

• download drone imagery tiles from OpenAerialMap, and
• rasterize the OpenStreetMap geometries into corresponding mask tiles

Here is a preview of what we want to generate and train the segmentation model on.

If you look closely you will notice the masks are not always perfect. Because we will train our model on thousands of images and masks, a slightly noisy dataset will still work fine.

The easiest way for us to create the drone image tiles is through the OpenAerialMap API. We can use its /meta endpoint to query all available drone images within a specific area.

http 'https://api.openaerialmap.org/meta?bbox=38.9410400390625,-7.0545565715284955,39.70458984374999,-5.711646879515092'

The response is a JSON array with metadata for all drone imagery within this bounding box. We can filter these responses with jq by their attributes, e.g. by acquisition date or by user name.

jq '.results[] | select(.user.name == "ZANZIBAR MAPPING INITIATIVE") | {user: .user.name, date: .acquisition_start, uuid: .uuid}'

Which will give us one JSON object per geo-referenced and stitched GeoTIFF image.

{
  "user": "ZANZIBAR MAPPING INITIATIVE",
  "date": "2017-06-07T00:00:00.000Z",
  "uuid": "https://oin-hotosm.s3.amazonaws.com/5ac7745591b5310010e0d49a/0/5ac7745591b5310010e0d49b.tif"
}

Now we have two options

• download the GeoTIFFs and cut out the tiles where there are buildings, or
• query the OpenAerialMap API's Slippy Map endpoint for the tiles directly

We can tile the GeoTIFFs with a small tool on top of rasterio and rio-tiler. Or for the second option we can download the tiles directly from the OpenAerialMap Slippy Map endpoints (changing the uuids).

rs download https://tiles.openaerialmap.org/5ac626e091b5310010e0d480/0/5ac626e091b5310010e0d481/{z}/{x}/{y}.png building.tiles

Note: OpenAerialMap provides multiple Slippy Map endpoints, one for every GeoTIFF.

In both cases the result is the same: a Slippy Map directory with drone image tiles of size 256x256 (by default; you can run the pipeline with 512x512 images for some efficiency gains, too).

To create the corresponding masks we can use the extracted building geometries and the list of tiles they cover to rasterize image tiles.

rs rasterize --dataset dataset-building.toml --zoom 20 --size 256 buildings.geojson buildings.tiles masks

Before rasterizing we need to create a dataset-building.toml; have a look at the parking lot config RoboSat comes with and change the tile size to 256 and the classes to background and building (we only support binary models right now). Other configuration values are not needed right now and we will come back to it later.

With downloaded drone imagery and rasterized corresponding masks, our dataset is ready!

Training and modeling

The RoboSat segmentation model is a fully convolutional neural net which we will train on pairs of drone images and corresponding masks. To make sure these models can generalize to images never seen before we need to split our dataset into:

• a training dataset on which we train the model on
• a validation dataset on which we calculate metrics on after training
• a hold-out evaluation dataset if you want to do hyper-parameter tuning

The recommended ratio is roughly 80/10/10 but feel free to change that slightly.

We can randomly shuffle our building.tiles, split it into three files according to our ratio, and use rs subset to split the Slippy Map directories.

rs subset images validation.tiles dataset/validation/images
rs subset masks validation.tiles dataset/validation/labels

Repeat for training and evaluation.

Before training the model we need to calculate the class distribution since background and building pixels are not evenly distributed in our images.

rs weights --dataset dataset-building.toml

Save the weights in the dataset configuration file, which training will then pick up. We can now adapt the model configuration file, e.g. enabling GPUs (CUDA) and then start training.

rs train --model model-unet.toml --dataset dataset-building.toml

For each epoch the training process saves the current model checkpoint and a history showing you the training and validation loss and metrics. We can pick the best model, saving its checkpoint, looking at the validation plots.

Using a saved checkpoint allows us to predict segmentation probabilities for every pixel in an image. These segmentation probabilities indicate how likely each pixel is background or building. We can then turn these probabilities into discrete segmentation masks.

rs predict --tile_size 256 --model model-unet.toml --dataset dataset-building.toml --checkpoint checkpoint-00038-of-00050.pth images segmentation-probabilities

rs masks segmentation-masks segmentation-probabilities

Note: both rs predict as well as rs mask transform Slippy Map directories and create .png files with a color palette attached for visual inspection.

These Slippy Map directories can be served via an HTTP server and then visualized directly in a map raster layer. We also provide an on-demand tile server with rs serve to do the segmentation on the fly; it's neither efficient nor handles post-processig (tile boundaries, de-noising, vectorization, simplification) and should only be used for debugging purpose.

If you manually check the predictions you will probably notice

• the segmentation masks already look okay'ish for buildings
• there are false positives where we predict buildings but there is none

The false positives are due to how we created the dataset: we bootstrapped a dataset based on tiles with buildings in them. Even though these tiles have some background pixels they won't contain enough background (so called negative samples) to properly learn what is not a building. If we never showed the model a single image of water it has a hard time classifying it as background.

There are two ways for us to approach this problem:

• add many randomly sampled background tiles to the training set, re-compute class distribution weights, then train again, or
• use the model we trained on the bootstrapped dataset and predict on tiles where we know there are no buildings; if the model tells us there is a building put these tiles into the dataset with an all-background mask, then train again

The second option is called "hard-negative mining" and allows us to come up with negative images which contribute most to the model learning about background tiles. We recommend this approach if you want a small, clean, and solid dataset and care about short training time.

For hard-negative mining we can randomly sample tiles which are not in building.tiles and predict on them with our trained model. Then make use of the rs compare tool to create images visualizing the images without buildings in them and the prediction next to it.

rs compare visualizations images segmentation-masks

After making sure these are really background images and not just unmapped buildings in OpenStreetMap, we can put the negative samples into our dataset with a corresponding all-background mask. Then run rs weights again, update the dataset config, and re-train.

It is common to do a couple rounds of hard-negative mining and re-training, resulting in a solid and small dataset which helps the model most for learning.

Congratulations, you now have a solid model ready for prediction!

Here are the segmentation probabilities I got out after spending a few hours of hard negative mining.

Interesting to see here is the model is not entirely sure about building construction sites. It is on us to make an explicit decision when creating the dataset and when doing hard-negative mining: do we want to include building construction sites or not.

These edge-cases occur with all features and make up the boundaries of your feature’s visual appearance. Are house-boats still buildings? Are parking lots without parking aisle lane markings still parking lots? Make a call and be consistent.

Finally, the post-processing steps are responsible for turning the segmentation masks into simplified and vectorized GeoJSON features potentially spanning multiple tiles. We also tools for de-duplicating detections against OpenStreetMap to filter out already mapped features.

I won’t go into post-processing details in this guide since the segmentation masks based on this small training dataset are still a bit rough to make it properly work well and the RoboSat post-processing is currently tuned to parking lots on zoom level 18 and I had to make some in-place adaptions when running this out.

Summary

In this step-by-step guide we walked through the RoboSat pipeline from creating a dataset, to training the segmentation model, to predicting buildings in drone imagery. All tools and datasets used in this guide are open source and openly available, respectively.

Give it a try! https://github.com/mapbox/robosat

I'm happy to hear your feedback, ideas and use-cases either here, on a ticket, or by mail.

I've set up a Mastodon instance for OSM (english speaking)!

https://en.osm.town/ - OpenStreetMap Mastodon

Mastodon is an open source, federated micro-blogging system, with more than a million users. Basically open source twitter, spread across many servers. This is a new instance/server focused on OpenStreetMap (there's already fr.osm.social for francophone OSMers). Like email, this server ("instance") talks to other servers, so anyone on the "fediverse" can follow and interact with anyone on this server & vice versa. The "local timeline" will only show toots (= tweets) from everyone on the server, so will be full of OSM related stuff.

Let's ditch twitter for something open, and under our control! No adverts, no analytics, no "algorithmic" promoted tweets. 500 characters! Let's use mapstodon instead!

I'm mirroring some twitter accounts to it. I can turn them over the appropriate people, or continue to auto post from twitter. I'll create more mirror accounts later.

• @[email protected]
• @[email protected]

More on Mastodon:

• https://joinmastodon.org/
• Mastodon User Guide
• Wikipedia on Mastodon
• OSM Wiki on Mastodon

Follow me on mapstadon: @[email protected]

the changeset upload is known to take quite some time for larger changesets, sometimes resulting in timeouts and unclear overall status. Luckily, JOSM already covers some of those issues via its chunked upload, still there's always room for improvement.

(Image by zerebubuth, original source(defunct), mirror)

Since a few days now, a new changeset upload implementation to address those issues is available for testing. That's a good opportunity to check if everything is still working as expected. Overall, the new implementation should be a bit more resilient towards uploading large changesets in one go.

Apps like JOSM frequently use regular expressions to analyze error messages. Special care has been taken to make sure this mechanism still works as before. Also, all HTTP return codes should be identical.

Steps to start editing on the demo server

1. Create a new user on the demo server: http://78.46.206.64:31337/. NB. A fake email address will be just fine on this server, it's neither checked nor used for anything.
2. Wait up to 5 minutes, until the user has been auto-confirmed by the system. A dedicated confirmation email will not be sent out and is not required.
3. Log on to the site
4. Start testing in iD, Potlatch, or JOSM (see below)

Example: http://static.64.206.46.78.clients.your-server.de:31337/edit?editor=id#map=16/49.2459/6.9278

Special instructions for OAuth set up in JOSM

Note: configuring JOSM to point to the demo server is an advanced topic and not suited for beginners.

For JOSM, all relevant instructions are outlined on the following user page http://78.46.206.64:31337/user/mmd2

OAuth is mandatory at this time.

If you encounter any issues with the new implementation, feel free to send me a message or leave a comment on the respective Github issue

Happy testing!

I was using the default Bing maps satellite imagery, until I found "Background Settings" (B) on the right toolbar. For Ojai, CA the Mapbox Satellite imagery is much more clear; however, the alignment can be slightly different for roads and buildings, compared with the default Bing maps imagery.

The 18.06 version (13996) is out!

Notable changes in this release:

• To address a growing performance issue while dragging the map when street labels are displayed, we now disable label rendering during this operation:

• It is now possible to quickly switch from one imagery layer to another using the tilde key (~ on QWERTY keyboard layout) or the square key (² on AZERTY layout):

• If you're running Java 8 (which is still the recommended version), you won't be prompted to switch to latest version of Java (currently 10.0.1), because Oracle is messing up by removing a lot of features used by JOSM.

For more details about the other changes and bugfixes, see the summarized changelog.

Happy mapping!

WOW...:!!! Its a very Exciting moment for me as i was able to map over 5123 buildings,in about 15 countries with over 1299 changesets in 2 WEEKS...!!!!!! That's the best experience i have had so far as a mapper of about 3 months old. Shout Out to my Team #UNIQUE MAPPERS TEAM# For We Are UNIQUE..!!!

Bình Châu Commune of Ba Ria Vung Tau Province launched new breakwaters in 2015, sadly the bay and waters of the port hadn't been mapped until... 5 minutes ago. Finally they appear here, clear and beautiful, as if it's Mona Lisa in a fine arts museum.

Before mapping:

After mapping:

As of today I have broken a quarter of a million images uploaded to Mapillary that any OSM user can use for helping map Turkmenistan. I still have over 20K more images to upload from the Serhetabad trip and last Monday's day trip to Magtymguly (Garry Gala).

Sometime this year I will depart Turkmenistan, so am feeling some pressure to collect as much data as possible before moving back to the United States.

Wikipedia's work on Maps. See: https://blog.wikimedia.org/2018/06/28/interactive-maps-now-in-your-language/

OpenStreetMap Mexico's data governance strategy

In Mexico, a working group of 8 people from the OpenStreetMap Mexico community has been formed since 2014, with varied profiles and several axes among which [1] the community training to add more users to OpenStreetMap, [2] the management with local and federal public institutions for the integration of OpenStreetMap and other geographical open data sources to their planning actions as well as for the opening of public data, and [3] an evolution of their methods to include a greater participation of the citizenship in the production and use of information.

One of the most consolidated topics of the international OpenStreetMap community is the generation and distribution of data in humanitarian contexts, in a preventive manner or after a crisis. The high frequency of natural cataclysms that affect the Mexican territory has given this group many opportunities for dialogue and collaborations with federal institutions and organizations (National Digital Strategy, CENAPRED, Red Cross, Doctors Without Borders, Greenpeace, Techo, Observatorio de la Vivienda, etc.), as well as towards affected states, for the generation and opening of up-to-date territorial data that make it possible to speed up rescue and reconstruction operations.

The first type of effort was training officials and organizations to familiarize them with OpenStreetMap and its potential for sustainable local management of territorial data. In response to various disasters since 2014, we have acted more directly to collaborate by providing information in real time to these institutions through tasking managers.

In parallel, we have had a constant effort of long-term linkage to establish a critical path where OpenStreetMap remains in the panorama of the actors of the data ecosystem for post-disaster interventions.

The main difficulty in this initiative has been to identify the correct channels to give an output to the information mapped by the community in Tasking-Managers created on each occasion, and identify with local institutions the real data needs to intervene on site. The administrative context is a general lack of access to public information, both for civil society and for other administrations. Another difficulty is the absence of clear critical routes so that organizations and institutions that collaborate with data can organize themselves and fulfill useful roles without overlapping.

The impact is a great difficulty and confusion to simply think together about the concrete need for data and the idea of collaboration, as well as about the potential for enriched data once opened and socialized.

Invitation from OSM Mexico to the working group on humanitarian data and technologies

As a result of a continuous and persistent presence during several years, the federal institution of risk management (National Center for Disaster Prevention - CENAPRED) invited us to be part of a scheme that will leave the next government for 2019. This working group is justified by the same shared awareness of the value of companies and civil society with expertise and stability over time, to act hand in hand with the Federal Government and collaborate with their communities in data creation. It is also justified by the awareness of the challenge of generating an institutionalized scheme and lasting channels of joint work. Finally, in Mexico as in other countries, the changes of administration represent another challenge: to transmit a vision, a learning, and a structure to the next administration, and to go beyond a single governmental team.

The group of humanitarian data and technologies faces these three challenges. Given the imminent and repeated risk of other disasters and the need to have different skills, the group brings together civil society organizations, companies and different public institutions with a multiplied potential for action, monitoring and evaluation of public action.

Functions of the workgroup

The group, interconnected continuously and with biannual meetings, will be able to follow up on different types of emergencies and define actions under a principle of complementarity and immediacy, as well as risk prevention and vulnerability reduction through information. In the face of a disaster threat, specifically, each member will be able to fulfill a role, a type of data to be generated or processed, to be the bridge to other specialized networks and communities. It will also be possible to define lines of action in the long term, working on vulnerabilities through data, technologies and infrastructures. The group could act as an entity that evaluates transparency and monitoring.

Part of the first actions before the change of government at the end of 2018 will be a digital simulation, which will measure the reaction capacity of the members and better define roles and specialties.

Long-term objective of OpenStreetMap Mexico

Through this participation, we intend to contribute to the construction of a sustainable public data ecosystem where authorities, private and civil communities share in a very short time an improved information for each one.

1. Design of an accurate collaboration scheme with companies and institutions providing satellite images
2. Definition of data not provided in an updated manner and accessible by the National Institute of Statistics and Geography or by another agency, and necessary
3. Construction of the precise channel of information exchange in real time
4. Construction of specialized groups of emergency mappers by OpenStreetMap
5. A system of direct communication of the data for download destinated to the workgroup and the authority-destination, as well as towards the general public.

It seems I have gained a cyber fan.

I have been adding previously unmapped roads to the database using satellite imagery, but mainly in areas I have traveled, as recently as within the past two weeks. There is a particular user who seems to be chasing and changing my recent edits around the map. I say "chasing" because I moved to a totally different area of the map I don't usually work on and this user still found and changed my work.

My main goal is to map roads that aren't in the database yet, but it seems this user is mainly just tracking my changesets and changing what I tag when I add the roads.

Is it frustrating for the mapper? Yes indeed. Frustrating is someone else changing the classification of a road I just drove on in a regular car. I might not be as frustrated if this user was also working at adding to the road network but the bulk of their edits are changing and deleting other users work.

Rhetorical question, but if everything I classify and tag will be shortly changed after I save, should I just add the road geometry with no tags at all and let this other user do all the tagging work?

I understand the OSM project is open to all and every user has the right/ability to change information they deem to be inaccurate. But isn't it rather rude to single someone out and chase their work around the map, rather than add new information to the database?

Not really looking for comments - I'm just venting and sharing in case others are experiencing the same issue.

Recently I picked up a GoPro HERO5 Black camera for use in street-level imagery. It's been a really great platform that has displayed fairly steady GPS acquisition and tracking. (Though I may not necessarily be the person driving when I am capturing footage.) I'm also big fan of contributing to as many projects in the OpenStreetMap ecosystem as possible.

To that end, I've found a workflow that has worked fairly well for taking photos from my GoPro and resulting in photo contributions to OpenStreetCam and Mapillary. Here's how (note this is a compilation of not only trial-and-error but also advice scattered throughout the internet):

Capture street-level imagery with the camera

As mentioned, I use a GoPro HERO5 Black because it has GPS, and I capture in time lapse photo mode with a linear frame and 1 second timing (I have found that 0.5 second timing causes some issues with upload backends). Unfortunately glare from the dash is a major issue unless you've situated the camera dead on the windshield, so I use some fabric I picked up at my local Walmart to cut down on the reflectivity of the dash.

Extract photos

I usually plug my card from the GoPro into an SD card adapter that I use on my MacBook. Once downloaded, I then scp the files to a Linux box. You could most likely also complete the following steps on another platform that has a Python interpreter, but I haven't tested it out.

Separate and filter photos

Depending on how you capture the photos, you may need to perform some manual separation of sequences. If you're the kind of person who leaves the camera on the whole trip, you're going to initially have a directory (or many directories if you have over 999 photos) of many photos. Furthermore, you're going to have many photos of you idling in the same position, so that will require filtering. I like to stop my camera with the remote switch right as I'm rolling up to a stop light; I turn the camera back on just as I'm about to accelerate from the stop. The GoPro increments one of the first few numbers (depending on what photo count you're on) every time you start a new sequence, so this allows me to easily find breaking points to split up segments as I see fit. Note that Mapillary prefers sequence counts in the low hundreds.

Interpolate compass

The GoPro is great in that it has a built in GPS for photos, but there is no information supplied about the bearing. The easiest way to add that to the photos with a fairly good degree of accuracy is the script at https://github.com/mapillary/mapillary_tools/blob/ca7bec7be44ed2560d3c26eaa9255f6d5a7dad85/python/interpolate_direction.py which will require you to clone that full git repository and install dependencies; note I am using an older commit because that's what I'm familiar with. With that installed, you run this step as python interpolate_direction.py --path /data2/losangeles/seq01/*.JPG. Repeat this for each sequence you have constructed.

(optional) Crop photos

The linear frame on the GoPro leaves a lot of sky at the top of the image and, even if you have some fabric in your dash, it may reflect other things in your car behind the dash such as your passenger seat, driver seat, or radio selection. Furthermore, we're mostly only interested in what's going on at street-level, so cropping the extra is useful. To crop the photos, I use Imagemagick: for f in 'ls /data2/losangeles/seq01/*.JPG'; do mogrify -gravity South -crop 4000x2200+0+0 $f; done (the ' is actually a grave accent on the ls command part--and by grave accent I mean the one on the same key as the tilde for American English keyboards). The parameters work well for my GoPro photos but will depend on the resolution of the camera you're using. Repeat that for each sequence you have constructed. Here's an example how, even with cropping, there's still some reflection from past the dash: https://www.openstreetcam.org/details/1201407/0/track-info.

Upload to OpenStreetCam

Now you ideally have sequences of photos that are GPS tagged by the GoPro, bearing set by the script above, and possibly filtered/cropped. The first place you can upload is OpenStreetCam. I cloned the repository at https://github.com/openstreetcam/upload-scripts, installed dependencies and authenticated as instructed in their README, then navigated to the upload_photos_by_exif subdirectory. Once there, you can call python upload_exif.py -p /data2/losangeles/seq01/ for a given sequence of photos. This will upload the photos and create two log files in their directory. Repeat this command for each sequence of photos.

Upload to Mapillary

The next place you can upload to is Mapillary. Again, I have been using an older version of their tools library, so your mileage may vary here. But with those scripts downloaded from before, I navigate to the python directory again and I edit the upload_with_authentication.py file. Depending on the commit, this line may not match exactly, but with the above-quoted commit, line 40 should have the variable MOVE_FILES defined as True. I set this to False so that the photos are not split up into success and failure directories while uploading. With that one-and-done edit, I now run upload script as python upload_with_authentication.py --auto_done /data2/losangeles/seq01/ and iterate over all the sequence directories.

This is not as coherent as it could be, so I will probably revise it in the near future.

Good day! I am Jake and this is my experience on OSM.

Online mapping was a concept that I have never heard of until this week. The office I am an intern in for two (2) weeks taught me about the basics of mapping. I would have never imagined people from all around the globe coming together to form such a great community. This community does public service in a sense because they input data into the website for other people to benefit from and use in their everyday lives.

The introduction to OSM was fairly simple. The website is designed in a neat and simple way which helped me begin mapping. The layout of the website is neat and the tutorial was really easy to understand. After learning the basics of mapping, it was time for me to actually map. I, along with my fellow interns, were tasked to map the buildings, roads, and any land use in our respective villages. This task was easy for me since some buildings in my village were already mapped/outlined.

After our introduction to OSM, we were then showed a website called HOT Tasking Manager. It is a website where people can collaborate in OSM to finish mapping tasks in certain areas. We were tasked to try the website out by mapping and validating. This part of my internship surprised me the most since I never expected people to collaborate through OSM to help the public gather data.

Bonus: We were also taught how to use field papers and smartphones to broaden our knowledge on mapping.

After these few days of mapping, I learned that OSM is a good way to help other people map out different parts of the world. I highly recommend that people try mapping because it is helpful and it is a great way to make a difference.

Hi I'm Nick,

So in my first week of openstreet mapping, I was actually interning at an office, and these were part of my daily tasks. Overall, it has been an interesting experience, mapping, correcting and validating things on the HOT Tasking Manager. I was also interested to find out that many people around the world contribute to mapping, in fact in 20 minutes all the tasks that I saw originally, had already been done. I am amazed by the amount of people willing to do this sort of thing. I was even able to go around the University of the Philippines Campus, to check if the mapping had been done accurately, most of it was except for a few things every now and then. In just one week, I saw how this place can help those who suffer from disasters and the like, and it has been a great experience overall, to see people willing to help others. It's also been fun to be able to work together with my friends to be able to properly map places in the Philippines.

OSM has overall been an interesting experience for me