geojs 1.8.2 → 1.8.3

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) {
@@ -26667,7 +26804,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "0232ecc9dd2b5096d1f715cf71b0fc1ffc8cf8cf";
+module.exports = "06c78d577d1a9dd6332ee47b20fe441d239225ca";
 
 /***/ }),
 
@@ -37216,7 +37353,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 +37363,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 +39274,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.8.2";
+module.exports = "1.8.3";
 
 /***/ }),