terra-route 0.0.11 → 0.0.13

package/src/graph/methods/duplicates.ts

@@ -1,117 +0,0 @@
-import { FeatureCollection, LineString, Feature, Position } from 'geojson'
-
-/**
- * Are the two coordinate sequences exactly equal (in same order)?
- */
-function areCoordinatesEqual(a: Position[], b: Position[]): boolean {
-    if (a.length !== b.length) {
-        return false
-    }
-
-    for (let i = 0; i < a.length; i++) {
-        if (a[i][0] !== b[i][0] || a[i][1] !== b[i][1]) {
-            return false
-        }
-    }
-
-    return true
-}
-
-/**
- * Is `sub` a contiguous subsequence of `full`, either forward or reversed?
- */
-function isSubsequence(sub: Position[], full: Position[]): boolean {
-    const subLength = sub.length
-    const fullLength = full.length
-
-    if (subLength > fullLength) {
-        return false
-    }
-
-    // check forward
-    for (let start = 0; start <= fullLength - subLength; start++) {
-        let matches = true
-
-        for (let offset = 0; offset < subLength; offset++) {
-            if (
-                full[start + offset][0] !== sub[offset][0] ||
-                full[start + offset][1] !== sub[offset][1]
-            ) {
-                matches = false
-                break
-            }
-        }
-
-        if (matches) {
-            return true
-        }
-    }
-
-    // check reversed
-    const reversedSub = [...sub].reverse()
-
-    for (let start = 0; start <= fullLength - subLength; start++) {
-        let matches = true
-
-        for (let offset = 0; offset < subLength; offset++) {
-            if (
-                full[start + offset][0] !== reversedSub[offset][0] ||
-                full[start + offset][1] !== reversedSub[offset][1]
-            ) {
-                matches = false
-                break
-            }
-        }
-
-        if (matches) {
-            return true
-        }
-    }
-
-    return false
-}
-
-/**
- * Remove any LineString that is either
- *  - an exact duplicate of an earlier one, or
- *  - a contiguous subsequence (in either direction) of any other.
- */
-export function removeDuplicateAndSubsectionLines(
-    collection: FeatureCollection<LineString>
-): FeatureCollection<LineString> {
-    const features = collection.features
-    const toRemove = new Set<number>()
-
-    for (let i = 0; i < features.length; i++) {
-        const coordsI = features[i].geometry.coordinates
-
-        for (let j = 0; j < features.length; j++) {
-            if (i === j) {
-                continue
-            }
-
-            const coordsJ = features[j].geometry.coordinates
-
-            // if coordsI are a subsequence of coordsJ, OR exactly equal,
-            // then mark coordsI for removal—but only if
-            //   • coordsI is strictly shorter than coordsJ, or
-            //   • they’re the same length and this is the later duplicate (i > j)
-            if (
-                isSubsequence(coordsI, coordsJ) &&
-                (
-                    coordsI.length < coordsJ.length ||
-                    (coordsI.length === coordsJ.length && i > j)
-                )
-            ) {
-                toRemove.add(i)
-                break
-            }
-        }
-    }
-
-    const filtered = features.filter((_, index) => !toRemove.has(index))
-    return {
-        type: 'FeatureCollection',
-        features: filtered
-    }
-}

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

@@ -1,224 +0,0 @@
-import { FeatureCollection, LineString } from 'geojson';
-import { createFeatureCollection } from '../../test-utils/create';
-import { getLeafEdges } from './leaf';
-
-describe('getLeafEdges', () => {
-
-    describe('leafEdges', () => {
-        describe('for an empty feature collection', () => {
-            it('returns 0 nodes and edges', () => {
-                const input: FeatureCollection<LineString> = createFeatureCollection([]);
-                const output = getLeafEdges(input).leafEdges
-
-                expect(output).toEqual(createFeatureCollection([]));
-            });
-        });
-
-        describe('for feature collection with 1 linestring', () => {
-            it('returns the single linestring as a leaf edge', () => {
-                const input: FeatureCollection<LineString> = createFeatureCollection([
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-
-                expect(output.features.length).toBe(1);
-                expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-            });
-
-            it('returns the two linestring as as leaf edge for long linestring', () => {
-                const input: FeatureCollection<LineString> = createFeatureCollection([
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1], [2, 2]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-
-                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]]);
-            });
-        });
-
-        describe('for feature collection with 2 linestrings', () => {
-            it('returns both linestrings if they are unconnected leaf edges', () => {
-                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 = getLeafEdges(input).leafEdges
-                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 both linestrings if they are connected leaf edges', () => {
-                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 = getLeafEdges(input).leafEdges
-                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 but they are both leaf edges', () => {
-                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 = getLeafEdges(input).leafEdges
-                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('handles duplicates', () => {
-                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]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-                expect(output.features.length).toBe(1);
-            });
-        });
-
-        describe('for feature collection with 3 linestrings', () => {
-            it('returns 3 leafs when all are disconnected', () => {
-                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: {} },
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[4, 4], [5, 5]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-                expect(output.features.length).toBe(3);
-            });
-
-            it('returns 3 leafs when all three linestrings are connected by a shared central point', () => {
-                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: {} },
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[1, 1], [3, 3]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-                expect(output.features.length).toBe(3);
-                expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-                expect(output.features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
-                expect(output.features[2].geometry.coordinates).toEqual([[1, 1], [3, 3]]);
-            });
-
-            it('returns 3 leafs when two are connected and one is disconnected', () => {
-                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: {} },
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-                expect(output.features.length).toBe(3);
-                expect(output.features[0].geometry.coordinates).toEqual([[0, 0], [1, 1]]);
-                expect(output.features[1].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
-                expect(output.features[2].geometry.coordinates).toEqual([[3, 3], [4, 4]]);
-            });
-
-            it('returns 3 leafs when one linestring is a subsection of another and 3rd is disconnected', () => {
-                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: {} },
-                    { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4]] }, properties: {} }
-                ]);
-                const output = getLeafEdges(input).leafEdges
-                expect(output.features.length).toBe(3);
-            });
-        });
-    });
-
-    describe('nonLeafEdges', () => {
-        it('returns an empty feature collection for empty input', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output).toEqual(createFeatureCollection([]));
-        });
-
-        it('returns no linestrings for a single input linestring as it would be a leaf edge', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} }
-            ]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns no linestrings for two unconnected linestrings as they would be leaf edges', () => {
-            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 = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns no linestrings for two connected linestrings as they would be leaf edges', () => {
-            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 = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns no linestrings if one is a subsection of the other as they would be leaf edges', () => {
-            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 = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns no linestrings for two linestrings that are duplicates', () => {
-            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]] }, properties: {} }
-            ]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns no linestrings for two linestrings that are inverse duplicates', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[0, 0], [1, 1]] }, properties: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[1, 1], [0, 0]] }, properties: {} }
-            ]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns a no linestring for three linestrings where two are connected and one is disconnected', () => {
-            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: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[3, 3], [4, 4]] }, properties: {} }
-            ]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(0);
-        });
-
-        it('returns a linestring for three linestrings when one is a middle edge and the other two are leaf edges', () => {
-            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: {} },
-                { type: 'Feature', geometry: { type: 'LineString', coordinates: [[2, 2], [3, 3]] }, properties: {} }
-            ]);
-            const output = getLeafEdges(input).nonLeafEdges;
-
-            expect(output.features.length).toBe(1);
-            expect(output.features[0].geometry.coordinates).toEqual([[1, 1], [2, 2]]);
-        });
-    })
-});
-

package/src/graph/methods/leaf.ts

@@ -1,88 +0,0 @@
-import { FeatureCollection, LineString, Feature } from 'geojson';
-import { graphGetUniqueSegments } from './unique';
-
-/**
- * Separates a graph's edges into leaf and non-leaf edges.
- * A leaf edge has a start or end node with degree 1.
- *
- * @param edgesFc - FeatureCollection containing LineString features representing edges of a graph
- * @returns Object containing two FeatureCollections: leafEdges and nonLeafEdges
- */
-export function getLeafEdges(
-    edgesFc: FeatureCollection<LineString>
-): {
-    leafEdges: FeatureCollection<LineString>;
-    nonLeafEdges: FeatureCollection<LineString>;
-} {
-    const edges = graphGetUniqueSegments(edgesFc);
-
-    const endpointCountMap: Map<string, number> = new Map();
-
-    function coordKey(position: number[]): string {
-        return position.join(",");
-    }
-
-    // Count the degree (number of edge endpoints) for each coordinate
-    for (let i = 0; i < edges.features.length; i++) {
-        const feature = edges.features[i];
-        const coordinates = feature.geometry.coordinates;
-
-        if (coordinates.length < 2) {
-            continue;
-        }
-
-        const startKey = coordKey(coordinates[0]);
-        const endKey = coordKey(coordinates[coordinates.length - 1]);
-
-        endpointCountMap.set(
-            startKey,
-            (endpointCountMap.get(startKey) || 0) + 1
-        );
-        endpointCountMap.set(
-            endKey,
-            (endpointCountMap.get(endKey) || 0) + 1
-        );
-    }
-
-    const leafEdgeMap: Map<string, Feature<LineString>> = new Map();
-    const nonLeafEdgeMap: Map<string, Feature<LineString>> = new Map();
-
-    for (let i = 0; i < edges.features.length; i++) {
-        const feature = edges.features[i];
-        const coordinates = feature.geometry.coordinates;
-
-        if (coordinates.length < 2) {
-            continue;
-        }
-
-        const startKey = coordKey(coordinates[0]);
-        const endKey = coordKey(coordinates[coordinates.length - 1]);
-
-        const startCount = endpointCountMap.get(startKey) || 0;
-        const endCount = endpointCountMap.get(endKey) || 0;
-
-        const edgeKey = coordinates.map(coordKey).join(";");
-
-        if (startCount === 1 || endCount === 1) {
-            if (!leafEdgeMap.has(edgeKey)) {
-                leafEdgeMap.set(edgeKey, feature);
-            }
-        } else {
-            if (!nonLeafEdgeMap.has(edgeKey)) {
-                nonLeafEdgeMap.set(edgeKey, feature);
-            }
-        }
-    }
-
-    return {
-        leafEdges: {
-            type: "FeatureCollection",
-            features: Array.from(leafEdgeMap.values())
-        },
-        nonLeafEdges: {
-            type: "FeatureCollection",
-            features: Array.from(nonLeafEdgeMap.values())
-        }
-    };
-}
-