geojs 1.8.2 → 1.8.5

package/geo.lean.js

@@ -303,7 +303,7 @@ var annotation = function annotation(type, args) {
 
   this._rotateHandlePosition = function (offset, rotation) {
     var map = m_this.layer().map(),
-        coor = m_this._coordinates(),
+        coord = m_this._coordinates(),
         center = util.centerFromPerimeter(m_this._coordinates()),
         dispCenter = center ? map.gcsToDisplay(center, null) : undefined,
         i,
@@ -317,9 +317,10 @@ var annotation = function annotation(type, args) {
 
     offset = offset || 0;
     rotation = rotation || 0;
+    coord = coord.outer ? coord.outer : coord;
 
-    for (i = 0; i < coor.length; i += 1) {
-      pos = map.gcsToDisplay(coor[i], null);
+    for (i = 0; i < coord.length; i += 1) {
+      pos = map.gcsToDisplay(coord[i], null);
       maxr2 = Math.max(maxr2, Math.pow(pos.x - dispCenter.x, 2) + Math.pow(pos.y - dispCenter.y, 2));
     }
 
@@ -511,6 +512,30 @@ var annotation = function annotation(type, args) {
         return m_this._processEditActionResize(evt);
     }
   };
+  /**
+   * Return a copy of the _coordinates or a geo.polygon record so that it
+   * doesn't share memory with the original.
+   *
+   * @param {geo.polygon} [coord] if specified, return a copy of this object.
+   *   Otherwise, return a copy of this._coordinates.
+   * @returns {geo.polygon}
+   */
+
+
+  this._copyOfCoordinates = function (coord) {
+    coord = coord || m_this._coordinates();
+
+    if (!coord.outer) {
+      return coord.slice();
+    }
+
+    return {
+      outer: coord.outer.slice(),
+      inner: (coord.inner || []).map(function (h) {
+        return h.slice();
+      })
+    };
+  };
   /**
    * When an edit handle is selected or deselected (for instance, by moving the
    * mouse on or off of it), mark if it is selected and record the current
@@ -532,7 +557,7 @@ var annotation = function annotation(type, args) {
     var amountRotated = (m_this._editHandle || {}).amountRotated || 0;
     m_this._editHandle = {
       handle: handle,
-      startCoordinates: m_this._coordinates().slice(),
+      startCoordinates: m_this._copyOfCoordinates(),
       center: util.centerFromPerimeter(m_this._coordinates()),
       rotatePosition: m_this._rotateHandlePosition(handle.style.rotateHandleOffset, handle.style.rotateHandleRotation + amountRotated),
       startAmountRotated: amountRotated,
@@ -592,10 +617,10 @@ var annotation = function annotation(type, args) {
     }
 
     if (m_options.coordinates) {
-      var coor = m_options.coordinates;
+      var coord = m_options.coordinates;
       delete m_options.coordinates;
 
-      m_this._coordinates(coor);
+      m_this._coordinates(coord);
     }
 
     if (m_options.name !== undefined) {
@@ -829,7 +854,7 @@ var annotation = function annotation(type, args) {
       gcs = gcs === null ? map.gcs() : gcs === undefined ? map.ingcs() : gcs;
 
       if (gcs !== map.gcs()) {
-        coord = transform.transformCoordinates(map.gcs(), gcs, coord);
+        coord = m_this._convertCoordinates(map.gcs(), gcs, coord);
       }
     }
 
@@ -912,7 +937,7 @@ var annotation = function annotation(type, args) {
 
 
   this.geojson = function (gcs, includeCrs) {
-    var coor = m_this._geojsonCoordinates(gcs),
+    var coord = m_this._geojsonCoordinates(gcs),
         geotype = m_this._geojsonGeometryType(),
         styles = m_this._geojsonStyles(),
         objStyle = m_this.options('style') || {},
@@ -921,7 +946,7 @@ var annotation = function annotation(type, args) {
         key,
         value;
 
-    if (!coor || !coor.length || !geotype) {
+    if (!coord || !coord.length || !geotype) {
       return;
     }
 
@@ -929,7 +954,7 @@ var annotation = function annotation(type, args) {
       type: 'Feature',
       geometry: {
         type: geotype,
-        coordinates: coor
+        coordinates: coord
       },
       properties: {
         annotationType: m_type,
@@ -1027,39 +1052,45 @@ var annotation = function annotation(type, args) {
     }
 
     editPoints = features[editHandleFeatureLevel].point;
-    vertices.forEach(function (pt, idx) {
-      if (opts.vertex !== false) {
-        editPoints.push($.extend({}, pt, {
-          type: 'vertex',
-          index: idx,
-          style: style,
-          editHandle: true
-        }));
-      }
-
-      if (opts.edge !== false && idx !== vertices.length - 1 && (pt.x !== vertices[idx + 1].x || pt.y !== vertices[idx + 1].y)) {
-        editPoints.push($.extend({
-          x: (pt.x + vertices[idx + 1].x) / 2,
-          y: (pt.y + vertices[idx + 1].y) / 2
-        }, {
-          type: 'edge',
-          index: idx,
-          style: style,
-          editHandle: true
-        }));
-      }
+    var vertexList = vertices.outer ? [vertices.outer].concat(vertices.inner || []) : [vertices];
+    vertexList.forEach(function (vert, vidx) {
+      vert.forEach(function (pt, idx) {
+        if (opts.vertex !== false) {
+          editPoints.push($.extend({}, pt, {
+            type: 'vertex',
+            index: idx,
+            vindex: vidx,
+            style: style,
+            editHandle: true
+          }));
+        }
 
-      if (opts.edge !== false && !isOpen && idx === vertices.length - 1 && (pt.x !== vertices[0].x || pt.y !== vertices[0].y)) {
-        editPoints.push($.extend({
-          x: (pt.x + vertices[0].x) / 2,
-          y: (pt.y + vertices[0].y) / 2
-        }, {
-          type: 'edge',
-          index: idx,
-          style: style,
-          editHandle: true
-        }));
-      }
+        if (opts.edge !== false && idx !== vert.length - 1 && (pt.x !== vert[idx + 1].x || pt.y !== vert[idx + 1].y)) {
+          editPoints.push($.extend({
+            x: (pt.x + vert[idx + 1].x) / 2,
+            y: (pt.y + vert[idx + 1].y) / 2
+          }, {
+            type: 'edge',
+            index: idx,
+            vindex: vidx,
+            style: style,
+            editHandle: true
+          }));
+        }
+
+        if (opts.edge !== false && !isOpen && idx === vert.length - 1 && (pt.x !== vert[0].x || pt.y !== vert[0].y)) {
+          editPoints.push($.extend({
+            x: (pt.x + vert[0].x) / 2,
+            y: (pt.y + vert[0].y) / 2
+          }, {
+            type: 'edge',
+            index: idx,
+            vindex: vidx,
+            style: style,
+            editHandle: true
+          }));
+        }
+      });
     });
 
     if (opts.center !== false) {
@@ -1092,12 +1123,47 @@ var annotation = function annotation(type, args) {
 
     if (selected) {
       editPoints.forEach(function (pt) {
-        if (pt.type === selected.type && pt.index === selected.index) {
+        if (pt.type === selected.type && pt.index === selected.index && pt.vindex === selected.vindex) {
           pt.selected = true;
         }
       });
     }
   };
+  /**
+   * Apply a map function of a geo.polygon.
+   *
+   * @param {geo.polygon} coord The polygon to apply the function to.
+   * @param {function} func The function to apply.
+   * @returns {array} The map results.
+   */
+
+
+  this._coordinatesMapFunc = function (coord, func) {
+    if (!coord.outer) {
+      return coord.map(func);
+    }
+
+    return {
+      outer: coord.outer.map(func),
+      inner: (coord.inner || []).map(function (h) {
+        return h.map(func);
+      })
+    };
+  };
+  /**
+   * Check if two geo.polygons differ in their first point.
+   *
+   * @param {geo.polygon} coord1 One polygon to compare.
+   * @param {geo.polygon} coord2 A second polygon to compare.
+   * @returns {boolean} true if the first point matches.
+   */
+
+
+  this._firstPointDifferent = function (coord1, coord2) {
+    coord1 = coord1.outer ? coord1.outer : coord1;
+    coord2 = coord2.outer ? coord2.outer : coord2;
+    return coord1[0].x !== coord2[0].x || coord1[0].y !== coord2[0].y;
+  };
   /**
    * Process the edit center action for a general annotation.
    *
@@ -1115,14 +1181,14 @@ var annotation = function annotation(type, args) {
     },
         curPts = m_this._coordinates();
 
-    var pts = start.map(function (elem) {
+    var pts = m_this._coordinatesMapFunc(start, function (elem) {
       return {
         x: elem.x + delta.x,
         y: elem.y + delta.y
       };
     });
 
-    if (pts[0].x !== curPts[0].x || pts[0].y !== curPts[0].y) {
+    if (m_this._firstPointDifferent(pts, curPts)) {
       m_this._coordinates(pts);
 
       return true;
@@ -1151,7 +1217,7 @@ var annotation = function annotation(type, args) {
         ang = ang2 - ang1,
         curPts = m_this._coordinates();
 
-    var pts = start.map(function (elem) {
+    var pts = m_this._coordinatesMapFunc(start, function (elem) {
       var delta = {
         x: elem.x - handle.center.x,
         y: elem.y - handle.center.y
@@ -1162,7 +1228,7 @@ var annotation = function annotation(type, args) {
       };
     });
 
-    if (pts[0].x !== curPts[0].x || pts[0].y !== curPts[0].y) {
+    if (m_this._firstPointDifferent(pts, curPts)) {
       m_this._coordinates(pts);
 
       handle.amountRotated = handle.startAmountRotated + ang;
@@ -1200,14 +1266,15 @@ var annotation = function annotation(type, args) {
 
     if (d02 && d01) {
       var scale = d02 / d01;
-      var pts = start.map(function (elem) {
+
+      var pts = m_this._coordinatesMapFunc(start, function (elem) {
         return {
           x: (elem.x - handle.center.x) * scale + handle.center.x,
           y: (elem.y - handle.center.y) * scale + handle.center.y
         };
       });
 
-      if (pts[0].x !== curPts[0].x || pts[0].y !== curPts[0].y) {
+      if (m_this._firstPointDifferent(pts, curPts)) {
         m_this._coordinates(pts);
 
         return true;
@@ -1228,15 +1295,25 @@ var annotation = function annotation(type, args) {
   this._processEditActionEdge = function (evt) {
     var handle = m_this._editHandle,
         index = handle.handle.index,
+        vindex = handle.handle.vindex,
         curPts = m_this._coordinates();
 
-    curPts.splice(index + 1, 0, {
-      x: handle.handle.x,
-      y: handle.handle.y
-    });
+    if (!curPts.outer) {
+      curPts.splice(index + 1, 0, {
+        x: handle.handle.x,
+        y: handle.handle.y
+      });
+    } else {
+      var loop = vindex ? curPts.inner[vindex - 1] : curPts.outer;
+      loop.splice(index + 1, 0, {
+        x: handle.handle.x,
+        y: handle.handle.y
+      });
+    }
+
     handle.handle.type = 'vertex';
     handle.handle.index += 1;
-    handle.startCoordinates = curPts.slice();
+    handle.startCoordinates = m_this._copyOfCoordinates(curPts);
     m_this.modified();
     return true;
   };
@@ -1255,8 +1332,10 @@ var annotation = function annotation(type, args) {
   this._processEditActionVertex = function (evt, canClose) {
     var handle = m_this._editHandle,
         index = handle.handle.index,
+        vindex = handle.handle.vindex,
         start = handle.startCoordinates,
-        curPts = m_this._coordinates(),
+        ptsRef = m_this._coordinates(),
+        curPts = ptsRef.outer ? vindex ? ptsRef.inner[vindex - 1] : ptsRef.outer : ptsRef,
         origLen = curPts.length,
         origPt = curPts[index],
         delta = {
@@ -1268,6 +1347,10 @@ var annotation = function annotation(type, args) {
         near,
         atEnd;
 
+    if (start.outer) {
+      start = vindex ? start.inner[vindex - 1] : start.outer;
+    }
+
     curPts[index] = {
       x: start[index].x + delta.x,
       y: start[index].y + delta.y
@@ -1308,10 +1391,43 @@ var annotation = function annotation(type, args) {
       return false;
     }
 
-    m_this._coordinates(curPts);
+    m_this._coordinates(ptsRef);
 
     return true;
   };
+  /**
+   * Transform the annotations coordinates from one gcs to another.
+   *
+   * @param {string|geo.transform} oldgcs The current gcs.
+   * @param {string|geo.transform} newgcs The new gcs.
+   * @param {geo.polygon} [coord] If not specified, convert the coordinates in
+   *   place.  If specified, convert these coordinates and return them (don't
+   *   alter the existing values).
+   * @returns {geo.polygon}
+   */
+
+
+  this._convertCoordinates = function (oldgcs, newgcs, coord) {
+    var store = !coord;
+    coord = coord || m_this._coordinates();
+
+    if (!coord.outer) {
+      coord = transform.transformCoordinates(oldgcs, newgcs, coord);
+    } else {
+      coord = {
+        outer: transform.transformCoordinates(oldgcs, newgcs, coord.outer),
+        inner: (coord.inner || []).map(function (h) {
+          return transform.transformCoordinates(oldgcs, newgcs, h);
+        })
+      };
+    }
+
+    if (store) {
+      m_this._coordinates(coord);
+    }
+
+    return coord;
+  };
 };
 /* Functions used by multiple annotations */
 
@@ -1664,14 +1780,14 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
       return;
     }
 
-    var coor = [];
+    var coord = [];
 
     for (var i = 0; i < 4; i += 1) {
-      coor.push([src[i].x, src[i].y]);
+      coord.push([src[i].x, src[i].y]);
     }
 
-    coor.push([src[0].x, src[0].y]);
-    return [coor];
+    coord.push([src[0].x, src[0].y]);
+    return [coord];
   };
   /**
    * Return the geometry type that is used to store this annotation in geojson.
@@ -2115,13 +2231,20 @@ var polygonAnnotation = function polygonAnnotation(args) {
       },
       fillOpacity: 0.25,
       line: function line(d) {
+        var coord = m_this._coordinates();
         /* Return an array that has the same number of items as we have
          * vertices. */
-        return Array.apply(null, Array(m_this.options('vertices').length)).map(function () {
+
+
+        return Array.apply(null, Array((coord.outer || coord).length)).map(function () {
           return d;
         });
       },
       position: function position(d, i) {
+        if (d.x !== undefined) {
+          return d.x;
+        }
+
         return m_this.options('vertices')[i];
       },
       stroke: false,
@@ -2155,7 +2278,7 @@ var polygonAnnotation = function polygonAnnotation(args) {
       case annotationState.create:
         features = [];
 
-        if (opt.vertices && opt.vertices.length >= 3) {
+        if (opt.vertices && (opt.vertices.outer || opt.vertices.length >= 3)) {
           features[1] = {
             polygon: {
               polygon: opt.vertices,
@@ -2340,18 +2463,32 @@ var polygonAnnotation = function polygonAnnotation(args) {
   this._geojsonCoordinates = function (gcs) {
     var src = m_this.coordinates(gcs);
 
-    if (!src || src.length < 3 || m_this.state() === annotationState.create) {
+    if (!src || !src.outer && src.length < 3 || m_this.state() === annotationState.create) {
       return;
     }
 
-    var coor = [];
+    var coord = [];
 
-    for (var i = 0; i < src.length; i += 1) {
-      coor.push([src[i].x, src[i].y]);
+    if (!src.outer) {
+      coord = [src.map(function (pt) {
+        return [pt.x, pt.y];
+      })];
+      coord[0].push(coord[0][0].slice());
+    } else {
+      coord = [src.outer.map(function (pt) {
+        return [pt.x, pt.y];
+      })];
+      coord[0].push(coord[0][0].slice());
+      (src.inner || []).forEach(function (h) {
+        var poly = h.map(function (pt) {
+          return [pt.x, pt.y];
+        });
+        poly.push(poly[0].slice());
+        coord.push(poly);
+      });
     }
 
-    coor.push([src[0].x, src[0].y]);
-    return [coor];
+    return coord;
   };
   /**
    * Return the geometry type that is used to store this annotation in geojson.
@@ -2659,13 +2796,13 @@ var lineAnnotation = function lineAnnotation(args) {
       return;
     }
 
-    var coor = [];
+    var coord = [];
 
     for (var i = 0; i < src.length; i += 1) {
-      coor.push([src[i].x, src[i].y]);
+      coord.push([src[i].x, src[i].y]);
     }
 
-    return coor;
+    return coord;
   };
   /**
    * Return the geometry type that is used to store this annotation in geojson.
@@ -3675,7 +3812,7 @@ var annotationLayer = function annotationLayer(arg) {
       gcs = gcs === null ? map.gcs() : gcs === undefined ? map.ingcs() : gcs;
 
       if (gcs !== map.gcs()) {
-        annotation._coordinates(transform.transformCoordinates(gcs, map.gcs(), annotation._coordinates()));
+        annotation._convertCoordinates(gcs, map.gcs());
       }
 
       if (update !== false) {
@@ -4028,16 +4165,31 @@ var annotationLayer = function annotationLayer(arg) {
           } // make a copy of the position array to avoid mutating the original.
 
 
-          position = position.outer.slice();
+          position = {
+            outer: position.outer.slice(),
+            inner: (position.inner || []).map(function (h) {
+              return h.slice();
+            })
+          };
 
-          if (position[position.length - 1][0] === position[0][0] && position[position.length - 1][1] === position[0][1]) {
-            position.splice(position.length - 1, 1);
+          if (position.outer[position.outer.length - 1][0] === position.outer[0][0] && position.outer[position.outer.length - 1][1] === position.outer[0][1]) {
+            position.outer.splice(position.outer.length - 1, 1);
 
-            if (position.length < 3) {
+            if (position.outer.length < 3) {
               return;
             }
           }
 
+          position.inner.forEach(function (h) {
+            if (h.length > 3 && h[h.length - 1][0] === h[0][0] && h[h.length - 1][1] === h[0][1]) {
+              h.splice(h.length - 1, 1);
+            }
+          });
+
+          if (!position.inner || !position.inner.length) {
+            position = position.outer;
+          }
+
           break;
 
         case 'marker':
@@ -4049,16 +4201,20 @@ var annotationLayer = function annotationLayer(arg) {
           break;
       }
 
-      for (i = 0; i < position.length; i += 1) {
-        position[i] = util.normalizeCoordinates(position[i]);
-      }
-
       datagcs = data.crs && data.crs.type === 'name' && data.crs.properties && data.crs.properties.type === 'proj4' && data.crs.properties.name ? data.crs.properties.name : gcs;
+      [position.outer || position].concat(position.inner || []).forEach(function (poslist) {
+        for (i = 0; i < poslist.length; i += 1) {
+          poslist[i] = util.normalizeCoordinates(poslist[i]);
+        }
 
-      if (datagcs !== map.gcs()) {
-        position = transform.transformCoordinates(datagcs, map.gcs(), position);
-      }
+        if (datagcs !== map.gcs()) {
+          var transposlist = transform.transformCoordinates(datagcs, map.gcs(), poslist);
 
+          for (i = 0; i < poslist.length; i += 1) {
+            poslist[i] = transposlist[i];
+          }
+        }
+      });
       options.coordinates = position;
       /* For each style listed in the geojsonStyleProperties object, check if
        * is given under any of the variety of keys as a valid instance of the
@@ -10624,6 +10780,7 @@ var fetchQueue = function fetchQueue(options) {
   this._size = options.size || 6;
   this._initialSize = options.initialSize || 0;
   this._track = options.track || 600;
+  this._initialTrack = this._track;
   this._needed = options.needed || null;
   this._batch = false;
   var m_this = this,
@@ -10664,6 +10821,38 @@ var fetchQueue = function fetchQueue(options) {
       m_this.next_item();
     }
   });
+  /**
+   * Get/set the track size.  This is used to determine when to check if
+   * entries can be discarded.
+   * @property {number} track The number of entries to track without checking
+   *    for discards.
+   * @name geo.fetchQueue#track
+   */
+
+  Object.defineProperty(this, 'track', {
+    get: function get() {
+      return m_this._track;
+    },
+    set: function set(n) {
+      m_this._track = n;
+    }
+  });
+  /**
+   * Get/set the initial track size.  Unless changed, this is the value used
+   * for track on class initialization.
+   * @property {number} initialTrack The number of entries to track without
+   *    checking for discards.
+   * @name geo.fetchQueue#intitialTrack
+   */
+
+  Object.defineProperty(this, 'initialTrack', {
+    get: function get() {
+      return m_this._initialTrack;
+    },
+    set: function set(n) {
+      m_this._initialTrack = n;
+    }
+  });
   /**
    * Get the current queue size.  Read only.
    * @property {number} length The current queue size.
@@ -10716,9 +10905,8 @@ var fetchQueue = function fetchQueue(options) {
       var pos = $.inArray(defer, m_this._queue);
 
       if (pos >= 0) {
-        m_this._queue.splice(pos, 1);
-
-        m_this._addToQueue(defer, atEnd);
+        // m_this._queue.splice(pos, 1);
+        m_this._addToQueue(defer, atEnd, pos);
 
         return defer;
       }
@@ -10752,24 +10940,40 @@ var fetchQueue = function fetchQueue(options) {
    * @param {boolean} atEnd If falsy, add the item to the front of the queue
    *  if batching is turned off or at the end of the current batch if it is
    *  turned on.  If truthy, always add the item to the end of the queue.
+   * @param {number} [pos] If specified, the current location in the queue of
+   *   the object being added.  This avoids having to splice, push, or unshift
+   *   the queue.
    */
 
 
-  this._addToQueue = function (defer, atEnd) {
+  this._addToQueue = function (defer, atEnd, pos) {
+    var move = atEnd ? m_this._queue.length - 1 : 0;
     defer.__fetchQueue._batch = m_this._batch;
 
-    if (atEnd) {
-      m_this._queue.push(defer);
-    } else if (!this._batch) {
-      m_this._queue.unshift(defer);
-    } else {
-      for (var i = 0; i < m_this._queue.length; i += 1) {
-        if (m_this._queue[i].__fetchQueue._batch !== m_this._batch) {
+    if (!atEnd && m_this._batch) {
+      for (move = 0; move < m_this._queue.length - (pos === undefined ? 0 : 1); move += 1) {
+        if (m_this._queue[move].__fetchQueue._batch !== m_this._batch) {
           break;
         }
       }
+    }
 
-      m_this._queue.splice(i, 0, defer);
+    if (pos === undefined) {
+      if (atEnd) {
+        m_this._queue.push(defer);
+      } else if (!move) {
+        m_this._queue.unshift(defer);
+      } else {
+        m_this._queue.splice(move, 0, defer);
+      }
+    } else if (pos !== move) {
+      var dir = pos < move ? 1 : -1;
+
+      for (var i = pos; i !== move; i += dir) {
+        m_this._queue[i] = m_this._queue[i + dir];
+      }
+
+      m_this._queue[move] = defer;
     }
   };
   /**
@@ -26667,7 +26871,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "0232ecc9dd2b5096d1f715cf71b0fc1ffc8cf8cf";
+module.exports = "c8c9edda606de6cb2990b41bfdfe2c4a82c885cb";
 
 /***/ }),
 
@@ -29510,7 +29714,7 @@ var featureLayer = __webpack_require__(3715);
  * @property {function} [tilesAtZoom=null] A function that is given a zoom
  *   level and returns `{x: (num), y: (num)}` with the number of tiles at that
  *   zoom level.
- * @property {number} [cacheSize=400] The maximum number of tiles to cache.
+ * @property {number} [cacheSize=600] The maximum number of tiles to cache.
  *   The default is 200 if keepLower is false.
  * @property {geo.fetchQueue} [queue] A fetch queue to use.  If unspecified, a
  *   new queue is created.
@@ -29695,6 +29899,10 @@ var tileLayer = function tileLayer(arg) {
 
   if (!arg.cacheSize) {
     // this size should be sufficient for a 4k display
+    // where display size is (w, h), minimum tile dimension is ts, and total
+    // number of levels is ml, this is roughly
+    // sum([(math.ceil((w**2+h**2)**0.5 / (ts*2**l)) + 1) *
+    //      (math.ceil(min(w, h) / (ts*2**l)) + 1) for l in range(ml)])
     arg.cacheSize = arg.keepLower ? 600 : 200;
   }
 
@@ -29772,6 +29980,10 @@ var tileLayer = function tileLayer(arg) {
 
   this._queue._tileLayers.push(m_this);
 
+  if (this._queue.initialTrack && this._queue.track) {
+    this._queue.track = this._queue.initialTrack * this._queue._tileLayers.length;
+  }
+
   var m_tileOffsetValues = {};
   /**
    * Readonly accessor to the options object.
@@ -29828,12 +30040,20 @@ var tileLayer = function tileLayer(arg) {
       if (m_this._queue !== queue) {
         if (this._queue && this._queue._tileLayers && this._queue._tileLayers.indexOf(m_this) >= 0) {
           this._queue._tileLayers.splice(this._queue._tileLayers.indexOf(m_this), 1);
+
+          if (this._queue.initialTrack && this._queue.track && this._queue._tileLayers.length) {
+            this._queue.track = this._queue.initialTrack * this._queue._tileLayers.length;
+          }
         }
 
         m_this._queue = queue;
         m_this._queue._tileLayers = m_this._queue._tileLayers || [];
 
         m_this._queue._tileLayers.push(m_this);
+
+        if (m_this._queue.initialTrack && m_this._queue.track) {
+          m_this._queue.track = m_this._queue.initialTrack * m_this._queue._tileLayers.length;
+        }
       }
     }
   });
@@ -31442,6 +31662,10 @@ var tileLayer = function tileLayer(arg) {
 
     if (this._queue && this._queue._tileLayers && this._queue._tileLayers.indexOf(m_this) >= 0) {
       this._queue._tileLayers.splice(this._queue._tileLayers.indexOf(m_this), 1);
+
+      if (this._queue.initialTrack && this._queue.track && this._queue._tileLayers.length) {
+        this._queue.track = this._queue.initialTrack * this._queue._tileLayers.length;
+      }
     }
 
     return m_this;
@@ -31478,7 +31702,7 @@ tileLayer.defaults = {
   topDown: false,
   keepLower: true,
   idleAfter: 'view',
-  // cacheSize: 400,  // set depending on keepLower
+  // cacheSize: 600,  // set depending on keepLower
   tileRounding: Math.round,
   attribution: '',
   animationDuration: 0
@@ -37216,7 +37440,9 @@ var util = {
    * this is the same as the average of all the points of the lines of the
    * perimeter.
    *
-   * @param {geo.geoPosition[]} coor An array of coordinates.
+   * @param {geo.geoPolygon} coor An array of coordinates.  This can also be
+   *    a polygon object with an ``outer`` element with an array of
+   *    coordinates.
    * @returns {geo.geoPosition|undefined} The position for the center, or
    *    `undefined` if no such position exists.
    * @memberof geo.util
@@ -37224,6 +37450,10 @@ var util = {
   centerFromPerimeter: function centerFromPerimeter(coor) {
     var position, p0, p1, w, sumw, i;
 
+    if (coor && coor.outer) {
+      coor = coor.outer;
+    }
+
     if (!coor || !coor.length) {
       return;
     }
@@ -39131,7 +39361,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.8.2";
+module.exports = "1.8.5";
 
 /***/ }),