Source: OverpassRelation.js

  1. /* global L:false */
  3. const async = require('async')
  4. const BoundingBox = require('boundingbox')
  5. const osmtogeojson = require('osmtogeojson')
  6. const OverpassObject = require('./OverpassObject')
  7. const OverpassFrontend = require('./defines')
  8. const geojsonShiftWorld = require('./geojsonShiftWorld')
  9. const turf = require('./turf')
  11. /**
  12.  * A relation
  13.  * @property {string} id ID of this object, starting with 'r'.
  14.  * @property {number} osm_id Numeric id.
  15.  * @property {string} type Type: 'relation'.
  16.  * @property {object} tags OpenStreetMap tags.
  17.  * @property {object} meta OpenStreetMap meta information.
  18.  * @property {GeoJSON} geometry of the object
  19.  * @property {object} data Data as loaded from Overpass API.
  20.  * @property {bit_array} properties Which information about this object is known?
  21.  * @property {object[]} memberOf List of relations where this object is member of.
  22.  * @property {string} memberOf.id ID of the relation where this object is member of.
  23.  * @property {string} memberOf.role Role of this object in the relation.
  24.  * @property {number} memberOf.sequence This object is the nth member in the relation.
  25.  * @property {null|string} memberOf.connectedPrev null (unknown), 'no' (connected), 'forward' (connected at the front end of this way), 'backward' (connected at the back end of this way)
  26.  * @property {null|string} memberOf.connectedNext null (unknown), 'no' (connected), 'forward' (connected at the back end of this way), 'backward' (connected at the front end of this way)
  27.  * @property {null|string} members.dir null (unknown), 'forward', 'backward'
  28.  * @property {BoundingBox} bounds Bounding box of this object.
  29.  * @property {Point} center Centroid of the bounding box.
  30.  * @property {object[]} members Nodes of the way.
  31.  * @property {string} members.id ID of the member.
  32.  * @property {number} members.ref Numeric ID of the member.
  33.  * @property {string} members.type 'node'.
  34.  * @property {string} members.role Role of the member.
  35.  * @property {null|string} members.connectedPrev null (unknown), 'no' (connected), 'forward' (connected at the front end of this way), 'backward' (connected at the back end of this way)
  36.  * @property {null|string} members.connectedNext null (unknown), 'no' (connected), 'forward' (connected at the back end of this way), 'backward' (connected at the fornt end of this way)
  37.  * @property {null|string} members.dir null (unknown), 'forward', 'backward', 'loop'
  38.  */
  39. class OverpassRelation extends OverpassObject {
  40.   updateData (data, options) {
  41.     super.updateData(data, options)
  43.     if (data.bounds) {
  44.       this.bounds = new BoundingBox(data.bounds)
  45.       this.center = this.bounds.getCenter()
  46.       this.properties |= OverpassFrontend.BBOX | OverpassFrontend.CENTER
  47.     }
  49.     if (data.center) {
  50.       this.center = data.center
  51.       this.properties |= OverpassFrontend.CENTER
  52.     }
  54.     if (data.members) {
  55.       this.members = []
  56.       this.properties |= OverpassFrontend.MEMBERS
  58.       const membersKnown = !!this.memberFeatures
  59.       this.memberFeatures = data.members.map(
  60.         (member, sequence) => {
  61.           this.members.push(member)
  63.           // fix referenced ways from 'out geom' output
  64.           if (member.type === 'way' && typeof member.ref === 'string') {
  65.             const m = member.ref.match(/^_fullGeom([0-9]+)$/)
  66.             if (m) {
  67.               member.ref = parseInt(m[1])
  68.             }
  69.           }
  71.           member.id = member.type.substr(0, 1) + member.ref
  73.           const ob = JSON.parse(JSON.stringify(member))
  74.           ob.id = ob.ref
  75.           delete ob.ref
  76.           delete ob.role
  77.           let memberProperties = OverpassFrontend.ID_ONLY
  79.           if ((member.type === 'node' && 'lat' in member) ||
  80.               (member.type === 'way' && 'geometry' in member)) {
  81.             memberProperties |= OverpassFrontend.GEOM
  82.           }
  84.           const memberOb = this.overpass.createOrUpdateOSMObject(ob, { properties: memberProperties })
  86.           // call notifyMemberOf only once per member
  87.           if (!membersKnown) {
  88.             memberOb.notifyMemberOf(this, member.role, sequence)
  89.           }
  91.           return memberOb
  92.         }
  93.       )
  95.       this.updateGeometry()
  96.     }
  97.   }
  99.   updateGeometry () {
  100.     if (!this.members) {
  101.       return
  102.     }
  104.     let allKnown = true
  105.     const elements = [{
  106.       type: 'relation',
  107.       id: this.osm_id,
  108.       tags: this.tags,
  109.       members: this.members.map(member => {
  110.         const data = {
  111.           ref: member.ref,
  112.           type: member.type,
  113.           role: member.role
  114.         }
  116.         if (!(member.id in this.overpass.cacheElements)) {
  117.           allKnown = false
  118.           return data
  119.         }
  121.         const ob = this.overpass.cacheElements[member.id]
  123.         if ((ob.properties & OverpassFrontend.GEOM) === 0) {
  124.           allKnown = false
  125.         }
  127.         if (ob.type === 'node') {
  128.           if (ob.geometry) {
  129.             data.lat = ob.geometry.lat
  130.             data.lon = ob.geometry.lon
  131.           }
  132.         } else if (ob.type === 'way') {
  133.           data.geometry = ob.geometry
  134.         }
  136.         return data
  137.       })
  138.     }]
  140.     this.geometry = osmtogeojson({ elements })
  141.     if (allKnown) {
  142.       this.properties = this.properties | OverpassFrontend.GEOM
  143.     }
  145.     this.members.forEach(
  146.       (member, index) => {
  147.         if (member.type !== 'way') {
  148.           return
  149.         }
  151.         const memberOb = this.overpass.cacheElements[member.id]
  152.         if (!memberOb.members || member.type !== 'way') {
  153.           return
  154.         }
  156.         const firstMemberId = memberOb.members[0].id
  157.         const lastMemberId = memberOb.members[memberOb.members.length - 1].id
  158.         const revMemberOf = memberOb.memberOf.filter(memberOf => memberOf.sequence === index && memberOf.id === this.id)[0]
  160.         if (index > 0) {
  161.           const prevMember = this.overpass.cacheElements[this.members[index - 1].id]
  162.           if (prevMember.type === 'way' && prevMember.members) {
  163.             if (firstMemberId === prevMember.members[0].id || firstMemberId === prevMember.members[prevMember.members.length - 1].id) {
  164.               member.connectedPrev = 'forward'
  165.             } else if (lastMemberId === prevMember.members[0].id || lastMemberId === prevMember.members[prevMember.members.length - 1].id) {
  166.               member.connectedPrev = 'backward'
  167.             } else {
  168.               member.connectedPrev = 'no'
  169.             }
  170.           }
  171.         }
  173.         if (index < this.members.length - 1) {
  174.           const nextMember = this.overpass.cacheElements[this.members[index + 1].id]
  175.           if (nextMember.type === 'way' && nextMember.members) {
  176.             if (firstMemberId === nextMember.members[0].id || firstMemberId === nextMember.members[nextMember.members.length - 1].id) {
  177.               member.connectedNext = 'backward'
  178.             } else if (lastMemberId === nextMember.members[0].id || lastMemberId === nextMember.members[nextMember.members.length - 1].id) {
  179.               member.connectedNext = 'forward'
  180.             } else {
  181.               member.connectedNext = 'no'
  182.             }
  183.           }
  184.         }
  186.         if (!member.connectedPrev || !member.connectedNext) {
  187.           member.dir = member.connectedPrev || member.connectedNext || null
  188.         } else if (member.connectedPrev === member.connectedNext) {
  189.           member.dir = member.connectedPrev || member.connectedNext || null
  190.         } else {
  191.           member.dir = null
  192.         }
  194.         if (revMemberOf) {
  195.           if ('dir' in member) {
  196.             revMemberOf.dir = member.dir
  197.           }
  198.           if ('connectedPrev' in member) {
  199.             revMemberOf.connectedPrev = member.connectedPrev
  200.           }
  201.           if ('connectedNext' in member) {
  202.             revMemberOf.connectedNext = member.connectedNext
  203.           }
  204.         } else {
  205.           console.log('Warning: memberOf reference ' + member.id + ' -> ' + this.id + ' (#' + index + ') does not exist.')
  206.         }
  207.       }
  208.     )
  210.     if (!(this.properties & OverpassFrontend.BBOX)) {
  211.       this.members.forEach(member => {
  212.         const ob = this.overpass.cacheElements[member.id]
  213.         if (ob.bounds) {
  214.           if (this.bounds) {
  215.             this.bounds.extend(ob.bounds)
  216.           } else {
  217.             this.bounds = new BoundingBox(ob.bounds)
  218.           }
  219.         }
  220.         if (this.bounds) {
  221.           this.center = this.bounds.getCenter()
  222.         }
  223.       })
  225.       if (this.bounds && allKnown) {
  226.         this.properties = this.properties | OverpassFrontend.BBOX | OverpassFrontend.CENTER
  227.       }
  228.     }
  229.   }
  231.   notifyMemberUpdate (memberObs) {
  232.     super.notifyMemberUpdate(memberObs)
  234.     if (!this.members) {
  235.       return
  236.     }
  238.     this.updateGeometry()
  239.   }
  241.   /**
  242.    * Return list of member ids.
  243.    * @return {string[]}
  244.    */
  245.   memberIds () {
  246.     if (this._memberIds) {
  247.       return this._memberIds
  248.     }
  250.     if (typeof this.data.members === 'undefined') {
  251.       return null
  252.     }
  254.     this._memberIds = []
  255.     for (let i = 0; i < this.data.members.length; i++) {
  256.       const member = this.data.members[i]
  258.       this._memberIds.push(member.type.substr(0, 1) + member.ref)
  259.     }
  261.     return this._memberIds
  262.   }
  264.   member_ids () { // eslint-disable-line
  265.     console.log('called deprecated OverpassRelation.member_ids() function - replace by memberIds()')
  266.     return this.memberIds()
  267.   }
  269.   /**
  270.    * return a leaflet feature for this object.
  271.    * @param {object} [options] options Options will be passed to the leaflet function
  272.    * @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)
  273.    * @return {L.layer}
  274.    */
  275.   leafletFeature (options = {}) {
  276.     if (!this.data.members) {
  277.       return null
  278.     }
  280.     if (!('shiftWorld' in options)) {
  281.       options.shiftWorld = [0, 0]
  282.     }
  284.     // no geometry? use the member features instead
  285.     if (!this.geometry) {
  286.       const feature = L.featureGroup()
  287.       feature._updateCallbacks = []
  289.       return feature
  290.     }
  292.     const feature = L.geoJSON(geojsonShiftWorld(this.geometry, options.shiftWorld), {
  293.       pointToLayer: function (options, geoJsonPoint, member) {
  294.         let feature
  296.         switch (options.nodeFeature) {
  297.           case 'Marker':
  298.             feature = L.marker(member, options)
  299.             break
  300.           case 'Circle':
  301.             feature = L.circle(member, options.radius, options)
  302.             break
  303.           case 'CircleMarker':
  304.           default:
  305.             feature = L.circleMarker(member, options)
  306.         }
  308.         return feature
  309.       }.bind(this, options)
  310.     })
  311.     feature.setStyle(options)
  313.     // create an event handler on the 'update' event, so that loading member
  314.     // features will update geometry
  315.     this.memberFeatures.forEach(
  316.       (member, index) => {
  317.         if (!(member.properties & OverpassFrontend.GEOM)) {
  318.           const updFun = member => {
  319.             feature.clearLayers()
  320.             feature.addData(this.geometry)
  321.             feature.setStyle(options)
  322.           }
  324.           member.once('update', updFun)
  325.         }
  326.       }
  327.     )
  329.     return feature
  330.   }
  332.   GeoJSON () {
  333.     const ret = {
  334.       type: 'Feature',
  335.       id: this.type + '/' + this.osm_id,
  336.       properties: this.GeoJSONProperties()
  337.     }
  339.     if (this.members) {
  340.       if (this.geometry.features.length === 1) {
  341.         ret.geometry = this.geometry.features[0].geometry
  342.       } else {
  343.         ret.geometry = {
  344.           type: 'GeometryCollection',
  345.           geometries: this.memberFeatures
  346.             .map(member => member.GeoJSON().geometry) // .geometry may be undefined
  347.             .filter(member => member)
  348.             .filter(member => member.type !== 'GeometryCollection' || member.geometries.length)
  349.         }
  350.       }
  351.     }
  353.     return ret
  354.   }
  356.   exportOSMXML (options, parentNode, callback) {
  357.     super.exportOSMXML(options, parentNode,
  358.       (err, result) => {
  359.         if (err) {
  360.           return callback(err)
  361.         }
  363.         if (!result) { // already included
  364.           return callback(null)
  365.         }
  367.         if (this.members) {
  368.           async.each(this.members,
  369.             (member, done) => {
  370.               const memberOb = this.overpass.cacheElements[member.id]
  372.               const nd = parentNode.ownerDocument.createElement('member')
  373.               nd.setAttribute('ref', memberOb.osm_id)
  374.               nd.setAttribute('type', memberOb.type)
  375.               nd.setAttribute('role', member.role)
  376.               result.appendChild(nd)
  378.               memberOb.exportOSMXML(options, parentNode, done)
  379.             },
  380.             (err) => {
  381.               callback(err, result)
  382.             }
  383.           )
  384.         } else {
  385.           callback(null, result)
  386.         }
  387.       }
  388.     )
  389.   }
  391.   exportOSMJSON (conf, elements, callback) {
  392.     super.exportOSMJSON(conf, elements,
  393.       (err, result) => {
  394.         if (err) {
  395.           return callback(err)
  396.         }
  398.         if (!result) { // already included
  399.           return callback(null)
  400.         }
  402.         if (this.members) {
  403.           result.members = []
  405.           async.each(this.members,
  406.             (member, done) => {
  407.               const memberOb = this.overpass.cacheElements[member.id]
  409.               result.members.push({
  410.                 ref: memberOb.osm_id,
  411.                 type: memberOb.type,
  412.                 role: member.role
  413.               })
  415.               memberOb.exportOSMJSON(conf, elements, done)
  416.             },
  417.             (err) => {
  418.               callback(err, result)
  419.             }
  420.           )
  421.         } else {
  422.           callback(null, result)
  423.         }
  424.       }
  425.     )
  426.   }
  428.   intersects (bbox) {
  429.     const result = super.intersects(bbox)
  431.     if (result === 0 || result === 2) {
  432.       return result
  433.     }
  435.     let i
  437.     if (this.geometry) {
  438.       let geometry = this.geometry
  439.       let bboxShifted = bbox.toGeoJSON ? bbox.toGeoJSON() : bbox
  440.       if (this.bounds && this.bounds.minlon > this.bounds.maxlon) {
  441.         geometry = geojsonShiftWorld(geometry, [360, 0])
  442.         bboxShifted = geojsonShiftWorld(bboxShifted, [360, 0])
  443.       }
  445.       if (turf.booleanIntersects(geometry, bboxShifted)) {
  446.         return 2
  447.       }
  449.       // if there's a relation member (where Overpass does not return the
  450.       // geometry) we can't know if the geometry intersects -> return 1
  451.       for (i = 0; i < this.data.members.length; i++) {
  452.         if (this.data.members[i].type === 'relation') {
  453.           return 1
  454.         }
  455.       }
  457.       // if there's no relation member and the geometry is complete we can be sure there's no intersection
  458.       return this.properties & OverpassFrontend.GEOM ? 0 : 1
  459.     } else if (this.members) {
  460.       for (i in this.members) {
  461.         const memberId = this.members[i].id
  462.         const member = this.overpass.cacheElements[memberId]
  464.         if (member) {
  465.           if (member.intersects(bbox) === 2) {
  466.             return 2
  467.           }
  468.         }
  469.       }
  470.     }
  472.     return 1
  473.   }
  474. }
  476. module.exports = OverpassRelation