Source: RequestBBox.js

  1. const Request = require('./Request')
  2. const overpassOutOptions = require('./overpassOutOptions')
  3. const defines = require('./defines')
  4. const RequestBBoxMembers = require('./RequestBBoxMembers')
  5. const Filter = require('./Filter')
  6. const boundsToLokiQuery = require('./boundsToLokiQuery')
  7. const boundsIsFullWorld = require('./boundsIsFullWorld')
  9. /**
  10.  * A BBox request
  11.  * @extends Request
  12.  */
  13. class RequestBBox extends Request {
  14.   /**
  15.    * @param {OverpassFrontend} overpass
  16.    * @param {object} options
  17.    */
  18.   constructor (overpass, data) {
  19.     super(overpass, data)
  20.     this.type = 'BBoxQuery'
  22.     if (typeof this.options.properties === 'undefined') {
  23.       this.options.properties = defines.DEFAULT
  24.     }
  25.     this.options.properties |= defines.BBOX
  26.     this.options.minEffort = this.options.minEffort || 256
  28.     // make sure the request ends with ';'
  29.     if (!this.query.match(/;\s*$/)) {
  30.       this.query += ';'
  31.     }
  33.     if (!('noCacheQuery' in this.options) || !this.options.noCacheQuery) {
  34.       try {
  35.         if (this.options.filter) {
  36.           this.filterQuery = new Filter({ and: [this.query, this.options.filter] })
  37.           this.query = this.filterQuery.toQl()
  38.         } else {
  39.           this.filterQuery = new Filter(this.query)
  40.         }
  41.       } catch (err) {
  42.         return this.finish(err)
  43.       }
  45.       this.lokiQuery = this.filterQuery.toLokijs()
  46.       this.lokiQueryNeedMatch = !!this.lokiQuery.needMatch
  47.       delete this.lokiQuery.needMatch
  49.       if (!boundsIsFullWorld(this.bounds)) {
  50.         this.lokiQuery = { $and: [this.lokiQuery, boundsToLokiQuery(this.bbox, this.overpass)] }
  51.       }
  53.       const cacheFilter = new Filter({ and: [this.filterQuery, new Filter('nwr(properties:' + this.options.properties + ')')] })
  54.       this.options.properties = cacheFilter.properties()
  56.       this.cacheDescriptors = cacheFilter.cacheDescriptors().map(cacheDescriptors => {
  57.         return {
  58.           cache: this.overpass.bboxQueryCache.get(cacheDescriptors.id),
  59.           cacheDescriptors
  60.         }
  61.       })
  62.     }
  64.     this.loadFinish = false
  66.     if ('members' in this.options) {
  67.       RequestBBoxMembers(this)
  68.     }
  69.   }
  71.   /**
  72.    * check if there are any map features which can be returned right now
  73.    */
  74.   preprocess () {
  75.     let items = []
  76.     if (this.lokiQuery) {
  77.       items = this.overpass.db.find(this.lokiQuery)
  78.     }
  80.     for (let i = 0; i < items.length; i++) {
  81.       if (this.options.limit && this.count >= this.options.limit) {
  82.         this.loadFinish = true
  83.         return
  84.       }
  86.       const id = items[i].id
  88.       if (!(id in this.overpass.cacheElements)) {
  89.         continue
  90.       }
  91.       const ob = this.overpass.cacheElements[id]
  93.       if (id in this.doneFeatures) {
  94.         continue
  95.       }
  97.       // maybe we need an additional check
  98.       if (this.lokiQueryNeedMatch && !this.filterQuery.match(ob)) {
  99.         continue
  100.       }
  102.       // also check the object directly if it intersects the bbox - if possible
  103.       if (ob.intersects(this.bounds) < 2) {
  104.         continue
  105.       }
  107.       if ((this.options.properties & ob.properties) === this.options.properties) {
  108.         this.receiveObject(ob)
  109.         this.featureCallback(null, ob)
  110.       }
  111.     }
  113.     if (this.options.limit && this.count >= this.options.limit) {
  114.       this.loadFinish = true
  115.     }
  116.   }
  118.   /**
  119.    * shall this Request be included in the current call?
  120.    * @param {OverpassFrontend#Context} context - Current context
  121.    * @return {boolean|int[]} - yes|no - or [ minEffort, maxEffort ]
  122.    */
  123.   willInclude (context) {
  124.     if (this.loadFinish) {
  125.       return false
  126.     }
  128.     if (context.bbox && context.bbox.toLatLonString() !== this.bbox.toLatLonString()) {
  129.       return false
  130.     }
  131.     context.bbox = this.bbox
  133.     for (const i in context.requests) {
  134.       const request = context.requests[i]
  135.       if (request instanceof RequestBBox && request.query === this.query) {
  136.         return false
  137.       }
  138.     }
  140.     return true
  141.   }
  143.   /**
  144.    * how much effort can a call to this request use
  145.    * @return {Request#minMaxEffortResult} - minimum and maximum effort
  146.    */
  147.   minMaxEffort () {
  148.     if (this.loadFinish) {
  149.       return { minEffort: 0, maxEffort: 0 }
  150.     }
  152.     let minEffort = this.options.minEffort
  153.     let maxEffort = null
  154.     if (this.options.limit) {
  155.       maxEffort = (this.options.limit - this.count) * this.overpass.options.effortBBoxFeature
  156.       minEffort = Math.min(minEffort, maxEffort)
  157.     }
  159.     return { minEffort, maxEffort }
  160.   }
  162.   /**
  163.    * compile the query
  164.    * @param {OverpassFrontend#Context} context - Current context
  165.    * @return {Request#SubRequest|false} - the compiled query or false if the bbox does not match
  166.    */
  167.   _compileQuery (context) {
  168.     if (this.loadFinish || (context.bbox && context.bbox.toLatLonString() !== this.bbox.toLatLonString())) {
  169.       return {
  170.         query: '',
  171.         request: this,
  172.         parts: [],
  173.         effort: 0
  174.       }
  175.     }
  177.     const efforts = this.minMaxEffort()
  178.     let effortAvailable = Math.max(context.maxEffort, efforts.minEffort)
  179.     if (efforts.maxEffort) {
  180.       effortAvailable = Math.min(effortAvailable, efforts.maxEffort)
  181.     }
  183.     // if the context already has a bbox and it differs from this, we can't add
  184.     // ours
  185.     let query = this.query.substr(0, this.query.length - 1) + '->.result;\n'
  187.     let queryRemoveDoneFeatures = ''
  188.     let countRemoveDoneFeatures = 0
  189.     for (const id in this.doneFeatures) {
  190.       const ob = this.doneFeatures[id]
  192.       if (countRemoveDoneFeatures % 1000 === 999) {
  193.         query += '(' + queryRemoveDoneFeatures + ')->.done;\n'
  194.         queryRemoveDoneFeatures = '.done;'
  195.       }
  197.       queryRemoveDoneFeatures += ob.type + '(' + ob.osm_id + ');'
  198.       countRemoveDoneFeatures++
  199.     }
  201.     if (countRemoveDoneFeatures) {
  202.       query += '(' + queryRemoveDoneFeatures + ')->.done;\n'
  203.       query += '(.result; - .done;)->.result;\n'
  204.     }
  206.     if (!('split' in this.options)) {
  207.       this.options.effortSplit = Math.ceil(effortAvailable / this.overpass.options.effortBBoxFeature)
  208.     }
  209.     query += '.result out ' + overpassOutOptions(this.options) + ';'
  211.     const subRequest = {
  212.       query,
  213.       request: this,
  214.       parts: [
  215.         {
  216.           properties: this.options.properties,
  217.           receiveObject: this.receiveObject.bind(this),
  218.           checkFeatureCallback: this.checkFeatureCallback.bind(this),
  219.           featureCallback: this.featureCallback
  220.         }
  221.       ],
  222.       effort: this.options.split ? this.options.split * this.overpass.options.effortBBoxFeature : effortAvailable
  223.     }
  224.     return subRequest
  225.   }
  227.   /**
  228.    * receive an object from OverpassFronted -> enter to cache, return to caller
  229.    * @param {OverpassObject} ob - Object which has been received
  230.    * @param {Request#SubRequest} subRequest - sub request which is being handled right now
  231.    * @param {int} partIndex - Which part of the subRequest is being received
  232.    */
  233.   receiveObject (ob) {
  234.     super.receiveObject(ob)
  235.     this.doneFeatures[ob.id] = ob
  236.   }
  238.   checkFeatureCallback (ob) {
  239.     if (this.bounds && ob.intersects(this.bounds) === 0) {
  240.       return false
  241.     }
  243.     return true
  244.   }
  246.   /**
  247.    * the current subrequest is finished -> update caches, check whether request is finished
  248.    * @param {Request#SubRequest} subRequest - the current sub request
  249.    */
  250.   finishSubRequest (subRequest) {
  251.     super.finishSubRequest(subRequest)
  253.     if (('effortSplit' in this.options && this.options.effortSplit > subRequest.parts[0].count) ||
  254.         (this.options.split > subRequest.parts[0].count)) {
  255.       this.loadFinish = true
  257.       this.cacheDescriptors && this.cacheDescriptors.forEach(cache => {
  258.         cache.cache.add(this.bbox, cache.cacheDescriptors)
  259.       })
  260.     }
  262.     if (this.options.limit && this.options.limit <= this.count) {
  263.       this.loadFinish = true
  264.     }
  265.   }
  267.   /**
  268.    * check if we need to call Overpass API. Maybe whole area is cached anyway?
  269.    * @return {boolean} - true, if we need to call Overpass API
  270.    */
  271.   needLoad () {
  272.     if (this.loadFinish) {
  273.       return false
  274.     }
  276.     return !this.cacheDescriptors || !this.cacheDescriptors.every(cache => {
  277.       return cache.cache.check(this.bbox, cache.cacheDescriptors)
  278.     })
  279.   }
  281.   mayFinish () {
  282.     return !this.needLoad()
  283.   }
  284. }
  286. module.exports = RequestBBox