@wemap/geo 9.0.1 → 9.0.2

package/src/graph/GraphNode.js

@@ -97,7 +97,7 @@ class GraphNode {
         return new GraphNode(Coordinates.fromCompressedJson(json));
     }
 
-    generateLevelFromEdges() {
+    _generateLevelFromEdges() {
         let tmpLevel = null;
         for (let i = 0; i < this.edges.length; i++) {
             const edge = this.edges[i];
@@ -105,7 +105,7 @@ class GraphNode {
                 if (tmpLevel === null) {
                     tmpLevel = Level.clone(edge.level);
                 } else {
-                    tmpLevel = Level.intersect(tmpLevel, edge.level);
+                    tmpLevel = Level.intersection(tmpLevel, edge.level);
                     if (tmpLevel === null) {
                         Logger.error('Error: Something bad happend during parsing: We cannot retrieve node level from adjacent ways: ' + this.coords);
                         return false;
@@ -121,7 +121,7 @@ class GraphNode {
     /**
      * We suppose generateLevelFromEdges() was called before
      */
-    inferNodeLevelByRecursion() {
+    _inferNodeLevelByRecursion() {
         const { level } = this.coords;
         if (level === null || !Level.isRange(level)) {
             return true;
@@ -181,7 +181,7 @@ class GraphNode {
     /**
      * We suppose generateLevelFromEdges() was called before
      */
-    inferNodeLevelByNeighboors() {
+    _inferNodeLevelByNeighboors() {
         const { level } = this.coords;
         if (level === null || !Level.isRange(level)) {
             return true;
@@ -205,7 +205,7 @@ class GraphNode {
      * Set node.io to true for nodes that make the link between
      * indoor and outdoor edges
      */
-    checkIO() {
+    _checkIO() {
         this.io = this._coords.level !== null
             && this.edges.some(edge => edge.level === null);
         return true;
@@ -215,7 +215,7 @@ class GraphNode {
      * @param {GraphNode[]} nodes
      */
     static generateNodesLevels(nodes) {
-        const success = nodes.reduce((acc, node) => acc && node.generateLevelFromEdges(), true);
+        const success = nodes.reduce((acc, node) => acc && node._generateLevelFromEdges(), true);
         if (!success) {
             return false;
         }
@@ -224,12 +224,12 @@ class GraphNode {
         // (e.g stairs without network at one of its bounds)
         // To infer this node level, we use inferNodeLevelByRecursion()
         const res = nodes.reduce((acc, node) => acc
-            && node.inferNodeLevelByNeighboors()
-            && node.inferNodeLevelByRecursion()
+            && node._inferNodeLevelByNeighboors()
+            && node._inferNodeLevelByRecursion()
         , true);
 
         // Finally define nodes that are links between indoor and outdoor
-        nodes.forEach(node => node.checkIO());
+        nodes.forEach(node => node._checkIO());
 
         return res;
     }

package/src/graph/MapMatching.js

@@ -81,37 +81,29 @@ class MapMatching {
      */
     _shouldProjectOnEdgeAndNodes(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
 
+        // ignore projections if edge is not accepted
         if (!acceptEdgeFn(edge)) {
-            // if edge selection is not verified
             return [false, false, false];
         }
 
-        let checkNode1 = true;
-        let checkNode2 = true;
-        let checkEdge = true;
-
-        if (
-            // Verify if edge level only if one of both is defined
-            (location.level !== null || edge.level !== null)
-            && (
-                // if edge level intersect location level
-                !(Level.intersect(location.level, edge.level) !== null)
-                // ignore MultiLevelSegments if option used
-                || (!useMultiLevelSegments && Level.isRange(edge.level))
-            )) {
-            checkEdge = false;
-        }
+        // First, check if levels intersects
+        let checkEdge = Level.intersect(location.level, edge.level);
+        let checkNode1 = Level.intersect(location.level, edge.node1.coords.level);
+        let checkNode2 = Level.intersect(location.level, edge.node2.coords.level);
 
-        if (!Level.equals(location.level, edge.node1.coords.level) && !(edge.node1.io && location.level === null)) {
-            checkNode1 = false;
-        }
+        // Second, in case of IO nodes, accept matching if location's level is null
+        checkNode1 ||= edge.node1.io && location.level === null;
+        checkNode2 ||= edge.node2.io && location.level === null;
 
-        if (!Level.equals(location.level, edge.node2.coords.level) && !(edge.node2.io && location.level === null)) {
-            checkNode2 = false;
+        // Third, check if level is a range if useMultiLevelSegments is false
+        if (!useMultiLevelSegments) {
+            checkEdge &&= !Level.isRange(edge.level);
+            checkNode1 &&= !Level.isRange(edge.node1.coords.level);
+            checkNode2 &&= !Level.isRange(edge.node2.coords.level);
         }
 
+        // Finally, check edges bearing if option is used
         if (useBearing) {
-            // if mapmatching bearing is enabled do not use nodes matching
             if (checkEdge) {
                 // condition for optimisation
                 const diffAngle = diffAngleLines(edge.bearing, location.bearing);
@@ -120,6 +112,7 @@ class MapMatching {
                     checkEdge = false;
                 }
             }
+            // if mapmatching bearing is enabled do not use nodes matching
             checkNode1 = false;
             checkNode2 = false;
         }
@@ -135,7 +128,22 @@ class MapMatching {
     static _assignLatLngLevel(fromCoordinates, toCoordinates) {
         toCoordinates.lat = fromCoordinates.lat;
         toCoordinates.lng = fromCoordinates.lng;
-        toCoordinates.level = fromCoordinates.level;
+        toCoordinates.level = Level.clone(fromCoordinates.level);
+    }
+
+    /**
+     * IO Nodes are typical because they have a non-null level but projection car works on them.
+     * This function handles the case where the projection is on an IO node and a location with
+     * a null level is required.
+     *
+     * @param {Coordinates} projection
+     * @param {Coordinates} location
+     * @param {GraphNode} projectionNode
+     */
+    static _handleLevelsWithIONodes(projection, location, projectionNode) {
+        if (location.level === null && projectionNode.io) {
+            projection.level = null;
+        }
     }
 
     /**
@@ -147,12 +155,16 @@ class MapMatching {
     };
 
     /**
+     * Main function for map-matching, the networks have to be set before calling this function
+     * The function will returns a GraphProjection object given a coordinates object and a set
+     * of options (useDistance, useBearing, useMultiLevelSegments, acceptEdgeFn).
+     *
      * @param {!Coordinates} location
      * @param {boolean} useDistance
      * @param {boolean} useBearing
      * @param {boolean} useMultiLevelSegments
      * @param {function} acceptEdgeFn
-     * @returns {GraphProjection}
+     * @returns {?GraphProjection}
      */
     getProjection(location, useDistance = false, useBearing = false,
         useMultiLevelSegments = true, acceptEdgeFn = () => true) {
@@ -166,22 +178,29 @@ class MapMatching {
         }
 
         if (useBearing && (!location.bearing || !this._maxAngleBearing)) {
+            // If useBearing is true and bearing is not set in coordinates, return null
             return null;
         }
 
+        // Build a new GraphProjection object from parameters
         const projection = new GraphProjection();
         projection.origin = location;
         projection.distanceFromNearestElement = Number.MAX_VALUE;
         projection.projection = location.clone();
 
+        // Define a function to know if a projection is better than the current one
         const isProjectionBetter = (distanceOfNewProjection) => {
             return distanceOfNewProjection < projection.distanceFromNearestElement
                 && (!useDistance || distanceOfNewProjection <= this._maxDistance);
         };
 
-        for (let i = 0; i < this.network.edges.length; i++) {
-            const edge = this.network.edges[i];
+        // Loop on all the network edges
+        // Each time a better projection is found (see isProjectionBetter()),
+        //  the current projection is replaced
+        for (const edge of this.network.edges) {
 
+            // Check if the specified edge and its nodes can be used for projection. See the
+            // documentation of the corresponding function for more information.
             const [checkEdge, checkNode1, checkNode2] = this._shouldProjectOnEdgeAndNodes(
                 edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn);
 
@@ -192,12 +211,11 @@ class MapMatching {
                     projection.distanceFromNearestElement = distNode1;
                     projection.nearestElement = edge.node1;
                     MapMatching._assignLatLngLevel(edge.node1.coords, projection.projection);
+                    MapMatching._handleLevelsWithIONodes(projection.projection, location, edge.node1);
 
-                    if (distNode1 <= Constants.EPS_MM
-                        && location.level === edge.node1.coords.level) {
+                    if (distNode1 <= Constants.EPS_MM) {
                         break;
                     }
-                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
                 }
             }
 
@@ -205,16 +223,14 @@ class MapMatching {
 
                 const distNode2 = location.distanceTo(edge.node2.coords);
                 if (isProjectionBetter(distNode2) || distNode2 <= Constants.EPS_MM) {
-
                     projection.distanceFromNearestElement = distNode2;
                     projection.nearestElement = edge.node2;
                     MapMatching._assignLatLngLevel(edge.node2.coords, projection.projection);
+                    MapMatching._handleLevelsWithIONodes(projection.projection, location, edge.node2);
 
-                    if (distNode2 <= Constants.EPS_MM
-                        && location.level === edge.node2.coords.level) {
+                    if (distNode2 <= Constants.EPS_MM) {
                         break;
                     }
-                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
                 }
             }
 

package/src/graph/MapMatching.spec.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import chai from 'chai';
 
 import { deg2rad } from '@wemap/maths';
@@ -156,116 +157,220 @@ describe('MapMatching - multilevels', () => {
     it('matching node levels', () => {
         let currentPosition, projection;
 
-        currentPosition = new Coordinates(43.6091773, 3.8842584, null, null);
+        currentPosition = new Coordinates(43.6091773, 3.8842584, null, -1);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
 
+        currentPosition = new Coordinates(43.6091773, 3.8842584, null, null);
+        projection = mapMatching.getProjection(currentPosition);
+        expect(projection).is.not.null;
+        expect(projection.projection.level).is.null;
+        expect(projection.nearestElement.builtFrom).equals('p22');
+
         currentPosition = new Coordinates(43.6091773, 3.8842584, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 1)).true;
+        expect(projection.projection.level).equals(1);
+        expect(projection.nearestElement.builtFrom).equals('p16');
 
         currentPosition = new Coordinates(43.6091773, 3.8842584, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 2)).true;
+        expect(projection.projection.level).equals(2);
+        expect(projection.nearestElement.builtFrom).equals('p5');
 
     });
 
     it('matching edge levels', () => {
         let currentPosition, projection;
 
-        currentPosition = new Coordinates(43.6092811, 3.8842406, null, null);
+        currentPosition = new Coordinates(43.6092811, 3.8842406, null, -1);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
 
+        currentPosition = new Coordinates(43.6095474, 3.8844914, null, null);
+        projection = mapMatching.getProjection(currentPosition);
+        expect(projection).is.not.null;
+        expect(projection.projection.level).is.null;
+        expect(projection.nearestElement.builtFrom).equals('e24');
+
         currentPosition = new Coordinates(43.6092811, 3.8842406, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.nearestElement.level, 1)).true;
+        expect(projection.projection.level).equals(1);
+        expect(projection.nearestElement.builtFrom).equals('e15');
 
         currentPosition = new Coordinates(43.6092811, 3.8842406, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.nearestElement.level, 2)).true;
+        expect(projection.projection.level).equals(2);
+        expect(projection.nearestElement.builtFrom).equals('e7');
 
     });
 
     it('matching stairs nodes levels', () => {
         let currentPosition, projection;
 
-        currentPosition = new Coordinates(43.6093691, 3.8842057, null, null);
+        currentPosition = new Coordinates(43.6093691, 3.8842057, null, -1);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
 
         currentPosition = new Coordinates(43.6093691, 3.8842057, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 1)).true;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
 
         currentPosition = new Coordinates(43.6093691, 3.8842057, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 2)).true;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.6093691, 3.8842057, null, [1, 2]);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
 
     });
 
     it('matching stairs edge levels', () => {
         let currentPosition, projection;
 
-        currentPosition = new Coordinates(43.6093476, 3.8841978, null, null);
+        currentPosition = new Coordinates(43.6093476, 3.8841978, null, -1);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
 
         currentPosition = new Coordinates(43.6093476, 3.8841978, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 1)).true;
-        expect(Level.contains(projection.nearestElement.level, 1)).true;
+        expect(projection.nearestElement.builtFrom).equals('e11');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
 
         currentPosition = new Coordinates(43.6093476, 3.8841978, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false);
         expect(projection).is.not.null;
-        expect(Level.contains(projection.projection.level, 2)).true;
-        expect(Level.contains(projection.nearestElement.level, 2)).true;
+        expect(projection.nearestElement.builtFrom).equals('e11');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.6093476, 3.8841978, null, [1, 2]);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('e11');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
 
     });
 
-    it('useMultiLevelSegments', () => {
+    it('useMultiLevelSegments = false', () => {
         let currentPosition, projection;
 
         // On Nodes
 
-        currentPosition = new Coordinates(43.6093381, 3.8841926, null, 0);
+        currentPosition = new Coordinates(43.6093381, 3.8841926, null, -1);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.null;
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection).is.null;
+
+        currentPosition = new Coordinates(43.6093381, 3.8841926, null, 0);
+        projection = mapMatching.getProjection(currentPosition, true, false, false);
+        expect(projection).is.not.null;
+        expect(projection.projection.level).equals(0);
+        expect(projection.nearestElement.builtFrom).equals('p19c');
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('p19c');
 
         currentPosition = new Coordinates(43.6093381, 3.8841926, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
+        expect(projection.projection.level).equals(1);
         expect(projection.nearestElement.builtFrom).equals('p14');
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('e11');
 
         currentPosition = new Coordinates(43.6093381, 3.8841926, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
+        expect(projection.projection.level).equals(2);
         expect(projection.nearestElement.builtFrom).equals('p11');
-
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('e11');
 
         // On Segments
 
-        currentPosition = new Coordinates(43.6093258, 3.8842272, null, 0);
+        currentPosition = new Coordinates(43.6093551, 3.88425725, null, -1);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.null;
 
-        currentPosition = new Coordinates(43.6093258, 3.8842272, null, 1);
+        currentPosition = new Coordinates(43.6093551, 3.88425725, null, 0);
+        projection = mapMatching.getProjection(currentPosition, true, false, false);
+        expect(projection).is.not.null;
+        expect(projection.projection.level).equals(0);
+        expect(projection.nearestElement.builtFrom).equals('e22');
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('e22');
+
+        currentPosition = new Coordinates(43.6093551, 3.88425725, null, 1);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
-        expect(projection.nearestElement.builtFrom).equals('e14');
+        expect(projection.projection.level).equals(1);
+        expect(projection.nearestElement.builtFrom).equals('e17');
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('e13');
 
         currentPosition = new Coordinates(43.6093258, 3.8842272, null, 2);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
         expect(projection).is.not.null;
+        expect(projection.projection.level).equals(2);
         expect(projection.nearestElement.builtFrom).equals('e10');
+        projection = mapMatching.getProjection(currentPosition, true, false, true);
+        expect(projection.nearestElement.builtFrom).equals('e13');
+
+    });
+
+    it('matching exact node position with eps', () => {
+        let currentPosition, projection;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, -1);
+        projection = mapMatching.getProjection(currentPosition);
+        expect(projection).is.null;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, null);
+        projection = mapMatching.getProjection(currentPosition);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p22');
+        expect(projection.projection.level).is.null;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, [1, 2]);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, 1);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, 2);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, [0, 3]);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p12');
+        expect(Level.equals(projection.projection.level, [1, 2])).true;
+
+        currentPosition = new Coordinates(43.6093323, 3.8842483, null, 0);
+        projection = mapMatching.getProjection(currentPosition, true, false);
+        expect(projection).is.not.null;
+        expect(projection.nearestElement.builtFrom).equals('p19c');
+        expect(projection.projection.level).equals(0);
 
     });
 

package/src/graph/Network.js

@@ -196,7 +196,7 @@ class Network {
     getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
         return this.edges.filter(
             ({ level }) => useMultiLevelEdges
-                ? Level.intersect(targetLevel, level) !== null
+                ? Level.intersect(targetLevel, level)
                 : Level.contains(targetLevel, level)
         );
     }

package/tests/CommonTest.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-inline-comments */
 import chai from 'chai';
 
 import Coordinates from '../src/coordinates/Coordinates.js';
@@ -9,7 +10,7 @@ import Network from '../src/graph/Network.js';
 const { expect } = chai;
 
 const nodes = [
-    new Node(new Coordinates(43.6092404, 3.884099), 'p0'),
+    new Node(new Coordinates(43.6092404, 3.884099), 'p0'), // 0
     new Node(new Coordinates(43.6091965, 3.8841285), 'p1'),
     new Node(new Coordinates(43.6091888, 3.8841263), 'p2'),
     new Node(new Coordinates(43.6091361, 3.8841109), 'p3'),
@@ -19,7 +20,7 @@ const nodes = [
     new Node(new Coordinates(43.609276, 3.8842467), 'p7'),
     new Node(new Coordinates(43.6092935, 3.8842518), 'p8'),
     new Node(new Coordinates(43.6093022, 3.8842702), 'p9'),
-    new Node(new Coordinates(43.6093123, 3.8842731), 'p10'),
+    new Node(new Coordinates(43.6093123, 3.8842731), 'p10'), // 10
     new Node(new Coordinates(43.6093234, 3.8842009), 'p11'),
     new Node(new Coordinates(43.6093629, 3.8842127), 'p12'),
     new Node(new Coordinates(43.6093597, 3.8842336), 'p13'),
@@ -29,31 +30,41 @@ const nodes = [
     new Node(new Coordinates(43.6093279, 3.8842777), 'p17'),
     new Node(new Coordinates(43.6093279, 3.8842777), 'p18'),
     new Node(new Coordinates(43.6093323, 3.8842483), 'p19a'),
-    new Node(new Coordinates(43.6093323, 3.8842483), 'p19b')
+    new Node(new Coordinates(43.6093323, 3.8842483), 'p19b'), // 20
+    new Node(new Coordinates(43.6093323, 3.8842483), 'p19c'),
+    new Node(new Coordinates(43.6093032, 3.8844388), 'p21'),
+    new Node(new Coordinates(43.6095297, 3.8845039), 'p22'),
+    new Node(new Coordinates(43.6095624, 3.8845134), 'p23')
 ];
 
+const n = name => nodes.find(node => node.builtFrom === name);
+
 const edges = [
-    new Edge(nodes[1], nodes[2], 2, 'e0'),
-    new Edge(nodes[2], nodes[3], 2, 'e1'),
-    new Edge(nodes[3], nodes[4], 2, 'e2'),
-    new Edge(nodes[4], nodes[5], 2, 'e3'),
-    new Edge(nodes[5], nodes[6], 2, 'e4'),
-    new Edge(nodes[6], nodes[2], 2, 'e5'),
-    new Edge(nodes[6], nodes[7], 2, 'e6'),
-    new Edge(nodes[7], nodes[8], 2, 'e7'),
-    new Edge(nodes[8], nodes[9], 2, 'e8'),
-    new Edge(nodes[9], nodes[10], 2, 'e9'),
-    new Edge(nodes[10], nodes[11], 2, 'e10'),
-    new Edge(nodes[11], nodes[12], [1, 2], 'e11'),
-    new Edge(nodes[12], nodes[13], [1, 2], 'e12'),
-    new Edge(nodes[13], nodes[14], [1, 2], 'e13'),
-    new Edge(nodes[14], nodes[15], 1, 'e14'),
-    new Edge(nodes[15], nodes[16], 1, 'e15'),
-    new Edge(nodes[15], nodes[17], 1, 'e16'),
-    new Edge(nodes[19], nodes[17], 1, 'e17'),
-    new Edge(nodes[10], nodes[18], 2, 'e18'),
-    new Edge(nodes[20], nodes[18], 2, 'e19'),
-    new Edge(nodes[19], nodes[20], [1, 2], 'e20')
+    new Edge(n('p1'), n('p2'), 2, 'e0'),
+    new Edge(n('p2'), n('p3'), 2, 'e1'),
+    new Edge(n('p3'), n('p4'), 2, 'e2'),
+    new Edge(n('p4'), n('p5'), 2, 'e3'),
+    new Edge(n('p5'), n('p6'), 2, 'e4'),
+    new Edge(n('p6'), n('p2'), 2, 'e5'),
+    new Edge(n('p6'), n('p7'), 2, 'e6'),
+    new Edge(n('p7'), n('p8'), 2, 'e7'),
+    new Edge(n('p8'), n('p9'), 2, 'e8'),
+    new Edge(n('p9'), n('p10'), 2, 'e9'),
+    new Edge(n('p10'), n('p11'), 2, 'e10'),
+    new Edge(n('p11'), n('p12'), [1, 2], 'e11'),
+    new Edge(n('p12'), n('p13'), [1, 2], 'e12'),
+    new Edge(n('p13'), n('p14'), [1, 2], 'e13'),
+    new Edge(n('p14'), n('p15'), 1, 'e14'),
+    new Edge(n('p15'), n('p16'), 1, 'e15'),
+    new Edge(n('p15'), n('p17'), 1, 'e16'),
+    new Edge(n('p19b'), n('p17'), 1, 'e17'),
+    new Edge(n('p10'), n('p18'), 2, 'e18'),
+    new Edge(n('p19a'), n('p18'), 2, 'e19'),
+    new Edge(n('p19a'), n('p19b'), [1, 2], 'e20'),
+    new Edge(n('p19b'), n('p19c'), [0, 1], 'e21'),
+    new Edge(n('p19c'), n('p21'), 0, 'e22'),
+    new Edge(n('p21'), n('p22'), 0, 'e23'),
+    new Edge(n('p22'), n('p23'), null, 'e24')
 ];
 
 const network = new Network();