@mark1russell7/highways 0.2.0 → 0.3.0

package/src/routers/sections.ts

@@ -1,17 +1,17 @@
 import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
-import { center, dist, pointSegmentDistance, polylineLength, type Box, type Point } from "../geom.ts";
+import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
 import { LEVEL_LINK_DEFAULTS, levelLinks, type ItemPair, type LevelLinkOptions } from "../levels.ts";
-import { nodeIndex, type Graph, type Level, type LevelItem, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
-import { allSections, buildSections, checkSections, SECTION_DEFAULTS, treeDepth, type Section, type SectionOptions } from "../sections.ts";
-import { orderLanes } from "../segments.ts";
+import { allSections, buildSections, checkSections, levelCut, SECTION_DEFAULTS, treeDepth, type Section, type SectionOptions } from "../sections.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
 import type { Strategy } from "../strategies/model.ts";
 import { WayFinder } from "../ways.ts";
 
 /**
  * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
  * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
- * The options `tightMargin` and `plugInset` are the limits of the level links (`levelLinks`).
+ * The options `tightMargin`, `plugInset` and `throughCost` are the limits of the level links (`levelLinks`).
  */
 export interface SectionsOptions extends LevelLinkOptions, SectionOptions {
   /** The name in the benchmark. */
@@ -45,18 +45,21 @@ export interface SectionsOptions extends LevelLinkOptions, SectionOptions {
    * The default is each depth, from 0 to the depth of the deepest section.
    */
   readonly levels?: readonly number[];
+  /** The lane order of the runs. With `run`, the default, each run gets its order alone. With `bundle`, two edges keep one order on each run of their common stretch. */
+  readonly laneOrder?: RunOrder;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
 /** The default values of the numbers of `SectionsOptions`: the limits of the hubs, of the tree and of the level links. */
-export const SECTIONS_DEFAULTS: Readonly<Required<Pick<SectionsOptions, "cap" | "maxDepth" | "collapse" | "tightMargin" | "plugInset" | "hubs" | "stretch" | "stretchPad" | "hubSlack">>> =
+export const SECTIONS_DEFAULTS: Readonly<Required<Pick<SectionsOptions, "cap" | "maxDepth" | "collapse" | "tightMargin" | "plugInset" | "throughCost" | "hubs" | "stretch" | "stretchPad" | "hubSlack">>> =
   Object.freeze({
     cap: SECTION_DEFAULTS.cap,
     maxDepth: SECTION_DEFAULTS.maxDepth,
     collapse: SECTION_DEFAULTS.collapse,
     tightMargin: LEVEL_LINK_DEFAULTS.tightMargin,
     plugInset: LEVEL_LINK_DEFAULTS.plugInset,
+    throughCost: LEVEL_LINK_DEFAULTS.throughCost,
     hubs: Infinity,
     stretch: 2,
     stretchPad: 4,
@@ -205,7 +208,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
       for (const [key, p] of pieces) {
         const list = users.get(key) ?? [];
         if (list.length < 2 || p.length < 2) continue;
-        runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!)) });
+        runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!), options.laneOrder) });
       }
       return { routes, runs, levels: makeLevels(graph, root, routeOf, options) };
     },
@@ -235,45 +238,17 @@ function makeLevels(graph: Graph, root: Section, routeOf: ReadonlyMap<string, Ro
   const shown = options.levels && new Set(options.levels);
   for (let d = 0; d <= deepest + 1; d++) {
     if (shown && d <= deepest && !shown.has(d)) continue;
-    const items: LevelItem[] = [];
-    const itemOf: (Section | number)[] = [];
-    const boxOf = (list: readonly number[]): Box => {
-      let x0 = Infinity;
-      let y0 = Infinity;
-      let x1 = -Infinity;
-      let y1 = -Infinity;
-      for (const i of list) {
-        const b = graph.nodes[i]!.box;
-        x0 = Math.min(x0, b.x);
-        y0 = Math.min(y0, b.y);
-        x1 = Math.max(x1, b.x + b.w);
-        y1 = Math.max(y1, b.y + b.h);
-      }
-      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
-    };
-    const visit = (s: Section): void => {
-      if (s.depth >= d) {
-        items.push({ id: s.id, box: boxOf(s.nodes), nodes: s.nodes.map((i) => graph.nodes[i]!.id) });
-        for (const i of s.nodes) itemOf[i] = s;
-      } else if (s.children.length > 0) for (const c of s.children) visit(c);
-      else
-        for (const i of s.nodes) {
-          const n = graph.nodes[i]!;
-          items.push({ id: n.id, box: n.box, nodes: [n.id] });
-          itemOf[i] = i;
-        }
-    };
-    if (graph.nodes.length > 0) visit(root);
+    const { items, owner } = levelCut(graph.nodes, root, d);
     const links = new Map<string, { source: string; target: string; count: number; edge: string }>();
     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 a = itemOf[iu]!;
-      const b = itemOf[iv]!;
+      const a = owner[iu]!;
+      const b = owner[iv]!;
       if (a === b) continue;
-      const ida = typeof a === "number" ? graph.nodes[a]!.id : a.id;
-      const idb = typeof b === "number" ? graph.nodes[b]!.id : b.id;
+      const ida = items[a]!.id;
+      const idb = items[b]!.id;
       const key = `${ida}\u0000${idb}`;
       const link = links.get(key);
       if (link) {

package/src/routers/shared.ts

@@ -1,6 +1,7 @@
 import { center, dist, type Point } from "../geom.ts";
 import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
 /** The options of the router with shared ways. */
@@ -11,6 +12,8 @@ export interface SharedOptions extends WayOptions {
   readonly rule?: GroupRule;
   /** The cost of a link that an edge with the same key uses already, as a share of its length. The default is 0.5. */
   readonly discount?: number;
+  /** The lane order of the runs. With `bundle`, the default, two edges keep one order on each run of their common stretch. With `run`, each run gets its order alone. */
+  readonly laneOrder?: RunOrder;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -171,8 +174,10 @@ export function sharedRouter(options: SharedOptions): Router {
       const routes: Route[] = [];
       for (const w of all) routes.push({ edge: w.edge.id, points: points.get(w.edge.id) ?? [w.ps.point, w.pt.point] });
       const shared: SharedRun[] = [];
+      const routeOf = new Map(routes.map((r) => [r.edge, r]));
       for (const run of runs.values()) {
-        shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges: laneOrderOfRun(run) });
+        const edges = options.laneOrder === "run" ? laneOrderOfRun(run) : orderLanes(run.points, run.ways.map((w) => routeOf.get(w.edge.id)!), "bundle");
+        shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges });
       }
       return { routes, runs: shared };
     },
@@ -181,7 +186,7 @@ export function sharedRouter(options: SharedOptions): Router {
 }
 
 /**
- * This function gives the lane order of a run (metro-line order). Two edges of the run go together past its last corner
+ * This function gives the lane order of a run with the option `laneOrder: "run"` (metro-line order). Two edges of the run go together past its last corner
  * until they part. The edge that turns more to the left there gets the lane more to the left.
  * Two edges can part only before the first corner. Then the edge that comes from more to the left gets the lane more to the left.
  */

package/src/routers/trunks.ts

@@ -1,6 +1,7 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
+import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
 
 /** The options of the trunk router. */
@@ -13,10 +14,20 @@ export interface TrunksOptions extends WayOptions {
   readonly split?: number;
   /** A group with fewer edges stays unbundled. The default is 2. */
   readonly minSize?: number;
+  /** The lane order of a trunk. With `bundle`, the default, the branches part in lane order. With `run`, the first leg of each branch tells the order. */
+  readonly laneOrder?: RunOrder;
+  /**
+   * The place where each lane leaves the trunk. With `part`, the default, a lane leaves where its way parts from the ways of the other lanes.
+   * A lane that turns back over the trunk leaves at an earlier point of the trunk. With `split`, each lane leaves at the split point, as in version 0.2.0.
+   */
+  readonly leave?: TrunkLeave;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
 
+/** The place where the lanes of a trunk leave it: where their ways part, or at the split point. */
+export type TrunkLeave = "part" | "split";
+
 /** The rule that groups the edges by the collection of their target, in `data.collection`. */
 export const byCollection: GroupRule = (e) => {
   const c = e.data?.["collection"];
@@ -74,6 +85,83 @@ export function splitPoint(start: Point, targets: readonly Point[], split: numbe
 
 const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
 
+/** The place where a branch leaves its trunk. */
+export interface TrunkExit {
+  /** The place along the trunk: the index of a point of the trunk, plus the share of the next leg. Point `i` of the trunk is at `i`. */
+  readonly at: number;
+  /** The point where the branch leaves the trunk. */
+  readonly point: Point;
+  /** The branch past `point`, to the plug of the target. */
+  readonly rest: readonly Point[];
+}
+
+/**
+ * This function gives the place where a branch leaves its trunk. The branch starts at the last point of the trunk and ends at the plug of the target.
+ *
+ * A branch that turns back over the trunk, by more than 90 degrees, leaves at the point of the trunk before.
+ * It does so when it goes back along the trunk to that point. It also does so when `clear` tells that the line from that point is free.
+ * The first two legs of the trunk stay. When the branch still turns back, it leaves the last leg at the foot of its next point, if the line from there is free.
+ * Each step makes the route shorter or keeps its length.
+ *
+ * The function gives `undefined` when the foot on the second leg of the trunk is less than `min` past the start of that leg.
+ * Then the target is behind or beside the plug, and the edge does not go well in the bundle.
+ */
+export function leaveTrunk(trunk: readonly Point[], branch: readonly Point[], clear: (a: Point, b: Point) => boolean, min = 0): TrunkExit | undefined {
+  const back = (a: Point, b: Point, q: Point): boolean => (b.x - a.x) * (q.x - b.x) + (b.y - a.y) * (q.y - b.y) < 0;
+  let at = trunk.length - 1;
+  let rest = branch.slice(1);
+  while (at >= 3 && rest.length >= 2) {
+    const a = trunk[at - 1]!;
+    if (!back(a, trunk[at]!, rest[0]!)) break;
+    const next = dist(rest[0]!, a) <= 1e-9 ? rest.slice(1) : rest;
+    if (next === rest && !clear(a, rest[0]!)) break;
+    rest = next;
+    at -= 1;
+  }
+  const exit: TrunkExit = { at, point: trunk[at]!, rest };
+  if (at < 1 || rest.length < 2 || !back(trunk[at - 1]!, trunk[at]!, rest[0]!)) return exit;
+  const a = trunk[at - 1]!;
+  const b = trunk[at]!;
+  const q = rest[0]!;
+  const u = ((q.x - a.x) * (b.x - a.x) + (q.y - a.y) * (b.y - a.y)) / ((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
+  if (at <= 2 ? u * Math.hypot(b.x - a.x, b.y - a.y) < min : u <= 0) return at <= 2 ? undefined : exit;
+  const foot = { x: a.x + u * (b.x - a.x), y: a.y + u * (b.y - a.y) };
+  return at >= 2 && clear(foot, q) ? { at: at - 1 + u, point: foot, rest } : exit;
+}
+
+/** This function gives the number of points at the start of each route that all the routes share. */
+function commonStart(routes: readonly Route[], from: number): number {
+  const first = routes[0]!.points;
+  let n = from;
+  while (n < first.length && routes.every((r) => n < r.points.length && dist(r.points[n]!, first[n]!) <= 1e-9)) n++;
+  return n;
+}
+
+/**
+ * This function gives the shared ways of the routes of one bundle past the trunk. The routes share their first `from` points.
+ * At the last of these points, the routes part. The routes that go on to one next point share a way to the point where they part again.
+ * Each shared way has two edges or more, in the order of the routes.
+ */
+export function sharedWays(routes: readonly Route[], from: number): { points: Point[]; edges: string[] }[] {
+  const out: { points: Point[]; edges: string[] }[] = [];
+  const next = new Map<string, Route[]>();
+  for (const r of routes) {
+    const q = r.points[from];
+    if (!q) continue;
+    const key = `${q.x},${q.y}`;
+    const list = next.get(key);
+    if (list) list.push(r);
+    else next.set(key, [r]);
+  }
+  for (const list of next.values()) {
+    if (list.length < 2) continue;
+    const end = commonStart(list, from);
+    out.push({ points: list[0]!.points.slice(from - 1, end), edges: list.map((r) => r.edge) });
+    out.push(...sharedWays(list, end));
+  }
+  return out;
+}
+
 /**
  * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
  * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
@@ -85,8 +173,12 @@ export function trunksRouter(options: TrunksOptions): Router {
     route(graph: Graph): Result {
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
-      const points = new Map<string, Point[]>();
+      const points = new Map<string, readonly Point[]>();
       const bundles: Bundle[] = [];
+      const runs: SharedRun[] = [];
+      const part = (options.leave ?? "part") === "part";
+      // A branch leaves the trunk early only on a line that keeps out of the boxes as far as the corner graph does.
+      const clear = (a: Point, b: Point): boolean => ways.obstacles.clear(a, b, ways.margin / 2);
       for (const [id, group] of groupEdges(graph.edges, options.rule, options.minSize ?? 2)) {
         const first = group[0]!;
         const s = byId.get(first.source.node);
@@ -105,13 +197,46 @@ export function trunksRouter(options: TrunksOptions): Router {
         const len = dist(prev, end);
         const dir = len > 0 ? { x: (end.x - prev.x) / len, y: (end.y - prev.y) / len } : plug.normal;
         const branches: { edge: string; next: Point }[] = [];
+        const own: Route[] = [];
+        const exits: { edge: string; exit: TrunkExit }[] = [];
         group.forEach((e, i) => {
           const pt = placePlug(targets[i]!, e.target, end);
           const branch = dedupe(ways.toPlug(end, pt) ?? [end, pt.point]);
-          points.set(e.id, dedupe([...trunk, ...branch.slice(1)]));
-          branches.push({ edge: e.id, next: branch[1] ?? pt.point });
+          if (!part) {
+            own.push({ edge: e.id, points: dedupe([...trunk, ...branch.slice(1)]) });
+            branches.push({ edge: e.id, next: branch[1] ?? pt.point });
+            return;
+          }
+          // An edge whose target is behind the plug goes alone, as an edge outside the groups.
+          const exit = leaveTrunk(trunk, branch, clear, 2 * ways.margin);
+          if (exit) exits.push({ edge: e.id, exit });
         });
-        bundles.push({ id: `b${bundles.length}`, key: id.split("\u0000")[2]!, node: s.id, edges: laneOrder(dir, end, branches), trunk });
+        const key = id.split("\u0000")[2]!;
+        if (!part) {
+          for (const r of own) points.set(r.edge, r.points);
+          const edges = options.laneOrder === "run" || trunk.length < 2 ? laneOrder(dir, end, branches) : orderLanes(trunk, own, "bundle");
+          bundles.push({ id: `b${bundles.length}`, key, node: s.id, edges, trunk });
+          continue;
+        }
+        // A group that keeps fewer than `minSize` edges stays unbundled.
+        if (exits.length < (options.minSize ?? 2)) continue;
+        // The trunk gets a point at each place where a branch leaves it. Thus each route holds the points of the trunk up to its exit.
+        const stops = new Map<number, Point>(trunk.map((p, i) => [i, p]));
+        for (const { exit } of exits) if (!stops.has(exit.at)) stops.set(exit.at, exit.point);
+        const line = [...stops].sort((x, y) => x[0] - y[0]);
+        for (const { edge, exit } of exits) {
+          const p = dedupe([...line.filter(([at]) => at <= exit.at).map(([, q]) => q), ...exit.rest]);
+          points.set(edge, p);
+          own.push({ edge, points: p });
+        }
+        // The bundle keeps the points that all the routes share. Past them, the routes that go on together share a run.
+        const order = options.laneOrder ?? "bundle";
+        const common = own[0]!.points.slice(0, commonStart(own, 0));
+        bundles.push({ id: `b${bundles.length}`, key, node: s.id, edges: orderLanes(common, own, order), trunk: common });
+        for (const way of sharedWays(own, common.length)) {
+          const users = own.filter((r) => way.edges.includes(r.edge));
+          runs.push({ id: `r${runs.length}`, key, points: way.points, edges: orderLanes(way.points, users, order) });
+        }
       }
       const routes: Route[] = [];
       for (const e of graph.edges) {
@@ -127,7 +252,7 @@ export function trunksRouter(options: TrunksOptions): Router {
         const pt = placePlug(t, e.target, center(s.box));
         routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
       }
-      return { routes, bundles };
+      return runs.length > 0 ? { routes, bundles, runs } : { routes, bundles };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };

package/src/sections.ts

@@ -1,5 +1,5 @@
 import { center, type Box } from "./geom.ts";
-import type { Node } from "./model.ts";
+import type { LevelItem, Node } from "./model.ts";
 
 /** A section of the plane: a cell of a quadtree, with the nodes whose centers are in it. */
 export interface Section {
@@ -123,3 +123,49 @@ export function checkSections(root: Section, count: number): void {
   const lost = seen.findIndex((n) => n !== 1);
   if (lost >= 0) fail(root, `the node index ${lost} is in ${seen[lost]} leaves, not in one`);
 }
+
+/** The items of one zoom level of a tree of sections, and the item of each node. */
+export interface LevelCut {
+  /** The items of the level: a section of the depth of the level, or one node of a leaf above that depth. */
+  readonly items: LevelItem[];
+  /** The index in `items` of the item of each node, in the order of the nodes. */
+  readonly owner: readonly number[];
+}
+
+/**
+ * This function gives the items of the zoom level at `depth`. A section of that depth is one item, with the bounding box of its nodes.
+ * A node of a leaf above that depth is an item alone. The items come in the order of the walk of the tree, parents before children.
+ * A depth past the depth of the deepest section gives each node alone.
+ */
+export function levelCut(nodes: readonly Pick<Node, "id" | "box">[], root: Section, depth: number): LevelCut {
+  const items: LevelItem[] = [];
+  const owner: number[] = [];
+  const boxOf = (list: readonly number[]): Box => {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const i of list) {
+      const b = nodes[i]!.box;
+      x0 = Math.min(x0, b.x);
+      y0 = Math.min(y0, b.y);
+      x1 = Math.max(x1, b.x + b.w);
+      y1 = Math.max(y1, b.y + b.h);
+    }
+    return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+  };
+  const visit = (s: Section): void => {
+    if (s.depth >= depth) {
+      for (const i of s.nodes) owner[i] = items.length;
+      items.push({ id: s.id, box: boxOf(s.nodes), nodes: s.nodes.map((i) => nodes[i]!.id) });
+    } else if (s.children.length > 0) for (const c of s.children) visit(c);
+    else
+      for (const i of s.nodes) {
+        const n = nodes[i]!;
+        owner[i] = items.length;
+        items.push({ id: n.id, box: n.box, nodes: [n.id] });
+      }
+  };
+  if (nodes.length > 0) visit(root);
+  return { items, owner };
+}

package/src/segments.ts

@@ -203,13 +203,77 @@ function turn(from: Point, base: Point, to: Point): number {
 }
 
 /**
- * This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
- * past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
- * Two routes can part only before the first point. Then the route that comes from more to the left gets the lane more to the left.
- * A route that does not hold the run goes last.
+ * The lane order of the shared ways of a router.
+ * With `bundle`, two edges keep one order on all the shared ways of their common stretch.
+ * With `run`, each shared way gets its order alone. Two edges can change sides from one shared way to the next.
  */
-export function orderLanes(run: readonly Point[], routes: readonly Route[]): string[] {
-  const placed: { edge: string; p: readonly Point[]; s: number; e: number }[] = [];
+export type RunOrder = "bundle" | "run";
+
+/** The place of a route on a run. The points go in the direction of the run. `s` and `e` are the indexes of the ends of the run. */
+interface Placed {
+  readonly edge: string;
+  readonly p: readonly Point[];
+  readonly s: number;
+  readonly e: number;
+}
+
+/** The place where two routes part past one end of their common stretch, and the side of the first route there. */
+interface Parting {
+  /** The last common point. */
+  readonly at: Point;
+  /** This value is below 0 when the first route goes to the left of the second route. It is above 0 when it goes to the right. */
+  readonly side: number;
+}
+
+/** This function gives the place where the routes `P` and `Q` part after the last point of the run, or nothing. */
+function partAfter(P: Placed, Q: Placed): Parting | undefined {
+  for (let j = 1; ; j++) {
+    const a = P.p[P.e + j];
+    const b = Q.p[Q.e + j];
+    if (a === undefined || b === undefined) return undefined;
+    if (dist(a, b) > SAME) {
+      const from = P.p[P.e + j - 2]!;
+      const at = P.p[P.e + j - 1]!;
+      const side = turn(from, at, a) - turn(from, at, b);
+      return side === 0 ? undefined : { at, side };
+    }
+  }
+}
+
+/** This function gives the place where the routes `P` and `Q` part before the first point of the run, or nothing. */
+function partBefore(P: Placed, Q: Placed): Parting | undefined {
+  for (let j = 1; ; j++) {
+    const a = P.p[P.s - j];
+    const b = Q.p[Q.s - j];
+    if (a === undefined || b === undefined) return undefined;
+    if (dist(a, b) > SAME) {
+      const from = P.p[P.s - j + 2]!;
+      const at = P.p[P.s - j + 1]!;
+      // Seen backward, the left side is the right side. Thus the order turns around.
+      const side = turn(from, at, b) - turn(from, at, a);
+      return side === 0 ? undefined : { at, side };
+    }
+  }
+}
+
+const byEdge = (P: Placed, Q: Placed): number => (P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0);
+
+/** This function puts the point `a` before the point `b`: the smaller x first, then the smaller y. */
+const firstPoint = (a: Point, b: Point): boolean => a.x < b.x - SAME || (Math.abs(a.x - b.x) <= SAME && a.y < b.y);
+
+/**
+ * This function gives the lane order of the edges on a shared way `run` (metro-line order).
+ * The routes are polylines that hold the points of the run in a row, in either direction. A route that does not hold the run goes last.
+ *
+ * Two routes go on together past each end of the run until they part. The route that turns more to the left there gets the lane more to the left.
+ *
+ * With the order `run`, the default, the end after the last point of the run tells the side first.
+ * With the order `bundle`, two routes that part on one side at both ends keep that side.
+ * When the two ends disagree, the two routes must cross. The end with the smaller x, then the smaller y, tells the side.
+ * Thus each shared way of a common stretch gives two routes the same order, and the crossing is where they part.
+ */
+export function orderLanes(run: readonly Point[], routes: readonly Route[], order: RunOrder = "run"): string[] {
+  const placed: Placed[] = [];
   const lost: string[] = [];
   for (const r of routes) {
     let at = indexOf(r.points, run, 0);
@@ -221,30 +285,16 @@ export function orderLanes(run: readonly Point[], routes: readonly Route[]): str
       else lost.push(r.edge);
     }
   }
-  const same = (a: Point, b: Point): boolean => dist(a, b) <= SAME;
-  placed.sort((P, Q) => {
-    for (let j = 1; ; j++) {
-      const a = P.p[P.e + j];
-      const b = Q.p[Q.e + j];
-      if (a === undefined || b === undefined) break;
-      if (!same(a, b)) {
-        const d = turn(P.p[P.e + j - 2]!, P.p[P.e + j - 1]!, a) - turn(P.p[P.e + j - 2]!, P.p[P.e + j - 1]!, b);
-        if (d !== 0) return d;
-        break;
-      }
-    }
-    for (let j = 1; ; j++) {
-      const a = P.p[P.s - j];
-      const b = Q.p[Q.s - j];
-      if (a === undefined || b === undefined) break;
-      if (!same(a, b)) {
-        // Seen backward, the left side is the right side. Thus the order turns around.
-        const d = turn(P.p[P.s - j + 2]!, P.p[P.s - j + 1]!, b) - turn(P.p[P.s - j + 2]!, P.p[P.s - j + 1]!, a);
-        if (d !== 0) return d;
-        break;
-      }
-    }
-    return P.edge < Q.edge ? -1 : P.edge > Q.edge ? 1 : 0;
-  });
+  if (order === "run") placed.sort((P, Q) => partAfter(P, Q)?.side ?? partBefore(P, Q)?.side ?? byEdge(P, Q));
+  else {
+    // The sort starts from the order of the edges, so that each run sorts the same edges the same way.
+    placed.sort(byEdge);
+    placed.sort((P, Q) => {
+      const after = partAfter(P, Q);
+      const before = partBefore(P, Q);
+      if (after && before && Math.sign(after.side) !== Math.sign(before.side)) return firstPoint(after.at, before.at) ? after.side : before.side;
+      return after?.side ?? before?.side ?? byEdge(P, Q);
+    });
+  }
   return [...placed.map((x) => x.edge), ...lost.sort()];
 }