geojs 1.8.10 → 1.9.2

package/src/annotationLayer.js

@@ -181,6 +181,44 @@ var annotationLayer = function (arg) {
     m_this._updateFromEvent(update);
   };
 
+  /**
+   * Check if there is a current boolean operation.
+   *
+   * @returns {string?} Either undefined for no current boolean operation or
+   *   the name of the operation.
+   */
+  this.currentBooleanOperation = function () {
+    let op;
+    if (m_this._currentBooleanClass) {
+      op = m_this._currentBooleanClass.split('-')[1];
+    }
+    return op;
+  };
+
+  /**
+   * Check if the map is currently in a mode where we are adding an annotation
+   * with a boolean operation.  If so, remove the current annotation from the
+   * layer, then apply it via the boolean operation.
+   */
+  this._handleBooleanOperation = function () {
+    const op = m_this.currentBooleanOperation();
+    if (!op || !m_this.currentAnnotation || !m_this.currentAnnotation.toPolygonList) {
+      return;
+    }
+    const newAnnot = m_this.currentAnnotation;
+    m_this.removeAnnotation(m_this.currentAnnotation, false);
+    if (m_this.annotations().length || (op !== 'difference' && op !== 'intersect')) {
+      const evt = {
+        annotation: newAnnot,
+        operation: op
+      };
+      m_this.geoTrigger(geo_event.annotation.boolean, evt);
+      if (evt.cancel !== false) {
+        util.polyops[op](m_this, newAnnot.toPolygonList(), {correspond: {}, keepAnnotations: 'exact', style: m_this});
+      }
+    }
+  };
+
   /**
    * Handle updating the current annotation based on an update state.
    *
@@ -196,6 +234,7 @@ var annotationLayer = function (arg) {
         m_this.mode(null);
         break;
       case 'done':
+        m_this._handleBooleanOperation();
         m_this.mode(null);
         break;
     }
@@ -205,6 +244,27 @@ var annotationLayer = function (arg) {
     }
   };
 
+  /**
+   * Check the state of the modifier keys and apply them if appropriate.
+   *
+   * @param {geo.event} evt The mouse move or click event.
+   */
+  this._handleMouseMoveModifiers = function (evt) {
+    if (m_this.mode() !== m_this.modes.edit && m_this.currentAnnotation.options('allowBooleanOperations') && m_this.currentAnnotation._coordinates().length < 2) {
+      if (evt.modifiers) {
+        const mod = (evt.modifiers.shift ? 's' : '') + (evt.modifiers.ctrl ? 'c' : '') + (evt.modifiers.meta || evt.modifiers.alt ? 'a' : '');
+        if (m_this._currentBooleanClass === m_this._booleanClasses[mod]) {
+          return;
+        }
+        m_this._currentBooleanClass = m_this._booleanClasses[mod];
+        const mapNode = m_this.map().node();
+        Object.values(m_this._booleanClasses).forEach((c) => {
+          mapNode.toggleClass(c, m_this._booleanClasses[mod] === c);
+        });
+      }
+    }
+  };
+
   /**
    * Handle mouse movement.  If there is a current annotation, the movement
    * event is sent to it.
@@ -213,6 +273,7 @@ var annotationLayer = function (arg) {
    */
   this._handleMouseMove = function (evt) {
     if (m_this.mode() && m_this.currentAnnotation) {
+      m_this._handleMouseMoveModifiers(evt);
       var update = m_this.currentAnnotation.mouseMove(evt);
       if (update) {
         m_this.modified();
@@ -316,6 +377,7 @@ var annotationLayer = function (arg) {
       });
       retrigger = true;
     } else if (m_this.mode() && m_this.currentAnnotation) {
+      m_this._handleMouseMoveModifiers(evt);
       update = m_this.currentAnnotation.mouseClick(evt);
       m_this._updateFromEvent(update);
       retrigger = !m_this.mode();
@@ -518,6 +580,15 @@ var annotationLayer = function (arg) {
     edit: 'edit'
   };
 
+  /* Keys are short-hand for preferred event modifiers.  Values are classes to
+   * apply to the map node. */
+  this._booleanClasses = {
+    s: 'annotation-union',
+    sc: 'annotation-intersect',
+    c: 'annotation-difference',
+    sa: 'annotation-xor'
+  };
+
   /**
    * Get or set the current mode.
    *
@@ -537,11 +608,15 @@ var annotationLayer = function (arg) {
     if (arg === undefined) {
       return m_mode;
     }
-    if (arg !== m_mode || (arg === m_this.modes.edit && editAnnotation !== m_this.editAnnotation)) {
+    if (arg !== m_mode || (arg === m_this.modes.edit && editAnnotation !== m_this.editAnnotation) || (arg !== m_this.modes.edit && arg && !m_this.currentAnnotation)) {
       var createAnnotation, actions,
           mapNode = m_this.map().node(), oldMode = m_mode;
       m_mode = arg;
       mapNode.toggleClass('annotation-input', !!(m_mode && m_mode !== m_this.modes.edit));
+      if (!m_mode || m_mode === m_this.modes.edit) {
+        Object.values(m_this._booleanClasses).forEach((c) => mapNode.toggleClass(c, false));
+        m_this._currentBooleanClass = undefined;
+      }
       if (!m_keyHandler) {
         m_keyHandler = Mousetrap(mapNode[0]);
       }
@@ -618,7 +693,12 @@ var annotationLayer = function (arg) {
    */
   this.geojson = function (geojson, clear, gcs, includeCrs) {
     if (geojson !== undefined) {
-      var reader = registry.createFileReader('geojsonReader', {layer: m_this});
+      var reader = registry.createFileReader('geojsonReader', {
+        layer: m_this,
+        lineStyle: require('./annotation/lineAnnotation').defaults.style,
+        pointStyle: require('./annotation/pointAnnotation').defaults.style,
+        polygonStyle: require('./annotation/polygonAnnotation').defaults.style
+      });
       if (!reader.canRead(geojson)) {
         return;
       }
@@ -1156,6 +1236,112 @@ var annotationLayer = function (arg) {
     return m_this;
   };
 
+  /**
+   * Return any annotation that has area as a polygon list: an array of
+   * polygons, each of which is an array of polylines, each of which is an
+   * array of points, each of which is a 2-tuple of numbers.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+  this.toPolygonList = function (opts) {
+    const poly = [];
+    opts = opts || {};
+    opts.annotationIndices = [];
+    m_annotations.forEach((annotation, idx) => {
+      if (annotation.toPolygonList) {
+        annotation.toPolygonList(opts).forEach((p) => poly.push(p));
+        opts.annotationIndices.push(idx);
+      }
+    });
+    return poly;
+  };
+
+  /**
+   * Replace appropriate annotations with a list of polygons.
+   *
+   * @param {geo.polygonList} poly A list of polygons.
+   * @param {geo.util.polyop.spec} [opts] This contains annotationIndices and
+   *   correspondence used to track annotations.
+   * @returns {this}
+   */
+  this.fromPolygonList = function (poly, opts) {
+    if (!poly || !poly.length) {
+      return m_this;
+    }
+    /* One of 'all', 'exact', 'none'; default is 'exact' */
+    const keep = opts.keepAnnotations;
+    const keepIds = {};
+    const reusedIds = {};
+    let correspond, exact, annot;
+    if (opts.annotationIndices && opts.correspond && opts.correspond.poly1 && opts.annotationIndices.length === opts.correspond.poly1.length) {
+      correspond = opts.correspond.poly1;
+      exact = opts.correspond.exact1;
+      annot = m_this.annotations();
+    }
+    if (keep !== 'all' && keep !== 'none') {
+      annot.forEach((oldAnnot, idx) => {
+        if (opts.annotationIndices.indexOf(idx) < 0) {
+          keepIds[oldAnnot.id()] = true;
+        }
+      });
+    }
+    const polyAnnot = [];
+    poly.forEach((p, idx) => {
+      p = p.map((h) => h.map((pt) => ({x: pt[0], y: pt[1]})));
+      const result = {
+        vertices: p.length === 1 ? p[0] : {outer: p[0], inner: p.slice(1)}
+      };
+      if (correspond) {
+        for (let i = 0; i < correspond.length; i += 1) {
+          if (correspond[i] && correspond[i].indexOf(idx) >= 0) {
+            const orig = annot[opts.annotationIndices[i]];
+            if (keep !== 'all' && keep !== 'none' && exact && exact[i] && exact[i].indexOf(idx) >= 0) {
+              keepIds[orig.id()] = true;
+              return;
+            }
+            if (keep !== 'all' && reusedIds[orig.id()] === undefined) {
+              result.annotationId = orig.id();
+              reusedIds[orig.id()] = true;
+            }
+            ['name', 'description', 'label'].forEach((k) => {
+              if (orig[k](undefined, true)) {
+                result[k] = orig[k](undefined, true);
+              }
+            });
+            Object.entries(orig.options()).forEach(([key, value]) => {
+              if (['showLabel', 'style'].indexOf(key) >= 0 || key.endsWith('Style')) {
+                result[key] = value;
+              }
+            });
+            break;
+          }
+        }
+      }
+      polyAnnot.push(result);
+    });
+    let update = false;
+    // delete extant annotations
+    if (keep !== 'all' && annot) {
+      annot
+        .filter((oldAnnot) => keepIds[oldAnnot.id()] === undefined)
+        .forEach((oldAnnot) => {
+          m_this.removeAnnotation(oldAnnot, false);
+          update = true;
+        });
+    }
+    // add new annotations
+    polyAnnot.forEach((p) => {
+      m_this.addAnnotation(registry.createAnnotation('polygon', p), m_this.gcs(), false);
+      update = true;
+    });
+    if (update) {
+      m_this.modified();
+      m_this.draw();
+    }
+    return m_this;
+  };
+
   /**
    * Initialize.
    *

package/src/css/cursor-crosshair-difference.svg

@@ -0,0 +1,4 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="32" height="32">
+<path d="M0,11l11,0l0,-11l2,0l0,11l11,0l0,2l-11,0l0,11l-2,0l0,-11l-11,0z" fill="black" stroke-width="0"/>
+<path d="M24,27l8,0l0,2l-8,0z" fill="black" stroke-width="0"/>
+</svg>

package/src/css/cursor-crosshair-intersect.svg

@@ -0,0 +1,4 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="32" height="32">
+<path d="M0,11l11,0l0,-11l2,0l0,11l11,0l0,2l-11,0l0,11l-2,0l0,-11l-11,0z" fill="black" stroke-width="0"/>
+<path d="M24,32l0,-4a4,4,0,0,1,8,0l0,4l-2,0l0,-4a2,2,0,0,0,-4,0l0,4z" fill="black" stroke-width="0"/>
+</svg>

package/src/css/cursor-crosshair-union.svg

@@ -0,0 +1,4 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="32" height="32">
+<path d="M0,11l11,0l0,-11l2,0l0,11l11,0l0,2l-11,0l0,11l-2,0l0,-11l-11,0z" fill="black" stroke-width="0"/>
+<path d="M24,27l3,0l0,-3l2,0l0,3l3,0l0,2l-3,0l0,3l-2,0l0,-3l-3,0z" fill="black" stroke-width="0"/>
+</svg>

package/src/css/cursor-crosshair-xor.svg

@@ -0,0 +1,4 @@
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="32" height="32">
+<path d="M0,11l11,0l0,-11l2,0l0,11l11,0l0,2l-11,0l0,11l-2,0l0,-11l-11,0z" fill="black" stroke-width="0"/>
+<path d="M32,30.59l-1.41,1.41l-2.12,-2.12l-2.12,2.12l-1.41,-1.41l2.12,-2.12l-2.12,-2.12l1.41,-1.41l2.12,2.12l2.12,-2.12l1.41,1.41l-2.12,2.12z" fill="black" stroke-width="0"/>
+</svg>

package/src/event.js

@@ -692,4 +692,18 @@ geo_event.annotation.state = 'geo_annotation_state';
  */
 geo_event.annotation.mode = 'geo_annotation_mode';
 
+/**
+ * Triggered when an annotation can be combined via a boolean operation (union,
+ * intersect, difference, xor).
+ *
+ * @event geo.event.annotation.boolean
+ * @type {geo.event.base}
+ * @property {geo.annotation} annotation The annotation that is being operated
+ *      on.
+ * @property {string} operation The operation being performed.
+ * @property {boolean} [cancel] If the handle sets this to false, don't apply
+ *      the operation to the annotation layer.
+ */
+geo_event.annotation.boolean = 'geo_annotation_boolean';
+
 module.exports = geo_event;

package/src/lineFeature.js

@@ -182,7 +182,7 @@ var lineFeature = function (arg) {
         const current = lineRecord[j];
         let p = posFunc(current, j, d, index);
         if (onlyInvertedY) {
-          p.y = -p.y;
+          p = {x: p.x, y: -p.y};
         } else if (gcs !== mapgcs) {
           p = transform.transformCoordinates(gcs, mapgcs, p);
         }

package/src/main.styl

@@ -49,6 +49,14 @@
 
   &.annotation-input
     cursor crosshair
+    &.annotation-intersect
+      cursor embedurl("./css/cursor-crosshair-intersect.svg") 12 12,crosshair
+    &.annotation-difference
+      cursor embedurl("./css/cursor-crosshair-difference.svg") 12 12,crosshair
+    &.annotation-union
+      cursor embedurl("./css/cursor-crosshair-union.svg") 12 12,crosshair
+    &.annotation-xor
+      cursor embedurl("./css/cursor-crosshair-xor.svg") 12 12,crosshair
 
   &.highlight-focus
     &:after

package/src/polygonFeature.js

@@ -686,6 +686,56 @@ var polygonFeature = function (arg) {
     });
   };
 
+  /**
+   * Return the polygons as a polygon list: an array of polygons, each of which
+   * is an array of polylines, each of which is an array of points, each of
+   * which is a 2-tuple of numbers.
+   *
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {geo.polygonList} A list of polygons.
+   */
+  this.toPolygonList = function (opts) {
+    const polyFunc = m_this.style.get('polygon');
+    const posFunc = m_this.style.get('position');
+    return m_this.data().map((d, i) => {
+      const polygon = polyFunc(d, i);
+      const outer = polygon.outer || (Array.isArray(polygon) ? polygon : []);
+      if (outer.length < 3) {
+        return [];
+      }
+      const resp = [outer.map((p, j) => {
+        const pos = posFunc(p, j, d, i);
+        return [pos.x, pos.y];
+      })];
+      if (polygon.inner) {
+        polygon.inner.forEach((h) => {
+          resp.push(h.map((p, j) => {
+            const pos = posFunc(p, j, d, i);
+            return [pos.x, pos.y];
+          }));
+        });
+      }
+      return resp;
+    });
+  };
+
+  /**
+   * Set the data, position accessor, and polygon accessor to use a list of
+   * polygons.
+   *
+   * @param {geo.polygonList} poly A list of polygons.
+   * @param {geo.util.polyop.spec} [opts] Ignored.
+   * @returns {this}
+   */
+  this.fromPolygonList = function (poly, opts) {
+    m_this.style({
+      position: (p) => ({x: p[0], y: p[1]}),
+      polygon: (p) => ({outer: p[0], inner: p.slice(1)})
+    });
+    m_this.data(poly);
+    return m_this;
+  };
+
   /**
    * Destroy.
    */

package/src/typedef.js

@@ -54,6 +54,17 @@
  * @property {number} [z=0] Altitude coordinate.
  */
 
+/**
+ * General represention of a point on the earth.  The coordinates are most
+ * commonly in longitude and latitude, but the coordinate system is changed
+ * by the interface gcs.  This is a list of numbers consisting of either [x, y]
+ * or [x, y, z], where therse are the horizontal, vertical, and altitude
+ * coordinates.
+ *
+ * @typedef geo.geoPositionFlat
+ * @type {number[]}
+ */
+
 /**
  * General represention of a two-dimensional point in any coordinate system.
  *

package/src/util/index.js

@@ -8,6 +8,7 @@ module.exports = Object.assign(
   {
     DistanceGrid: require('./distanceGrid'),
     ClusterGroup: require('./clustering'),
-    mesh: require('./mesh')
+    mesh: require('./mesh'),
+    polyops: require('./polyops')
   }
 );