replace calcFromTrace wrapper with more direct computeError routine

- this should be a performance boost as we no longer mock calcdata item

Author: etpinard

src/components/errorbars/index.js

@@ -49,37 +49,12 @@ module.exports = {
     supplyDefaults: require('./defaults'),
 
     calc: calc,
-    calcFromTrace: calcFromTrace,
 
     plot: require('./plot'),
     style: require('./style'),
     hoverInfo: hoverInfo
 };
 
-function calcFromTrace(trace, layout) {
-    var x = trace.x || [],
-        y = trace.y || [],
-        len = x.length || y.length;
-
-    var calcdataMock = new Array(len);
-
-    for(var i = 0; i < len; i++) {
-        calcdataMock[i] = {
-            x: x[i],
-            y: y[i]
-        };
-    }
-
-    calcdataMock[0].trace = trace;
-
-    calc({
-        calcdata: [calcdataMock],
-        _fullLayout: layout
-    });
-
-    return calcdataMock;
-}
-
 function hoverInfo(calcPoint, trace, hoverPoint) {
     if((trace.error_y || {}).visible) {
         hoverPoint.yerr = calcPoint.yh - calcPoint.y;

src/traces/scattergl/convert.js

@@ -8,17 +8,20 @@
 
 'use strict';
 
+var isNumeric = require('fast-isnumeric');
 var svgSdf = require('svg-path-sdf');
 var rgba = require('color-normalize');
 
 var Registry = require('../../registry');
 var Lib = require('../../lib');
 var Drawing = require('../../components/drawing');
+var Axes = require('../../plots/cartesian/axes');
 var AxisIDs = require('../../plots/cartesian/axis_ids');
 
 var formatColor = require('../../lib/gl_format_color').formatColor;
 var subTypes = require('../scatter/subtypes');
 var makeBubbleSizeFn = require('../scatter/make_bubble_size_func');
+var makeComputeError = require('../../components/errorbars/compute_error');
 
 var constants = require('./constants');
 var DESELECTDIM = require('../../constants/interactions').DESELECTDIM;
@@ -360,42 +363,59 @@ function convertLinePositions(gd, trace, positions) {
     };
 }
 
-function convertErrorBarPositions(gd, trace, pos, x, y) {
-    var calcFromTrace = Registry.getComponentMethod('errorbars', 'calcFromTrace');
-    var _trace = Lib.extendFlat({}, trace, {x: x, y: y});
-    var vals = calcFromTrace(_trace, gd._fullLayout);
-    var count = pos.length / 2;
+function convertErrorBarPositions(gd, trace, positions, x, y) {
+    var xa = AxisIDs.getFromId(gd, trace.xaxis);
+    var ya = AxisIDs.getFromId(gd, trace.yaxis);
+    var count = positions.length / 2;
     var out = {};
 
-    function put(axLetter) {
-        var errors = new Float64Array(4 * count);
-        var ax = AxisIDs.getFromId(gd, trace[axLetter + 'axis']);
-        var pOffset = {x: 0, y: 1}[axLetter];
-        var eOffset = {x: [0, 1, 2, 3], y: [2, 3, 0, 1]}[axLetter];
-
-        for(var i = 0, p = 0; i < count; i++, p += 4) {
-            errors[p + eOffset[0]] = pos[i * 2 + pOffset] - ax.c2l(vals[i][axLetter + 's']) || 0;
-            errors[p + eOffset[1]] = ax.c2l(vals[i][axLetter + 'h']) - pos[i * 2 + pOffset] || 0;
-            errors[p + eOffset[2]] = 0;
-            errors[p + eOffset[3]] = 0;
-        }
+    function convertOneAxis(coords, ax) {
+        var axLetter = ax._id.charAt(0);
+        var opts = trace['error_' + axLetter];
+
+        if(opts && opts.visible && (ax.type === 'linear' || ax.type === 'log')) {
+            var computeError = makeComputeError(trace['error_' + axLetter]);
+            var pOffset = {x: 0, y: 1}[axLetter];
+            var eOffset = {x: [0, 1, 2, 3], y: [2, 3, 0, 1]}[axLetter];
+            var errors = new Float64Array(4 * count);
+            var minShoe = Infinity;
+            var maxHat = -Infinity;
+
+            for(var i = 0, j = 0; i < count; i++, j += 4) {
+                var dc = coords[i];
+
+                if(isNumeric(dc)) {
+                    var dl = positions[i * 2 + pOffset];
+                    var vals = computeError(dc, i);
+                    var lv = vals[0];
+                    var hv = vals[1];
+
+                    if(isNumeric(lv) && isNumeric(hv)) {
+                        var shoe = dc - lv;
+                        var hat = dc + hv;
+
+                        errors[j + eOffset[0]] = dl - ax.c2l(shoe);
+                        errors[j + eOffset[1]] = ax.c2l(hat) - dl;
+                        errors[j + eOffset[2]] = 0;
+                        errors[j + eOffset[3]] = 0;
+
+                        minShoe = Math.min(minShoe, dc - lv);
+                        maxHat = Math.max(maxHat, dc + hv);
+                    }
+                }
+            }
 
-        return errors;
-    }
+            Axes.expand(ax, [minShoe, maxHat], {padded: true});
 
-    if(trace.error_x && trace.error_x.visible) {
-        out.x = {
-            positions: pos,
-            errors: put('x')
-        };
-    }
-    if(trace.error_y && trace.error_y.visible) {
-        out.y = {
-            positions: pos,
-            errors: put('y')
-        };
+            out[axLetter] = {
+                positions: positions,
+                errors: errors
+            };
+        }
     }
 
+    convertOneAxis(x, xa);
+    convertOneAxis(y, ya);
     return out;
 }