fill trace._extremes with findExtremes in calc

etpinard · etpinard · commit 769c16020bb7 · 2018-07-31T14:22:14.000-04:00
- replacing Axe.expand
- for ErrorBars, we append the min/max arrays
  of the corresponding trace
diff --git a/src/components/errorbars/calc.js b/src/components/errorbars/calc.js
@@ -21,16 +21,15 @@ 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(!Registry.traceIs(trace, 'errorBarsOK')) continue;
-
-        var xa = Axes.getFromId(gd, trace.xaxis),
-            ya = Axes.getFromId(gd, trace.yaxis);
-
-        calcOneAxis(calcTrace, trace, xa, 'x');
-        calcOneAxis(calcTrace, trace, ya, 'y');
+        var calcTrace = calcdata[i];
+        var trace = calcTrace[0].trace;
+
+        if(trace.visible === true && Registry.traceIs(trace, 'errorBarsOK')) {
+            var xa = Axes.getFromId(gd, trace.xaxis);
+            var ya = Axes.getFromId(gd, trace.yaxis);
+            calcOneAxis(calcTrace, trace, xa, 'x');
+            calcOneAxis(calcTrace, trace, ya, 'y');
+        }
     }
 };
 
@@ -57,5 +56,8 @@ function calcOneAxis(calcTrace, trace, axis, coord) {
         }
     }
 
-    Axes.expand(axis, vals, {padded: true});
+    var extremes = Axes.findExtremes(axis, vals, {padded: true});
+    var axId = axis._id;
+    trace._extremes[axId].min = trace._extremes[axId].min.concat(extremes.min);
+    trace._extremes[axId].max = trace._extremes[axId].max.concat(extremes.max);
 }
diff --git a/src/plots/cartesian/axes.js b/src/plots/cartesian/axes.js
@@ -50,6 +50,7 @@ axes.getFromTrace = axisIds.getFromTrace;
 var autorange = require('./autorange');
 axes.expand = autorange.expand;
 axes.getAutoRange = autorange.getAutoRange;
+axes.findExtremes = autorange.findExtremes;
 
 /*
  * find the list of possible axes to reference with an xref or yref attribute
diff --git a/src/plots/plots.js b/src/plots/plots.js
@@ -2455,10 +2455,13 @@ plots.doCalcdata = function(gd, traces) {
         }
     }
 
-    // find array attributes in trace
     for(i = 0; i < fullData.length; i++) {
         trace = fullData[i];
+
         trace._arrayAttrs = PlotSchema.findArrayAttributes(trace);
+
+        // keep track of trace extremes (for autorange) in here
+        trace._extremes = {};
     }
 
     // add polar axes to axis list
diff --git a/src/traces/bar/set_positions.js b/src/traces/bar/set_positions.js
@@ -496,7 +496,8 @@ function updatePositionAxis(gd, pa, sieve, allowMinDtick) {
         }
     }
 
-    Axes.expand(pa, [pMin, pMax], {padded: false});
+    var extremes = Axes.findExtremes(pa, [pMin, pMax], {padded: false});
+    putExtremes(calcTraces, pa, extremes);
 }
 
 function expandRange(range, newValue) {
@@ -530,7 +531,8 @@ function setBaseAndTop(gd, sa, sieve) {
         }
     }
 
-    Axes.expand(sa, sRange, {tozero: true, padded: true});
+    var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: true});
+    putExtremes(traces, sa, extremes);
 }
 
 
@@ -568,7 +570,10 @@ function stackBars(gd, sa, sieve) {
     }
 
     // if barnorm is set, let normalizeBars update the axis range
-    if(!barnorm) Axes.expand(sa, sRange, {tozero: true, padded: true});
+    if(!barnorm) {
+        var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: true});
+        putExtremes(traces, sa, extremes);
+    }
 }
 
 
@@ -633,14 +638,21 @@ function normalizeBars(gd, sa, sieve) {
     }
 
     // update range of size axis
-    Axes.expand(sa, sRange, {tozero: true, padded: padded});
+    var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: padded});
+    putExtremes(traces, sa, extremes);
 }
 
 
 function getAxisLetter(ax) {
     return ax._id.charAt(0);
 }
 
+function putExtremes(cd, ax, extremes) {
+    for(var i = 0; i < cd.length; i++) {
+        cd[i][0].trace._extremes[ax._id] = extremes;
+    }
+}
+
 // find the full position span of bars at each position
 // for use by hover, to ensure labels move in if bars are
 // narrower than the space they're in.
diff --git a/src/traces/box/calc.js b/src/traces/box/calc.js
@@ -122,7 +122,8 @@ module.exports = function calc(gd, trace) {
     }
 
     calcSelection(cd, trace);
-    Axes.expand(valAxis, val, {padded: true});
+    var extremes = Axes.findExtremes(valAxis, val, {padded: true});
+    trace._extremes[valAxis._id] = extremes;
 
     if(cd.length > 0) {
         cd[0].t = {
diff --git a/src/traces/box/set_positions.js b/src/traces/box/set_positions.js
@@ -86,23 +86,26 @@ function setPositionOffset(traceType, gd, boxList, posAxis, pad) {
     // check for forced minimum dtick
     Axes.minDtick(posAxis, boxdv.minDiff, boxdv.vals[0], true);
 
-    // set the width of all boxes
-    for(i = 0; i < boxList.length; i++) {
-        calcTrace = calcdata[boxList[i]];
-        calcTrace[0].t.dPos = dPos;
-    }
-
     var gap = fullLayout[traceType + 'gap'];
     var groupgap = fullLayout[traceType + 'groupgap'];
     var padfactor = (1 - gap) * (1 - groupgap) * dPos / fullLayout[numKey];
 
     // autoscale the x axis - including space for points if they're off the side
     // TODO: this will overdo it if the outermost boxes don't have
     // their points as far out as the other boxes
-    Axes.expand(posAxis, boxdv.vals, {
+    var extremes = Axes.findExtremes(posAxis, boxdv.vals, {
         vpadminus: dPos + pad[0] * padfactor,
         vpadplus: dPos + pad[1] * padfactor
     });
+
+    for(i = 0; i < boxList.length; i++) {
+        calcTrace = calcdata[boxList[i]];
+        // set the width of all boxes
+        calcTrace[0].t.dPos = dPos;
+        // link extremes to all boxes
+        calcTrace[0].trace._extremes[posAxis._id] = extremes;
+    }
+
 }
 
 module.exports = {
diff --git a/src/traces/carpet/calc.js b/src/traces/carpet/calc.js
@@ -82,8 +82,8 @@ module.exports = function calc(gd, trace) {
     xrange = [xc - dx * grow, xc + dx * grow];
     yrange = [yc - dy * grow, yc + dy * grow];
 
-    Axes.expand(xa, xrange, {padded: true});
-    Axes.expand(ya, yrange, {padded: true});
+    trace._extremes[xa._id] = Axes.findExtremes(xa, xrange, {padded: true});
+    trace._extremes[ya._id] = Axes.findExtremes(ya, yrange, {padded: true});
 
     // Enumerate the gridlines, both major and minor, and store them on the trace
     // object:
diff --git a/src/traces/heatmap/calc.js b/src/traces/heatmap/calc.js
@@ -124,8 +124,8 @@ module.exports = function calc(gd, trace) {
 
     // handled in gl2d convert step
     if(!isGL2D) {
-        Axes.expand(xa, xArray);
-        Axes.expand(ya, yArray);
+        trace._extremes[xa._id] = Axes.findExtremes(xa, xArray);
+        trace._extremes[ya._id] = Axes.findExtremes(ya, yArray);
     }
 
     var cd0 = {
diff --git a/src/traces/ohlc/calc.js b/src/traces/ohlc/calc.js
@@ -25,8 +25,7 @@ function calc(gd, trace) {
 
     var cd = calcCommon(gd, trace, x, ya, ptFunc);
 
-    Axes.expand(xa, x, {vpad: minDiff / 2});
-
+    trace._extremes[xa._id] = Axes.findExtremes(xa, x, {vpad: minDiff / 2});
     if(cd.length) {
         Lib.extendFlat(cd[0].t, {
             wHover: minDiff / 2,
@@ -93,7 +92,7 @@ function calcCommon(gd, trace, x, ya, ptFunc) {
         }
     }
 
-    Axes.expand(ya, l.concat(h), {padded: true});
+    trace._extremes[ya._id] = Axes.findExtremes(ya, l.concat(h), {padded: true});
 
     if(cd.length) {
         cd[0].t = {
diff --git a/src/traces/scatter/calc.js b/src/traces/scatter/calc.js
@@ -97,8 +97,8 @@ function calcAxisExpansion(gd, trace, xa, ya, x, y, ppad) {
     }
 
     // N.B. asymmetric splom traces call this with blank {} xa or ya
-    if(xa._id) Axes.expand(xa, x, xOptions);
-    if(ya._id) Axes.expand(ya, y, yOptions);
+    if(xa._id) trace._extremes[xa._id] = Axes.findExtremes(xa, x, xOptions);
+    if(ya._id) trace._extremes[ya._id] = Axes.findExtremes(ya, y, yOptions);
 }
 
 function calcMarkerSize(trace, serieslen) {
diff --git a/src/traces/scattergl/convert.js b/src/traces/scattergl/convert.js
@@ -15,7 +15,6 @@ 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;
@@ -511,11 +510,10 @@ function convertErrorBarPositions(gd, trace, positions, x, y) {
                 }
             }
 
-            Axes.expand(ax, [minShoe, maxHat], {padded: true});
-
             out[axLetter] = {
                 positions: positions,
-                errors: errors
+                errors: errors,
+                _bnds: [minShoe, maxHat]
             };
         }
     }
diff --git a/src/traces/scattergl/index.js b/src/traces/scattergl/index.js
@@ -19,6 +19,7 @@ var Registry = require('../../registry');
 var Lib = require('../../lib');
 var prepareRegl = require('../../lib/prepare_regl');
 var AxisIDs = require('../../plots/cartesian/axis_ids');
+var findExtremes = require('../../plots/cartesian/autorange').findExtremes;
 var Color = require('../../components/color');
 
 var subTypes = require('../scatter/subtypes');
@@ -85,18 +86,18 @@ function calc(gd, trace) {
     var opts = sceneOptions(gd, subplot, trace, positions, x, y);
     var scene = sceneUpdate(gd, subplot);
 
-    // Re-use SVG scatter axis expansion routine except
-    // for graph with very large number of points where it
-    // performs poorly.
-    // In big data case, fake Axes.expand outputs with data bounds,
-    // and an average size for array marker.size inputs.
+    // Reuse SVG scatter axis expansion routine.
+    // For graphs with very large number of points and array marker.size,
+    // use average marker size instead to speed things up.
     var ppad;
     if(count < TOO_MANY_POINTS) {
         ppad = calcMarkerSize(trace, count);
     } else if(opts.marker) {
         ppad = 2 * (opts.marker.sizeAvg || Math.max(opts.marker.size, 3));
     }
     calcAxisExpansion(gd, trace, xa, ya, x, y, ppad);
+    if(opts.errorX) expandForErrorBars(trace, xa, opts.errorX);
+    if(opts.errorY) expandForErrorBars(trace, ya, opts.errorY);
 
     // set flags to create scene renderers
     if(opts.fill && !scene.fill2d) scene.fill2d = true;
@@ -137,6 +138,12 @@ function calc(gd, trace) {
     return [{x: false, y: false, t: stash, trace: trace}];
 }
 
+function expandForErrorBars(trace, ax, opts) {
+    var extremes = trace._extremes[ax._id];
+    var errExt = findExtremes(ax, opts._bnds, {padded: true});
+    extremes.min = extremes.min.concat(errExt.min);
+    extremes.max = extremes.max.concat(errExt.max);
+}
 
 // create scene options
 function sceneOptions(gd, subplot, trace, positions, x, y) {
diff --git a/src/traces/splom/index.js b/src/traces/splom/index.js
@@ -66,11 +66,9 @@ function calc(gd, trace) {
             var xa = AxisIDs.getFromId(gd, trace._diag[i][0]) || {};
             var ya = AxisIDs.getFromId(gd, trace._diag[i][1]) || {};
 
-            // Re-use SVG scatter axis expansion routine except
-            // for graph with very large number of points where it
-            // performs poorly.
-            // In big data case, fake Axes.expand outputs with data bounds,
-            // and an average size for array marker.size inputs.
+            // Reuse SVG scatter axis expansion routine.
+            // For graphs with very large number of points and array marker.size,
+            // use average marker size instead to speed things up.
             var ppad;
             if(hasTooManyPoints) {
                 ppad = 2 * (opts.sizeAvg || Math.max(opts.size, 3));
diff --git a/src/traces/violin/calc.js b/src/traces/violin/calc.js
@@ -35,6 +35,9 @@ module.exports = function calc(gd, trace) {
         };
     }
 
+    var spanMin = Infinity;
+    var spanMax = -Infinity;
+
     for(var i = 0; i < cd.length; i++) {
         var cdi = cd[i];
         var vals = cdi.pts.map(helpers.extractVal);
@@ -62,10 +65,15 @@ module.exports = function calc(gd, trace) {
             cdi.density[k] = {v: v, t: t};
         }
 
-        Axes.expand(valAxis, span, {padded: true});
         groupStats.maxCount = Math.max(groupStats.maxCount, vals.length);
+
+        spanMin = Math.min(spanMin, span[0]);
+        spanMax = Math.max(spanMax, span[1]);
     }
 
+    var extremes = Axes.findExtremes(valAxis, [spanMin, spanMax], {padded: true});
+    trace._extremes[valAxis._id] = extremes;
+
     cd[0].t.labels.kde = Lib._(gd, 'kde:');
 
     return cd;

Original file line number	Diff line number	Diff line change
`@@ -2455,10 +2455,13 @@ plots.doCalcdata = function(gd, traces) {`
`2455`	`2455`	`}`
`2456`	`2456`	`}`
`2457`	`2457`
`2458`		`- // find array attributes in trace`
`2459`	`2458`	`for(i = 0; i < fullData.length; i++) {`
`2460`	`2459`	`trace = fullData[i];`
	`2460`	`+`
`2461`	`2461`	`trace._arrayAttrs = PlotSchema.findArrayAttributes(trace);`
	`2462`	`+`
	`2463`	`+ // keep track of trace extremes (for autorange) in here`
	`2464`	`+ trace._extremes = {};`
`2462`	`2465`	`}`
`2463`	`2466`
`2464`	`2467`	`// add polar axes to axis list`
Original file line number	Diff line number	Diff line change
`@@ -496,7 +496,8 @@ function updatePositionAxis(gd, pa, sieve, allowMinDtick) {`
`496`	`496`	`}`
`497`	`497`	`}`
`498`	`498`
`499`		`- Axes.expand(pa, [pMin, pMax], {padded: false});`
	`499`	`+ var extremes = Axes.findExtremes(pa, [pMin, pMax], {padded: false});`
	`500`	`+ putExtremes(calcTraces, pa, extremes);`
`500`	`501`	`}`
`501`	`502`
`502`	`503`	`function expandRange(range, newValue) {`
`@@ -530,7 +531,8 @@ function setBaseAndTop(gd, sa, sieve) {`
`530`	`531`	`}`
`531`	`532`	`}`
`532`	`533`
`533`		`- Axes.expand(sa, sRange, {tozero: true, padded: true});`
	`534`	`+ var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: true});`
	`535`	`+ putExtremes(traces, sa, extremes);`
`534`	`536`	`}`
`535`	`537`
`536`	`538`
`@@ -568,7 +570,10 @@ function stackBars(gd, sa, sieve) {`
`568`	`570`	`}`
`569`	`571`
`570`	`572`	`// if barnorm is set, let normalizeBars update the axis range`
`571`		`- if(!barnorm) Axes.expand(sa, sRange, {tozero: true, padded: true});`
	`573`	`+ if(!barnorm) {`
	`574`	`+ var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: true});`
	`575`	`+ putExtremes(traces, sa, extremes);`
	`576`	`+ }`
`572`	`577`	`}`
`573`	`578`
`574`	`579`
`@@ -633,14 +638,21 @@ function normalizeBars(gd, sa, sieve) {`
`633`	`638`	`}`
`634`	`639`
`635`	`640`	`// update range of size axis`
`636`		`- Axes.expand(sa, sRange, {tozero: true, padded: padded});`
	`641`	`+ var extremes = Axes.findExtremes(sa, sRange, {tozero: true, padded: padded});`
	`642`	`+ putExtremes(traces, sa, extremes);`
`637`	`643`	`}`
`638`	`644`
`639`	`645`
`640`	`646`	`function getAxisLetter(ax) {`
`641`	`647`	`return ax._id.charAt(0);`
`642`	`648`	`}`
`643`	`649`
	`650`	`+function putExtremes(cd, ax, extremes) {`
	`651`	`+ for(var i = 0; i < cd.length; i++) {`
	`652`	`+ cd[i][0].trace._extremes[ax._id] = extremes;`
	`653`	`+ }`
	`654`	`+}`
	`655`	`+`
`644`	`656`	`// find the full position span of bars at each position`
`645`	`657`	`// for use by hover, to ensure labels move in if bars are`
`646`	`658`	`// narrower than the space they're in.`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,8 @@ module.exports = function calc(gd, trace) {`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`calcSelection(cd, trace);`
`125`		`- Axes.expand(valAxis, val, {padded: true});`
	`125`	`+ var extremes = Axes.findExtremes(valAxis, val, {padded: true});`
	`126`	`+ trace._extremes[valAxis._id] = extremes;`
`126`	`127`
`127`	`128`	`if(cd.length > 0) {`
`128`	`129`	`cd[0].t = {`
Original file line number	Diff line number	Diff line change
`@@ -124,8 +124,8 @@ module.exports = function calc(gd, trace) {`
`124`	`124`
`125`	`125`	`// handled in gl2d convert step`
`126`	`126`	`if(!isGL2D) {`
`127`		`- Axes.expand(xa, xArray);`
`128`		`- Axes.expand(ya, yArray);`
	`127`	`+ trace._extremes[xa._id] = Axes.findExtremes(xa, xArray);`
	`128`	`+ trace._extremes[ya._id] = Axes.findExtremes(ya, yArray);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`var cd0 = {`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,7 @@ function calc(gd, trace) {`
`25`	`25`
`26`	`26`	`var cd = calcCommon(gd, trace, x, ya, ptFunc);`
`27`	`27`
`28`		`- Axes.expand(xa, x, {vpad: minDiff / 2});`
`29`		`-`
	`28`	`+ trace._extremes[xa._id] = Axes.findExtremes(xa, x, {vpad: minDiff / 2});`
`30`	`29`	`if(cd.length) {`
`31`	`30`	`Lib.extendFlat(cd[0].t, {`
`32`	`31`	`wHover: minDiff / 2,`
`@@ -93,7 +92,7 @@ function calcCommon(gd, trace, x, ya, ptFunc) {`
`93`	`92`	`}`
`94`	`93`	`}`
`95`	`94`
`96`		`- Axes.expand(ya, l.concat(h), {padded: true});`
	`95`	`+ trace._extremes[ya._id] = Axes.findExtremes(ya, l.concat(h), {padded: true});`
`97`	`96`
`98`	`97`	`if(cd.length) {`
`99`	`98`	`cd[0].t = {`
Original file line number	Diff line number	Diff line change
`@@ -97,8 +97,8 @@ function calcAxisExpansion(gd, trace, xa, ya, x, y, ppad) {`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`// N.B. asymmetric splom traces call this with blank {} xa or ya`
`100`		`- if(xa._id) Axes.expand(xa, x, xOptions);`
`101`		`- if(ya._id) Axes.expand(ya, y, yOptions);`
	`100`	`+ if(xa._id) trace._extremes[xa._id] = Axes.findExtremes(xa, x, xOptions);`
	`101`	`+ if(ya._id) trace._extremes[ya._id] = Axes.findExtremes(ya, y, yOptions);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`function calcMarkerSize(trace, serieslen) {`