terra-route 0.0.11 → 0.0.12

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

@@ -1,317 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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/spatial-index/geokdbush.spec.ts

@@ -1,86 +0,0 @@
-import { KDBush } from './kdbush';
-import { around, distance } from './geokdbush';
-
-describe('geokdbush', () => {
-    const points = [
-        [0, 0], [1, 1], [2, 2], [3, 3],
-        [1, 0], [0, 1], [3, 2], [2, 3]
-    ];
-    const index = new KDBush(points.length);
-    for (const p of points) {
-        index.add(p[0], p[1]);
-    }
-    index.finish();
-
-    it('should return points within a given radius', () => {
-        const d = distance(0, 0, 1, 1);
-        const result = around(index, 0, 0, Infinity, d + 1);
-        const resultPoints = result.map(i => points[i]);
-        expect(resultPoints).toEqual(expect.arrayContaining([
-            [0, 0], [1, 1], [1, 0], [0, 1]
-        ]));
-        expect(resultPoints.length).toBe(4);
-    });
-
-    it('defaults to maxResults and maxDistance being Infinity', () => {
-        const result = around(index, 0, 0);
-        expect(result.length).toBe(points.length);
-        const resultPoints = result.map(i => points[i]);
-        expect(resultPoints).toEqual(expect.arrayContaining(points));
-    });
-
-    it('should return an empty array if no points are within the radius', () => {
-        const result = around(index, 10, 10, Infinity, 1);
-        expect(result).toEqual([]);
-    });
-
-    it('should handle maxResults correctly', () => {
-        const result = around(index, 0, 0, 2);
-        expect(result.length).toBe(2);
-    });
-
-    it('should also export a distance function', () => {
-        expect(distance(0, 0, 1, 1)).toBeCloseTo(157.2493, 2);
-    });
-
-    describe('with a larger number of points', () => {
-        const largePoints: [number, number][] = [];
-        for (let i = 0; i < 1000; i++) {
-            // Points around London
-            largePoints.push([
-                -0.1278 + (Math.random() - 0.5) * 2,
-                51.5074 + (Math.random() - 0.5) * 2
-            ]);
-        }
-        const index = new KDBush(largePoints.length, 16);
-        for (const p of largePoints) {
-            index.add(p[0], p[1]);
-        }
-        index.finish();
-
-        it('should find points around a location', () => {
-            const results = around(index, -0.1278, 51.5074, 10);
-            expect(results.length).toBe(10);
-            results.forEach(i => {
-                const p = largePoints[i];
-                expect(distance(p[0], p[1], -0.1278, 51.5074)).toBeLessThan(200); // 200km, rough check
-            });
-        });
-
-        it('should find points within a radius', () => {
-            const results = around(index, -0.1278, 51.5074, Infinity, 10); // 10km radius
-            expect(results.length).toBeGreaterThan(0);
-            results.forEach(i => {
-                const p = largePoints[i];
-                expect(distance(p[0], p[1], -0.1278, 51.5074)).toBeLessThanOrEqual(10);
-            });
-        });
-    });
-
-    it('should work with maxResults being undefined', () => {
-        const result = around(index, 0, 0, undefined);
-        expect(result.length).toBe(points.length);
-    });
-
-
-});

package/src/graph/methods/spatial-index/geokdbush.ts

@@ -1,189 +0,0 @@
-// Adapted from https://github.com/mourner/geokdbush
-
-// ISC License
-
-// Copyright (c) 2017, Vladimir Agafonkin
-
-// Permission to use, copy, modify, and/or distribute this software for any purpose
-// with or without fee is hereby granted, provided that the above copyright notice
-// and this permission notice appear in all copies.
-
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-// THIS SOFTWARE.
-
-import { KDBush } from './kdbush';
-import TinyQueue from './tinyqueue';
-
-const earthRadius = 6371;
-const rad = Math.PI / 180;
-
-
-// Distance is in kilometers
-export function around(index: KDBush, lng: number, lat: number, maxResults = Infinity, maxDistanceKm = Infinity) {
-    let maxHaverSinDist = 1;
-    const result = [];
-
-    if (maxResults === undefined) {
-        maxResults = Infinity;
-    }
-
-    if (maxDistanceKm !== undefined) {
-        maxHaverSinDist = haverSin(maxDistanceKm / earthRadius);
-    }
-
-    // a distance-sorted priority queue that will contain both points and kd-tree nodes
-    const q = new TinyQueue([], compareDist);
-
-    // an object that represents the top kd-tree node (the whole Earth)
-    let node = {
-        left: 0, // left index in the kd-tree array
-        right: index.ids.length - 1, // right index
-        axis: 0, // 0 for longitude axis and 1 for latitude axis
-        dist: 0, // will hold the lower bound of children's distances to the query point
-        minLng: -180, // bounding box of the node
-        minLat: -90,
-        maxLng: 180,
-        maxLat: 90
-    };
-
-    const cosLat = Math.cos(lat * rad);
-
-    while (node) {
-        const right = node.right;
-        const left = node.left;
-
-        if (right - left <= index.nodeSize) { // leaf node
-
-            // add all points of the leaf node to the queue
-            for (let i = left; i <= right; i++) {
-                const id = index.ids[i];
-
-                const dist = haverSinDist(lng, lat, index.coords[2 * i], index.coords[2 * i + 1], cosLat);
-                q.push({ id, dist });
-            }
-
-        } else { // not a leaf node (has child nodes)
-
-            const m = (left + right) >> 1; // middle index
-            const midLng = index.coords[2 * m];
-            const midLat = index.coords[2 * m + 1];
-
-            // add middle point to the queue
-            const id = index.ids[m];
-            const dist = haverSinDist(lng, lat, midLng, midLat, cosLat);
-            q.push({ id, dist });
-
-
-            const nextAxis = (node.axis + 1) % 2;
-
-            // first half of the node
-            const leftNode = {
-                left,
-                right: m - 1,
-                axis: nextAxis,
-                minLng: node.minLng,
-                minLat: node.minLat,
-                maxLng: node.axis === 0 ? midLng : node.maxLng,
-                maxLat: node.axis === 1 ? midLat : node.maxLat,
-                dist: 0
-            };
-            // second half of the node
-            const rightNode = {
-                left: m + 1,
-                right,
-                axis: nextAxis,
-                minLng: node.axis === 0 ? midLng : node.minLng,
-                minLat: node.axis === 1 ? midLat : node.minLat,
-                maxLng: node.maxLng,
-                maxLat: node.maxLat,
-                dist: 0
-            };
-
-            leftNode.dist = boxDist(lng, lat, cosLat, leftNode);
-            rightNode.dist = boxDist(lng, lat, cosLat, rightNode);
-
-            // add child nodes to the queue
-            q.push(leftNode);
-            q.push(rightNode);
-        }
-
-        // fetch closest points from the queue; they're guaranteed to be closer
-        // than all remaining points (both individual and those in kd-tree nodes),
-        // since each node's distance is a lower bound of distances to its children
-        while (q.length && q.peek().id != null) {
-            const candidate = q.pop()!;
-            if (candidate.dist > maxHaverSinDist) return result;
-            result.push(candidate.id);
-            if (result.length === maxResults) return result;
-        }
-
-        // the next closest kd-tree node
-        node = q.pop();
-    }
-
-    return result;
-}
-
-// lower bound for distance from a location to points inside a bounding box
-function boxDist(lng: number, lat: number, cosLat: number, node: any) {
-    const minLng = node.minLng;
-    const maxLng = node.maxLng;
-    const minLat = node.minLat;
-    const maxLat = node.maxLat;
-
-    // query point is between minimum and maximum longitudes
-    if (lng >= minLng && lng <= maxLng) {
-        if (lat < minLat) return haverSin((lat - minLat) * rad);
-        if (lat > maxLat) return haverSin((lat - maxLat) * rad);
-        return 0;
-    }
-
-    // query point is west or east of the bounding box;
-    // calculate the extremum for great circle distance from query point to the closest longitude;
-    const haverSinDLng = Math.min(haverSin((lng - minLng) * rad), haverSin((lng - maxLng) * rad));
-    const extremumLat = vertexLat(lat, haverSinDLng);
-
-    // if extremum is inside the box, return the distance to it
-    if (extremumLat > minLat && extremumLat < maxLat) {
-        return haverSinDistPartial(haverSinDLng, cosLat, lat, extremumLat);
-    }
-    // otherwise return the distan e to one of the bbox corners (whichever is closest)
-    return Math.min(
-        haverSinDistPartial(haverSinDLng, cosLat, lat, minLat),
-        haverSinDistPartial(haverSinDLng, cosLat, lat, maxLat)
-    );
-}
-
-function compareDist(a: any, b: any) {
-    return a.dist - b.dist;
-}
-
-function haverSin(theta: number) {
-    const s = Math.sin(theta / 2);
-    return s * s;
-}
-
-function haverSinDistPartial(haverSinDLng: number, cosLat1: number, lat1: number, lat2: number) {
-    return cosLat1 * Math.cos(lat2 * rad) * haverSinDLng + haverSin((lat1 - lat2) * rad);
-}
-
-function haverSinDist(lng1: number, lat1: number, lng2: number, lat2: number, cosLat1: number) {
-    const haverSinDLng = haverSin((lng1 - lng2) * rad);
-    return haverSinDistPartial(haverSinDLng, cosLat1, lat1, lat2);
-}
-
-export function distance(lng1: number, lat1: number, lng2: number, lat2: number) {
-    const h = haverSinDist(lng1, lat1, lng2, lat2, Math.cos(lat1 * rad));
-    return 2 * earthRadius * Math.asin(Math.sqrt(h));
-}
-
-function vertexLat(lat: number, haverSinDLng: number) {
-    const cosDLng = 1 - 2 * haverSinDLng;
-    if (cosDLng <= 0) return lat > 0 ? 90 : -90;
-    return Math.atan(Math.tan(lat * rad) / cosDLng) / rad;
-}