geojs 1.8.7 → 1.8.10

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # GeoJS Change Log
 
+## Version 1.8.10
+
+### Improvements
+
+- Added a uniformLine property to speed up line rendering ([#1211](../../pull/1211))
+
+## Version 1.8.9
+
+### Bug Fixes
+
+- Fix a bug introduced in #1207 ([#1210](../../pull/1210))
+
+## Version 1.8.8
+
+### Improvements
+
+- Reduce polygon and position function calls ([#1208](../../pull/1208))
+
 ## Version 1.8.7
 
 ### Improvements

package/geo.js

@@ -11490,6 +11490,7 @@ var geojsonReader = function geojsonReader(arg) {
       strokeOffset: 0,
       lineCap: 'butt',
       lineJoin: 'miter',
+      uniformLine: true,
       closed: false
     }, arg.lineStyle),
     polygonStyle: _objectSpread({
@@ -11499,7 +11500,8 @@ var geojsonReader = function geojsonReader(arg) {
       stroke: true,
       strokeColor: '#999999',
       strokeWidth: 2,
-      strokeOpacity: 1
+      strokeOpacity: 1,
+      uniformPolygon: true
     }, arg.polygonStyle)
   });
 
@@ -12042,9 +12044,7 @@ var graphFeature = function graphFeature(arg) {
 
     }, arg.style === undefined ? {} : arg.style);
     m_this.style(defaultStyle);
-    m_this.nodes(function (d) {
-      return d;
-    });
+    m_this.nodes(util.identityFunction);
     return m_this;
   };
   /**
@@ -12466,6 +12466,8 @@ var inherit = __webpack_require__(5699);
 var feature = __webpack_require__(6837);
 
 var transform = __webpack_require__(6853);
+
+var util = __webpack_require__(4634);
 /**
  * Heatmap feature specification.
  *
@@ -12544,10 +12546,7 @@ var heatmapFeature = function heatmapFeature(arg) {
       m_gcsPosition,
       s_init = this._init;
   this.featureType = 'heatmap';
-
-  m_position = arg.position || function (d) {
-    return d;
-  };
+  m_position = arg.position || util.identityFunction;
 
   m_intensity = arg.intensity || function (d) {
     return 1;
@@ -15144,6 +15143,9 @@ var util = __webpack_require__(4634);
  *   divided by the sine of half the angle between segments, then a bevel join
  *   is used instead.  This is a single value that applies to all lines.  If a
  *   function, it is called with `(data)`.
+ * @property {boolean|function} [uniformLine=false] Boolean indicating if each
+ *   line has a uniform style (uniform stroke color, opacity, and width).  Can
+ *   vary by line.
  * @property {number|function} [antialiasing] Antialiasing distance in pixels.
  *   Values must be non-negative.  A value greater than 1 will produce a
  *   visible gradient.  This is a single value that applies to all lines.
@@ -15261,24 +15263,38 @@ var lineFeature = function lineFeature(arg) {
     var data = m_this.data(),
         line = m_this.line(),
         widthFunc = m_this.style.get('strokeWidth'),
+        widthVal = util.isFunction(m_this.style('strokeWidth')) ? undefined : widthFunc(),
         posFunc = m_this.position(),
         closedFunc = m_this.style.get('closed'),
+        closedVal = util.isFunction(m_this.style('closed')) ? undefined : closedFunc(),
+        uniformFunc = m_this.style.get('uniformLine'),
+        uniformVal = util.isFunction(m_this.style('uniformLine')) ? undefined : uniformFunc(),
         gcs = m_this.gcs(),
-        mapgcs = m_this.layer().map().gcs();
-    data.forEach(function (d, index) {
-      var closed = closedFunc(d, index),
-          last,
-          lasti,
-          lastr,
-          lastr2,
-          first,
-          record = [],
-          min,
-          max;
-      line(d, index).forEach(function (current, j) {
+        mapgcs = m_this.layer().map().gcs(),
+        onlyInvertedY = transform.onlyInvertedY(gcs, mapgcs);
+
+    for (var index = 0; index < data.length; index += 1) {
+      var d = data[index];
+      var closed = closedVal === undefined ? closedFunc(d, index) : closedVal;
+      var last = void 0,
+          lasti = void 0,
+          lastr = void 0,
+          lastr2 = void 0,
+          first = void 0,
+          min = void 0,
+          max = void 0,
+          width = void 0;
+      var record = [];
+      var uniform = uniformVal === undefined ? uniformFunc(d, index) : uniformVal;
+      var lineRecord = line(d, index);
+
+      for (var j = 0; j < lineRecord.length; j += 1) {
+        var current = lineRecord[j];
         var p = posFunc(current, j, d, index);
 
-        if (gcs !== mapgcs) {
+        if (onlyInvertedY) {
+          p.y = -p.y;
+        } else if (gcs !== mapgcs) {
           p = transform.transformCoordinates(gcs, mapgcs, p);
         }
 
@@ -15312,7 +15328,11 @@ var lineFeature = function lineFeature(arg) {
           max.y = p.y;
         }
 
-        var r = Math.ceil(widthFunc(current, j, d, index) / 2) + 2;
+        if (!uniform || !j) {
+          width = widthVal === undefined ? widthFunc(current, j, d, index) : widthVal;
+        }
+
+        var r = Math.ceil(width / 2) + 2;
 
         if (max.r === undefined || r > max.r) {
           max.r = r;
@@ -15344,7 +15364,7 @@ var lineFeature = function lineFeature(arg) {
             i: j
           };
         }
-      });
+      }
 
       if (closed && first && (last.x !== first.p.x || last.y !== first.p.y)) {
         record.push({
@@ -15360,7 +15380,8 @@ var lineFeature = function lineFeature(arg) {
       record.min = min;
       record.max = max;
       m_pointSearchInfo.push(record);
-    });
+    }
+
     return m_pointSearchInfo;
   };
   /**
@@ -15668,12 +15689,8 @@ var lineFeature = function lineFeature(arg) {
     });
     /* Set the reduced lines as the data and use simple accessors. */
 
-    m_this.style('position', function (d) {
-      return d;
-    });
-    m_this.style('line', function (d) {
-      return d;
-    });
+    m_this.style('position', util.identityFunction);
+    m_this.style('line', util.identityFunction);
     m_this.data(data);
     return m_this;
   };
@@ -15701,9 +15718,7 @@ var lineFeature = function lineFeature(arg) {
       // Values of 2 and above appear smoothest.
       antialiasing: 2.0,
       closed: false,
-      line: function line(d) {
-        return d;
-      },
+      line: util.identityFunction,
       position: function position(d) {
         return Array.isArray(d) ? {
           x: d[0],
@@ -23324,9 +23339,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
           a: 1
         };
       },
-      position: function position(d) {
-        return d;
-      }
+      position: util.identityFunction
     }, arg.style === undefined ? {} : arg.style);
 
     if (arg.position !== undefined) {
@@ -24861,7 +24874,8 @@ var polygonFeature = function polygonFeature(arg) {
       strokeStyle: linePolyStyle(polyStyle.strokeStyle),
       strokeColor: linePolyStyle(polyStyle.strokeColor),
       strokeOffset: linePolyStyle(polyStyle.strokeOffset),
-      strokeOpacity: strokeOpacity
+      strokeOpacity: strokeOpacity,
+      uniformLine: linePolyStyle(polyStyle.uniformPolygon)
     });
     var data = m_this.data(),
         posVal = m_this.style('position');
@@ -25022,12 +25036,8 @@ var polygonFeature = function polygonFeature(arg) {
     });
     /* Set the reduced polgons as the data and use simple accessors. */
 
-    m_this.style('position', function (d) {
-      return d;
-    });
-    m_this.style('polygon', function (d) {
-      return d;
-    });
+    m_this.style('position', util.identityFunction);
+    m_this.style('polygon', util.identityFunction);
     m_this.data(data);
     return m_this;
   };
@@ -25123,9 +25133,7 @@ var polygonFeature = function polygonFeature(arg) {
         b: 1.0
       },
       strokeOpacity: 1.0,
-      polygon: function polygon(d) {
-        return d;
-      },
+      polygon: util.identityFunction,
       position: function position(d) {
         return Array.isArray(d) ? {
           x: d[0],
@@ -26014,9 +26022,7 @@ var quadFeature = function quadFeature(arg) {
       video: function video(d) {
         return d.video;
       },
-      position: function position(d) {
-        return d;
-      }
+      position: util.identityFunction
     }, arg.style === undefined ? {} : arg.style);
 
     if (arg.position !== undefined) {
@@ -27053,7 +27059,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "493ff30a20fb5c5febb2c3521372398121e0cdee";
+module.exports = "e13f6d922451bb86544884283bfb31843f58bd60";
 
 /***/ }),
 
@@ -32927,12 +32933,8 @@ var trackFeature = function trackFeature(arg) {
     arg = arg || {};
     s_init.call(m_this, arg);
     var style = $.extend(true, {}, {
-      track: function track(d) {
-        return d;
-      },
-      position: function position(d) {
-        return d;
-      },
+      track: util.identityFunction,
+      position: util.identityFunction,
       time: function time(d, i) {
         return d.t !== undefined ? d.t : i;
       }
@@ -33007,7 +33009,7 @@ var maxTransformCacheSize = 10;
 /* A RegExp to detect if two transforms only different by the middle axis's
  * direction. */
 
-var axisPattern = /^(.* |)\\+axis=e(n|s)u(| .*)$/;
+var axisPattern = /^(.* |)\+axis=e(n|s)u(| .*)$/;
 var affinePattern = /(^|\s)\+(s[1-3][1-3]|[xyz]off)=\S/;
 /**
  * This purpose of this class is to provide a generic interface for computing
@@ -38579,6 +38581,17 @@ var util = {
 
     return value !== null && value !== undefined && (type === 'object' || type === 'function');
   },
+
+  /**
+   * Return the first value passed to the function.  Using this function for
+   * identity calls can allow some code to bypass making such a call entirely.
+   *
+   * @param {*} d Any value.
+   * @returns {*} The passed value.
+   */
+  identityFunction: function identityFunction(d) {
+    return d;
+  },
   ///////////////////////////////////////////////////////////////////////////
 
   /*
@@ -39408,6 +39421,8 @@ module.exports = {
 var inherit = __webpack_require__(5699);
 
 var feature = __webpack_require__(6837);
+
+var util = __webpack_require__(4634);
 /**
  * Object specification for a graph feature.
  *
@@ -39534,9 +39549,7 @@ var vectorFeature = function vectorFeature(arg) {
         y: 0,
         z: 0
       },
-      delta: function delta(d) {
-        return d;
-      },
+      delta: util.identityFunction,
       scale: null // size scaling factor (null -> renderer decides)
 
     }, arg.style === undefined ? {} : arg.style);
@@ -39568,7 +39581,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.8.7";
+module.exports = "1.8.10";
 
 /***/ }),
 
@@ -40801,7 +40814,6 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         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,
@@ -40821,6 +40833,9 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         strokeOffsetVal,
         miterLimit = m_this.style.get('miterLimit')(data),
         antialiasing = m_this.style.get('antialiasing')(data) || 0,
+        uniformFunc = m_this.style.get('uniformLine'),
+        uniformVal,
+        uniform,
         order = m_this.featureVertices(),
         orderk0,
         prevkey,
@@ -40851,6 +40866,7 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
     strokeOffsetVal = util.isFunction(m_this.style('strokeOffset')) ? undefined : strokeOffsetFunc() || 0;
     strokeOpacityVal = util.isFunction(m_this.style('strokeOpacity')) ? undefined : strokeOpacityFunc();
     strokeWidthVal = util.isFunction(m_this.style('strokeWidth')) ? undefined : strokeWidthFunc();
+    uniformVal = util.isFunction(m_this.style('uniformLine')) ? undefined : uniformFunc();
 
     if (miterLimit !== undefined) {
       /* We impose a limit no matter what, since otherwise the growth is
@@ -40865,6 +40881,7 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
     if (!onlyStyle) {
       var position = [],
           posFunc = m_this.position();
+      posFunc = posFunc === util.identityFunction ? null : posFunc;
       lineItemList = new Array(data.length);
       closed = new Array(data.length);
 
@@ -40880,9 +40897,9 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         numSegments += lineItem.length - 1;
 
         for (j = 0; j < lineItem.length; j += 1) {
-          pos = posFunc(lineItem[j], j, d, i);
+          pos = posFunc ? posFunc(lineItem[j], j, d, i) : lineItem[j];
           position.push(pos.x);
-          position.push(simpleInverse ? -pos.y : pos.y);
+          position.push(pos.y);
           position.push(pos.z || 0.0);
 
           if (!j) {
@@ -40905,10 +40922,7 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         }
       }
 
-      if (!simpleInverse) {
-        position = transform.transformCoordinates(target_gcs, map_gcs, position, 3);
-      }
-
+      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]) {
@@ -40961,6 +40975,7 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         continue;
       }
 
+      uniform = uniformVal === undefined ? uniformFunc(lineItem, i) : uniformVal;
       d = data[i];
       closedVal = closed[i];
       firstPosIdx3 = posIdx3;
@@ -40990,13 +41005,27 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
           v.next = j + 1 < lineItem.length ? posIdx3 + 3 : closedVal ? j !== lidx ? firstPosIdx3 + 3 : firstPosIdx3 + 6 - closedVal * 3 : posIdx3;
         }
 
-        v.strokeWidth = strokeWidthVal === undefined ? strokeWidthFunc(lineItemData, lidx, d, i) : strokeWidthVal;
-        v.strokeColor = strokeColorVal === undefined ? strokeColorFunc(lineItemData, lidx, d, i) : strokeColorVal;
-        v.strokeOpacity = strokeOpacityVal === undefined ? strokeOpacityFunc(lineItemData, lidx, d, i) : strokeOpacityVal;
+        if (uniform && j > 0) {
+          if (j === 1) {
+            v.strokeWidth = vert[0].strokeWidth;
+            v.strokeColor = vert[0].strokeColor;
+            v.strokeOpacity = vert[0].strokeOpacity;
+          }
+        } else {
+          v.strokeWidth = strokeWidthVal === undefined ? strokeWidthFunc(lineItemData, lidx, d, i) : strokeWidthVal;
+          v.strokeColor = strokeColorVal === undefined ? strokeColorFunc(lineItemData, lidx, d, i) : strokeColorVal;
+          v.strokeOpacity = strokeOpacityVal === undefined ? strokeOpacityFunc(lineItemData, lidx, d, i) : strokeOpacityVal;
+        }
 
         if (updateFlags) {
           if (strokeOffsetVal !== 0) {
-            v.strokeOffset = (strokeOffsetVal === undefined ? strokeOffsetFunc(lineItemData, lidx, d, i) : strokeOffsetVal) || 0;
+            if (uniform && j > 0) {
+              if (j === 1) {
+                v.strokeOffset = vert[0].strokeOffset;
+              }
+            } else {
+              v.strokeOffset = (strokeOffsetVal === undefined ? strokeOffsetFunc(lineItemData, lidx, d, i) : strokeOffsetVal) || 0;
+            }
 
             if (v.strokeOffset) {
               /* we use 11 bits to store the offset, and we want to store values
@@ -43426,13 +43455,13 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         fillOpacityVal,
         fillFunc,
         fillVal,
-        uniformPolyFunc,
+        uniformFunc,
+        uniformVal,
         uniform,
         indices,
         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,
@@ -43455,14 +43484,17 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
     fillOpacityVal = util.isFunction(m_this.style('fillOpacity')) ? undefined : fillOpacityFunc();
     fillFunc = m_this.style.get('fill');
     fillVal = util.isFunction(m_this.style('fill')) ? undefined : fillFunc();
-    uniformPolyFunc = m_this.style.get('uniformPolygon');
+    uniformFunc = m_this.style.get('uniformPolygon');
+    uniformVal = util.isFunction(m_this.style('uniformPolygon')) ? undefined : uniformFunc();
 
     if (!onlyStyle) {
       posFunc = m_this.style.get('position');
+      posFunc = posFunc === util.identityFunction ? null : posFunc;
       polyFunc = m_this.style.get('polygon');
+      polyFunc = polyFunc === util.identityFunction ? null : polyFunc;
       m_this.data().forEach(function (item, itemIndex) {
         var polygon, outer, geometry, c;
-        polygon = polyFunc(item, itemIndex);
+        polygon = polyFunc ? polyFunc(item, itemIndex) : item;
 
         if (!polygon) {
           return;
@@ -43481,9 +43513,9 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         geometry = new Array(outer.length * 3);
 
         for (i = d3 = 0; i < outer.length; i += 1, d3 += 3) {
-          c = posFunc(outer[i], i, item, itemIndex);
+          c = posFunc ? posFunc(outer[i], i, item, itemIndex) : outer[i];
           geometry[d3] = c.x;
-          geometry[d3 + 1] = simpleInverse ? -c.y : c.y; // ignore the z values until we support them
+          geometry[d3 + 1] = c.y; // ignore the z values until we support them
 
           geometry[d3 + 2] = 0; // c.z || 0;
         }
@@ -43505,9 +43537,9 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
             geometry.holes.push(d3 / 3);
 
             for (i = 0; i < hole.length; i += 1, d3 += 3) {
-              c = posFunc(hole[i], i, item, itemIndex);
+              c = posFunc ? posFunc(hole[i], i, item, itemIndex) : hole[i];
               geometry.vertices[d3] = c.x;
-              geometry.vertices[d3 + 1] = simpleInverse ? -c.y : c.y; // ignore the z values until we support them
+              geometry.vertices[d3 + 1] = c.y; // ignore the z values until we support them
 
               geometry.vertices[d3 + 2] = 0; // c.z || 0;
             }
@@ -43515,10 +43547,7 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         } // transform to map gcs
 
 
-        if (!simpleInverse) {
-          geometry.vertices = transform.transformCoordinates(target_gcs, map_gcs, geometry.vertices, geometry.dimensions);
-        }
-
+        geometry.vertices = transform.transformCoordinates(target_gcs, map_gcs, geometry.vertices, geometry.dimensions);
         record = {
           // triangulate
           triangles: earcut(geometry.vertices, geometry.holes, geometry.dimensions),
@@ -43564,7 +43593,7 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
       item = items[k].item;
       itemIndex = items[k].itemIndex;
       original = items[k].original;
-      uniform = uniformPolyFunc(item, itemIndex);
+      uniform = uniformVal === undefined ? uniformFunc(item, itemIndex) : uniformVal;
       opacity = fillOpacityVal;
 
       if (uniform) {