geojs 1.8.7 → 1.8.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "geojs",
-  "version": "1.8.7",
+  "version": "1.8.10",
   "description": "JavaScript Geo Visualization and Analysis Library",
   "homepage": "https://github.com/OpenGeoscience/geojs",
   "license": "Apache-2.0",

package/src/geojsonReader.js

@@ -55,6 +55,7 @@ var geojsonReader = function (arg) {
           strokeOffset: 0,
           lineCap: 'butt',
           lineJoin: 'miter',
+          uniformLine: true,
           closed: false,
           ...arg.lineStyle
         },
@@ -66,6 +67,7 @@ var geojsonReader = function (arg) {
           strokeColor: '#999999',
           strokeWidth: 2,
           strokeOpacity: 1,
+          uniformPolygon: true,
           ...arg.polygonStyle
         }
       };

package/src/graphFeature.js

@@ -80,7 +80,7 @@ var graphFeature = function (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;
   };
 

package/src/heatmapFeature.js

@@ -2,6 +2,7 @@ var $ = require('jquery');
 var inherit = require('./inherit');
 var feature = require('./feature');
 var transform = require('./transform');
+var util = require('./util');
 
 /**
  * Heatmap feature specification.
@@ -79,7 +80,7 @@ var heatmapFeature = function (arg) {
 
   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; };
   m_maxIntensity = arg.maxIntensity !== undefined ? arg.maxIntensity : null;
   m_minIntensity = arg.minIntensity !== undefined ? arg.minIntensity : null;

package/src/lineFeature.js

@@ -46,6 +46,9 @@ var util = require('./util');
  *   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.
@@ -157,18 +160,30 @@ var lineFeature = function (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();
+        mapgcs = m_this.layer().map().gcs(),
+        onlyInvertedY = transform.onlyInvertedY(gcs, mapgcs);
 
-    data.forEach(function (d, index) {
-      var closed = closedFunc(d, index),
-          last, lasti, lastr, lastr2, first, record = [], min, max;
+    for (let index = 0; index < data.length; index += 1) {
+      const d = data[index];
+      const closed = closedVal === undefined ? closedFunc(d, index) : closedVal;
+      let last, lasti, lastr, lastr2, first, min, max, width;
+      const record = [];
+      const uniform = uniformVal === undefined ? uniformFunc(d, index) : uniformVal;
 
-      line(d, index).forEach(function (current, j) {
-        var p = posFunc(current, j, d, index);
-        if (gcs !== mapgcs) {
+      const lineRecord = line(d, index);
+      for (let j = 0; j < lineRecord.length; j += 1) {
+        const current = lineRecord[j];
+        let p = posFunc(current, j, d, index);
+        if (onlyInvertedY) {
+          p.y = -p.y;
+        } else if (gcs !== mapgcs) {
           p = transform.transformCoordinates(gcs, mapgcs, p);
         }
         if (min === undefined) { min = {x: p.x, y: p.y}; }
@@ -177,9 +192,12 @@ var lineFeature = function (arg) {
         if (p.x > max.x) { max.x = p.x; }
         if (p.y < min.y) { min.y = p.y; }
         if (p.y > max.y) { 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;
+        }
+        const r = Math.ceil(width / 2) + 2;
         if (max.r === undefined || r > max.r) { max.r = r; }
-        var r2 = r * r;
+        const r2 = r * r;
         if (last) {
           record.push({u: p, v: last, r: lastr > r ? lastr : r, r2: lastr2 > r2 ? lastr2 : r2, i: j, j: lasti});
         }
@@ -190,14 +208,14 @@ var lineFeature = function (arg) {
         if (!first && closed) {
           first = {p: p, r: r, r2: r2, i: j};
         }
-      });
+      }
       if (closed && first && (last.x !== first.p.x || last.y !== first.p.y)) {
         record.push({u: last, v: first.p, r: lastr > first.r ? lastr : first.r, r2: lastr2 > first.r2 ? lastr2 : first.r2, i: lasti, j: first.i});
       }
       record.min = min;
       record.max = max;
       m_pointSearchInfo.push(record);
-    });
+    }
     return m_pointSearchInfo;
   };
 
@@ -438,8 +456,8 @@ var lineFeature = function (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;
   };
@@ -465,7 +483,7 @@ var lineFeature = function (arg) {
         // Values of 2 and above appear smoothest.
         antialiasing: 2.0,
         closed: false,
-        line: function (d) { return d; },
+        line: util.identityFunction,
         position: (d) => Array.isArray(d) ? {x: d[0], y: d[1], z: d[2] || 0} : d,
         origin: (p) => (p.length >= 3 ? p.slice(0, 3) : [0, 0, 0])
       },

package/src/pixelmapFeature.js

@@ -285,7 +285,7 @@ var pixelmapFeature = function (arg) {
             a: 1
           };
         },
-        position: function (d) { return d; }
+        position: util.identityFunction
       },
       arg.style === undefined ? {} : arg.style
     );

package/src/polygonFeature.js

@@ -495,7 +495,8 @@ var polygonFeature = function (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');
@@ -634,8 +635,8 @@ var polygonFeature = function (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;
   };
@@ -719,7 +720,7 @@ var polygonFeature = function (arg) {
         strokeStyle: 'solid',
         strokeColor: {r: 0.0, g: 1.0, b: 1.0},
         strokeOpacity: 1.0,
-        polygon: function (d) { return d; },
+        polygon: util.identityFunction,
         position: (d) => Array.isArray(d) ? {x: d[0], y: d[1], z: d[2] || 0} : d,
         origin: (items) => {
           for (let i = 0; i < items.length; i += 1) {

package/src/quadFeature.js

@@ -699,7 +699,7 @@ var quadFeature = function (arg) {
         previewImage: null,
         image: function (d) { return d.image; },
         video: function (d) { return d.video; },
-        position: function (d) { return d; }
+        position: util.identityFunction
       },
       arg.style === undefined ? {} : arg.style
     );

package/src/trackFeature.js

@@ -814,8 +814,8 @@ var trackFeature = function (arg) {
       true,
       {},
       {
-        track: (d) => d,
-        position: (d) => d,
+        track: util.identityFunction,
+        position: util.identityFunction,
         time: (d, i) => (d.t !== undefined ? d.t : i)
       },
       arg.style === undefined ? {} : arg.style

package/src/transform.js

@@ -19,7 +19,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/;
 
 /**

package/src/util/common.js

@@ -1443,6 +1443,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 (d) {
+    return d;
+  },
+
   ///////////////////////////////////////////////////////////////////////////
   /*
    * Utility member properties.

package/src/vectorFeature.js

@@ -1,5 +1,6 @@
 var inherit = require('./inherit');
 var feature = require('./feature');
+var util = require('./util');
 
 /**
  * Object specification for a graph feature.
@@ -120,7 +121,7 @@ var vectorFeature = function (arg) {
         originStyle: 'none',
         endStyle: 'arrow',
         origin: {x: 0, y: 0, z: 0},
-        delta: function (d) { return d; },
+        delta: util.identityFunction,
         scale: null // size scaling factor (null -> renderer decides)
       },
       arg.style === undefined ? {} : arg.style

package/src/webgl/lineFeature.js

@@ -136,7 +136,6 @@ var webgl_lineFeature = function (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, firstPosIdx3,
         lineFunc = m_this.line(),
         strokeWidthFunc = m_this.style.get('strokeWidth'), strokeWidthVal,
@@ -147,6 +146,7 @@ var webgl_lineFeature = function (arg) {
         strokeOffsetFunc = m_this.style.get('strokeOffset'), 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, nextkey, offkey,
         orderLen = order.length,
         // webgl buffers; see _init for details
@@ -165,6 +165,7 @@ var webgl_lineFeature = function (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
@@ -178,6 +179,7 @@ var webgl_lineFeature = function (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);
       for (i = 0; i < data.length; i += 1) {
@@ -189,9 +191,9 @@ var webgl_lineFeature = function (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) {
             firstpos = pos;
@@ -211,9 +213,7 @@ var webgl_lineFeature = function (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]) {
         for (i = 0; i < position.length; i += 3) {
@@ -264,6 +264,7 @@ var webgl_lineFeature = function (arg) {
       if (lineItem.length < 2) {
         continue;
       }
+      uniform = uniformVal === undefined ? uniformFunc(lineItem, i) : uniformVal;
       d = data[i];
       closedVal = closed[i];
       firstPosIdx3 = posIdx3;
@@ -290,12 +291,26 @@ var webgl_lineFeature = function (arg) {
             (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
                * from -1 to 1, so multiply our values by 1023, and use some bit

package/src/webgl/polygonFeature.js

@@ -77,12 +77,11 @@ var webgl_polygonFeature = function (arg) {
         fillColor, fillColorFunc, fillColorVal,
         fillOpacity, fillOpacityFunc, fillOpacityVal,
         fillFunc, fillVal,
-        uniformPolyFunc, uniform,
+        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, opacity, fill, d, d3, vertices, i, j, k, n,
@@ -94,15 +93,18 @@ var webgl_polygonFeature = function (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;
         }
@@ -116,9 +118,9 @@ var webgl_polygonFeature = function (arg) {
          * test). */
         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;
+          geometry[d3 + 1] = c.y;
           // ignore the z values until we support them
           geometry[d3 + 2] = 0;  // c.z || 0;
         }
@@ -133,9 +135,9 @@ var webgl_polygonFeature = function (arg) {
             original = original.concat(hole);
             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;
+              geometry.vertices[d3 + 1] = c.y;
               // ignore the z values until we support them
               geometry.vertices[d3 + 2] = 0;  // c.z || 0;
             }
@@ -143,14 +145,12 @@ var webgl_polygonFeature = function (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
@@ -189,7 +189,7 @@ var webgl_polygonFeature = function (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) {
         if (fillColorVal === undefined) {