geojs 1.8.4 → 1.8.7

package/src/annotation/squareAnnotation.js

@@ -0,0 +1,33 @@
+const $ = require('jquery');
+const inherit = require('../inherit');
+const registerAnnotation = require('../registry').registerAnnotation;
+const polygonFeature = require('../polygonFeature');
+
+const rectangleAnnotation = require('./rectangleAnnotation');
+
+/**
+ * Square annotation class.
+ *
+ * Squares are a subset of rectangles with a fixed aspect ratio.
+ *
+ * @class
+ * @alias geo.squareAnnotation
+ * @extends geo.annotation
+ *
+ * @param {geo.squareAnnotation.spec?} [args] Options for the annotation.
+ * @param {string} [annotationName='square'] Override the annotation name.
+ */
+var squareAnnotation = function (args, annotationName) {
+  'use strict';
+  args = $.extend({}, args, {constraint: 1});
+  if (!(this instanceof squareAnnotation)) {
+    return new squareAnnotation(args, annotationName);
+  }
+  rectangleAnnotation.call(this, args, annotationName || 'square');
+};
+inherit(squareAnnotation, rectangleAnnotation);
+var squareRequiredFeatures = {};
+squareRequiredFeatures[polygonFeature.capabilities.feature] = true;
+registerAnnotation('square', squareAnnotation, squareRequiredFeatures);
+
+module.exports = squareAnnotation;

package/src/fetchQueue.js

@@ -146,8 +146,8 @@ var fetchQueue = function (options) {
     if (defer.__fetchQueue) {
       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;
       }
     }
@@ -177,20 +177,34 @@ var fetchQueue = function (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) {
+    let move = atEnd ? m_this._queue.length - 1 : 0;
     defer.__fetchQueue._batch = m_this._batch;
-    if (atEnd) {
-      m_this._queue.push(defer);
-    } else if (!m_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) {
+      const dir = pos < move ? 1 : -1;
+      for (let i = pos; i !== move; i += dir) {
+        m_this._queue[i] = m_this._queue[i + dir];
+      }
+      m_this._queue[move] = defer;
     }
   };
 

package/src/index.js

@@ -46,7 +46,6 @@ $.htmlPrefilter = function (html) {
 require('./main.styl');
 
 module.exports = $.extend({
-  annotation: require('./annotation'),
   annotationLayer: require('./annotationLayer'),
   camera: require('./camera'),
   choroplethFeature: require('./choroplethFeature'),
@@ -93,6 +92,7 @@ module.exports = $.extend({
   version: require('./version'),
   sha: require('./sha'),
 
+  annotation: require('./annotation'),
   util: require('./util'),
   jQuery: $,
   canvas: require('./canvas'),

package/src/transform.js

@@ -767,6 +767,21 @@ transform.vincentyDistance = function (pt1, pt2, gcs, baseGcs, ellipsoid, maxIte
   };
 };
 
+/**
+ * Return a boolean indicating if the projections only differ in their y
+ * coordinate.
+ *
+ * @param {string} srcPrj The source projection.
+ * @param {string} tgtPrj The destination projection.
+ * @returns {boolean} truthy if only the y coordinate is different between
+ *    projections.
+ */
+transform.onlyInvertedY = function (srcPrj, tgtPrj) {
+  const smatch = srcPrj.match(axisPattern),
+      tmatch = tgtPrj.match(axisPattern);
+  return smatch && tmatch && smatch[1] === tmatch[1] && smatch[3] === tmatch[3];
+};
+
 /* Expose proj4 to make it easier to debug */
 transform.proj4 = proj4;
 

package/src/typedef.js

@@ -74,6 +74,15 @@
  * @property {number} [z=0] Altitude coordinate, often zero.
  */
 
+/**
+ * Represention of a size in gcs coordinates.
+ *
+ * @typedef geo.geoSize
+ * @type {object}
+ * @property {number} width Width in gcs coordinates.
+ * @property {number} height Height in gcs coordinates.
+ */
+
 /**
  * Represention of a size in pixels.
  *

package/src/webgl/lineFeature.js

@@ -134,6 +134,9 @@ var webgl_lineFeature = function (arg) {
           strokeOffset: 0, posStrokeOffset: 0, negStrokeOffset: 0
         }],
         v = vert[1],
+        target_gcs = m_this.gcs(),
+        map_gcs = m_this.layer().map().gcs(),
+        simpleInverse = transform.onlyInvertedY(target_gcs, map_gcs),
         pos, posIdx3, firstpos, firstPosIdx3,
         lineFunc = m_this.line(),
         strokeWidthFunc = m_this.style.get('strokeWidth'), strokeWidthVal,
@@ -188,7 +191,7 @@ var webgl_lineFeature = function (arg) {
         for (j = 0; j < lineItem.length; j += 1) {
           pos = posFunc(lineItem[j], j, d, i);
           position.push(pos.x);
-          position.push(pos.y);
+          position.push(simpleInverse ? -pos.y : pos.y);
           position.push(pos.z || 0.0);
           if (!j) {
             firstpos = pos;
@@ -208,8 +211,9 @@ var webgl_lineFeature = function (arg) {
         }
       }
 
-      position = transform.transformCoordinates(
-        m_this.gcs(), m_this.layer().map().gcs(), position, 3);
+      if (!simpleInverse) {
+        position = transform.transformCoordinates(target_gcs, map_gcs, position, 3);
+      }
       m_origin = new Float32Array(m_this.style.get('origin')(position));
       if (m_origin[0] || m_origin[1] || m_origin[2]) {
         for (i = 0; i < position.length; i += 3) {

package/src/webgl/polygonFeature.js

@@ -82,6 +82,7 @@ var webgl_polygonFeature = function (arg) {
         items = [],
         target_gcs = m_this.gcs(),
         map_gcs = m_this.layer().map().gcs(),
+        simpleInverse = transform.onlyInvertedY(target_gcs, map_gcs),
         numPts = 0,
         geom = m_mapper.geometryData(),
         color, opacity, fill, d, d3, vertices, i, j, k, n,
@@ -117,7 +118,7 @@ var webgl_polygonFeature = function (arg) {
         for (i = d3 = 0; i < outer.length; i += 1, d3 += 3) {
           c = posFunc(outer[i], i, item, itemIndex);
           geometry[d3] = c.x;
-          geometry[d3 + 1] = c.y;
+          geometry[d3 + 1] = simpleInverse ? -c.y : c.y;
           // ignore the z values until we support them
           geometry[d3 + 2] = 0;  // c.z || 0;
         }
@@ -134,7 +135,7 @@ var webgl_polygonFeature = function (arg) {
             for (i = 0; i < hole.length; i += 1, d3 += 3) {
               c = posFunc(hole[i], i, item, itemIndex);
               geometry.vertices[d3] = c.x;
-              geometry.vertices[d3 + 1] = c.y;
+              geometry.vertices[d3 + 1] = simpleInverse ? -c.y : c.y;
               // ignore the z values until we support them
               geometry.vertices[d3 + 2] = 0;  // c.z || 0;
             }
@@ -142,12 +143,14 @@ var webgl_polygonFeature = function (arg) {
         }
 
         // transform to map gcs
-        geometry.vertices = transform.transformCoordinates(
-          target_gcs,
-          map_gcs,
-          geometry.vertices,
-          geometry.dimensions
-        );
+        if (!simpleInverse) {
+          geometry.vertices = transform.transformCoordinates(
+            target_gcs,
+            map_gcs,
+            geometry.vertices,
+            geometry.dimensions
+          );
+        }
 
         record = {
           // triangulate