Very rough carpet scatter trace

Author: rreusser

src/plots/cartesian/index.js

@@ -62,8 +62,11 @@ exports.plot = function(gd, traces, transitionOpts, makeOnCompleteCallback) {
             // Skip trace if whitelist provided and it's not whitelisted:
             // if (Array.isArray(traces) && traces.indexOf(i) === -1) continue;
             if(trace.xaxis + trace.yaxis === subplot) {
+                // XXX: Should trace carpet dependencies. Only replot all carpet plots if the carpet
+                // axis has actually changed:
+                //
                 // If this trace is specifically requested, add it to the list:
-                if(traces.indexOf(trace.index) !== -1) {
+                if(traces.indexOf(trace.index) !== -1 || trace.carpetid) {
                     // Okay, so example: traces 0, 1, and 2 have fill = tonext. You animate
                     // traces 0 and 2. Trace 1 also needs to be updated, otherwise its fill
                     // is outdated. So this retroactively adds the previous trace if the

src/traces/carpet/set_convert.js

@@ -105,6 +105,24 @@ module.exports = function setConvert(trace) {
         return trace._evalxy([], i0, j0, ti, tj);
     };
 
+    trace.ab2xy = function (aval, bval) {
+        if (aval < a[0] || aval > a[na - 1] | bval < b[0] || bval > b[nb - 1]) {
+            return [false, false];
+        }
+        var i = trace.a2i(aval);
+        var i0 = Math.max(0, Math.min(na - 2, Math.floor(i)));
+        var ti = i - i0;
+
+        var j = trace.b2j(bval);
+        var j0 = Math.max(0, Math.min(nb - 2, Math.floor(j)));
+        var tj = j - j0;
+
+        if (tj < 0 || tj > 1 || ti < 0 || ti > 1) {
+            return [false, false];
+        }
+        return trace._evalxy([], i0, j0, ti, tj);
+    }
+
     trace.c2p = function (xy, xa, ya) {
         return [xa.c2p(xy[0]), ya.c2p(xy[1])];
     };

src/traces/scattercarpet/attributes.js

@@ -20,17 +20,16 @@ var scatterMarkerAttrs = scatterAttrs.marker,
     scatterMarkerLineAttrs = scatterMarkerAttrs.line;
 
 module.exports = {
-    a: {
-        valType: 'data_array',
+    carpetid: {
+        valType: 'string',
+        role: 'info',
         description: [
-            'Sets the quantity of component `a` in each data point.',
-            'If `a`, `b`, and `c` are all provided, they need not be',
-            'normalized, only the relative values matter. If only two',
-            'arrays are provided they must be normalized to match',
-            '`ternary<i>.sum`.'
+            'An identifier for this carpet, so that `scattercarpet` and',
+            '`scattercontour` traces can specify a carpet plot on which',
+            'they lie'
         ].join(' ')
     },
-    b: {
+    a: {
         valType: 'data_array',
         description: [
             'Sets the quantity of component `a` in each data point.',
@@ -40,7 +39,7 @@ module.exports = {
             '`ternary<i>.sum`.'
         ].join(' ')
     },
-    c: {
+    b: {
         valType: 'data_array',
         description: [
             'Sets the quantity of component `a` in each data point.',

src/traces/scattercarpet/calc.js

@@ -17,74 +17,45 @@ var Lib = require('../../lib');
 var subTypes = require('../scatter/subtypes');
 var calcColorscale = require('../scatter/colorscale_calc');
 
-var dataArrays = ['a', 'b', 'c'];
-var arraysToFill = {a: ['b', 'c'], b: ['a', 'c'], c: ['a', 'b']};
-
+var dataArrays = ['a', 'b'];
 
 module.exports = function calc(gd, trace) {
-    var i, j, dataArray, newArray, fillArray1, fillArray2, trace;
+    var i, j, dataArray, newArray, fillArray1, fillArray2, carpet;
 
-    for (i = 0; i < gd.traces.length; i++) {
-        if (gd.traces[i].carpetid === trace.carpetid) {
-            trace = gd.traces[i];
+    for (i = 0; i < gd._fullData.length; i++) {
+        if (gd._fullData[i].carpetid === trace.carpetid && gd._fullData[i].type === 'carpet') {
+            carpet = gd._fullData[i];
             break;
         }
     }
 
-    if (!trace) return;
-
-    console.log('trace:', trace);
+    if (!carpet) return;
 
-    return;
+    // Transfer this over from carpet before plotting since this is a necessary
+    // condition in order for cartesian to actually plot this trace:
+    trace.xaxis = carpet.xaxis;
+    trace.yaxis = carpet.yaxis;
 
-    var ternary = gd._fullLayout[trace.subplot],
-        displaySum = ternary.sum,
+    var displaySum = carpet.sum,
         normSum = trace.sum || displaySum;
 
-    // fill in one missing component
-    for(i = 0; i < dataArrays.length; i++) {
-        dataArray = dataArrays[i];
-        if(trace[dataArray]) continue;
-
-        fillArray1 = trace[arraysToFill[dataArray][0]];
-        fillArray2 = trace[arraysToFill[dataArray][1]];
-        newArray = new Array(fillArray1.length);
-        for(j = 0; j < fillArray1.length; j++) {
-            newArray[j] = normSum - fillArray1[j] - fillArray2[j];
-        }
-        trace[dataArray] = newArray;
-    }
-
     // make the calcdata array
     var serieslen = trace.a.length;
     var cd = new Array(serieslen);
-    var a, b, c, norm, x, y;
+    var a, b, norm, x, y;
     for(i = 0; i < serieslen; i++) {
         a = trace.a[i];
         b = trace.b[i];
-        c = trace.c[i];
-        if(isNumeric(a) && isNumeric(b) && isNumeric(c)) {
-            a = +a;
-            b = +b;
-            c = +c;
-            norm = displaySum / (a + b + c);
-            if(norm !== 1) {
-                a *= norm;
-                b *= norm;
-                c *= norm;
-            }
-            // map a, b, c onto x and y where the full scale of y
-            // is [0, sum], and x is [-sum, sum]
-            // TODO: this makes `a` always the top, `b` the bottom left,
-            // and `c` the bottom right. Do we want options to rearrange
-            // these?
-            y = a;
-            x = c - b;
-            cd[i] = {x: x, y: y, a: a, b: b, c: c};
+        if(isNumeric(a) && isNumeric(b)) {
+            var xy = carpet.ab2xy(+a, +b);
+            cd[i] = {x: xy[0], y: xy[1], a: a, b: b};
         }
         else cd[i] = {x: false, y: false};
     }
 
+    cd[0].carpet = carpet;
+    cd[0].trace = trace;
+
     // fill in some extras
     var marker, s;
     if(subTypes.hasMarkers(trace)) {

src/traces/scattercarpet/defaults.js

@@ -27,28 +27,17 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
     }
 
+    coerce('carpetid');
+
+    // XXX: Don't hard code this
+    traceOut.xaxis = 'x';
+    traceOut.yaxis = 'y';
+
     var a = coerce('a'),
         b = coerce('b'),
-        c = coerce('c'),
         len;
 
-    // allow any one array to be missing, len is the minimum length of those
-    // present. Note that after coerce data_array's are either Arrays (which
-    // are truthy even if empty) or undefined. As in scatter, an empty array
-    // is different from undefined, because it can signify that this data is
-    // not known yet but expected in the future
-    if(a) {
-        len = a.length;
-        if(b) {
-            len = Math.min(len, b.length);
-            if(c) len = Math.min(len, c.length);
-        }
-        else if(c) len = Math.min(len, c.length);
-        else len = 0;
-    }
-    else if(b && c) {
-        len = Math.min(b.length, c.length);
-    }
+    len = Math.min(a.length, b.length);
 
     if(!len) {
         traceOut.visible = false;
@@ -58,7 +47,6 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
     // cut all data arrays down to same length
     if(a && len < a.length) traceOut.a = a.slice(0, len);
     if(b && len < b.length) traceOut.b = b.slice(0, len);
-    if(c && len < c.length) traceOut.c = c.slice(0, len);
 
     coerce('sum');
 
@@ -94,7 +82,7 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         if(!subTypes.hasLines(traceOut)) handleLineShapeDefaults(traceIn, traceOut, coerce);
     }
 
-    coerce('hoverinfo', (layout._dataLength === 1) ? 'a+b+c+text' : undefined);
+    coerce('hoverinfo', (layout._dataLength === 1) ? 'a+b+text' : undefined);
 
     if(traceOut.fill === 'tonext' || traceOut.fill === 'toself') {
         dfltHoverOn.push('fills');

src/traces/scattercarpet/plot.js

@@ -10,23 +10,21 @@
 'use strict';
 
 var scatterPlot = require('../scatter/plot');
+var Axes = require('../../plots/cartesian/axes');
 
+module.exports = function plot(gd, plotinfoproxy, data) {
 
-module.exports = function plot(ternary, data) {
-    var plotContainer = ternary.plotContainer;
-
-    // remove all nodes inside the scatter layer
-    plotContainer.select('.scatterlayer').selectAll('*').remove();
+    var carpet = data[0][0].carpet;
 
     // mimic cartesian plotinfo
     var plotinfo = {
-        xaxis: ternary.xaxis,
-        yaxis: ternary.yaxis,
-        plot: plotContainer
+        xaxis: Axes.getFromId(gd, carpet.xaxis || 'x'),
+        yaxis: Axes.getFromId(gd, carpet.yaxis || 'y'),
+        plot: plotinfoproxy.plot
     };
 
-    var calcdata = new Array(data.length),
-        fullCalcdata = ternary.graphDiv.calcdata;
+    /*var calcdata = new Array(data.length),
+        fullCalcdata = gd.calcdata;
 
     for(var i = 0; i < fullCalcdata.length; i++) {
         var j = data.indexOf(fullCalcdata[i][0].trace);
@@ -35,10 +33,10 @@ module.exports = function plot(ternary, data) {
 
         calcdata[j] = fullCalcdata[i];
 
-        // while we're here and have references to both the Ternary object
+        // while we're here and have references to both the Carpet object
         // and fullData, connect the two (for use by hover)
-        data[j]._ternary = ternary;
-    }
+        data[j]._carpet = plotinfo;
+    }*/
 
-    scatterPlot(ternary.graphDiv, plotinfo, calcdata);
+    scatterPlot(plotinfo.graphDiv, plotinfo, data);
 };