terra-route 0.0.8 → 0.0.10

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

@@ -0,0 +1,475 @@
+import { FeatureCollection, LineString } from 'geojson';
+import { unifyCloseCoordinates } from './unify';
+import { getReasonIfLineStringInvalid } from '../../test-utils/utils';
+import { graphGetConnectedComponentCount } from './connected';
+import { graphGetNodeAndEdgeCount } from './nodes';
+import { createFeatureCollection, createLineStringFeature } from '../../test-utils/create';
+
+describe('unifyCloseCoordinates', () => {
+    describe('for an empty feature collection', () => {
+        it('returns an empty feature collection', () => {
+            const input: FeatureCollection<LineString> = {
+                type: 'FeatureCollection',
+                features: []
+            };
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(output).toEqual({
+                type: 'FeatureCollection',
+                features: []
+            });
+        });
+    });
+
+    describe('for a single linestring', () => {
+        it('does not modify coordinates', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001], // ~1.5m apart
+                    [0.00002, 0.00002] // ~1.5m apart
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+            const coords = output.features[0].geometry.coordinates;
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+
+            expect(coords).toHaveLength(3); // Should unify to a single coordinate
+            expect(coords[0]).toEqual([0, 0]); // Both coordinates should unify to the first one
+            expect(coords[1]).toEqual([0.00001, 0.00001]); // Both coordinates should unify to the first one
+            expect(coords[2]).toEqual([0.00002, 0.00002]); // Both coordinates should unify to the first one
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 3, edgeCount: 2 });
+        });
+    });
+
+    describe('for two linestrings', () => {
+        it('does nothing if linestrings are already connected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00001, 0.00001],
+                    [0.00002, 0.00002] // ~1.5m apart
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsTwo[1]).toEqual([0.00002, 0.00002]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 3, edgeCount: 2 });
+        });
+
+        it('unifies two nearby linestring coordinates if they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00002, 0.00002],
+                    [0.00003, 0.00003] // ~1.5m apart
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsTwo[1]).toEqual([0.00003, 0.00003]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 3, edgeCount: 2 });
+        });
+
+        it('does not unify coordinates if they are not within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [1, 1]
+                ]),
+                createLineStringFeature([
+                    [10, 10],
+                    [11, 11]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([1, 1]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([10, 10]);
+            expect(coordsTwo[1]).toEqual([11, 11]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(2);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 4, edgeCount: 2 });
+        });
+
+        it('does unify both coordinates to corresponding coordinates in counterpart linestring if they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [1, 1]
+                ]),
+                createLineStringFeature([
+                    [0.000001, 0.000001],
+                    [1.000001, 1.000001]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([1, 1]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0, 0]);
+            expect(coordsTwo[1]).toEqual([1, 1]);
+
+            // Only one because lines are now identical and connected
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 2, edgeCount: 1 });
+        });
+    });
+
+    describe('for multiple linestrings', () => {
+        it('does nothing if linestrings already connected', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00001, 0.00001],
+                    [0.00002, 0.00002] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00002, 0.00002],
+                    [0.00003, 0.00003] // ~1.5m apart
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsTwo[1]).toEqual([0.00002, 0.00002]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([0.00002, 0.00002]);
+            expect(coordsThree[1]).toEqual([0.00003, 0.00003]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 4, edgeCount: 3 });
+        });
+
+        it('does not unify any linestrings coordinates if they are not within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00002, 0.00002],
+                    [0.00003, 0.00003] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00004, 0.00004],
+                    [0.00005, 0.00005] // ~1.5m apart
+                ]),
+            ]);
+
+            // Note the reduced radiusMeters
+            const radiusMeters = 1; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00002, 0.00002]);
+            expect(coordsTwo[1]).toEqual([0.00003, 0.00003]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([0.00004, 0.00004]);
+            expect(coordsThree[1]).toEqual([0.00005, 0.00005]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(3);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 6, edgeCount: 3 });
+        });
+
+        it('unifies linestrings coordinates where they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00002, 0.00002],
+                    [0.00003, 0.00003] // ~1.5m apart
+                ]),
+                createLineStringFeature([
+                    [0.00004, 0.00004],
+                    [0.00005, 0.00005] // ~1.5m apart
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsTwo[1]).toEqual([0.00003, 0.00003]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([0.00003, 0.00003]);
+            expect(coordsThree[1]).toEqual([0.00005, 0.00005]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+            expect(graphGetNodeAndEdgeCount(output)).toEqual({ nodeCount: 4, edgeCount: 3 });
+
+        });
+
+        it('unifies closest coordinate of linestrings if they are within tolerance and there are multiple options', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001]
+                ]),
+                createLineStringFeature([
+                    [0.000011, 0.000011],
+                    [0.00003, 0.00003]
+                ]),
+                createLineStringFeature([
+                    [0.000012, 0.000012],
+                    [0.00005, 0.00005]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsTwo[1]).toEqual([0.00003, 0.00003]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([0.00001, 0.00001]);
+            expect(coordsThree[1]).toEqual([0.00005, 0.00005]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+        });
+
+        it('unifies first coordinate where they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [0, 0],
+                    [0.00001, 0.00001]
+                ]),
+                // Going off in a different direction
+                createLineStringFeature([
+                    [0.000001, 0.000001],
+                    [-0.00001, -0.00001]
+                ]),
+                createLineStringFeature([
+                    [0.0000011, 0.0000011],
+                    [-0.00003, -0.00003]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([0, 0]);
+            expect(coords[1]).toEqual([0.00001, 0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+            expect(coordsTwo[0]).toEqual([0, 0]);
+            expect(coordsTwo[1]).toEqual([-0.00001, -0.00001]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([0, 0]);
+            expect(coordsThree[1]).toEqual([-0.00003, -0.00003]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+        });
+
+        it('unifies last coordinate where they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [-3, -3],
+                    [0, 0]
+                ]),
+                createLineStringFeature([
+                    [-1, -1],
+                    [0.000001, 0.000001]
+                ]),
+                createLineStringFeature([
+                    [-2, -2],
+                    [0.0000011, 0.0000011]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(2);
+            expect(coords[0]).toEqual([-3, -3]);
+            expect(coords[1]).toEqual([0, 0]);
+
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(2);
+
+            expect(coordsTwo[0]).toEqual([-1, -1]);
+            expect(coordsTwo[1]).toEqual([0, 0]);
+
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(2);
+            expect(coordsThree[0]).toEqual([-2, -2]);
+            expect(coordsThree[1]).toEqual([0, 0]);
+
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+        });
+
+        it('unifies middle coordinate where they are within tolerance', () => {
+            const input: FeatureCollection<LineString> = createFeatureCollection([
+                createLineStringFeature([
+                    [-1, -1],
+                    [0, 0],
+                    [1, 1]
+                ]),
+                createLineStringFeature([
+                    [-2, -2],
+                    [0.000001, 0.000001],
+                    [2, 2]
+                ]),
+                createLineStringFeature([
+                    [-3, -3],
+                    [0.0000011, 0.0000011],
+                    [3, 3]
+                ]),
+            ]);
+
+            const radiusMeters = 2; // meters
+            const output = unifyCloseCoordinates(input, radiusMeters);
+
+            expect(getReasonIfLineStringInvalid(output.features[0])).toBeUndefined();
+            const coords = output.features[0].geometry.coordinates;
+            expect(coords).toHaveLength(3);
+            expect(coords[0]).toEqual([-1, -1]);
+            expect(coords[1]).toEqual([0, 0]);
+            expect(coords[2]).toEqual([1, 1]);
+
+            expect(getReasonIfLineStringInvalid(output.features[1])).toBeUndefined();
+            const coordsTwo = output.features[1].geometry.coordinates;
+            expect(coordsTwo).toHaveLength(3);
+            expect(coordsTwo[0]).toEqual([-2, -2]);
+            expect(coordsTwo[1]).toEqual([0, 0]);
+            expect(coordsTwo[2]).toEqual([2, 2]);
+
+            expect(getReasonIfLineStringInvalid(output.features[2])).toBeUndefined();
+            const coordsThree = output.features[2].geometry.coordinates;
+            expect(coordsThree).toHaveLength(3);
+            expect(coordsThree[0]).toEqual([-3, -3]);
+            expect(coordsThree[1]).toEqual([0, 0]);
+            expect(coordsThree[2]).toEqual([3, 3]);
+
+            expect(graphGetConnectedComponentCount(output)).toBe(1);
+        });
+    });
+});

package/src/graph/methods/unify.ts

@@ -0,0 +1,132 @@
+import { FeatureCollection, LineString, Position } from 'geojson';
+import { haversineDistance } from '../../distance/haversine';
+import { KDBush } from './spatial-index/kdbush';
+import { around } from './spatial-index/geokdbush';
+
+export function unifyCloseCoordinates(
+    featureCollection: FeatureCollection<LineString>,
+    radiusMeters: number
+): FeatureCollection<LineString> {
+    if (featureCollection.features.length < 2) {
+        return featureCollection; // No features to process
+    }
+
+    const globalSeen: Position[] = [];
+    const globalSeenSet = new Set<string>(); // Fast O(1) lookup for globalSeen
+    const mapping: Map<string, Position> = new Map();
+
+    // Build a one-time spatial index with all coordinates for efficient querying
+    const allCoords: Position[] = [];
+    const coordToGlobalIndex = new Map<string, number>();
+
+    // Collect all unique coordinates first
+    for (const feature of featureCollection.features) {
+        for (const coord of feature.geometry.coordinates) {
+            const key = `${coord[0]},${coord[1]}`; // Faster than join
+            if (!coordToGlobalIndex.has(key)) {
+                coordToGlobalIndex.set(key, allCoords.length);
+                allCoords.push(coord);
+            }
+        }
+    }
+
+    // Build spatial index once for all coordinates
+    let spatialIndex: KDBush = new KDBush(allCoords.length);
+    for (const coord of allCoords) {
+        spatialIndex.add(coord[0], coord[1]); // lng, lat
+    }
+    spatialIndex.finish();
+
+    function findOrRegisterCoordinate(
+        coordinate: Position,
+        exclude: Position[],
+        futureConflictCheck: Set<string>
+    ): Position {
+        let closest: Position | null = null;
+        let closestDistance = Infinity;
+
+        // if (globalSeen.length > 5) {
+        // Use spatial index for efficient querying
+        const radiusKm = radiusMeters / 1000; // Convert meters to kilometers
+        const candidateIndices = around(spatialIndex, coordinate[0], coordinate[1], Infinity, radiusKm);
+
+        for (const candidateIndex of candidateIndices) {
+            const candidateCoord = allCoords[candidateIndex];
+            const candidateKey = `${candidateCoord[0]},${candidateCoord[1]}`;
+
+            // Only consider coordinates that are in globalSeen (O(1) lookup)
+            if (!globalSeenSet.has(candidateKey)) {
+                continue;
+            }
+
+            if (exclude.includes(candidateCoord)) {
+                continue;
+            }
+
+            if (futureConflictCheck.has(candidateKey)) {
+                continue;
+            }
+
+            const distance = haversineDistance(candidateCoord, coordinate) * 1000; // Convert to meters
+
+            if (distance <= radiusMeters && distance < closestDistance) {
+                closest = candidateCoord;
+                closestDistance = distance;
+            }
+        }
+
+
+        if (closest !== null) {
+            return closest;
+        }
+
+        globalSeen.push(coordinate);
+        globalSeenSet.add(`${coordinate[0]},${coordinate[1]}`);
+        return coordinate;
+    }
+
+    const updatedFeatures = featureCollection.features.map((feature) => {
+        const localSeen: Position[] = [];
+        const updatedCoordinates: Position[] = [];
+        const usedKeys = new Set<string>();
+
+        for (const coordinate of feature.geometry.coordinates) {
+            const key = `${coordinate[0]},${coordinate[1]}`;
+
+            if (!mapping.has(key)) {
+                const unified = findOrRegisterCoordinate(coordinate, localSeen, usedKeys);
+                const unifiedKey = `${unified[0]},${unified[1]}`;
+
+                // Avoid inserting a coordinate if it's going to cause duplication later in this feature
+                if (usedKeys.has(unifiedKey)) {
+                    mapping.set(key, coordinate);
+                } else {
+                    mapping.set(key, unified);
+                }
+            }
+
+            const unifiedCoordinate = mapping.get(key)!;
+            const unifiedKey = `${unifiedCoordinate[0]},${unifiedCoordinate[1]}`;
+
+            if (!usedKeys.has(unifiedKey)) {
+                updatedCoordinates.push(unifiedCoordinate);
+                usedKeys.add(unifiedKey);
+            }
+
+            localSeen.push(coordinate);
+        }
+
+        return {
+            ...feature,
+            geometry: {
+                ...feature.geometry,
+                coordinates: updatedCoordinates
+            }
+        };
+    });
+
+    return {
+        ...featureCollection,
+        features: updatedFeatures
+    };
+}

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

@@ -0,0 +1,65 @@
+import { FeatureCollection, LineString } from 'geojson';
+import { readFileSync } from 'fs';
+import { graphGetUniqueSegments } from './unique';
+import { graphGetNodeAndEdgeCount } from './nodes';
+import { createFeatureCollection } from '../../test-utils/create';
+
+describe('graphGetUniqueSegments', () => {
+    it('returns an empty feature collection for empty input', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([]);
+        const output = graphGetUniqueSegments(input);
+        expect(output).toEqual(createFeatureCollection([]));
+    });
+
+    it('returns a single linestring for a single input linestring', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
+        ]);
+        const output = graphGetUniqueSegments(input);
+        expect(output.features.length).toBe(1);
+        expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+    });
+
+    it('returns two linestrings for two unconnected linestrings', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[2, 2], [3, 3]] }, properties: {} }
+        ]);
+        const output = graphGetUniqueSegments(input);
+        expect(output.features.length).toBe(2);
+        expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+        expect(output.features[1].geometry.coordinates).toEqual([[2, 2], [3, 3]]);
+    });
+
+    it('returns two linestrings for two connected linestrings', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[1, 1], [2, 2]] }, properties: {} }
+        ]);
+        const output = graphGetUniqueSegments(input);
+        expect(output.features.length).toBe(2);
+        expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+        expect(output.features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
+    });
+
+    it('returns two linestrings if one is a subsection of the other', () => {
+        const input: FeatureCollection<LineString> = createFeatureCollection([
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
+            { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} }
+        ]);
+        const output = graphGetUniqueSegments(input);
+        expect(output.features.length).toBe(2);
+        expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
+        expect(output.features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
+    });
+
+    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);
+    });
+});