New job history! Have you ever wanted to check status of your geocode and data source jobs and see what jobs you’ve run recently? Bing Spatial Data Services now makes it easy to view your job history. With the new ListJobs API , you can return a list of all geocode jobs and jobs that made changes to data sources in the last 15 days for any Bing Maps Account. Pending jobs are listed first. All you need to do is provide a Bing Maps Key from your Bing Maps Account with the following URL.

http://spatial.virtualearth.net/REST/v1/dataflows/listjobs?key=Insert_Your_Bing_Maps_Key_Here

A JSON response is returned by default. Add “output(o)=xml” to return XML. Jobs that download data source data do not make changes to your data source and therefore are not part of this list.

More __Distance query parameter options. Want to simply get all your entity data plus the distance to each entity? Bing Spatial Data Services now accepts the wildcard character with the __Distance propertywhen you Query by Area. Just specify $select=*,__Distance in your request. The distance option has also been expanded to support bounding box (rectangular region) queries. For bounding box queries, the distance returned for each entity is the distance from the center of the bounding box.

Make your data source public! Want to share your data with the world? Bing Spatial Data Services now gives you the option to make your data source public so that anyone with a Bing Maps Key can access. All you have to do is a Make a Data Source Public request as shown below. Set the setpublic parameter to true, and your data is publicly shared.

http://spatial.virtualearth.net/REST/v1/data/accessID/dataSourceName/$updateDataSource?setPublic=trueOrFalse&key= Insert_Your_Master_Key_Here

You can always make a data source private again by making the request again and setting the setpublic parameter to false. This parameter is also available when you Create or update your data source.

Delete selected entities with the new deleteEntity property. Want the ability to delete specific entities when you update your data source while leaving the rest of your data source intact? Bing Spatial Data Services can now incrementally delete entities when you use the __deleteEntityproperty in your schema and set it to 1 or true for each entity you want to remove when you update your data source.

We hope you enjoy these new features!

-The Bing Maps Team

Within Bing Maps you have the ability to view Venue Maps. Venue Maps are often thought of as maps of indoor structures such as malls and airports; however, venue maps can be opened up to so much more. A few examples of other types of venue maps include: the layout of shopping districts, stadiums, race courses, and universities.

Using Venue Maps in Bing Maps requires loading in the Venue Map module. If you are not familiar with modules in Bing Maps take a look at the blog post on Bing Maps Modules in Windows Store Apps.

In this blog post, we are going to create a simple application that when zoomed in, will load in nearby venues into Bing Maps in your Windows Store App as you pan the map around.

Setting up the project

To set up the project, open Visual Studios 2012 and create a new project. In the window that opens select JavaScript -> Windows Store. Select the Blank App template, and call the application VenueMaps_JS and press OK.

To keep things clean we are going to create a separate JavaScript file for our application. Right click on the js folder and select Add -> New Item. Create a new JavaScript file called VenueMaps.js.

At this point your Solution should look something like this:

Next, add a reference to the Bing Maps JavaScript library. To do this, right click on the References folder and press Add Reference. Select Windows -> Extensions select Bing Maps for JavaScript. If you do not see this option ensure that you have installed the Bing Maps Windows Store App SDK.

Now we can open up the default.html file and add references to the Bing Maps SDK along with references to the Bing Maps modules API and our JavaScript file. While we are at it, we will also add a div to the body of the page where we want the map control to load. Your default.html file should look like this:

Loading the Bing Maps Control

We will add the functionality to load the Bing Maps control to the VenueMap.js file. To start, we are going to create six global variables called: map, _mapBounds, _zoom, venueFactory, loadedVenues, and loadedVenueIds. Then, we will create a function called GetMap which will load the Bing Maps control for us. When loading the Bing Maps control we will also turn on the breadcrumb. The breadcrumb allows us to select different floors when viewing a venue. Inside of this function we will load in the Venue Maps module and initialize the venueFactory object. Now we will add a throttled event handler for when the map has finished moving that will get nearby venues. The GetMap function will be loaded after the Microsoft.Maps.Map module has completed loading. Your code should look like this:

Adding the Application Logic

When the veiwchangeend event handler is fired, it will trigger a function called GetNearbyVenues. This function will first loop through all loaded venues and dispose those that are out of view or all of them if the zoom level is less than 14. When disposing a venue we will also delete the stored venue id in the loadedVenueIds array. If the zoom level is greater or equal to 14 we will do a search for all venues that are within 4000 meters of the center of the map.

When the search for nearby venues completes, a function called DisplayNearbyVenues will be fired. This function will loop through the venues that are returned and check if the venue has been loaded by checking the loadedVenueIds array. If the venue hasn’t been loaded we will create the venue and check to see if it is in the current map view and add both the venue and the venue id to the loadVenues and loadedVenueIds arrays. If it was loaded, we will then show it on the map. If it hasn't, we will dispose it. We will also attach a close event handler to the venue so that we can properly dispose it and remove any reference from our arrays.

Running the App

At this point we have created all the functionality needed for nearby venues to be loaded as we navigate the map. If we run the app, zoom in and pan around in an area with the venue maps we should see the footprint of the venue load on the map. If you click on a venue footprint the map will zoom in on that venue and show the inside of the venue map. Here is a screen shot of the app with the venue map of Alder Hey Children’s Hospital located in Liverpool, UK.

- Ricky Brundritt, EMEA Bing Maps Technology Solution Professional

In this blog post we are going to look at how implement Geocoding and Routing using the Bing Maps Windows Store App JavaScript SDK. If you are new to JavaScript development with the Bing Maps Windows Store App SDK I recommend reading the Getting started with Bing Maps Windows Store Apps blog post first. We will also be making use of Bing Maps Modules. If you are unfamiliar with modules, I recommend reading the blog post: Modules in Bing Maps Windows Store Apps.

Geocoding is one of the most common tasks done by users of online maps. Geocoding is the process of taking an address or query and returning its equivalent coordinate on the map. Routing is the task of calculating the directions between two or more locations. In Bing Maps there are a lot of different options around routing such as routing by different modes of transportation; driving, walking, or transit. In Bing Maps there are several ways to carry out these tasks. The most common method is to use the Bing Maps REST services which are very easy to use from just about any programming language. In the JavaScript version of Bing Maps there a modules which wraps the REST services and exposes it as an easy to use JavaScript library. We will be making use of the Search module for geocoding and the Directions module for routing.

Setting up the project

To set up the project open Visual Studios 2012 and create a new project. In the window that opens select JavaScript -> Windows Store. Select the Blank App template, call the application BingMapsSearch_WinRTJS and press OK.

To keep things clean, we are going to create a separate CSS Style Sheet and JavaScript file for our application. To do this, right click on the js folder and select Add -> New Item. Create a new JavaScript file called BingMapsSearch.js. Then, right click on the css folder and select Add -> New Item and create a new Style Sheet called BingMapsSearch.css.

At this point your Solution should look something like this:

Next, you’ll want to add a reference to the Bing Maps JavaScript library. Right click on the References folder and press Add Reference. Then select Windows -> Extensions and select Bing Maps for JavaScript. If you do not see this option, you may want to verify that you have installed the Bing Maps for Windows Store App SDK .

We can now open up the default.html file and add references to the Bing Maps SDK along with references to our CSS Style Sheet and JavaScript file. To do this, simply add the following in the head of the page:

Creating the UI Layout

Before we worry about how to do all the programming of the logic required for this application, let’s first focus on creating the UI. For this app we are going to have a panel on the left side where all our input controls will reside and the map will fill up the rest of the space to the right. In the left frame we will have Clear Map button, an area for inputting geocode and route requests, and a div for rendering routing itineraries. The geocode input area will consist of a single textbox and a button. The routing input area will have two textboxes and a button. The HTML for the default.html file should look like this:

To keep things clean we will add some of the styling information into the BingMapsSearch.css file. Add the following to this file:

At this point we can run the application and see what it looks like. You should end up with something like this:

Note that the map does not appear as we have not yet added the logic to load it. Also, since we haven’t wired up any of the functionality for the buttons, clicking on them now would throw an error.

Loading the Bing Maps Control

We will add the functionality to load the Bing Maps control to the BingMapsSearch.js file. We are now going to create three global variables called: map, searchManager and directionsManager. Next, we will create a function called GetMap which will load the Bing Maps control for us. The GetMap function will be loaded after the Microsoft.Maps.Map module has completed loading. Your code should look like this:

Adding the Geocoding Logic

When a user adds content to the searchTbx textbox and presses the Go button a request will be fired to a Geocode function. For this functionality we will be making use of the Search module. The first thing we will do in this function is check to see if the searchManager variable has been initialized. If it hasn’t, we will load the Search module and initialize this variable and then process the search request. If this variable has been initialized, we will then create a geocode request passing in the users input value and requests a maximum of 1 result. We will also pass in the names of callback functions that get called if the request is successful or not.

If the request is successful we will display the result on the map with a pushpin and zoom into the location. If it is not successful, we will alert the user. The request will then be geocoded against the search manager. I would like to take a moment to point out that the alert JavaScript function that is commonly used in web development is not supported in Windows Store Apps. Instead, we need to make use of the Windows.UI.Popups.MessageDialog class. And since this is likely something we will want to use regularly, we will create a simple function for displaying messages to the user called ShowMessage. Add the following code to the BingMapsSearch.js file.

Adding the Routing Logic

When a user adds content to the fromTbx and toTbx textboxes and presses the Get Directions button a request will be fired to a GetRoute function. For this functionality we will be making use of the Directions module. The first thing we want to do in this function is to verify that the directionsManager variable has been initialized. If it hasn’t, we will load the Directions module and initialize this variable and then process the route request. If this variable has been initialized, we will then pass the start and end points to the directions manager and pass in the itinerary div id as the location to display the directions. We will then have the directions manager calculate the directions. Add the following code to the BingMapsSearch.js file.

The directions manager takes care of notifying the user if there is an issue calculating the route such as one of the route points having ambiguous results. This saves use a lot of time as we won’t have to worry about handling and developing this functionality. Additionally, this gives us the ability to easily drag the route if we want to customize it or avoid an area.

Clearing the Map

Whenever we process a new geocode or route request we will want to clear the map. We will also need to create a function named ClearMap as this is needed for the Clear Map button. When this function is called we will want to remove any entities from the map and reset the directions manager. This is rather simple to do, just add the following code to the BingMapsSearch.js file.

Running the App

At this point we have created all the functionality needed for the UI we created originally. If you run the app now you can make geocode and routing requests. Here is a screen shot of the app with a route from New York to Toronto.

- Ricky Brundritt, EMEA Bing Maps Technology Solution Professional

With the release of the Bing Maps REST Elevations service I started looking into cool and interesting things that can be done with the service. While doing some searching around, I stumbled across an interesting blog post titled Examining 3D Terrain of Bing Maps Tiles with SQL Server 2008 and WPF by one of our Bing Maps MVP’s which inspired me to see if I could make something similar using this new Elevations service. So with that, I’ve put together this blog posts which demonstrates how to create a tool for generating a 3D model of elevation data and then overlay static imagery over the top. As a teaser, here is a screenshot of a 3D model of Niagara Falls created using this code.

Setting up the Visual Studio Project

To start, we will create a WPF Application project in Visual Studios called BingMaps3DModel_WPF. Once this is done we will want to add references to the following libraries:

• System.Runtime.Serialization
• Microsoft.Maps.MapControl.WPF

Adding support for the REST based Elevation service

Since we will be accessing the Bing Maps REST Elevation service from .NET code we will need to add in a library to parse the responses from the service. Rather than writing these from scratch I’ll be making use of some code I helped put together in a previous MSDN article on using Bing Maps REST Service with .NET Libraries. To include this library into the project we will right click on the project and select Add -> New Item. Add a class file called BingMapsRESTServices.cs. Remove any content that’s in this file and copy and paste in the complete code from the bottom of the previous blog post. At this point your project should look something like this:

Creating the User Interface

For this application we will want to have two tabs. The first tab will have a map that the user will be able to use to select what area the 3D model should be created for. Once the user has selected the area they are interested in they will be able to press a button to generate the 3D model. Once the model is created the user will be taken to the second tab which will allow the user to view and interact with the 3D model. To make things a bit cleaner we will create a separate user control for the 3D models tab. To do this, right click on the project and select Add -> New Item. Select “User Control (WPF)” and call it ViewerPanel3D.xaml.

With this, we can create the markup for the MainWindow.xaml file. The XAML should look like this.

<Windowx:Class="BingMaps3DModel_WPF.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:m="clr-namespace:Microsoft.Maps.MapControl.WPF;assembly=Microsoft.Maps.MapControl.WPF"
xmlns:local="clr-namespace:BingMaps3DModel_WPF"
Title="3D Map Generator"Height="700"Width="800">
<Grid>
<TabControlName="MyTabs">
<TabItemHeader="Map">
<Grid>
<m:MapName="MyMap"CredentialsProvider="YOUR_BING_MAPS_KEY"Mode="AerialWithLabels"/>
<ButtonContent="Generate 3D Map Model"Click="Generate3DModel_Click"
Width="150"Height="25"Margin="10"
HorizontalAlignment="Right"VerticalAlignment="Top"/>
</Grid>
</TabItem>
<TabItemHeader="3D Model">
<local:ViewerPanel3Dx:Name="viewerPanel"/>
</TabItem>
</TabControl>
</Grid>
</Window>

If you run the application now, it should result in an application that looks like this:

Note: you may get an error if you haven’t created an instance of the click event for the button. Simply right click on the event name and press “Navigate to Event Handler” to generate the click event code that is needed.

The ViewerPanel3D User Control

We can now turn our attention to the ViewerPanel3D user control that we created and add the needed markup to that. When a model is loaded into this control we will want to give the user several sliders which they can use to rotate and move the model around with. I came across a really nice example in this blog post that I thought I would use as a starting point. The nice thing about this example is that it binds the sliders to the rotation transform which means there is no code needed in the background for this functionality. In addition to the sliders for rotating the model we will add a set of sliders for translating (moving in different directions) the model. We will also add a mouse wheel event for zooming in and out of the model. Putting this all together the markup for the ViewerPanel3D.xaml file should look like this:

<UserControlx:Class="BingMaps3DModel_WPF.ViewerPanel3D"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
mc:Ignorable="d"
d:DesignHeight="300"d:DesignWidth="300">

<UserControl.Resources>
<StyleTargetType="{x:Type TextBlock}">
<SetterProperty="HorizontalAlignment"Value="Center"/>
<SetterProperty="VerticalAlignment"Value="Center"/>
</Style>
<Stylex:Key="slider">
<SetterProperty="Slider.Orientation"Value="Vertical"/>
<SetterProperty="Slider.Height"Value="130.0"/>
<SetterProperty="Slider.HorizontalAlignment"Value="Center"/>
<SetterProperty="Slider.VerticalAlignment"Value="Center"/>
</Style>
</UserControl.Resources>

<GridBackground="Gray"MouseWheel="OnViewportMouseWheel">
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinitionWidth="100"/>
</Grid.ColumnDefinitions>
<Viewport3DName="viewport"Grid.Row="0"Grid.Column="0">
<Viewport3D.Camera>
<PerspectiveCamerax:Name="camera"FarPlaneDistance="50"
NearPlaneDistance="0"LookDirection="0,0,-10"UpDirection="0,1,0"
Position="0,0,5"FieldOfView="45">
<PerspectiveCamera.Transform>
<Transform3DGroup>
<RotateTransform3D>
<RotateTransform3D.Rotation>
<AxisAngleRotation3D
Axis="1.0, 0.0, 0.0"
Angle="{Binding ElementName=sliderX, Path=Value}"/>
</RotateTransform3D.Rotation>
</RotateTransform3D>
<RotateTransform3D>
<RotateTransform3D.Rotation>
<AxisAngleRotation3D
Axis="0.0, 1.0, 0.0"
Angle="{Binding ElementName=sliderY, Path=Value}"/>
</RotateTransform3D.Rotation>
</RotateTransform3D>
<RotateTransform3D>
<RotateTransform3D.Rotation>
<AxisAngleRotation3D
Axis="0.0, 0.0, 1.0"
Angle="{Binding ElementName=sliderZ, Path=Value}"/>
</RotateTransform3D.Rotation>
</RotateTransform3D>
<TranslateTransform3D
OffsetX="{Binding ElementName=transSliderX, Path=Value}"
OffsetY="{Binding ElementName=transSliderY, Path=Value}"
OffsetZ="{Binding ElementName=transSliderZ, Path=Value}"/>
<ScaleTransform3D
ScaleX="{Binding ElementName=sliderZoom, Path=Value}"
ScaleY="{Binding ElementName=sliderZoom, Path=Value}"
ScaleZ="{Binding ElementName=sliderZoom, Path=Value}"/>
</Transform3DGroup>
</PerspectiveCamera.Transform>
</PerspectiveCamera>
</Viewport3D.Camera>
<ModelVisual3D>

</ModelVisual3D>
<ModelVisual3Dx:Name="model">
<ModelVisual3D.Content>
<Model3DGroupx:Name="group">
<AmbientLightColor="DarkGray"/>
<DirectionalLightColor="DarkGray"Direction="10,10,5"/>
</Model3DGroup>
</ModelVisual3D.Content>
</ModelVisual3D>
</Viewport3D>

<StackPanelGrid.Column="1"Width="100"Background="LightGray">
<GroupBoxHeader="Rotation"Margin="4.0">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinition/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition/>
</Grid.RowDefinitions>
<TextBlockText="X"Grid.Column="0"Grid.Row="0"/>
<TextBlockText="Y"Grid.Column="1"Grid.Row="0"/>
<TextBlockText="Z"Grid.Column="2"Grid.Row="0"/>
<Sliderx:Name="sliderX"Grid.Column="0"Grid.Row="1"Minimum="0.0"Maximum="360.0"Value="230"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Rotate around X-Axis"/>
</Slider.ToolTip>
</Slider>
<Sliderx:Name="sliderY"Grid.Column="1"Grid.Row="1"Minimum="-180.0"Maximum="180.0"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Rotate around Y-Axis"/>
</Slider.ToolTip>
</Slider>
<Sliderx:Name="sliderZ"Grid.Column="2"Grid.Row="1"Minimum="-180.0"Maximum="180.0"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Rotate around Z-Axis"/>
</Slider.ToolTip>
</Slider>
</Grid>
</GroupBox>

<GroupBoxHeader="Translate"Margin="4.0">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinition/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition/>
</Grid.RowDefinitions>
<TextBlockText="X"Grid.Column="0"Grid.Row="0"/>
<TextBlockText="Y"Grid.Column="1"Grid.Row="0"/>
<TextBlockText="Z"Grid.Column="2"Grid.Row="0"/>
<Sliderx:Name="transSliderX"Grid.Column="0"Grid.Row="1"Minimum="-10"Maximum="10"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Translate along the X-Axis"/>
</Slider.ToolTip>
</Slider>
<Sliderx:Name="transSliderY"Grid.Column="1"Grid.Row="1"Minimum="-10"Maximum="10"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Translate along the Y-Axis"/>
</Slider.ToolTip>
</Slider>
<Sliderx:Name="transSliderZ"Grid.Column="2"Grid.Row="1"Minimum="-10"Maximum="10"Style="{StaticResource slider}">
<Slider.ToolTip>
<TextBlockText="Translate along the Z-Axis"/>
</Slider.ToolTip>
</Slider>
</Grid>
</GroupBox>

<GroupBoxHeader="Zoom"Margin="4.0">
<Sliderx:Name="sliderZoom"IsDirectionReversed="True"Minimum="0.01"Maximum="1"Value="0.8"Style="{StaticResource slider}"/>
</GroupBox>
</StackPanel>
</Grid>
</UserControl>

using System.Windows.Controls;
using System.Windows.Input;

namespace BingMaps3DModel_WPF
{
/// <summary>
/// Interaction logic for ViewerPanel3D.xaml
/// </summary>
publicpartialclass ViewerPanel3D : UserControl
    {       
public ViewerPanel3D()
        {
            InitializeComponent();
        }

privatevoid OnViewportMouseWheel(object sender, MouseWheelEventArgs e)
        {
            sliderZoom.Value -= (double)e.Delta / 1000;
        }
    }
}

Generating the Model

Having a nice panel for viewing the model is a good start but doesn’t really do us much good without having a 3D model to view. To create the 3D model we will need to do the following:

(1) Get a static map image for the based on the center point and zoom level of the map. To keep things easy, we will make keep the width and height of the image equal to 800 pixels.

(2) Based on the center point, zoom level and imagery size we will then need to calculate the bounding box of the image as we will need it to request the elevation data.

(3) Make a request for the elevation data for the bounding box we created. Again, to keep things simple we will specify that the data points be evenly distributed over 30 rows and columns. This will result in 900 elevation data points being returned which is under the 1000 elevation data point limit.

(4) We need to loop through all the elevation data, calculate the relative coordinate, and then convert this coordinate to a pixel coordinate. We will also need to convert the elevation into a pixel length and then scale these values down relative to the size of the map.

(5) Now we can create a 3D Mesh Geometry out of the data. To do this, we will need to specify all the data points as 3 dimensional coordinates, and then specify the texture coordinates used to map the static map image to the mesh. We will also need to specify the point indices used to create the triangles needed for the mesh.

(6) As a final step, we will create a Geometry Model out of the 3D Mesh and set the static image as the material to be overlaid on top of it. This model can then be passed into our ViewerPanel3D user control.

Most of the math used to work with the pixel coordinates are based off of these two articles: Bing Maps Tile System, and VE Imagery Service and Custom Icons. Putting all the above tasks together and adding them to the MainWindow.xaml.cs file you should end up with a code for the MainWindow.xaml file that looks like this:

using System;
using System.IO;
using System.Net;
using System.Runtime.Serialization.Json;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Media.Media3D;
using BingMapsRESTService.Common.JSON;

namespace BingMaps3DModel_WPF
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
publicpartialclass MainWindow : Window
    {
#region Private Properties

privatestring sessionBingMapsKey;

private GeometryModel3D mGeometry;

privateconstdouble mapSize = 800;

privatedouble topLeftX;
privatedouble topLeftY;
privatedouble zoom;

#endregion

#region Constructor

public MainWindow()
        {
            InitializeComponent();

            MyMap.CredentialsProvider.GetCredentials((x) =>
            {
                sessionBingMapsKey = x.ApplicationId;
            });
        }

#endregion

#region Button Event Handler

privatevoid Generate3DModel_Click(object sender, RoutedEventArgs e)
        {
double cLat = MyMap.Center.Latitude;
double cLon = MyMap.Center.Longitude;

//Round off the zoom level to the nearest integer as an integer zoom level is needed for the REST Imagery service
            zoom = Math.Round(MyMap.ZoomLevel);

//Only generate models when the user is zoomed in at a decent zoom level, otherwise the model will just be a flat sheet.
if (zoom < 8)
            {
                MessageBox.Show("This zoom level is not supported. Please zoom in closer (>8).");
return;
            }

//Clear current model from the viewer panel
if (mGeometry != null)
            {
                viewerPanel.group.Children.Remove(mGeometry);
            }

//Open up the 3D model tab
            MyTabs.SelectedIndex = 1;

//Calculate bounding box of image for specified zoom level and center point for map dimensions

//Retrieve image of map dimensions for the specified zoom level and center point.
string imgUrl = string.Format("http://dev.virtualearth.net/REST/v1/Imagery/Map/Aerial/{0},{1}/{2}?mapSize={3},{4}&key={5}",
                cLat,
                cLon,
                zoom,
                mapSize,
                mapSize,
                sessionBingMapsKey);

            ImageBrush imgBrush = new ImageBrush();
            imgBrush.ImageSource = new BitmapImage(new Uri(imgUrl));

            DiffuseMaterial material = new DiffuseMaterial(imgBrush);

//calcuate pixel coordinates of center point of map
double sinLatitudeCenter = Math.Sin(cLat * Math.PI / 180);
double pixelXCenter = ((cLon + 180) / 360) * 256 * Math.Pow(2, zoom);
double pixelYCenter = (0.5 - Math.Log((1 + sinLatitudeCenter) / (1 - sinLatitudeCenter)) / (4 * Math.PI)) * 256 * Math.Pow(2, zoom);

//calculate top left corner pixel coordiates of map image
            topLeftX = pixelXCenter - (mapSize / 2);
            topLeftY = pixelYCenter - (mapSize / 2);

//Calculate bounding coordinates of map view
double brLongitude, brLatitude, tlLongitude, tlLatitude;

            PixelToLatLong(new System.Windows.Point(900, 800), out brLatitude, out brLongitude);
            PixelToLatLong(new System.Windows.Point(0, 0), out tlLatitude, out tlLongitude);

//Retrieve elevation data for the specified bounding box
//Rows * Cols <= 1000 -> Let R = C = 30

string elevationUrl = string.Format("http://dev.virtualearth.net/REST/v1/Elevation/Bounds?bounds={0},{1},{2},{3}&rows=30&cols=30&key={4}",
                brLatitude,
                tlLongitude,
                tlLatitude,
                brLongitude,
                sessionBingMapsKey);

            WebClient wc = new WebClient();
            wc.OpenReadCompleted += (s, a) =>
            {
using (Stream stream = a.Result)
                {
                    DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Response));
                    Response response = ser.ReadObject(stream) as Response;

if (response != null&& 
                        response.ResourceSets != null&&
                        response.ResourceSets.Length > 0 &&
                        response.ResourceSets[0] != null&&
                        response.ResourceSets[0].Resources != null&&
                        response.ResourceSets[0].Resources.Length > 0)
                    {
                        ElevationData elevationData = response.ResourceSets[0].Resources[0] as ElevationData;

//Map elevation data to 3D Mesh
                        MeshGeometry3D mesh = new MeshGeometry3D();

double dLat = Math.Abs(tlLatitude - brLatitude) / 30;
double dLon = Math.Abs(tlLongitude - brLongitude) / 30;

double x, y, m2p;

for (int r = 0; r < 30; r++)
                        {
                            y = tlLatitude + (dLat * r);

for (int c = 0; c < 30; c++)
                            {
int idx = r * 30 + c;

                                x = tlLongitude + (dLon * c);

double z = -elevationData.Elevations[idx];

                                m2p = 156543.04 * Math.Cos(y * Math.PI / 180) / Math.Pow(2, zoom);

                                System.Windows.Point p = LatLongToPixel(y, x);
                                p.X = (p.X - 400) / mapSize;
                                p.Y = (p.Y + 400) / mapSize;

                                mesh.Positions.Add(new Point3D(p.X, p.Y, z / mapSize / m2p));

                                mesh.TextureCoordinates.Add(p);

//Create triangles for model
if (r < 29 && c < 29)
                                {
                                    mesh.TriangleIndices.Add(idx);
                                    mesh.TriangleIndices.Add(idx + 1);
                                    mesh.TriangleIndices.Add(idx + 30);

                                    mesh.TriangleIndices.Add(idx + 1);
                                    mesh.TriangleIndices.Add(idx + 31);
                                    mesh.TriangleIndices.Add(idx + 30);
                                }
                            }
                        }

//Add 3D mesh to view panel
                        mGeometry = new GeometryModel3D(mesh, material);
                        mGeometry.Transform = new Transform3DGroup();
                        viewerPanel.group.Children.Add(mGeometry);
                    }
                }
            };

            wc.OpenReadAsync(new Uri(elevationUrl));
        }

#endregion

#region Helper Methods

private System.Windows.Point LatLongToPixel(double latitude, double longitude)
        {
//Formulas based on following article:
//http://msdn.microsoft.com/en-us/library/bb259689.aspx

//calculate pixel coordinate of location
double sinLatitude = Math.Sin(latitude * Math.PI / 180);
double pixelX = ((longitude + 180) / 360) * 256 * Math.Pow(2, zoom);
double pixelY = (0.5 - Math.Log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI)) * 256 * Math.Pow(2, zoom);

//calculate relative pixel cooridnates of location
double x = pixelX - topLeftX;
double y = pixelY - topLeftY;

returnnew System.Windows.Point((int)Math.Floor(x), (int)Math.Floor(y));
        }

privatevoid PixelToLatLong(System.Windows.Point pixel, outdouble lat, outdouble lon)
        {
double x = topLeftX + pixel.X;
double y = topLeftY + pixel.Y;

            lon = (x * 360) / (256 * Math.Pow(2, zoom)) - 180;

double efactor = Math.Exp((0.5 - y / 256 / Math.Pow(2, zoom)) * 4 * Math.PI);

            lat = Math.Asin((efactor - 1) / (efactor + 1)) * 180 / Math.PI;
        }

#endregion
    }
}

Here is a screenshot of my finished application with the generated 3D model of a section of the Grand Canyon. Nice, right?

- Ricky Brundritt, EMEA Bing Maps Technology Solution Professional

I’ve been a big fan of the Bing Maps REST services since they were first released several years ago and highly recommend trying them out if you haven’t already. The REST services are much newer than the SOAP services, have more features, are faster and can be consumed by non .NET languages with greater ease. If you have the Bing Maps REST services return JSON the response size of a request is significantly smaller than the response size from the same request using the Bing Maps SOAP services. This blog post will go through and highlight some tips for getting the most out of the Bing Maps REST services.

Using the REST services in managed code

I want to take the time to provide a useful resource for those who have had issues consuming the Bing Maps REST Services APIs using .NET. The documentation on how to consume the JSON responses from the Bing Maps REST services can be found on MSDN here.

If you are using Java then take a look at how the REST services are handled in the Bing Maps Android SDK.

Geocoding

·         Unless you are geocoding English addresses in the US you should specify a culture parameter to help ensure you get the most relevant results. By default, the culture for all requests is set to en-US. If geocoding addresses in the UK, you will find that in some cases using the culture parameter en-GB will return better results. This becomes even more important when geocoding addresses that are not in English. To specify a culture in a REST request simply use “&c=cultureCode” – you can take a look at the complete list of Supported Cultures.

·        Encode address and query parameters. This is especially important when working with non-English languages as special characters often will not work correctly. This is also important if you want to use an ampersand (&) in your query. By encoding an ampersand it will appear in the URL as “%26”. Here are the methods that can be used in different programming languages to encode URL parameters.

·         When geocoding free form queries use the unstructured URL format rather than the structured format. The unstructured URL format tends to be much more successful for these types of queries. Note: the structured format actually overlaps with the reverse geocoding URL request format and can return odd results if your query is just made up of numbers.

·         The Bing Maps geocoder will attempt to find the closest match as possible to your query. In some cases, it will not be able to find an exact match. This is where the match code parameter of the returned results becomes useful. The match code parameter is an array of values and can have any combination of the following three values; Good, Ambiguous, and UpHierarchy. If you are only interested in exact matches then keep a look out for UpHierachy as this indicates that your exact query was not found but an upper level address value was found. For example, you attempt to geocode a postal code but instead the associated country is returned as the postal code was not found.

·        If using the REST services from server side code you may find that the results on in your application may differ from the results found when using the services locally. The reason for this is that the REST services take your IP address into consideration when making a request. To help reduce this issue you can set theuserIpparameter of the request to 127.0.0.1. This will trick the service into thinking you are making the call from a local application and cause it to ignore your IP address.

·         If you have a lot of data you want to geocode at once consider using the Bing Spatial Data Servicesand the batch geocoding functionality. This service allows you to geocode up to 200,000 addresses in a single request.

Reverse Geocoding

·         Limit your coordinates to 6 decimal places. At 6 decimal places you have an accuracy of approximately 10cm on the ground. Any more than 6 decimal places just makes for a longer URL and can confuse the reverse geocoder into thinking this is a free form query search.

·         Ensure that your numbers are not being turned into scientific notation format when converting them to string. This occurs quite often when working with small numbers. For example, it is not uncommon for some languages to convert 0.00005 to 5E-5.  Scientific notation is not supported by the service and will be interpreted as a free form query.

·         Ensure that when converting your coordinates to string that you use an invariant culture. Coordinates that use commas for decimal places will not work correctly.

·         Like the batch geocoder you can also do batch reverse geocoding using the Bing Spatial Data Services if you need to reverse geocode a large number of coordinates in one go.

Routing

·         Many of the tips in the geocoding service apply for the routing service, like being sure to encode your address locations. However, don’t encode coordinate based locations.

·         The default distance units are in Kilometers. Use thedistanceUnitparameter to change this to miles if that is your preferred unit of measurement.

·        You can now have up to 3 possible routes returned by the routing engine for transit and driving directions in certain countries. This may be desirable in some applications but it is best to make this optional to your users. Although the calculation on Bing Maps end is fast, the response from Bing Maps is much bigger when returning 3 routes, rather than one. This could become an issue for users with slow internet connections (i.e. mobile users).

·         If using Bing Maps in areas where geocoding coverage is limited consider allowing the user to select their start and end point on the map via a click event or by dragging a pushpin. This will allow you to pass in coordinates for your end points rather than an address. The routing engine is capable of calculating routes anywhere there is road data, even if there is no geocoding coverage.

·         If you want to retrieve the coordinates that make up the route line along the roads use the routePathOutputparameter.

Imagery Service

·         When requesting a static map image from Bing Maps the imagery service the service will automatically choose the best image format to return the image in for best resolution. Note: this may not be the preferred image type in some cases. For example, the service may return Ordnance Survey maps in PNG format; you may find you prefer these maps returned as JPG of GIF format. You can specify the image type using the formatparameter.

·         The Imagery service can return two different types of metadata. The first typeof metadata gives you information about the imagery in Bing Maps for a specific location, zoom level and map type. This is useful if you want to find out the age of the imagery or want to know is a specific type of imagery is available for a certain location. The second typeof metadata is for a static image generated from the imagery service. This second metadata may include information such as pixel coordinates of pushpins on your image. This is useful if you want to be able to tie events to the generated image or create an HTML image mapout of it.

Reducing Usage Transactions

Are you are using the Bing Maps Rest services in conjunction with one of the Bing Maps map controls? If so, you can significantly reduce the number of transactions your application incurs against your Bing Maps account if you request the Bing Maps key from the map control rather than using your normal Bing Maps key. This is quite often an overlooked feature. When getting the credentials from the map you do not get back your original Bing Maps key. Instead, you get a special session key which you can use as a Bing Maps key to make requests to the Bing Maps services. By doing this all transactions incurred by this session key will be non-billable. Here are some examples of how to properly use a session key.

Full working sample using JavaScript can be found here.

You are invited to attend this webcast to learn how solutions that integrate Bing Maps and SharePoint help organizations gain greater insight from their business data to make smarter business decisions. We will also explore new native geospatial support for SharePoint 2013 and Office 365 (SharePoint in the cloud) which makes it much easier to geocode address data and display with Bing Maps. We’ll explore solution scenarios and tools that illustrate the value of geospatial support in SharePoint when combined with Bing Maps, and look at examples of customers extending their investment in the SharePoint platform by leveraging location and Bing Maps.

You’ll learn what’s included in the Bing Maps platform, and how to take advantage of the data services & imagery and incorporate them into line of business solutions within your organization. We will explore the development options with the platform, and how to get started with Bing Maps and SharePoint 2013/Office 365 development.

Webcast Details

Bing Maps and SharePoint Solutions for the Enterprise (EPG382CAL)

Date/Time:

Tue Feb 26, 2013, 9:00 AM, USA Pacific

Duration:

1 Hour

Presenters:

Mark Merchant, Bing Maps Technical Solution Professional

Ricky Brundritt, Bing Maps Technical Solution Professional

Scott Caulk, VP of Product Management for IDV Solutions

Steve Milroy, CEO OnTerra Systems

The Bing Maps V7 AJAX control is designed as a modular framework and the Bing Maps for Windows Store App JavaScript control follows the same design. Modules allow users to load only the features and functionalities they need, rather than loading everything up when the application starts. You can save yourself a lot of development time by using modules and avoid reinventing the wheel. Out of the box, Bing Maps provides the following modules:

In addition to the modules available through the Bing Maps control, there are a large number of community created modules also available on the Bing Maps V7 Modules CodePlex project. However, not all community created modules are designed to work with Windows Store applications; you may need to make some modifications to get them to work with your code. You can also create custom modules, which is a really great way to promote code reuse. For the purpose of this post, we will build on top of the code we created in the Getting started with Bing Maps Windows Store Apps blog post.

Implementing Modules

There are three steps:

1. Add a reference to the veapimodules.js file from the Bing Maps SDK
2. Register the module if it isn’t already registered
3. Load the module and run any post load logic

To add a reference to the veapimodules.js file in the Bing Maps SDK, open the default.html file and update the Bing Maps references to the following:

Now, before you can load a module, it must first be registered. All modules built into Bing Maps are already registered, however, if you are using a custom module you will need to register it. If you have used custom modules before, be warned, registeringthe web version of the Bing Maps V7 AJAX control and registering modules in the Windows Store App version of the Bing Maps JavaScript control are done differently. Registering custom modules is pretty straightforward; simply add a line of code to register the name and load in the JavaScript file containing your module code. You can do this by adding code, similar to the example below, into the head of the default.html page.

One benefit of this approach is that the JavaScript file for our module will be cached as byte code by the Windows 8 framework, which makes for fast loading. However, it doesn’t have the same benefit of being able to load the code for the module on demand which we were are able to do with the built in modules. This is useful when you want the fastest possible startup for your application. With a bit of code we can use JavaScript to dynamically load our custom modules. Here is a simple function we can use to accomplish this:

Now that the module is registered, we can load it. When to load a module really depends on the type of module you are using. For instance, the Bing Theme module needs to be loaded before the map is loaded, however the directions module doesn’t need to be loaded until the user wants to get directions. Here is the basic way of loading a module:

With some modules you may want to run code after the module has loaded. In this case, you can pass in a callback function as an option when loading the module. Doing the following will trigger a function called myModuleLoaded when the module has completed loading.

Loading the Traffic Module

Now that we understand how to use the module framework in the Bing Maps control, lets implement the traffic module in our application. To start, we will add a checkbox on the map for toggling the traffic layer on and off. First, open the default.html file and the checkbox to the same floating div that has our GPS checkbox. This time we are going to give the checkbox an id property.

Since the traffic module is a built in module in the Bing Maps SDK we do not need to worry about registering it. We also don’t need to load the traffic module until the user presses the Traffic checkbox. To add the logic for traffic checkbox open the bingMapsIntro.js file and add a global variable called trafficLayer. Next, add a function called ToggleTraffic. In this function we will check to see the trafficLayer variable is implemented. If it is, then we can get the checked state from the traffic checkbox and show or hide the traffic layer accordingly. If the trafficLayer variable is not implemented we will need to load the traffic module and create an instance of the Microsoft.Maps.Traffic.TrafficLayer class after the module has loaded. By default, the traffic tile layer has no opacity to it and it ends up covering up the names of roads. To make for a better user experience we will get the base tile layer of the traffic layer and set it’s opacity to 0.5. Finally, after we created an instance of the TrafficLayer class we will want to rerun our logic for toggling the traffic layer. To do all this, add the following code into the bingMapsIntro.js file.

If you run the application now and press the traffic button you may not notice anything if you are zoomed out. To make things easy, I’m going to toggle on both the GPS and the Traffic functionalities. Doing this I end up with the following map:

For more information on where traffic data is available see the Bing Maps Traffic Coverage section of the MSDN documentation.

Loading a Custom Module

We have seen how to load one of the built in modules to our application, now we will look at how to implement a custom module. To do this we will make use of one of the community created modules called Point Based Clustering. This module will group pushpins together when zoomed out to make the map less crowded. This particular module uses a point based algorithm rather than a traditional grid based one. The point based algorithm gives use a much nicer user experience than the grid based algorithm, but there is a trade off in performance. With that said, this algorithm can easily handle 2,000+ pushpins.

Since this module is not really related to what we have put together in our Bing Maps Intro project we will start fresh with a new project. In Visual Studios create a new project and use the JavaScript -> Store -> Blank App template. Call the project PointBasedClustering_WinRT. Once the application is loaded, right click on the js folder and add a new JavaScript file called bingMapsClustering.js. Next, right click on the References folder and add a reference to the Bing Maps SDK. Now, go to the Point Based Clustering page and download the code. Unzip the file and copy the scripts/minified/PointBasedClustering.min.js and the scripts/TestDataGenerator.js files into the js folder of the project. After you do this your project should look like this:

Now we can get started on implementing this custom module. To start, we will open up the default.html file and add a textbox and a button to a floating div in the top, right hand corner of our map where the user can enter the number of pushpins to add to the map. When the button is clicked it will generate the mock pushpin data and display it on the map and clustering it automatically. We will also need to add a reference to the TestDataGenerator.js file for this example. In a production application you would not need this as you would use real data with the Point Based Clustering module. Adding this to the default.html file we end up with the following HTML:

Now, open the bingMapsClustering.js file, add the following code to load the map, and register and load the Point Based Clustering Module. We will register our module right after loading the map in the GetMap function.