make contour zmin/zmax logic compatible with color axes

- remove zmin/zmax mutations happening after the calc stpe
- make traceIs('contour') traces call Colorscale.calc with
  their own options.

Author: etpinard

src/components/colorbar/draw.js

@@ -158,6 +158,11 @@ function makeColorBarData(gd) {
             opts._propPrefix = k + '.colorbar.';
 
             cbOpt = {min: 'cmin', max: 'cmax'};
+            if(colorAxOpts[0] !== 'heatmap') {
+                trace = colorAxOpts[1];
+                cbOpt.calc = trace._module.colorbar.calc;
+            }
+
             calcOpts();
             out.push(opts);
         }

src/traces/contour/calc.js

@@ -6,17 +6,46 @@
 * LICENSE file in the root directory of this source tree.
 */
 
-
 'use strict';
 
+var Colorscale = require('../../components/colorscale');
+
 var heatmapCalc = require('../heatmap/calc');
 var setContours = require('./set_contours');
+var endPlus = require('./end_plus');
 
 // most is the same as heatmap calc, then adjust it
 // though a few things inside heatmap calc still look for
 // contour maps, because the makeBoundArray calls are too entangled
 module.exports = function calc(gd, trace) {
     var cd = heatmapCalc(gd, trace);
-    setContours(trace);
+
+    var zOut = cd[0].z;
+    setContours(trace, zOut);
+
+    var contours = trace.contours;
+    var cOpts = Colorscale.extractOpts(trace);
+    var cVals;
+
+    if(contours.coloring === 'heatmap' && cOpts.auto && trace.autocontour === false) {
+        var start = contours.start;
+        var end = endPlus(contours);
+        var cs = contours.size || 1;
+        var nc = Math.floor((end - start) / cs) + 1;
+
+        if(!isFinite(cs)) {
+            cs = 1;
+            nc = 1;
+        }
+
+        var min0 = start - cs / 2;
+        var max0 = min0 + nc * cs;
+        cVals = [min0, max0];
+    } else {
+        cVals = zOut;
+    }
+
+    Colorscale.calc(gd, trace, {vals: cVals, cLetter: 'z'});
+
     return cd;
 };

src/traces/contour/colorbar.js

@@ -8,20 +8,21 @@
 
 'use strict';
 
+var extractOpts = require('../../components/colorscale').extractOpts;
 var makeColorMap = require('./make_color_map');
 var endPlus = require('./end_plus');
 
-function calc(gd, cd, opts) {
-    var trace = cd[0].trace;
+function calc(gd, trace, opts) {
     var contours = trace.contours;
     var line = trace.line;
     var cs = contours.size || 1;
     var coloring = contours.coloring;
     var colorMap = makeColorMap(trace, {isColorbar: true});
 
     if(coloring === 'heatmap') {
+        var cOpts = extractOpts(trace);
         opts._fillgradient = trace.colorscale;
-        opts._zrange = [trace.zmin, trace.zmax];
+        opts._zrange = [cOpts.min, cOpts.max];
     } else if(coloring === 'fill') {
         opts._fillcolor = colorMap;
     }

src/traces/contour/make_color_map.js

@@ -6,10 +6,10 @@
 * LICENSE file in the root directory of this source tree.
 */
 
-
 'use strict';
 
 var d3 = require('d3');
+
 var Colorscale = require('../../components/colorscale');
 var endPlus = require('./end_plus');
 
@@ -20,15 +20,16 @@ module.exports = function makeColorMap(trace) {
     var cs = contours.size || 1;
     var nc = Math.floor((end - start) / cs) + 1;
     var extra = contours.coloring === 'lines' ? 0 : 1;
+    var cOpts = Colorscale.extractOpts(trace);
 
     if(!isFinite(cs)) {
         cs = 1;
         nc = 1;
     }
 
-    var scl = trace.reversescale ?
-        Colorscale.flipScale(trace.colorscale) :
-        trace.colorscale;
+    var scl = cOpts.reversescale ?
+        Colorscale.flipScale(cOpts.colorscale) :
+        cOpts.colorscale;
 
     var len = scl.length;
     var domain = new Array(len);
@@ -37,51 +38,45 @@ module.exports = function makeColorMap(trace) {
     var si, i;
 
     if(contours.coloring === 'heatmap') {
-        if(trace.zauto && trace.autocontour === false) {
-            trace.zmin = start - cs / 2;
-            trace.zmax = trace.zmin + nc * cs;
-        }
+        var zmin0 = cOpts.min;
+        var zmax0 = cOpts.max;
 
         for(i = 0; i < len; i++) {
             si = scl[i];
-
-            domain[i] = si[0] * (trace.zmax - trace.zmin) + trace.zmin;
+            domain[i] = si[0] * (zmax0 - zmin0) + zmin0;
             range[i] = si[1];
         }
 
         // do the contours extend beyond the colorscale?
         // if so, extend the colorscale with constants
         var zRange = d3.extent([
-            trace.zmin,
-            trace.zmax,
+            zmin0,
+            zmax0,
             contours.start,
             contours.start + cs * (nc - 1)
         ]);
-        var zmin = zRange[trace.zmin < trace.zmax ? 0 : 1];
-        var zmax = zRange[trace.zmin < trace.zmax ? 1 : 0];
+        var zmin = zRange[zmin0 < zmax0 ? 0 : 1];
+        var zmax = zRange[zmin0 < zmax0 ? 1 : 0];
 
-        if(zmin !== trace.zmin) {
+        if(zmin !== zmin0) {
             domain.splice(0, 0, zmin);
-            range.splice(0, 0, Range[0]);
+            range.splice(0, 0, range[0]);
         }
 
-        if(zmax !== trace.zmax) {
+        if(zmax !== zmax0) {
             domain.push(zmax);
             range.push(range[range.length - 1]);
         }
     } else {
         for(i = 0; i < len; i++) {
             si = scl[i];
-
             domain[i] = (si[0] * (nc + extra - 1) - (extra / 2)) * cs + start;
             range[i] = si[1];
         }
     }
 
-    return Colorscale.makeColorScaleFunc({
-        domain: domain,
-        range: range,
-    }, {
-        noNumericCheck: true
-    });
+    return Colorscale.makeColorScaleFunc(
+        {domain: domain, range: range},
+        {noNumericCheck: true}
+    );
 };

src/traces/contour/plot.js

@@ -43,12 +43,6 @@ exports.plot = function plot(gd, plotinfo, cdcontours, contourLayer) {
         var heatmapColoringLayer = Lib.ensureSingle(plotGroup, 'g', 'heatmapcoloring');
         var cdheatmaps = [];
         if(contours.coloring === 'heatmap') {
-            if(trace.zauto && (trace.autocontour === false)) {
-                trace._input.zmin = trace.zmin =
-                    contours.start - contours.size / 2;
-                trace._input.zmax = trace.zmax =
-                    trace.zmin + pathinfo.length * contours.size;
-            }
             cdheatmaps = [cd];
         }
         heatmapPlot(gd, plotinfo, cdheatmaps, heatmapColoringLayer);

src/traces/contour/set_contours.js

@@ -6,28 +6,29 @@
 * LICENSE file in the root directory of this source tree.
 */
 
-
 'use strict';
 
 var Axes = require('../../plots/cartesian/axes');
 var Lib = require('../../lib');
 
-
-module.exports = function setContours(trace) {
+module.exports = function setContours(trace, vals) {
     var contours = trace.contours;
 
     // check if we need to auto-choose contour levels
     if(trace.autocontour) {
+        // N.B. do not try to use coloraxis cmin/cmax,
+        // these values here are meant to remain "per-trace" for now
         var zmin = trace.zmin;
         var zmax = trace.zmax;
-        if(zmin === undefined || zmax === undefined) {
-            zmin = Lib.aggNums(Math.min, null, trace._z);
-            zmax = Lib.aggNums(Math.max, null, trace._z);
+        if(trace.zauto || zmin === undefined) {
+            zmin = Lib.aggNums(Math.min, null, vals);
+        }
+        if(trace.zauto || zmax === undefined) {
+            zmax = Lib.aggNums(Math.max, null, vals);
         }
-        var dummyAx = autoContours(zmin, zmax, trace.ncontours);
 
+        var dummyAx = autoContours(zmin, zmax, trace.ncontours);
         contours.size = dummyAx.dtick;
-
         contours.start = Axes.tickFirst(dummyAx);
         dummyAx.range.reverse();
         contours.end = Axes.tickFirst(dummyAx);

src/traces/contourcarpet/calc.js

@@ -45,8 +45,7 @@ module.exports = function calc(gd, trace) {
     }
 
     var cd = heatmappishCalc(gd, trace);
-
-    setContours(trace);
+    setContours(trace, trace._z);
 
     return cd;
 };

src/traces/heatmap/calc.js

@@ -142,13 +142,8 @@ module.exports = function calc(gd, trace) {
         cd0.pts = binned.pts;
     }
 
-    // auto-z and autocolorscale if applicable
-    if(!isContour || trace.contours.type !== 'constraint') {
-        colorscaleCalc(gd, trace, {
-            vals: z,
-            containerStr: '',
-            cLetter: 'z'
-        });
+    if(!isContour) {
+        colorscaleCalc(gd, trace, {vals: z, cLetter: 'z'});
     }
 
     if(isContour && trace.contours && trace.contours.coloring === 'heatmap') {