@mark1russell7/highways 0.4.1 → 0.4.2

package/src/highways/gates/model.ts

@@ -0,0 +1,129 @@
+import { polylineLength } from "../../geom.ts";
+import type { Graph } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import type { WayOptions } from "../../ways.ts";
+import { follow } from "../follow.ts";
+import type { Highway, HighwayInput, HighwayMember, HighwayPlan } from "../model.ts";
+import { wayOptionsOf } from "../router.ts";
+
+/**
+ * A gate: a rule that keeps, drops or changes the highways of a plan. `gateStrategy` puts a gate after a highway strategy.
+ * A gate does not move a spine. It takes members out of a highway, drops a highway or changes the id of a highway.
+ */
+export interface Gate<G extends object> {
+  /** The name of the gate. The strategy of a gate has the name `<strategy>+<gate>`. */
+  readonly name: string;
+  /** One or two sentences that tell what the gate does. */
+  readonly describe: string;
+  /** The values of the options of the gate. Their keys must not be keys of the options of the strategy before the gate. */
+  readonly defaults: G;
+  readonly schema: OptionSchema<G>;
+  /** This function gives the plan after the gate. `way` holds the options of the way finder of the strategy. */
+  apply(input: HighwayInput, plan: HighwayPlan, options: Readonly<G>, way: WayOptions): HighwayPlan;
+}
+
+/**
+ * This function puts a gate after a highway strategy. The new strategy has the name `<strategy>+<gate>`, and the options of both.
+ * The strategy gets its own options, and the gate gets the plan of the strategy and the options of the gate.
+ * Thus a gate can follow each plan, for example `corridors+breakeven` or `shared-ways+stretch`. Gates can follow gates.
+ */
+export function gateStrategy<O extends object, G extends object>(strategy: Strategy<"highway", O>, gate: Gate<G>): Strategy<"highway", O & G> {
+  const keys = Object.keys(gate.defaults);
+  for (const k of keys) if (k in strategy.defaults) throw new Error(`The gate "${gate.name}" has the option "${k}", and the strategy "${strategy.name}" has it too.`);
+  return defineStrategy<"highway", O & G>({
+    step: "highway",
+    name: `${strategy.name}+${gate.name}`,
+    describe: `${strategy.describe} ${gate.describe}`,
+    defaults: { ...strategy.defaults, ...gate.defaults } as O & G,
+    schema: { ...(strategy.schema ?? {}), ...gate.schema } as OptionSchema<O & G>,
+    ...(strategy.maxNodes === undefined ? {} : { maxNodes: strategy.maxNodes }),
+    run: (input: HighwayInput, options: Readonly<O & G>): HighwayPlan => {
+      const own: Record<string, unknown> = {};
+      const mine: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(options)) (keys.includes(k) ? mine : own)[k] = v;
+      return gate.apply(input, strategy.run(input, own as Partial<O>), mine as G, wayOptionsOf(options));
+    },
+  });
+}
+
+/**
+ * This function gives the plan with only the members that `keep` accepts. A highway with fewer than two members goes away.
+ * The lanes keep their order, and each highway keeps its id, its key and its spine.
+ */
+export function keepMembers(plan: HighwayPlan, keep: (h: Highway, m: HighwayMember) => boolean): HighwayPlan {
+  const highways: Highway[] = [];
+  for (const h of plan.highways) {
+    const members = h.members.filter((m) => keep(h, m));
+    if (members.length < 2) continue;
+    if (members.length === h.members.length) {
+      highways.push(h);
+      continue;
+    }
+    const stay = new Set(members.map((m) => m.edge));
+    highways.push({ ...h, lanes: h.lanes.filter((e) => stay.has(e)), members });
+  }
+  return { highways };
+}
+
+/** The lengths of the route of one edge of a plan. */
+export interface EdgeLengths {
+  /** The length of the route along the plan, after `follow`. */
+  readonly route: number;
+  /** The length of the route without a highway: the route of the router `corners`. */
+  readonly alone: number;
+}
+
+/**
+ * This function gives the length of the route of each edge of a plan, along the plan and alone. `follow` routes each edge of a plan on its own.
+ * Thus the route of an edge does not change when another edge leaves the plan.
+ */
+export function edgeLengths(graph: Graph, plan: HighwayPlan, way: WayOptions): Map<string, EdgeLengths> {
+  const edges = new Set(plan.highways.flatMap((h) => h.members.map((m) => m.edge)));
+  const sub: Graph = { nodes: graph.nodes, edges: graph.edges.filter((e) => edges.has(e.id)) };
+  const along = follow(sub, plan, way);
+  const alone = follow(sub, { highways: [] }, way);
+  const lengthOf = new Map(alone.routes.map((r) => [r.edge, polylineLength(r.points)]));
+  return new Map(along.routes.map((r) => [r.edge, { route: polylineLength(r.points), alone: lengthOf.get(r.edge) ?? 0 }]));
+}
+
+/** This function gives the ids of the edges that both graphs have. */
+export function commonEdges(a: Graph, b: Graph): Set<string> {
+  const ids = new Set(b.edges.map((e) => e.id));
+  return new Set(a.edges.map((e) => e.id).filter((id) => ids.has(id)));
+}
+
+/** This function gives the Jaccard index of two sets of edges: the common edges over all edges. Two empty sets give 0. */
+export function jaccard(a: ReadonlySet<string>, b: ReadonlySet<string>): number {
+  let common = 0;
+  for (const x of a) if (b.has(x)) common++;
+  const all = a.size + b.size - common;
+  return all === 0 ? 0 : common / all;
+}
+
+/**
+ * This function matches the highways of a plan with the highways of an earlier plan. It pairs the highways with the largest Jaccard index of their edges first.
+ * A pair needs an index of `min` or more. Each highway is in one pair at most. The result maps the index of a new highway to the index of its old highway.
+ * Only the edges of `edges` count, when this set is present: for example the edges of both graphs.
+ */
+export function matchHighways(before: HighwayPlan, after: HighwayPlan, min: number, edges?: ReadonlySet<string>): Map<number, number> {
+  const setOf = (h: Highway): Set<string> => new Set(h.members.map((m) => m.edge).filter((e) => edges?.has(e) ?? true));
+  const old = before.highways.map(setOf);
+  const now = after.highways.map(setOf);
+  const pairs: [j: number, i: number, i0: number][] = [];
+  now.forEach((a, i) =>
+    old.forEach((b, i0) => {
+      const j = jaccard(a, b);
+      if (j >= min && j > 0) pairs.push([j, i, i0]);
+    }),
+  );
+  pairs.sort((p, q) => q[0] - p[0] || p[1] - q[1] || p[2] - q[2]);
+  const out = new Map<number, number>();
+  const used = new Set<number>();
+  for (const [, i, i0] of pairs) {
+    if (out.has(i) || used.has(i0)) continue;
+    out.set(i, i0);
+    used.add(i0);
+  }
+  return out;
+}

package/src/highways/gates/stretch/index.ts

@@ -0,0 +1,39 @@
+import type { WayOptions } from "../../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../../model.ts";
+import { edgeLengths, keepMembers, type Gate } from "../model.ts";
+
+/** The options of the gate `stretch` (HWY-048). */
+export interface StretchOptions {
+  /** An edge stays on its highways when its route is at most this number times its route alone, plus `pad`. The default is 1.2. */
+  readonly budget: number;
+  /** The added length that each edge can use, in units of the board. The default is 0. */
+  readonly pad: number;
+}
+
+/** The default options of the gate `stretch`. */
+export const STRETCH_DEFAULTS: Readonly<StretchOptions> = Object.freeze({ budget: 1.2, pad: 0 });
+
+/**
+ * This function applies the stretch budget of HWY-048 to a plan: the join test of each edge.
+ * An edge stays on its highways only when its route along the plan is at most `budget` times its route alone, plus `pad`.
+ * The route alone is the route of the router `corners`. An edge that fails leaves each of its highways and goes alone, so the highways do not bend for it.
+ * `follow` routes each edge on its own, so the test of one edge does not change with the other edges. One pass is enough.
+ */
+export function stretchPlan(input: HighwayInput, plan: HighwayPlan, options: Readonly<StretchOptions>, way: WayOptions = {}): HighwayPlan {
+  const lengths = edgeLengths(input.graph, plan, way);
+  const out = new Set<string>();
+  for (const [edge, l] of lengths) if (l.route > options.budget * l.alone + options.pad + 1e-9) out.add(edge);
+  return out.size === 0 ? plan : keepMembers(plan, (_, m) => !out.has(m.edge));
+}
+
+/** The gate `stretch` (HWY-048): an edge joins a highway only when its route stays in a budget of its route alone. */
+export const stretchGate: Gate<StretchOptions> = {
+  name: "stretch",
+  describe: "The gate `stretch` (HWY-048) keeps an edge on a highway only when its route is at most `budget` times its route alone, plus `pad`.",
+  defaults: STRETCH_DEFAULTS,
+  schema: {
+    budget: { type: "number", min: 1, max: 2, step: 0.05, marks: [1.1, 1.2, 1.3, 1.5], default: 1.2, describe: "The largest ratio of the route along the plan to the route alone." },
+    pad: { type: "number", min: 0, max: 40, step: 5, default: 0, describe: "The added length that each edge can use, in units of the board." },
+  },
+  apply: stretchPlan,
+};

package/src/highways/grouped.ts

@@ -0,0 +1,123 @@
+import { dist, polylineLength, type Point } from "../geom.ts";
+import { orderLanes } from "../segments.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+import { tidyPlan } from "./base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "./model.ts";
+import { sharedWaysPlan } from "./shared-ways/index.ts";
+import { edgePlugs } from "./stretches.ts";
+
+/**
+ * The spine of a group of edges. With `shared`, the edges of each group go through the router `shared` with the group as their key.
+ * Each stretch that they share is a highway. With `trunk`, each group gets one trunk between two terminals, with a leg from each plug.
+ */
+export type GroupSpine = "shared" | "trunk";
+
+/** The values of `GroupSpine`. */
+export const GROUP_SPINES: readonly GroupSpine[] = Object.freeze(["shared", "trunk"]);
+
+/** The group of one edge: its key, and `flip` when the edge goes from the second end of the group to the first end. */
+export interface EdgeGroup {
+  readonly key: string;
+  readonly flip: boolean;
+}
+
+/** The options of `groupedPlan`. */
+export interface GroupedOptions extends WayOptions {
+  readonly spine: GroupSpine;
+  /** A group has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+  /**
+   * With the spine `trunk`, an edge rides the trunk only when each of its legs is this share of the span or shorter.
+   * The span is the distance between the two terminals. `Infinity` sets no limit.
+   */
+  readonly legMax?: number;
+}
+
+/**
+ * This function gives the geometric median of points (the Weber point), with the iterations of Weiszfeld.
+ * The point has the least sum of the distances to the points.
+ */
+export function weberPoint(points: readonly Point[], iterations = 32): Point {
+  if (points.length === 0) throw new Error("The list has no point.");
+  let p = { x: points.reduce((s, q) => s + q.x, 0) / points.length, y: points.reduce((s, q) => s + q.y, 0) / points.length };
+  for (let k = 0; k < iterations; k++) {
+    let wx = 0;
+    let wy = 0;
+    let w = 0;
+    for (const q of points) {
+      const d = dist(p, q);
+      if (d < 1e-9) return q;
+      wx += q.x / d;
+      wy += q.y / d;
+      w += 1 / d;
+    }
+    const next = { x: wx / w, y: wy / w };
+    if (dist(next, p) < 1e-6) return next;
+    p = next;
+  }
+  return p;
+}
+
+/**
+ * This function gives the highways of the groups of edges. Only the edges in `groups` ride a highway, and each group needs `minSize` edges.
+ * The spine `shared` gives the shared stretches of the router `shared` with the group as the key.
+ * The spine `trunk` gives one trunk for each group, through the corner graph between two terminals.
+ * A terminal is the Weber point of the points out of the plugs at one end of the group. A terminal in a box moves to the nearest of those points.
+ */
+export function groupedPlan(input: HighwayInput, groups: ReadonlyMap<string, EdgeGroup>, o: Readonly<GroupedOptions>): HighwayPlan {
+  const min = Math.max(2, o.minSize);
+  const size = new Map<string, number>();
+  for (const g of groups.values()) size.set(g.key, (size.get(g.key) ?? 0) + 1);
+  const big = (edge: string): EdgeGroup | undefined => {
+    const g = groups.get(edge);
+    return g && (size.get(g.key) ?? 0) >= min ? g : undefined;
+  };
+  const way: WayOptions = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  if (o.spine === "shared") return sharedWaysPlan(input, { ...way, rule: (e) => big(e.id)?.key });
+
+  const finder = new WayFinder(input.graph.nodes, way);
+  const byKey = new Map<string, { edge: string; flip: boolean; a: Point; b: Point; ps: Point; pt: Point }[]>();
+  for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+    const g = big(edge.id);
+    if (!g) continue;
+    const os = finder.out(ps);
+    const ot = finder.out(pt);
+    const item = g.flip ? { edge: edge.id, flip: true, a: ot, b: os, ps: ps.point, pt: pt.point } : { edge: edge.id, flip: false, a: os, b: ot, ps: ps.point, pt: pt.point };
+    const list = byKey.get(g.key);
+    if (list) list.push(item);
+    else byKey.set(g.key, [item]);
+  }
+  const pad = finder.margin / 2;
+  const terminal = (points: readonly Point[]): Point => {
+    const p = weberPoint(points);
+    if (!finder.obstacles.inside(p, pad)) return p;
+    let best = points[0]!;
+    for (const q of points) if (dist(q, p) < dist(best, p)) best = q;
+    return best;
+  };
+  const highways: Highway[] = [];
+  const legMax = o.legMax ?? Infinity;
+  for (const [key, list] of byKey) {
+    if (list.length < min) continue;
+    const ta = terminal(list.map((x) => x.a));
+    const tb = terminal(list.map((x) => x.b));
+    const span = dist(ta, tb);
+    if (span <= finder.margin) continue;
+    const riders = list.filter((x) => dist(x.a, ta) <= legMax * span && dist(x.b, tb) <= legMax * span);
+    if (riders.length < min) continue;
+    const raw = finder.corners.path(ta, tb);
+    if (!raw) continue;
+    const spine = finder.corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= 1e-6) continue;
+    const last = spine.length - 1;
+    const lanes = orderLanes(
+      spine,
+      riders.map((x) => ({ edge: x.edge, points: x.flip ? [x.ps, x.b, ...[...spine].reverse(), x.a, x.pt] : [x.ps, x.a, ...spine, x.b, x.pt] })),
+      "bundle",
+    );
+    const byEdge = new Map(riders.map((x) => [x.edge, x]));
+    const members: HighwayMember[] = lanes.map((edge) => (byEdge.get(edge)!.flip ? memberAt(spine, edge, last, 0) : memberAt(spine, edge, 0, last)));
+    highways.push({ id: `h${highways.length}`, key, spine, lanes, members });
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/index.ts

@@ -5,3 +5,18 @@ export { highwayRouter, highwayRouterStrategy } from "./router.ts";
 export { keysPlan, type KeysOptions } from "./keys/index.ts";
 export { sharedWaysPlan, type SharedWaysOptions } from "./shared-ways/index.ts";
 export { BREAK_EVEN, CORRIDOR_DEFAULTS, corridorPlan, minHash, type CorridorOptions } from "./corridors/index.ts";
+export { basePlan, HIGHWAY_BASES, type HighwayBase } from "./base.ts";
+export { MEET_DEFAULTS, meetMember, meetPlan, type MeetOptions } from "./meet/index.ts";
+export { meetingPoints, WEISZFELD_DEFAULTS, weiszfeldPlan, type WeiszfeldOptions } from "./weiszfeld/index.ts";
+export { STUB_DEFAULTS, stubPlan, type StubEnds, type StubOptions } from "./stubs/index.ts";
+export { ZIPPER_DEFAULTS, zipLegs, zipperPlan, type Zip, type ZipLimits, type ZipperOptions } from "./zipper/index.ts";
+export { LEVEL_HIGHWAY_DEFAULTS, levelHighwayPlan, type LevelHighwayOptions } from "./level-links/index.ts";
+export { edgePlugs, sharedStretches, type EdgePlugs, type KeyedWay, type SharedStretchOptions } from "./stretches.ts";
+export { GROUP_SPINES, groupedPlan, weberPoint, type EdgeGroup, type GroupedOptions, type GroupSpine } from "./grouped.ts";
+export { mdf, QUICKBUNDLES_DEFAULTS, quickBundles, quickBundlesPlan, resample, type BundleLine, type BundleOrder, type QuickBundlesOptions } from "./quickbundles/index.ts";
+export { ROAD_CLASS_DEFAULTS, roadClassPlan, type RoadClassOptions } from "./road-classes/index.ts";
+export { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FieldEnd, type FlowFieldOptions } from "./flow-field/index.ts";
+export { SplitTree, WSPD_DEFAULTS, wspdGroups, wspdPlan, type SplitCell, type WspdOptions } from "./wspd/index.ts";
+export { OD_CELL_DEFAULTS, odCellPlan, odGroups, type OdCellOptions } from "./od-cells/index.ts";
+export { CANDIDATE_SOURCES, candidatePlan, candidateScore, SELECT_DEFAULTS, selectPlan, type CandidateSource, type SelectOptions } from "./select/index.ts";
+export * from "./gates/index.ts";

package/src/highways/level-links/index.ts

@@ -0,0 +1,114 @@
+import { dist, pointBoxDistance, polylineLength, type Point } from "../../geom.ts";
+import { levelLinks, type ItemPair } from "../../levels.ts";
+import { nodeIndex } from "../../model.ts";
+import { buildSections, levelCut } from "../../sections.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, firstRoutes, tidyPlan, type HighwayBase } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `level-links` (HWY-056 with WILD-034 of the notes). */
+export interface LevelHighwayOptions {
+  /** The plan of the edges that do not ride a level link. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The depth of the level in the tree of sections. Depth 1 is the level below the root. The default is 1. */
+  readonly depth: number;
+  /** A level link becomes a highway when this number of edges or more ride it. The default is 2. */
+  readonly minSize: number;
+  /** An edge rides the link only when its way along the link is this many times its first route, or shorter. The default is 1.5. */
+  readonly stretch: number;
+}
+
+/** The default options of the strategy `level-links`. */
+export const LEVEL_HIGHWAY_DEFAULTS: Readonly<LevelHighwayOptions> = Object.freeze({ from: "shared-ways", depth: 1, minSize: 2, stretch: 1.5 });
+
+/** This function gives the stretch of a polyline from the length `from` to the length `to`, along the polyline. */
+function cut(p: readonly Point[], from: number, to: number): Point[] {
+  const out: Point[] = [];
+  let walked = 0;
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    const len = dist(a, b);
+    const s = Math.max(from, walked);
+    const e = Math.min(to, walked + len);
+    if (e > s && len > 0) {
+      const at = (l: number): Point => ({ x: a.x + ((b.x - a.x) * (l - walked)) / len, y: a.y + ((b.y - a.y) * (l - walked)) / len });
+      if (out.length === 0) out.push(at(s));
+      out.push(at(e));
+    }
+    walked += len;
+  }
+  return out;
+}
+
+/**
+ * This function gives a highway for each link of a zoom level, with the edges between its two items (HWY-056, WILD-034).
+ * The level is the cut of the tree of sections at `depth`. The link goes around the boxes of the other items (`levelLinks`).
+ * The spine is the link without a margin at each end, so it stays off the boxes of the two items. It must stay out of each box.
+ * The edges between the two items, in each direction, ride the spine. The ramps go through the corner graph inside the items.
+ *
+ * An edge rides only when the ramps (as straight lines) and the spine are `stretch` times its first route, or shorter.
+ * A link with fewer than `minSize` such edges is not a highway. The other edges keep their highways of the plan `from`.
+ * Thus a zoom from the level to the routes shows the same lines, which open into lanes.
+ */
+export function levelHighwayPlan(input: HighwayInput, o: Readonly<LevelHighwayOptions>): HighwayPlan {
+  const graph = input.graph;
+  const base = basePlan(input, o.from);
+  if (graph.nodes.length === 0) return base;
+  const byId = nodeIndex(graph);
+  const root = buildSections(graph.nodes);
+  const { items, owner } = levelCut(graph.nodes, root, Math.max(0, Math.round(o.depth)));
+  const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+  // The edges between each pair of items, by the pair in the order of the items.
+  const between = new Map<string, { a: number; b: number; edges: { edge: string; forward: boolean }[] }>();
+  for (const e of graph.edges) {
+    const iu = indexOfNode.get(e.source.node);
+    const iv = indexOfNode.get(e.target.node);
+    if (iu === undefined || iv === undefined) continue;
+    const x = owner[iu]!;
+    const y = owner[iv]!;
+    if (x === y) continue;
+    const [a, b] = x < y ? [x, y] : [y, x];
+    const key = `${a}\u0000${b}`;
+    const pair = between.get(key) ?? { a, b, edges: [] };
+    pair.edges.push({ edge: e.id, forward: x === a });
+    between.set(key, pair);
+  }
+  const pairs = [...between.values()].filter((p) => p.edges.length >= Math.max(2, o.minSize));
+  if (pairs.length === 0) return base;
+  const itemPairs: ItemPair[] = pairs.map((p) => ({ source: items[p.a]!.id, target: items[p.b]!.id, count: p.edges.length }));
+  const links = levelLinks(items, itemPairs);
+  const linkOf = new Map(links.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+  const ways = new WayFinder(graph.nodes);
+  const first = firstRoutes(input);
+  const edgeOf = new Map(graph.edges.map((e) => [e.id, e]));
+  const added: Highway[] = [];
+  const riders = new Set<string>();
+  for (const p of pairs) {
+    const points = linkOf.get(`${items[p.a]!.id}\u0000${items[p.b]!.id}`);
+    if (!points || points.length < 2) continue;
+    const length = polylineLength(points);
+    if (length <= 4 * ways.margin) continue;
+    const spine = cut(points, ways.margin, length - ways.margin);
+    if (spine.length < 2 || !ways.obstacles.clearPath(spine, 1)) continue;
+    const head = spine[0]!;
+    const tail = spine[spine.length - 1]!;
+    const along = polylineLength(spine);
+    const members: HighwayMember[] = [];
+    for (const { edge, forward } of p.edges) {
+      const e = edgeOf.get(edge)!;
+      const s = byId.get(e.source.node)!;
+      const t = byId.get(e.target.node)!;
+      const [enter, leave] = forward ? [head, tail] : [tail, head];
+      const way = pointBoxDistance(enter, s.box) + along + pointBoxDistance(leave, t.box);
+      const own = polylineLength(first.get(edge) ?? []);
+      if (own > 0 && way > o.stretch * own) continue;
+      members.push(forward ? memberAt(spine, edge, 0, spine.length - 1) : memberAt(spine, edge, spine.length - 1, 0));
+    }
+    if (members.length < Math.max(2, o.minSize)) continue;
+    for (const m of members) riders.add(m.edge);
+    added.push({ id: "", key: `level${o.depth}:${items[p.a]!.id}:${items[p.b]!.id}`, spine, lanes: members.map((m) => m.edge), members });
+  }
+  const rest = base.highways.map((h) => ({ ...h, members: h.members.filter((m) => !riders.has(m.edge)) }));
+  return tidyPlan({ highways: [...rest, ...added] });
+}

package/src/highways/meet/index.ts

@@ -0,0 +1,84 @@
+import { dist, type Point } from "../../geom.ts";
+import { basePlan, firstRoutes, tidyPlan, type HighwayBase } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `meet` (HWY-050 of the note on highways). */
+export interface MeetOptions {
+  /** The plan whose merge points and split points the strategy moves. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** A first route meets the spine where it is this distance from the spine, or nearer. The default is 8: two lanes of 4. */
+  readonly near: number;
+  /** A first route meets the spine only where it runs at this angle to the spine, or less, in degrees. The default is 45. */
+  readonly maxTurn: number;
+  /** A member keeps its places when the stretch where its first route meets the spine is shorter than this length. The default is 10. */
+  readonly minRun: number;
+}
+
+/** The default options of the strategy `meet`. */
+export const MEET_DEFAULTS: Readonly<MeetOptions> = Object.freeze({ from: "shared-ways", near: 8, maxTurn: 45, minRun: 10 });
+
+/** This function gives the distance from a point to a polyline, and the unit direction of the nearest leg. */
+function nearestLeg(line: readonly Point[], p: Point): { d: number; ux: number; uy: number } {
+  let best = { d: Infinity, ux: 1, uy: 0 };
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const len = dist(a, b);
+    if (len <= 1e-9) continue;
+    const u = Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / (len * len)));
+    const d = dist(p, { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+    if (d < best.d) best = { d, ux: (b.x - a.x) / len, uy: (b.y - a.y) / len };
+  }
+  return best;
+}
+
+/**
+ * This function gives a member with its merge point and its split point where its first route meets the spine and parts from it (HWY-050).
+ * The function samples the stretch of the member on the spine, at steps of `near / 2` or less.
+ * A sample meets the route when the route is `near` or nearer, and its nearest leg runs at `maxTurn` or less to the spine.
+ * The new merge point is the first sample that meets the route, in the direction of the member. The new split point is the last one.
+ * So the edge joins the spine late and leaves it early. The places only move inward.
+ * The member keeps its places when no sample meets the route, or when the met stretch is shorter than `minRun`.
+ */
+export function meetMember(spine: readonly Point[], member: HighwayMember, route: readonly Point[] | undefined, o: Readonly<MeetOptions>): HighwayMember {
+  if (!route || route.length < 2 || spine.length < 2) return member;
+  const lo = Math.min(member.on, member.off);
+  const hi = Math.max(member.on, member.off);
+  const cos = Math.cos((Math.max(0, Math.min(90, o.maxTurn)) * Math.PI) / 180);
+  const step = Math.max(1e-3, o.near / 2);
+  let first = Infinity;
+  let last = -Infinity;
+  for (let i = Math.floor(lo); i < Math.min(spine.length - 1, Math.ceil(hi)); i++) {
+    const from = Math.max(lo, i);
+    const to = Math.min(hi, i + 1);
+    if (to <= from) continue;
+    const a = spine[i]!;
+    const b = spine[i + 1]!;
+    const len = dist(a, b);
+    if (len <= 1e-9) continue;
+    const tx = (b.x - a.x) / len;
+    const ty = (b.y - a.y) / len;
+    const n = Math.min(256, Math.max(1, Math.ceil(((to - from) * len) / step)));
+    for (let j = 0; j <= n; j++) {
+      const at = from + ((to - from) * j) / n;
+      const leg = nearestLeg(route, pointAt(spine, at));
+      if (leg.d > o.near || Math.abs(leg.ux * tx + leg.uy * ty) < cos - 1e-12) continue;
+      first = Math.min(first, at);
+      last = Math.max(last, at);
+    }
+  }
+  if (!(last > first) || lengthBetween(spine, first, last) < o.minRun) return member;
+  return member.on <= member.off ? memberAt(spine, member.edge, first, last, member.seq) : memberAt(spine, member.edge, last, first, member.seq);
+}
+
+/**
+ * This function gives the highways of the plan `from`, with merge points and split points where the routes meet and part (HWY-050).
+ * The first route of each edge is the route of `input.routes`, or its route without highways.
+ * Each member gets the places of `meetMember`. The spines and the trips do not change.
+ */
+export function meetPlan(input: HighwayInput, o: Readonly<MeetOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  if (plan.highways.length === 0) return plan;
+  const first = firstRoutes(input);
+  return tidyPlan({ highways: plan.highways.map((h) => ({ ...h, members: h.members.map((m) => meetMember(h.spine, m, first.get(m.edge), o)) })) });
+}

package/src/highways/model.ts

@@ -9,6 +9,11 @@ export interface HighwayInput {
    * The strategy `corridors` makes the ways of the corner graph, as the router `corners` finds them.
    */
   readonly routes?: Result;
+  /**
+   * This value is the graph before an edit and the plan of the same strategy on it. A strategy that keeps its highways stable over edits reads it.
+   * The gates `hysteresis` (HWY-046) and `ids` (HWY-054) read it. The other strategies ignore it.
+   */
+  readonly previous?: { readonly graph: Graph; readonly plan: HighwayPlan };
 }
 
 /**

package/src/highways/od-cells/index.ts

@@ -0,0 +1,50 @@
+import { buildSections, levelCut } from "../../sections.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `od-cells` (EDA-033 with WILD-032 of the notes). */
+export interface OdCellOptions {
+  /** The depth of the cells in the tree of sections. Depth 1 is the level below the root. The default is 2. */
+  readonly level: number;
+  /** A pair of cells with this number of edges or more gets a trunk. The default is 3. */
+  readonly minGroup: number;
+  /** An edge rides the trunk only when each of its legs is this share of the span or shorter. The default is 0.3. */
+  readonly legMax: number;
+  /** The spine of each pair of cells. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `od-cells`. */
+export const OD_CELL_DEFAULTS: Readonly<OdCellOptions> = Object.freeze({ level: 2, minGroup: 3, legMax: 0.3, spine: "trunk" });
+
+/**
+ * This function gives the groups of the edges by the pair of the cells of their two nodes (EDA-033, WILD-032).
+ * The cells are the items of the zoom level at the depth `level`. The edges of one pair of cells, in either direction, are one group.
+ * An edge inside one cell is in no group.
+ */
+export function odGroups(input: HighwayInput, o: Readonly<OdCellOptions>): Map<string, EdgeGroup> {
+  const nodes = input.graph.nodes;
+  const groups = new Map<string, EdgeGroup>();
+  if (nodes.length === 0) return groups;
+  const { owner } = levelCut(nodes, buildSections(nodes), Math.max(0, Math.round(o.level)));
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  for (const e of input.graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined) continue;
+    const a = owner[u]!;
+    const b = owner[v]!;
+    if (a === b) continue;
+    groups.set(e.id, a < b ? { key: `od${a}:${b}`, flip: false } : { key: `od${b}:${a}`, flip: true });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of the consolidation by origin and destination cells (EDA-033, WILD-032).
+ * Carriers merge the loads from one region to another into one truck between two terminals. Thus each pair of cells with `minGroup` edges or more gets one trunk.
+ * The terminals are the Weber points of the plugs in each cell. An edge with a leg longer than `legMax` times the span goes alone.
+ */
+export function odCellPlan(input: HighwayInput, o: Readonly<OdCellOptions>): HighwayPlan {
+  return groupedPlan(input, odGroups(input, o), { spine: o.spine, minSize: o.minGroup, legMax: o.legMax });
+}