fix(routing): Use GraphHopper for follow streets routing

landonreed · landonreed · commit fda749c69d36 · 2018-01-29T13:00:21.000-05:00
Mapzen (and thus the valhalla routing service) is no longer in operation. This addresses #60, but needs to be cherry-picked into a separate branch for merging into dev. refs #60 Conflicts: lib/scenario-editor/utils/valhalla.js
diff --git a/configurations/default/env.yml.tmp b/configurations/default/env.yml.tmp
@@ -5,3 +5,4 @@ MAPBOX_ACCESS_TOKEN: test-access-token
 MAPBOX_MAP_ID: mapbox.streets
 MAPBOX_ATTRIBUTION: <a href="https://www.mapbox.com/about/maps/" target="_blank">&copy; Mapbox &copy; OpenStreetMap</a> <a href="https://www.mapbox.com/map-feedback/" target="_blank">Improve this map</a>
 # R5_URL: http://localhost:8080
+GRAPH_HOPPER_KEY: graph-hopper-routing-key
diff --git a/lib/scenario-editor/utils/valhalla.js b/lib/scenario-editor/utils/valhalla.js
@@ -4,6 +4,7 @@ import fetch from 'isomorphic-fetch'
 import {decode as decodePolyline} from 'polyline'
 import {isEqual as coordinatesAreEqual} from '@conveyal/lonlat'
 import lineString from 'turf-linestring'
+import lineSliceAlong from '@turf/line-slice-along'
 
 import type {
   Coordinates,
@@ -77,7 +78,81 @@ type ValhallaResponse = {
   }
 }
 
-export function route (points: Array<LatLng>): ?Promise<ValhallaResponse> {
+/**
+ * Convert GraphHopper routing JSON response to polyline.
+ */
+function handleGraphHopperRouting (json, individualLegs = false) {
+  if (json && json.paths && json.paths[0]) {
+    const decodedPolyline = decodePolyline(json.paths[0].points)
+      .map(coordinate => ([coordinate[1], coordinate[0]]))
+    // console.log('decoded polyline', json.paths[0].points, decodedPolyline)
+    if (individualLegs) {
+      // Reconstruct individual legs from the instructions. NOTE: we do not simply
+      // use the waypoints found in the response because for lines that share
+      // street segments, slicing on these points results in unpredictable splits.
+      // Slicing the line along distances is much more reliable.
+      const segments = []
+      const waypointDistances = [0]
+      let distance = 0
+      json.paths[0].instructions.forEach(instruction => {
+        // Iterate over the instructions, accumulating distance and storing the
+        // distance at each waypoint encountered.
+        if (instruction.text.match(/Waypoint (\d+)/)) {
+          // console.log(`adding waypoint ${waypointDistances.length} at ${distance} meters`)
+          waypointDistances.push(distance)
+        } else {
+          distance += instruction.distance
+        }
+      })
+      // Add last distance measure.
+      // FIXME: Should this just be the length of the entire line?
+      // console.log(waypointDistances, json.paths[0].distance)
+      waypointDistances.push(distance)
+      const decodedLineString = lineString(decodedPolyline)
+      if (waypointDistances.length > 2) {
+        for (var i = 1; i < waypointDistances.length; i++) {
+          const slicedSegment = lineSliceAlong(
+            decodedLineString,
+            waypointDistances[i - 1] / 1000,
+            waypointDistances[i] / 1000
+          )
+          segments.push(slicedSegment.geometry.coordinates)
+        }
+        // console.log('individual legs', segments)
+        return segments
+      } else {
+        // FIXME does this work for two input points?
+        return [decodedPolyline]
+      }
+    } else {
+      return decodedPolyline
+    }
+  } else {
+    return null
+  }
+}
+
+/**
+ * Convert Mapzen routing JSON response to polyline.
+ */
+export function handleMapzenRouting (json, individualLegs = false) {
+  if (json && json.trip) {
+    const legArray = json.trip.legs.map((leg, index) => {
+      return decodePolyline(leg.shape)
+        .map((c, index) => [c[1] / 10, c[0] / 10]) // Mapzen or Mapbox is encoding/decoding wrong?
+    })
+    return individualLegs
+      ? legArray
+      : [].concat.apply([], legArray)
+  } else {
+    return null
+  }
+}
+
+/**
+ * Call Mapzen routing service with set of lat/lng coordinates.
+ */
+export function routeWithMapzen (points: Array<LatLng>): ?Promise<ValhallaResponse> {
   if (points.length < 2) {
     console.warn('need at least two points to route with mapzen', points)
     return null
@@ -98,26 +173,28 @@ export function route (points: Array<LatLng>): ?Promise<ValhallaResponse> {
   ).then(res => res.json())
 }
 
+/**
+ * Route between two or more points using external routing service.
+ * @param  {[type]} points         array of two or more LatLng points
+ * @param  {[type]} individualLegs whether to return coordinates as set of
+ *                                 distinct segments for each pair of points
+ * @param  {[type]} useMapzen      FIXME: not implemented. boolean to select service to use.
+ * @return {[type]}                Array of coordinates or Array of arrays of coordinates.
+ */
 export async function polyline (
-  points: Array<LatLng>
+  points: Array<LatLng>,
+  individualLegs: boolean = false,
+  useMapzen: boolean = true
 ): Promise<?Array<[number, number]>> {
   let json
   try {
-    json = await route(points)
+    json = await routeWithGraphHopper(points)
   } catch (e) {
     console.log(e)
     return null
   }
-
-  if (json && json.trip) {
-    const legArray = json.trip.legs.map((leg, index) => {
-      return decodePolyline(leg.shape)
-        .map((c, index) => [c[1] / 10, c[0] / 10]) // Mapzen or Mapbox is encoding/decoding wrong?
-    })
-    return [].concat.apply([], legArray)
-  } else {
-    return null
-  }
+  const geometry = handleGraphHopperRouting(json, individualLegs)
+  return geometry
 }
 
 export async function getSegment (
@@ -128,19 +205,24 @@ export async function getSegment (
   type: 'LineString',
   coordinates: Coordinates
 }> {
+  // Store geometry to be returned here.
   let geometry
   if (followRoad) {
-    // if followRoad
+    // if snapping to streets, use routing service.
     const coordinates = await polyline(
       points.map(p => ({lng: p[0], lat: p[1]}))
-    ) // [{lng: from[0], lat: from[1]}, {lng: to[0], lat: to[1]}])
+    )
     if (!coordinates) {
+      // If routing was unsuccessful, default to straight line (if desired by
+      // caller).
+      console.warn(`Routing unsuccessful. Returning ${defaultToStraightLine ? 'straight line' : 'null'}.`)
       if (defaultToStraightLine) {
         geometry = lineString(points).geometry
       } else {
         return null
       }
     } else {
+      // If routing is successful, clean up shape if necessary
       const c0 = coordinates[0]
       const epsilon = 1e-6
       if (!coordinatesAreEqual(c0, points[0], epsilon)) {
@@ -152,7 +234,63 @@ export async function getSegment (
       }
     }
   } else {
+    // If not snapping to streets, simply generate a line string from input
+    // coordinates.
     geometry = lineString(points).geometry
   }
   return geometry
 }
+
+/**
+ * Call GraphHopper routing service with lat/lng coordinates.
+ */
+export function routeWithGraphHopper (points: Array<LatLng>): ?Promise<any> {
+  // https://graphhopper.com/api/1/route?point=49.932707,11.588051&point=50.3404,11.64705&vehicle=car&debug=true&&type=json
+  if (points.length < 2) {
+    console.warn('need at least two points to route with graphhopper', points)
+    return null
+  }
+  if (!process.env.GRAPH_HOPPER_KEY) {
+    throw new Error('GRAPH_HOPPER_KEY not set')
+  }
+  const GRAPH_HOPPER_KEY: string = process.env.GRAPH_HOPPER_KEY
+  const locations = points.map(p => (`point=${p.lat},${p.lng}`)).join('&')
+  return fetch(
+    `https://graphhopper.com/api/1/route?${locations}&key=${GRAPH_HOPPER_KEY}&vehicle=car&debug=true&&type=json`
+  ).then(res => res.json())
+}
+
+/**
+ * Call Mapbox routing service with set of lat/lng coordinates.
+ */
+export function routeWithMapbox (points: Array<LatLng>): ?Promise<any> {
+  if (points.length < 2) {
+    console.warn('need at least two points to route with mapbox', points)
+    return null
+  }
+  if (!process.env.MAPBOX_ACCESS_TOKEN) {
+    throw new Error('MAPBOX_ACCESS_TOKEN not set')
+  }
+  const MAPBOX_ACCESS_TOKEN: string = process.env.MAPBOX_ACCESS_TOKEN
+  // const locations = points.map(p => ({lon: p.lng, lat: p.lat}))
+  const locations = points.map(p => (`${p.lng},${p.lat}`)).join(';')
+  return fetch(
+    `https://api.mapbox.com/directions/v5/mapbox/driving/${locations}.json?access_token=${MAPBOX_ACCESS_TOKEN}`
+  ).then(res => res.json())
+}
+
+// /**
+//  * Convert Mapbox routing JSON response to polyline.
+//  */
+// function handleMapboxRouting (json) {
+//   if (json && json.routes && json.routes[0]) {
+//     // Return decoded polyline on route geometry (by default Mapbox returns a
+//     // single route with entire geometry contained therein).
+//     // return json.routes[0].geometry.coordinates
+//     const decodedPolyline = decodePolyline(json.routes[0].geometry)
+//     console.log('decoded polyline', json.routes[0].geometry, decodedPolyline)
+//     return decodedPolyline.map((c, index) => ([c[1], c[0]])) // index === 0 ? c :
+//   } else {
+//     return null
+//   }
+// }
