@wemap/geo 0.2.1 → 0.3.1

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.2.1",
+    "version": "0.3.1",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -27,8 +27,9 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/maths": "^0.2.0",
-        "lodash.isnumber": "^3.0.3"
+        "@wemap/maths": "^0.2.1",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "dc8de098a46002417ccf368038a1e093e42f1a8e"
+    "gitHead": "7b84c9d55646761f75f19235a15be8a1b73b3dbf"
 }

package/src/coordinates/Level.js

@@ -1,4 +1,6 @@
 import Logger from '@wemap/logger';
+import isNumber from 'lodash/isnumber';
+import isString from 'lodash/isstring';
 
 /**
  * A Level is the representation of a building floor number
@@ -7,18 +9,37 @@ import Logger from '@wemap/logger';
  */
 class Level {
 
-    constructor() {
-        this.val = null;
-        this.isRange = false;
+    /**
+     * Level constructor
+     *  1 argument: level is not a range and first argument is the level
+     *  2 arguments: level is a range
+     * @param {Number} arg1 if arg2: low value, otherwise: level
+     * @param {Number} arg2 (optional) up value
+     */
+    constructor(arg1, arg2) {
+        if (!isNumber(arg1)) {
+            throw new Error('first argument is mandatory');
+        }
+        if (isNumber(arg2)) {
+            if (arg1 === arg2) {
+                this.isRange = false;
+                this.val = arg1;
+            } else {
+                this.isRange = true;
+                this.low = Math.min(arg1, arg2);
+                this.up = Math.max(arg1, arg2);
+            }
+        } else {
+            this.isRange = false;
+            this.val = arg1;
+        }
     }
 
     clone() {
-        const output = new Level();
-        output.isRange = this.isRange;
-        output.val = this.val;
-        output.up = this.up;
-        output.low = this.low;
-        return output;
+        if (this.isRange) {
+            return new Level(this.low, this.up);
+        }
+        return new Level(this.val);
     }
 
     /**
@@ -26,12 +47,13 @@ class Level {
      * @param {*} str level in str format (eg. 1, -2, 1;2, -2;3, 2;-1, 0.5;1 ...)
      */
     static fromString(str) {
-        const level = new Level();
-        const num = Number(str);
-        if (!isNaN(num)) {
-            level.val = num;
-            level.isRange = false;
-            return level;
+
+        if (!isString(str)) {
+            return null;
+        }
+
+        if (!isNaN(Number(str))) {
+            return new Level(Number(str));
         }
 
         const splited = str.split(';');
@@ -39,10 +61,7 @@ class Level {
             const num1 = Number(splited[0]);
             const num2 = Number(splited[1]);
             if (!isNaN(num1) && !isNaN(num2)) {
-                level.up = Math.max(num1, num2);
-                level.low = Math.min(num1, num2);
-                level.isRange = true;
-                return level;
+                return new Level(num1, num2);
             }
         }
 
@@ -63,31 +82,95 @@ class Level {
      * @param {Level} other The other level
      */
     intersect(other) {
+        return Level.intersect(this, other);
+    }
 
-        if (!other) {
-            return null;
+    /**
+     * Retrieve the intersection of two levels
+     * @param {Level} other The other level
+     */
+    static intersect(first, second) {
+
+        if (first === second) {
+            return first;
+        }
+
+        if (!second) {
+            return first;
+        }
+
+        if (!first) {
+            return second;
         }
 
-        if (this.isRange && !other.isRange) {
-            if (this.isInside(other.val)) {
-                return other;
+        if (first.isRange && !second.isRange) {
+            if (first.isInside(second.val)) {
+                return second;
             }
             return null;
         }
-        if (!this.isRange && other.isRange) {
-            if (other.isInside(this.val)) {
-                return this;
+        if (!first.isRange && second.isRange) {
+            if (second.isInside(first.val)) {
+                return first;
             }
-            return null;
+            return first;
         }
-        if (this.isRange && other.isRange) {
-            const level = new Level();
-            level.low = Math.max(this.low, other.low);
-            level.up = Math.min(this.up, other.up);
-            level.isRange = true;
-            return level;
+        if (first.isRange && second.isRange) {
+            const up = Math.min(first.up, second.up);
+            const low = Math.max(first.low, second.low);
+            if (up < low) {
+                return null;
+            }
+            return new Level(low, up);
         }
-        return this.val === other.val ? this : null;
+        return first.val === second.val ? first : null;
+    }
+
+    /**
+     * Retrieve the union of two levels
+     * @param {Level} other The other level
+     */
+    union(other) {
+        return Level.union(this, other);
+    }
+
+    /**
+     * Retrieve the union of two levels
+     * @param {Level} other The other level
+     */
+    static union(first, second) {
+
+        if (first === second) {
+            return first;
+        }
+
+        if (!second) {
+            return first;
+        }
+
+        if (!first) {
+            return second;
+        }
+
+        let low, up;
+        if (!first.isRange && !second.isRange) {
+            low = Math.min(first.val, second.val);
+            up = Math.max(first.val, second.val);
+        } else if (first.isRange && !second.isRange) {
+            low = Math.min(first.low, second.val);
+            up = Math.max(first.up, second.val);
+        } else if (!first.isRange && second.isRange) {
+            low = Math.min(second.low, first.val);
+            up = Math.max(second.up, first.val);
+        } else if (first.isRange && second.isRange) {
+            low = Math.min(second.low, first.low);
+            up = Math.max(second.up, first.up);
+        }
+
+        if (low === up) {
+            return new Level(low);
+        }
+        return new Level(low, up);
     }
 
     multiplyBy(factor) {
@@ -100,7 +183,38 @@ class Level {
     }
 
     toString() {
-        return this.isRange ? this.low + ';' + this.up : this.val;
+        return this.isRange ? this.low + ';' + this.up : String(this.val);
+    }
+
+    static equalsTo(first, second) {
+
+        if (first === second) {
+            return true;
+        }
+        if (!first && !second) {
+            return true;
+        }
+        if (!first && second) {
+            return false;
+        }
+        if (first && !second) {
+            return false;
+        }
+        if (!first.isRange && second.isRange) {
+            return false;
+        }
+        if (first.isRange && !second.isRange) {
+            return false;
+        }
+        if (first.isRange && second.isRange) {
+            return first.low === second.low && first.up === second.up;
+        }
+        if (!first.isRange && !second.isRange) {
+            return first.val === second.val;
+        }
+
+        // Should never happen.
+        return false;
     }
 
 }

package/src/coordinates/Level.spec.js

@@ -0,0 +1,164 @@
+/* eslint-disable max-nested-callbacks */
+import { expect } from 'chai';
+
+import Level from './Level';
+import Logger from '@wemap/logger';
+
+Logger.enable(false);
+
+const checkSingle = (_level, _value) => {
+    expect(_level.isRange).false;
+    expect(_level.val).equals(_value);
+    expect(_level.low).undefined;
+    expect(_level.up).undefined;
+};
+
+const checkRange = (_level, _value1, _value2) => {
+    expect(_level.isRange).true;
+    expect(_level.val).undefined;
+    expect(_level.low).equals(Math.min(_value1, _value2));
+    expect(_level.up).equals(Math.max(_value1, _value2));
+};
+
+
+describe('Level', () => {
+
+    it('creation', () => {
+
+        const listOfInvalidLevel = ['toto', true, false, NaN, null];
+        const listOfValidLevel = [-1, 1, 0, 1.5, -2.3];
+        const listOfLevels = [].concat(listOfInvalidLevel, listOfValidLevel);
+
+        listOfLevels.forEach(value1 => {
+            if (listOfInvalidLevel.includes(value1)) {
+                expect(() => new Level(value1)).is.throw;
+            } else {
+                checkSingle(new Level(value1), value1);
+            }
+
+            listOfLevels.forEach(value2 => {
+                if (listOfInvalidLevel.includes(value1)
+                    || listOfInvalidLevel.includes(value2)) {
+                    expect(() => new Level(value1, value2)).is.throw;
+                    expect(() => new Level(value2, value1)).is.throw;
+                } else if (value1 === value2) {
+                    checkSingle(new Level(value1), value1);
+                } else {
+                    checkRange(new Level(value1, value2), value1, value2);
+                    checkRange(new Level(value2, value1), value1, value2);
+                }
+            });
+        });
+
+
+    });
+
+    it('fromString', () => {
+        const listOfInvalidLevel = ['toto', 'toto;toto', '1;toto', 'toto;1',
+            true, false, NaN, null];
+
+        listOfInvalidLevel.forEach(value1 => {
+            expect(Level.fromString(value1)).is.null;
+        });
+
+        checkSingle(Level.fromString('0'), 0);
+        checkSingle(Level.fromString('1'), 1);
+        checkSingle(Level.fromString('-1'), -1);
+        checkSingle(Level.fromString('1.5'), 1.5);
+        checkSingle(Level.fromString('-1.5'), -1.5);
+        checkRange(Level.fromString('0;1'), 0, 1);
+        checkRange(Level.fromString('1;0'), 0, 1);
+        checkSingle(Level.fromString('1;1'), 1);
+        checkRange(Level.fromString('-1;0'), -1, 0);
+        checkRange(Level.fromString('-1;1'), -1, 1);
+        checkSingle(Level.fromString('-1;-1'), -1);
+        checkRange(Level.fromString('-1;1.5'), -1, 1.5);
+        checkRange(Level.fromString('-1.5;1'), -1.5, 1);
+        checkRange(Level.fromString('-1.5;1.5'), -1.5, 1.5);
+    });
+
+
+    it('toString', () => {
+        expect(new Level(0).toString()).equals('0');
+        expect(new Level(1).toString()).equals('1');
+        expect(new Level(-1).toString()).equals('-1');
+        expect(new Level(1.5).toString()).equals('1.5');
+        expect(new Level(-1.5).toString()).equals('-1.5');
+        expect(new Level(0, 1).toString()).equals('0;1');
+        expect(new Level(1, 0).toString()).equals('0;1');
+        expect(new Level(1, 1).toString()).equals('1');
+        expect(new Level(-1, 0).toString()).equals('-1;0');
+        expect(new Level(-1, 1).toString()).equals('-1;1');
+        expect(new Level(-1, -1).toString()).equals('-1');
+        expect(new Level(-1, 1.5).toString()).equals('-1;1.5');
+        expect(new Level(-1.5, 1).toString()).equals('-1.5;1');
+        expect(new Level(-1.5, 1.5).toString()).equals('-1.5;1.5');
+    });
+
+    it('equalsTo', () => {
+        const level = new Level(1);
+        expect(Level.equalsTo(null, null)).true;
+        expect(Level.equalsTo(level, level)).true;
+        expect(Level.equalsTo(level, null)).false;
+        expect(Level.equalsTo(null, level)).false;
+        expect(Level.equalsTo(new Level(1), new Level(1))).true;
+        expect(Level.equalsTo(new Level(-1), new Level(1))).false;
+        expect(Level.equalsTo(new Level(1), new Level(0, 1))).false;
+        expect(Level.equalsTo(new Level(0, 1), new Level(1))).false;
+        expect(Level.equalsTo(new Level(1), new Level(1, 1))).true;
+        expect(Level.equalsTo(new Level(1, 0), new Level(1, 0))).true;
+        expect(Level.equalsTo(new Level(0, 1), new Level(1, 0))).true;
+    });
+
+    it('clone', () => {
+        expect(Level.equalsTo(new Level(0).clone(), new Level(0))).true;
+        expect(Level.equalsTo(new Level(1).clone(), new Level(1))).true;
+        expect(Level.equalsTo(new Level(-1).clone(), new Level(-1))).true;
+        expect(Level.equalsTo(new Level(0, 1).clone(), new Level(0, 1))).true;
+        expect(Level.equalsTo(new Level(1, 0).clone(), new Level(1, 0))).true;
+        expect(Level.equalsTo(new Level(-1.5, 1).clone(), new Level(-1.5, 1))).true;
+    });
+
+    it('intersect', () => {
+        expect(Level.intersect(null, null)).is.null;
+
+        const level = new Level(1);
+        expect(Level.intersect(level, null)).equals(level);
+        expect(Level.intersect(null, level)).equals(level);
+        expect(Level.intersect(level, level)).equals(level);
+
+        expect(Level.equalsTo(Level.intersect(new Level(0, 1), new Level(1)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(0, 2), new Level(1)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(-1, 2), new Level(1)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 1)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 2)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(-1, 2)), new Level(1)));
+        expect(Level.equalsTo(Level.intersect(new Level(1, 2), new Level(-1, 2)), new Level(1, 2)));
+        expect(Level.equalsTo(Level.intersect(new Level(-3, 1), new Level(-1, 2)), new Level(-1, 1)));
+        expect(Level.equalsTo(Level.intersect(new Level(-3, -1), new Level(-1, 2)), new Level(-1)));
+        expect(Level.intersect(new Level(-3, -2), new Level(-1, 2))).is.null;
+        expect(Level.intersect(new Level(-1, 2), new Level(-3, -2))).is.null;
+    });
+
+    it('union', () => {
+        expect(Level.union(null, null)).is.null;
+
+        const level = new Level(1);
+        expect(Level.union(level, null)).equals(level);
+        expect(Level.union(null, level)).equals(level);
+        expect(Level.union(level, level)).equals(level);
+
+        expect(Level.equalsTo(Level.union(new Level(0, 1), new Level(1)), new Level(0, 1)));
+        expect(Level.equalsTo(Level.union(new Level(0, 2), new Level(1)), new Level(0, 2)));
+        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(1)), new Level(-1, 2)));
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 1)), new Level(0, 1)));
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 2)), new Level(0, 2)));
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(-1, 2)), new Level(-1, 2)));
+        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(-1, 2)), new Level(-1, 2)));
+        expect(Level.equalsTo(Level.union(new Level(-3, 1), new Level(-1, 2)), new Level(-3, 2)));
+        expect(Level.equalsTo(Level.union(new Level(-3, -1), new Level(-1, 2)), new Level(-3, 2)));
+        expect(Level.equalsTo(Level.union(new Level(-3, -2), new Level(-1, 2)), new Level(-3, 2)));
+        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(-3, -2)), new Level(-3, 2)));
+    });
+
+});

package/src/coordinates/WGS84.js

@@ -3,14 +3,7 @@ import {
 } from '@wemap/maths';
 import Constants from '../Constants';
 import isNumber from 'lodash/isnumber';
-
-/**
- * JSON output formats:
- * - FORMAT_LAT_LNG_ELE (default)
- * - FORMAT_LNG_LAT_STRLEVEL
- */
-const FORMAT_LAT_LNG_ELE = 0;
-const FORMAT_LNG_LAT_STRLEVEL = 1;
+import Level from './Level';
 
 /**
  * A WGS84 position using at least latitude (lat) and longitude (lng).
@@ -21,11 +14,11 @@ const FORMAT_LNG_LAT_STRLEVEL = 1;
  */
 class WGS84 {
 
-    constructor(lat, lng, alt) {
+    constructor(lat, lng, alt, level) {
         this._lat = lat;
         this._lng = lng;
         this._alt = alt;
-        this._level = null;
+        this._level = level;
         this._ecef = null;
     }
 
@@ -78,7 +71,7 @@ class WGS84 {
             return false;
         }
 
-        return other.lat === this.lat && other.lng === this.lng;
+        return other.lat === this.lat && other.lng === this.lng && Level.equalsTo(other.level, this.level);
     }
 
     toString() {
@@ -86,21 +79,13 @@ class WGS84 {
         if (this._alt) {
             str += ', ' + this._alt.toFixed(2);
         }
+        if (this._level) {
+            str += ', [' + this._level.toString() + ']';
+        }
         str += ']';
         return str;
     }
 
-    toJson(format = FORMAT_LAT_LNG_ELE) {
-        switch (format) {
-        case FORMAT_LNG_LAT_STRLEVEL:
-            return [this.lng, this.lat, this.level ? this.level.toString() : null];
-
-        case FORMAT_LAT_LNG_ELE:
-        default:
-            return [this.lat, this.lng, this.ele];
-        }
-    }
-
     destinationPoint(distance, bearing, elevation = 0) {
         const newPoint = this.clone();
         newPoint.move(distance, bearing, elevation);
@@ -279,15 +264,21 @@ class WGS84 {
     }
 
     toMessage() {
-        return {
+        const output = {
             lat: this.lat,
-            lng: this.lng,
-            alt: this.alt
+            lng: this.lng
         };
+        if (isNumber(this.alt)) {
+            output.alt = this.alt;
+        }
+        if (this.level) {
+            output.level = this.level;
+        }
+        return output;
     }
 
     static fromMessage(message) {
-        return new WGS84(message.lat, message.lng, message.alt);
+        return new WGS84(message.lat, message.lng, message.alt, Level.fromString(message.level));
     }
 
     static fromPinpoint(pinpoint) {
@@ -329,15 +320,6 @@ class WGS84 {
 
         return sampledRoute;
     }
-
-
-    static get FORMAT_LNG_LAT_STRLEVEL() {
-        return FORMAT_LNG_LAT_STRLEVEL;
-    }
-
-    static get FORMAT_LAT_LNG_ELE() {
-        return FORMAT_LAT_LNG_ELE;
-    }
 }
 
 export default WGS84;

package/src/coordinates/WGS84UserPosition.js

@@ -1,4 +1,5 @@
 import WGS84 from './WGS84';
+import Level from './Level';
 
 const MESSAGE_TYPE = 'WGS84UserPosition';
 
@@ -7,9 +8,9 @@ const MESSAGE_TYPE = 'WGS84UserPosition';
  */
 class WGS84UserPosition extends WGS84 {
 
-    constructor(lat, lng, alt = null, time = null,
+    constructor(lat, lng, alt = null, level = null, time = null,
         accuracy = null, bearing = null, provider = null) {
-        super(lat, lng, alt);
+        super(lat, lng, alt, level);
         this.bearing = bearing;
         this.provider = provider;
         this.time = time;
@@ -21,15 +22,20 @@ class WGS84UserPosition extends WGS84 {
     static fromWGS84(wgs84Coordinates, userPosition) {
 
         if (userPosition) {
-            return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng, wgs84Coordinates.alt,
-                userPosition.time, userPosition.accuracy, userPosition.bearing, userPosition.provider);
+            return new WGS84UserPosition(
+                wgs84Coordinates.lat, wgs84Coordinates.lng,
+                wgs84Coordinates.alt, wgs84Coordinates.level,
+                userPosition.time, userPosition.accuracy,
+                userPosition.bearing, userPosition.provider);
         }
 
-        return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng, wgs84Coordinates.alt);
+        return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng,
+            wgs84Coordinates.alt, wgs84Coordinates.level);
     }
 
     clone() {
-        return new WGS84UserPosition(this.lat, this.lng, this.alt, this.time, this.accuracy, this.bearing, this.provider);
+        return new WGS84UserPosition(this.lat, this.lng, this.alt, this.level,
+            this.time, this.accuracy, this.bearing, this.provider);
     }
 
     static get MESSAGE_TYPE() {
@@ -48,6 +54,7 @@ class WGS84UserPosition extends WGS84 {
 
     static fromMessage(message) {
         return new WGS84UserPosition(message.lat, message.lng, message.alt,
+            Level.fromString(message.level),
             message.time, message.accuracy, message.bearing, message.provider);
     }
 }

package/src/graph/Edge.js

@@ -7,7 +7,7 @@ import Node from './Node';
  */
 class Edge {
 
-    constructor(node1, node2, data) {
+    constructor(node1, node2, data, level) {
 
         if (!(node1 instanceof Node)) {
             throw new TypeError('node1 is not an instance of Node');
@@ -20,7 +20,10 @@ class Edge {
         this.node1 = node1;
         this.node2 = node2;
         this.data = data;
-        this.level = null;
+        this.level = level;
+
+        this.node1.edges.push(this);
+        this.node2.edges.push(this);
 
         this.computedSizeAndBearing = false;
     }
@@ -61,7 +64,9 @@ class Edge {
     }
 
     clone(node1, node2) {
-        return new Edge(node1, node2, this.data);
+        const edge = new Edge(node1, node2, this.data);
+        edge.level = this.level;
+        return edge;
     }
 }
 

package/src/graph/GraphRouter.js

@@ -107,9 +107,6 @@ class GraphRouter {
         v.level = edge.level;
         v.data = edge.data;
 
-        m.edges.push(u, v);
-        a.edges.push(u);
-        b.edges.push(v);
         a.edges = a.edges.filter(_edge => _edge !== edge);
         b.edges = b.edges.filter(_edge => _edge !== edge);
 
@@ -132,9 +129,8 @@ class GraphRouter {
 
         const oldEdge = new Edge(u.node1, v.node1);
         oldEdge.data = u.data;
+        oldEdge.level = u.level;
         this.network.edges.push(oldEdge);
-        u.node1.edges.push(oldEdge);
-        v.node1.edges.push(oldEdge);
 
         this.network.nodes = this.network.nodes.filter(node => node !== _node);
         this.network.edges = this.network.edges.filter(