Source: OverpassWay.js

  1. /* global L:false */
  3. const async = require('async')
  4. const BoundingBox = require('boundingbox')
  5. const OverpassObject = require('./OverpassObject')
  6. const OverpassFrontend = require('./defines')
  7. const turf = require('./turf')
  9. /**
  10.  * A way
  11.  * @property {string} id ID of this object, starting with 'w'.
  12.  * @property {number} osm_id Numeric id.
  13.  * @property {string} type Type: 'way'.
  14.  * @property {object} tags OpenStreetMap tags.
  15.  * @property {object} meta OpenStreetMap meta information.
  16.  * @property {Point[]} geometry of the object
  17.  * @property {object} data Data as loaded from Overpass API.
  18.  * @property {bit_array} properties Which information about this object is known?
  19.  * @property {object[]} memberOf List of relations where this object is member of.
  20.  * @property {string} memberOf.id ID of the relation where this way is member of.
  21.  * @property {string} memberOf.role Role of this object in the relation.
  22.  * @property {number} memberOf.sequence This object is the nth member in the relation.
  23.  * @property {BoundingBox} bounds Bounding box of this object.
  24.  * @property {Point} center Centroid of the bounding box.
  25.  * @property {object[]} members Nodes of the way.
  26.  * @property {string} members.id ID of the member.
  27.  * @property {number} members.ref Numeric ID of the member.
  28.  * @property {string} members.type 'node'.
  29.  */
  30. class OverpassWay extends OverpassObject {
  31.   updateData (data, options) {
  32.     if (data.nodes) {
  33.       this.nodes = data.nodes
  34.     }
  36.     if (data.geometry) {
  37.       this.geometry = data.geometry
  38.       this.properties |= OverpassFrontend.GEOM
  39.     }
  41.     super.updateData(data, options)
  43.     if (typeof this.data.nodes !== 'undefined') {
  44.       this.members = []
  45.       this.properties |= OverpassFrontend.MEMBERS
  47.       for (let i = 0; i < this.data.nodes.length; i++) {
  48.         this.members.push({
  49.           id: 'n' + this.data.nodes[i],
  50.           ref: this.data.nodes[i],
  51.           type: 'node'
  52.         })
  54.         let obProperties = OverpassFrontend.ID_ONLY
  55.         const ob = {
  56.           id: this.data.nodes[i],
  57.           type: 'node'
  58.         }
  60.         if (data.geometry && data.geometry[i]) {
  61.           obProperties = obProperties | OverpassFrontend.GEOM
  62.           ob.lat = data.geometry[i].lat
  63.           ob.lon = data.geometry[i].lon
  64.         }
  66.         const memberOb = this.overpass.createOrUpdateOSMObject(ob, {
  67.           properties: obProperties
  68.         })
  70.         memberOb.notifyMemberOf(this, null, i)
  71.       }
  72.     }
  74.     this.checkGeometry()
  75.   }
  77.   notifyMemberUpdate (memberObs) {
  78.     super.notifyMemberUpdate(memberObs)
  80.     this.checkGeometry()
  81.   }
  83.   checkGeometry () {
  84.     if (this.members && (this.properties & OverpassFrontend.GEOM) === 0) {
  85.       this.geometry = this.members.map(
  86.         member => {
  87.           const node = this.overpass.cacheElements[member.id]
  88.           return node ? node.geometry : null
  89.         }
  90.       ).filter(geom => geom)
  92.       if (this.geometry.length === 0) {
  93.         delete this.geometry
  94.         return
  95.       }
  97.       if (this.geometry.length === this.members.length) {
  98.         this.properties = this.properties | OverpassFrontend.GEOM
  99.       }
  100.     }
  102.     if (this.geometry && (this.properties & OverpassFrontend.BBOX) === 0) {
  103.       this.bounds = new BoundingBox(this.geometry[0])
  104.       this.geometry.slice(1).forEach(geom => this.bounds.extend(geom))
  105.     }
  107.     if (this.bounds && (this.properties & OverpassFrontend.CENTER) === 0) {
  108.       this.center = this.bounds.getCenter()
  109.     }
  111.     if ((this.properties & OverpassFrontend.GEOM) === OverpassFrontend.GEOM) {
  112.       this.properties = this.properties | OverpassFrontend.BBOX | OverpassFrontend.CENTER
  113.     }
  114.   }
  116.   memberIds () {
  117.     if (this._memberIds) {
  118.       return this._memberIds
  119.     }
  121.     if (!this.nodes) {
  122.       return null
  123.     }
  125.     this._memberIds = []
  126.     for (let i = 0; i < this.nodes.length; i++) {
  127.       const member = this.nodes[i]
  129.       this._memberIds.push('n' + member)
  130.     }
  132.     return this._memberIds
  133.   }
  135.   member_ids () { // eslint-disable-line
  136.     console.log('called deprecated OverpassWay.member_ids() function - replace by memberIds()')
  137.     return this.memberIds()
  138.   }
  140.   GeoJSON () {
  141.     const result = {
  142.       type: 'Feature',
  143.       id: this.type + '/' + this.osm_id,
  144.       properties: this.GeoJSONProperties()
  145.     }
  147.     if (this.geometry) {
  148.       const coordinates = this.geometry
  149.         .filter(point => point) // discard non-loaded points
  150.         .map(point => [point.lon, point.lat])
  151.       const isClosed = coordinates.length > 1 && this.members && this.members[0].id === this.members[this.members.length - 1].id
  153.       if (isClosed) {
  154.         result.geometry = {
  155.           type: 'Polygon',
  156.           coordinates: [coordinates]
  157.         }
  158.       } else {
  159.         result.geometry = {
  160.           type: 'LineString',
  161.           coordinates: coordinates
  162.         }
  163.       }
  164.     }
  166.     return result
  167.   }
  169.   exportOSMXML (options, parentNode, callback) {
  170.     super.exportOSMXML(options, parentNode,
  171.       (err, result) => {
  172.         if (err) {
  173.           return callback(err)
  174.         }
  176.         if (!result) { // already included
  177.           return callback(null)
  178.         }
  180.         if (this.members) {
  181.           async.each(this.members,
  182.             (member, done) => {
  183.               const memberOb = this.overpass.cacheElements[member.id]
  185.               const nd = parentNode.ownerDocument.createElement('nd')
  186.               nd.setAttribute('ref', memberOb.osm_id)
  187.               result.appendChild(nd)
  189.               memberOb.exportOSMXML(options, parentNode, done)
  190.             },
  191.             (err) => {
  192.               callback(err, result)
  193.             }
  194.           )
  195.         } else {
  196.           callback(null, result)
  197.         }
  198.       }
  199.     )
  200.   }
  202.   exportOSMJSON (conf, elements, callback) {
  203.     super.exportOSMJSON(conf, elements,
  204.       (err, result) => {
  205.         if (err) {
  206.           return callback(err)
  207.         }
  209.         if (!result) { // already included
  210.           return callback(null)
  211.         }
  213.         if (this.members) {
  214.           result.nodes = []
  216.           async.each(this.members,
  217.             (member, done) => {
  218.               const memberOb = this.overpass.cacheElements[member.id]
  220.               result.nodes.push(memberOb.osm_id)
  222.               memberOb.exportOSMJSON(conf, elements, done)
  223.             },
  224.             (err) => {
  225.               callback(err, result)
  226.             }
  227.           )
  228.         } else {
  229.           callback(null, result)
  230.         }
  231.       }
  232.     )
  233.   }
  235.   /**
  236.    * return a leaflet feature for this object. If the ways is closed, a L.polygon will be returned, otherwise a L.polyline.
  237.    * @param {object} [options] options Options will be passed to the leaflet function
  238.    * @param {number[]} [options.shiftWorld=[0, 0]] Shift western (negative) longitudes by shiftWorld[0], eastern (positive) longitudes by shiftWorld[1] (e.g. by 360, 0 to show objects around lon=180)
  239.    * @return {L.layer}
  240.    */
  241.   leafletFeature (options = {}) {
  242.     if (!this.geometry) {
  243.       return null
  244.     }
  246.     if (!('shiftWorld' in options)) {
  247.       options.shiftWorld = [0, 0]
  248.     }
  250.     const geom = this.geometry
  251.       .filter(g => g)
  252.       .map(g => {
  253.         return { lat: g.lat, lon: g.lon + options.shiftWorld[g.lon < 0 ? 0 : 1] }
  254.       })
  256.     if (this.geometry[this.geometry.length - 1] && this.geometry[0] &&
  257.        this.geometry[this.geometry.length - 1].lat === this.geometry[0].lat &&
  258.        this.geometry[this.geometry.length - 1].lon === this.geometry[0].lon) {
  259.       return L.polygon(geom, options)
  260.     }
  262.     return L.polyline(geom, options)
  263.   }
  265.   intersects (bbox) {
  266.     const result = super.intersects(bbox)
  268.     if (result === 0 || result === 2) {
  269.       return result
  270.     }
  272.     if (this.geometry) {
  273.       let intersects
  274.       if (bbox.toGeoJSON) {
  275.         // bbox is BoundingBox
  276.         intersects = turf.booleanIntersects(this.GeoJSON(), bbox.toGeoJSON())
  277.       } else {
  278.         // bbox is GeoJSON
  279.         intersects = turf.booleanIntersects(this.GeoJSON(), bbox)
  280.       }
  282.       return intersects ? 2 : 0
  283.     }
  285.     return 1
  286.   }
  287. }
  289. module.exports = OverpassWay