split error bar calc step into calc.js and compute_error.js :

- compute_error is the reusable piece of logic that
  gl3d and gl2d error bars will use.

Author: etpinard

src/components/errorbars/calc.js

@@ -0,0 +1,66 @@
+/**
+* Copyright 2012-2015, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+var isNumeric = require('fast-isnumeric');
+
+var Plots = require('../../plots/plots');
+var Axes = require('../../plots/cartesian/axes');
+
+var compureError = require('./compute_error');
+
+
+module.exports = function calc(gd) {
+    var calcdata = gd.calcdata;
+
+    for(var i = 0; i < calcdata.length; i++) {
+        var calcTrace = calcdata[i],
+            trace = calcTrace[0].trace;
+
+        if(!Plots.traceIs(trace, 'errorBarsOK')) continue;
+
+        var xObj = trace.error_x || {},
+            yObj = trace.error_y || {},
+            xa = Axes.getFromId(gd, trace.xaxis),
+            ya = Axes.getFromId(gd, trace.yaxis),
+            xVis = xObj.visible && ['linear', 'log'].indexOf(xa.type)!==-1,
+            yVis = yObj.visible && ['linear', 'log'].indexOf(ya.type)!==-1;
+
+        if(!xVis && !yVis) continue;
+
+        var xVals = [],
+            yVals = [];
+
+        for(var j = 0; j < calcTrace.length; j++) {
+            var calcPt = calcTrace[j],
+                calcX = calcPt.x,
+                calcY = calcPt.y;
+
+            if(!isNumeric(ya.c2l(calcY)) || !isNumeric(xa.c2l(calcX))) continue;
+
+            var errorY = compureError(calcY, j, yObj);
+            if(isNumeric(errorY[0]) && isNumeric(errorY[1])) {
+                calcPt.ys = calcY - errorY[0];
+                calcPt.yh = calcY + errorY[1];
+                yVals.push(calcPt.ys, calcPt.yh);
+            }
+
+            var errorX = compureError(calcX, j, xObj);
+            if(isNumeric(errorX[0]) && isNumeric(errorX[1])) {
+                calcPt.xs = calcX - errorX[0];
+                calcPt.xh = calcX + errorX[1];
+                xVals.push(calcPt.xs, calcPt.xh);
+            }
+        }
+
+        Axes.expand(ya, yVals, {padded: true});
+        Axes.expand(xa, xVals, {padded: true});
+    }
+};

src/components/errorbars/compute_error.js

@@ -0,0 +1,53 @@
+/**
+* Copyright 2012-2015, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+
+'use strict';
+
+
+/**
+ * Compute the positive and negative error bar magnitudes.
+ *
+ * N.B. This function does not clean the dataPt entries, non-numeric
+ * entries result in undefined *error*
+ *
+ * @param {numeric} dataPt data point from where to compute the error magnitue
+ * @param {number} index index of dataPt in its corresponding data array
+ * @param {object} opts error bar attributes
+ *
+ * @return {array of two numbers}
+ *      - error[0] : error magnitude in the negative direction
+ *      - error[1] : " " " " positive "
+ */
+module.exports = function computeError(dataPt, index, opts) {
+    var type = opts.type,
+        error = new Array(2);
+
+    if(type === 'data') {
+        error[1] = +(opts.array[index]);
+        error[0] = (opts.symmetric || opts.arrayminus === undefined) ?
+            error[1] :
+            +(opts.arrayminus[index]);
+    }
+    else {
+        error[1] = getErrorVal(type, dataPt, opts.value);
+        error[0] = (opts.symmetric || opts.valueminus === undefined) ?
+            error[1] :
+            getErrorVal(type, dataPt, opts.valueminus);
+    }
+
+
+    return error;
+};
+
+// size the error bar itself (for all types except data)
+function getErrorVal(type, dataPt, value) {
+    if(type === 'percent') return Math.abs(dataPt * value / 100);
+    if(type === 'constant') return Math.abs(value);
+    if(type === 'sqrt') return Math.sqrt(Math.abs(dataPt));
+}

src/components/errorbars/index.js

@@ -19,69 +19,7 @@ errorBars.attributes = require('./attributes');
 
 errorBars.supplyDefaults = require('./defaults');
 
-// size the error bar itself (for all types except data)
-function errorval(type, dataval, errval) {
-    if(type === 'percent') return Math.abs(dataval * errval / 100);
-    if(type === 'constant') return Math.abs(errval);
-    if(type === 'sqrt') return Math.sqrt(Math.abs(dataval));
-
-    return 0;
-}
-
-errorBars.calc = function(gd) {
-    (gd.calcdata||[]).forEach(function(cdi){
-        var trace = cdi[0].trace;
-
-        if(!Plotly.Plots.traceIs(trace, 'errorBarsOK')) return;
-
-        var xObj = trace.error_x || {},
-            yObj = trace.error_y || {},
-            xa = Plotly.Axes.getFromId(gd, trace.xaxis),
-            ya = Plotly.Axes.getFromId(gd, trace.yaxis),
-            xvis = xObj.visible && ['linear', 'log'].indexOf(xa.type)!==-1,
-            yvis = yObj.visible && ['linear', 'log'].indexOf(ya.type)!==-1;
-
-        if(!xvis && !yvis) return;
-
-        var xvals = [],
-            yvals = [];
-
-        cdi.forEach(function(d,j) {
-            try {
-                if(isNumeric(ya.c2l(d.y)) && isNumeric(xa.c2l(d.x))){
-                    [
-                        {letter:'x', obj: xObj, visible: xvis, vals: xvals},
-                        {letter:'y', obj: yObj, visible: yvis, vals: yvals}
-                    ].forEach(function(o){
-                        if(o.visible) {
-                            var dataVal = d[o.letter],
-                                obj = o.obj,
-                                ep, en;
-                            if(o.obj.type==='data') {
-                                ep = Number(obj.array[j]);
-                                en = (obj.symmetric || !('arrayminus' in obj)) ?
-                                    ep : Number(obj.arrayminus[j]);
-                            }
-                            else {
-                                ep = errorval(obj.type, dataVal, obj.value);
-                                en = (obj.symmetric || !('valueminus' in obj)) ?
-                                    ep : errorval(obj.type, dataVal, obj.valueminus);
-                            }
-                            if(isNumeric(ep) && isNumeric(en)) {
-                                var shoe = d[o.letter + 'h'] = dataVal + ep;
-                                var hat = d[o.letter + 's'] = dataVal - en;
-                                o.vals.push(shoe, hat);
-                            }
-                        }
-                    });
-                }
-            }
-            catch(e) { console.log(e); }
-        });
-        Plotly.Axes.expand(ya, yvals, {padded: true});
-        Plotly.Axes.expand(xa, xvals, {padded: true});
-    });
-};
+errorBars.calc = require('./calc');
 
 errorBars.calcFromTrace = function(trace, layout) {
     var x = trace.x || [],