terra-route 0.0.8 → 0.0.9

package/src/distance/haversine.ts

@@ -22,5 +22,6 @@ export const haversineDistance = (pointOne: Position, pointTwo: Position): numbe
     const radius = 6371e3;
     const distance = radius * c;
 
+
     return distance / 1000;
 }

package/src/graph/graph.ts

@@ -0,0 +1,151 @@
+import { Feature, FeatureCollection, LineString, Point } from "geojson";
+import { graphGetConnectedComponentCount, graphGetConnectedComponents } from "./methods/connected";
+import { graphGetNodeAndEdgeCount, graphGetNodesAsPoints } from "./methods/nodes";
+import { graphGetUniqueSegments } from "./methods/unique-segments";
+import { routeLength } from "../test-utils/utils";
+
+/**
+ * Represents a graph constructed from a GeoJSON FeatureCollection of LineString features.
+ * This class provides methods to analyze the graph, including connected components, node and edge counts,
+ * and shortest paths. Coordinates in the LineStrings are considered connected if they share identical coordinates.
+ */
+export class LineStringGraph {
+    constructor(network: FeatureCollection<LineString>) {
+        this.network = network;
+    }
+
+    private network: FeatureCollection<LineString>;
+
+    /**
+     * Sets the network for the graph.
+     * This method replaces the current network with a new one.
+     * @param network A GeoJSON FeatureCollection of LineString features representing the network.
+     */
+    setNetwork(network: FeatureCollection<LineString>) {
+        this.network = network;
+    }
+
+    /**
+     * Gets the current network of the graph.
+     * @returns A GeoJSON FeatureCollection of LineString features representing the network.
+     */
+    getNetwork(): FeatureCollection<LineString> {
+        return this.network;
+    }
+
+    /**
+     * Gets the connected components of the graph.
+     * @returns An array of FeatureCollection<LineString> representing the connected components.
+     */
+    getConnectedComponents(): FeatureCollection<LineString>[] {
+        return graphGetConnectedComponents(this.network)
+    }
+
+    /**
+     * Gets the count of connected components in the graph.
+     * @returns The number of connected components in the graph.
+     */
+    getConnectedComponentCount(): number {
+        return graphGetConnectedComponentCount(this.network);
+    }
+
+    /**
+     * Gets the count of unique nodes and edges in the graph.
+     * @returns An object containing the counts of nodes and edges.
+     */
+    getNodeAndEdgeCount(): { nodeCount: number, edgeCount: number } {
+        return graphGetNodeAndEdgeCount(this.network);
+    }
+
+    /**
+     * Gets the unique nodes of the graph as a FeatureCollection of Point features.
+     * @returns A FeatureCollection<Point> containing the nodes of the graph.
+     */
+    getNodes(): FeatureCollection<Point> {
+        const nodes = graphGetNodesAsPoints(this.network);
+        return {
+            type: "FeatureCollection",
+            features: nodes
+        };
+    }
+
+    /**
+     * Gets the count of unique nodes in the graph.
+     * @returns The number of unique nodes in the graph.
+     */
+    getNodeCount(): number {
+        const { nodeCount } = this.getNodeAndEdgeCount();
+        return nodeCount;
+    }
+
+    /**
+     * Gets the unique edges of the graph as a FeatureCollection of LineString features. Each edge is represented as a LineString.
+     * This method ensures that each edge is unique, meaning that edges are not duplicated in the collection. Each linestring only 
+     * two coordinates, representing the start and end points of the edge.
+     * @returns A FeatureCollection<LineString> containing the unique edges of the graph.
+     */
+    getEdges(): FeatureCollection<LineString> {
+        return graphGetUniqueSegments(this.network);
+    }
+
+    /**
+     * Gets the length of the longest edge in the graph based on the length of the LineString.
+     * If no edges exist, it returns -1.
+     * @returns The length of the longest edge in meters, or 0 if no edges exist.
+     */
+    getLongestEdgeLength(): number {
+        const longestEdge = this.getLongestEdge();
+        if (!longestEdge) {
+            return -1;
+        }
+        return routeLength(longestEdge);
+    }
+
+    /**
+     * Gets the length of the shortest edge in the graph based on the length of the LineString.
+     * If no edges exist, it returns -1.
+     * @returns The length of the shortest edge in meters, or 0 if no edges exist.
+     */
+    getShortestEdgeLength(): number {
+        const shortestEdge = this.getShortestEdge();
+        if (!shortestEdge) {
+            return -1;
+        }
+        return routeLength(shortestEdge);
+    }
+
+    /**
+     * Gets the longest edge in the graph based on the length of the LineString.
+     * @returns The longest edge as a Feature<LineString> or null if no edges exist.
+     */
+    getLongestEdge(): Feature<LineString> | null {
+        const edges = this.getEdges().features;
+        if (edges.length === 0) {
+            return null;
+        }
+        const longestEdges = edges.sort((a, b) => routeLength(a) - routeLength(b));
+        return longestEdges[longestEdges.length - 1];
+    }
+
+    /**
+     * Gets the shortest edge in the graph based on the length of the LineString.
+     * @returns The shortest edge as a Feature<LineString> or null if no edges exist.
+     */
+    getShortestEdge(): Feature<LineString> | null {
+        const edges = this.getEdges().features;
+        if (edges.length === 0) {
+            return null;
+        }
+        const shortestEdges = edges.sort((a, b) => routeLength(a) - routeLength(b));
+        return shortestEdges[0];
+    }
+
+    /**
+     * Gets the count of unique edges in the graph.
+     * @returns The number of unique edges in the graph.
+     */
+    getEdgeCount(): number {
+        const { edgeCount } = this.getNodeAndEdgeCount();
+        return edgeCount;
+    }
+}

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

@@ -0,0 +1,217 @@
+import { FeatureCollection, LineString } from 'geojson';
+import { graphGetConnectedComponentCount, graphGetConnectedComponents } from './connected';
+import { generateTreeFeatureCollection } from '../../test-utils/generate-network';
+import { createFeatureCollection, createLineStringFeature } from '../../test-utils/create';
+import { readFileSync } from 'fs';
+
+describe('countConnectedComponents', () => {
+    describe('for an empty feature collection', () => {
+        it('returns 0', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([]);
+            const output = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(0);
+        });
+    });
+
+    describe('for feature collection with 1 linestring', () => {
+        it('returns 1', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]])
+            ]);
+            const output = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(1);
+        });
+    });
+
+    describe('for feature collection with 2 linestring', () => {
+        it('returns 1 if connected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[1, 1], [2, 2]]),
+
+            ]);
+            const output = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(1);
+        });
+
+        it('returns 2 if unconnected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([[0, 0], [1, 1]]),
+                createLineStringFeature([[10, 10], [11, 11]]),
+
+            ]);
+            const output = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(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 = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(1);
+        });
+
+        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 = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(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 = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(1);
+        });
+
+        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 = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(2);
+        });
+
+
+        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 = graphGetConnectedComponentCount(input);
+
+            expect(output).toBe(1);
+        });
+    });
+
+    describe('for complex linestring network', () => {
+        it('returns 1 when tree is connected', () => {
+            const input = generateTreeFeatureCollection(3, 2)
+            const output = graphGetConnectedComponentCount(input)
+
+            expect(output).toBe(1);
+        });
+
+        it('returns 1 when it is connected correctly', () => {
+            const input = generateTreeFeatureCollection(3, 2)
+            const output = graphGetConnectedComponentCount(input)
+
+            expect(output).toBe(1);
+        });
+    })
+});
+
+describe('splitIntoConnectedComponents', () => {
+    it('returns empty array for empty feature collection', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([]);
+        const output = graphGetConnectedComponents(input);
+
+        expect(output).toEqual([]);
+    });
+
+    it('returns single component for single linestring', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]])
+        ]);
+        const output = graphGetConnectedComponents(input);
+
+        expect(output).toHaveLength(1);
+        expect(output[0].features).toHaveLength(1);
+    });
+
+    it('returns multiple components for disconnected linestrings', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]]),
+            createLineStringFeature([[10, 10], [11, 11]])
+        ]);
+        const output = graphGetConnectedComponents(input);
+
+        expect(output).toHaveLength(2);
+        expect(output[0].features).toHaveLength(1);
+        expect(output[1].features).toHaveLength(1);
+    });
+
+    it('returns single component for connected linestrings', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]]),
+            createLineStringFeature([[1, 1], [2, 2]])
+        ]);
+        const output = graphGetConnectedComponents(input);
+
+        expect(output).toHaveLength(1);
+        expect(output[0].features).toHaveLength(2);
+        expect(output[0].features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+        expect(output[0].features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
+    });
+
+    it('returns multiple components for selection of connected linestrings', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            createLineStringFeature([[0, 0], [1, 1]]),
+            createLineStringFeature([[1, 1], [2, 2]]),
+            createLineStringFeature([[10, 10], [11, 11]]),
+            createLineStringFeature([[20, 20], [21, 21]])
+        ]);
+        const output = graphGetConnectedComponents(input);
+
+        expect(output).toHaveLength(3);
+        expect(output[0].features).toHaveLength(1);
+        expect(output[1].features).toHaveLength(1);
+        expect(output[2].features).toHaveLength(2);
+    });
+
+    it('returns single component for complex selection of linestrings', () => {
+        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
+        const output = graphGetConnectedComponents(network);
+        expect(output).toHaveLength(1);
+        expect(output[0].features).toHaveLength(network.features.length);
+    });
+
+    it('returns multiple components for complex selection of linestrings', () => {
+        const network = JSON.parse(readFileSync('src/data/network-5-cc.geojson', 'utf-8')) as FeatureCollection<LineString>;
+        const output = graphGetConnectedComponents(network);
+        expect(output).toHaveLength(5);
+        expect(output[4].features > output[0].features).toBeTruthy();
+    });
+
+    it('ensures splitIntoConnectedComponents and countConnectedComponents are consistent', () => {
+        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
+        const components = graphGetConnectedComponents(network);
+        const count = graphGetConnectedComponentCount(network);
+        expect(components.length).toBe(count);
+
+        const networkMultipleCC = JSON.parse(readFileSync('src/data/network-5-cc.geojson', 'utf-8')) as FeatureCollection<LineString>;
+        const componentsMultipleCC = graphGetConnectedComponents(networkMultipleCC);
+        const countMultipleCC = graphGetConnectedComponentCount(networkMultipleCC);
+        expect(componentsMultipleCC.length).toBe(countMultipleCC);
+    });
+})

package/src/graph/methods/connected.ts

@@ -0,0 +1,168 @@
+import { Feature, FeatureCollection, LineString, Position } from 'geojson'
+
+/**
+ * Counts the number of connected components in a graph represented by LineString features in a GeoJSON FeatureCollection.
+ * Each LineString is treated as an edge in the graph, and connected components are determined by shared coordinates.
+ * @param featureCollection - A GeoJSON FeatureCollection containing LineString features
+ * @returns The number of connected components in the graph represented by the LineStrings
+ */
+export function graphGetConnectedComponentCount(
+    featureCollection: FeatureCollection<LineString>
+): number {
+    const features = featureCollection.features
+    const numberOfFeatures = features.length
+
+    // Map coordinates to feature indices
+    const coordinateToFeatureIndices = new Map<string, number[]>()
+
+    for (let index = 0; index < numberOfFeatures; index++) {
+        const coordinates = features[index].geometry.coordinates
+
+        for (const coordinate of coordinates) {
+            const key = coordinateKey(coordinate)
+
+            if (!coordinateToFeatureIndices.has(key)) {
+                coordinateToFeatureIndices.set(key, [])
+            }
+
+            coordinateToFeatureIndices.get(key)!.push(index)
+        }
+    }
+
+    // Build adjacency list for the graph
+    const adjacencyList: number[][] = Array.from({ length: numberOfFeatures }, () => [])
+
+    for (const indices of coordinateToFeatureIndices.values()) {
+        for (let i = 0; i < indices.length; i++) {
+            for (let j = i + 1; j < indices.length; j++) {
+                const a = indices[i]
+                const b = indices[j]
+                adjacencyList[a].push(b)
+                adjacencyList[b].push(a)
+            }
+        }
+    }
+
+    const visited = new Array<boolean>(numberOfFeatures).fill(false)
+    let connectedComponents = 0
+
+    for (let index = 0; index < numberOfFeatures; index++) {
+        if (!visited[index]) {
+            dfs(index, adjacencyList, visited)
+            connectedComponents++
+        }
+    }
+
+    return connectedComponents
+}
+
+/**
+ * Depth-first search to mark all reachable nodes from the given index.
+ * @param index - The current node index to start DFS from.
+ * @param adjacencyList - The adjacency list representing the graph.
+ * @param visited - An array to keep track of visited nodes.
+ */
+function dfs(index: number, adjacencyList: number[][], visited: boolean[]): void {
+    visited[index] = true
+
+    for (const neighbor of adjacencyList[index]) {
+        if (!visited[neighbor]) {
+            dfs(neighbor, adjacencyList, visited)
+        }
+    }
+}
+
+function coordinateKey(position: Position): string {
+    return `${position[0]},${position[1]}`
+}
+
+export function graphGetConnectedComponents(
+    featureCollection: FeatureCollection<LineString>
+): FeatureCollection<LineString>[] {
+    const features = featureCollection.features
+    const graph: Map<number, Set<number>> = new Map()
+    const coordinateMap: Map<string, Set<number>> = new Map()
+
+    function coordinateKey(coordinate: Position): string {
+        return `${coordinate[0]},${coordinate[1]}`
+    }
+
+    // Build coordinate map: coordinate string -> Set of feature indices
+    for (let index = 0; index < features.length; index++) {
+        const coordinates = features[index].geometry.coordinates
+
+        for (const coordinate of coordinates) {
+            const key = coordinateKey(coordinate)
+
+            if (!coordinateMap.has(key)) {
+                coordinateMap.set(key, new Set())
+            }
+
+            coordinateMap.get(key)!.add(index)
+        }
+    }
+
+    // Build adjacency list for graph
+    for (let index = 0; index < features.length; index++) {
+        graph.set(index, new Set())
+
+        const coordinates = features[index].geometry.coordinates
+        for (const coordinate of coordinates) {
+            const key = coordinateKey(coordinate)
+            const neighbors = coordinateMap.get(key)
+
+            if (neighbors) {
+                for (const neighborIndex of neighbors) {
+                    if (neighborIndex !== index) {
+                        graph.get(index)!.add(neighborIndex)
+                    }
+                }
+            }
+        }
+    }
+
+    // DFS to find connected components
+    const visited = new Set<number>()
+    const components: FeatureCollection<LineString>[] = []
+
+    function dfs(startIndex: number, currentComponent: Feature<LineString>[]): void {
+        const stack: number[] = [startIndex]
+
+        while (stack.length > 0) {
+            const currentIndex = stack.pop()!
+
+            if (visited.has(currentIndex)) {
+                continue
+            }
+
+            visited.add(currentIndex)
+            currentComponent.push(features[currentIndex])
+
+            const neighbors = graph.get(currentIndex)
+            if (neighbors) {
+                for (const neighbor of neighbors) {
+                    if (!visited.has(neighbor)) {
+                        stack.push(neighbor)
+                    }
+                }
+            }
+        }
+    }
+
+    for (let index = 0; index < features.length; index++) {
+        if (!visited.has(index)) {
+            const component: Feature<LineString>[] = []
+            dfs(index, component)
+            components.push({
+                type: 'FeatureCollection',
+                features: component
+            })
+        }
+    }
+
+
+    // Sort components by the number of features in ascending order
+    components.sort((a, b) => a.features.length - b.features.length)
+
+    return components
+}