Source: OverpassObject.js

  1. const ee = require('event-emitter')
  2. const BoundingBox = require('boundingbox')
  3. const OverpassFrontend = require('./defines')
  4. const isGeoJSON = require('./isGeoJSON')
  5. const turf = require('./turf')
  7. const booleanWithin = require('./booleanWithin')
  9. /**
  10.  * Base class for representing map features.
  11.  * @property {string} id ID of this object.
  12.  * @property {number} osm_id Numeric id.
  13.  * @property {string} type Type: 'node', 'way' or 'relation'.
  14.  * @property {object} tags OpenStreetMap tags.
  15.  * @property {object} meta OpenStreetMap meta information.
  16.  * @property {object} 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 ways and relations where this object is member of.
  20.  * @property {string} memberOf.id ID of the way or 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 way resp. relation.
  23. * @property {BoundingBox} bounds Bounding box of this object.
  24.  * @property {Point} center Centroid of the bounding box.
  25.  */
  26. class OverpassObject {
  27.   constructor () {
  28.     this.data = {}
  29.     this.properties = 0
  30.     this.memberOf = []
  31.   }
  33.   memberIds () {
  34.     return []
  35.   }
  37.   member_ids () { // eslint-disable-line
  38.     console.log('called deprecated OverpassObject.member_ids() function - replace by memberIds()')
  39.     return this.memberIds()
  40.   }
  42.   notifyMemberOf (relation, role, sequence) {
  43.     this.memberOf.push({ id: relation.id, role, sequence })
  44.   }
  46.   updateData (data, options) {
  47.     if (typeof this.id === 'undefined') {
  48.       this.id = data.type.substr(0, 1) + data.id
  49.       this.type = data.type
  50.       this.osm_id = data.id
  51.     }
  53.     this.osm3sMeta = options.osm3sMeta
  55.     for (const k in data) {
  56.       this.data[k] = data[k]
  57.     }
  59.     if (data.bounds) {
  60.       this.bounds = new BoundingBox(data.bounds)
  61.       this.center = this.bounds.getCenter()
  62.       this.diagonalLength = this.bounds.diagonalLength()
  63.     } else if (data.center) {
  64.       this.bounds = new BoundingBox(data.center)
  65.       this.center = this.bounds.getCenter()
  66.     }
  68.     if (options.bounds) {
  69.       if (!this.bounds || options.bounds.intersects(this.bounds)) {
  70.         this.properties = this.properties | options.properties
  71.       } else {
  72.         this.properties = this.properties | OverpassFrontend.BBOX | OverpassFrontend.CENTER
  73.       }
  74.     } else {
  75.       this.properties = this.properties | options.properties
  76.     }
  78.     // result of a request with bbox limitation, where the object was outside
  79.     if (options.boundsNoMatch && this.bounds) {
  80.       // this.boundsPossibleMatch: record unsucessful bbox requests for an object
  81.       if (typeof this.boundsPossibleMatch === 'undefined') {
  82.         this.boundsPossibleMatch = this.bounds.toGeoJSON()
  83.       }
  85.       this.boundsPossibleMatch = turf.difference(this.boundsPossibleMatch, options.bounds.toGeoJSON())
  86.     }
  88.     // geometry is known -> no need for this.boundsPossibleMatch
  89.     if (this.geometry) {
  90.       delete this.boundsPossibleMatch
  91.     }
  93.     if (options.properties & OverpassFrontend.TAGS) {
  94.       if (typeof data.tags === 'undefined') {
  95.         this.tags = {}
  96.       } else {
  97.         this.tags = data.tags
  98.       }
  99.     } else if (data.tags) {
  100.       this.tags = data.tags
  101.       this.properties |= OverpassFrontend.TAGS
  102.     }
  103.     this.errors = []
  105.     if (data.timestamp) {
  106.       this.meta = {
  107.         timestamp: data.timestamp,
  108.         version: data.version,
  109.         changeset: data.changeset,
  110.         user: data.user,
  111.         uid: data.uid
  112.       }
  113.       this.properties |= OverpassFrontend.META
  114.     }
  115.   }
  117.   notifyMemberUpdate (memberObs) {
  118.   }
  120.   /**
  121.    * Title of of this object (default: name, operator or ref or the id of the object)
  122.    * @return {string}
  123.    */
  124.   title () {
  125.     if (!this.tags) {
  126.       return this.id
  127.     }
  129.     return this.tags.name || this.tags.operator || this.tags.ref || this.id
  130.   }
  132.   /**
  133.    * GeoJSON representation of this object
  134.    * @return {object}
  135.    */
  136.   GeoJSON () {
  137.     return {
  138.       type: 'Feature',
  139.       id: this.type + '/' + this.osm_id,
  140.       geometry: null,
  141.       properties: this.GeoJSONProperties()
  142.     }
  143.   }
  145.   GeoJSONProperties () {
  146.     const ret = {}
  147.     let k
  149.     ret['@id'] = this.type + '/' + this.osm_id
  151.     if (this.tags) {
  152.       for (k in this.tags) {
  153.         ret[k] = this.tags[k]
  154.       }
  155.     }
  157.     if (this.meta) {
  158.       for (k in this.meta) {
  159.         ret['@' + k] = this.meta[k]
  160.       }
  161.     }
  163.     for (k in this.osm3sMeta) {
  164.       ret['@osm3s:' + k] = this.osm3sMeta[k]
  165.     }
  167.     return ret
  168.   }
  170.   /**
  171.    * Export object as GeoJSON. Missing geometry will be loaded.
  172.    * @param object options Options
  173.    * @param function callback Function which will be called with (err, result)
  174.    */
  175.   exportGeoJSON (options, callback) {
  176.     this.overpass.get(
  177.       this.id,
  178.       {
  179.         properties: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META | OverpassFrontend.GEOM
  180.       },
  181.       () => {},
  182.       (err) => {
  183.         if (err) {
  184.           return callback(err)
  185.         }
  187.         callback(null, this.GeoJSON(options))
  188.       }
  189.     )
  190.   }
  192.   /**
  193.    * Export object (and members) as OpenStreetMap XML
  194.    * @param object options Options
  195.    * @param DOMNode parentNode a DOM Node where the object will be appended as child. Depending on object type and options, member objects will also be appended on the same level.
  196.    * @param function callback Function which will be called with (err, dom node)
  197.    */
  198.   exportOSMXML (options, parentNode, callback) {
  199.     if (!parentNode._alreadyIncluded) {
  200.       parentNode._alreadyIncluded = {}
  201.     }
  202.     if (this.id in parentNode._alreadyIncluded) {
  203.       return callback(null)
  204.     }
  205.     parentNode._alreadyIncluded[this.id] = true
  207.     if ((this.properties & (OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META)) !== (OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META)) {
  208.       return this.overpass.get(
  209.         this.id,
  210.         {
  211.           properties: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META
  212.         },
  213.         () => {},
  214.         (err) => {
  215.           if (err) {
  216.             return callback(err)
  217.           }
  219.           this._exportOSMXML(options, parentNode, callback)
  220.         }
  221.       )
  222.     }
  224.     this._exportOSMXML(options, parentNode, callback)
  225.   }
  227.   _exportOSMXML (options, parentNode, callback) {
  228.     const result = parentNode.ownerDocument.createElement(this.type)
  229.     result.setAttribute('id', this.osm_id)
  231.     if (this.meta) {
  232.       result.setAttribute('version', this.meta.version)
  233.       result.setAttribute('timestamp', this.meta.timestamp)
  234.       result.setAttribute('changeset', this.meta.changeset)
  235.       result.setAttribute('uid', this.meta.uid)
  236.       result.setAttribute('user', this.meta.user)
  237.     }
  239.     if (this.tags) {
  240.       for (const k in this.tags) {
  241.         const tag = parentNode.ownerDocument.createElement('tag')
  242.         tag.setAttribute('k', k)
  243.         tag.setAttribute('v', this.tags[k])
  245.         result.appendChild(tag)
  246.       }
  247.     }
  249.     parentNode.appendChild(result)
  251.     callback(null, result)
  252.   }
  254.   /**
  255.    * Export object (and members) as OpenStreetMap JSON
  256.    * @param object options Options
  257.    * @param object elements All exported elements, include member objects. Pass an empty object. If a member element would be exported multiple times it will appear only once. For the final export, to be compatible to Overpass API, you should convert the object to an array via Object.values().
  258.    * @param function callback Function which will be called with (err, result)
  259.    */
  260.   exportOSMJSON (conf, elements, callback) {
  261.     if (this.id in elements) {
  262.       return callback(null)
  263.     }
  264.     elements[this.id] = {}
  266.     if ((this.properties & (OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META)) !== (OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META)) {
  267.       return this.overpass.get(
  268.         this.id,
  269.         {
  270.           properties: OverpassFrontend.TAGS | OverpassFrontend.MEMBERS | OverpassFrontend.META
  271.         },
  272.         () => {},
  273.         (err) => {
  274.           if (err) {
  275.             return callback(err)
  276.           }
  278.           this._exportOSMJSON(conf, elements, callback)
  279.         }
  280.       )
  281.     }
  283.     this._exportOSMJSON(conf, elements, callback)
  284.   }
  286.   _exportOSMJSON (conf, elements, callback) {
  287.     const result = elements[this.id]
  288.     result.type = this.type
  289.     result.id = this.osm_id
  291.     if (this.meta) {
  292.       result.version = this.meta.version
  293.       result.timestamp = this.meta.timestamp
  294.       result.changeset = this.meta.changeset
  295.       result.uid = this.meta.uid
  296.       result.user = this.meta.user
  297.     }
  299.     if (this.tags && Object.keys(this.tags).length) {
  300.       result.tags = this.tags
  301.     }
  303.     callback(null, result)
  304.   }
  306.   /**
  307.    * Check whether this object intersects (or is within) the specified bounding box. Returns 0 if it does not match; 1 if the exact geometry is not known, but the object's bounding box matches; 2 exact match.
  308.    * @param {boundingbox:BoundingBox} bbox Bounding box
  309.    * @return {number}
  310.    */
  311.   intersects (bbox) {
  312.     if (this.bounds) {
  313.       if (!bbox.intersects) { // GeoJSON detected
  314.         const geojson = this.bounds.toGeoJSON()
  315.         if (!turf.booleanIntersects(geojson, bbox)) {
  316.           return 0
  317.         }
  318.         if (booleanWithin(geojson, bbox)) {
  319.           return 2
  320.         }
  321.       } else {
  322.         if (!bbox.intersects(this.bounds)) {
  323.           return 0
  324.         }
  325.         if (this.bounds.within(bbox)) {
  326.           return 2
  327.         }
  328.       }
  329.     }
  331.     if (this.boundsPossibleMatch) {
  332.       const remaining = turf.intersect(isGeoJSON(bbox) ? bbox : bbox.toGeoJSON(), this.boundsPossibleMatch)
  334.       if (!remaining || remaining.geometry.type !== 'Polygon') {
  335.         // geometry.type != Polygon: bbox matches border of this.boundsPossibleMatch
  336.         return 0
  337.       }
  339.       return 1
  340.     }
  342.     return 1
  343.   }
  345.   /**
  346.    * return a leaflet feature for this object.
  347.    * @param {object} [options] options Options will be passed to the leaflet function
  348.    * @return {L.layer}
  349.    */
  350.   leafletFeature (options) {
  351.     return null
  352.   }
  354.   dbInsert () {
  355.     if (!this.dbData) {
  356.       this.dbData = {}
  357.     }
  359.     this.dbData.tags = this.tags
  360.     this.dbData.osmMeta = this.meta
  361.     this.dbData.id = this.id
  362.     this.dbData.osm_id = this.osm_id
  363.     this.dbData.type = this.type
  365.     if (this.bounds && this.bounds.minlat) {
  366.       this.dbData.minlat = this.bounds.minlat
  367.       this.dbData.minlon = this.bounds.minlon
  368.       this.dbData.maxlat = this.bounds.maxlat
  369.       this.dbData.maxlon = this.bounds.maxlon
  371.       if (this.bounds.minlon > this.bounds.maxlon) {
  372.         this.dbData.stretchLon180 = true
  373.         this.overpass.hasStretchLon180 = true
  374.       }
  375.     }
  377.     return this.dbData
  378.   }
  380.   dbSet (values) {
  381.     if (!this.dbData) {
  382.       this.dbInsert()
  383.     }
  385.     for (const k in values) {
  386.       this.dbData[k] = values[k]
  387.     }
  389.     this.overpass.db.update(this.dbData)
  390.   }
  391. }
  393. ee(OverpassObject.prototype)
  395. module.exports = OverpassObject