split up contour index

Author: etpinard

src/traces/contour/calc.js

@@ -0,0 +1,47 @@
+/**
+* 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 Plotly = require('../../plotly');
+var heatmapCalc = require('../heatmap/calc');
+
+
+module.exports = function calc(gd, trace) {
+    // 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
+    var cd = heatmapCalc(gd, trace),
+        contours = trace.contours;
+
+    // check if we need to auto-choose contour levels
+    if(trace.autocontour!==false) {
+        var dummyAx = {
+            type: 'linear',
+            range: [trace.zmin, trace.zmax]
+        };
+        Plotly.Axes.autoTicks(dummyAx,
+            (trace.zmax - trace.zmin) / (trace.ncontours||15));
+        contours.start = Plotly.Axes.tickFirst(dummyAx);
+        contours.size = dummyAx.dtick;
+        dummyAx.range.reverse();
+        contours.end = Plotly.Axes.tickFirst(dummyAx);
+
+        if(contours.start===trace.zmin) contours.start += contours.size;
+        if(contours.end===trace.zmax) contours.end -= contours.size;
+
+        // so rounding errors don't cause us to miss the last contour
+        contours.end += contours.size/100;
+
+        // copy auto-contour info back to the source data.
+        trace._input.contours = contours;
+    }
+
+    return cd;
+};

src/traces/contour/colorbar.js

@@ -0,0 +1,91 @@
+/**
+* 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 d3 = require('d3');
+
+var Plotly = require('../../plotly');
+
+
+module.exports = function colorbar(gd, cd) {
+    var trace = cd[0].trace,
+        cbId = 'cb'+trace.uid;
+
+    gd._fullLayout._infolayer.selectAll('.'+cbId).remove();
+
+    if(trace.showscale===false){
+        Plotly.Plots.autoMargin(gd, cbId);
+        return;
+    }
+
+    // instantiate the colorbar (will be drawn and styled in contour.style)
+    var cb = Plotly.Colorbar(gd, cbId);
+    cd[0].t.cb = cb;
+
+    var contours = trace.contours,
+        line = trace.line,
+        cs = contours.size||1,
+        nc = Math.floor((contours.end + cs/10 - contours.start)/cs)+1,
+        scl = Plotly.Colorscale.getScale(trace.colorscale),
+        extraLevel = contours.coloring==='lines' ? 0 : 1,
+        colormap = d3.scale.linear().interpolate(d3.interpolateRgb),
+        colorDomain = scl.map(function(si){
+                return (si[0]*(nc+extraLevel-1)-(extraLevel/2)) * cs +
+                    contours.start;
+            }),
+        colorRange = scl.map(function(si){ return si[1]; });
+
+    // colorbar fill and lines
+    if(contours.coloring==='heatmap') {
+        if(trace.zauto && trace.autocontour===false) {
+            trace.zmin = contours.start-cs/2;
+            trace.zmax = trace.zmin+nc*cs;
+        }
+        cb.filllevels({
+            start: trace.zmin,
+            end: trace.zmax,
+            size: (trace.zmax-trace.zmin)/254
+        });
+        colorDomain = scl.map(function(si){
+            return si[0]*(trace.zmax-trace.zmin) + trace.zmin;
+        });
+
+        // do the contours extend beyond the colorscale?
+        // if so, extend the colorscale with constants
+        var zRange = d3.extent([trace.zmin, trace.zmax, contours.start,
+                contours.start + cs*(nc-1)]),
+            zmin = zRange[trace.zmin<trace.zmax ? 0 : 1],
+            zmax = zRange[trace.zmin<trace.zmax ? 1 : 0];
+        if(zmin!==trace.zmin) {
+            colorDomain.splice(0, 0, zmin);
+            colorRange.splice(0, 0, colorRange[0]);
+        }
+        if(zmax!==trace.zmax) {
+            colorDomain.push(zmax);
+            colorRange.push(colorRange[colorRange.length-1]);
+        }
+    }
+
+    colormap.domain(colorDomain).range(colorRange);
+
+    cb.fillcolor(contours.coloring==='fill' || contours.coloring==='heatmap' ?
+            colormap : '')
+        .line({
+            color: contours.coloring==='lines' ? colormap : line.color,
+            width: contours.showlines!==false ? line.width : 0,
+            dash: line.dash
+        })
+        .levels({
+            start: contours.start,
+            end: contours.end,
+            size: cs
+        })
+        .options(trace.colorbar)();
+};

src/traces/contour/defaults.js

@@ -0,0 +1,43 @@
+/**
+* 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 Lib = require('../../lib');
+var heatmapSupplyDefaults = require('../heatmap/defaults');
+
+var attributes = require('./attributes');
+
+
+module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout) {
+    function coerce(attr, dflt) {
+        return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
+    }
+
+    var contourStart = Lib.coerce2(traceIn, traceOut, attributes, 'contours.start'),
+        contourEnd = Lib.coerce2(traceIn, traceOut, attributes, 'contours.end'),
+        autocontour = coerce('autocontour', !(contourStart && contourEnd));
+
+    if(autocontour) coerce('ncontours');
+    else coerce('contours.size');
+
+    var coloring = coerce('contours.coloring');
+
+    if(coloring === 'fill') coerce('contours.showlines');
+
+    if(traceOut.contours.showlines!==false) {
+        if(coloring !== 'lines') coerce('line.color', '#000');
+        coerce('line.width', 0.5);
+        coerce('line.dash');
+    }
+
+    coerce('line.smoothing');
+
+    heatmapSupplyDefaults(traceIn, traceOut, defaultColor, layout);
+};

src/traces/contour/hover.js

@@ -0,0 +1,17 @@
+/**
+* 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 heatmapHoverPoints = require('../heatmap/hover');
+
+
+module.exports = function hoverPoints(pointData, xval, yval, hovermode) {
+    return heatmapHoverPoints(pointData, xval, yval, hovermode, true);
+};