osm2geojson-lite 0.8.13 → 0.9.0

package/ts/release/osmobjs.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+const polytags_json_1 = require("./polytags.json");
+class OsmObject {
+    constructor(type, id, refElems) {
+        this.type = type;
+        this.id = id;
+        this.refElems = refElems;
+        this.tags = {};
+        this.props = { id: this.getCompositeId() };
+        this.refCount = 0;
+        this.hasTag = false;
+        if (refElems) {
+            refElems.add(this.getCompositeId(), this);
+        }
+    }
+    addTags(tags) {
+        this.tags = Object.assign(this.tags, tags);
+        this.hasTag = tags ? true : false;
+    }
+    addTag(k, v) {
+        this.tags[k] = v;
+        this.hasTag = k ? true : false;
+    }
+    addProp(k, v) {
+        this.props[k] = v;
+    }
+    addProps(props) {
+        this.props = Object.assign(this.props, props);
+    }
+    getCompositeId() {
+        return `${this.type}/${this.id}`;
+    }
+    getProps() {
+        return Object.assign(this.props, this.tags);
+    }
+    toFeatureArray() {
+        return [];
+    }
+}
+class Node extends OsmObject {
+    constructor(id, refElems) {
+        super('node', id, refElems);
+        this.latLng = null;
+    }
+    setLatLng(latLng) {
+        this.latLng = latLng;
+    }
+    toFeatureArray() {
+        if (this.latLng) {
+            return [{
+                    type: 'Feature',
+                    id: this.getCompositeId(),
+                    properties: this.getProps(),
+                    geometry: {
+                        type: 'Point',
+                        coordinates: utils_1.strToFloat([this.latLng.lon, this.latLng.lat]),
+                    },
+                }];
+        }
+        return [];
+    }
+    getLatLng() {
+        return this.latLng;
+    }
+}
+exports.Node = Node;
+class Way extends OsmObject {
+    constructor(id, refElems) {
+        super('way', id, refElems);
+        this.latLngArray = [];
+        this.isPolygon = false;
+    }
+    addLatLng(latLng) {
+        this.latLngArray.push(latLng);
+    }
+    setLatLngArray(latLngArray) {
+        this.latLngArray = latLngArray;
+    }
+    addNodeRef(ref) {
+        const binder = new utils_2.LateBinder(this.latLngArray, function (id) {
+            const node = this.refElems.get(`node/${id}`);
+            if (node) {
+                node.refCount++;
+                return node.getLatLng();
+            }
+        }, this, [ref]);
+        this.latLngArray.push(binder);
+        this.refElems.addBinder(binder);
+    }
+    addTags(tags) {
+        super.addTags(tags);
+        for (const [k, v] of Object.entries(tags)) {
+            this.analyzeTag(k, v);
+        }
+    }
+    addTag(k, v) {
+        super.addTag(k, v);
+        this.analyzeTag(k, v);
+    }
+    toCoordsArray() {
+        return this.latLngArray.map((latLng) => [latLng.lon, latLng.lat]);
+    }
+    toFeatureArray() {
+        let coordsArray = this.toCoordsArray();
+        if (coordsArray.length > 1) {
+            coordsArray = utils_1.strToFloat(coordsArray);
+            const feature = {
+                type: 'Feature',
+                id: this.getCompositeId(),
+                properties: this.getProps(),
+                geometry: {
+                    type: 'LineString',
+                    coordinates: coordsArray,
+                },
+            };
+            if (this.isPolygon && utils_1.isRing(coordsArray)) {
+                if (utils_1.ringDirection(coordsArray) !== 'counterclockwise') {
+                    coordsArray.reverse();
+                }
+                feature.geometry = {
+                    type: 'Polygon',
+                    coordinates: [coordsArray],
+                };
+                return [feature];
+            }
+            return [feature];
+        }
+        return [];
+    }
+    analyzeTag(k, v) {
+        const o = polytags_json_1.default[k];
+        if (o) {
+            this.isPolygon = true;
+            if (o.whitelist) {
+                this.isPolygon = o.whitelist.indexOf(v) >= 0 ? true : false;
+            }
+            else if (o.blacklist) {
+                this.isPolygon = o.blacklist.indexOf(v) >= 0 ? false : true;
+            }
+        }
+    }
+}
+exports.Way = Way;
+class Relation extends OsmObject {
+    constructor(id, refElems) {
+        super('relation', id, refElems);
+        this.relations = [];
+        this.nodes = [];
+        this.bounds = undefined;
+    }
+    setBounds(bounds) {
+        this.bounds = bounds;
+    }
+    addMember(member) {
+        switch (member.type) {
+            // super relation, need to do combination
+            case 'relation':
+                let binder = new utils_2.LateBinder(this.relations, function (id) {
+                    const relation = this.refElems.get(`relation/${id}`);
+                    if (relation) {
+                        relation.refCount++;
+                        return relation;
+                    }
+                }, this, [member.ref]);
+                this.relations.push(binder);
+                this.refElems.addBinder(binder);
+                break;
+            case 'way':
+                if (!member.role) {
+                    member.role = '';
+                }
+                let ways = this[member.role];
+                if (!ways) {
+                    ways = this[member.role] = [];
+                }
+                if (member.geometry) {
+                    const way = new Way(member.ref, this.refElems);
+                    way.setLatLngArray(member.geometry);
+                    way.refCount++;
+                    ways.push(way);
+                }
+                else if (member.nodes) {
+                    const way = new Way(member.ref, this.refElems);
+                    for (const nid of member.nodes) {
+                        way.addNodeRef(nid);
+                    }
+                    way.refCount++;
+                    ways.push(way);
+                }
+                else {
+                    binder = new utils_2.LateBinder(ways, function (nid) {
+                        const way = this.refElems.get(`way/${nid}`);
+                        if (way) {
+                            way.refCount++;
+                            return way;
+                        }
+                    }, this, [member.ref]);
+                    ways.push(binder);
+                    this.refElems.addBinder(binder);
+                }
+                break;
+            case 'node':
+                let node = null;
+                if (member.lat && member.lon) {
+                    node = new Node(member.ref, this.refElems);
+                    node.setLatLng({ lon: member.lon, lat: member.lat });
+                    if (member.tags) {
+                        node.addTags(member.tags);
+                    }
+                    for (const [k, v] of Object.entries(member)) {
+                        if (['id', 'type', 'lat', 'lon'].indexOf(k) < 0) {
+                            node.addProp(k, v);
+                        }
+                    }
+                    node.refCount++;
+                    this.nodes.push(node);
+                }
+                else {
+                    binder = new utils_2.LateBinder(this.nodes, function (id) {
+                        const nn = this.refElems.get(`node/${id}`);
+                        if (nn) {
+                            nn.refCount++;
+                            return nn;
+                        }
+                    }, this, [member.ref]);
+                    this.nodes.push(binder);
+                    this.refElems.addBinder(binder);
+                }
+            default:
+                break;
+        }
+    }
+    toFeatureArray() {
+        function constructStringGeometry(ws) {
+            const strings = ws ? ws.toStrings() : [];
+            if (strings.length > 0) {
+                if (strings.length === 1) {
+                    return {
+                        type: 'LineString',
+                        coordinates: strings[0],
+                    };
+                }
+                return {
+                    type: 'MultiLineString',
+                    coordinates: strings,
+                };
+            }
+            return null;
+        }
+        function constructPolygonGeometry(ows, iws) {
+            const outerRings = ows ? ows.toRings('counterclockwise') : [];
+            const innerRings = iws ? iws.toRings('clockwise') : [];
+            if (outerRings.length > 0) {
+                const compositPolyons = [];
+                let ring;
+                for (ring of outerRings) {
+                    compositPolyons.push([ring]);
+                }
+                // link inner polygons to outer containers
+                ring = innerRings.shift();
+                while (ring) {
+                    for (const idx in outerRings) {
+                        if (utils_1.ptInsidePolygon(utils_1.first(ring), outerRings[idx])) {
+                            compositPolyons[idx].push(ring);
+                            break;
+                        }
+                    }
+                    ring = innerRings.shift();
+                }
+                // construct the Polygon/MultiPolygon geometry
+                if (compositPolyons.length === 1) {
+                    return {
+                        type: 'Polygon',
+                        coordinates: compositPolyons[0],
+                    };
+                }
+                return {
+                    type: 'MultiPolygon',
+                    coordinates: compositPolyons,
+                };
+            }
+            return null;
+        }
+        const polygonFeatures = [];
+        const stringFeatures = [];
+        let pointFeatures = [];
+        const waysFieldNames = ['outer', 'inner', ''];
+        // need to do combination when there're nested relations
+        for (const relation of this.relations) {
+            if (relation) {
+                for (const fieldName of waysFieldNames) {
+                    const ways = relation[fieldName];
+                    if (ways) {
+                        const thisWays = this[fieldName];
+                        if (thisWays) {
+                            [].splice.apply(thisWays, [thisWays.length, 0].concat(ways));
+                        }
+                        else {
+                            this[fieldName] = ways;
+                        }
+                    }
+                }
+            }
+        }
+        for (const fieldName of waysFieldNames) {
+            const ways = this[fieldName];
+            if (ways) {
+                this[fieldName] = new utils_2.WayCollection();
+                for (const way of ways) {
+                    this[fieldName].addWay(way);
+                }
+            }
+        }
+        let geometry = null;
+        const feature = {
+            type: 'Feature',
+            id: this.getCompositeId(),
+            bbox: this.bounds,
+            properties: this.getProps(),
+            geometry: null,
+        };
+        if (!this.bounds) {
+            delete feature.bbox;
+        }
+        if (this.outer) {
+            geometry = constructPolygonGeometry(this.outer, this.inner);
+            if (geometry) {
+                feature.geometry = geometry;
+                polygonFeatures.push(feature);
+            }
+        }
+        else if (this['']) {
+            geometry = constructStringGeometry(this['']);
+            if (geometry) {
+                feature.geometry = geometry;
+                stringFeatures.push(feature);
+            }
+        }
+        for (const node of this.nodes) {
+            pointFeatures = pointFeatures.concat(node.toFeatureArray());
+        }
+        return [...polygonFeatures, ...stringFeatures, ...pointFeatures];
+    }
+}
+exports.Relation = Relation;

package/ts/release/utils.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function purgeProps(obj, blacklist) {
+    if (obj) {
+        const rs = Object.assign({}, obj);
+        if (blacklist) {
+            for (const prop of blacklist) {
+                delete rs[prop];
+            }
+        }
+        return rs;
+    }
+    return {};
+}
+exports.purgeProps = purgeProps;
+function mergeProps(obj1, obj2) {
+    obj1 = obj1 ? obj1 : {};
+    obj2 = obj2 ? obj2 : {};
+    return Object.assign(obj1, obj2);
+}
+exports.mergeProps = mergeProps;
+function addPropToFeature(f, k, v) {
+    if (f.properties && k && v) {
+        f.properties[k] = v;
+    }
+}
+exports.addPropToFeature = addPropToFeature;
+function addPropToFeatures(fs, k, v) {
+    for (const f of fs) {
+        addPropToFeature(f, k, v);
+    }
+}
+exports.addPropToFeatures = addPropToFeatures;
+exports.first = (a) => a[0];
+exports.last = (a) => a[a.length - 1];
+exports.coordsToKey = (a) => a.join(',');
+function addToMap(m, k, v) {
+    const a = m[k];
+    if (a) {
+        a.push(v);
+    }
+    else {
+        m[k] = [v];
+    }
+}
+exports.addToMap = addToMap;
+function removeFromMap(m, k, v) {
+    const a = m[k];
+    let idx = -1;
+    if (a) {
+        idx = a.indexOf(v);
+    }
+    if (idx >= 0) {
+        a.splice(idx, 1);
+    }
+}
+exports.removeFromMap = removeFromMap;
+function getFirstFromMap(m, k) {
+    const a = m[k];
+    if (a && a.length > 0) {
+        return a[0];
+    }
+    return undefined;
+}
+exports.getFirstFromMap = getFirstFromMap;
+// need 3+ different points to form a ring, here using > 3 is 'coz a the first and the last points are actually the same
+exports.isRing = (a) => a.length > 3 && exports.coordsToKey(exports.first(a)) === exports.coordsToKey(exports.last(a));
+exports.ringDirection = (a, xIdx, yIdx) => {
+    xIdx = xIdx || 0, yIdx = yIdx || 1;
+    // get the index of the point which has the maximum x value
+    const m = a.reduce((maxxIdx, v, idx) => a[maxxIdx][xIdx || 0] > v[xIdx || 0] ? maxxIdx : idx, 0);
+    // 'coz the first point is virtually the same one as the last point,
+    // we need to skip a.length - 1 for left when m = 0,
+    // and skip 0 for right when m = a.length - 1;
+    const l = m <= 0 ? a.length - 2 : m - 1;
+    const r = m >= a.length - 1 ? 1 : m + 1;
+    const xa = a[l][xIdx];
+    const xb = a[m][xIdx];
+    const xc = a[r][xIdx];
+    const ya = a[l][yIdx];
+    const yb = a[m][yIdx];
+    const yc = a[r][yIdx];
+    const det = (xb - xa) * (yc - ya) - (xc - xa) * (yb - ya);
+    return det < 0 ? 'clockwise' : 'counterclockwise';
+};
+exports.ptInsidePolygon = (pt, polygon, xIdx, yIdx) => {
+    xIdx = xIdx || 0, yIdx = yIdx || 1;
+    let result = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        if ((polygon[i][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[j][xIdx] ||
+            polygon[j][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[i][xIdx]) &&
+            pt[yIdx] < (polygon[j][yIdx] - polygon[i][yIdx]) * (pt[xIdx] - polygon[i][xIdx]) / (polygon[j][xIdx] - polygon[i][xIdx]) + polygon[i][yIdx]) {
+            result = !result;
+        }
+    }
+    return result;
+};
+exports.strToFloat = (el) => el instanceof Array ? el.map(exports.strToFloat) : parseFloat(el);
+class LateBinder {
+    constructor(container, valueFunc, ctx, args) {
+        this.container = container;
+        this.valueFunc = valueFunc;
+        this.ctx = ctx;
+        this.args = args;
+    }
+    bind() {
+        const v = this.valueFunc.apply(this.ctx, this.args);
+        if (this.container instanceof Array) {
+            const idx = this.container.indexOf(this);
+            if (idx >= 0) {
+                const args = [idx, 1];
+                if (v) {
+                    args.push(v);
+                }
+                [].splice.apply(this.container, args);
+            }
+        }
+        else if (typeof this.container === 'object') {
+            const k = Object.keys(this.container).find((nv) => this.container[nv] === this);
+            if (k) {
+                if (v) {
+                    this.container[k] = v;
+                }
+                else {
+                    delete this.container[k];
+                }
+            }
+        }
+    }
+}
+exports.LateBinder = LateBinder;
+class RefElements extends Map {
+    constructor() {
+        super();
+        this.binders = [];
+    }
+    add(k, v) {
+        this.set(k, v);
+    }
+    addBinder(binder) {
+        this.binders.push(binder);
+    }
+    bindAll() {
+        this.binders.forEach((binder) => binder.bind());
+    }
+}
+exports.RefElements = RefElements;
+class WayCollection extends Array {
+    constructor() {
+        super();
+        this.firstMap = {};
+        this.lastMap = {};
+    }
+    addWay(way) {
+        const w = way.toCoordsArray();
+        if (w.length > 0) {
+            this.push(way);
+            addToMap(this.firstMap, exports.coordsToKey(exports.first(w)), w);
+            addToMap(this.lastMap, exports.coordsToKey(exports.last(w)), w);
+        }
+    }
+    toStrings() {
+        const strings = [];
+        let way = this.shift();
+        while (way) {
+            removeFromMap(this.firstMap, exports.coordsToKey(exports.first(way)), way);
+            removeFromMap(this.lastMap, exports.coordsToKey(exports.last(way)), way);
+            let current = way;
+            let next;
+            do {
+                const key = exports.coordsToKey(exports.last(current));
+                let shouldReverse = false;
+                next = getFirstFromMap(this.firstMap, key);
+                if (!next) {
+                    next = getFirstFromMap(this.lastMap, key);
+                    shouldReverse = true;
+                }
+                if (next) {
+                    this.splice(this.indexOf(next), 1);
+                    removeFromMap(this.firstMap, exports.coordsToKey(exports.first(next)), next);
+                    removeFromMap(this.lastMap, exports.coordsToKey(exports.last(next)), next);
+                    if (shouldReverse) {
+                        // always reverse shorter one to save time
+                        if (next.length > current.length) {
+                            [current, next] = [next, current];
+                        }
+                        next.reverse();
+                    }
+                    current = current.concat(next.slice(1));
+                }
+            } while (next);
+            strings.push(exports.strToFloat(current));
+            way = this.shift();
+        }
+        return strings;
+    }
+    toRings(direction) {
+        const strings = this.toStrings();
+        const rings = [];
+        let str = strings.shift();
+        while (str) {
+            if (exports.isRing(str)) {
+                if (exports.ringDirection(str) !== direction) {
+                    str.reverse();
+                }
+                rings.push(str);
+            }
+            str = strings.shift();
+        }
+        return rings;
+    }
+}
+exports.WayCollection = WayCollection;