incyclist-services 1.3.19 → 1.3.21

package/lib/maps/ways/MapArea.js

@@ -0,0 +1,1194 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMapArea = exports.destinationPoint = exports.alongTrackDistanceTo = exports.initialBearingTo = exports.isWithinBoundary = exports.getBounds = exports.getVector = exports.getCrossingInfo = exports.getPointCrossingPath = exports._getPointOnLine = exports.findAdditional = exports.getFirstBranch = exports.isOneWay = exports.isAllowed = exports.isNode = exports.isWay = exports.pointEquals = exports.splitAtPoint = exports.splitAtIndex = exports.isRoundabout = exports.getUntilFirstBranch = exports.splitAtPointInfo = void 0;
+const { EventLogger } = require('gd-eventlog');
+const DEFAULT_RADIUS = 1000;
+const DEFAULT_MIN_WAYS = 70;
+const DEFAULT_MAX_WAYS = 300;
+const MAX_DISTANCE_FROM_PATH = 5;
+const GET_WAYS_IN_AREA = '[out:json];way[highway](__boundary__);(._;>;);out geom;';
+class MapAreaService {
+    static getInstance(id = 'default') {
+        if (!MapAreaService._instances[id])
+            MapAreaService._instances[id] = new MapAreaService();
+        return MapAreaService._instances[id];
+    }
+    constructor(props) {
+        this.overpass = new OverpassApi();
+        this.logger = new EventLogger('MapArea');
+        this.init(props);
+    }
+    init(props) {
+        this.minWays = DEFAULT_MIN_WAYS;
+        this.maxWays = DEFAULT_MAX_WAYS;
+        this.radius = DEFAULT_RADIUS;
+        this.nodesLookup = [];
+        this.waysLookup = [];
+        this.ways = [];
+        if (props === undefined)
+            return;
+        if (props.onLoaded)
+            this.onLoaded = props.onLoaded;
+        if (props.minWays)
+            this.minWays = props.minWays;
+        if (props.maxWays)
+            this.maxWays = props.maxWays;
+        if (props.radius)
+            this.radius = props.radius;
+        if (props.filter)
+            this.filter = props.filter;
+        if (props.location) {
+            this.setLocation(props.location, true, this.onLoaded);
+        }
+    }
+    isInitialized() {
+        return this.boundary !== undefined;
+    }
+    load(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const onLoaded = callback ? callback : this.onLoaded;
+            let ts, ts1;
+            try {
+                this.query = this._buildQuery(GET_WAYS_IN_AREA);
+                this.queryLocation = this.location;
+                const { id, lat, lng } = this.location;
+                this.logger.logEvent({ message: 'overpass query', query: this.query, location: { id, lat, lng }, radius: this.radius });
+                ts = Date.now();
+                let openmapData = yield this.overpass.query(this.query);
+                ts1 = Date.now();
+                this.logger.logEvent({ message: 'overpass query result', status: 'success', duration: (ts1 - ts) });
+                this.setData(openmapData, onLoaded);
+            }
+            catch (error) {
+                ts1 = Date.now();
+                this.logger.logEvent({ message: 'overpass query result', status: 'failure', error: { code: error.code, response: error.response }, duration: (ts1 - ts) });
+                if (onLoaded !== undefined)
+                    onLoaded('failure', this.ways, this.openmapData);
+            }
+        });
+    }
+    setData(openmapData, callback) {
+        const onLoaded = callback ? callback : this.onLoaded;
+        let ts = Date.now();
+        let res = MapAreaService._parse(openmapData, this.filter);
+        let ts1 = Date.now();
+        this.logger.logEvent({ message: 'Parse', duration: (ts1 - ts),
+            ways: (res !== undefined && res.ways !== undefined ? res.ways.length : 0),
+            nodes: (res !== undefined && res.nodes !== undefined ? res.nodes.length : 0),
+            typeStats: (res !== undefined ? res.typeStats : '')
+        });
+        if (res !== undefined) {
+            this.openmapData = openmapData;
+            this.ways = res.ways;
+            this.nodesLookup = res.nodesLookup;
+            this.waysLookup = res.waysLookup;
+            this._checkRoundabouts();
+            this.loaded = 'success';
+            if (this.ways.length < this.minWays) {
+                if (this.ways.length > 0) {
+                    let gap = this.minWays / this.ways.length;
+                    this.radius = this.radius * Math.sqrt(gap);
+                }
+                else {
+                    this.radius = this.radius * 2;
+                }
+            }
+            else if (this.ways.length > this.maxWays) {
+                let gap = this.ways.length / this.maxWays;
+                this.radius = this.radius / Math.sqrt(gap);
+            }
+        }
+        else {
+            this.loaded = 'failure';
+        }
+        if (onLoaded !== undefined) {
+            onLoaded(this.loaded, this.ways, this.openmapData);
+        }
+    }
+    _collectRoundabout(way) {
+        if (!isRoundabout(way, true))
+            return undefined;
+        const contains = (ways, wid) => {
+            let found = ways.find(id => id === wid);
+            return found !== undefined;
+        };
+        const addNodes = (ways, way) => {
+            way.path.forEach((n, idx) => {
+                if (idx > 0) {
+                    n.ways.forEach(wid => {
+                        let w = this.waysLookup[wid];
+                        if (isRoundabout(w, true) && wid !== way.id && !contains(ways, wid)) {
+                            ways.push(wid);
+                            addNodes(ways, w);
+                        }
+                    });
+                }
+            });
+        };
+        let ways = [way.id];
+        addNodes(ways, way);
+        return ways;
+    }
+    ;
+    static _generateID(ways) {
+        if (ways === undefined || ways.length === 0)
+            return;
+        if (ways.length < 2)
+            return ways[0];
+        let w = [...ways];
+        let widStr = 'R:' + w.sort().join(',');
+        return widStr;
+    }
+    ;
+    _replaceWayID(way, newId, replaceLookup = true) {
+        if (way === undefined || newId === undefined || way.id === undefined || way.path === undefined)
+            return;
+        let oldId = way.id;
+        let w = this.waysLookup[oldId];
+        let self = this;
+        w.originalId = w.id;
+        w.id = newId;
+        w.path.forEach((nx, j) => {
+            w.path[j] = self.nodesLookup[nx.id];
+            let n = w.path[j];
+            n.ways.forEach((wid, i) => { if (wid === oldId)
+                n.ways[i] = newId; });
+            n.ways = [...new Set(n.ways)];
+        });
+        if (replaceLookup)
+            this.waysLookup[newId] = w;
+        delete this.waysLookup[oldId];
+        return w;
+    }
+    ;
+    _checkRoundabouts() {
+        let roundaboutsStrict = [];
+        let roundaboutsImplicit = [];
+        let self = this;
+        try {
+            this.ways.forEach(way => {
+                if (isRoundabout(way, true)) {
+                    let ways = self._collectRoundabout(way);
+                    let id = MapAreaService._generateID(ways);
+                    let found = roundaboutsStrict.find(e => e.id === id);
+                    if (!found) {
+                        found = (way.path[0].id === way.path[way.path.length - 1].id);
+                        if (found) {
+                            roundaboutsImplicit.push(way);
+                        }
+                    }
+                    if (!found)
+                        roundaboutsStrict.push({ id, ways });
+                }
+                else if (isRoundabout(way, false)) {
+                    roundaboutsImplicit.push(way);
+                }
+            });
+            this.logger.debug('_checkRoundabouts: found roundabouts:', roundaboutsStrict);
+            roundaboutsStrict.forEach(ri => {
+                let originalNodes = [];
+                ri.ways.forEach((wid, i) => {
+                    let way = self.waysLookup[wid];
+                    let path = way.path;
+                    path.forEach(n => {
+                        if (originalNodes.length === 0 ||
+                            originalNodes[originalNodes.length - 1] !== n.id)
+                            originalNodes.push(n.id);
+                    });
+                });
+                ri.ways.forEach((wid, i) => {
+                    let way = self.waysLookup[wid];
+                    self._replaceWayID(way, ri.id, i === 0);
+                });
+                let roundabout = self.waysLookup[ri.id];
+                roundabout.path = [];
+                originalNodes.forEach(nid => {
+                    let node = self.nodesLookup[nid];
+                    roundabout.path.push(node);
+                });
+                roundabout.tags.roundabout = true;
+            });
+            roundaboutsImplicit.forEach(roundabout => {
+                if (roundabout.tags === undefined)
+                    roundabout.tags = {};
+                roundabout.tags.roundabout = true;
+            });
+        }
+        catch (error) {
+            this.logger.logEvent({ message: 'Error', error });
+        }
+    }
+    setLocation(location, reload, onLoaded) {
+        this.location = location;
+        if (location === undefined) {
+            if (onLoaded)
+                onLoaded('failure', this.ways, this.openmapData);
+            return;
+        }
+        if (reload) {
+            this.boundary = MapAreaService._getBoundary(this.location, this.radius);
+            this.load(onLoaded);
+            this.center = this.location;
+        }
+        else {
+            if (onLoaded)
+                onLoaded('success', this.ways, this.openmapData);
+        }
+    }
+    _buildQuery(template) {
+        if (template === undefined)
+            return;
+        return template.replace('__boundary__', MapAreaService._boundaryToString(this.boundary));
+    }
+    getNearestPath(point) {
+        return MapAreaService._getNearestPath(point, this.ways);
+    }
+    static _getNearestPath(point, ways) {
+        if (ways === undefined || point === undefined)
+            return;
+        let w;
+        let min = { path: undefined, distance: undefined, way: undefined };
+        for (w of ways) {
+            let distance = MapAreaService._distanceToPath(point, w);
+            if (distance !== undefined && (min.distance === undefined || distance < min.distance)) {
+                min.distance = distance;
+                min.path = w.path;
+                min.way = w;
+            }
+        }
+        return min;
+    }
+    static _isWithinRange(distance) {
+        return abs(distance) < MAX_DISTANCE_FROM_PATH;
+    }
+    static _isOnPath(point, way) {
+        if (point === undefined || point.lat === undefined || point.lng === undefined
+            || way === undefined || way.path === undefined || way.path.length === 0)
+            return false;
+        return MapAreaService._distanceToPath(point, way) < MAX_DISTANCE_FROM_PATH;
+    }
+    static _isBetween(point, p1, p2) {
+        if (point === undefined || p1 === undefined || p2 === undefined ||
+            point.lat === undefined || point.lng === undefined ||
+            p1.lat === undefined || p1.lng === undefined ||
+            p2.lat === undefined || p2.lng === undefined)
+            return undefined;
+        let d = geo.distanceBetween(p1, point);
+        let bDest = initialBearingTo(p1, p2);
+        let bPoint = initialBearingTo(p1, point);
+        let angle = bPoint - bDest;
+        if (abs(angle) > 30)
+            return { between: false, offset: d };
+        let dP2 = geo.distanceBetween(p1, p2);
+        let offset = abs(d * sin(angle));
+        if (offset < MAX_DISTANCE_FROM_PATH && dP2 > d) {
+            return { between: true, offset };
+        }
+        return { between: false, offset: (dP2 - d) };
+    }
+    static _distanceToPath(point, way) {
+        if (point === undefined || point.lat === undefined || point.lng === undefined
+            || way === undefined || way.path === undefined || way.path.length === 0)
+            return undefined;
+        let minDistance;
+        let minIdx = -1;
+        let prev;
+        let foundExact = false;
+        way.path.forEach((element, idx) => {
+            if (element.lat === point.lat && element.lng === point.lng) {
+                minDistance = 0;
+                foundExact = true;
+                return;
+            }
+            if (foundExact)
+                return;
+            if (prev !== undefined) {
+                let res = MapAreaService._isBetween(point, prev, element);
+                if (res && res.between) {
+                    minDistance = res.offset;
+                    foundExact = true;
+                    return;
+                }
+            }
+            let distance = geo.distanceBetween(element, point);
+            if (minDistance === undefined || distance < minDistance) {
+                minDistance = distance;
+                minIdx = idx;
+            }
+            prev = element;
+        });
+        if (foundExact)
+            return minDistance;
+        if (minIdx > 0) {
+            const alpha = initialBearingTo(way.path[minIdx - 1], way.path[minIdx]);
+            const alpha2 = initialBearingTo(way.path[minIdx - 1], point);
+            let beta = alpha2 - alpha;
+            if (beta > 270)
+                beta -= 360;
+            if ((beta > -90 && beta < 90)) {
+                const dist = sin(abs(beta)) * geo.distanceBetween(way.path[minIdx - 1], point);
+                const distPath = cos(abs(beta)) * geo.distanceBetween(way.path[minIdx - 1], point);
+                if (dist < minDistance && distPath > 0 && distPath < geo.distanceBetween(way.path[minIdx - 1], way.path[minIdx]))
+                    minDistance = dist;
+            }
+        }
+        if (minIdx < way.path.length - 2) {
+            const alpha = initialBearingTo(way.path[minIdx], way.path[minIdx + 1]);
+            let beta = initialBearingTo(way.path[minIdx], point) - alpha;
+            if (beta > 270)
+                beta -= 360;
+            if ((beta > -90 && beta < 90)) {
+                const dist = sin(abs(beta)) * geo.distanceBetween(way.path[minIdx], point);
+                const distPath = cos(abs(beta)) * geo.distanceBetween(way.path[minIdx], point);
+                if (dist < minDistance && distPath > 0 && distPath < geo.distanceBetween(way.path[minIdx], way.path[minIdx + 1]))
+                    minDistance = dist;
+            }
+        }
+        return minDistance;
+    }
+    static addNode(node, nodesLookup, id, path) {
+        let point = nodesLookup[node];
+        if (point !== undefined)
+            path.push(point);
+        if (point.ways === undefined)
+            point.ways = [];
+        let found = point.ways.find((e) => { return e === id; });
+        if (found === undefined)
+            nodesLookup[node].ways.push(id);
+    }
+    static addWay(w, ways, waysLookup) {
+        if (waysLookup[w.id] !== undefined)
+            ways = ways.filter(e => e.id !== w.id);
+        ways.push(w);
+        waysLookup[w.id] = w;
+    }
+    static updateTypeStats(types, type) {
+        let t = (type === undefined ? '-' : type);
+        if (types[t] !== undefined)
+            types[t]++;
+        else
+            types[t] = 1;
+    }
+    static _parse(str, filter) {
+        if (str === undefined)
+            return;
+        let data;
+        if (typeof (str) === 'string') {
+            try {
+                data = JSON.parse(str);
+            }
+            catch (error) {
+                return;
+            }
+        }
+        else {
+            data = str;
+        }
+        if (data.elements === undefined)
+            return;
+        let nodesLookup = [];
+        let waysLookup = [];
+        let ways = [];
+        let types = [];
+        let idx = 0;
+        let id;
+        data.elements.forEach(element => {
+            if (element.type === 'node') {
+                id = (element.id !== undefined && typeof element.id === 'number') ? id = element.id.toString() : '_INT_' + idx;
+                nodesLookup[element.id] = { id, lat: element.lat, lng: element.lon, tags: element.tags };
+                idx++;
+            }
+        });
+        idx = 0;
+        data.elements.forEach(element => {
+            let path = [];
+            if (element.type === 'way') {
+                id = (element.id !== undefined && typeof element.id === 'number') ? id = element.id.toString() : '_INT_' + idx;
+                let type = undefined;
+                let name = undefined;
+                if (element.tags !== undefined) {
+                    name = element.tags.name;
+                    type = element.tags.highway;
+                }
+                if (type !== undefined && (filter === undefined || filter.find(e => e === type) === undefined)) {
+                    element.nodes.forEach(node => {
+                        MapAreaService.addNode(node, nodesLookup, id, path);
+                    });
+                    MapAreaService.updateTypeStats(types, type);
+                    MapAreaService.addWay({ id, path, type, name, tags: element.tags, bounds: element.bounds }, ways, waysLookup);
+                    idx++;
+                }
+            }
+        });
+        return { ways, nodesLookup, waysLookup, typeStats: types };
+    }
+    splitAtFirstBranch(way) {
+        if (way === undefined || way.path === undefined)
+            return;
+        let result = {
+            way: { id: way.id, path: [] },
+            branches: []
+        };
+        try {
+            let self = this;
+            let pointInfo = getFirstBranch(way);
+            if (pointInfo !== undefined) {
+                let paths = splitAtPointInfo(way, pointInfo);
+                result.way.path = paths[0];
+                let branch = { id: way.id, path: paths[1] };
+                if (branch.path.length > 1)
+                    result.branches.push(branch);
+                pointInfo.point.ways.forEach((wid) => {
+                    let w = clone(self.waysLookup[wid]);
+                    if (w !== undefined && w.id !== way.id) {
+                        if (w.path[0].id === pointInfo.point.id) {
+                            branch = getUntilFirstBranch(w, { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                        else if (w.path[w.path.length - 1].id === pointInfo.point.id) {
+                            w.path.reverse();
+                            branch = getUntilFirstBranch(w, { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                        else {
+                            let branches = splitAtPoint(w, pointInfo.point);
+                            branch = getUntilFirstBranch(branches[0], { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                            branch = getUntilFirstBranch(branches[1], { ignore: way.id });
+                            if (branch.path.length > 1)
+                                result.branches.push(branch);
+                        }
+                    }
+                });
+            }
+            else {
+                result.way.path = [...way.path];
+            }
+        }
+        catch (error) {
+            this.logger.logEvent({ message: 'error', fn: 'splitAtFirstBranch()', way, error: error.message, stack: error.stack });
+            result = undefined;
+        }
+        return result;
+    }
+    getWay(props) {
+        if (!props)
+            return;
+        if (typeof props === 'string') {
+            return clone(this.waysLookup[props]);
+        }
+        if (props.id !== undefined)
+            return clone(this.waysLookup[props.id]);
+    }
+    getNode(props) {
+        if (!props)
+            return this.location;
+        if (typeof props === 'string') {
+            return clone(this.nodesLookup[props]);
+        }
+        if (typeof props === 'object' && props.id === undefined && props.lat !== undefined && props.lng !== undefined && props.ways !== undefined) {
+            return clone(props);
+        }
+        if (props.id !== undefined) {
+            return clone(this.nodesLookup[props.id]);
+        }
+    }
+    copyWay(wayFrom, id) {
+        let w;
+        w = (id === undefined) ? this.getWay(wayFrom) : this.getWay(id);
+        let path = w.path;
+        let roundabout = isRoundabout(w);
+        if (!roundabout && wayFrom !== undefined && wayFrom.id === w.id) {
+            let idxPrev = undefined;
+            let idx = undefined;
+            let point = wayFrom.path[wayFrom.path.length - 1];
+            let prev = wayFrom.path[wayFrom.path.length - 2];
+            path.forEach((p, i) => {
+                if (idx === undefined || idxPrev === undefined) {
+                    if (pointEquals(p, point))
+                        idx = i;
+                    if (pointEquals(p, prev))
+                        idxPrev = i;
+                }
+            });
+            if (idx !== undefined && idxPrev !== undefined) {
+                if (idxPrev < idx)
+                    w.path = path.filter((n, i) => i >= idx);
+                if (idxPrev > idx) {
+                    w.path = path.filter((n, i) => i <= idx);
+                    w.path.reverse();
+                }
+            }
+        }
+        return { w, roundabout };
+    }
+    checkOptionsOnCurrentWay(location, way, options) {
+        try {
+            if (way.path.length > 1) {
+                let prev = way.path[way.path.length - 2];
+                let { w, roundabout } = this.copyWay(way);
+                if (roundabout) {
+                    let branches = this.splitWayAtPoint(w, location, way);
+                    branches.forEach(b => {
+                        if (b.path.length > 1 && b.path[1].id !== prev.id) {
+                            options.push(b);
+                        }
+                    });
+                }
+                else {
+                    if (w.path.length > 1) {
+                        let result = this.splitAtFirstBranch(w);
+                        options.push(result.way);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
+    splitWayAtPoint(w, location) {
+        return splitAtPoint(w, location);
+    }
+    checkOptionsOnDifferentWay(location, w, options) {
+        if (!w || !w.path || !location)
+            return;
+        let result;
+        let roundabout = isRoundabout(w);
+        let self = this;
+        if (!roundabout) {
+            if (w.path[0].id === location.id) {
+                result = this.splitAtFirstBranch(w);
+                let expand = false;
+                if (result.way.path.length === w.path.length) {
+                    const pLast = w.path[w.path.length - 1];
+                    if (pLast.ways.length === 2) {
+                        const wIdNext = pLast.ways.find(wid => wid !== w.id);
+                        const wNext = this.getWay({ id: wIdNext });
+                        if (!isRoundabout(wNext)) {
+                            const pNextStart = wNext.path[0];
+                            const pNextEnd = wNext.path[wNext.path.length - 1];
+                            if (pNextStart.id === pLast.id) {
+                                expand = true;
+                                const segment = this.splitAtFirstBranch(wNext);
+                                const combined = {
+                                    id: segment.way.id,
+                                    path: w.path.concat(segment.way.path.slice(1))
+                                };
+                                options.push(combined);
+                            }
+                            else if (pNextEnd.id === pLast.id) {
+                                const wReverse = this.copyWay(wNext);
+                                if (wReverse && wReverse.path) {
+                                    wReverse.path = wReverse.path.reverse();
+                                    const segment = this.splitAtFirstBranch(wNext);
+                                    const combined = {
+                                        id: segment.way.id,
+                                        path: w.path.concat(segment.way.path.slice(1))
+                                    };
+                                    options.push(combined);
+                                }
+                                else {
+                                    console.log(' ~~~~ unexpected', wNext, wReverse);
+                                }
+                            }
+                            else {
+                                const idxSplit = wNext.path.findIndex((p) => p.id === pLast.id);
+                                if (idxSplit !== 1) {
+                                    const nextPaths = splitAtIndex(wNext, idxSplit);
+                                    nextPaths.forEach((p) => {
+                                        if (p[0].ways.find(wid => wid === w.id)) {
+                                            expand = true;
+                                            const wFull = {
+                                                id: wIdNext,
+                                                path: p.slice(1)
+                                            };
+                                            const segment = this.splitAtFirstBranch(wFull);
+                                            const combined = {
+                                                id: segment.way.id,
+                                                path: w.path.concat(segment.way.path.slice(1))
+                                            };
+                                            options.push(combined);
+                                        }
+                                        else if (p[p.length - 1].ways.find(wid => wid === w.id)) {
+                                            expand = true;
+                                            const wFull = {
+                                                id: wIdNext,
+                                                path: p.reverse()
+                                            };
+                                            const segment = this.splitAtFirstBranch(wFull);
+                                            const combined = {
+                                                id: segment.way.id,
+                                                path: w.path.concat(segment.way.path.slice(1))
+                                            };
+                                            options.push(combined);
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+                if (!expand)
+                    options.push(result.way);
+            }
+            else if (w.path[w.path.length - 1].id === location.id) {
+                w.path.reverse();
+                result = this.splitAtFirstBranch(w);
+                if (isOneWay(w))
+                    result.way.onewayReverse = true;
+                options.push(result.way);
+            }
+            else {
+                let ways = splitAtPoint(w, location);
+                if (!ways[0].onewayReverse) {
+                    result = this.splitAtFirstBranch(ways[0]);
+                    options.push(result.way);
+                }
+                if (!ways[1].onewayReverse) {
+                    result = this.splitAtFirstBranch(ways[1]);
+                    options.push(result.way);
+                }
+            }
+        }
+        else {
+            let r = splitAtPoint(w, location);
+            if (!r || r.length === 0)
+                return;
+            let path = [];
+            r[0].path.forEach((p, idx) => {
+                if (idx === 0) {
+                    path.push(p);
+                    return;
+                }
+                if (p.ways.length > 1) {
+                    p.ways.forEach(owid => {
+                        if (owid !== w.id) {
+                            let ow = clone(this.waysLookup[owid]);
+                            if (ow !== undefined) {
+                                if (!isAllowed(ow, p))
+                                    return;
+                                if (ow.path[ow.path.length - 1].id === p.id)
+                                    ow.path.reverse();
+                                let optPath1 = self.splitAtFirstBranch(ow);
+                                let optPath = [...path];
+                                optPath.push(...optPath1.way.path);
+                                let o = {
+                                    roundabout: w.id,
+                                    id: ow.id,
+                                    path: optPath
+                                };
+                                options.push(o);
+                            }
+                        }
+                    });
+                }
+                path.push(p);
+            });
+        }
+        return this.removeDuplicates(options);
+    }
+    removeDuplicates(options) {
+        const endPoints = [];
+        const unique = [];
+        const uniqueUsed = [];
+        options.forEach((o) => { endPoints.push(o.path[o.path.length - 1].id); });
+        endPoints.forEach((id) => {
+            if (unique.indexOf(id) < 0) {
+                unique.push(id);
+                uniqueUsed.push(false);
+            }
+        });
+        return options.filter((o) => {
+            const id = o.path[o.path.length - 1].id;
+            const idx = unique.indexOf(id);
+            if (idx >= 0 && !uniqueUsed[idx]) {
+                uniqueUsed[idx] = true;
+                return true;
+            }
+            return false;
+        });
+    }
+    _getNextOptions(loc, way, way1, status) {
+        let self = this;
+        let location = self.getNode(loc);
+        let options = [];
+        if (location !== undefined) {
+            location.ways.forEach((wid, idx) => {
+                if (wid === way.id) {
+                    self.checkOptionsOnCurrentWay(location, way, options);
+                }
+                else if (way1 !== undefined && wid === way1.id) {
+                }
+                else {
+                    let w = self.getWay(wid);
+                    options = self.checkOptionsOnDifferentWay(location, w, options);
+                }
+            });
+        }
+        return options;
+    }
+    getNextOptions(way, way1 = undefined, reload = false, props) {
+        return new Promise((resolve, reject) => {
+            if (way === undefined || way.id === undefined || way.path === undefined || way.path.length < 1)
+                return reject({ retry: false, message: 'invalid arguments' });
+            let self = this;
+            let location = way.path[way.path.length - 1];
+            if (location.id === undefined) {
+                if (way.path.length > 1)
+                    location = way.path[way.path.length - 2];
+                else {
+                    return resolve([]);
+                }
+            }
+            let currentWay = way;
+            if (way.path[0].id === undefined) {
+                currentWay = this.copyWay(way);
+            }
+            if (props && props.mapReload === false) {
+                resolve(self._getNextOptions(location, currentWay, way1));
+            }
+            else {
+                this.setLocation(location, reload, (status, ways, data) => {
+                    if (status !== 'success') {
+                        reject({ retry: true, code: 1, message: 'could not load data' });
+                    }
+                    resolve(self._getNextOptions(location, currentWay, way1));
+                });
+            }
+        });
+    }
+    static _isCrossing(way1, way2, exact = true) {
+        let found = [];
+        let pPrev = undefined;
+        let distance = 0;
+        way1.path.forEach((p, idx) => {
+            if (pPrev !== undefined) {
+                distance += geo.distanceBetween(pPrev, p);
+            }
+            if (p.ways.find(e => e === way2.id) !== undefined) {
+                let x = JSON.parse(JSON.stringify(p));
+                x.distance = Number(Number.parseFloat(distance).toFixed());
+                found.push(x);
+            }
+            pPrev = p;
+        });
+        return found;
+    }
+    static _crossing(A, B, C, D, exact = true) {
+        let AB = getVector(A, B);
+        let CD = getVector(C, D);
+        let AC = getVector(A, C);
+        A.distance = 0;
+        B.distance = geo.distanceBetween(A, B);
+        if (MapAreaService._isWithinRange(geo.distanceBetween(A, C)))
+            return A;
+        if (MapAreaService._isWithinRange(geo.distanceBetween(A, D)))
+            return A;
+        if (MapAreaService._isWithinRange(geo.distanceBetween(B, C)))
+            return B;
+        if (MapAreaService._isWithinRange(geo.distanceBetween(B, D)))
+            return B;
+        let V = crossing(AB, CD, AC);
+        if (V === undefined)
+            return undefined;
+        let p1Len = AB.len();
+        let distance = V.len();
+        if (AB.isSameDirection(V) && (distance < p1Len || MapAreaService._isWithinRange(p1Len - distance))) {
+            let X = geo.getPointBetween(A, B, distance);
+            let CX = getVector(C, X);
+            if (!exact || (CX.len() < CD.len() || MapAreaService._isWithinRange(CD.len() - CX.len))) {
+                X.distance = distance;
+                return X;
+            }
+        }
+        return undefined;
+    }
+    static _getBoundary(location, radius) {
+        return getBounds(location.lat, location.lng, radius);
+    }
+    isWithinBoundary(location) {
+        return isWithinBoundary(location, this.boundary);
+    }
+    static _generateQuery(location, radius) {
+        const boundary = MapAreaService._getBoundary(location, radius);
+        const template = GET_WAYS_IN_AREA;
+        return template.replace('__boundary__', MapAreaService._boundaryToString(boundary));
+    }
+    static _boundaryToString(boundary) {
+        if (boundary === undefined)
+            return 'undefined';
+        let ne = boundary.northeast;
+        let sw = boundary.southwest;
+        if (ne !== undefined && (ne.lat === undefined || ne.lng === undefined))
+            return 'error: northeast incorrect';
+        if (sw !== undefined && (sw.lat === undefined || sw.lng === undefined))
+            return 'error: southwest incorrect';
+        if (ne === undefined)
+            ne = sw;
+        if (sw === undefined)
+            sw = ne;
+        if (sw === undefined)
+            return 'undefined';
+        let str = sw.lat + ',' + sw.lng + ',' + ne.lat + ',' + ne.lng;
+        return str;
+    }
+}
+MapAreaService.consts = { DEFAULT_RADIUS, DEFAULT_MIN_WAYS, DEFAULT_MAX_WAYS, MAX_DISTANCE_FROM_PATH, GET_WAYS_IN_AREA };
+MapAreaService._instances = {};
+exports.default = MapAreaService;
+function splitAtPointInfo(way, pointInfo) {
+    if (!way)
+        return;
+    let path = way.path;
+    let result = [[], []];
+    let foundBranch2 = false;
+    path.forEach((p, idx) => {
+        if (idx <= pointInfo.idx)
+            result[0].push(p);
+        if (idx === pointInfo.idx) {
+            result[1].push(p);
+        }
+        if (!foundBranch2 && idx > pointInfo.idx && p.ways.length === 1)
+            result[1].push(p);
+        if (!foundBranch2 && idx > pointInfo.idx && p.ways.length > 1) {
+            if (findAdditional(pointInfo.branches, p.ways, way.id, (id1, id2) => (id1 === id2)) !== undefined)
+                foundBranch2 = true;
+            result[1].push(p);
+        }
+    });
+    return result;
+}
+exports.splitAtPointInfo = splitAtPointInfo;
+function getUntilFirstBranch(w, props) {
+    if (!w)
+        return;
+    let reverse = (props !== undefined) ? props.reverse : false;
+    let ignore = (props !== undefined) ? props.ignore : undefined;
+    let branch;
+    let path = w.path;
+    if (reverse) {
+        w.path = [...path];
+        w.path.reverse();
+        path = w.path;
+    }
+    let piBranch = getFirstBranch(w, ignore);
+    if (piBranch !== undefined) {
+        branch = { id: w.id, path: [] };
+        path.forEach((p, idx) => {
+            if (idx <= piBranch.idx)
+                branch.path.push(p);
+        });
+    }
+    else {
+        branch = { id: w.id, path: w.path };
+    }
+    return branch;
+}
+exports.getUntilFirstBranch = getUntilFirstBranch;
+function isRoundabout(w, strictCheck = false) {
+    if (!w)
+        return;
+    let roundabout = (w.tags !== undefined && (w.tags.roundabout === true || w.tags.junction === 'roundabout'));
+    if (roundabout)
+        return true;
+    if (strictCheck)
+        return false;
+    if (w.path === undefined || w.path.length < 2)
+        return false;
+    roundabout = (w.path[0].id === w.path[w.path.length - 1].id);
+    return roundabout;
+}
+exports.isRoundabout = isRoundabout;
+function splitAtIndex(way, idxSplit) {
+    let path = way.path;
+    let result = [[], []];
+    path.forEach((p, idx) => {
+        if (idx <= idxSplit)
+            result[0].push(p);
+        if (idx >= idxSplit)
+            result[1].push(p);
+    });
+    return result;
+}
+exports.splitAtIndex = splitAtIndex;
+function splitAtPoint(way, point) {
+    let path = way.path;
+    let result = [{ id: way.id, path: [] }, { id: way.id, path: [] }];
+    let found = false;
+    let roundabout = isRoundabout(way);
+    if (!roundabout) {
+        path.forEach((p, idx) => {
+            if (!found)
+                result[0].path.push(p);
+            if (!found)
+                found = pointEquals(p, point);
+            if (found)
+                result[1].path.push(p);
+        });
+        result[0].path.reverse();
+        if (isOneWay(way))
+            result[0].onewayReverse = true;
+    }
+    else {
+        let idx = undefined;
+        path.forEach((p, i) => {
+            if (!found) {
+                found = pointEquals(p, point);
+                if (found)
+                    idx = i;
+            }
+        });
+        if (idx !== undefined) {
+            let i;
+            for (i = 0; i < path.length; i++) {
+                let len = path.length;
+                let p = path[(idx + i) % len];
+                let q = path[(idx - i + len) % len];
+                if (result[0].path.length === 0 ||
+                    (p.id !== result[0].path[result[0].path.length - 1].id && p.id !== result[0].path[0].id))
+                    result[0].path.push(p);
+                if (result[1].path.length === 0 ||
+                    (q.id !== result[1].path[result[1].path.length - 1].id && q.id !== result[1].path[0].id))
+                    result[1].path.push(q);
+            }
+            if (isOneWay(way)) {
+                result[1].onewayReverse = true;
+            }
+        }
+        else {
+            return ([]);
+        }
+    }
+    return result;
+}
+exports.splitAtPoint = splitAtPoint;
+function pointEquals(p1, p2) {
+    if (p1 === undefined || p2 === undefined)
+        return false;
+    return (p1.id === p2.id || (p1.lat !== undefined && p1.lng !== undefined && p1.lat === p2.lat && p1.lng === p2.lng));
+}
+exports.pointEquals = pointEquals;
+function isWay(p) {
+    if (p === undefined || p === null || p.id === undefined || p.path === undefined || p.tags === undefined)
+        return false;
+    return true;
+}
+exports.isWay = isWay;
+function isNode(p) {
+    if (p === undefined || p === null || p.id === undefined || p.lat === undefined || p.lng === undefined || p.ways === undefined)
+        return false;
+    return true;
+}
+exports.isNode = isNode;
+function isAllowed(way, from, to) {
+    if (isNode(from) && isWay(way)) {
+        const fromIdx = way.path.findIndex(p => p.id === from.id);
+        if (fromIdx !== -1 && !isOneWay(way))
+            return true;
+        let p0 = way.path[0];
+        let pN = way.path[way.path.length - 1];
+        if (from.id === p0.id)
+            return true;
+        if (from.id !== p0.id && from.id === pN.id)
+            return !isOneWay(way);
+        if (isNode(to) && to.id === pN.id)
+            return true;
+        if (isNode(from) && isNode(to)) {
+            const toId = way.path.findIndex(p => p.id === to.id);
+            if (fromIdx === -1 || toId === -1)
+                return;
+            return !isOneWay(way) || fromIdx < toId;
+        }
+    }
+    return undefined;
+}
+exports.isAllowed = isAllowed;
+function isOneWay(way) {
+    if (!way || !way.tags || !way.tags.oneway)
+        return false;
+    let ow = way.tags.oneway;
+    return (ow === true || ow === 'yes');
+}
+exports.isOneWay = isOneWay;
+function getFirstBranch(way, ignore) {
+    if (way === undefined || way.path === undefined)
+        return;
+    let pFound = undefined;
+    way.path.forEach((p, idx) => {
+        if (idx === 0)
+            return;
+        let ways = [];
+        p.ways.forEach((w) => {
+            if (ignore === undefined || w !== ignore)
+                ways.push(w);
+        });
+        if (!pFound && p.ways !== undefined && ways.length > 1) {
+            let branches = [];
+            ways.forEach(pw => {
+                if (pw !== way.id)
+                    branches.push(pw);
+            });
+            pFound = { point: p, idx, branches };
+        }
+    });
+    return pFound;
+}
+exports.getFirstBranch = getFirstBranch;
+function findAdditional(a1, a2, id3, fn) {
+    let res = [];
+    a1.forEach(e1 => {
+        a2.forEach(e2 => {
+            if (!fn(e1, e2) && !fn(e1, id3) && !fn(e2, id3))
+                res.push(e2);
+        });
+    });
+    if (res.length === 0)
+        return undefined;
+    return res;
+}
+exports.findAdditional = findAdditional;
+function _getPointOnLine(point, p1, p2) {
+    let bL = initialBearingTo(p1, p2);
+    let bP = bL + 90;
+    let p3 = destinationPoint(point, 100, bP);
+    return MapAreaService._crossing(p1, p2, point, p3, false);
+}
+exports._getPointOnLine = _getPointOnLine;
+function getPointCrossingPath(point, path, closest = false) {
+    let pPrev = undefined;
+    let X = undefined;
+    let pClosest = undefined;
+    if (path === undefined)
+        return undefined;
+    path.forEach((p, i) => {
+        let pDist = abs(geo.distanceBetween(p, point));
+        if (pClosest === undefined || pClosest.distance > pDist) {
+            pClosest = { distance: pDist, point: p, idx: i };
+        }
+        if (pPrev !== undefined) {
+            let pX = _getPointOnLine(point, pPrev, p);
+            if (pX !== undefined) {
+                let dist = abs(geo.distanceBetween(pX, point));
+                if (X === undefined || (X.distance > dist)) {
+                    X = { point: pX, distance: dist, idx: i };
+                }
+            }
+        }
+        pPrev = p;
+    });
+    if (X !== undefined) {
+        return X;
+    }
+    else {
+        if (closest)
+            return pClosest;
+    }
+}
+exports.getPointCrossingPath = getPointCrossingPath;
+function getCrossingInfo(way1, way2) {
+    if (way1 === undefined || way1.path === undefined || way2 === undefined || way2.path === undefined)
+        return;
+    let crossing = undefined;
+    way1.path.forEach((p1, i) => {
+        way2.path.forEach((p2, j) => {
+            if (crossing === undefined && p1.id === p2.id) {
+                crossing = { point: p1, idx1: i, idx2: j };
+            }
+        });
+    });
+    return crossing;
+}
+exports.getCrossingInfo = getCrossingInfo;
+function getVector(p1, p2) {
+    if (p1 === undefined)
+        throw new Error("missing mandatory argument: p1");
+    if (p2 === undefined)
+        throw new Error("missing mandatory argument: p2");
+    let distance = geo.distanceBetween(p1, p2);
+    if (distance === 0) {
+        return new Vector([0, 0]);
+    }
+    let bearing = initialBearingTo(p1, p2);
+    return new Vector({ path: { bearing, distance } });
+}
+exports.getVector = getVector;
+const rEarth = 6378.100;
+function getBounds(lat, lng, offset) {
+    const pi = Math.PI;
+    const m = (1 / ((2 * pi / 360) * rEarth)) / 1000;
+    let boundary = {
+        northeast: {},
+        southwest: {}
+    };
+    boundary.northeast.lat = lat + offset * m;
+    boundary.northeast.lng = lng + (offset * m) / Math.cos(lat * pi / 180);
+    boundary.southwest.lat = lat - offset * m;
+    boundary.southwest.lng = lng - (offset * m) / Math.cos(lat * pi / 180);
+    return boundary;
+}
+exports.getBounds = getBounds;
+function isWithinBoundary(location, boundary) {
+    if (location === undefined || location.lat === undefined || location.lng === undefined)
+        return false;
+    const lat = location.lat;
+    const lng = location.lng;
+    const sw = boundary.southwest;
+    const ne = boundary.northeast;
+    return (lat >= sw.lat && lat <= ne.lat && lng >= sw.lng && lng <= ne.lng);
+}
+exports.isWithinBoundary = isWithinBoundary;
+function initialBearingTo(p1, p2) {
+    if (p1 === undefined || p2 === undefined || (p1.lat === p2.lat && p1.lng === p2.lng))
+        return;
+    const φ1 = rad(p1.lat);
+    const φ2 = rad(p2.lat);
+    const Δλ = rad(p2.lng - p1.lng);
+    const x = Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(Δλ);
+    const y = Math.sin(Δλ) * Math.cos(φ2);
+    const θ = Math.atan2(y, x);
+    const bearing = degrees(θ);
+    return bearing;
+}
+exports.initialBearingTo = initialBearingTo;
+function alongTrackDistanceTo(point, pathStart, pathEnd, radius = rEarth * 1000) {
+    if (point === undefined || pathStart === undefined || pathEnd === undefined)
+        return;
+    const R = radius;
+    const δ13 = geo.calculateDistance(pathStart.lat, pathStart.lng, point.lat, point.lng, R) / R;
+    const θ13 = rad(initialBearingTo(pathStart, point));
+    const θ12 = rad(initialBearingTo(pathStart, pathEnd));
+    const δxt = Math.asin(Math.sin(δ13) * Math.sin(θ13 - θ12));
+    const δat = Math.acos(Math.cos(δ13) / Math.abs(Math.cos(δxt)));
+    let d = δat * Math.sign(Math.cos(θ12 - θ13)) * R;
+    return d;
+}
+exports.alongTrackDistanceTo = alongTrackDistanceTo;
+function destinationPoint(start, distance, bearing, radius = rEarth * 1000) {
+    const δ = distance / radius;
+    const θ = rad(bearing);
+    const φ1 = rad(start.lat), λ1 = rad(start.lng);
+    const sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+    const φ2 = Math.asin(sinφ2);
+    const y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+    const x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+    const λ2 = λ1 + Math.atan2(y, x);
+    const lat = degrees(φ2);
+    const lng = degrees(λ2);
+    return { lat, lng };
+}
+exports.destinationPoint = destinationPoint;
+const useMapArea = (id) => MapAreaService.getInstance(id);
+exports.useMapArea = useMapArea;