mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-21 14:36:31 +00:00
Maurice
53a422d22d
The picker of other ways asked OSRM with nothing avoided while the rail drives a trip that avoids a road class through Valhalla, so the list had no current road, called a road the rail was not on the fastest, and choosing it changed nothing. A choice was stored as one via where the offer strayed furthest, without asking whether the router then drove it: a point on a ferry was pulled to the pier and the drive went overland, and a way weighed away from motorways kept the motorway after its one point. An OSRM answer standing in for a Valhalla that did not respond was cached as the avoided road, unmarked. The rail now hands out a router per leg with the leg's own mode, avoided classes and engine, and its days carry the line of every leg. Offers come from that engine, and the rail's own leg always heads the list as Current. A choice is pinned and proven against that router with at most three pins before anything is written; a way it will not follow is not saved and says why, with a hint when it crosses by ferry, and a leg that changed meanwhile or a device offline writes nothing. The OSRM stand-in is filed under the plain key only and flags the day as not avoided.
1191 lines
52 KiB
TypeScript
1191 lines
52 KiB
TypeScript
import { useSettingsStore } from '../../store/settingsStore'
|
|
import { pluginsApi } from '../../api/client'
|
|
import type { DistanceUnit, RouteResult, RouteSegment, RouteWithLegs, SnappedWaypoint, Waypoint, RouteAnchors } from '../../types'
|
|
import { haversineKm } from '../../utils/geo'
|
|
import { formatDistance } from '../../utils/units'
|
|
import { countRoute } from './routeUsageCounter'
|
|
import { valhallaRouteAvoiding, valhallaRun, valhallaAvailable, valhallaAlternates, valhallaSpacing, legAvoids, type AvoidClass, type ValhallaLeg } from './valhallaRoute'
|
|
import type { RouteUsageSurface } from '@trek/shared'
|
|
|
|
// FOSSGIS hosts OSRM with real per-profile routing (car/foot/bike) — the
|
|
// project-osrm.org demo is car-only (it ignores the profile in the URL). Use
|
|
// the matching profile so walking routes follow footpaths, not the road network.
|
|
const OSRM_PROFILE_BASE: Record<'driving' | 'walking' | 'cycling', string> = {
|
|
driving: 'https://routing.openstreetmap.de/routed-car/route/v1/driving',
|
|
walking: 'https://routing.openstreetmap.de/routed-foot/route/v1/foot',
|
|
cycling: 'https://routing.openstreetmap.de/routed-bike/route/v1/bike',
|
|
}
|
|
|
|
/** OSRM's own profile names, which a self-hosted instance serves under its own paths. */
|
|
const OSRM_PROFILE_PATH: Record<'driving' | 'walking' | 'cycling', string> = {
|
|
driving: 'driving',
|
|
walking: 'foot',
|
|
cycling: 'bike',
|
|
}
|
|
|
|
/**
|
|
* Where to ask for a route.
|
|
*
|
|
* The public FOSSGIS hosts allow roughly one request a second, which a road trip — every
|
|
* leg of every day — runs into immediately. An instance that runs its own OSRM sets
|
|
* `routing_base_url` and everything routes against that instead; the server has to name
|
|
* the same origin in its connect-src, or the browser blocks the requests silently.
|
|
*
|
|
* A configured base is expected to serve the standard OSRM layout,
|
|
* `<base>/route/v1/<profile>/…`, which is what `osrm-routed` does out of the box.
|
|
*/
|
|
/**
|
|
* A configured base URL without its trailing slashes.
|
|
*
|
|
* Walked rather than matched with `/\/+$/`: that pattern backtracks over a run of
|
|
* slashes, and the value comes from an instance setting somebody types. Linear either
|
|
* way in practice, but the regex is the shape a scanner is right to flag.
|
|
*/
|
|
function withoutTrailingSlashes(value: string): string {
|
|
let end = value.length
|
|
while (end > 0 && value[end - 1] === '/') end -= 1
|
|
return value.slice(0, end)
|
|
}
|
|
|
|
function routeBaseFor(profile: 'driving' | 'walking' | 'cycling'): string {
|
|
const configured = useSettingsStore.getState().settings.routing_base_url?.trim()
|
|
if (!configured) return OSRM_PROFILE_BASE[profile]
|
|
return `${withoutTrailingSlashes(configured)}/route/v1/${OSRM_PROFILE_PATH[profile]}`
|
|
}
|
|
|
|
/**
|
|
* Permission to turn around at a stop, for requests that have stops to turn around at.
|
|
*
|
|
* OSRM's car profile forbids a u-turn at an INTERMEDIATE waypoint unless asked otherwise,
|
|
* and a refusal is not local: the whole request comes back `400 NoRoute`, every leg of it,
|
|
* however many were fine. A stop on a dead end is enough. Gouffre de Padirac snaps onto
|
|
* `Route du Puits au Salvage`, which goes nowhere else, so a day that visits it in the
|
|
* middle lost all its legs at once while each of its pairs routed perfectly on its own.
|
|
* That is also why the fault looked like it depended on how the stops were spread across
|
|
* days: a pair on a day boundary is asked for on its own, and a request with nothing in
|
|
* the middle has nothing to refuse.
|
|
*
|
|
* Correct as well as convenient here. TREK's waypoints are places somebody stops at, not
|
|
* shape hints, and the way out of a dead end IS the way back in, and the constraint was
|
|
* buying a detour even where it did not refuse outright.
|
|
*
|
|
* Empty for two waypoints, which have no middle, so the many two-point callers
|
|
* (alternatives, the day connectors, booking geometry) keep the URL they had.
|
|
*/
|
|
const U_TURN_PARAM = '&continue_straight=false'
|
|
|
|
function uTurnParam(waypoints: readonly Waypoint[]): string {
|
|
return waypoints.length > 2 ? U_TURN_PARAM : ''
|
|
}
|
|
|
|
/**
|
|
* `fetch`, with the request counted.
|
|
*
|
|
* Every route TREK draws goes out from here, and nowhere else, which makes this the one
|
|
* place that can answer how much routing an instance really does — the number behind
|
|
* "could we host an engine ourselves". Counted: how many requests, of what kind, how
|
|
* many waypoints, roughly how far, and whether the host refused. Not counted, because it
|
|
* is never sent: where any of it was.
|
|
*
|
|
* Distance is the straight line along the waypoint chain rather than the routed length,
|
|
* which is only in the answer and differs per response shape. It is a floor on the real
|
|
* figure, and a floor is enough to tell a 1500 km per-request limit from a 150 km one.
|
|
*
|
|
* An aborted request is not a failure: the map cancels constantly while someone drags.
|
|
*/
|
|
async function routedFetch(
|
|
url: string,
|
|
signal: AbortSignal | undefined,
|
|
kind: RouteUsageSurface,
|
|
profile: 'driving' | 'walking' | 'cycling',
|
|
waypoints: readonly Waypoint[],
|
|
): Promise<Response> {
|
|
const selfHosted = !!useSettingsStore.getState().settings.routing_base_url?.trim()
|
|
let km = 0
|
|
for (let i = 1; i < waypoints.length; i++) km += haversineKm(waypoints[i - 1], waypoints[i])
|
|
const sample = { profile, surface: kind, selfHosted, waypoints: waypoints.length, km }
|
|
const asked = withoutUTurnIfRefused(url)
|
|
try {
|
|
const response = await fetch(asked, { signal })
|
|
countRoute({ ...sample, failed: !response.ok })
|
|
if (response.ok || !asked.includes(U_TURN_PARAM)) return response
|
|
const plain = await droppedUTurn(asked, response)
|
|
if (!plain) return response
|
|
const second = await fetch(plain, { signal })
|
|
countRoute({ ...sample, failed: !second.ok })
|
|
return second
|
|
} catch (err) {
|
|
if (!(err instanceof DOMException && err.name === 'AbortError')) {
|
|
countRoute({ ...sample, failed: true })
|
|
}
|
|
throw err
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hosts that answered `InvalidQuery` to `continue_straight`, by origin.
|
|
*
|
|
* OSRM refuses an unknown query parameter outright rather than ignoring it, so a router
|
|
* that has never heard of this one would refuse EVERY request with a stop in the middle,
|
|
* which is a far worse fault than the one it fixes. `osrm-routed` has understood it
|
|
* since 5.6, so this is about something else answering under `routing_base_url`, and the
|
|
* first real request is the probe: there is no separate one.
|
|
*
|
|
* By origin rather than per profile, because a router either knows the parameter or does
|
|
* not; and in a Set rather than a setting, so pointing the instance at a router that does
|
|
* know it starts asking again without a reload. Same shape and the same reasoning as
|
|
* `excludeUnsupported` below.
|
|
*/
|
|
const uTurnUnsupported = new Set<string>()
|
|
|
|
const originOf = (url: string): string => {
|
|
try { return new URL(url).origin } catch { return url }
|
|
}
|
|
|
|
/** The url as it should go out, with the permission dropped for a host that refused it. */
|
|
function withoutUTurnIfRefused(url: string): string {
|
|
if (!url.includes(U_TURN_PARAM)) return url
|
|
return uTurnUnsupported.has(originOf(url)) ? url.replace(U_TURN_PARAM, '') : url
|
|
}
|
|
|
|
/**
|
|
* The same url without the u-turn permission, once it is clear the host objects to the
|
|
* PARAMETER and not to the route. Null when the refusal was about the route itself.
|
|
*
|
|
* OSRM says which it is: `InvalidQuery` names the query string, `NoRoute` names the road.
|
|
* Reading the body is safe here because this response is about to be thrown away either
|
|
* way, and it only happens on a 400 for a request that carried the parameter.
|
|
*/
|
|
async function droppedUTurn(url: string, response: Response): Promise<string | null> {
|
|
if (response.status !== 400) return null
|
|
let code: unknown
|
|
try { code = (await response.clone().json())?.code } catch { return null }
|
|
if (code !== 'InvalidQuery') return null
|
|
uTurnUnsupported.add(originOf(url))
|
|
return url.replace(U_TURN_PARAM, '')
|
|
}
|
|
|
|
/**
|
|
* A routing request the host refused, as opposed to one it answered with "no route".
|
|
*
|
|
* The public OSRM instances allow roughly one request a second and answer 429 above that.
|
|
* Both used to arrive as the same generic Error, so a caller could not tell "back off and
|
|
* try again" from "these two points are not connected by road" — and a road trip, which
|
|
* asks for every leg of every day, hits the first case constantly while the second is
|
|
* rare. `retryAfterMs` carries the host's own `Retry-After` when it sends one.
|
|
*/
|
|
export class RoutingRefusedError extends Error {
|
|
constructor(readonly status: number, readonly retryAfterMs: number | null) {
|
|
super(status === 429 ? 'Routing rate limit reached' : 'Route could not be calculated')
|
|
this.name = 'RoutingRefusedError'
|
|
}
|
|
|
|
/** True when waiting and asking again is the right response. */
|
|
get isRateLimit(): boolean {
|
|
return this.status === 429 || this.status === 503
|
|
}
|
|
}
|
|
|
|
/** `Retry-After` is either seconds or an HTTP date; anything else is no answer at all. */
|
|
function retryAfterMs(response: Response): number | null {
|
|
const raw = response.headers.get('Retry-After')
|
|
if (!raw) return null
|
|
const seconds = Number(raw)
|
|
if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1000)
|
|
const at = Date.parse(raw)
|
|
return Number.isNaN(at) ? null : Math.max(0, at - Date.now())
|
|
}
|
|
|
|
// Cache route responses keyed by the exact waypoint list. Routes are stable, so
|
|
// this avoids re-hitting the public OSRM demo server on every day switch / reorder.
|
|
const routeCache = new Map<string, RouteWithLegs>()
|
|
const ROUTE_CACHE_MAX = 200
|
|
|
|
/**
|
|
* A route profile is either one of the built-in OSRM profiles or a plugin profile
|
|
* key `plugin:<pluginId>/<profileId>` — the route toggle offers those for every
|
|
* active routeProvider plugin, and calculateRouteWithLegs dispatches on the prefix.
|
|
*/
|
|
export type RouteProfileKey = 'driving' | 'walking' | 'cycling' | (string & {})
|
|
|
|
export function parsePluginProfile(profile: string): { pluginId: string; profileId: string } | null {
|
|
if (!profile.startsWith('plugin:')) return null
|
|
const rest = profile.slice('plugin:'.length)
|
|
const slash = rest.indexOf('/')
|
|
if (slash <= 0 || slash === rest.length - 1) return null
|
|
return { pluginId: rest.slice(0, slash), profileId: rest.slice(slash + 1) }
|
|
}
|
|
|
|
/**
|
|
* Which engine priced a route: OSRM, the second engine that weighs road classes away, or
|
|
* a route provider plugin. Their figures are three different speed models, so a figure
|
|
* from one read against a figure from another measures the models, not the roads.
|
|
*/
|
|
export type RouteEngine = 'osrm' | 'valhalla' | 'plugin'
|
|
|
|
/**
|
|
* The classes a request really weighs away, in a stable order, and none when it cannot.
|
|
*
|
|
* Only the driving profile has classes to leave out and only Valhalla can leave them out,
|
|
* so every other request is asked plainly whatever the trip says. One function for the
|
|
* day routing and for the offers beside it, so the two cannot disagree about which engine
|
|
* a leg belongs to.
|
|
*/
|
|
export function avoidedClasses(profile: RouteProfileKey, avoid: readonly AvoidClass[]): AvoidClass[] {
|
|
return profile === 'driving' && avoid.length > 0 && valhallaAvailable()
|
|
? [...avoid].sort((a, b) => a.localeCompare(b))
|
|
: []
|
|
}
|
|
|
|
/** The engine `calculateRouteWithLegs` hands a request with this profile and avoidance to. */
|
|
export function routeEngineFor(profile: RouteProfileKey, avoid: readonly AvoidClass[]): RouteEngine {
|
|
if (parsePluginProfile(profile)) return 'plugin'
|
|
return avoidedClasses(profile, avoid).length ? 'valhalla' : 'osrm'
|
|
}
|
|
|
|
/** Fetches a full route via OSRM and returns coordinates, distance, and duration estimates for driving/walking. */
|
|
export async function calculateRoute(
|
|
waypoints: Waypoint[],
|
|
profile: 'driving' | 'walking' | 'cycling' = 'driving',
|
|
{ signal }: { signal?: AbortSignal } = {}
|
|
): Promise<RouteResult> {
|
|
if (!waypoints || waypoints.length < 2) {
|
|
throw new Error('At least 2 waypoints required')
|
|
}
|
|
|
|
const coords = waypoints.map((p) => `${p.lng},${p.lat}`).join(';')
|
|
const url = `${routeBaseFor(profile)}/${coords}?overview=full&geometries=geojson&steps=false${uTurnParam(waypoints)}`
|
|
|
|
const response = await routedFetch(url, signal, 'route', profile, waypoints)
|
|
if (!response.ok) {
|
|
throw new RoutingRefusedError(response.status, retryAfterMs(response))
|
|
}
|
|
|
|
const data = await response.json()
|
|
|
|
if (data.code !== 'Ok' || !data.routes || data.routes.length === 0) {
|
|
throw new Error('No route found')
|
|
}
|
|
|
|
const route = data.routes[0]
|
|
const coordinates: [number, number][] = route.geometry.coordinates.map(([lng, lat]: [number, number]) => [lat, lng])
|
|
|
|
const distance: number = route.distance
|
|
let duration: number
|
|
if (profile === 'walking') {
|
|
duration = distance / (5000 / 3600)
|
|
} else if (profile === 'cycling') {
|
|
duration = distance / (15000 / 3600)
|
|
} else {
|
|
duration = route.duration
|
|
}
|
|
|
|
const walkingDuration = distance / (5000 / 3600)
|
|
const drivingDuration: number = route.duration
|
|
|
|
return {
|
|
coordinates,
|
|
distance,
|
|
duration,
|
|
distanceText: formatRouteDistance(distance),
|
|
durationText: formatDuration(duration),
|
|
walkingText: formatDuration(walkingDuration),
|
|
drivingText: formatDuration(drivingDuration),
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepends a hotel→first-waypoint run and appends a last-waypoint→hotel run to the
|
|
* day's activity runs, so the drawn route starts and ends at the day's accommodation
|
|
* (matching the sidebar's hotel connectors). A bookend is only added when both its
|
|
* hotel and the first/last located waypoint exist; passing nulls leaves `runs`
|
|
* untouched. The shared first/last waypoint is repeated so the polylines join.
|
|
*/
|
|
export function withHotelBookends<T extends { lat: number; lng: number }>(
|
|
runs: T[][],
|
|
firstWay: T | undefined,
|
|
lastWay: T | undefined,
|
|
startHotel: T | null,
|
|
endHotel: T | null,
|
|
): T[][] {
|
|
const out: T[][] = []
|
|
if (startHotel && firstWay) out.push([startHotel, firstWay])
|
|
out.push(...runs)
|
|
if (endHotel && lastWay) out.push([lastWay, endHotel])
|
|
return out
|
|
}
|
|
|
|
export function generateGoogleMapsUrl(places: Waypoint[]): string | null {
|
|
const valid = places.filter((p) => p.lat && p.lng)
|
|
if (valid.length === 0) return null
|
|
if (valid.length === 1) {
|
|
return `https://www.google.com/maps/search/?api=1&query=${valid[0].lat},${valid[0].lng}`
|
|
}
|
|
const stops = valid.map((p) => `${p.lat},${p.lng}`).join('/')
|
|
return `https://www.google.com/maps/dir/${stops}`
|
|
}
|
|
|
|
/** A stop that can carry its name into a deep link that has somewhere to put one. */
|
|
export type NamedWaypoint = Waypoint & { name?: string | null }
|
|
|
|
/** TREK's route profiles in CoMaps' vocabulary; a plugin profile has no equivalent and drives. */
|
|
function coMapsRouteType(profile: RouteProfileKey): string {
|
|
if (profile === 'walking') return 'pedestrian'
|
|
if (profile === 'cycling') return 'bicycle'
|
|
return 'vehicle'
|
|
}
|
|
|
|
/**
|
|
* Open a day's stops in CoMaps for offline navigation (#1904).
|
|
*
|
|
* CoMaps has two links and they trade against each other. `route` builds real
|
|
* turn-by-turn in the given travel mode but takes a start and a destination and
|
|
* nothing between them; `map` takes any number of named pins but routes nothing.
|
|
* So a two-stop day goes as a route — everything it has fits, mode included —
|
|
* and a longer one goes as pins, because handing over the whole day and letting
|
|
* CoMaps route leg by leg beats quietly dropping the middle of someone's plan.
|
|
* A day that needs the full itinerary as one navigable track has the GPX export.
|
|
*
|
|
* https rather than `cm://` for the same reason as `getCoMapsUrlForPlace`.
|
|
*/
|
|
export function generateCoMapsUrl(places: NamedWaypoint[], profile: RouteProfileKey = 'driving'): string | null {
|
|
const valid = places.filter((p) => p.lat != null && p.lng != null)
|
|
if (valid.length === 0) return null
|
|
const label = (p: NamedWaypoint) => encodeURIComponent(p.name?.trim() || `${p.lat},${p.lng}`)
|
|
if (valid.length === 2) {
|
|
const [from, to] = valid
|
|
return `https://comaps.at/route?sll=${from.lat},${from.lng}&saddr=${label(from)}`
|
|
+ `&dll=${to.lat},${to.lng}&daddr=${label(to)}&type=${coMapsRouteType(profile)}`
|
|
}
|
|
const pins = valid.map((p) => `ll=${p.lat},${p.lng}&n=${label(p)}`).join('&')
|
|
return `https://comaps.at/map?v=1&${pins}`
|
|
}
|
|
|
|
// Squared planar distance — enough for nearest-neighbor comparisons and cheaper than a full haversine.
|
|
function sqDist(a: Waypoint, b: Waypoint): number {
|
|
return (a.lat - b.lat) ** 2 + (a.lng - b.lng) ** 2
|
|
}
|
|
|
|
// Length of visiting `order` in sequence, optionally pinned to a fixed start and/or end anchor.
|
|
// With start === end this is a closed loop back to the anchor (a day out from and back to the hotel).
|
|
function tourLength(order: Waypoint[], start?: Waypoint, end?: Waypoint): number {
|
|
if (order.length === 0) return 0
|
|
let total = 0
|
|
if (start) total += Math.sqrt(sqDist(start, order[0]))
|
|
for (let i = 0; i < order.length - 1; i++) total += Math.sqrt(sqDist(order[i], order[i + 1]))
|
|
if (end) total += Math.sqrt(sqDist(order[order.length - 1], end))
|
|
return total
|
|
}
|
|
|
|
// Greedy nearest-neighbor ordering, seeded at the start anchor when there is one.
|
|
function nearestNeighborOrder<T extends Waypoint>(valid: T[], start?: Waypoint): T[] {
|
|
const visited = new Set<number>()
|
|
const result: T[] = []
|
|
let current: Waypoint
|
|
if (start) {
|
|
current = start
|
|
} else {
|
|
current = valid[0]
|
|
visited.add(0)
|
|
result.push(valid[0])
|
|
}
|
|
while (result.length < valid.length) {
|
|
let nearestIdx = -1
|
|
let minDist = Infinity
|
|
for (let i = 0; i < valid.length; i++) {
|
|
if (visited.has(i)) continue
|
|
const d = sqDist(valid[i], current)
|
|
if (d < minDist) { minDist = d; nearestIdx = i }
|
|
}
|
|
if (nearestIdx === -1) break
|
|
visited.add(nearestIdx)
|
|
current = valid[nearestIdx]
|
|
result.push(valid[nearestIdx])
|
|
}
|
|
return result
|
|
}
|
|
|
|
// 2-opt: repeatedly reverse a sub-segment whenever it shortens the tour. This removes the crossings
|
|
// a pure nearest-neighbor pass leaves behind. The start/end anchors stay fixed, so a round trip
|
|
// (start === end) is untangled into a clean loop rather than an open path.
|
|
function twoOptImprove<T extends Waypoint>(order: T[], start?: Waypoint, end?: Waypoint): T[] {
|
|
if (order.length < 3) return order
|
|
let best = order
|
|
let bestLen = tourLength(best, start, end)
|
|
let improved = true
|
|
while (improved) {
|
|
improved = false
|
|
for (let i = 0; i < best.length - 1; i++) {
|
|
for (let j = i + 1; j < best.length; j++) {
|
|
const candidate = best.slice(0, i).concat(best.slice(i, j + 1).reverse(), best.slice(j + 1))
|
|
const len = tourLength(candidate, start, end)
|
|
if (len < bestLen - 1e-12) {
|
|
best = candidate
|
|
bestLen = len
|
|
improved = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return best
|
|
}
|
|
|
|
/**
|
|
* Reorders waypoints to minimize travel distance: a nearest-neighbor pass for a good starting order,
|
|
* then 2-opt to untangle crossings. Optional anchors (e.g. the day's accommodation) pin the route's
|
|
* ends — start === end makes it a loop out from and back to the hotel; a transfer day runs start → end.
|
|
*/
|
|
export function optimizeRoute<T extends Waypoint>(places: T[], anchors: RouteAnchors = {}): T[] {
|
|
const { start, end } = anchors
|
|
const valid = places.filter((p) => p.lat && p.lng)
|
|
if (valid.length <= 1) return places
|
|
// Two unanchored stops have no meaningful order to optimize; anchors can still flip them.
|
|
if (valid.length === 2 && !start && !end) return places
|
|
|
|
const order = twoOptImprove(nearestNeighborOrder(valid, start), start, end)
|
|
|
|
// A round trip's loop direction is arbitrary, so orient it to begin at the stop nearest the hotel —
|
|
// that reads naturally as "leave the hotel, head to the closest place, …, come back".
|
|
if (start && end && start.lat === end.lat && start.lng === end.lng && order.length > 1) {
|
|
if (sqDist(order[order.length - 1], start) < sqDist(order[0], start)) order.reverse()
|
|
}
|
|
|
|
return order
|
|
}
|
|
|
|
/** Fetches per-leg distance/duration from OSRM and returns segment metadata (midpoints, walking/driving times). */
|
|
export async function calculateSegments(
|
|
waypoints: Waypoint[],
|
|
{ signal }: { signal?: AbortSignal } = {}
|
|
): Promise<RouteSegment[]> {
|
|
if (!waypoints || waypoints.length < 2) return []
|
|
|
|
const coords = waypoints.map((p) => `${p.lng},${p.lat}`).join(';')
|
|
const url = `${routeBaseFor('driving')}/${coords}?overview=false&geometries=geojson&steps=false&annotations=distance,duration${uTurnParam(waypoints)}`
|
|
|
|
const response = await routedFetch(url, signal, 'segments', 'driving', waypoints)
|
|
if (!response.ok) throw new RoutingRefusedError(response.status, retryAfterMs(response))
|
|
|
|
const data = await response.json()
|
|
if (data.code !== 'Ok' || !data.routes?.[0]) throw new Error('No route found')
|
|
|
|
const legs = data.routes[0].legs
|
|
return legs.map((leg: { distance: number; duration: number }, i: number): RouteSegment => {
|
|
const from: [number, number] = [waypoints[i].lat, waypoints[i].lng]
|
|
const to: [number, number] = [waypoints[i + 1].lat, waypoints[i + 1].lng]
|
|
const mid: [number, number] = [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2]
|
|
const walkingDuration = leg.distance / (5000 / 3600)
|
|
return {
|
|
mid, from, to,
|
|
distance: leg.distance,
|
|
duration: leg.duration,
|
|
walkingText: formatDuration(walkingDuration),
|
|
drivingText: formatDuration(leg.duration),
|
|
distanceText: formatRouteDistance(leg.distance),
|
|
}
|
|
})
|
|
}
|
|
|
|
/**
|
|
* One OSRM call per waypoint-run that returns BOTH the real road geometry (for the
|
|
* map) and per-leg distance/duration (for the sidebar connectors). Results are cached
|
|
* by the exact waypoint list. Throws on OSRM failure so callers can fall back to a
|
|
* straight line.
|
|
*/
|
|
export async function calculateRouteWithLegs(
|
|
waypoints: Waypoint[],
|
|
{ signal, profile = 'driving', tripId, dayId, avoid = [] }: {
|
|
signal?: AbortSignal
|
|
profile?: RouteProfileKey
|
|
tripId?: number | string | null
|
|
dayId?: number | null
|
|
/** Road classes to weight away. Only the driving profile has any, and only Valhalla can. */
|
|
avoid?: readonly AvoidClass[]
|
|
} = {}
|
|
): Promise<RouteWithLegs> {
|
|
if (!waypoints || waypoints.length < 2) {
|
|
return { coordinates: [], distance: 0, duration: 0, legs: [] }
|
|
}
|
|
|
|
const avoiding = avoidedClasses(profile, avoid)
|
|
|
|
const coords = waypoints.map((p) => `${p.lng},${p.lat}`).join(';')
|
|
// The cached result carries formatted leg distances, so the active distance unit is
|
|
// part of the key — otherwise switching km↔mi would return stale text (#1300).
|
|
// A plugin route is trip-/day-specific (it may return different charging stops for
|
|
// the same coordinates on a different day), so its key includes tripId/dayId;
|
|
// the built-in OSRM profiles are context-free and leave those out.
|
|
//
|
|
// The avoidance belongs in the key for two reasons pointing opposite ways. Without it
|
|
// turning the switch on returns the tolled route out of cache in under a millisecond,
|
|
// so nothing on screen changes and it reads as a broken toggle. And the leak the other
|
|
// way is worse: this Map is shared with the ordinary day planner, the studio and the
|
|
// booking geometry, none of which ask for avoidance, so an avoid-routed answer stored
|
|
// under the plain key would hand them a road nobody drives and a second engine's
|
|
// times. So the avoiding key only ever holds a Valhalla answer: when Valhalla cannot
|
|
// answer and OSRM drives the request after all, that answer is filed under the plain
|
|
// key, where it is exactly what an ordinary caller would have got. Filed under the
|
|
// avoiding key it stood in for the avoided road until the next reload, however soon
|
|
// Valhalla came back.
|
|
const pluginScope = profile.startsWith('plugin:') ? `:${tripId ?? ''}:${dayId ?? ''}` : ''
|
|
const avoidScope = avoiding.length ? `:avoid=${avoiding.join(',')}` : ''
|
|
const plainKey = `${profile}:${getDistanceUnit()}:${coords}${pluginScope}`
|
|
const cacheKey = `${plainKey}${avoidScope}`
|
|
const cached = routeCache.get(cacheKey)
|
|
if (cached) return cached
|
|
|
|
if (avoiding.length) {
|
|
const routed = await routeAvoidingWithLegs(waypoints, avoiding, signal)
|
|
if (routed) {
|
|
cacheRoute(cacheKey, routed)
|
|
return routed
|
|
}
|
|
// Null is a Valhalla that could not answer at all. OSRM keeps the day drawn rather
|
|
// than blank, and the answer says that nothing was avoided, with the reason, so the
|
|
// rail flags the day instead of implying the setting held on a road nobody weighed.
|
|
const plain = routeCache.get(plainKey) ?? await osrmWithLegs(waypoints, coords, profile, signal)
|
|
cacheRoute(plainKey, plain)
|
|
return { ...plain, avoidance: { asked: avoiding, achieved: [], fellBack: true } }
|
|
}
|
|
|
|
// Plugin profile (`plugin:<id>/<profile>`): the server invokes that routeProvider
|
|
// and normalizes its answer; null means the provider failed or refused, and the
|
|
// throw makes callers fall back to straight lines exactly like an OSRM outage.
|
|
const pluginProfile = parsePluginProfile(profile)
|
|
if (pluginProfile) {
|
|
if (tripId == null) throw new Error('Plugin routing needs a trip context')
|
|
const { route } = await pluginsApi.pluginRoute(pluginProfile.pluginId, pluginProfile.profileId, {
|
|
tripId,
|
|
dayId: dayId ?? null,
|
|
waypoints: waypoints.map((p) => ({ lat: p.lat, lng: p.lng })),
|
|
}, { signal })
|
|
if (!route) throw new Error('No route found')
|
|
const legs: RouteSegment[] = route.legs.map((leg, i): RouteSegment => {
|
|
const from: [number, number] = [waypoints[i].lat, waypoints[i].lng]
|
|
const to: [number, number] = [waypoints[i + 1].lat, waypoints[i + 1].lng]
|
|
const mid: [number, number] = [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2]
|
|
return {
|
|
mid, from, to,
|
|
distance: leg.distance,
|
|
duration: leg.duration,
|
|
walkingText: formatDuration(leg.distance / (5000 / 3600)),
|
|
drivingText: formatDuration(leg.duration),
|
|
distanceText: formatRouteDistance(leg.distance),
|
|
durationText: formatDuration(leg.duration),
|
|
...(leg.note ? { noteText: leg.note } : {}),
|
|
}
|
|
})
|
|
const result: RouteWithLegs = {
|
|
coordinates: route.coordinates,
|
|
distance: route.distance,
|
|
duration: route.duration,
|
|
legs,
|
|
...(route.viaPoints.length ? { vias: route.viaPoints } : {}),
|
|
}
|
|
routeCache.set(cacheKey, result)
|
|
if (routeCache.size > ROUTE_CACHE_MAX) {
|
|
const oldest = routeCache.keys().next().value
|
|
if (oldest !== undefined) routeCache.delete(oldest)
|
|
}
|
|
return result
|
|
}
|
|
|
|
const result = await osrmWithLegs(waypoints, coords, profile, signal)
|
|
cacheRoute(cacheKey, result)
|
|
return result
|
|
}
|
|
|
|
/** The OSRM answer for a chain, one leg per waypoint pair. Throws like every OSRM call here. */
|
|
async function osrmWithLegs(
|
|
waypoints: Waypoint[],
|
|
coords: string,
|
|
profile: RouteProfileKey,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteWithLegs> {
|
|
// Written as literals rather than narrowing `profile`: its type is an open string union
|
|
// (plugins name their own modes), which no comparison narrows to the three OSRM knows.
|
|
const osrmProfile: 'driving' | 'walking' | 'cycling' =
|
|
profile === 'walking' ? 'walking' : profile === 'cycling' ? 'cycling' : 'driving'
|
|
const url = `${routeBaseFor(osrmProfile)}/${coords}?overview=full&geometries=geojson&annotations=distance,duration${uTurnParam(waypoints)}`
|
|
const response = await routedFetch(url, signal, 'legs', osrmProfile, waypoints)
|
|
if (!response.ok) throw new RoutingRefusedError(response.status, retryAfterMs(response))
|
|
|
|
const data = await response.json()
|
|
if (data.code !== 'Ok' || !data.routes?.[0]) throw new Error('No route found')
|
|
|
|
const route = data.routes[0]
|
|
const coordinates: [number, number][] = route.geometry.coordinates.map(
|
|
([lng, lat]: [number, number]) => [lat, lng]
|
|
)
|
|
const legs: RouteSegment[] = (route.legs || []).map(
|
|
(leg: { distance: number; duration: number }, i: number): RouteSegment => {
|
|
const from: [number, number] = [waypoints[i].lat, waypoints[i].lng]
|
|
const to: [number, number] = [waypoints[i + 1].lat, waypoints[i + 1].lng]
|
|
const mid: [number, number] = [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2]
|
|
const walkingDuration = leg.distance / (5000 / 3600)
|
|
return {
|
|
mid, from, to,
|
|
distance: leg.distance,
|
|
duration: leg.duration,
|
|
walkingText: formatDuration(walkingDuration),
|
|
drivingText: formatDuration(leg.duration),
|
|
distanceText: formatRouteDistance(leg.distance),
|
|
durationText: formatDuration(leg.duration),
|
|
}
|
|
}
|
|
)
|
|
|
|
const snapped = readSnapped(data, waypoints)
|
|
return { coordinates, distance: route.distance, duration: route.duration, legs, ...(snapped ? { snapped } : {}) }
|
|
}
|
|
|
|
/** Store a route and drop the oldest once the cache is over its cap. */
|
|
function cacheRoute(key: string, route: RouteWithLegs): void {
|
|
routeCache.set(key, route)
|
|
if (routeCache.size > ROUTE_CACHE_MAX) {
|
|
const oldest = routeCache.keys().next().value
|
|
if (oldest !== undefined) routeCache.delete(oldest)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A whole chain from the second engine, weighted away from some road classes.
|
|
*
|
|
* Shaped exactly like the OSRM answer above so the callers never branch on which engine
|
|
* spoke — same leg list, same formatted text, same snap positions. What it adds is
|
|
* `avoidance`: what was asked for against what the road actually turned out to be, which
|
|
* is the only honest way to label a weighting that can fail.
|
|
*
|
|
* Null rather than a throw when it cannot answer, so the caller falls through to OSRM
|
|
* and the day stays drawn.
|
|
*/
|
|
async function routeAvoidingWithLegs(
|
|
waypoints: Waypoint[],
|
|
avoid: AvoidClass[],
|
|
signal?: AbortSignal,
|
|
): Promise<RouteWithLegs | null> {
|
|
const sample = {
|
|
profile: 'driving' as const,
|
|
surface: 'legs' as const,
|
|
selfHosted: !!useSettingsStore.getState().settings.routing_base_url?.trim(),
|
|
waypoints: waypoints.length,
|
|
km: waypoints.slice(1).reduce((sum, point, i) => sum + haversineKm(waypoints[i], point), 0),
|
|
}
|
|
const run = await valhallaRun(waypoints, 'driving', avoid, signal)
|
|
// Counted by hand because the adapter speaks to a different engine with a different
|
|
// verb, and the counter exists to answer "how much routing does this instance do" —
|
|
// an engine it cannot see is exactly the traffic that would go missing from it.
|
|
if (!signal?.aborted) countRoute({ ...sample, failed: !run })
|
|
if (!run) return null
|
|
|
|
const legs: RouteSegment[] = run.legs.map((leg, i): RouteSegment => {
|
|
const from: [number, number] = [waypoints[i].lat, waypoints[i].lng]
|
|
const to: [number, number] = [waypoints[i + 1].lat, waypoints[i + 1].lng]
|
|
return {
|
|
mid: [(from[0] + to[0]) / 2, (from[1] + to[1]) / 2],
|
|
from,
|
|
to,
|
|
distance: leg.distance,
|
|
duration: leg.duration,
|
|
walkingText: formatDuration(leg.distance / (5000 / 3600)),
|
|
drivingText: formatDuration(leg.duration),
|
|
distanceText: formatRouteDistance(leg.distance),
|
|
durationText: formatDuration(leg.duration),
|
|
}
|
|
})
|
|
|
|
return {
|
|
coordinates: run.total.coordinates,
|
|
distance: run.total.distance,
|
|
duration: run.total.duration,
|
|
legs,
|
|
snapped: run.snapped,
|
|
avoidance: { asked: avoid, achieved: avoid.filter(cls => legAvoids(run.total, cls)) },
|
|
hasFerry: run.total.hasFerry,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The snap positions out of an OSRM answer, or undefined if it did not describe them.
|
|
*
|
|
* OSRM reports this in every response and TREK has thrown it away since the first route
|
|
* was drawn. `distance` is the straight line from the coordinate we sent to the road it
|
|
* used; it is recomputed from the two points when the field is missing or nonsense, so a
|
|
* mirror that trims its answers still produces a usable gap rather than a wrong one.
|
|
*
|
|
* All-or-nothing on purpose: a partial list would have to be indexed by waypoint anyway,
|
|
* and one bad entry would put a spur on the wrong stop.
|
|
*/
|
|
function readSnapped(data: unknown, waypoints: Waypoint[]): SnappedWaypoint[] | undefined {
|
|
const raw = (data as { waypoints?: unknown })?.waypoints
|
|
if (!Array.isArray(raw) || raw.length !== waypoints.length) return undefined
|
|
const out: SnappedWaypoint[] = []
|
|
for (let i = 0; i < raw.length; i++) {
|
|
const loc = (raw[i] as { location?: unknown })?.location
|
|
if (!Array.isArray(loc) || loc.length < 2) return undefined
|
|
const [lng, lat] = loc as [number, number]
|
|
if (!Number.isFinite(lat) || !Number.isFinite(lng)) return undefined
|
|
const asked: [number, number] = [waypoints[i].lat, waypoints[i].lng]
|
|
const at: [number, number] = [lat, lng]
|
|
const reported = (raw[i] as { distance?: unknown })?.distance
|
|
const meters = typeof reported === 'number' && Number.isFinite(reported) && reported >= 0
|
|
? reported
|
|
: haversineKm({ lat: asked[0], lng: asked[1] }, { lat, lng }) * 1000
|
|
out.push({ asked, at, meters })
|
|
}
|
|
return out
|
|
}
|
|
|
|
function getDistanceUnit(): DistanceUnit {
|
|
return useSettingsStore.getState().settings.distance_unit === 'imperial' ? 'imperial' : 'metric'
|
|
}
|
|
|
|
function formatRouteDistance(meters: number): string {
|
|
const unit = getDistanceUnit()
|
|
if (unit === 'metric' && meters < 1000) {
|
|
return `${Math.round(meters)} m`
|
|
}
|
|
return formatDistance(meters / 1000, unit)
|
|
}
|
|
|
|
function formatDuration(seconds: number): string {
|
|
const h = Math.floor(seconds / 3600)
|
|
const m = Math.floor((seconds % 3600) / 60)
|
|
if (h > 0) {
|
|
return `${h} h ${m} min`
|
|
}
|
|
return `${m} min`
|
|
}
|
|
|
|
/** One way of driving a leg, as a router offers it. */
|
|
export interface RouteAlternative {
|
|
coordinates: [number, number][]
|
|
distance: number
|
|
duration: number
|
|
/** Where this route differs most from the first one — the point that would pin it. */
|
|
divergence: { lat: number; lng: number } | null
|
|
/** Set when this way exists because a road class was left out of it. */
|
|
avoids?: AvoidClass
|
|
/**
|
|
* Which engine priced this route. Absent means OSRM, which is what answers every route
|
|
* of a trip that avoids nothing, except the avoidance offer on a default install.
|
|
*
|
|
* It exists because the engines do not agree on speed: measured over twelve European
|
|
* legs the per-leg drive times run from 14.7 % under OSRM's to 13.2 % over, and the
|
|
* sign depends on the region: Valhalla is faster on Spanish autovía and slower through
|
|
* a city. So a figure from one of them subtracted from a figure from the other is not a
|
|
* difference in driving time, it is the gap between two speed models, and the reader
|
|
* has no way of telling the two apart.
|
|
*/
|
|
engine?: RouteEngine
|
|
/** Whether the way crosses by ferry, where the engine that drew it says so. */
|
|
hasFerry?: boolean
|
|
}
|
|
|
|
/** What two routes are compared by: their line, and their figures where there is none. */
|
|
export type RoadLine = Pick<RouteAlternative, 'coordinates' | 'distance' | 'duration'>
|
|
|
|
/**
|
|
* Road classes worth asking the router to leave out, in the order they are tried.
|
|
*
|
|
* OSRM's own alternative search is conservative: it only offers a second road when the
|
|
* detour is short enough and shares little enough with the first, so on a long motorway
|
|
* run it usually answers with exactly one route — while a perfectly good, slower way over
|
|
* the B-roads exists and is what somebody opening "other ways" is looking for. Excluding
|
|
* a class asks a different question and reliably produces that road.
|
|
*
|
|
* Only for driving: the foot and bike profiles have no excludable classes, and asking
|
|
* anyway earns an `InvalidOptions` for nothing.
|
|
*
|
|
* Ferry is on the list for Valhalla's sake and skipped on the OSRM path below. OSRM
|
|
* does carry a ferry class, but on a leg where a ferry is the only crossing it answers
|
|
* NoRoute rather than the long way round, which is not an alternative anybody can use.
|
|
* Valhalla weights it instead and drives around, which is the whole point.
|
|
*/
|
|
const EXCLUDABLE_CLASSES = ['motorway', 'toll', 'ferry'] as const
|
|
|
|
/**
|
|
* How far two lines may stray from each other and still be the same road, in kilometres.
|
|
*
|
|
* Parallel carriageways, a different slip road onto the same motorway and the noise
|
|
* between two engines' idea of where a road is all sit well under this. A way somebody
|
|
* would call an alternative leaves it by kilometres: the ferry-free run from Hamburg to
|
|
* Copenhagen, which is a genuinely different road, peaks 2.3 km off the default.
|
|
*/
|
|
const SAME_ROAD_KM = 0.5
|
|
|
|
/**
|
|
* Two lines are the same road.
|
|
*
|
|
* Length and duration used to decide this, and stopped being enough when a second engine
|
|
* started answering. Valhalla prices roads differently: measured over twelve European
|
|
* legs its distances ran 1.8 % above OSRM's, so on a 470 km leg the same road comes back
|
|
* thirteen kilometres apart and a 200 m tolerance calls it a discovery. Two identical
|
|
* blue lines on the map is exactly what that looks like. Duration is the worse of the
|
|
* two to lean on: over the same twelve legs it ranged from 14.7 % under OSRM's to 13.2 %
|
|
* over, with the sign set by the region rather than by the road.
|
|
*
|
|
* The geometry does not care which engine drew it, so it decides whenever there is one.
|
|
* The numbers stay as the fallback for a line with no shape to compare.
|
|
*
|
|
* Measured both ways round. Asked only whether `b` stays near `a`, a road that runs the
|
|
* whole of `b` and then turns off to a point and back passed as `b`, because every point
|
|
* of `b` is on it; that is exactly the shape of a leg bent by a via, and the picker and
|
|
* the check behind a choice both have to tell it from the plain road.
|
|
*/
|
|
export function sameRoad(a: RoadLine, b: RoadLine): boolean {
|
|
const there = furthestFrom(b.coordinates, a.coordinates)
|
|
const back = furthestFrom(a.coordinates, b.coordinates)
|
|
if (there && back) return Math.max(there.km, back.km) < SAME_ROAD_KM
|
|
return Math.abs(a.distance - b.distance) < 200 && Math.abs(a.duration - b.duration) < 60
|
|
}
|
|
|
|
/**
|
|
* Hosts that have already answered "I do not do exclude", by base URL.
|
|
*
|
|
* Both public hosts TREK ships with reject the parameter outright with HTTP 400: the
|
|
* upstream car profile is built without excludable classes, and only a self-hosted OSRM
|
|
* built through the MLD pipeline supports it. Without this, every long leg on a default
|
|
* install pays two extra requests to be told twice that it cannot have what it asked for,
|
|
* against a host that allows one request per second.
|
|
*
|
|
* The first real attempt is the probe; there is no separate one. Only a 400 is recorded,
|
|
* because only a 400 is about the host rather than about this particular question: a 429
|
|
* is a rate limit, an abort is the user moving on, and a `NoRoute` means this leg has no
|
|
* way round the motorway while the next one might.
|
|
*
|
|
* Per base URL rather than global, so pointing the instance at an own router that does
|
|
* support it starts asking again without a reload.
|
|
*/
|
|
const excludeUnsupported = new Set<string>()
|
|
|
|
/**
|
|
* One route with a road class left out, or null when the router will not or cannot.
|
|
*
|
|
* Every failure is a null: a rate limit answers 429, and a leg with no way round the
|
|
* motorway answers `NoRoute`. Neither is worth an error on screen — they just mean this
|
|
* particular question had no answer.
|
|
*/
|
|
async function routeExcluding(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
profile: 'driving' | 'walking' | 'cycling',
|
|
exclude: AvoidClass,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteAlternative | null> {
|
|
// Valhalla first, because on a default install it is the only one of the two that
|
|
// can answer at all. It weights the class away instead of banning it, so it also
|
|
// answers on a leg where the class cannot be avoided — and says so, which is why the
|
|
// result is thrown away below unless the road really came back without it.
|
|
const weighted = await valhallaExcluding(from, to, profile, exclude, signal)
|
|
if (weighted) return weighted
|
|
|
|
// OSRM has a ferry class too, but on a leg where the ferry IS the crossing it answers
|
|
// NoRoute rather than driving round, so there is nothing to offer and no point paying
|
|
// a request to be told so.
|
|
if (exclude === 'ferry') return null
|
|
return osrmExcluding(from, to, profile, exclude, signal)
|
|
}
|
|
|
|
/**
|
|
* The same leg from Valhalla, weighted away from one class, or null.
|
|
*
|
|
* The check that makes this honest is `legAvoids`: `use_tolls: 0` is a preference, so
|
|
* between two points with no untolled connection the answer is still a tolled road.
|
|
* Offering that as "No tolls" would put a lie on the map, so it is dropped and the
|
|
* OSRM attempt gets its turn.
|
|
*/
|
|
async function valhallaExcluding(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
profile: 'driving' | 'walking' | 'cycling',
|
|
exclude: AvoidClass,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteAlternative | null> {
|
|
if (!valhallaAvailable()) return null
|
|
const sample = {
|
|
profile,
|
|
surface: 'alternatives' as const,
|
|
selfHosted: !!useSettingsStore.getState().settings.routing_base_url?.trim(),
|
|
waypoints: 2,
|
|
km: haversineKm(from, to),
|
|
}
|
|
const leg = await valhallaRouteAvoiding(from, to, profile, exclude, signal)
|
|
// Counted here rather than in the adapter, so the adapter stays a format translator
|
|
// and every routing request an instance makes still lands in the one counter.
|
|
if (!signal?.aborted) countRoute({ ...sample, failed: !leg })
|
|
if (!leg || !legAvoids(leg, exclude)) return null
|
|
return valhallaOffer(leg)
|
|
}
|
|
|
|
/** A Valhalla leg as an offer, carrying the engine that priced it and what it crosses. */
|
|
function valhallaOffer(leg: ValhallaLeg): RouteAlternative {
|
|
return {
|
|
coordinates: leg.coordinates,
|
|
distance: leg.distance,
|
|
duration: leg.duration,
|
|
divergence: null,
|
|
engine: 'valhalla',
|
|
hasFerry: leg.hasFerry,
|
|
}
|
|
}
|
|
|
|
/** The same leg from OSRM with the class excluded outright, or null. */
|
|
async function osrmExcluding(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
profile: 'driving' | 'walking' | 'cycling',
|
|
exclude: AvoidClass,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteAlternative | null> {
|
|
const base = routeBaseFor(profile)
|
|
if (excludeUnsupported.has(base)) return null
|
|
try {
|
|
const coords = `${from.lng},${from.lat};${to.lng},${to.lat}`
|
|
const url = `${base}/${coords}?exclude=${exclude}&overview=full&geometries=geojson`
|
|
const response = await routedFetch(url, signal, 'alternatives', profile, [from, to])
|
|
if (!response.ok) {
|
|
// 400 is the router saying the parameter itself is not available here, which is
|
|
// true of every leg from now on. Anything else is about this request alone.
|
|
if (response.status === 400) excludeUnsupported.add(base)
|
|
return null
|
|
}
|
|
const data = await response.json()
|
|
const route = data?.code === 'Ok' && Array.isArray(data.routes) ? data.routes[0] : null
|
|
if (!route?.geometry?.coordinates?.length) return null
|
|
return {
|
|
coordinates: route.geometry.coordinates.map(([lng, lat]: [number, number]) => [lat, lng] as [number, number]),
|
|
distance: route.distance,
|
|
duration: route.duration,
|
|
divergence: null,
|
|
}
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The ways of driving one leg, not one day.
|
|
*
|
|
* Deliberately per leg: OSRM only offers alternatives between exactly two coordinates, so
|
|
* asking for a whole day would mean splitting it into one request per leg — which is the
|
|
* bundling `splitIntoRuns` exists to avoid, and the reason a road trip appears at once
|
|
* instead of trickling in. Asked for a single leg, on demand, it costs one extra request.
|
|
*
|
|
* `divergence` is the point on each alternative that lies furthest from the default route.
|
|
* It is what makes a choice persistable: saving that point as a via forces the router back
|
|
* onto this road on every future request, without storing a polyline that would go stale
|
|
* with the next OSM update.
|
|
*
|
|
* `avoid` is the classes the trip weighs away. A driving leg of such a trip is routed by
|
|
* Valhalla, so its offers come from Valhalla too, weighed the same way, and never from
|
|
* OSRM: a list holding both engines is what offered a road the rail was not on as the
|
|
* quicker one, and clicking it changed nothing.
|
|
*/
|
|
export async function calculateAlternatives(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
profile: 'driving' | 'walking' | 'cycling' = 'driving',
|
|
{ signal, limit = 3, avoid = [] }: { signal?: AbortSignal; limit?: number; avoid?: readonly AvoidClass[] } = {},
|
|
): Promise<RouteAlternative[]> {
|
|
const avoiding = avoidedClasses(profile, avoid)
|
|
const routes = avoiding.length
|
|
? await alternativesAvoiding(from, to, avoiding, limit, signal)
|
|
: await alternativesFromOsrm(from, to, profile, limit, signal)
|
|
if (!routes.length) return routes
|
|
|
|
// The first route is what the router would have given anyway; the others are measured
|
|
// against it so each one can be pinned by the point that makes it different.
|
|
const [primary, ...rest] = routes
|
|
for (const alt of rest) alt.divergence = furthestPointFrom(alt.coordinates, primary.coordinates)
|
|
return routes
|
|
}
|
|
|
|
/**
|
|
* The offers for a leg of a trip that weighs classes away, every one of them Valhalla's.
|
|
*
|
|
* Throws when Valhalla has nothing to say, so the picker reports a router that is not
|
|
* answering. Quietly offering OSRM's roads instead is the very mix this path exists to end.
|
|
*
|
|
* One way back gets the question the OSRM path asks too: the same drive with one more
|
|
* class left out, only of those the trip does not already avoid, and only where the road
|
|
* that comes back really is without it. Paced like the pieces of a split day, because the
|
|
* public instance allows one request a second.
|
|
*/
|
|
async function alternativesAvoiding(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
avoiding: AvoidClass[],
|
|
limit: number,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteAlternative[]> {
|
|
const sample = {
|
|
profile: 'driving' as const,
|
|
surface: 'alternatives' as const,
|
|
selfHosted: !!useSettingsStore.getState().settings.routing_base_url?.trim(),
|
|
waypoints: 2,
|
|
km: haversineKm(from, to),
|
|
}
|
|
const answered = await valhallaAlternates(from, to, 'driving', avoiding, Math.max(0, limit - 1), signal)
|
|
if (!signal?.aborted) countRoute({ ...sample, failed: !answered })
|
|
if (!answered?.length) throw new Error('No route found')
|
|
|
|
const routes: RouteAlternative[] = []
|
|
for (const leg of answered) {
|
|
const offer = valhallaOffer(leg)
|
|
if (!routes.some(r => sameRoad(r, offer))) routes.push(offer)
|
|
}
|
|
if (routes.length >= 2) return routes
|
|
|
|
for (const cls of EXCLUDABLE_CLASSES) {
|
|
if (avoiding.includes(cls)) continue
|
|
await valhallaSpacing(signal)
|
|
if (signal?.aborted) break
|
|
const run = await valhallaRun([from, to], 'driving', [...avoiding, cls], signal)
|
|
if (!signal?.aborted) countRoute({ ...sample, failed: !run })
|
|
if (!run || !legAvoids(run.total, cls)) continue
|
|
const detour = valhallaOffer(run.total)
|
|
if (routes.some(r => sameRoad(r, detour))) continue
|
|
routes.push({ ...detour, avoids: cls })
|
|
break
|
|
}
|
|
return routes
|
|
}
|
|
|
|
/** The offers for a leg of a trip that avoids nothing: OSRM's, and one avoidance offer. */
|
|
async function alternativesFromOsrm(
|
|
from: Waypoint,
|
|
to: Waypoint,
|
|
profile: 'driving' | 'walking' | 'cycling',
|
|
limit: number,
|
|
signal?: AbortSignal,
|
|
): Promise<RouteAlternative[]> {
|
|
const coords = `${from.lng},${from.lat};${to.lng},${to.lat}`
|
|
const url = `${routeBaseFor(profile)}/${coords}?alternatives=${limit}&overview=full&geometries=geojson`
|
|
const response = await routedFetch(url, signal, 'alternatives', profile, [from, to])
|
|
if (!response.ok) throw new RoutingRefusedError(response.status, retryAfterMs(response))
|
|
|
|
const data = await response.json()
|
|
if (data.code !== 'Ok' || !Array.isArray(data.routes) || !data.routes.length) return []
|
|
|
|
const routes: RouteAlternative[] = data.routes.map((r: { geometry: { coordinates: [number, number][] }; distance: number; duration: number }) => ({
|
|
coordinates: r.geometry.coordinates.map(([lng, lat]) => [lat, lng] as [number, number]),
|
|
distance: r.distance,
|
|
duration: r.duration,
|
|
divergence: null,
|
|
}))
|
|
|
|
// Nothing but the router's own preference came back, which is what it answers on most
|
|
// long legs. Rather than reporting "only one sensible way", ask a different question:
|
|
// the same drive without the motorway, then without the tolls, then without a ferry.
|
|
// Tried one at a time and stopped as soon as one lands, so a leg that does have a
|
|
// second road costs one extra request rather than three.
|
|
//
|
|
// This used to produce nothing at all on a default install: OSRM's `exclude` is HTTP
|
|
// 400 on both public hosts, whose car profile is built without excludable classes. It
|
|
// now asks Valhalla first, where avoidance is a runtime weighting, and only falls back
|
|
// to OSRM's `exclude` for an instance running its own MLD-built router.
|
|
if (routes.length < 2 && profile === 'driving') {
|
|
for (const exclude of EXCLUDABLE_CLASSES) {
|
|
if (signal?.aborted) break
|
|
const detour = await routeExcluding(from, to, profile, exclude, signal)
|
|
if (detour && !routes.some(r => sameRoad(r, detour))) {
|
|
detour.avoids = exclude
|
|
routes.push(detour)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return routes
|
|
}
|
|
|
|
/** The point of `line` that lies furthest from `reference`, in plain degrees. */
|
|
function furthestPointFrom(line: [number, number][], reference: [number, number][]): { lat: number; lng: number } | null {
|
|
const furthest = furthestFrom(line, reference)
|
|
return furthest ? { lat: furthest.lat, lng: furthest.lng } : null
|
|
}
|
|
|
|
/**
|
|
* The same point, plus how far off it actually is.
|
|
*
|
|
* The search itself stays in squared degrees with a cosine on the longitude: it only has
|
|
* to ORDER the candidates, and a haversine per pair of a 200-by-200 comparison buys
|
|
* nothing for it. The winner is converted once at the end, because `sameRoad` needs a
|
|
* real distance rather than a rank, and half a degree is a different number of metres in
|
|
* Andalusia than in Lapland.
|
|
*
|
|
* `index` is where on `line` the point sits, so points taken off one line can be put back
|
|
* in the order that line drives through them.
|
|
*/
|
|
export function furthestFrom(
|
|
line: [number, number][],
|
|
reference: [number, number][],
|
|
): { index: number; lat: number; lng: number; km: number } | null {
|
|
if (!line.length || !reference.length) return null
|
|
// Every tenth vertex is plenty: alternatives differ over kilometres, not metres, and a
|
|
// full cross product of two thousand-point lines is not worth the milliseconds.
|
|
const step = Math.max(1, Math.floor(reference.length / 200))
|
|
let bestIndex = -1
|
|
let bestNeighbour: [number, number] | null = null
|
|
let bestDist = -1
|
|
for (let i = 0; i < line.length; i += Math.max(1, Math.floor(line.length / 200))) {
|
|
const near = nearestOn(line[i], reference, step)
|
|
if (near.d > bestDist) { bestDist = near.d; bestIndex = i; bestNeighbour = near.at }
|
|
}
|
|
if (bestIndex < 0) return null
|
|
const [lat, lng] = line[bestIndex]
|
|
const km = bestNeighbour ? haversineKm({ lat, lng }, { lat: bestNeighbour[0], lng: bestNeighbour[1] }) : 0
|
|
return { index: bestIndex, lat, lng, km }
|
|
}
|
|
|
|
/**
|
|
* Where `reference` passes closest to `point`, as a squared distance in the same scaled
|
|
* degrees and the spot on the line it was measured to.
|
|
*
|
|
* Coarse, then fine. The sampled vertices find the stretch, and the segments either side
|
|
* of the nearest one find the road itself. Measured to the sampled vertex alone, a point
|
|
* on the very same road sat up to half a sample apart from it, which on a thousand
|
|
* kilometre leg is kilometres: two engines' lines of one motorway then read as two roads.
|
|
*/
|
|
function nearestOn(
|
|
point: [number, number],
|
|
reference: [number, number][],
|
|
step: number,
|
|
): { d: number; at: [number, number] } {
|
|
const cos = Math.cos((point[0] * Math.PI) / 180)
|
|
const squared = (p: [number, number]): number => {
|
|
const dLat = point[0] - p[0]
|
|
const dLng = (point[1] - p[1]) * cos
|
|
return dLat * dLat + dLng * dLng
|
|
}
|
|
let nearestIndex = 0
|
|
let nearest = Infinity
|
|
for (let j = 0; j < reference.length; j += step) {
|
|
const d = squared(reference[j])
|
|
if (d < nearest) { nearest = d; nearestIndex = j }
|
|
}
|
|
let at = reference[nearestIndex]
|
|
const last = Math.min(reference.length - 1, nearestIndex + step)
|
|
for (let k = Math.max(0, nearestIndex - step); k < last; k++) {
|
|
const on = closestOnSegment(point, reference[k], reference[k + 1], cos)
|
|
const d = squared(on)
|
|
if (d < nearest) { nearest = d; at = on }
|
|
}
|
|
return { d: nearest, at }
|
|
}
|
|
|
|
/** The point of segment a-b closest to `p`, with longitude scaled by `cos` so the plane is fair. */
|
|
function closestOnSegment(
|
|
p: [number, number],
|
|
a: [number, number],
|
|
b: [number, number],
|
|
cos: number,
|
|
): [number, number] {
|
|
const dx = (b[1] - a[1]) * cos
|
|
const dy = b[0] - a[0]
|
|
const length = dx * dx + dy * dy
|
|
if (length === 0) return a
|
|
const t = Math.max(0, Math.min(1, (((p[1] - a[1]) * cos) * dx + (p[0] - a[0]) * dy) / length))
|
|
return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
|
|
}
|