terra-route 0.0.11 → 0.0.13

package/src/graph/graph.spec.ts

@@ -1,238 +0,0 @@
-import { LineStringGraph } from "./graph";
-import { FeatureCollection, LineString } from "geojson";
-import { readFileSync } from "fs";
-import { createLineStringFeature, createFeatureCollection } from "../test-utils/create";
-import { BoundingBox } from "./methods/bounding-box";
-
-describe("LineStringGraph", () => {
-    it("should create a graph from a GeoJSON network", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        expect(graph.getNetwork()).toEqual(network);
-    });
-
-    it("should return connected components", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const components = graph.getConnectedComponents();
-        expect(components.length).toBe(1);
-    });
-
-    it("should return the count of connected components", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const count = graph.getConnectedComponentCount();
-        expect(count).toBe(1);
-    });
-
-    it("should return node and edge counts", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const counts = graph.getNodeAndEdgeCount();
-        expect(counts.nodeCount).toBe(2598);
-        expect(counts.edgeCount).toBe(2839);
-    });
-
-    it("should return nodes as Point features", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const nodes = graph.getNodes();
-        expect(nodes.features.length).toBe(2598);
-    });
-
-    it("should return the count of unique nodes", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const count = graph.getNodeCount();
-        expect(count).toBe(2598);
-    });
-
-    it("should return edges as LineString features", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const edges = graph.getEdges();
-        expect(edges.features.length).toBe(2839);
-    });
-
-    it("should return the count of unique edges", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const count = graph.getEdgeCount();
-        expect(count).toBe(2839);
-    });
-
-    it("should return the shortest edge between two nodes", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const edge = graph.getShortestEdge();
-        expect(edge).toEqual({
-            "type": "Feature",
-            "geometry": {
-                "type": "LineString",
-                "coordinates": [
-                    [
-                        -0.0837395,
-                        51.5394794,
-                    ],
-                    [
-                        -0.083739,
-                        51.5394744,
-                    ],
-                ],
-            },
-            "properties": {},
-        })
-    })
-
-    it("should return the longest edge between two nodes", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const edge = graph.getLongestEdge();
-        expect(edge).toEqual({
-            "type": "Feature",
-            "geometry": {
-                "type": "LineString",
-                "coordinates": [
-                    [
-                        -0.0755711,
-                        51.5394099,
-                    ],
-                    [
-                        -0.0753028,
-                        51.5423462,
-                    ],
-                ],
-            },
-            "properties": {},
-        })
-    });
-
-    it("should return the length of the longest edge", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const length = graph.getLongestEdgeLength();
-        expect(length).toBeCloseTo(0.3270284866264399, 1);
-    });
-
-    it("should return the length of the shortest edge", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const length = graph.getShortestEdgeLength();
-        expect(length).toBeCloseTo(0.0004570489974749478);
-    });
-
-    it("should set the network", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const newNetwork = JSON.parse(readFileSync('src/data/network-5-cc.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        graph.setNetwork(newNetwork);
-    });
-
-    it('should get network without duplicates or subsections', () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const uniqueNetwork = graph.getNetworkWithoutDuplicatesOrSubsections();
-        expect(uniqueNetwork.features.length).toBe(network.features.length);
-    });
-
-    it("should return leaf edges and pruned edges", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-        const leafEdges = graph.getLeafEdges();
-        const nonLeafEdges = graph.getPrunedEdges();
-        const edgesCount = graph.getEdgeCount();
-        expect(leafEdges.features.length).toBe(243);
-        expect(nonLeafEdges.features.length).toBe(edgesCount - leafEdges.features.length);
-    });
-
-    it("should progressively strips leaf nodes", () => {
-        const network = JSON.parse(readFileSync('src/data/network.geojson', 'utf-8')) as FeatureCollection<LineString>;
-        const graph = new LineStringGraph(network);
-
-        const graphAfterFirstPrune = graph.getPrunedEdges(1);
-        const graphAfterSecondPrune = graph.getPrunedEdges(2);
-        expect(graphAfterSecondPrune.features.length).toBeLessThan(graphAfterFirstPrune.features.length);
-
-        const graphAfterThirdPrune = graph.getPrunedEdges(3);
-        expect(graphAfterThirdPrune.features.length).toBeLessThan(graphAfterSecondPrune.features.length);
-    });
-
-    describe('getNetworkInBoundingBox', () => {
-        it('filters network LineStrings based on bounding box', () => {
-            const insideLine = createLineStringFeature([[1, 1], [2, 2]]);
-            const outsideLine = createLineStringFeature([[15, 15], [20, 20]]);
-
-            const network = createFeatureCollection([insideLine, outsideLine]);
-            const graph = new LineStringGraph(network);
-
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const filteredNetwork = graph.getNetworkInBoundingBox(boundingBox);
-
-            expect(filteredNetwork.features).toHaveLength(1);
-            expect(filteredNetwork.features[0]).toEqual(insideLine);
-        });
-
-        it('returns empty collection when no LineStrings are within bounds', () => {
-            const outsideLine1 = createLineStringFeature([[15, 15], [20, 20]]);
-            const outsideLine2 = createLineStringFeature([[25, 25], [30, 30]]);
-
-            const network = createFeatureCollection([outsideLine1, outsideLine2]);
-            const graph = new LineStringGraph(network);
-
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const filteredNetwork = graph.getNetworkInBoundingBox(boundingBox);
-
-            expect(filteredNetwork.features).toHaveLength(0);
-        });
-
-        it('does not modify the original network', () => {
-            const originalLine = createLineStringFeature([[1, 1], [2, 2]]);
-            const network = createFeatureCollection([originalLine]);
-            const graph = new LineStringGraph(network);
-
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const filteredNetwork = graph.getNetworkInBoundingBox(boundingBox);
-
-            // Original network should remain unchanged
-            expect(graph.getNetwork().features).toHaveLength(1);
-            expect(filteredNetwork.features).toHaveLength(1);
-
-            // Modifying filtered result shouldn't affect original
-            filteredNetwork.features.pop();
-            expect(graph.getNetwork().features).toHaveLength(1);
-        });
-    });
-
-    describe('getUnifiedNetwork', () => {
-        it('returns the unified network', () => {
-            const insideLine = createLineStringFeature([[1, 1], [2, 2]]);
-            const outsideLine = createLineStringFeature([[1.000001, 1.000001], [20, 20]]);
-
-            const network = createFeatureCollection([insideLine, outsideLine]);
-            const graph = new LineStringGraph(network);
-
-            const filteredNetwork = graph.getUnifiedNetwork(0.5);
-
-            expect(filteredNetwork.features).toHaveLength(2);
-            expect(filteredNetwork.features).toEqual([
-                {
-                    "geometry": {
-                        "coordinates": [[1, 1], [2, 2]],
-                        "type": "LineString"
-                    },
-                    "properties": {},
-                    "type": "Feature"
-                },
-                {
-                    "geometry": {
-                        "coordinates": [[1, 1], [20, 20]],
-                        "type": "LineString"
-                    },
-                    "properties": {},
-                    "type": "Feature"
-                }
-            ]);
-        });
-    });
-
-});

package/src/graph/graph.ts

@@ -1,212 +0,0 @@
-import { Feature, FeatureCollection, LineString, Point } from "geojson";
-import { graphGetConnectedComponentCount, graphGetConnectedComponents } from "./methods/connected";
-import { graphGetNodeAndEdgeCount, graphGetNodesAsPoints } from "./methods/nodes";
-import { graphGetUniqueSegments } from "./methods/unique";
-import { routeLength } from "../test-utils/utils";
-import { removeDuplicateAndSubsectionLines } from "./methods/duplicates";
-import { getLeafEdges } from "./methods/leaf";
-import { getNetworkInBoundingBox, BoundingBox } from "./methods/bounding-box";
-import { unifyCloseCoordinates } from "./methods/unify";
-
-/**
- * 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 a filtered network containing only LineStrings that are completely within the specified bounding box.
-     * @param boundingBox A bounding box array in the format [minLng, minLat, maxLng, maxLat]
-     * @returns A GeoJSON FeatureCollection of LineString features representing the network filtered by the bounding box.
-     */
-    getNetworkInBoundingBox(boundingBox: BoundingBox): FeatureCollection<LineString> {
-        return getNetworkInBoundingBox(this.network, boundingBox);
-    }
-
-    /**
-     * Gets the network without duplicate or subsection lines. 
-     * This method processes the network to remove any duplicate lines or lines that are subsections of other lines.
-     * @returns A FeatureCollection<LineString> representing the network without duplicate or subsection lines.
-     */
-    getNetworkWithoutDuplicatesOrSubsections() {
-        return removeDuplicateAndSubsectionLines(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;
-    }
-
-    /**
-     * Gets the leaf edges of the graph. A leaf edge is defined as an edge whose start or end node has a degree of 1.
-     * Here an edge is defined as a LineString with two coordinates, representing the start and end points.
-     * @returns A FeatureCollection<LineString> containing only the leaf edges of the graph.
-     */
-    getLeafEdges(): FeatureCollection<LineString> {
-        return getLeafEdges(this.network).leafEdges;
-    }
-
-    /**
-     * Returns the pruned network, which is the network without the leaf edges.
-     * i.e. This method removes all leaf edges from the network, leaving only the non-leaf edges
-     * @return A FeatureCollection<LineString> representing the pruned network without leaf edges.
-     */
-    getPrunedEdges(depth?: number): FeatureCollection<LineString> {
-        if (depth && depth > 0) {
-
-            let currentEdges = this.network;
-
-            for (let i = 0; i < depth; i++) {
-                const leafEdges = getLeafEdges(currentEdges);
-                currentEdges = leafEdges.nonLeafEdges;
-            }
-
-            return currentEdges;
-
-        }
-        return getLeafEdges(this.network).nonLeafEdges;
-    }
-
-    /**
-     * Returns the network where all nodes that are with n meters of each other are unified. 
-     * The function will avoid unifying coordinates in the same linestring.
-     * @param toleranceMeters the tolerance for unifying nodes in meters. 
-     */
-    getUnifiedNetwork(toleranceMeters: number) {
-        return unifyCloseCoordinates(this.network, toleranceMeters);
-    }
-}

package/src/graph/methods/bounding-box.spec.ts

@@ -1,199 +0,0 @@
-import { FeatureCollection, LineString } from 'geojson';
-import { getNetworkInBoundingBox, BoundingBox } from './bounding-box';
-import { createFeatureCollection, createLineStringFeature } from '../../test-utils/create';
-
-describe('getNetworkInBoundingBox', () => {
-    describe('with an empty feature collection', () => {
-        it('returns an empty feature collection', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: []
-            });
-        });
-    });
-
-    describe('with a single LineString completely within bounds', () => {
-        it('returns the LineString', () => {
-            const lineString = createLineStringFeature([[1, 1], [2, 2], [3, 3]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [lineString]
-            });
-        });
-    });
-
-    describe('with a single LineString partially outside bounds', () => {
-        it('excludes the LineString', () => {
-            const lineString = createLineStringFeature([[1, 1], [2, 2], [15, 15]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: []
-            });
-        });
-    });
-
-    describe('with a single LineString completely outside bounds', () => {
-        it('excludes the LineString', () => {
-            const lineString = createLineStringFeature([[20, 20], [25, 25], [30, 30]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: []
-            });
-        });
-    });
-
-    describe('with multiple LineStrings', () => {
-        it('returns only those completely within bounds', () => {
-            const insideLine1 = createLineStringFeature([[1, 1], [2, 2]]);
-            const insideLine2 = createLineStringFeature([[5, 5], [6, 6], [7, 7]]);
-            const partiallyOutside = createLineStringFeature([[8, 8], [12, 12]]);
-            const completelyOutside = createLineStringFeature([[20, 20], [25, 25]]);
-
-            const input: FeatureCollection<LineString> = createFeatureCollection([
-                insideLine1,
-                insideLine2,
-                partiallyOutside,
-                completelyOutside
-            ]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [insideLine1, insideLine2]
-            });
-        });
-    });
-
-    describe('with LineStrings on the boundary', () => {
-        it('includes LineStrings with coordinates exactly on the boundary', () => {
-            const onBoundary = createLineStringFeature([[0, 0], [10, 10]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([onBoundary]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [onBoundary]
-            });
-        });
-
-        it('excludes LineStrings with any coordinate outside the boundary', () => {
-            const slightlyOutside = createLineStringFeature([[0, 0], [10.001, 10]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([slightlyOutside]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: []
-            });
-        });
-    });
-
-    describe('with negative coordinates', () => {
-        it('handles negative bounding box coordinates correctly', () => {
-            const lineString = createLineStringFeature([[-5, -5], [-2, -2], [-1, -1]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [-10, -10, 0, 0];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [lineString]
-            });
-        });
-    });
-
-    describe('with cross-meridian bounding box (longitude crossing 180°)', () => {
-        it('handles coordinates correctly when bounding box crosses the antimeridian', () => {
-            // Note: This test assumes the simple implementation doesn't handle cross-meridian cases
-            // In a real-world scenario, you might need special handling for this
-            const lineString = createLineStringFeature([[170, 10], [175, 15]]);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [160, 0, 180, 20];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [lineString]
-            });
-        });
-    });
-
-    describe('input validation', () => {
-        it('throws an error for invalid bounding box (minLng >= maxLng)', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const invalidBoundingBox: BoundingBox = [10, 0, 5, 10]; // minLng > maxLng
-
-            expect(() => {
-                getNetworkInBoundingBox(input, invalidBoundingBox);
-            }).toThrow('Invalid bounding box: min values must be less than max values');
-        });
-
-        it('throws an error for invalid bounding box (minLat >= maxLat)', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const invalidBoundingBox: BoundingBox = [0, 10, 10, 5]; // minLat > maxLat
-
-            expect(() => {
-                getNetworkInBoundingBox(input, invalidBoundingBox);
-            }).toThrow('Invalid bounding box: min values must be less than max values');
-        });
-
-        it('throws an error for invalid bounding box (equal min and max)', () => {
-            const input: FeatureCollection<LineString> = createFeatureCollection([]);
-            const invalidBoundingBox: BoundingBox = [0, 0, 0, 0]; // minLng === maxLng
-
-            expect(() => {
-                getNetworkInBoundingBox(input, invalidBoundingBox);
-            }).toThrow('Invalid bounding box: min values must be less than max values');
-        });
-    });
-
-    describe('with complex LineStrings', () => {
-        it('handles LineStrings with many coordinates', () => {
-            const manyCoords = [];
-            for (let i = 1; i <= 100; i++) {
-                manyCoords.push([i * 0.1, i * 0.1]);
-            }
-            const complexLineString = createLineStringFeature(manyCoords);
-            const input: FeatureCollection<LineString> = createFeatureCollection([complexLineString]);
-            const boundingBox: BoundingBox = [0, 0, 20, 20];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: [complexLineString]
-            });
-        });
-
-        it('excludes LineStrings when even one coordinate is outside', () => {
-            const coords = [[1, 1], [2, 2], [3, 3], [4, 4], [15, 15]]; // last coordinate outside
-            const lineString = createLineStringFeature(coords);
-            const input: FeatureCollection<LineString> = createFeatureCollection([lineString]);
-            const boundingBox: BoundingBox = [0, 0, 10, 10];
-            const output = getNetworkInBoundingBox(input, boundingBox);
-
-            expect(output).toEqual({
-                type: 'FeatureCollection',
-                features: []
-            });
-        });
-    });
-});