Source: BoundingBox.js

  1. 'use strict'
  3. var GeoJSONBounds = require('geojson-bounds')
  4. const haversine = require('haversine')
  6. /* global L:false */
  8. /**
  9.  * create bounding box from input
  10.  * @class
  11.  * @param {object|Leaflet.latLngBounds|GeoJSON} bounds Input boundary. Can be an object with { minlat, minlon, maxlat, maxlon } or { lat, lon } or { lat, lng } or [ N (lat), N (lon) ] a GeoJSON object or a Leaflet object (latLng or latLngBounds). The boundary will automatically be wrapped at longitude -180 / 180.
  12.  * @example
  13.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  14.  */
  15. function BoundingBox (bounds) {
  16.   var k
  18.   if (bounds === null || typeof bounds === 'undefined') {
  19.     this.minlat = -90
  20.     this.minlon = -180
  21.     this.maxlat = +90
  22.     this.maxlon = +180
  23.     return
  24.   }
  26.   // Leaflet.latLngBounds detected!
  27.   if (typeof bounds.getSouthWest === 'function') {
  28.     var sw = bounds.getSouthWest().wrap()
  29.     var ne = bounds.getNorthEast().wrap()
  31.     bounds = {
  32.       minlat: sw.lat,
  33.       minlon: sw.lng,
  34.       maxlat: ne.lat,
  35.       maxlon: ne.lng
  36.     }
  37.   }
  39.   // GeoJSON detected
  40.   if (bounds.type === 'Feature') {
  41.     let boxes
  43.     if (bounds.geometry.type === 'GeometryCollection') {
  44.       boxes = bounds.geometry.geometries.map(
  45.         geometry => {
  46.           let b = new BoundingBox({ type: 'Feature', geometry })
  47.           return [ b.minlon, b.minlat, b.maxlon, b.maxlat ]
  48.         }
  49.       )
  50.     } else if ([ 'MultiPoint', 'MultiPolygon', 'MultiLineString' ].includes(bounds.geometry.type)) {
  51.       boxes = bounds.geometry.coordinates.map(
  52.         geom => GeoJSONBounds.extent({ type: 'Feature', geometry: { type: bounds.geometry.type.substr(5), coordinates: geom } })
  53.       )
  54.     } else {
  55.       boxes = [ GeoJSONBounds.extent(bounds) ]
  56.     }
  58.     let b = boxes.shift()
  60.     this.minlat = b[1]
  61.     this.minlon = b[0]
  62.     this.maxlat = b[3]
  63.     this.maxlon = b[2]
  65.     boxes.forEach(b => this.extend({
  66.       minlat: b[1],
  67.       minlon: b[0],
  68.       maxlat: b[3],
  69.       maxlon: b[2]
  70.     }))
  72.     this._wrap()
  74.     return
  75.   }
  77.   if ('bounds' in bounds) {
  78.     bounds = bounds.bounds
  79.   }
  81.   if (bounds.lat) {
  82.     this.minlat = bounds.lat
  83.     this.maxlat = bounds.lat
  84.   }
  86.   if (bounds.lon) {
  87.     this.minlon = bounds.lon
  88.     this.maxlon = bounds.lon
  89.   }
  91.   if (Array.isArray(bounds)) {
  92.     this.minlat = bounds[0]
  93.     this.maxlat = bounds[0]
  94.     this.minlon = bounds[1]
  95.     this.maxlon = bounds[1]
  96.   }
  98.   // e.g. L.latLng object
  99.   if (bounds.lng) {
  100.     this.minlon = bounds.lng
  101.     this.maxlon = bounds.lng
  102.   }
  104.   var props = ['minlon', 'minlat', 'maxlon', 'maxlat']
  105.   for (var i = 0; i < props.length; i++) {
  106.     k = props[i]
  107.     if (k in bounds) {
  108.       this[k] = bounds[k]
  109.     }
  110.   }
  112.   this._wrap()
  113. }
  115. BoundingBox.prototype.wrapMaxLon = function () {
  116.   return (this.minlon > this.maxlon) ? this.maxlon + 360 : this.maxlon
  117. }
  119. BoundingBox.prototype.wrapMinLon = function () {
  120.   return (this.minlon > this.maxlon) ? this.minlon - 360 : this.minlon
  121. }
  123. BoundingBox.prototype._wrap = function () {
  124.   if (this.minlon < -180 || this.minlon > 180) {
  125.     this.minlon = (this.minlon + 180) % 360 - 180
  126.   }
  127.   if (this.maxlon < -180 || this.maxlon > 180) {
  128.     this.maxlon = (this.maxlon + 180) % 360 - 180
  129.   }
  131.   return this
  132. }
  134. /**
  135.   * Checks whether the other bounding box intersects (shares any portion of space) the current object.
  136.  * @param {BoundingBox} other Other boundingbox to check for
  137.  * @return {boolean} true if the bounding boxes intersect
  138.  * @example
  139.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  140.  * var bbox2 = new BoundingBox({ lat: 48.5, lon: 16.267 })
  141.  * console.log(bbox.intersects(bbox2)) // true
  142.  */
  143. BoundingBox.prototype.intersects = function (other) {
  144.   if (!(other instanceof BoundingBox)) {
  145.     other = new BoundingBox(other)
  146.   }
  148.   if (other.maxlat < this.minlat) {
  149.     return false
  150.   }
  152.   if (other.minlat > this.maxlat) {
  153.     return false
  154.   }
  156.   if (other.wrapMaxLon() < this.wrapMinLon()) {
  157.     return false
  158.   }
  160.   if (other.wrapMinLon() > this.wrapMaxLon()) {
  161.     return false
  162.   }
  164.   return true
  165. }
  167. /**
  168.  * Checks whether the current object is fully within the other bounding box.
  169.  * @param {BoundingBox} other Other boundingbox to check for
  170.  * @return {boolean} true if the bounding boxes is within other
  171.  * @example
  172.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  173.  * var bbox2 = new BoundingBox({ lat: 48.5, lon: 16.267 })
  174.  * console.log(bbox2.within(bbox)) // true
  175.  */
  176. BoundingBox.prototype.within = function (other) {
  177.   if (!(other instanceof BoundingBox)) {
  178.     other = new BoundingBox(other)
  179.   }
  181.   if (other.maxlat < this.maxlat) {
  182.     return false
  183.   }
  185.   if (other.minlat > this.minlat) {
  186.     return false
  187.   }
  189.   if (other.wrapMaxLon() < this.wrapMaxLon()) {
  190.     return false
  191.   }
  193.   if (other.wrapMinLon() > this.wrapMinLon()) {
  194.     return false
  195.   }
  197.   return true
  198. }
  200. BoundingBox.prototype.toTile = function () {
  201.   return new BoundingBox({
  202.     minlat: Math.floor(this.minlat * 10) / 10,
  203.     minlon: Math.floor(this.minlon * 10) / 10,
  204.     maxlat: Math.ceil(this.maxlat * 10) / 10,
  205.     maxlon: Math.ceil(this.maxlon * 10) / 10
  206.   })
  207. }
  209. /**
  210.  * return the bounding box as lon-lat string, e.g. '179.5,55,-179.5,56'
  211.  * @return {string}
  212.  * @example
  213.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  214.  * console.log(bbox.toLonLatString()) // '16.23,48.123,16.367,49.012'
  215.  */
  216. BoundingBox.prototype.toLonLatString = function () {
  217.   return this.minlon + ',' +
  218.          this.minlat + ',' +
  219.          this.maxlon + ',' +
  220.          this.maxlat
  221. }
  223. /**
  224.  * return the bounding box as lon-lat string, e.g. '179.5,55,-179.5,56'. Useful for sending requests to web services that return geo data.
  225.  * @return {string}
  226.  * @example
  227.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  228.  * console.log(bbox.toBBoxString()) // '16.23,48.123,16.367,49.012'
  229.  */
  230. BoundingBox.prototype.toBBoxString = BoundingBox.prototype.toLonLatString
  232. /**
  233.  * return the bounding box as lon-lat string, e.g. '55,179.5,56,-179.5'. Useful e.g. for Overpass API requests.
  234.  * @return {string}
  235.  * @example
  236.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  237.  * console.log(bbox.toLatLonString()) // '48.123,16.23,49.012,16.367'
  238.  */
  239. BoundingBox.prototype.toLatLonString = function () {
  240.   return this.minlat + ',' +
  241.          this.minlon + ',' +
  242.          this.maxlat + ',' +
  243.          this.maxlon
  244. }
  246. /**
  247.  * return the diagonal length (length of hypothenuse).
  248.  * @return {number}
  249.  * @example
  250.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  251.  * console.log(bbox.diagonalLength()) // 0.8994943023721748
  252.  */
  253. BoundingBox.prototype.diagonalLength = function () {
  254.   var dlat = this.maxlat - this.minlat
  255.   var dlon = this.wrapMaxLon() - this.minlon
  257.   return Math.sqrt(dlat * dlat + dlon * dlon)
  258. }
  260. /**
  261.  * return the diagonal distance (using the haversine function). See https://github.com/njj/haversine for further details.
  262.  * @param {object} [options] Options
  263.  * @param {string} [options.unit=km] Unit of measurement applied to result ('km', 'mile', 'meter', 'nmi')
  264.  * @param {number} [options.threshold] If passed, will result in library returning boolean value of whether or not the start and end points are within that supplied threshold.
  265.  * @return {number}
  266.  * @example
  267.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  268.  * console.log(bbox.diagonalDistance({ unit: 'm' })) // 99.36491328576697
  269.  */
  270. BoundingBox.prototype.diagonalDistance = function (options = {}) {
  271.   return haversine(
  272.     { latitude: this.minlat, longitude: this.minlon },
  273.     { latitude: this.maxlat, longitude: this.maxlon },
  274.     options
  275.   )
  276. }
  278. /**
  279.  * Returns the center point of the bounding box as { lat, lon }
  280.  * @return {object}
  281.  * @example
  282.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  283.  * console.log(bbox.getCenter()) // { lat: 48.567499999999995, lon: 16.2985 }
  284.  */
  285. BoundingBox.prototype.getCenter = function () {
  286.   var dlat = this.maxlat - this.minlat
  287.   var dlon = this.wrapMaxLon() - this.minlon
  288.   let lon = this.minlon + dlon / 2
  289.   if (lon < -180 || lon > 180) {
  290.     lon = (lon + 180) % 360 - 180
  291.   }
  293.   return {
  294.     lat: this.minlat + dlat / 2,
  295.     lon
  296.   }
  297. }
  299. /**
  300.  * get Northern boundary (latitude)
  301.  * @param {number}
  302.  */
  303. BoundingBox.prototype.getNorth = function () {
  304.   return this.maxlat
  305. }
  307. /**
  308.  * get Southern boundary (latitude)
  309.  * @param {number}
  310.  */
  311. BoundingBox.prototype.getSouth = function () {
  312.   return this.minlat
  313. }
  315. /**
  316.  * get Eastern boundary (longitude)
  317.  * @param {number}
  318.  */
  319. BoundingBox.prototype.getEast = function () {
  320.   return this.maxlon
  321. }
  323. /**
  324.  * get Western boundary (longitude)
  325.  * @param {number}
  326.  */
  327. BoundingBox.prototype.getWest = function () {
  328.   return this.minlon
  329. }
  331. /**
  332.  * extends current boundary by the other boundary
  333.  * @param {BoundingBox} other
  334.  * @example
  335.  * var bbox1 = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  336.  * var bbox2 = new BoundingBox({ minlat: 48.000, minlon: 16.23, maxlat: 49.012, maxlon: 16.789 })
  337.  * bbox1.extend(bbox2)
  338.  * console.log(bbox1.bounds) // { minlat: 48, minlon: 16.23, maxlat: 49.012, maxlon: 16.789 }
  339.  */
  340. BoundingBox.prototype.extend = function (other) {
  341.   if (!(other instanceof BoundingBox)) {
  342.     other = new BoundingBox(other)
  343.   }
  345.   if (other.minlat < this.minlat) {
  346.     this.minlat = other.minlat
  347.   }
  349.   if (other.maxlat > this.maxlat) {
  350.     this.maxlat = other.maxlat
  351.   }
  353.   // does bounds intersect with other bounds in longitude?
  354.   for (let shift = -360; shift <= 360; shift += 360) {
  355.     if (other.wrapMaxLon() + shift > this.minlon && other.minlon + shift < this.wrapMaxLon()) {
  356.       this.minlon = Math.min(this.minlon, other.minlon + shift)
  357.       this.maxlon = Math.max(this.wrapMaxLon(), other.wrapMaxLon() + shift)
  359.       this._wrap()
  360.       return
  361.     }
  362.   }
  364.   let min1 = Math.min(this.minlon, other.minlon)
  365.   let min2 = Math.max(this.minlon, other.minlon)
  366.   let max1 = Math.max(this.wrapMaxLon(), other.wrapMaxLon())
  367.   let max2 = Math.min(this.wrapMaxLon(), other.wrapMaxLon())
  369.   if (max1 - min1 < max2 - min2 + 360) {
  370.     this.minlon = min1
  371.     this.maxlon = max1
  372.   } else {
  373.     this.minlon = min2
  374.     this.maxlon = max2
  375.   }
  377.   this._wrap()
  378. }
  380. /**
  381.  * Returns the bounding box as GeoJSON feature. In case of bounding boxes crossing the antimeridian, this function will return a multipolygon with the parts on each side of the antimeridian (as specified in RFC 7946, section 3.1.9).
  382.  * @return {object}
  383.  * @example
  384.  * var bbox = new BoundingBox({ minlat: 48.123, minlon: 16.23, maxlat: 49.012, maxlon: 16.367 })
  385.  * bbox.toGeoJSON()
  386.  * // {
  387.  * //   "type": "Feature",
  388.  * //   "properties": {},
  389.  * //   "geometry": {
  390.  * //     "type": "Polygon",
  391.  * //     "coordinates": [
  392.  * //       [
  393.  * //         [ 16.23, 48.123 ],
  394.  * //         [ 16.367, 48.123 ],
  395.  * //         [ 16.367, 49.012 ],
  396.  * //         [ 16.23, 49.012 ],
  397.  * //         [ 16.23, 48.123 ]
  398.  * //       ]
  399.  * //     ]
  400.  * //   }
  401.  * // }
  402.  */
  403. BoundingBox.prototype.toGeoJSON = function () {
  404.   if (this.minlon > this.maxlon) {
  405.     return {
  406.       type: 'Feature',
  407.       properties: {},
  408.       geometry: {
  409.         'type': 'MultiPolygon',
  410.         'coordinates': [
  411.           [[
  412.             [ this.minlon, this.minlat ],
  413.             [ 180, this.minlat ],
  414.             [ 180, this.maxlat ],
  415.             [ this.minlon, this.maxlat ],
  416.             [ this.minlon, this.minlat ]
  417.           ]],
  418.           [[
  419.             [ -180, this.minlat ],
  420.             [ this.maxlon, this.minlat ],
  421.             [ this.maxlon, this.maxlat ],
  422.             [ -180, this.maxlat ],
  423.             [ -180, this.minlat ]
  424.           ]]
  425.         ]
  426.       }
  427.     }
  428.   }
  430.   return {
  431.     type: 'Feature',
  432.     properties: {},
  433.     geometry: {
  434.       'type': 'Polygon',
  435.       'coordinates': [[
  436.         [ this.minlon, this.minlat ],
  437.         [ this.maxlon, this.minlat ],
  438.         [ this.maxlon, this.maxlat ],
  439.         [ this.minlon, this.maxlat ],
  440.         [ this.minlon, this.minlat ]
  441.       ]]
  442.     }
  443.   }
  444. }
  446. /**
  447.  * Returns the bounding box as L.latLngBounds object. Leaflet must be included separately!
  448.  * @param {object} [options] Options.
  449.  * @param {number[]} [options.shiftWorld=[0, 0]] Shift the world by the first value for the Western hemisphere (lon < 0) or the second value for the Eastern hemisphere (lon >= 0).
  450.  */
  451. BoundingBox.prototype.toLeaflet = function (options = {}) {
  452.   if (!('shiftWorld' in options)) {
  453.     options.shiftWorld = [ 0, 0 ]
  454.   }
  456.   return L.latLngBounds(
  457.     L.latLng(this.minlat, this.minlon + (this.minlon < 0 ? options.shiftWorld[0] : options.shiftWorld[1])),
  458.     L.latLng(this.maxlat, this.maxlon + (this.maxlon < 0 ? options.shiftWorld[0] : options.shiftWorld[1]))
  459.   )
  460. }
  462. if (typeof module !== 'undefined' && module.exports) {
  463.   module.exports = BoundingBox
  464. }
  465. if (typeof window !== 'undefined') {
  466.   window.BoundingBox = BoundingBox
  467. }