@wemap/geo 4.0.13 → 5.0.0

package/src/graph/GraphNode.spec.js

@@ -0,0 +1,203 @@
+/* eslint-disable no-new */
+import chai from 'chai';
+
+import Logger from '@wemap/logger';
+
+import Coordinates from '../coordinates/Coordinates.js';
+import Level from '../coordinates/Level.js';
+
+import GraphNode from './GraphNode.js';
+import GraphEdge from './GraphEdge.js';
+
+Logger.enable(false);
+
+const { expect } = chai;
+
+describe('GraphNode', () => {
+
+    it('creation', () => {
+
+        expect(() => new GraphNode()).throw(Error);
+        expect(() => new GraphNode({
+            lat: 45,
+            lng: 5
+        })).throw(Error);
+        expect(() => new GraphNode(new Coordinates(0, 0))).not.throw(Error);
+        expect(() => new GraphNode(new Coordinates(0, 0), 'foo')).not.throw(Error);
+
+    });
+
+
+    const pos1 = new Coordinates(45, 5);
+    const pos2 = new Coordinates(46, 5);
+    const node1 = new GraphNode(pos1);
+    const node2 = new GraphNode(pos2);
+
+    it('distanceTo', () => {
+        expect(node1.distanceTo(node2)).equals(pos1.distanceTo(pos2));
+    });
+
+    it('bearingTo', () => {
+        expect(node1.bearingTo(node2)).equals(pos1.bearingTo(pos2));
+    });
+
+    it('equalsTo', () => {
+        expect(node1.equalsTo(node2)).false;
+        expect(node1.equalsTo(node1)).true;
+        expect(new GraphNode(pos1).equalsTo(node1)).true;
+    });
+
+    it('clone', () => {
+
+        const node = new GraphNode(pos1);
+
+        const nodeBis = node.clone();
+        expect(nodeBis.coords).equals(node.coords);
+        nodeBis.edges.forEach((val, idx) => expect(val).equals(node.edges[idx]));
+        expect(nodeBis.builtFrom).equals(node.builtFrom);
+
+    });
+
+    it('toJson / fromJson', () => {
+
+        const node = new GraphNode(pos1);
+
+        const jsonNode = node.toJson();
+        expect(jsonNode).deep.equals([45, 5]);
+
+        const nodeBis = GraphNode.fromJson(jsonNode);
+        expect(nodeBis.coords.equalsTo(node.coords)).true;
+    });
+
+    // eslint-disable-next-line max-statements
+    it('generateNodesLevels', () => {
+
+        const cleanNodes = count => [...Array(count)].map((_ignore, idx) => new GraphNode(new Coordinates(0, 0), 'n' + idx));
+        const cleanNodesWithAdjEdges = (...levelEdges) => {
+            const _nodes = cleanNodes(levelEdges.length + 1);
+            levelEdges.forEach((level, idx) => new GraphEdge(_nodes[0], _nodes[idx + 1], level));
+            return _nodes;
+        };
+
+        let nodes;
+
+        /**
+         * Simple case with only adjacent nodes
+         */
+
+        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(0));
+        expect(GraphNode.generateNodesLevels(nodes)).false;
+        expect(nodes[0].coords.level).is.null;
+
+        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(1));
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+
+        nodes = cleanNodesWithAdjEdges(new Level(1), new Level(1, 2));
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+
+        nodes = cleanNodesWithAdjEdges(new Level(0, 1), new Level(1, 2));
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+
+        nodes = cleanNodesWithAdjEdges(new Level(0, 1));
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(0, 1))).true;
+
+        /**
+         * More complex cases with no adjacent edges
+         */
+
+        nodes = cleanNodes(4);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(1, 2), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(1, 2), 'e2');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(1, 2))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(2))).true;
+
+
+        nodes = cleanNodes(5);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(1, 2), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(1, 2), 'e2');
+        new GraphEdge(nodes[2], nodes[4], null, 'e3');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+
+
+        nodes = cleanNodes(4);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(0, 1), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(0, 1), 'e2');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(0, 1))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(0))).true;
+
+
+        nodes = cleanNodes(4);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(1, 2), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(1, 2), 'e2');
+        new GraphEdge(nodes[1], nodes[3], new Level(1), 'e3');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(2))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
+
+
+        nodes = cleanNodes(4);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(0, 1), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(0, 1), 'e2');
+        new GraphEdge(nodes[1], nodes[3], new Level(1), 'e3');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(0))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
+
+
+        nodes = cleanNodes(6);
+        new GraphEdge(nodes[0], nodes[1], new Level(1), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(1, 2), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(1, 2), 'e2');
+        new GraphEdge(nodes[2], nodes[4], new Level(1, 2), 'e3');
+        new GraphEdge(nodes[4], nodes[5], new Level(2), 'e4');
+        expect(GraphNode.generateNodesLevels(nodes)).false;
+
+
+        nodes = cleanNodes(5);
+        new GraphEdge(nodes[0], nodes[1], new Level(1, 2));
+        new GraphEdge(nodes[1], nodes[2], new Level(1, 2));
+        new GraphEdge(nodes[2], nodes[3], new Level(1, 2));
+        new GraphEdge(nodes[3], nodes[4], new Level(1));
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[0].coords.level, new Level(2))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(1, 2))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(1, 2))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[4].coords.level, new Level(1))).true;
+
+
+        nodes = cleanNodes(6);
+        new GraphEdge(nodes[0], nodes[1], new Level(0), 'e0');
+        new GraphEdge(nodes[1], nodes[2], new Level(0, 1), 'e1');
+        new GraphEdge(nodes[2], nodes[3], new Level(0, 1), 'e2');
+        new GraphEdge(nodes[3], nodes[4], new Level(0, 1), 'e3');
+        new GraphEdge(nodes[4], nodes[5], new Level(1), 'e4');
+        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(0))).true;
+        expect(Level.equalsTo(nodes[1].coords.level, new Level(0))).true;
+        expect(Level.equalsTo(nodes[2].coords.level, new Level(0, 1))).true;
+        expect(Level.equalsTo(nodes[3].coords.level, new Level(0, 1))).true;
+        expect(Level.equalsTo(nodes[4].coords.level, new Level(1))).true;
+        expect(Level.equalsTo(nodes[5].coords.level, new Level(1))).true;
+    });
+
+});

package/src/graph/{Projection.js → GraphProjection.js}

@@ -1,8 +1,8 @@
 import Coordinates from '../coordinates/Coordinates.js';
-import Edge from './Edge.js';
-import Node from './Node.js';
+import Edge from './GraphEdge.js';
+import Node from './GraphNode.js';
 
-class Projection {
+class GraphProjection {
 
     /** @type {Coordinates} */
     origin;
@@ -18,4 +18,4 @@ class Projection {
 
 }
 
-export default Projection;
+export default GraphProjection;

package/src/graph/GraphUtils.js

@@ -0,0 +1,17 @@
+
+import GraphEdge from './GraphEdge.js';
+import GraphNode from './GraphNode.js';
+
+/**
+ * @template T
+ * @param {GraphEdge<T>[]} edges
+ * @param {GraphNode<T>} node1
+ * @param {GraphNode<T>} node2
+ * @returns {?GraphEdge<T>}
+ */
+export function getEdgeByNodes(edges, node1, node2) {
+    return edges.find(edge =>
+        node1 === edge.node1 && node2 === edge.node2
+        || node2 === edge.node1 && node1 === edge.node2
+    );
+}

package/src/graph/MapMatching.js

@@ -4,10 +4,11 @@ import { diffAngleLines } from '@wemap/maths';
 
 import Constants from '../Constants.js';
 import Coordinates from '../coordinates/Coordinates.js';
+import UserPosition from '../coordinates/UserPosition.js';
 import Level from '../coordinates/Level.js';
 
 import Network from './Network.js';
-import Projection from './Projection.js';
+import GraphProjection from './GraphProjection.js';
 
 class MapMatching {
 
@@ -146,7 +147,7 @@ class MapMatching {
      * @param {boolean} useBearing
      * @param {boolean} useMultiLevelSegments
      * @param {function} acceptEdgeFn
-     * @returns {Projection}
+     * @returns {GraphProjection}
      */
     getProjection(location, useDistance = false, useBearing = false,
         useMultiLevelSegments = true, acceptEdgeFn = () => true) {
@@ -163,7 +164,7 @@ class MapMatching {
             return null;
         }
 
-        const projection = new Projection();
+        const projection = new GraphProjection();
         projection.origin = location;
         projection.distanceFromNearestElement = Number.MAX_VALUE;
         projection.projection = location.clone();
@@ -231,8 +232,9 @@ class MapMatching {
             return null;
         }
 
-        projection.projection.accuracy += projection.distanceFromNearestElement;
-
+        if (projection.projection instanceof UserPosition) {
+            projection.projection.accuracy += projection.distanceFromNearestElement;
+        }
         return projection;
     }
 

package/src/graph/MapMatching.spec.js

@@ -8,10 +8,10 @@ import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
 import UserPosition from '../coordinates/UserPosition.js';
 
-import Edge from './Edge.js';
+import GraphEdge from './GraphEdge.js';
+import GraphNode from './GraphNode.js';
 import MapMatching from './MapMatching.js';
 import Network from './Network.js';
-import Node from './Node.js';
 
 import { network } from '../../tests/CommonTest.js';
 
@@ -20,14 +20,14 @@ const { expect } = chai;
 describe('MapMatching', () => {
 
     const nodes = [
-        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
-        new Node(new Coordinates(43.6093629, 3.8842777), 'p1'),
-        new Node(new Coordinates(43.6092785, 3.8845052), 'p2')
+        new GraphNode(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new GraphNode(new Coordinates(43.6093629, 3.8842777), 'p1'),
+        new GraphNode(new Coordinates(43.6092785, 3.8845052), 'p2')
     ];
 
     const edges = [
-        new Edge(nodes[0], nodes[1], null, 'e0'),
-        new Edge(nodes[1], nodes[2], null, 'e1')
+        new GraphEdge(nodes[0], nodes[1], null, 'e0'),
+        new GraphEdge(nodes[1], nodes[2], null, 'e1')
     ];
 
     let mapMatching;
@@ -70,17 +70,17 @@ describe('MapMatching', () => {
 
         result = mapMatching.getProjection(location);
         expect(result).is.not.null;
-        expect(result.nearestElement).instanceOf(Edge);
-        expect(result.nearestElement.name).equal('e0');
+        expect(result.nearestElement).instanceOf(GraphEdge);
+        expect(result.nearestElement.builtFrom).equal('e0');
         expect(result.projection.distanceTo(expected)).to.below(Constants.EPS_MM);
         expect(Level.equalsTo(expected.level, result.projection.level)).true;
 
         const owNodes = [
-            new Node(new Coordinates(43.6091194, 3.884099, 5)),
-            new Node(new Coordinates(43.6093629, 3.8842777, 10))
+            new GraphNode(new Coordinates(43.6091194, 3.884099, 5)),
+            new GraphNode(new Coordinates(43.6093629, 3.8842777, 10))
         ];
         const owNetwork = new Network(owNodes, [
-            new Edge(owNodes[0], owNodes[1])
+            new GraphEdge(owNodes[0], owNodes[1])
         ]);
         const owMapMatching = new MapMatching(owNetwork);
         result = owMapMatching.getProjection(new Coordinates(43.6092086, 3.8842598, 10));
@@ -95,8 +95,8 @@ describe('MapMatching', () => {
         location.bearing = deg2rad(101.9);
         result = mapMatching.getProjection(location, true, true);
         expect(result).is.not.null;
-        expect(result.nearestElement).instanceOf(Edge);
-        expect(result.nearestElement.name).equal('e1');
+        expect(result.nearestElement).instanceOf(GraphEdge);
+        expect(result.nearestElement.builtFrom).equal('e1');
         expect(result.projection.distanceTo(expected)).to.below(Constants.EPS_MM);
         expect(Level.equalsTo(expected.level, result.projection.level)).true;
     });
@@ -107,24 +107,24 @@ describe('MapMatching', () => {
 
         pointToTest = nodes[0].coords.destinationPoint(0.0001, nodes[0].bearingTo(nodes[1]));
         result = mapMatching.getProjection(pointToTest);
-        expect(result.nearestElement).instanceOf(Node);
-        expect(result.nearestElement.name).equal('p0');
+        expect(result.nearestElement).instanceOf(GraphNode);
+        expect(result.nearestElement.builtFrom).equal('p0');
 
         pointToTest = nodes[1].coords.destinationPoint(0.0001, nodes[1].bearingTo(nodes[0]));
         result = mapMatching.getProjection(pointToTest);
-        expect(result.nearestElement).instanceOf(Node);
-        expect(result.nearestElement.name).equal('p1');
+        expect(result.nearestElement).instanceOf(GraphNode);
+        expect(result.nearestElement.builtFrom).equal('p1');
 
         pointToTest = nodes[0].coords.destinationPoint(0.005, nodes[0].bearingTo(nodes[1]));
         result = mapMatching.getProjection(pointToTest);
-        expect(result.nearestElement).instanceOf(Edge);
-        expect(result.nearestElement.name).equal('e0');
+        expect(result.nearestElement).instanceOf(GraphEdge);
+        expect(result.nearestElement.builtFrom).equal('e0');
         expect(result.projection.distanceTo(pointToTest)).to.below(Constants.EPS_MM);
 
         pointToTest = nodes[1].coords.destinationPoint(0.005, nodes[1].bearingTo(nodes[0]));
         result = mapMatching.getProjection(pointToTest);
-        expect(result.nearestElement).instanceOf(Edge);
-        expect(result.nearestElement.name).equal('e0');
+        expect(result.nearestElement).instanceOf(GraphEdge);
+        expect(result.nearestElement.builtFrom).equal('e0');
         expect(result.projection.distanceTo(pointToTest)).to.below(Constants.EPS_MM);
 
     });
@@ -243,12 +243,12 @@ describe('MapMatching - multilevels', () => {
         currentPosition = new Coordinates(43.6093381, 3.8841926, null, new Level(1));
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
-        expect(projection.nearestElement.name).equals('p14');
+        expect(projection.nearestElement.builtFrom).equals('p14');
 
         currentPosition = new Coordinates(43.6093381, 3.8841926, null, new Level(2));
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
-        expect(projection.nearestElement.name).equals('p11');
+        expect(projection.nearestElement.builtFrom).equals('p11');
 
 
         // On Segments
@@ -260,12 +260,12 @@ describe('MapMatching - multilevels', () => {
         currentPosition = new Coordinates(43.6093258, 3.8842272, null, new Level(1));
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
-        expect(projection.nearestElement.name).equals('e14');
+        expect(projection.nearestElement.builtFrom).equals('e14');
 
         currentPosition = new Coordinates(43.6093258, 3.8842272, null, new Level(2));
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
-        expect(projection.nearestElement.name).equals('e10');
+        expect(projection.nearestElement.builtFrom).equals('e10');
 
     });
 

package/src/graph/Network.js

@@ -1,23 +1,28 @@
 import BoundingBox from '../coordinates/BoundingBox.js';
 import Coordinates from '../coordinates/Coordinates.js';
+import Level from '../coordinates/Level.js';
 
-import Edge from './Edge.js';
-import Node from './Node.js';
+import GraphEdge from './GraphEdge.js';
+import GraphNode from './GraphNode.js';
+import { getEdgeByNodes } from './GraphUtils.js';
 
 /**
+ * @template T
+ *
  * A typical network with nodes (Node) and edges (Edge)
  */
 class Network {
 
-    /** @type {Node[]} */
+    /** @type {GraphNode<T>[]} */
     nodes;
 
-    /** @type {Edge[]} */
+    /** @type {GraphEdge<T>[]} */
     edges;
 
     /**
-     * @param {Node[]} nodes
-     * @param {Edge[]} edges
+     * @template T
+     * @param {GraphNode<T>[]} nodes
+     * @param {GraphEdge<T>[]} edges
      */
     constructor(nodes, edges) {
         this.nodes = Array.isArray(nodes) ? nodes : [];
@@ -25,50 +30,24 @@ class Network {
     }
 
     /**
+     * @template T
      * @param {Coordinates} coords
-     * @returns {?Node}
+     * @returns {?GraphNode<T>}
      */
     getNodeByCoords(coords) {
         return this.nodes.find(node => node.coords.equalsTo(coords));
     }
 
     /**
-     * @param {string} name
-     * @returns {?Node}
-     */
-    getNodeByName(name) {
-        return this.nodes.find(node => node.name === name);
-    }
-
-    /**
-     * @param {Node} node1
-     * @param {Node} node2
-     * @returns {?Edge}
+     * @template T
+     * @param {GraphNode<T>} node1
+     * @param {GraphNode<T>} node2
+     * @returns {?GraphEdge<T>}
      */
     getEdgeByNodes(node1, node2) {
-        return Network.getEdgeByNodes(this.edges, node1, node2);
-    }
-
-    /**
-     * @param {string} name
-     * @returns {?Edge}
-     */
-    getEdgeByName(name) {
-        return this.edges.find(edge => edge.name === name);
+        return getEdgeByNodes(this.edges, node1, node2);
     }
 
-    /**
-     * @param {Edge[]} edges
-     * @param {Node} node1
-     * @param {Node} node2
-     * @returns {?Edge}
-     */
-    static getEdgeByNodes(edges, node1, node2) {
-        return edges.find(edge =>
-            node1 === edge.node1 && node2 === edge.node2
-            || node2 === edge.node1 && node1 === edge.node2
-        );
-    }
 
     /**
      * @param {?number} extendedMeasure
@@ -93,12 +72,12 @@ class Network {
 
         let nodeToStringFn = _nodeToStringFn;
         if (!nodeToStringFn) {
-            nodeToStringFn = node => `${node.name}`;
+            nodeToStringFn = node => `${node.builtFrom}`;
         }
 
         let edgeToStringFn = _edgeToStringFn;
         if (!_edgeToStringFn) {
-            edgeToStringFn = edge => `${edge.name}`;
+            edgeToStringFn = edge => `${edge.builtFrom}`;
         }
 
         let output
@@ -131,9 +110,14 @@ class Network {
                     this.nodes.indexOf(edge.node1),
                     this.nodes.indexOf(edge.node2)
                 ];
-                const properties = edge.extractProperties();
-                if (Object.keys(properties).length > 0) {
-                    output.push(properties);
+                if (edge.level !== null) {
+                    output.push(edge.level.toString());
+                }
+                if (edge.isOneway) {
+                    if (edge.level === null) {
+                        output.push(null);
+                    }
+                    output.push(true);
                 }
                 return output;
             })
@@ -148,21 +132,74 @@ class Network {
 
         const network = new Network();
 
-        network.nodes = json.nodes.map(Node.fromJson);
+        network.nodes = json.nodes.map(GraphNode.fromJson);
 
         network.edges = json.edges.map(jsonEdge => {
-            const edge = new Edge(
+            const edge = new GraphEdge(
                 network.nodes[jsonEdge[0]],
                 network.nodes[jsonEdge[1]]
             );
-            if (jsonEdge.length > 2) {
-                edge.applyProperties(jsonEdge[2]);
+            if (jsonEdge.length > 2 && jsonEdge[2] !== null) {
+                edge.level = Level.fromString(jsonEdge[2]);
+            }
+            if (jsonEdge.length > 3 && jsonEdge[3]) {
+                edge.isOneway = true;
             }
             return edge;
         });
 
         return network;
     }
+
+
+    /**
+     * Convert Array of Coordinates array to a network
+     * @param {Coordinates[][]} segments
+     * @returns {Network}
+     */
+    static fromCoordinates(segments) {
+
+        const network = new Network();
+
+        const getOrCreateNode = coords =>
+            network.nodes.find(_coords => _coords.equalsTo(coords)) || new GraphNode(coords);
+
+        const createEdgeFromCoords = (coords1, coords2) =>
+            new GraphEdge(coords1, coords2, Level.union(coords1.level, coords2.level));
+
+        for (const segment of segments) {
+
+            let previousNode = null;
+            for (const coords of segment) {
+                const currentNode = getOrCreateNode(coords);
+
+                if (previousNode) {
+                    const edge = createEdgeFromCoords(currentNode, previousNode);
+                    network.edges.push(edge);
+                }
+
+                network.nodes.push(currentNode);
+                previousNode = currentNode;
+            }
+        }
+
+        return network;
+    }
+
+    /**
+     * Create edges From MultiLevel Itinerary for a given level
+     * @param {Level} targetLevel level for selection.
+     * @param {Boolean} useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
+     * @returns {GraphEdge[]} Ordered edges
+     */
+    getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
+        return this.edges.filter(
+            ({ level }) => useMultiLevelEdges
+                ? Level.intersect(targetLevel, level) !== null
+                : Level.contains(targetLevel, level)
+        );
+    }
+
 }
 
 export default Network;