terra-route 0.0.6 → 0.0.7

package/src/heap/pairing-heap.ts

@@ -0,0 +1,109 @@
+import { Heap } from "./heap";
+
+class PairingHeapNode {
+    key: number;
+    value: number;
+    child: PairingHeapNode | null = null;
+    sibling: PairingHeapNode | null = null;
+
+    constructor(key: number, value: number) {
+        this.key = key;
+        this.value = value;
+    }
+}
+
+export class PairingHeap implements Heap {
+    private root: PairingHeapNode | null = null;
+    private heapSize = 0;
+
+    public insert(key: number, value: number): void {
+        const node = new PairingHeapNode(key, value);
+        this.root = this.merge(this.root, node);
+        this.heapSize++;
+    }
+
+    public extractMin(): number | null {
+        if (!this.root) {
+            return null;
+        }
+
+        const minValue = this.root.value;
+        const minChild = this.root.child;
+
+        // Detach the old root
+        this.root.child = null;
+
+        // Combine all children of the old root
+        this.root = this.combineSiblings(minChild);
+        this.heapSize--;
+
+        return minValue;
+    }
+
+    public size(): number {
+        return this.heapSize;
+    }
+
+    /**
+     * Merges two pairing heaps into one. Assumes each parameter is a root.
+     * Returns the root of the merged tree.
+     */
+    private merge(a: PairingHeapNode | null, b: PairingHeapNode | null): PairingHeapNode | null {
+        if (!a) {
+            return b;
+        }
+        if (!b) {
+            return a;
+        }
+        if (a.key <= b.key) {
+            // Make b a child of a
+            b.sibling = a.child;
+            a.child = b;
+            return a;
+        } else {
+            // Make a a child of b
+            a.sibling = b.child;
+            b.child = a;
+            return b;
+        }
+    }
+
+    /**
+     * Merges an entire list of siblings into a single root using a two‐pass pairing strategy.
+     */
+    private combineSiblings(firstSibling: PairingHeapNode | null): PairingHeapNode | null {
+        if (!firstSibling || !firstSibling.sibling) {
+            // Zero or one sibling, so it's already merged
+            return firstSibling;
+        }
+
+        // Step 1: Collect siblings into an array
+        const siblingArray: PairingHeapNode[] = [];
+        let current: PairingHeapNode | null = firstSibling;
+        while (current) {
+            const next: PairingHeapNode = current.sibling!;
+            current.sibling = null;
+            siblingArray.push(current);
+            current = next;
+        }
+
+        // Step 2: Pair up neighbors and merge them
+        let i = 0;
+        for (; i + 1 < siblingArray.length; i += 2) {
+            siblingArray[i] = this.merge(siblingArray[i], siblingArray[i + 1])!;
+        }
+
+        // If we had an odd number of siblings, 'i' is now pointing at the last single sibling
+        // Step 3: Merge the resulting heaps left to right
+        let j = i - 2;
+        // j starts at the second‐to‐last pair
+        if (j < 0) {
+            j = 0;
+        }
+        for (; j >= 0; j -= 2) {
+            siblingArray[j] = this.merge(siblingArray[j], siblingArray[j + 2])!;
+        }
+
+        return siblingArray[0];
+    }
+}

package/src/terra-route.compare.spec.ts

@@ -0,0 +1,89 @@
+import PathFinder, { pathToGeoJSON } from "geojson-path-finder";
+import { FeatureCollection, LineString, Position } from "geojson";
+import { haversineDistance, TerraRoute } from "./terra-route";
+import { createPointFeature, routeLength } from "./test-utils/test-utils";
+import { readFileSync } from 'fs';
+
+
+/** Test on a "real" network to ensure that the path is as short or shorter than GeoJSON Path Finder */
+describe("TerraRoute", () => {
+    describe('getRoute', () => {
+        it('matches route create from GeoJSON Path Finder', () => {
+
+            const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
+
+            const pairs: [Position, Position][] = [];
+
+            // Connect midpoints of lines across the network
+            for (let i = 0, j = network.features.length - 1; i < j; i++, j--) {
+                const coordsA = network.features[i].geometry.coordinates;
+                const coordsB = network.features[j].geometry.coordinates;
+
+                const midA = Math.floor(coordsA.length / 2);
+                const midB = Math.floor(coordsB.length / 2);
+
+                pairs.push([
+                    coordsA[midA] as Position,
+                    coordsB[midB] as Position
+                ]);
+            }
+
+            // Connect starting and ending points of lines across the network
+            for (let i = 0, j = network.features.length - 1; i < j; i++, j--) {
+                const coordsA = network.features[i].geometry.coordinates;
+                const coordsB = network.features[j].geometry.coordinates;
+
+                pairs.push([
+                    coordsA[0] as Position,
+                    coordsB[coordsB.length - 1] as Position
+                ]);
+            }
+
+            const terraRoute = new TerraRoute();
+
+            terraRoute.buildRouteGraph(network as FeatureCollection<LineString>);
+
+            const pathFinder = new PathFinder(network as FeatureCollection<LineString>, {
+                // Mimic points having to be identical
+                tolerance: 0.000000000000000000001,
+                weight: (a, b) => haversineDistance(a, b)
+            });
+
+            for (let i = 0; i < pairs.length; i++) {
+                // Start and end points are the same
+                const startIsEnd = pairs[i][0][0] === pairs[i][1][0] && pairs[i][0][1] === pairs[i][1][1]
+                if (startIsEnd) {
+                    continue;
+                }
+
+                const start = createPointFeature(pairs[i][0]);
+                const end = createPointFeature(pairs[i][1]);
+
+                const route = pathFinder.findPath(start, end);
+                expect(route).not.toBeNull();
+
+                // Route not found
+                if (!route || route.path.length <= 1) {
+                    const routeFromTerraRoute = terraRoute.getRoute(start, end);
+
+                    // We want to check terra-route also returns null in this scenario
+                    expect(routeFromTerraRoute).toBeNull();
+                    continue
+                }
+
+                const routeFromPathFinder = pathToGeoJSON(route);
+                expect(routeFromPathFinder).toBeDefined();
+
+                const routeFromTerraRoute = terraRoute.getRoute(start, end);
+                expect(routeFromTerraRoute).not.toBeNull();
+
+                const pathFinderLength = routeLength(routeFromPathFinder!)
+                const terraDrawLength = routeLength(routeFromTerraRoute!);
+
+                expect(pathFinderLength).toBeGreaterThanOrEqual(terraDrawLength);
+
+            }
+        });
+
+    })
+});