@furkot/directions 1.5.1

package/lib/service/mapquest/index.js

@@ -0,0 +1,199 @@
+const { pathType } = require("../../model");
+const status = require('../status');
+const util = require('../util');
+
+module.exports = init;
+
+const units = {
+  km: 'k',
+  m: 'm'
+};
+const routeType = {
+  '-1': 'shortest',
+  0: 'shortest',
+  1: 'bicycle',
+  2: 'pedestrian',
+  5: 'shortest'
+};
+const tolerance = {
+  '-1': 20,
+  0: 20,
+  1: 10,
+  2: 2
+};
+
+function prepareWaypoint(p) {
+  return {
+    latLng: {
+      lng: p[0],
+      lat: p[1]
+    }
+  };
+}
+
+function addPoint(result, p, i, points) {
+  if (i % 2 === 0) {
+    result.push([points[i + 1], p]);
+  }
+  return result;
+}
+
+function extractSegment(result, { distance, index, narrative, time }) {
+  const { directions: { segments }, maneuverIndexes: indexes, path, unitMultiplier } = result;
+  segments.push({
+    duration: time,
+    distance: Math.round((distance || 0) * unitMultiplier),
+    path: indexes && path && path.slice(indexes[index], indexes[index + 1]),
+    instructions: narrative
+  });
+  return result;
+}
+
+function extractDirections(result, leg) {
+  const { directions: { routes, segments }, legIndexes: indexes, path } = result;
+  const route = {
+    duration: leg.time || 0,
+    distance: Math.round((leg.distance || 0) * result.unitMultiplier)
+  };
+  if (indexes && path && result.fullPath) {
+    route.path = path.slice(indexes[leg.index], indexes[leg.index + 1]);
+  }
+  if (leg.hasSeasonalClosure) {
+    route.seasonal = true;
+  }
+  if (segments) {
+    route.segmentIndex = segments.length;
+  }
+  routes.push(route);
+  if (segments && leg.maneuvers) {
+    leg.maneuvers.reduce(extractSegment, result);
+  }
+  return result;
+}
+
+function getStatus(err, response) {
+  if (!response) {
+    return;
+  }
+  const { info, route } = response;
+  const st = info && info.statuscode;
+  if (st === 403 || st === 500) {
+    // assume its because we exceeded the limit
+    return status.failure;
+  }
+  if (st === 402 || st > 600) {
+    // cannot find route
+    return status.empty;
+  }
+  if (st === 0) {
+    if (route) {
+      return status.success;
+    }
+    return status.empty;
+  }
+}
+
+function init(options) {
+
+  function getProvider(query) {
+    if (query.alternate) {
+      return options.name;
+    }
+    return 'open' + options.name;
+  }
+
+  function getUrl(query) {
+    return options[getProvider(query) + '_url'] + '/directions/v2/' +
+      (query.alternate && query.points.length <= 2 ? 'alternateroutes' : 'route');
+  }
+
+  function prepareRequest(query) {
+    const req = {
+      unit: units[query.units] || units.m,
+      manmaps: false,
+      destinationManeuverDisplay: false,
+      doReverseGeocode: false,
+      routeType: routeType[query.mode] || routeType[0],
+      generalize: tolerance[query.mode]
+    };
+    if (query.avoidHighways) {
+      req.avoids = ['Limited Access'];
+    }
+    if (query.avoidTolls) {
+      req.avoids = req.avoids || [];
+      req.avoids.push('Toll Road');
+    }
+    if (query.begin) {
+      req.timeType = 2;
+      req.dateType = 0;
+      req.isoLocal = query.begin;
+    } else if (!query.seasonal) {
+      req.disallows = ['Approximate Seasonal Closure'];
+    }
+    if (!query.turnbyturn) {
+      req.narrativeType = 'none';
+    }
+
+    return {
+      json: JSON.stringify({
+        options: req,
+        locations: query.points.map(prepareWaypoint)
+      }),
+      inFormat: 'json',
+      outFormat: 'json',
+      key: options.mapquest_key
+    };
+  }
+
+  function processResponse(response, query) {
+
+    if (response && response.info) {
+      const { statuscode: st } = response.info;
+      if (st === 402 || st > 600) {
+        // let it cascade to the next service
+        return;
+      }
+    }
+
+    const route = response && response.route;
+    if (!(route && route.legs && route.legs.length)) {
+      // shouldn't happen
+      return;
+    }
+    const directions = {
+      query,
+      provider: getProvider(query)
+    };
+    if (route.name) {
+      directions.name = route.name;
+    }
+    directions.routes = [];
+    if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {
+      directions.segments = [];
+    }
+    const fullPath = query.path === pathType.full;
+    route.legs.reduce(extractDirections, {
+      directions,
+      unitMultiplier: query.units === 'km' ? util.metersInKm : util.metersInMile,
+      maneuverIndexes: route.shape && route.shape.maneuverIndexes,
+      legIndexes: route.shape && route.shape.legIndexes,
+      path: route.shape && route.shape.shapePoints.reduce(addPoint, []),
+      fullPath
+    });
+    if (fullPath) {
+      // path is already prepared - no need to do it again from segments
+      directions.pathReady = true;
+    }
+    return directions;
+  }
+
+  options = util.defaults(options, {
+    // MapQuest allows 50 but we code it in URL and may run into URL length limit of approx 2000
+    maxPoints: 30,
+    url: getUrl,
+    status: getStatus,
+    prepareRequest,
+    processResponse
+  });
+  return require('..')(options);
+}

package/lib/service/openroute/index.js

@@ -0,0 +1,197 @@
+const { pathType, travelMode } = require("../../model");
+const status = require('../status');
+const util = require('../util');
+
+module.exports = init;
+
+const profile = {
+  '-1': 'driving-car',
+  0: 'driving-car',
+  1: 'cycling-regular',
+  2: 'foot-hiking',
+  5: 'driving-hgv'
+};
+const profileRestrictions = {
+  5: {
+    hazmat: true
+  }
+};
+const ferryType = 9;
+
+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 seg = {
+    duration: Math.round(duration || 0),
+    distance: Math.round(distance || 0),
+    path: path && path.slice(way_points[0], way_points[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 extractDirections(result, { distance, duration, steps }, i) {
+  const { directions: { routes, segments }, path, waypoints } = result;
+  const route = {
+    duration: Math.round(duration || 0),
+    distance: Math.round(distance || 0),
+    path: path && path.slice(waypoints[i], waypoints[i + 1] + 1)
+  };
+  if (!(route.duration || route.distance || (route.path && route.path.length > 1))) {
+    route.path = [];
+  }
+  if (segments) {
+    route.segmentIndex = segments.length;
+  }
+  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))) {
+        seg.path = [];
+      }
+    }
+    if (segments.length && route.path.length) {
+      util.last(segments).path.push(util.last(route.path));
+    }
+  }
+  return result;
+}
+
+function getStatus(st, response) {
+  if (!st && response && response.routes && response.routes.length) {
+    return status.success;
+  }
+  return status.empty;
+}
+
+function vehicleSize(query, restrictions) {
+  const { mode, vehicle } = query;
+  if (!(vehicle && mode === 5)) {
+    return restrictions;
+  }
+  restrictions = Object.assign({}, restrictions, vehicle);
+  if (restrictions.axle_load !== undefined) {
+    restrictions.axleload = restrictions.axle_load;
+    delete restrictions.axle_load;
+  }
+  return restrictions;
+}
+
+function init(options) {
+
+  function prepareUrl(query) {
+    return [
+      options.openroute_url,
+      profile[query.mode] || profile[0],
+      'json'
+    ].join('/');
+  }
+
+  function prepareRequest(query) {
+    const req = {
+      coordinates: query.points
+    };
+    if (!query.turnbyturn && query.path !== pathType.smooth && query.path !== pathType.coarse) {
+      req.instructions = false;
+    } else {
+      req.extra_info = ['waytype'];
+    }
+    const restrictions = vehicleSize(query, profileRestrictions[query.mode]);
+    if (restrictions) {
+      req.options = {
+        profile_params: {
+          restrictions
+        }
+      };
+    }
+    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');
+      }
+    }
+
+    return req;
+  }
+
+  function processResponse(response, query) {
+
+    if (!(response && response.routes && response.routes.length)) {
+      // let it cascade to the next service
+      return;
+    }
+
+    const directions = {
+      query,
+      provider: options.name
+    };
+    const paths = response.routes[0].segments;
+    const geometry = response.routes[0].geometry;
+    if (paths) {
+      directions.routes = [];
+      if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {
+        directions.segments = [];
+      }
+      const fullPath = query.path === pathType.full;
+      const { extras, way_points: waypoints } = response.routes[0];
+      paths.reduce(extractDirections, {
+        directions,
+        path: util.decode(geometry),
+        waypoints,
+        waytypes: extras && extras.waytypes && extras.waytypes.values
+      });
+      if (fullPath) {
+        // path is already prepared - no need to do it again from segments
+        directions.pathReady = true;
+      }
+    }
+    return directions;
+  }
+
+  options = util.defaults(options, {
+    maxPoints: 10, // unknown maximum
+    post: true,
+    authorization: options.openroute_key,
+    url: prepareUrl,
+    status: getStatus,
+    prepareRequest,
+    processResponse
+  });
+  return require('..')(options);
+}

package/lib/service/osrm/index.js

@@ -0,0 +1,144 @@
+const { pathType } = require("../../model");
+const status = require('../status');
+const util = require('../util');
+
+const code2status = {
+  Ok: status.success,
+  NoRoute: status.empty,
+  NoSegment: status.empty
+};
+const RADIUS = 1000; // search radius for nearby roads
+
+module.exports = init;
+
+function convertPlace(wpt) {
+  return wpt.name;
+}
+
+function convertStep(step) {
+  return {
+    duration: step.duration,
+    distance: step.distance,
+    path: util.decode(step.geometry),
+    instructions: step.maneuver.type + ' ' + step.maneuver.modifier
+  };
+}
+
+function convertPath(path, seg) {
+  return path.concat(seg.path.slice(1));
+}
+
+function convertLeg({ distance, duration, steps }) {
+  const r = {
+    duration,
+    distance,
+    segments: steps.map(convertStep)
+  };
+
+  r.path = r.segments.reduce(convertPath, []);
+
+  return r;
+}
+
+function convertRoute({ legs }) {
+  return legs.map(convertLeg);
+}
+
+// response codes: http://project-osrm.org/docs/v5.5.2/api/#responses
+function getStatus(err, response) {
+  const code = response && response.code;
+  if (!response) {
+    return;
+  }
+  return code2status[code] || status.error;
+}
+
+function point2radius() {
+  return RADIUS;
+}
+
+function prepareRequest(query) {
+  return {
+    alternatives: Boolean(query.alternate),
+    steps: true, // always ask for steps since legs do not have overview
+    overview: false, // we'll get this from steps
+    radiuses: query.points.map(point2radius).join(';')
+  };
+}
+
+const profile = {
+  '-1': 'driving', // same as car
+  0: 'car',
+  1: 'bicycle',
+  2: 'foot',
+  5: 'driving'
+};
+
+function prepareUrl(baseUrl, query) {
+
+  function coords2string(c) {
+    return c[0].toFixed(5) + ',' + c[1].toFixed(5);
+  }
+
+
+  const path = query.points
+    .map(coords2string)
+    .join(';');
+
+  return [
+    baseUrl,
+    'route/v1',
+    profile[query.mode],
+    path
+  ].join('/');
+}
+
+function init(options) {
+
+  function processResponse(response, query) {
+    const directions = {
+      query,
+      provider: options.name
+    };
+
+    if (response) {
+      if (response.waypoints) {
+        directions.places = response.waypoints.map(convertPlace);
+      }
+
+      if (response.routes) {
+        directions.routes = convertRoute(response.routes[0]);
+
+        if (query.turnbyturn || query.path === pathType.smooth || query.path === pathType.coarse) {
+          directions.segments = [];
+          // copy segments from route to its own table
+          directions.routes.forEach(function (route) {
+            route.segmentIndex = directions.segments.length;
+            directions.segments = directions.segments.concat(route.segments);
+            delete route.segments;
+          });
+        } else {
+          // delete segments
+          directions.routes.forEach(function (route) {
+            delete route.segments;
+          });
+        }
+
+        if (query.path === pathType.full) {
+          // path is already prepared - no need to do it again from segments
+          directions.pathReady = true;
+        }
+      }
+    }
+    return directions;
+  }
+
+  options = util.defaults(options, {
+    maxPoints: 20, // max 20 points for automobile and 50 for bicycle and pedestrian
+    url: prepareUrl.bind(null, options.osrm_url || 'https://router.project-osrm.org'),
+    status: getStatus,
+    prepareRequest,
+    processResponse
+  });
+  return require('..')(options);
+}

package/lib/service/partition.js

@@ -0,0 +1,79 @@
+const util = require('./util');
+
+module.exports = partition;
+
+function distanceSquare(p1, p2) {
+  return Math.pow((p1[0] - p2[0]), 2) + Math.pow((p1[1] - p2[1]), 2);
+}
+
+function pointOnLine(point, p1, p2) {
+  const d = distanceSquare(p1, p2);
+  let t;
+  let pol;
+  if (!d) {
+    pol = p1;
+  } else {
+    t = ((point[0] - p1[0]) * (p2[0] - p1[0]) + (point[1] - p1[1]) * (p2[1] - p1[1])) / d;
+    if (t < 0) {
+      pol = p1;
+    } else if (t > 1) {
+      pol = p2;
+    } else {
+      pol = [p1[0] + t * (p2[0] - p1[0]), p1[1] + t * (p2[1] - p1[1])];
+    }
+  }
+  return pol;
+}
+
+function minDistance(res, p, i, path) {
+  let dist = distanceSquare(res.point, p);
+  if (dist < res.dist || (dist < res.minDistance && res.pol)) {
+    res.dist = dist;
+    res.idx = i;
+    res.p = p;
+    res.pol = undefined;
+  }
+  if (i > 0) {
+    p = pointOnLine(res.point, path[i - 1], p);
+    dist = distanceSquare(res.point, p);
+    if (dist < res.dist && (res.dist >= res.minDistance || res.pol)) {
+      res.dist = dist;
+      res.idx = i - 1;
+      res.p = p;
+      res.pol = true;
+    }
+  }
+  return res;
+}
+
+function findPointOnPath(point, path) {
+  let result;
+  if (point && path) {
+    result = path.reduce(minDistance, {
+      dist: Number.MAX_VALUE,
+      point,
+      minDistance: 0.5
+    });
+    if (result.idx !== undefined) {
+      return result;
+    }
+  }
+}
+
+function cut(prev, next) {
+  const segments = prev.path.segments;
+  const point = findPointOnPath(segments[next.segmentIndex].path[0], prev.path);
+  if (point) {
+    next.path = prev.path.slice(point.idx + 1);
+    prev.path = prev.path.slice(0, point.idx + 1);
+    next.path.segments = segments;
+  }
+}
+
+// divide path into routes
+function partition(path, routes, segments) {
+  path.segments = segments;
+  routes[0].path = path;
+  routes.reduce(cut);
+  delete util.last(routes).path.segments;
+}

package/lib/service/simplify.js

@@ -0,0 +1,96 @@
+const pathType = require("../model").pathType;
+const util = require('./util');
+
+module.exports = init;
+
+function init(options) {
+  options = options || {};
+
+  const algorithm = options.algorithm || require("vis-why");
+  const endPoints = options.endPoints || 25; // how many points keep at ends
+  const maxPoints = options.pathPoints || 100; // maximum number of points kept per path
+  const ed = maxPoints / endPoints;
+
+  function simplifyRoute(result, route) {
+    let i;
+    let seg;
+    let first = [];
+    let last = [];
+    const path = [];
+    const type = result.type;
+    const segments = result.segments;
+    let endDistance = result.endDistance;
+
+    if (endDistance > route.distance / ed) {
+      endDistance = 0;
+    }
+    last.distance = 0;
+    if (endDistance) {
+      for (i = result.segmentIndex - 1; i >= route.segmentIndex; i -= 1) {
+        seg = segments[i];
+        last.distance += seg.distance;
+        if (last.distance >= endDistance) {
+          last.split = util.indexAt(seg.path, last.distance - endDistance);
+          Array.prototype.unshift.apply(last, seg.path.slice(last.split));
+          break;
+        }
+        result.segmentIndex -= 1;
+        Array.prototype.unshift.apply(last, seg.path);
+      }
+    }
+    first.distance = 0;
+    i = route.segmentIndex;
+    if (endDistance) {
+      for (; i < result.segmentIndex; i += 1) {
+        seg = segments[i];
+        first.distance += seg.distance;
+        if (first.distance >= endDistance) {
+          first.split = util.indexAt(seg.path, endDistance - first.distance + seg.distance);
+          util.concat(first, seg.path.slice(0, first.split));
+          break;
+        }
+        util.concat(first, seg.path);
+      }
+    }
+    if (first.split) {
+      util.concat(path, segments[i].path.slice(first.split,
+        (i === result.segmentIndex - 1 && last.split) ? last.split : undefined));
+      i += 1;
+    }
+    for (; i < (last.split ? result.segmentIndex - 1 : result.segmentIndex); i += 1) {
+      util.concat(path, segments[i].path);
+    }
+    if (last.split && i < result.segmentIndex) {
+      util.concat(path, segments[i].path.slice(0, last.split));
+    }
+    result.segmentIndex = route.segmentIndex;
+    if (type === pathType.full || (first.length + path.length + last.length) <= maxPoints) {
+      if (endDistance) {
+        route.path = util.concat(util.concat(first, path), last);
+      } else {
+        route.path = path;
+      }
+    } else if (endDistance) {
+      first = algorithm(first, endPoints);
+      last = algorithm(last, endPoints);
+      route.path = util.concat(util.concat(first, algorithm(path, maxPoints - first.length - last.length)), last);
+    } else {
+      route.path = algorithm(path, maxPoints);
+    }
+    return result;
+  }
+
+  function simplify(type, endDistance, routes, segments) {
+    if (type === pathType.none) {
+      return;
+    }
+    routes.reduceRight(simplifyRoute, {
+      type,
+      segments,
+      segmentIndex: segments.length,
+      endDistance: endDistance || 2000
+    });
+  }
+
+  return simplify;
+}