BingMaps RouteService

Home » Dev » BingMaps RouteService

BingMaps RouteService

25. Mai 2011

Einführung

In meinen ersten beiden Blog-Beiträgen Microsoft Bing Maps for Enterprise und BingMaps GeocodeService, habe ich über die Darstellung von Punkten auf einer BingMaps-Karte gesprochen. Im Gegensatz zu dem ersten Blog-Beitrag wurde im Zweiten der WebService “GeocodeService” mit eingebunden, der sich über den Webservice die Koordinaten des gesuchten Ortes/Punktes holt.

Microsoft bietet aber 3 verschiedene WebServices für die Darstellung von Punkten, Linien oder Bereichen auf Karten an. Diese wären

GeocodeService (Punkte)
RouteService (Punkte, Linien)
SearchService (Punkte)

In diesem Blog Beitrag möchte ich die Verwendung des RouteService in BingMaps erläutern.

Wozu verwende ich den RouteService?

Mit Hilfe des Route Service wird eine Abfrage an den Webservice gestellt, der die Koordinaten (Längen- und Breitengrad im Format WGS84) der Eckpunkte für die zu berechnende Route zurückliefert. Bei diesem RouteService kann die Unterscheidung erfolgen, ob die Route/Strecke mit einem Fahrzeug (z.B. Auto) oder zu Fuß (Wanderstrecke) zurückgelegt werden soll. Des Weiteren kann noch unterschieden werden, ob Autobahnen genutzt oder vermieden werden sollen. Diesbezüglich verändert sich auch der Verlauf der Route/Strecke.

Eine Verwendung des RouteService bietet sich insbesondere für die Berechnung von Routenplanungen für den Güterverkehr an.

Voraussetzungen

BingMaps-Key
Visual Studio
Silverlight

Falls Sie noch keinen BingMaps-Key haben, können Sie sich hier einen erstellen.

Silverlight-Applikation

Als erster Schritt wird eine neue Silverlight-Applikation erstellt und der GeocodeService als Service Reference hinzugefügt. Hierzu klicken Sie mit der rechten Maustaste auf das Projekt und wählen Add Service Reference. Geben Sie als Adresse http://dev.virtualearth.net/webservices/v1/GeocodeService/GeocodeService.svc ein und klicken auf Go. Nennen Sie den Namespace GeocodeService. Wiederholen Sie diesen Schritt mit der Adresse http://dev.virtualearth.net/webservices/v1/RouteService/RouteService.svc. Nennen Sie den Namespace RouteService.

Im nächsten Schritt werden zwei Textboxen zum Eingeben der Start- und Zieladresse, zwei RadioButton für die Auswahl des Routenmodus (Auto, Fußgänger) und ein Button zum Starten der Routenberechnung erstellt. Des Weiteren werden noch ein Textblock zum Ausgeben der Entfernung/Distanz und eine Karte zum Darstellen der Suchergebnisse erstellt.

<Grid x:Name="LayoutRoot" Background="White" HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
 <Grid.RowDefinitions>
  <RowDefinition Height="auto" />
  <RowDefinition Height="*" />
 </Grid.RowDefinitions>
 <StackPanel Grid.Row="0">
  <TextBlock Text="Geben Sie den Start- und den Zielpunkt ein!" FontSize="13" TextWrapping="Wrap" />
  <Grid>
   <Grid.RowDefinitions>
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
    <RowDefinition />
   </Grid.RowDefinitions>
   <Grid.ColumnDefinitions>
    <ColumnDefinition Width="auto" />
    <ColumnDefinition Width="500" />
    <ColumnDefinition Width="auto" />
    <ColumnDefinition Width="auto" />
    <ColumnDefinition Width="auto" />
   </Grid.ColumnDefinitions>
   <TextBlock Text="Start:" Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" FontSize="10" />
   <TextBox x:Name="inputStart" Grid.Row="0" Grid.Column="1" KeyDown="input_KeyDown" GotFocus="inputStart_GotFocus" Width="500" Text="Borsigallee 19, Frankfurt am Main" FontSize="13" />
   <TextBlock x:Name="outputStart" Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="4" FontSize="10" Foreground="Black" Margin="14,0,0,0" VerticalAlignment="Center" />
   <TextBlock Text="Ziel:" Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" FontSize="10" />
   <TextBox x:Name="inputZiel" Grid.Row="1" Grid.Column="1" KeyDown="input_KeyDown" GotFocus="inputZiel_GotFocus" Width="500" Text="Landwehrstraße 61, München" FontSize="13" />
   <Button Content="Route berechnen" Grid.Row="1" Grid.Column="2" Click="Button_Click" />
   <RadioButton x:Name="rdbDriving" Grid.Row="0" Grid.Column="2" Content="Auto" />
   <RadioButton x:Name="rdbWalking" Grid.Row="0" Grid.Column="3" Content="Fußgänger" />
   <TextBlock x:Name="outputZiel" Grid.Row="1" Grid.Column="3" FontSize="10" Foreground="Black" Margin="14,0,0,0" VerticalAlignment="Center" />
   <TextBlock Text="Entfernung" Grid.Row="3" Grid.Column="0" VerticalAlignment="Center" FontSize="10"/>
   <TextBlock x:Name="outputDistance" Grid.Row="3" Grid.Column="1" FontSize="13" Foreground="Black" FontWeight="Bold" Margin="14,0,0,0" VerticalAlignment="Center" />
  </Grid>
 </StackPanel>
 <StackPanel Grid.Row="1">
  <Grid>
   <Grid.ColumnDefinitions>
    <ColumnDefinition Width="*" />
    <ColumnDefinition Width="auto" />
   </Grid.ColumnDefinitions>
   <map:Map x:Name="routedMap" CredentialsProvider="<Your Key>" Culture="de-de" Grid.Column="0" Margin="0,0,10,0" CopyrightVisibility="Collapsed" ScaleVisibility="Collapsed" NavigationVisibility="Collapsed">
    <map:MapLayer x:Name="RouteLayer" />
    <map:MapLayer x:Name="ContentPopupLayer">
     <Canvas x:Name="ContentPopup" Visibility="Collapsed" Opacity="0.85" MouseEnter="ContentPopup_MouseEnter" MouseLeave="ContentPopup_MouseLeave">
      <Rectangle x:Name="ContentPopupRectange" Fill="White" Canvas.Left="0" Canvas.Top="0" Height="100" Width="300" RadiusX="20" RadiusY="20" />
      <StackPanel Canvas.Left="10" Canvas.Top="10">
       <TextBlock x:Name="ContentPopupText" FontSize="12" FontWeight="Bold" TextWrapping="Wrap" Width="250" />
      </StackPanel>
     </Canvas>
    </map:MapLayer>
   </map:Map>
   <TextBlock x:Name="outputRoute" Grid.Column="1" />
  </Grid>
 </StackPanel>
</Grid>

In den beiden nachfolgenden Funktionen werden die Services GeocodeService und RouteService aufgerufen.

private GeocodeService.GeocodeServiceClient geocodeClient;
private GeocodeService.GeocodeServiceClient GeocodeClient
{
  get
  {
    if (null == geocodeClient)
    {
      //Handle http/https; OutOfBrowser is currently supported on the MapControl only for http pages
      bool httpsUriScheme = !Application.Current.IsRunningOutOfBrowser && HtmlPage.Document.DocumentUri.Scheme.Equals(Uri.UriSchemeHttps);
      BasicHttpBinding binding = new BasicHttpBinding(httpsUriScheme ? BasicHttpSecurityMode.Transport : BasicHttpSecurityMode.None);
      UriBuilder serviceUri = new UriBuilder("http://dev.virtualearth.net/webservices/v1/GeocodeService/GeocodeService.svc");
      if (httpsUriScheme)
      {
        //For https, change the UriSceheme to https and change it to use the default https port.
        serviceUri.Scheme = Uri.UriSchemeHttps;
        serviceUri.Port = -1; 
      }
  
      //Create the Service Client
      geocodeClient = new GeocodeService.GeocodeServiceClient(binding, new EndpointAddress(serviceUri.Uri));
      geocodeClient.GeocodeCompleted += new EventHandler<GeocodeService.GeocodeCompletedEventArgs>(client_GeocodeCompleted);
    }
    return geocodeClient;
  }
}
  
private RouteService.RouteServiceClient routeClient;
private RouteService.RouteServiceClient RouteClient
{
  get
  {
    if (null == routeClient)
    {
      //Handle http/https; OutOfBrowser is currently supported on the MapControl only for http pages
      bool httpsUriScheme = !Application.Current.IsRunningOutOfBrowser && HtmlPage.Document.DocumentUri.Scheme.Equals(Uri.UriSchemeHttps);
      BasicHttpBinding binding = new BasicHttpBinding(httpsUriScheme ? BasicHttpSecurityMode.Transport : BasicHttpSecurityMode.None);
      binding.MaxReceivedMessageSize = int.MaxValue;
      binding.MaxBufferSize = int.MaxValue;
      UriBuilder serviceUri = new UriBuilder("http://dev.virtualearth.net/webservices/v1/RouteService/RouteService.svc");
      if (httpsUriScheme)
      {
        //For https, change the UriSceheme to https and change it to use the default https port.
        serviceUri.Scheme = Uri.UriSchemeHttps;
        serviceUri.Port = -1; 
      }
  
      //Create the Service Client
      routeClient = new RouteService.RouteServiceClient(binding, new EndpointAddress(serviceUri.Uri));
      routeClient.CalculateRouteCompleted += new EventHandler<RouteService.CalculateRouteCompletedEventArgs>(client_RouteCompleted);
    }
    return routeClient;
  }
}

Mit der Funktion GeocodeAddress werden die Koordinaten für die beiden Punkte (Start- und Zieladresse) vom Webservice abgerufen.

private void GeocodeAddress(string address, RoutingState state)
{
  var request = new GeocodeService.GeocodeRequest
  {
    ExecutionOptions = new GeocodeService.ExecutionOptions { SuppressFaults = true },
    Culture = routedMap.Culture,
    Query = address
  };
 
  // Only accept results with high confidence.
  request.Options = new GeocodeService.GeocodeOptions();
  // Using ObservableCollection since this is the default for Silverlight proxy generation.
  request.Options.Filters = new ObservableCollection<GeocodeService.FilterBase>();
  GeocodeService.ConfidenceFilter filter = new GeocodeService.ConfidenceFilter();
  filter.MinimumConfidence = GeocodeService.Confidence.High;
  request.Options.Filters.Add(filter);
 
  if (null != state.output)
  {
    state.output.Text = "<Berechnung wird durchgeführt>";
    state.output.Foreground = new SolidColorBrush(Colors.Black);
  }
 
  routedMap.CredentialsProvider.GetCredentials(
    (Credentials credentials) =>
  {
    // Pass in credentials for web services call. Replace with your own Credentials.
    request.Credentials = credentials;
 
    // Make asynchronous call to fetch the data ... pass state object.
    GeocodeClient.GeocodeAsync(request, state);
  });
}

private object lockObject = new object();
private void client_GeocodeCompleted(object sender, GeocodeService.GeocodeCompletedEventArgs e)
{
  RoutingState state = e.UserState as RoutingState;
  GeocodeService.GeocodeResult result = null;
  string outString;
  
  try
  {
    if (e.Result.ResponseSummary.StatusCode != GeocodeService.ResponseStatusCode.Success)
    {
      outString = "Fehler bei der Berechnung ... Status <" + e.Result.ResponseSummary.StatusCode.ToString() + ">";
    }
    else if (0 == e.Result.Results.Count)
    {
      outString = "Kein Ergebnis";
    }
    else
    {
      // Only report on first result.
      result = e.Result.Results[0];
      outString = result.DisplayName;
    }
  }
  catch (Exception)
  {
    outString = "Exception raised";
  }
          
  // Update UI with geocode result.
  if (null != state.output)
  {
    state.output.Text = outString;
  }
  
  if (null == result)
  {
    result = new GeocodeService.GeocodeResult();
  }
  
  // Update state object ... when all the results are set, call route.
  bool doneGeocoding;
  lock (lockObject)
  {
    state.results[state.locationNumber] = result;
    doneGeocoding = state.GeocodesComplete;
  }
  
  if (doneGeocoding && state.GeocodesSuccessful)
  {
    //Clear any existing routes
    ClearRoute();
  
    //Calculate the route
    CalculateRoute(state.results);
  }
}

private RouteService.Waypoint GeocodeResultToWaypoint(GeocodeService.GeocodeResult result)
{
  var waypoint = new RouteService.Waypoint
  {
    Description = result.DisplayName,
    Location = new Location { Latitude = result.Locations[0].Latitude, Longitude = result.Locations[0].Longitude }
  };
  return waypoint;
}

Die beiden nachfolgenden Funktionen CalculateRoute und client_RouteCompleted, die wir nun erstellen, berechnen die Fahr- bzw. Laufstrecke der Route und geben entscheidende Eckpunkte (z.B. hier abbiegen, geradeaus fahren, usw…) zurück. Diese beinhalten die Koordinaten sowie Anweisungen.

private void CalculateRoute(GeocodeService.GeocodeResult[] locations)
{
  var request = new RouteService.RouteRequest
  {
    Culture = routedMap.Culture,
    Waypoints = new ObservableCollection<RouteService.Waypoint>(),
    ExecutionOptions = new RouteService.ExecutionOptions { SuppressFaults = true },
    Options = new RouteService.RouteOptions { RoutePathType = RouteService.RoutePathType.Points }
  };
  
  foreach (GeocodeService.GeocodeResult result in locations)
  {
    request.Waypoints.Add(GeocodeResultToWaypoint(result));
  }
  
  //Wenn “Auto” ausgewählt ist
  if (rdbDriving.IsChecked == true)
  {
    request.Options.Mode = RouteService.TravelMode.Driving;
  }
  //Wenn “Fußgänger” ausgewählt ist
  else if (rdbWalking.IsChecked == true)
  {
    request.Options.Mode = RouteService.TravelMode.Walking;
  }
  //Wenn weder “Auto” noch “Fußgänger” ausgewählt ist, dann gib eine Infobox aus
  else
  {
    MessageBox.Show("Bitte wählen Sie Auto oder Fußgänger aus!");
  }
  
  // Now that both locations were found ... use "to" for routing update.
  outputStart.Text += " --> " + outputZiel.Text;
  outputZiel.Text += " ... <routing>";
  
  routedMap.CredentialsProvider.GetCredentials(
    (Credentials credentials) =>
  {
    //Pass in credentials for web services call. Replace with your own Credentials.
    request.Credentials = credentials;
                
    // Make asynchronous call to fetch the data ... pass state object.
    RouteClient.CalculateRouteAsync(request);
  });
}

private void client_RouteCompleted(object sender, RouteService.CalculateRouteCompletedEventArgs e)
{
  string outString;
  try
  {
    if (e.Result.ResponseSummary.StatusCode != RouteService.ResponseStatusCode.Success)
    {
      outString = "Fehler bei der Berechnung ... Status <" + e.Result.ResponseSummary.StatusCode.ToString() + ">";
    }
    else if (0 == e.Result.Result.Legs.Count)
    {
      outString = "Kann keine Route berechnen";
    }
    else
    {
      double distance = e.Result.Result.Summary.Distance;
      outputDistance.Text = distance.ToString() + " km";
                    
      Color routeColor = Colors.Blue;
      SolidColorBrush routeBrush = new SolidColorBrush(routeColor);
      outString = "Route berechnet";
      outputZiel.Foreground = routeBrush;
  
      var routeLine = new MapPolyline
      {
        Stroke = routeBrush,
        Opacity = 0.65,
        StrokeThickness = 5.0
      };
  
      routeLine.Locations = new LocationCollection();
      foreach (Location p in e.Result.Result.RoutePath.Points)
      {
        routeLine.Locations.Add(new Location(p.Latitude, p.Longitude));
      }
      RouteLayer.Children.Add(routeLine);
      LocationRect rect = new LocationRect(routeLine.Locations[0], routeLine.Locations[routeLine.Locations.Count - 1]);
                                  
      int i = 1;
      int anz = e.Result.Result.Legs[0].Itinerary.Count;
      foreach (RouteService.ItineraryItem itineraryItem in e.Result.Result.Legs[0].Itinerary)
      {
        var point = new Ellipse
        {
          Width = 10,
          Height = 10,
          DataContext = i,
          Opacity = 0.65,
          Tag = itineraryItem
        };
  
        if (i == 1) 
        { 
          point.Fill = new SolidColorBrush(Colors.Green);
          point.Width = 20;
          point.Height = 20;
        }else if(i == anz)
        {
          point.Fill = new SolidColorBrush(Colors.Red);
          point.Width = 20;
          point.Height = 20;
        }
        else
        {
          point.Fill = new SolidColorBrush(Colors.Yellow);
          point.Width = 15;
          point.Height = 15;
        }
        Location location = new Location(itineraryItem.Location.Latitude, itineraryItem.Location.Longitude);
        MapLayer.SetPosition(point, location);
        MapLayer.SetPositionOrigin(point, PositionOrigin.Center);
  
        RouteLayer.Children.Add(point);
        i++;
      }
      routedMap.SetView(rect);
    }
  }
  catch (Exception)
  {
    outString = "Exception raised routine";
  }
  outputZiel.Text = outString;
}

private void GetRoute()
{
  bool errorFound = false;
  
  if (string.IsNullOrEmpty(inputZiel.Text))
  {
    outputZiel.Text = "Bitte eine Zieladresse eingeben!";
    errorFound = true;
  }
  if (string.IsNullOrEmpty(inputStart.Text))
  {
    outputStart.Text = "Bitte eine Startadresse eingeben!";
    errorFound = true;
  }
  if (errorFound)
  {
    return;
  }
  
  // Geocode locations in parallel.
  GeocodeService.GeocodeResult[] results = new GeocodeService.GeocodeResult[2];
  // From location.
  RoutingState state0 = new RoutingState(results, 0, outputStart);
  GeocodeAddress(inputStart.Text, state0);
  // To location.
  RoutingState state1 = new RoutingState(results, 1, outputZiel);
  GeocodeAddress(inputZiel.Text, state1);
}

internal class RoutingState
{
  internal RoutingState(GeocodeService.GeocodeResult[] resultArray, int index, TextBlock tb)
  {
    results = resultArray;
    locationNumber = index;
    output = tb;
  }
 
  internal bool GeocodesComplete
  {
    get
    {
      for (int idx = 0; idx < results.Length; idx++)
      {
        if (null == results[idx])
        return false;
      }
      return true;
    }
  }
 
  internal bool GeocodesSuccessful
  {
    get
    {
      for (int idx = 0; idx < results.Length; idx++)
      {
        if (null == results[idx] || null == results[idx].Locations || 0 == results[idx].Locations.Count)
        {
          return false;
        }
      }
      return true;
    }
  }
 
  internal GeocodeService.GeocodeResult[] results;
  internal int locationNumber;
  internal TextBlock output;
}

Abschließend muss noch eine Methode für den Button Route berechnen geschrieben werden, der die Berechnung der Route startet.

private void Button_Click(object sender, RoutedEventArgs e)
{
  GetRoute();
}
  
private void inputZiel_GotFocus(object sender, RoutedEventArgs e)
{
  inputZiel.SelectAll();
}
  
private void inputStart_GotFocus(object sender, RoutedEventArgs e)
{
  inputStart.SelectAll();
}
  
private void input_KeyDown(object sender, KeyEventArgs e)
{
  if (e.Key == Key.Enter)
  {
    GetRoute();
  }
}

Ergebnis

Starten Sie nun die Solution und geben Sie eine Start- und eine Zieladresse ein. Klicken Sie anschließend auf Route berechnen um den RouteService anzusprechen.

In dem folgenden Screenshot kann man erkennen, dass nachdem ich Start- und Zieladresse eingeben, Streckenmodus (hier: Auto) ausgewählt und auf den Button Route berechnen gedrückt habe, oberhalb der Karte die Entfernung und in der Karte mehrere verschieden farbige Punkte erstellt wurden. Hierbei wird der Startpunkt grün, der Endpunkt rot und die Zwischenpunkte gelb dargestellt. Wenn man mit dem Mauszeiger auf einen Punkt geht, werden der Name und die Beschreibung des Punktes angezeigt.

Rechts neben der Karte kann man den Verlauf der Strecke ablesen.

In meinem nächsten Blog-Beitrag werde ich die Verwendung des SearchService in BingMaps erläutern.