@furkot/directions 2.0.2 → 2.1.0

package/lib/model.js

@@ -12,7 +12,7 @@ const travelMode = {
   car: 0,
   bicycle: 1,
   walk: 2,
-  other: 3,
+  rv: 5,
   ferry: 6
 };
 

package/lib/service/graphhopper/index.js

@@ -1,5 +1,9 @@
-const { pathType } = require("../../model");
+// https://docs.graphhopper.com/#tag/Routing-API
+// https://github.com/boldtrn/kurviger-api-documentation
+
+const { pathType, travelMode } = require("../../model");
 const status = require('../status');
+const tagRoute = require('../tag-route');
 const util = require('../util');
 
 module.exports = init;
@@ -18,24 +22,48 @@ const weighting = {
   2: 'curvaturefastest'
 };
 
-function prepareWaypoint(qs, p) {
-  // waypoint format is lat,lon
-  qs.push('point=' + encodeURIComponent(p[1] + ',' + p[0]));
-  return qs;
-}
+const ferryTypes = {
+  ferry: true
+};
+const roughTypes = {
+  compacted: true,
+  dirt: true,
+  fine_gravel: true,
+  grass: true,
+  gravel: true,
+  ground: true,
+  sand: true,
+  unpaved: true
+};
+const tollTypes = {
+  all: true
+};
 
 function extractSegment(result, { distance, interval, text, time }) {
   const { directions: { segments }, path } = result;
+  const [from, to] = interval;
   segments.push({
     duration: Math.round((time || 0) / 1000),
     distance: Math.round(distance || 0),
-    path: path && path.slice(interval[0], interval[1]),
+    path: path?.slice(from, to + 1),
     instructions: text
   });
   return result;
 }
 
-function extractDirections(result, { distance, instructions, points, time }) {
+function setFerryMode(seg) {
+  seg.mode = travelMode.ferry;
+}
+
+function setRough(seg) {
+  seg.rough = true;
+}
+
+function setTolls(seg) {
+  seg.tolls = true;
+}
+
+function extractDirections(result, { details, distance, instructions, points, time }) {
   const { directions: { routes, segments }, fullPath } = result;
   result.path = util.decode(points);
   const route = {
@@ -54,6 +82,30 @@ function extractDirections(result, { distance, instructions, points, time }) {
     if (segments.length) {
       util.last(segments).path.push(util.last(result.path));
     }
+    const ferry = tagRoute(details?.road_environment, {
+      segments,
+      types: ferryTypes,
+      updateSegment: setFerryMode
+    });
+    if (ferry?.foundType) {
+      route.ferry = true;
+    }
+    const rough = tagRoute(details?.surface, {
+      segments,
+      types: roughTypes,
+      updateSegment: setRough
+    });
+    if (rough?.foundType) {
+      route.rough = true;
+    }
+    const tolls = tagRoute(details?.toll, {
+      segments,
+      types: tollTypes,
+      updateSegment: setTolls
+    });
+    if (tolls?.foundType) {
+      route.tolls = true;
+    }
   }
   return result;
 }
@@ -78,48 +130,92 @@ function getStatus(st, response) {
   }
 }
 
+function vehicleSize(query, options) {
+  const { mode, vehicle } = query;
+  if (!(vehicle && mode === travelMode.rv)) {
+    return;
+  }
+  const { hazmat } = vehicle;
+  if (hazmat) {
+    options.push({
+      if: 'hazmat == NO',
+      multiply_by: '0.0'
+    });
+  }
+  ['height', 'width', 'length', 'weight', 'axle_load'].forEach(p => {
+    if (vehicle[p]) {
+      options.push({
+        if: `max_${p} < ${vehicle[p]}`,
+        multiply_by: '0.0'
+      });
+    }
+  });
+}
+
 function init(options) {
 
-  function prepareUrl(url, { avoidHighways, avoidTolls, avoidUnpaved, curvy, mode, path, points, turnbyturn }) {
+  function prepareUrl(url) {
+    return `${url}?key=${options.graphhopper_key}`;
+  }
+
+  function prepareRequest(query) {
+    const { avoidFerry, avoidHighways, avoidTolls, avoidUnpaved, curvy, mode, path, points, turnbyturn } = query;
+    if (options.parameters.max_curvy_distance && curvy && mode === -1 && points.length === 2 &&
+      util.distance(points[0], points[1]) > options.parameters.max_curvy_distance) {
+      return;
+    }
     let req = {
       vehicle: vehicle[mode] || vehicle[0],
-      key: options.graphhopper_key
+      points,
+      details: ['road_environment', 'toll']
     };
+    if (!turnbyturn && path !== pathType.smooth && path !== pathType.coarse) {
+      req.instructions = false;
+    }
     if (curvy && mode === -1) {
       req.vehicle = 'motorcycle.kurviger.de';
       req.weighting = weighting[curvy];
       if (options.parameters.app_type) {
         req['app.type'] = options.parameters.app_type;
       }
+      if (avoidHighways) {
+        req.avoid_motorways = true;
+      }
+      if (avoidTolls) {
+        req.avoid_toll_roads = true;
+      }
+      if (avoidFerry) {
+        req.avoid_ferries = true;
+      }
       if (avoidUnpaved) {
         req.avoid_unpaved_roads = true;
       }
     }
-    if (!turnbyturn && path !== pathType.smooth && path !== pathType.coarse) {
-      req.instructions = false;
-    }
-    if (options.parameters.flexible) {
-      if (avoidTolls) {
-        req['ch.disable'] = true;
-        req.avoid = ['toll'];
-      }
-      if (avoidHighways) {
-        req['ch.disable'] = true;
-        req.avoid = req.avoid || [];
-        req.avoid.push('motorway');
+    else {
+      req.details.push('surface');
+      req['ch.disable'] = true;
+      req.custom_model = {
+        priority: [{
+          if: 'road_class == MOTORWAY',
+          multiply_by: avoidHighways ? '0.1' : '1.0'
+        }, {
+          if: 'toll == ALL',
+          multiply_by: avoidTolls ? '0.1' : '1.0'
+        }, {
+          if: 'road_environment == FERRY',
+          multiply_by: avoidFerry ? '0.1' : '1.0'
+        }]
+      };
+      if (avoidUnpaved) {
+        req.custom_model.priority.push({
+          if: 'surface == UNPAVED',
+          multiply_by: '0.0'
+        });
       }
+      vehicleSize(query, req.custom_model.priority);
     }
 
-    req = points.reduce(prepareWaypoint, Object.keys(req).map(function (name) {
-      return name + '=' + encodeURIComponent(req[name]);
-    }));
-
-    return url + '?' + req.join('&');
-  }
-
-  function prepareRequest({ mode, points, curvy }) {
-    return !(options.parameters.max_curvy_distance && curvy && mode === -1 && points.length === 2 &&
-      util.distance(points[0], points[1]) > options.parameters.max_curvy_distance);
+    return req;
   }
 
   function processResponse(response, query) {
@@ -154,6 +250,7 @@ function init(options) {
 
   options = util.defaults(options, {
     maxPoints: options.graphhopper_max_points || 5, // max 5 points for free and 30-150 for paid plan
+    post: true,
     url: prepareUrl.bind(undefined, options.graphhopper_url),
     status: getStatus,
     prepareRequest,

package/lib/service/openroute/index.js

@@ -3,6 +3,7 @@
 const LatLon = require('geodesy/latlon-spherical');
 const { pathType, travelMode } = require("../../model");
 const status = require('../status');
+const tagRoute = require('../tag-route');
 const util = require('../util');
 
 module.exports = init;
@@ -19,55 +20,63 @@ const profileRestrictions = {
     hazmat: true
   }
 };
-const ferryType = 9;
+const avoidFeatures = {
+  avoidHighways: 'highways',
+  avoidTolls: 'tollways',
+  avoidFerry: 'ferries'
+};
+const ferryTypes = {
+  '9': true
+};
+const roughTypes = {
+  '2': true, // Unpaved
+  '8': true, // Compacted Gravel
+  '9': true, // Fine Gravel
+  '10': true, // Gravel
+  '11': true, // Dirt
+  '12': true, // Ground
+  '15': true, // Sand
+  '17': true, // Grass
+  '18': true // Grass Paver
+};
+const tollTypes = {
+  '1': true
+};
 const maxRoundabout = 12 * 60 * 60; // 12 hours maximum for route that is 10 times longer than direct distance
 
-function nextFerry(result, points = [-1, -1]) {
-  let { waytypes } = result;
-  if (!waytypes) {
-    return;
-  }
-  for (; result.way < waytypes.length; result.way += 1) {
-    const waytype = waytypes[result.way];
-    if (waytype[0] > points[1]) {
-      return;
-    }
-    if (waytype[2] === ferryType && (
-        (waytype[0] <= points[0] && waytype[1] >= points[1]) ||
-        (waytype[0] > points[0] && waytype[1] < points[1]) ||
-        (waytype[0] >= points[0] && waytype[0] <= points[1]) ||
-        (waytype[1] >= points[0] && waytype[1] <= points[1])
-      )) {
-      return waytype;
-    }
-  }
-}
 
 function extractStep(result, { distance, duration, instruction, way_points }) {
-  const { directions: { segments, routes }, path } = result;
+  const { directions: { segments }, path } = result;
   const seg = {
     duration: Math.round(duration || 0),
     distance: Math.round(distance || 0),
-    path: path && path.slice(way_points[0], way_points[1]),
+    path: path?.slice(way_points[0], way_points[1] + 1),
     instructions: instruction
   };
   segments.push(seg);
-  const ferrySeg = nextFerry(result, way_points);
-  if (ferrySeg) {
-    seg.mode = travelMode.ferry;
-    util.last(routes).ferry = true;
-  }
   return result;
 }
 
+function setFerryMode(seg) {
+  seg.mode = travelMode.ferry;
+}
+
+function setRough(seg) {
+  seg.rough = true;
+}
+
+function setTolls(seg) {
+  seg.tolls = true;
+}
+
 function extractDirections(result, { distance, duration, steps }, i) {
-  const { directions: { routes, segments }, path, waypoints } = result;
+  const { directions: { routes, segments }, path, surface, waypoints, waytypes, tollways } = result;
   const route = {
     duration: Math.round(duration || 0),
     distance: Math.round(distance || 0),
-    path: path && path.slice(waypoints[i], waypoints[i + 1] + 1)
+    path: path?.slice(waypoints[i], waypoints[i + 1] + 1)
   };
-  if (!(route.duration || route.distance || (route.path && route.path.length > 1))) {
+  if (!(route.duration || route.distance || (route.path?.length > 1))) {
     route.path = [];
   }
   if (segments) {
@@ -75,18 +84,40 @@ function extractDirections(result, { distance, duration, steps }, i) {
   }
   routes.push(route);
   if (segments && steps) {
-    result.way = 0;
-    nextFerry(result);
     steps.reduce(extractStep, result);
     if (segments.length === 1) {
       const seg = segments[0];
-      if (!(seg.duration || seg.distance || (seg.path && seg.path.length > 1))) {
+      if (!(seg.duration || seg.distance || (seg.path?.length > 1))) {
         seg.path = [];
       }
     }
     if (segments.length && route.path.length) {
       util.last(segments).path.push(util.last(route.path));
     }
+    const ferry = tagRoute(waytypes, {
+      segments,
+      types: ferryTypes,
+      updateSegment: setFerryMode
+    });
+    if (ferry?.foundType) {
+      route.ferry = true;
+    }
+    const rough = tagRoute(surface, {
+      segments,
+      types: roughTypes,
+      updateSegment: setRough
+    });
+    if (rough?.foundType) {
+      route.rough = true;
+    }
+    const tolls = tagRoute(tollways, {
+      segments,
+      types: tollTypes,
+      updateSegment: setTolls
+    });
+    if (tolls?.foundType) {
+      route.tolls = true;
+    }
   }
   return result;
 }
@@ -108,7 +139,7 @@ function directDistance(locations) {
 }
 
 function getStatus(st, response) {
-  if (!st && response && response.routes && response.routes.length) {
+  if (!st && response?.routes?.length) {
     const { distance, duration } = response.routes.reduce((result, { summary}) => {
       result.distance += summary.distance;
       result.duration += summary.duration;
@@ -126,7 +157,7 @@ function getStatus(st, response) {
 
 function vehicleSize(query, restrictions) {
   const { mode, vehicle } = query;
-  if (!(vehicle && mode === 5)) {
+  if (!(vehicle && mode === travelMode.rv)) {
     return restrictions;
   }
   restrictions = Object.assign({}, restrictions, vehicle);
@@ -147,14 +178,25 @@ function init(options) {
     ].join('/');
   }
 
+  function avoidFeature(result, flag) {
+    const { query, req } = result;
+    if (query[flag]) {
+      req.options = req.options || {};
+      req.options.avoid_features = req.options.avoid_features || [];
+      req.options.avoid_features.push(avoidFeatures[flag]);
+    }
+    return result;
+  }
+
   function prepareRequest(query) {
     const req = {
-      coordinates: query.points
+      coordinates: query.points,
+      extra_info: ['surface', 'tollways']
     };
     if (!query.turnbyturn && query.path !== pathType.smooth && query.path !== pathType.coarse) {
       req.instructions = false;
     } else {
-      req.extra_info = ['waytype'];
+      req.extra_info.push('waytype');
     }
     const restrictions = vehicleSize(query, profileRestrictions[query.mode]);
     if (restrictions) {
@@ -164,25 +206,18 @@ function init(options) {
         }
       };
     }
+    const param = { query, req };
     if ((profile[query.mode] || profile[0]) === 'driving-car') {
-      if (query.avoidHighways) {
-        req.options = req.options || {
-          avoid_features: ['highways']
-        };
-      }
-      if (query.avoidTolls) {
-        req.options = req.options || {};
-        req.options.avoid_features = req.options.avoid_features || [];
-        req.options.avoid_features.push('tollways');
-      }
+      ['avoidHighways', 'avoidTolls'].reduce(avoidFeature, param);
     }
+    avoidFeature(param, 'avoidFerry');
 
     return req;
   }
 
   function processResponse(response, query) {
 
-    if (!(response && response.routes && response.routes.length)) {
+    if (!response?.routes?.length) {
       // let it cascade to the next service
       return;
     }
@@ -203,8 +238,10 @@ function init(options) {
       paths.reduce(extractDirections, {
         directions,
         path: util.decode(geometry),
+        surface: extras?.surface?.values,
+        tollways: extras?.tollways?.values,
         waypoints,
-        waytypes: extras && extras.waytypes && extras.waytypes.values
+        waytypes: extras?.waytypes?.values
       });
       if (fullPath) {
         // path is already prepared - no need to do it again from segments

package/lib/service/tag-route.js

@@ -0,0 +1,54 @@
+module.exports = tagRoute;
+
+function splitSegment(result, length) {
+  const { segments, seg } = result;
+  const { distance, duration, path } = segments[seg];
+  if (length <= 0 || length + 1 >= path.length) {
+    return;
+  }
+  const factor = length / path.length;
+  segments.splice(seg, 0, {
+    distance: distance * factor,
+    duration: duration * factor,
+    path: path?.slice(0, length + 1)
+  });
+  segments[seg + 1].distance -= segments[seg].distance;
+  segments[seg + 1].duration -= segments[seg].duration;
+  segments[seg + 1].path = path?.slice(length);
+  result.running += length;
+  result.seg += 1;
+}
+
+function extractRouteType(result, [from, to, type]) {
+  const { segments, types, updateSegment } = result;
+  if (!types[type]) {
+    return result;
+  }
+  while (result.running + segments[result.seg].path.length - 1 <= from) {
+    result.running += segments[result.seg].path.length - 1;
+    result.seg += 1;
+  }
+  const { running } = result;
+  splitSegment(result, from - running);
+  let { seg } = result;
+  splitSegment(result, to - from);
+  updateSegment(segments[seg]);
+  result.foundType = true;
+  if (result.seg === seg) {
+    while (result.running + segments[seg].path.length < to) {
+      const { length } = segments[seg].path;
+      from += length - 1;
+      result.running += length - 1;
+      result.seg += 1;
+      seg = result.seg;
+      splitSegment(result, to - from);
+      updateSegment(segments[seg]);
+    }
+  }
+  return result;
+}
+
+function tagRoute(tagSegments, params) {
+  params.seg = params.running = 0;
+  return tagSegments?.reduce(extractRouteType, params);
+}

package/lib/service/valhalla/index.js

@@ -49,14 +49,21 @@ function extractSegment(result, {
   length,
   time,
   rough,
+  toll,
   travel_mode
 }) {
   const { directions: { segments, routes }, unitMultiplier, path } = result;
   const distance = Math.round((length || 0) * unitMultiplier);
   let duration = time;
-  // for some reason Valhalla calculates absurdly low speed on some dirt roads
-  if (rough && duration && travel_mode === 'drive' && distance > turnDistance && distance / duration < minSpeed) {
-    duration = Math.round(distance / minSpeed);
+  if (rough) {
+    util.last(routes).rough = true;
+    // for some reason Valhalla calculates absurdly low speed on some dirt roads
+    if (duration && travel_mode === 'drive' && distance > turnDistance && distance / duration < minSpeed) {
+      duration = Math.round(distance / minSpeed);
+    }
+  }
+  if (toll) {
+    util.last(routes).tolls = true;
   }
   result.legDuration += duration;
   const seg = {
@@ -65,6 +72,12 @@ function extractSegment(result, {
     path: path && path.slice(begin_shape_index, end_shape_index),
     instructions: instruction
   };
+  if (rough) {
+    seg.rough = true;
+  }
+  if (toll) {
+    seg.tolls = true;
+  }
   if (type === maneuver.ferryExit || result.ferry) {
     if (result.ferry) {
       delete result.ferry;
@@ -155,7 +168,7 @@ function getStatus(err, response) {
 
 function vehicleSize(query, options) {
   const { mode, vehicle } = query;
-  if (!(vehicle && mode === 5)) {
+  if (!(vehicle && mode === travelMode.rv)) {
     return;
   }
   Object.assign(options, vehicle);
@@ -184,6 +197,14 @@ function init(options) {
     } else {
       req.costing_options[req.costing].use_highways = 1.1;
     }
+    if (query.avoidFerry) {
+      req.costing_options[req.costing].use_ferry = 0;
+    } else {
+      req.costing_options[req.costing].use_ferry = 1;
+    }
+    if (query.avoidUnpaved) {
+      req.costing_options[req.costing].exclude_unpaved = true;
+    }
     vehicleSize(query, req.costing_options[req.costing]);
 
     if (query.begin) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@furkot/directions",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Directions service for Furkot",
   "author": {
     "name": "Damian Krzeminski",