@mark1russell7/highways 0.8.0 → 0.8.1

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/src/bench/exact/index.ts

@@ -283,9 +283,13 @@ function distancesTo(points: readonly Point[], adj: readonly (readonly { to: num
   const done = new Uint8Array(adj.length);
   const goal = new Set(targets);
   const ends = targets.map((t) => points[t]!);
+  // A node can go in the heap more than one time. Each node gets its guide one time (ROUTE-SCALE), so a search to many targets stays fast.
+  const guides = new Float64Array(adj.length).fill(-1);
   const guide = (v: number): number => {
+    if (guides[v]! >= 0) return guides[v]!;
     let h = Infinity;
     for (const t of ends) h = Math.min(h, dist(points[v]!, t));
+    guides[v] = h;
     return h;
   };
   const heap = new NodeHeap();

package/src/bench/properties.ts

@@ -83,9 +83,11 @@ export function checkProperties(graph: Graph, result: Result, limit = 100): Viol
   for (const run of result.runs ?? []) {
     if (run.edges.length < 2)
       if (add({ rule: "run-shared", detail: `run ${run.id} has fewer than two edges` })) return out;
+    // The run gets its reverse one time, not one time for each edge (ROUTE-SCALE).
+    let back: readonly Point[] | undefined;
     for (const id of run.edges) {
       const r = routes.get(id);
-      if (!r || !(holds(r.points, run.points) || holds(r.points, [...run.points].reverse())))
+      if (!r || !(holds(r.points, run.points) || holds(r.points, (back ??= [...run.points].reverse()))))
         if (add({ rule: "run-shared", edge: id, detail: `run ${run.id}: the route does not hold the points of the run in a row` })) return out;
     }
   }
@@ -139,6 +141,10 @@ function onBoundary(p: Point, b: Box): boolean {
 /** This function tells if the polyline `p` holds the points of `part` in a row. */
 function holds(p: readonly Point[], part: readonly Point[]): boolean {
   if (part.length === 0) return true;
-  for (let i = 0; i + part.length <= p.length; i++) if (part.every((q, j) => dist(q, p[i + j]!) <= TOLERANCE)) return true;
+  for (let i = 0; i + part.length <= p.length; i++) {
+    let j = 0;
+    while (j < part.length && dist(part[j]!, p[i + j]!) <= TOLERANCE) j++;
+    if (j === part.length) return true;
+  }
   return false;
 }

package/src/highways/stretches.ts

@@ -77,17 +77,35 @@ export function sharedStretches(ways: readonly KeyedWay[], o: Readonly<SharedStr
     readonly key: string;
     readonly points: readonly Point[];
     readonly members: { edge: string; forward: boolean; at: number }[];
+    /** The edges of `members`, so that the check of a member does not scan the list. */
+    readonly seen: Set<string>;
   }
   const stretches = new Map<string, Stretch>();
   const wayOf = new Map<string, readonly Point[]>();
+  // The signature of each link (ROUTE-SCALE): 0 for a link with fewer than `min` ways, else the number of the sorted list of its ways.
+  // Each link gets its signature one time. Two links get the same number only when they have the same sorted list, so the stretches do not change.
+  const texts = new Map<string, number>();
+  const sigs = new Map<string, number>();
+  const sigOf = (k: string): number => {
+    let n = sigs.get(k);
+    if (n !== undefined) return n;
+    const list = users.get(k) ?? [];
+    if (list.length < min) n = 0;
+    else {
+      const text = [...list].sort().join("\u0001");
+      n = texts.get(text);
+      if (n === undefined) texts.set(text, (n = texts.size + 1));
+    }
+    sigs.set(k, n);
+    return n;
+  };
   for (const w of clean) {
     wayOf.set(w.edge, w.points);
-    const sig = (i: number): string => {
+    const sig = (i: number): number => {
       const a = w.points[i]!;
       const b = w.points[i + 1]!;
-      if (!usable(a, b)) return "";
-      const list = users.get(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`) ?? [];
-      return list.length < min ? "" : [...list].sort().join("\u0001");
+      if (!usable(a, b)) return 0;
+      return sigOf(`${w.key}\u0000${linkKey(pointKey(a), pointKey(b))}`);
     };
     let start = 0;
     for (let i = 0; i < w.points.length - 1; i++) {
@@ -95,15 +113,18 @@ export function sharedStretches(ways: readonly KeyedWay[], o: Readonly<SharedStr
       if (i + 1 < w.points.length - 1 && sig(i + 1) === s) continue;
       const from = start;
       start = i + 1;
-      if (s === "") continue;
+      if (s === 0) continue;
       const a = pointKey(w.points[from]!);
       const b = pointKey(w.points[i + 1]!);
       if (a === b) continue;
       const id = `${w.key}\u0000${s}\u0000${linkKey(a, b)}`;
       const piece = w.points.slice(from, i + 2);
       let found = stretches.get(id);
-      if (!found) stretches.set(id, (found = { key: w.key, points: a < b ? piece : [...piece].reverse(), members: [] }));
-      if (!found.members.some((m) => m.edge === w.edge)) found.members.push({ edge: w.edge, forward: a < b, at: from });
+      if (!found) stretches.set(id, (found = { key: w.key, points: a < b ? piece : [...piece].reverse(), members: [], seen: new Set() }));
+      if (!found.seen.has(w.edge)) {
+        found.seen.add(w.edge);
+        found.members.push({ edge: w.edge, forward: a < b, at: from });
+      }
     }
   }
   // The order of the stretches of each way gives the `seq` of its members.

package/src/lane-order.ts

@@ -31,13 +31,16 @@ function turn(from: Point, base: Point, to: Point): number {
   return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
 }
 
+// The routes of one run often hold the same point objects past the run. A point is at the distance 0 from itself,
+// so the check `a !== b` skips the distance and keeps each result (ROUTE-SCALE).
+
 /** 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) {
+    if (a !== b && 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);
@@ -52,7 +55,7 @@ function partBefore(P: Placed, Q: Placed): Parting | undefined {
     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) {
+    if (a !== b && 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.

package/src/routers/shared.ts

@@ -238,20 +238,38 @@ export function sharedRouter(options: SharedOptions): Router {
       }
 
       // The users of each link, with the links to the ends. Two edges from one plug share the link from it.
-      const users = new Map<string, Map<string, string[]>>();
+      const N = corners.points.length + ends.size + 1;
+      const pairOf = (a: number, b: number): number => (a < b ? a * N + b : b * N + a);
+      const users = new Map<string, Map<number, string[]>>();
       for (const w of order) {
         if (!w.found) continue;
         let mine = users.get(w.key);
         if (!mine) users.set(w.key, (mine = new Map()));
         for (let i = 1; i < w.ids.length; i++) {
-          const a = w.ids[i - 1]!;
-          const b = w.ids[i]!;
-          const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+          const k = pairOf(w.ids[i - 1]!, w.ids[i]!);
           const list = mine.get(k);
           if (list) list.push(w.edge.id);
           else mine.set(k, [w.edge.id]);
         }
       }
+      // The signature of each link (ROUTE-SCALE): 0 for a link with fewer than 2 users, else the number of the sorted list of its users.
+      // Each link gets its signature one time. Two links get the same number only when they have the same sorted list, so the runs do not change.
+      const texts = new Map<string, number>();
+      const sigs = new Map<string, Map<number, number>>();
+      for (const [key, mine] of users) {
+        const own = new Map<number, number>();
+        for (const [k, list] of mine) {
+          if (list.length < 2) {
+            own.set(k, 0);
+            continue;
+          }
+          const text = [...list].sort(byText).join("\u0001");
+          let n = texts.get(text);
+          if (n === undefined) texts.set(text, (n = texts.size + 1));
+          own.set(k, n);
+        }
+        sigs.set(key, own);
+      }
 
       // Each way breaks into stretches where the set of edges on the links stays the same.
       // A shared stretch loses its needless corners one time, so it has the same points in each of its routes.
@@ -259,13 +277,8 @@ export function sharedRouter(options: SharedOptions): Router {
       const points = new Map<string, Point[]>();
       for (const w of all) {
         if (!w.found) continue;
-        const used = users.get(w.key)!;
-        const sig = (i: number): string => {
-          const a = w.ids[i]!;
-          const b = w.ids[i + 1]!;
-          const list = used.get(a < b ? `${a}:${b}` : `${b}:${a}`)!;
-          return list.length < 2 ? "" : [...list].sort(byText).join("\u0001");
-        };
+        const own = sigs.get(w.key)!;
+        const sig = (i: number): number => own.get(pairOf(w.ids[i]!, w.ids[i + 1]!))!;
         const out: Point[] = [w.ps.point];
         const append = (piece: readonly Point[]): void => {
           for (const p of piece) if (dist(p, out[out.length - 1]!) > 1e-9) out.push(p);
@@ -275,7 +288,7 @@ export function sharedRouter(options: SharedOptions): Router {
           const s = sig(i);
           if (i + 1 < w.seq.length - 1 && sig(i + 1) === s) continue;
           const raw = w.seq.slice(start, i + 2);
-          if (s === "") append(corners.pull(raw));
+          if (s === 0) append(corners.pull(raw));
           else {
             const a = w.ids[start]!;
             const b = w.ids[i + 1]!;

package/src/segments.ts

@@ -174,6 +174,8 @@ export function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<stri
 /** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
 function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Route[] {
   const byId = new Map(graph.segments.map((s) => [s.id, s]));
+  // Each segment gets its spacing one time (ROUTE-SCALE). A key of `runKey` sorts the edges of the segment, and a busy segment is on many paths.
+  const spacings = new Map<Segment, number>();
   const routes: Route[] = [];
   for (const path of graph.paths) {
     const ends = pathPoints(graph, path);
@@ -181,7 +183,8 @@ function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Rout
     for (const ref of path.segments) {
       const s = byId.get(ref.segment);
       if (!s) continue;
-      const spacing = spacingOf(s);
+      let spacing = spacings.get(s);
+      if (spacing === undefined) spacings.set(s, (spacing = spacingOf(s)));
       const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
       for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]!) > SAME) out.push(q);
     }