Introduction

This article will create a simple WPF control that enables browsing of map data from OpenStreetMap, as well as enabling searching for places and displaying the results on the map.

The attached zip file has both the source code, with documentation, and a sample application.

Background

I needed to allow the user to select various locations in my project but didn't want the user to have to install any other applications (such as Google Earth or Bing Maps 3D). One option was to have a web browser in my application pointing to the online versions, but this didn't feel right. Finally, I looked at OpenStreetMap and was impressed by the maps, but couldn't find any controls to put in my application.

What is OpenStreetMap?

OpenStreetMap creates and provides free geographic data such as street maps to anyone who wants them. The project was started because most maps you think of as free actually have legal or technical restrictions on their use, holding back people from using them in creative, productive, or unexpected ways.

Basically, OpenStreetMap is a map made by the community for everybody to use. Also, luckily for me, all the details for the file naming conventions are there for creating our own control. All we have to do is download the relevant 256 x 256 pixel square image tiles for the area we want to look at and stitch them together - simple!

Performance

The original version of the code used a method similar to the WinForms DoEvents method to allow queued up messages in the UI to be processed while the images were updating. There was a reason WPF doesn't implement this method because it's not a good idea to do that! This time around, there's a separate class responsible for fetching the images (either from the cache on disk or from the server) and this is called on a background thread (using ThreadPool.QueueUserWorkItem to take care of thread creation) and then freezing the BitmapImage. Once frozen, this can be passed back to the UI thread, which updates one tile at a time as needed without blocking.

Using the Code

All the basic functionality for displaying a map and searching is in the MapControl project, however, you will need to create the controls for navigating and for getting the search query from the user. I've made a separate project called SampleApp which does just this, but I must confess my design skills suck.

TileGenerator Class

This class has helper methods to retrieve information from OpenStreetMap and has the following members:

publicstaticclass TileGenerator
{
// The maximum allowed zoom level.
publicconstint MaxZoom = 18;
// Occurs when the number of downloads changes.
publicstaticevent EventHandler DownloadCountChanged;
// Occurs when there is an error downloading a Tile.
publicstaticevent EventHandler DownloadError;
// Gets or sets the folder used to store the downloaded tiles.
// Note: This should be set before any call to GetTileImage.
publicstaticstring CacheFolder { get; set; }
// Gets the number of tile images waiting to be downloaded.
// Note: this is not the same as the number of active downloads.
publicstaticint DownloadCount { get; }
// Gets or sets the user agent used to make the tile request.
// Note: This should be set before any call to GetTileImage.
publicstaticstring UserAgent { get; set; }
// Returns a valid value for the specified zoom,
// in the range of 0 - MaxZoom inclusive.
publicstaticint GetValidZoom(int zoom);
}

Before we do anything with any of the map controls, even before trying to call their constructors, we need to set the directory for the tile image cache folder and the user agent we will use to identify ourselves. Here MainWindow is assumed to be the first window loaded but you could instead put this line inside the constructor of the default App class:

public MainWindow()
{
// Very important we set the CacheFolder before doing anything so the
// MapCanvas knows where to save the downloaded files to.
TileGenerator.CacheFolder = @"ImageCache";
TileGenerator.UserAgent = "MyDemoApp";
this.InitializeComponent(); // Because this will create the MapCanvas, it
// has to go after the above.
}

MapCanvas Class

The actual map is displayed inside the MapCanvas, which is inherited from the WPF Canvas control (hence the well thought out name ).

publicsealedclass MapCanvas : Canvas
{
// Identifies the Latitude attached property.
publicstaticreadonly DependencyProperty LatitudeProperty;
// Identifies the Longitude attached property.
publicstaticreadonly DependencyProperty LongitudeProperty;
// Identifies the Viewport dependency property. This will be read only.
publicstaticreadonly DependencyProperty ViewportProperty;
// Identifies the Zoom dependency property.
publicstaticreadonly DependencyProperty ZoomProperty;
// Gets the visible area of the map in latitude/longitude coordinates.
public Rect Viewport { get; }
// Gets or sets the zoom level of the map.
publicint Zoom { get; set; }
// Gets the value of the Latitude attached property for a given dependency object.
publicstaticdouble GetLatitude(DependencyObject obj);
// Gets the value of the Longitude attached property for a given dependency object.
publicstaticdouble GetLongitude(DependencyObject obj);
// Sets the value of the Latitude attached property for a given dependency object.
publicstaticvoid SetLatitude(DependencyObject obj, double value);
// Sets the value of the Longitude attached property for a given dependency object.
publicstaticvoid SetLongitude(DependencyObject obj, double value);
// Centers the map on the specified coordinates, calculating the required zoom level.
// The size parameter is the minimum size that must be visible,
// centered on the coordinates.
// i.e. the longitude range that must be visible will be:
// longitude +- (size.Width / 2)
publicvoid Center(double latitude, double longitude, Size size);
// Creates a static image of the current view.
public ImageSource CreateImage();
// Calculates the coordinates of the specified point.
// The point should be in pixels, relative to the top left corner of the control.
// The returned Point will be filled with the Latitude in the Y property and
// the Longitude in the X property.
public Point GetLocation(Point point);
}

The main points of interest are the two attached properties that make it a bit easier for positioning child controls (though you can still use the regular Canvas ones such as Canvas.Left, etc.): MapCanvas.Latitude and MapCanvas.Longitude. Using them should be straight forward:

<!-- Make sure you've included a reference to MapControl.dll in your project --><!-- and put a reference like the following at the start of the XAML file: --><!-- xmlns:map="clr-namespace:MapControl;assembly=MapControl" --><map:MapCanvas><!-- The Top Left corner of the control will be at the specified Latitude + Longitude,
so set a negative Margin to centralise the control on the coordinates. --><RectangleFill="Red"Height="50"Width="50"Margin="-25,-25,0,0"map:MapCanvas.Latitude="38.895"map:MapCanvas.Longitude="-77.037"/></map:MapCanvas>

Panning and Zooming

The MapCanvas will handle dragging with the mouse and zooming using the scroll wheel, however, you will probably want to add a set of navigation controls as well. To enable this, the MapControl registers itself with the following (self explanatory) standard WPF commands:

ComponentCommands.MoveDown

ComponentCommands.MoveLeft

ComponentCommands.MoveRight

ComponentCommands.MoveUp

NavigationCommands.DecreaseZoom

NavigationCommands.IncreaseZoom

SearchProvider/SearchResult Classes

This SearchProvider class first tries to parse the query for a decimal latitude and longitude (in that order, separated by a comma and/or space) but if that fails will pass the query on to Nominatim to search osm data by name and address. Just to reiterate, it will only try and parse decimal degrees, not degrees minutes seconds.

publicsealedclass SearchProvider
{
// Occurs when the search has completed.
publicevent EventHandler SearchCompleted;
// Occurs if there were errors during the search.
publicevent EventHandler<SearchErrorEventArgs> SearchError;
// Gets the results returned from the most recent search.
public SearchResult[] Results { get; }
// Searches for the specified query, localizing the results to the specified
// area.
// Note that it only returns true if a search was started. This does not
// always mean that the method has failed - if a set of valid coordinates
// were passed as the query then no search will be performed (returning
// false) but the SearchCompleted event will be raised and the Results will
// be updated.
publicbool Search(string query, Rect area);
}

This finally leaves the SearchResult class that, as you would expect, contains information for an individual search result returned from Nominatim.

publicsealedclass SearchResult
{
// Gets the formatted name of the search result.
publicstring DisplayName { get; }
// Gets the index the result was returned from the search.
publicint Index { get; }
// Gets the latitude coordinate of the center of the search result.
publicdouble Latitude { get; }
// Gets the longitude coordinate of the center of the search result.
publicdouble Longitude { get; }
// Gets the size of the search's bounding box.
public System.Windows.Size Size { get; }
}

Points of Interest

Before using the code or sample application, you should read and make sure you comply with the following:

The way I read it is make sure you put a copyright notice on the map (like the one in the bottom right hand corner of the sample application) and make sure you don't abuse the servers by downloading too much (such as trying to download all the tiles in one go).

History

27/01/2012 - Allowed the user agent to be specified (complying with the Tile Usage Policy) and removed the DoEvents related code