geojs 1.4.0 → 1.5.0

package/geo.js

@@ -33500,8 +33500,10 @@ function continuousVerticesProcessAction(m_this, evt, name) {
   }
   var cpp = layer.options('continuousPointProximity');
   var cpc = layer.options('continuousPointColinearity');
+  var ccp = layer.options('continuousCloseProximity');
   if (cpp || cpp === 0) {
     var vertices = m_this.options('vertices');
+    var update = false;
     if (!vertices.length) {
       vertices.push(evt.mouse.mapgcs);
       vertices.push(evt.mouse.mapgcs);
@@ -33523,8 +33525,17 @@ function continuousVerticesProcessAction(m_this, evt, name) {
       }
       vertices[vertices.length - 1] = evt.mouse.mapgcs;
       vertices.push(evt.mouse.mapgcs);
-      return true;
+      update = true;
+    }
+    if ((ccp || ccp === 0) && evt.event === geo_event.actionup && (ccp === true || layer.displayDistance(vertices[0], null, evt.mouse.map, 'display') <= cpp)) {
+      if (vertices.length < 3 + (name === 'polygon' ? 1 : 0)) {
+        return 'remove';
+      }
+      vertices.pop();
+      m_this.state(annotationState.done);
+      return 'done';
     }
+    return update;
   }
 }
 
@@ -46108,8 +46119,11 @@ var transform = __webpack_require__(17);
  * @property {number} [minIntensity=null] Minimum intensity of the data.
  *   Minimum intensity must be a positive real number and is used to normalize
  *   all intensities within a dataset.  If `null`, it is computed.
- * @property {number} [updateDelay=1000] Delay in milliseconds after a zoom,
- *   rotate, or pan event before recomputing the heatmap.
+ * @property {number} [updateDelay=-1] Delay in milliseconds after a zoom,
+ *   rotate, or pan event before recomputing the heatmap.  If 0, this is double
+ *   the last render time.  If negative, it is roughly the last render time
+ *   plus the absolute value of the specified number of refresh intervals.
+ *   compute a delay based on the last heatmap render time.
  * @property {boolean|number|'auto'} [binned='auto'] If `true` or a number,
  *   spatially bin data as part of producing the heatmap.  If falsy, each
  *   datapoint stands on its own.  If `'auto'`, bin data if there are more data
@@ -46126,6 +46140,11 @@ var transform = __webpack_require__(17);
  *   approximation.  The total weight of the gaussian area is approximately the
  *   `9/16 r^2`.  The sum of `radius + blurRadius` is used as the radius for
  *   the gaussian distribution.
+ * @property {boolean} [scaleWithZoom=false] If truthy, the value for radius
+ *   and blurRadius scale with zoom.  In this case, the values for radius and
+ *   blurRadius are the values at zoom-level zero.  If the scaled radius is
+ *   less than 0.5 or more than 8192 screen pixels, the heatmap will not
+ *   render.
  */
 
 /**
@@ -46170,7 +46189,7 @@ var heatmapFeature = function heatmapFeature(arg) {
   m_maxIntensity = arg.maxIntensity !== undefined ? arg.maxIntensity : null;
   m_minIntensity = arg.minIntensity !== undefined ? arg.minIntensity : null;
   m_binned = arg.binned !== undefined ? arg.binned : 'auto';
-  m_updateDelay = arg.updateDelay ? parseInt(arg.updateDelay, 10) : 1000;
+  m_updateDelay = arg.updateDelay || arg.updateDelay === 0 ? parseInt(arg.updateDelay, 10) : -1;
 
   /**
    * Get/Set maxIntensity.
@@ -46215,7 +46234,9 @@ var heatmapFeature = function heatmapFeature(arg) {
    *
    * @param {number} [val] If not specified, return the current update delay.
    *    If specified, this is the delay in milliseconds after a zoom, rotate,
-   *    or pan event before recomputing the heatmap.
+   *    or pan event before recomputing the heatmap.  If 0, this is double the
+   *    last render time.  If negative, it is roughly the last render time plus
+   *    the absolute value of the specified number of refresh intervals.
    * @returns {number|this}
    */
   this.updateDelay = function (val) {
@@ -46325,7 +46346,8 @@ var heatmapFeature = function heatmapFeature(arg) {
         0.25: { r: 0, g: 0, b: 1, a: 0.5 },
         0.5: { r: 0, g: 1, b: 1, a: 0.6 },
         0.75: { r: 1, g: 1, b: 0, a: 0.7 },
-        1: { r: 1, g: 0, b: 0, a: 0.8 } }
+        1: { r: 1, g: 0, b: 0, a: 0.8 } },
+      scaleWithZoom: false
     }, arg.style === undefined ? {} : arg.style);
 
     m_this.style(defaultStyle);
@@ -58749,6 +58771,7 @@ module.exports.mockWebglRenderer = function mockWebglRenderer(supported) {
     enable: noop('enable'),
     enableVertexAttribArray: noop('enableVertexAttribArray'),
     finish: noop('finish'),
+    getError: noop('getError'),
     getExtension: incID('getExtension'),
     getParameter: function getParameter(key) {
       count('getParameter');
@@ -72079,6 +72102,10 @@ var textFeature = __webpack_require__(80);
  * @property {number} [continuousPointColinearity=1.0deg] The minimum angle
  *   between a series of three points when dragging to not interpret them as
  *   colinear.  Only applies if `continuousPointProximity` is not `false`.
+ * @property {number} [continuousCloseProximity=10] The minimum distance in
+ *   display coordinates (pixels) to close a polygon or end drawing a line when
+ *   dragging to create an annotation.  `false` never closes at the end of a
+ *   drag.  `true` is effectively infinite.
  * @property {number} [finalPointProximity=10] The maximum distance in display
  *   coordinates (pixels) between the starting point and the mouse coordinates
  *   to signal closing a polygon.  A value of 0 requires an exact match.  A
@@ -72185,6 +72212,7 @@ var annotationLayer = function annotationLayer(arg) {
     // in radians, minimum angle between continuous points to interpret them as
     // being coliner
     continuousPointColinearity: 1.0 * Math.PI / 180,
+    continuousCloseProximity: 10, // in pixels, 0 is exact
     finalPointProximity: 10, // in pixels, 0 is exact
     showLabels: true,
     clickToEdit: false
@@ -89111,6 +89139,9 @@ osmLayer.defaults = $.extend({}, tileLayer.defaults, {
  * http://{s}.tile.stamen.com/toner-lite/{z}/{x}/{y}.png */
 var StamenAttribution = 'Map tiles by <a href="http://stamen.com">Stamen ' + 'Design</a>, under <a href="http://creativecommons.org/licenses/by/3.0">' + 'CC BY 3.0</a>. Data by <a href="http://openstreetmap.org">OpenStreetMap' + '</a>, under <a href="http://www.openstreetmap.org/copyright">ODbL</a>.';
 
+/* Per Carto's website regarding basemap attribution: https://carto.com/help/working-with-data/attribution/#basemaps */
+var CartoAttribution = '<a href="https://carto.com"> Carto</a> ' + 'Contributors <a href="https://www.openstreetmap.org/"> OpenStreetMap</a>';
+
 /**
  * This is a list of known tile sources.  It can be added to via
  * `geo.osmLayer.tilesource[<key>] = <object>`, where the object has `url`,
@@ -89119,22 +89150,53 @@ var StamenAttribution = 'Map tiles by <a href="http://stamen.com">Stamen ' + 'De
  * @type {object}
  */
 osmLayer.tileSources = {
+  'dark-matter-with-labels': {
+    url: ' https://{s}.basemaps.cartocdn.com/rastertiles/dark_all/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Dark Matter With Labels',
+    minLevel: 0,
+    maxLevel: 18
+  },
+  'dark-matter-without-labels': {
+    url: 'https://{s}.basemaps.cartocdn.com/rastertiles/dark_nolabels/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Dark Matter Without Labels',
+    minLevel: 0,
+    maxLevel: 18
+  },
   'nationalmap-satellite': {
     url: 'https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}',
     attribution: 'Tile data from <a href="https://basemap.nationalmap.gov/">USGS</a>',
+    name: 'National Map Satellite',
     minLevel: 0,
     maxLevel: 16
   },
   osm: {
     url: 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
     attribution: 'Tile data &copy; <a href="https://osm.org/copyright">' + 'OpenStreetMap</a> contributors',
+    name: 'OpenStreetMap',
     subdomains: 'abc',
     minLevel: 0,
     maxLevel: 19
   },
+  'positron-with-labels': {
+    url: 'https://{s}.basemaps.cartocdn.com/rastertiles/light_all/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Positron With Labels',
+    minLevel: 0,
+    maxLevel: 18
+  },
+  'positron-without-labels': {
+    url: 'https://{s}.basemaps.cartocdn.com/rastertiles/light_nolabels/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Positron Without Labels',
+    minLevel: 0,
+    maxLevel: 18
+  },
   'stamen-terrain': {
     url: 'https://stamen-tiles-{s}.a.ssl.fastly.net/terrain/{z}/{x}/{y}.png',
     attribution: StamenAttribution,
+    name: 'Stamen Terrain',
     subdomains: 'abcd',
     minLevel: 0,
     maxLevel: 14
@@ -89142,6 +89204,7 @@ osmLayer.tileSources = {
   'stamen-terrain-background': {
     url: 'https://stamen-tiles-{s}.a.ssl.fastly.net/terrain-background/{z}/{x}/{y}.png',
     attribution: StamenAttribution,
+    name: 'Stamen Terrain Background',
     subdomains: 'abcd',
     minLevel: 0,
     maxLevel: 14
@@ -89149,6 +89212,7 @@ osmLayer.tileSources = {
   'stamen-toner': {
     url: 'https://stamen-tiles-{s}.a.ssl.fastly.net/toner/{z}/{x}/{y}.png',
     attribution: StamenAttribution,
+    name: 'Stamen Toner',
     subdomains: 'abcd',
     minLevel: 0,
     maxLevel: 20
@@ -89156,15 +89220,24 @@ osmLayer.tileSources = {
   'stamen-toner-lite': {
     url: 'https://stamen-tiles-{s}.a.ssl.fastly.net/toner-lite/{z}/{x}/{y}.png',
     attribution: StamenAttribution,
+    name: 'Stamen Toner Lite',
     subdomains: 'abcd',
     minLevel: 0,
     maxLevel: 20
   },
-  'wikimedia': {
-    url: 'https://maps.wikimedia.org/osm-intl/{z}/{x}/{y}.png',
-    attribution: '<a href="https://wikimediafoundation.org/wiki/Maps_Terms_of_Use">Wikimedia maps</a> | Map data &copy; <a href="http://openstreetmap.org/copyright">OpenStreetMap contributors</a>',
+  'voyager-with-labels': {
+    url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager_labels_under/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Voyager With Labels',
     minLevel: 0,
-    maxLevel: 19
+    maxLevel: 18
+  },
+  'voyager-without-layers': {
+    url: 'https://{s}.basemaps.cartocdn.com/rastertiles/voyager_nolabels/{z}/{x}/{y}.png',
+    attribution: CartoAttribution,
+    name: 'Carto Voyager Without Layers',
+    minLevel: 0,
+    maxLevel: 18
   }
 };
 
@@ -89435,7 +89508,7 @@ module.exports = osmLayer;
  * @constant
  * @type {string}
  */
-module.exports = "1.4.0";
+module.exports = "1.5.0";
 
 /***/ }),
 /* 630 */
@@ -89453,7 +89526,7 @@ module.exports = "1.4.0";
  * @constant
  * @type {string}
  */
-module.exports = "b5a6d9aaf6dab70f9a45588dcc5e8a8828023042";
+module.exports = "29ceeda3ffe254a1300d6237e88b3f5bc480c4fa";
 
 /***/ }),
 /* 631 */
@@ -89724,6 +89797,7 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
       m_heatMapTransform,
       s_init = this._init,
       s_update = this._update,
+      m_lastRenderDuration,
       m_renderTime = timestamp();
 
   /**
@@ -89757,15 +89831,22 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
   };
 
   /**
-   * Create circle for each data point.
+   * Create a circle to render at each data point.
    *
    * @returns {this}
    */
   this._createCircle = function () {
-    var circle, ctx, r, r2, blur, gaussian;
+    var circle, ctx, r, r2, blur, gaussian, scale;
     r = m_this.style('radius');
     blur = m_this.style('blurRadius');
     gaussian = m_this.style('gaussian');
+    scale = m_this.style('scaleWithZoom');
+    if (scale) {
+      var zoom = this.layer().map().zoom();
+      scale = Math.pow(2, zoom);
+      r *= scale;
+      blur *= scale;
+    }
     if (!m_this._circle || m_this._circle.gaussian !== gaussian || m_this._circle.radius !== r || m_this._circle.blurRadius !== blur) {
       circle = m_this._circle = document.createElement('canvas');
       ctx = circle.getContext('2d');
@@ -89990,6 +90071,7 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
   this._renderOnCanvas = function (context2d, map) {
 
     if (m_renderTime.timestamp() < m_this.buildTime().timestamp()) {
+      var starttime = Date.now();
       var data = m_this.data() || [],
           radius = m_this.style('radius') + m_this.style('blurRadius'),
           binned = m_this.binned(),
@@ -89998,9 +90080,12 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
           layer = m_this.layer(),
           mapSize = map.size();
 
+      if (m_this.style('scaleWithZoom')) {
+        radius *= Math.pow(2, map.zoom());
+      }
       /* Determine if we should bin the data */
       if (binned === true || binned === 'auto') {
-        binned = Math.max(Math.floor(radius / 8), 3);
+        binned = Math.max(Math.floor(radius / 8), Math.max(1.5, Math.min(3, radius / 2.5)));
         if (m_this.binned() === 'auto') {
           var numbins = Math.ceil((mapSize.width + radius * 2) / binned) * Math.ceil((mapSize.height + radius * 2) / binned);
           if (numbins >= data.length) {
@@ -90017,20 +90102,22 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
       context2d.setTransform(1, 0, 0, 1, 0, 0);
       context2d.clearRect(0, 0, mapSize.width, mapSize.height);
       m_heatMapTransform = '';
-      map.scheduleAnimationFrame(m_this._setTransform, false);
-      layer.canvas().css({ transform: '' });
-
-      m_this._createCircle();
-      m_this._computeGradient();
-      if (!binned) {
-        m_this._renderPoints(context2d, map, data, radius);
-      } else {
-        m_this._renderBinnedData(context2d, map, data, radius, binned);
+      if (radius > 0.5 && radius < 8192) {
+        map.scheduleAnimationFrame(m_this._setTransform, false);
+        layer.canvas().css({ transform: '' });
+
+        m_this._createCircle();
+        m_this._computeGradient();
+        if (!binned) {
+          m_this._renderPoints(context2d, map, data, radius);
+        } else {
+          m_this._renderBinnedData(context2d, map, data, radius, binned);
+        }
+        canvas = layer.canvas()[0];
+        pixelArray = context2d.getImageData(0, 0, canvas.width, canvas.height);
+        m_this._colorize(pixelArray.data, m_this._grad);
+        context2d.putImageData(pixelArray, 0, 0);
       }
-      canvas = layer.canvas()[0];
-      pixelArray = context2d.getImageData(0, 0, canvas.width, canvas.height);
-      m_this._colorize(pixelArray.data, m_this._grad);
-      context2d.putImageData(pixelArray, 0, 0);
 
       m_heatMapPosition = {
         zoom: map.zoom(),
@@ -90042,6 +90129,7 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
       };
       m_renderTime.modified();
       layer.renderer().clearCanvas(false);
+      m_lastRenderDuration = Date.now() - starttime;
     }
 
     return m_this;
@@ -90122,6 +90210,14 @@ var canvas_heatmapFeature = function canvas_heatmapFeature(arg) {
      * close to where the heatmap was originally computed, don't bother
      * updating it. */
     if (parseFloat(scale.toFixed(4)) !== 1 || parseFloat((rotation - m_heatMapPosition.rotation).toFixed(4)) !== 0 || parseFloat(origin.x.toFixed(1)) !== 0 || parseFloat(origin.y.toFixed(1)) !== 0) {
+      var delay = m_this.updateDelay();
+      if (delay < 0 && m_lastRenderDuration) {
+        delay = m_lastRenderDuration - Math.floor(1000 / 60 * delay);
+      } else if (m_lastRenderDuration) {
+        delay = m_lastRenderDuration * 2;
+      } else {
+        delay = 100;
+      }
       m_heatMapPosition.timeout = window.setTimeout(function () {
         m_heatMapPosition.timeout = undefined;
         m_this.buildTime().modified();
@@ -96179,7 +96275,9 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
         return;
       }
       quad.texture.bind(renderState);
-
+      if (context.getError() === context.OUT_OF_MEMORY) {
+        console.log('Insufficient GPU memory for texture');
+      }
       if (quad.opacity !== opacity) {
         opacity = quad.opacity;
         context.uniform1fv(renderState.m_material.shaderProgram().uniformLocation('opacity'), new Float32Array([opacity]));