terra-route 0.0.7 → 0.0.9

package/src/graph/methods/nodes.spec.ts

@@ -0,0 +1,317 @@
+import { FeatureCollection, LineString } from 'geojson';
+import { graphGetNodesAsPoints, graphGetNodeAndEdgeCount } from './nodes';
+import { createFeatureCollection, createLineStringFeature } from '../../test-utils/create';
+
+describe('graphGetNodeAndEdgeCount', () => {
+    describe('for an empty feature collection', () => {
+        it('returns 0 nodes and edges', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 0,
+                edgeCount: 0
+            });
+        });
+    });
+
+    describe('for feature collection with 1 linestring', () => {
+        it('returns 1', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]])
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 2,
+                edgeCount: 1
+            });
+        });
+    });
+
+    describe('for feature collection with 2 linestring', () => {
+        it('returns 3 nodes and 2 edges if line is connected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [2, 2]]),
+
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 3,
+                edgeCount: 2
+            });
+        });
+
+        it('returns 4 nodes and 2 if unconnected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[10, 10], [11, 11]]),
+
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 4,
+                edgeCount: 2
+            });
+        });
+    });
+
+    describe('for feature collection with 3 linestring', () => {
+        it('returns 1 if connected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [2, 2]]),
+                createLineStringFeature([[2, 2], [3, 3]]),
+
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 4,
+                edgeCount: 3
+            });
+        });
+
+        it('returns 3 if unconnected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[10, 10], [11, 11]]),
+                createLineStringFeature([[20, 20], [21, 21]]),
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 6,
+                edgeCount: 3
+            });
+        });
+    });
+
+
+    describe('for feature collection with multiple linestring', () => {
+        it('returns 1 when all lines share the same coordinate', () => {
+            const input = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [2, 2]]),
+                createLineStringFeature([[1, 1], [3, 3]]),
+                createLineStringFeature([[4, 4], [1, 1]]),
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 5,
+                edgeCount: 4
+            });
+        });
+
+        it('returns 2 when two disconnected groups exist', () => {
+            const input = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [2, 2]]),
+                createLineStringFeature([[10, 10], [11, 11]]),
+                createLineStringFeature([[11, 11], [12, 12]]),
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 6,
+                edgeCount: 4
+            });
+        });
+
+
+        it('returns 1 for a loop of connected lines', () => {
+            const input = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 0]]),
+                createLineStringFeature([[1, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [0, 1]]),
+                createLineStringFeature([[0, 1], [0, 0]]),
+            ]);
+            const output = graphGetNodeAndEdgeCount(input);
+
+            expect(output).toEqual({
+                nodeCount: 4,
+                edgeCount: 4
+            });
+        });
+    });
+});
+
+describe('graphGetNodesAsPoints', () => {
+    it('returns an empty array for an empty feature collection', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([]);
+        const output = graphGetNodesAsPoints(input);
+
+        expect(output).toEqual([]);
+    });
+
+    it('returns points for a single linestring', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]])
+        ]);
+        const output = graphGetNodesAsPoints(input);
+
+        expect(output).toEqual([
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [0, 0]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [1, 1]
+                },
+                properties: {}
+            }
+        ]);
+    });
+
+    it('returns points for multiple linestrings with unique coordinates', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]]),
+            createLineStringFeature([[1, 1], [2, 2]]),
+            createLineStringFeature([[3, 3], [4, 4]])
+        ]);
+        const output = graphGetNodesAsPoints(input);
+
+        expect(output).toEqual([
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [0, 0]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [1, 1]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [2, 2]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [3, 3]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [4, 4]
+                },
+                properties: {}
+            }
+        ]);
+    });
+
+    it('returns points for multiple linestrings with shared coordinates', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]]),
+            createLineStringFeature([[1, 1], [2, 2]]),
+            createLineStringFeature([[1, 1], [3, 3]])
+        ]);
+        const output = graphGetNodesAsPoints(input);
+
+        expect(output).toEqual([
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [0, 0]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [1, 1]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [2, 2]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [3, 3]
+                },
+                properties: {}
+            }
+        ]);
+    });
+
+    it('returns points for a loop of connected lines', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 0]]),
+            createLineStringFeature([[1, 0], [1, 1]]),
+            createLineStringFeature([[1, 1], [0, 1]]),
+            createLineStringFeature([[0, 1], [0, 0]]),
+        ]);
+        const output = graphGetNodesAsPoints(input);
+
+        expect(output).toEqual([
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [0, 0]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [1, 0]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [1, 1]
+                },
+                properties: {}
+            },
+            {
+                type: 'Feature',
+                geometry: {
+                    type: 'Point',
+                    coordinates: [0, 1]
+                },
+                properties: {}
+            }
+        ]);
+    });
+})

package/src/graph/methods/nodes.ts

@@ -0,0 +1,77 @@
+import { Feature, FeatureCollection, LineString, Point, Position } from 'geojson'
+
+/**
+ * Counts the unique nodes and edges in a GeoJSON FeatureCollection of LineString features.
+ * @param featureCollection - A GeoJSON FeatureCollection containing LineString features
+ * @returns An object containing the count of unique nodes and edges
+ */
+export function graphGetNodeAndEdgeCount(
+    featureCollection: FeatureCollection<LineString>
+): { nodeCount: number; edgeCount: number } {
+    const nodeSet = new Set<string>()
+    const edgeSet = new Set<string>()
+
+    for (const feature of featureCollection.features) {
+        const coordinates = feature.geometry.coordinates
+
+        for (const coordinate of coordinates) {
+            nodeSet.add(JSON.stringify(coordinate))
+        }
+
+        for (let i = 0; i < coordinates.length - 1; i++) {
+            const coordinateOne = coordinates[i]
+            const coordinateTwo = coordinates[i + 1]
+
+            const edge = normalizeEdge(coordinateOne, coordinateTwo)
+            edgeSet.add(edge)
+        }
+    }
+
+    return {
+        nodeCount: nodeSet.size,
+        edgeCount: edgeSet.size,
+    }
+}
+
+function normalizeEdge(coordinateOne: Position, coordinateTwo: Position): string {
+    const stringOne = JSON.stringify(coordinateOne)
+    const stringTwo = JSON.stringify(coordinateTwo)
+
+    if (stringOne < stringTwo) {
+        return `${stringOne}|${stringTwo}`
+    }
+
+    return `${stringTwo}|${stringOne}`
+}
+
+
+/**
+ * Converts a FeatureCollection of LineString features into a FeatureCollection of Point features,
+ * where each unique coordinate in the LineStrings becomes a Point.
+ * @param lines - A GeoJSON FeatureCollection containing LineString features
+ * @returns A FeatureCollection of Point features representing unique nodes
+ */
+export function graphGetNodesAsPoints(lines: FeatureCollection<LineString>): Feature<Point>[] {
+    const seen = new Set<string>();
+    const points: Feature<Point>[] = [];
+
+    for (const feature of lines.features) {
+        for (const coord of feature.geometry.coordinates) {
+            const key = coord.join(',');
+
+            if (!seen.has(key)) {
+                seen.add(key);
+                points.push({
+                    type: 'Feature',
+                    geometry: {
+                        type: 'Point',
+                        coordinates: coord
+                    },
+                    properties: {}
+                });
+            }
+        }
+    }
+
+    return points;
+}

package/src/graph/methods/unique-segments.spec.ts

@@ -0,0 +1,16 @@
+import { FeatureCollection, LineString } from 'geojson';
+import { readFileSync } from 'fs';
+import { graphGetUniqueSegments } from './unique-segments';
+import { graphGetNodeAndEdgeCount } from './nodes';
+
+describe('graphGetUniqueSegments', () => {
+    it('should not change the properties of the graph', () => {
+        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
+
+        const networkAfter = graphGetUniqueSegments(network)
+
+        const afterNodeAndEdgeCount = graphGetNodeAndEdgeCount(networkAfter);
+        expect(afterNodeAndEdgeCount).toEqual(graphGetNodeAndEdgeCount(network));
+        expect(networkAfter.features.length).toEqual(afterNodeAndEdgeCount.edgeCount);
+    });
+});

package/src/graph/methods/unique-segments.ts

@@ -0,0 +1,69 @@
+import {
+    Feature,
+    FeatureCollection,
+    LineString,
+    Position
+} from 'geojson';
+
+/**
+ * Normalize a segment so that [A, B] is equal to [B, A]
+ */
+function normalizeSegment(start: Position, end: Position): [Position, Position] {
+    const [aLat, aLng] = start;
+    const [bLat, bLng] = end;
+
+    if (
+        aLat < bLat ||
+        (aLat === bLat && aLng <= bLng)
+    ) {
+        return [start, end];
+    }
+
+    return [end, start];
+}
+
+/**
+ * Convert a pair of Positions to a string key for deduplication
+ */
+function segmentKey(start: Position, end: Position): string {
+    const [normalizedStart, normalizedEnd] = normalizeSegment(start, end);
+    return JSON.stringify([normalizedStart, normalizedEnd]);
+}
+
+/**
+ * Breaks LineStrings in a FeatureCollection into unique single line segments
+ */
+export function graphGetUniqueSegments(
+    input: FeatureCollection<LineString>
+): FeatureCollection<LineString> {
+    const uniqueSegments = new Map<string, Feature<LineString>>();
+
+    for (const feature of input.features) {
+        const coordinates = feature.geometry.coordinates;
+
+        for (let index = 0; index < coordinates.length - 1; index++) {
+            const start = coordinates[index];
+            const end = coordinates[index + 1];
+
+            const key = segmentKey(start, end);
+
+            if (!uniqueSegments.has(key)) {
+                const segment: Feature<LineString> = {
+                    type: 'Feature',
+                    geometry: {
+                        type: 'LineString',
+                        coordinates: [start, end]
+                    },
+                    properties: {}
+                };
+
+                uniqueSegments.set(key, segment);
+            }
+        }
+    }
+
+    return {
+        type: 'FeatureCollection',
+        features: Array.from(uniqueSegments.values())
+    };
+}

package/src/heap/min-heap.ts

@@ -6,29 +6,40 @@ export class MinHeap implements Heap {
 
     insert(key: number, value: number): void {
         const node = { key, value, index: this.insertCounter++ };
-        let idx = this.heap.length;
+        let currentIndex = this.heap.length;
         this.heap.push(node);
 
-        // Optimized Bubble Up
-        while (idx > 0) {
-            const parentIdx = (idx - 1) >>> 1; // Fast Math.floor((idx - 1) / 2)
-            const parent = this.heap[parentIdx];
-            if (node.key > parent.key || (node.key === parent.key && node.index > parent.index)) break;
-            this.heap[idx] = parent;
-            idx = parentIdx;
+        while (currentIndex > 0) {
+            const parentIndex = (currentIndex - 1) >>> 1;
+            const parent = this.heap[parentIndex];
+
+            if (
+                key > parent.key ||
+                (key === parent.key && node.index > parent.index)
+            ) {
+                break;
+            }
+
+            this.heap[currentIndex] = parent;
+            currentIndex = parentIndex;
         }
-        this.heap[idx] = node;
+
+        this.heap[currentIndex] = node;
     }
 
     extractMin(): number | null {
-        const length = this.heap.length;
-        if (length === 0) return null;
+        const heap = this.heap;
+        const length = heap.length;
+
+        if (length === 0) {
+            return null;
+        }
 
-        const minNode = this.heap[0];
-        const endNode = this.heap.pop()!;
+        const minNode = heap[0];
+        const endNode = heap.pop()!;
 
         if (length > 1) {
-            this.heap[0] = endNode;
+            heap[0] = endNode;
             this.bubbleDown(0);
         }
 
@@ -39,52 +50,45 @@ export class MinHeap implements Heap {
         return this.heap.length;
     }
 
-    private bubbleDown(idx: number): void {
-        const { heap } = this;
+    private bubbleDown(index: number): void {
+        const heap = this.heap;
         const length = heap.length;
-        // Grab the parent node once, then move it down only if needed
-        const node = heap[idx];
+        const node = heap[index];
         const nodeKey = node.key;
         const nodeIndex = node.index;
 
-        // eslint-disable-next-line no-constant-condition
         while (true) {
-            // Calculate left and right child indexes
-            const leftIdx = (idx << 1) + 1;
-            if (leftIdx >= length) {
-                // No children => we’re already in place
+            const leftChildIndex = (index << 1) + 1;
+            if (leftChildIndex >= length) {
                 break;
             }
 
-            // Assume left child is the smaller one by default
-            let smallestIdx = leftIdx;
-            let smallestKey = heap[leftIdx].key;
-            let smallestIndex = heap[leftIdx].index;
-
-            const rightIdx = leftIdx + 1;
-            if (rightIdx < length) {
-                // Compare left child vs. right child
-                const rightKey = heap[rightIdx].key;
-                const rightIndex = heap[rightIdx].index;
-                if (rightKey < smallestKey || (rightKey === smallestKey && rightIndex < smallestIndex)) {
-                    smallestIdx = rightIdx;
-                    smallestKey = rightKey;
-                    smallestIndex = rightIndex;
+            let smallestIndex = leftChildIndex;
+            let smallest = heap[leftChildIndex];
+
+            const rightChildIndex = leftChildIndex + 1;
+            if (rightChildIndex < length) {
+                const right = heap[rightChildIndex];
+                if (
+                    right.key < smallest.key ||
+                    (right.key === smallest.key && right.index < smallest.index)
+                ) {
+                    smallestIndex = rightChildIndex;
+                    smallest = right;
                 }
             }
 
-            // Compare the smaller child with the parent
-            if (smallestKey < nodeKey || (smallestKey === nodeKey && smallestIndex < nodeIndex)) {
-                // Swap the smaller child up
-                heap[idx] = heap[smallestIdx];
-                idx = smallestIdx;
+            if (
+                smallest.key < nodeKey ||
+                (smallest.key === nodeKey && smallest.index < nodeIndex)
+            ) {
+                heap[index] = smallest;
+                index = smallestIndex;
             } else {
-                // We’re in the correct position now, so stop
                 break;
             }
         }
 
-        // Place the original node in its final position
-        heap[idx] = node;
+        heap[index] = node;
     }
-}
+}

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

@@ -1,7 +1,9 @@
 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 { routeLength } from "./test-utils/utils";
+import { createPointFeature } from "./test-utils/create";
+
 import { readFileSync } from 'fs';
 
 

package/src/terra-route.spec.ts

@@ -1,8 +1,19 @@
 import { createCheapRuler } from "./distance/cheap-ruler";
 import { TerraRoute } from "./terra-route";
-import { createFeatureCollection, createLineStringFeature, createPointFeature, generateConcentricRings, generateGridWithDiagonals, generateStarPolygon, generateTreeFeatureCollection, getReasonIfLineStringInvalid, getUniqueCoordinatesFromLineStrings, routeIsLongerThanDirectPath, startAndEndAreCorrect } from "./test-utils/test-utils";
+import {
+    createFeatureCollection, createLineStringFeature, createPointFeature,
+} from "./test-utils/create";
+
+import {
+    generateConcentricRings, generateGridWithDiagonals, generateStarPolygon, generateTreeFeatureCollection,
+} from "./test-utils/generate-network";
+
+import {
+    getReasonIfLineStringInvalid, getUniqueCoordinatesFromLineStrings, routeIsLongerThanDirectPath, startAndEndAreCorrect
+} from "./test-utils/utils";
 
 describe("TerraRoute", () => {
+
     let routeFinder: TerraRoute;
 
     beforeEach(() => {