contour constraints outside carpet

Author: alexcjohnson

src/components/legend/helpers.js

@@ -9,11 +9,14 @@
 
 'use strict';
 
-var Registry = require('../../registry');
-
-
 exports.legendGetsTrace = function legendGetsTrace(trace) {
-    return trace.visible && Registry.traceIs(trace, 'showLegend');
+    // traceIs(trace, 'showLegend') is not sufficient anymore, due to contour(carpet)?
+    // which are legend-eligible only if type: constraint. Otherwise, showlegend gets deleted.
+
+    // Note that we explicitly include showlegend: false, so a trace that *could* be
+    // in the legend but is not shown still counts toward the two traces you need to
+    // ensure the legend is shown by default, because this can still help disambiguate.
+    return trace.visible && (trace.showlegend !== undefined);
 };
 
 exports.isGrouped = function isGrouped(legendLayout) {

src/components/legend/style.js

@@ -60,13 +60,14 @@ module.exports = function style(s, gd) {
     .each(stylePoints);
 
     function styleLines(d) {
-        var trace = d[0].trace,
-            showFill = trace.visible && trace.fill && trace.fill !== 'none',
-            showLine = subTypes.hasLines(trace);
-
-        if(trace && trace._module && trace._module.name === 'contourcarpet') {
-            showLine = trace.contours.showlines;
-            showFill = trace.contours.coloring === 'fill' || trace.contours.type === 'constraint';
+        var trace = d[0].trace;
+        var showFill = trace.visible && trace.fill && trace.fill !== 'none';
+        var showLine = subTypes.hasLines(trace);
+        var contours = trace.contours;
+
+        if(contours && contours.type === 'constraint') {
+            showLine = contours.showlines;
+            showFill = contours.operation !== '=';
         }
 
         var fill = d3.select(this).select('.legendfill').selectAll('path')

src/traces/contour/attributes.js

@@ -39,6 +39,17 @@ module.exports = extendFlat({
 
     connectgaps: heatmapAttrs.connectgaps,
 
+    fillcolor: {
+        valType: 'color',
+        role: 'style',
+        editType: 'calc',
+        description: [
+            'Sets the fill color if `contours.type` is *constraint*.',
+            'Defaults to a half-transparent variant of the line color,',
+            'marker color, or marker line color, whichever is available.'
+        ].join(' ')
+    },
+
     autocontour: {
         valType: 'boolean',
         dflt: true,

src/traces/contour/calc.js

@@ -9,94 +9,14 @@
 
 'use strict';
 
-var Axes = require('../../plots/cartesian/axes');
-var extendFlat = require('../../lib').extendFlat;
 var heatmapCalc = require('../heatmap/calc');
-
+var setContours = require('./set_contours');
 
 // 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),
-        contours = trace.contours;
-
-    // check if we need to auto-choose contour levels
-    if(trace.autocontour !== false) {
-        var dummyAx = autoContours(trace.zmin, trace.zmax, trace.ncontours);
-
-        contours.size = dummyAx.dtick;
-
-        contours.start = Axes.tickFirst(dummyAx);
-        dummyAx.range.reverse();
-        contours.end = Axes.tickFirst(dummyAx);
-
-        if(contours.start === trace.zmin) contours.start += contours.size;
-        if(contours.end === trace.zmax) contours.end -= contours.size;
-
-        // if you set a small ncontours, *and* the ends are exactly on zmin/zmax
-        // there's an edge case where start > end now. Make sure there's at least
-        // one meaningful contour, put it midway between the crossed values
-        if(contours.start > contours.end) {
-            contours.start = contours.end = (contours.start + contours.end) / 2;
-        }
-
-        // copy auto-contour info back to the source data.
-        // previously we copied the whole contours object back, but that had
-        // other info (coloring, showlines) that should be left to supplyDefaults
-        if(!trace._input.contours) trace._input.contours = {};
-        extendFlat(trace._input.contours, {
-            start: contours.start,
-            end: contours.end,
-            size: contours.size
-        });
-        trace._input.autocontour = true;
-    }
-    else {
-        // sanity checks on manually-supplied start/end/size
-        var start = contours.start,
-            end = contours.end,
-            inputContours = trace._input.contours;
-
-        if(start > end) {
-            contours.start = inputContours.start = end;
-            end = contours.end = inputContours.end = start;
-            start = contours.start;
-        }
-
-        if(!(contours.size > 0)) {
-            var sizeOut;
-            if(start === end) sizeOut = 1;
-            else sizeOut = autoContours(start, end, trace.ncontours).dtick;
-
-            inputContours.size = contours.size = sizeOut;
-        }
-    }
-
+    var cd = heatmapCalc(gd, trace);
+    setContours(trace);
     return cd;
 };
-
-/*
- * autoContours: make a dummy axis object with dtick we can use
- * as contours.size, and if needed we can use Axes.tickFirst
- * with this axis object to calculate the start and end too
- *
- * start: the value to start the contours at
- * end: the value to end at (must be > start)
- * ncontours: max number of contours to make, like roughDTick
- *
- * returns: an axis object
- */
-function autoContours(start, end, ncontours) {
-    var dummyAx = {
-        type: 'linear',
-        range: [start, end]
-    };
-
-    Axes.autoTicks(
-        dummyAx,
-        (end - start) / (ncontours || 15)
-    );
-
-    return dummyAx;
-}

src/traces/contourcarpet/close_boundaries.js renamed to src/traces/contour/close_boundaries.js

@@ -11,9 +11,11 @@
 module.exports = function(pathinfo, operation, perimeter, trace) {
     // Abandon all hope, ye who enter here.
     var i, v1, v2;
-    var na = trace.a.length;
-    var nb = trace.b.length;
-    var z = trace.z;
+    var pi0 = pathinfo[0];
+    var na = pi0.x.length;
+    var nb = pi0.y.length;
+    var z = pi0.z;
+    var contours = trace.contours;
 
     var boundaryMax = -Infinity;
     var boundaryMin = Infinity;
@@ -32,36 +34,35 @@ module.exports = function(pathinfo, operation, perimeter, trace) {
         boundaryMax = Math.max(boundaryMax, z[nb - 1][i]);
     }
 
+    pi0.prefixBoundary = false;
+
     switch(operation) {
         case '>':
         case '>=':
-            if(trace.contours.value > boundaryMax) {
-                pathinfo[0].prefixBoundary = true;
+            if(contours.value > boundaryMax) {
+                pi0.prefixBoundary = true;
             }
             break;
         case '<':
         case '<=':
-            if(trace.contours.value < boundaryMin) {
-                pathinfo[0].prefixBoundary = true;
+            if(contours.value < boundaryMin) {
+                pi0.prefixBoundary = true;
             }
             break;
         case '[]':
         case '()':
-            v1 = Math.min.apply(null, trace.contours.value);
-            v2 = Math.max.apply(null, trace.contours.value);
-            if(v2 < boundaryMin) {
-                pathinfo[0].prefixBoundary = true;
-            }
-            if(v1 > boundaryMax) {
-                pathinfo[0].prefixBoundary = true;
+            v1 = Math.min.apply(null, contours.value);
+            v2 = Math.max.apply(null, contours.value);
+            if(v2 < boundaryMin || v1 > boundaryMax) {
+                pi0.prefixBoundary = true;
             }
             break;
         case '][':
         case ')(':
-            v1 = Math.min.apply(null, trace.contours.value);
-            v2 = Math.max.apply(null, trace.contours.value);
+            v1 = Math.min.apply(null, contours.value);
+            v2 = Math.max.apply(null, contours.value);
             if(v1 < boundaryMin && v2 > boundaryMax) {
-                pathinfo[0].prefixBoundary = true;
+                pi0.prefixBoundary = true;
             }
             break;
     }

src/traces/contour/constraint_defaults.js

@@ -0,0 +1,48 @@
+/**
+* Copyright 2012-2018, 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 handleConstraintValueDefaults = require('./constraint_value_defaults');
+var handleLabelDefaults = require('./label_defaults');
+var Color = require('../../components/color');
+var addOpacity = Color.addOpacity;
+var opacity = Color.opacity;
+
+module.exports = function handleConstraintDefaults(traceIn, traceOut, coerce, layout, defaultColor, opts) {
+    var contours = traceOut.contours;
+    var showLines, lineColor, fillColor;
+
+    var operation = coerce('contours.operation');
+
+    handleConstraintValueDefaults(coerce, contours);
+
+    if(operation === '=') {
+        showLines = contours.showlines = true;
+    }
+    else {
+        showLines = coerce('contours.showlines');
+        fillColor = coerce('fillcolor', addOpacity(
+            (traceIn.line || {}).color || defaultColor, 0.5
+        ));
+    }
+
+    if(showLines) {
+        var lineDfltColor = fillColor && opacity(fillColor) ?
+            addOpacity(traceOut.fillcolor, 1) :
+            defaultColor;
+        lineColor = coerce('line.color', lineDfltColor);
+        coerce('line.width', 2);
+        coerce('line.dash');
+    }
+
+    coerce('line.smoothing');
+
+    handleLabelDefaults(coerce, layout, lineColor, opts);
+};

src/traces/contourcarpet/constraint_mapping.js renamed to src/traces/contour/constraint_mapping.js

@@ -9,7 +9,7 @@
 
 'use strict';
 
-var constraintMapping = require('./constraint_mapping');
+// var constraintMapping = require('./constraint_mapping');
 var isNumeric = require('fast-isnumeric');
 
 module.exports = function(coerce, contours) {
@@ -50,10 +50,4 @@ module.exports = function(coerce, contours) {
             }
         }
     }
-
-    var map = constraintMapping[contours.operation](contours.value);
-
-    contours.start = map.start;
-    contours.end = map.end;
-    contours.size = map.size;
 };

src/traces/contourcarpet/constraint_value_defaults.js renamed to src/traces/contour/constraint_value_defaults.js

@@ -21,6 +21,29 @@ module.exports = function(pathinfo, operation) {
     var op1 = function(arr) { return arr; };
 
     switch(operation) {
+        case '=':
+        case '<':
+        case '<=':
+            return pathinfo;
+        case '>=':
+        case '>':
+            if(pathinfo.length !== 1) {
+                Lib.warn('Contour data invalid for the specified inequality operation.');
+            }
+
+            // In this case there should be exactly two contour levels in pathinfo. We
+            // simply concatenate the info into one pathinfo and flip all of the data
+            // in one. This will draw the contour as closed.
+            pi0 = pathinfo[0];
+
+            for(i = 0; i < pi0.edgepaths.length; i++) {
+                pi0.edgepaths[i] = op0(pi0.edgepaths[i]);
+            }
+
+            for(i = 0; i < pi0.paths.length; i++) {
+                pi0.paths[i] = op0(pi0.paths[i]);
+            }
+            return pathinfo;
         case '][':
         case ')[':
         case '](':
@@ -37,14 +60,13 @@ module.exports = function(pathinfo, operation) {
             /* eslint-enable: no-fallthrough */
             if(pathinfo.length !== 2) {
                 Lib.warn('Contour data invalid for the specified inequality range operation.');
-                return;
             }
 
             // In this case there should be exactly two contour levels in pathinfo. We
             // simply concatenate the info into one pathinfo and flip all of the data
             // in one. This will draw the contour as closed.
-            pi0 = pathinfo[0];
-            pi1 = pathinfo[1];
+            pi0 = copyPathinfo(pathinfo[0]);
+            pi1 = copyPathinfo(pathinfo[1]);
 
             for(i = 0; i < pi0.edgepaths.length; i++) {
                 pi0.edgepaths[i] = op0(pi0.edgepaths[i]);
@@ -60,28 +82,13 @@ module.exports = function(pathinfo, operation) {
             while(pi1.paths.length) {
                 pi0.paths.push(op1(pi1.paths.shift()));
             }
-            pathinfo.pop();
-
-            break;
-        case '>=':
-        case '>':
-            if(pathinfo.length !== 1) {
-                Lib.warn('Contour data invalid for the specified inequality operation.');
-                return;
-            }
-
-            // In this case there should be exactly two contour levels in pathinfo. We
-            // simply concatenate the info into one pathinfo and flip all of the data
-            // in one. This will draw the contour as closed.
-            pi0 = pathinfo[0];
-
-            for(i = 0; i < pi0.edgepaths.length; i++) {
-                pi0.edgepaths[i] = op0(pi0.edgepaths[i]);
-            }
-
-            for(i = 0; i < pi0.paths.length; i++) {
-                pi0.paths[i] = op0(pi0.paths[i]);
-            }
-            break;
+            return [pi0];
     }
 };
+
+function copyPathinfo(pi) {
+    return Lib.extendFlat({}, pi, {
+        edgepaths: Lib.extendDeep([], pi.edgepaths),
+        paths: Lib.extendDeep([], pi.paths)
+    });
+}