Fix tons of interpolation bugs

rreusser · rreusser · commit ce290aed7e63 · 2016-12-15T09:30:05.000-05:00
diff --git a/src/traces/carpet/calc.js b/src/traces/carpet/calc.js
@@ -17,6 +17,7 @@ var map2dArray = require('./map_2d_array');
 var createSplineEvaluator = require('./create_spline_evaluator');
 var setConvert = require('./set_convert');
 var calcGridlines = require('./calc_gridlines');
+var calcLabels = require('./calc_labels');
 
 module.exports = function calc(gd, trace) {
     var xa = Axes.getFromId(gd, trace.xaxis || 'x'),
@@ -66,8 +67,11 @@ module.exports = function calc(gd, trace) {
     // Create conversions from one coordinate system to another:
     setConvert(trace, xa, ya);
 
-    calcGridlines(trace, 'a', 'b', xa, ya);
-    calcGridlines(trace, 'b', 'a', xa, ya);
+    calcGridlines(trace, 'a', 'b');
+    calcGridlines(trace, 'b', 'a');
+
+    calcLabels(trace, aax);
+    calcLabels(trace, bax);
 
     return [{
         x: x,
diff --git a/src/traces/carpet/calc_gridlines.js b/src/traces/carpet/calc_gridlines.js
@@ -21,7 +21,7 @@ var map1dArray = require('./map_1d_array');
 var makepath = require('./makepath');
 var extendFlat = require('../../lib/extend').extendFlat;
 
-module.exports = function calcGridlines (trace, axisLetter, crossAxisLetter, xaxis, yaxis) {
+module.exports = function calcGridlines (trace, axisLetter, crossAxisLetter) {
     var i, j, gridline, j0, i0;
 
     var data = trace[axisLetter];
@@ -53,11 +53,24 @@ module.exports = function calcGridlines (trace, axisLetter, crossAxisLetter, xax
         var j, j0, tj, pxy, i0, ti, xy, dxydi0, dxydi1, i, dxydj0, dxydj1;
         var xpoints = [];
         var ypoints = [];
+        var ret = {};
         // Search for the fractional grid index giving this line:
         if (axisLetter === 'b') {
             j = trace.b2j(value);
             j0 = Math.floor(Math.max(0, Math.min(nb - 2, j)));
             tj = j - j0;
+            ret.length = nb;
+            ret.crossLength = na;
+
+            ret.xy = function (i) {
+                var i0 = Math.max(0, Math.min(crossData.length - 2, Math.floor(i)));
+                var ti = i - i0;
+                return trace._evalxy([], i0, j0, ti, tj);
+            }
+
+            ret.dxy = function (i0, ti) {
+                return trace.dxydi([], i0, j0, ti, tj);
+            };
 
             for (var i = 0; i < na; i++) {
                 i0 = Math.min(na - 2, i);
@@ -85,6 +98,18 @@ module.exports = function calcGridlines (trace, axisLetter, crossAxisLetter, xax
             i = trace.a2i(value);
             i0 = Math.floor(Math.max(0, Math.min(na - 2, i)));
             ti = i - i0;
+            ret.length = na;
+            ret.crossLength = nb;
+
+            ret.xy = function (j) {
+                var j0 = Math.max(0, Math.min(crossData.length - 2, Math.floor(j)));
+                var tj = j - j0;
+                return trace._evalxy([], i0, j0, ti, tj);
+            }
+
+            ret.dxy = function (j0, tj) {
+                return trace.dxydj([], i0, j0, ti, tj);
+            };
 
             for (var j = 0; j < nb; j++) {
                 j0 = Math.min(nb - 2, j);
@@ -110,61 +135,84 @@ module.exports = function calcGridlines (trace, axisLetter, crossAxisLetter, xax
             }
         }
 
-        return {
-            axisLetter: axisLetter,
-            axis: trace[axisLetter + 'axis'],
-            value: value,
-            constvar: crossAxisLetter,
-            index: n,
-            x: xpoints,
-            y: ypoints,
-            //dxy_0: dxy_0,
-            //dxy_1: dxy_1,
-            smoothing: crossAxis.smoothing,
-        };
+        ret.axisLetter = axisLetter;
+        ret.axis = axis;
+        ret.crossAxis = crossAxis;
+        ret.value = value;
+        ret.constvar = crossAxisLetter;
+        ret.index = n;
+        ret.x = xpoints;
+        ret.y = ypoints;
+        ret.smoothing = crossAxis.smoothing;
+
+        return ret;
     }
 
-    function constructArrayGridline (j) {
-        var dxy_0, dxy_1;
+    function constructArrayGridline (idx) {
         var xpoints = [];
         var ypoints = [];
+        var ret = {};
+        ret.length = data.length;
+        ret.crossLength = crossData.length;
 
         if (axisLetter === 'b') {
+            var j0 = Math.max(0, Math.min(nb - 2, idx));
+            var tj = Math.min(1, Math.max(0, idx - j0));
+
+            ret.xy = function (i) {
+                var i0 = Math.max(0, Math.min(na - 2, Math.floor(i)));
+                var ti = Math.min(1, Math.max(0, i - i0));
+                return trace._evalxy([], i0, j0, ti, tj);
+            };
+
+            ret.dxy = function (i) {
+                var i0 = Math.max(0, Math.min(na - 2, Math.floor(i)));
+                var ti = Math.min(1, Math.max(0, i - i0));
+                return trace.dxydi([], i0, j0, ti, tj);
+            };
+
             // In the tickmode: array case, this operation is a simple
             // transfer of data:
             for (i = 0; i < nea; i++) {
-                xpoints[i] = xcp[i][j * stride];
-                ypoints[i] = ycp[i][j * stride];
+                xpoints[i] = xcp[i][idx * stride];
+                ypoints[i] = ycp[i][idx * stride];
             }
-
-            j0 = Math.min(j, nb - 2);
-            dxy_0 = trace.dxydi(null, 0, j0, 0, j - j0);
-            dxy_1 = trace.dxydi(null, na - 2, j0, 1, j - j0);
         } else {
+            var i0 = Math.max(0, Math.min(na - 2, idx));
+            var ti = Math.min(1, Math.max(0, idx - i0));
+
+            ret.xy = function (j) {
+                var j0 = Math.max(0, Math.min(nb - 2, Math.floor(j)));
+                var tj = Math.min(1, Math.max(0, j - j0));
+                return trace._evalxy([], i0, j0, ti, tj);
+            }
+
+
+            ret.dxy = function (j) {
+                var j0 = Math.max(0, Math.min(nb - 2, Math.floor(j)));
+                var tj = Math.min(1, Math.max(0, j - j0));
+                return trace.dxydj([], i0, j0, ti, tj);
+            };
+
             // In the tickmode: array case, this operation is a simple
             // transfer of data:
             for (i = 0; i < neb; i++) {
-                xpoints[i] = xcp[j * stride][i];
-                ypoints[i] = ycp[j * stride][i];
+                xpoints[i] = xcp[idx * stride][i];
+                ypoints[i] = ycp[idx * stride][i];
             }
-
-            i0 = Math.min(i, na - 2);
-            dxy_0 = trace.dxydj(null, i0, 0, i - i0, 0);
-            dxy_1 = trace.dxydj(null, i0, nb - 2, i - i0, 1);
         }
 
-        return {
-            axisLetter: axisLetter,
-            axis: trace[axisLetter + 'axis'],
-            value: data[j],
-            constvar: crossAxisLetter,
-            index: j,
-            x: xpoints,
-            y: ypoints,
-            dxy_0: dxy_0,
-            dxy_1: dxy_1,
-            smoothing: crossAxis.smoothing,
-        };
+        ret.axisLetter = axisLetter;
+        ret.axis = axis;
+        ret.crossAxis = crossAxis;
+        ret.value = data[idx];
+        ret.constvar = crossAxisLetter;
+        ret.index = idx;
+        ret.x = xpoints;
+        ret.y = ypoints;
+        ret.smoothing = crossAxis.smoothing;
+
+        return ret;
     };
 
 
diff --git a/src/traces/carpet/calc_labels.js b/src/traces/carpet/calc_labels.js
@@ -0,0 +1,55 @@
+/**
+* Copyright 2012-2016, 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 Axes = require('../../plots/cartesian/axes');
+var cheaterBasis = require('./cheater_basis');
+var arrayMinmax = require('./array_minmax');
+var search = require('../../lib/search').findBin;
+var computeControlPoints = require('./compute_control_points');
+var map2dArray = require('./map_2d_array');
+var createSplineEvaluator = require('./create_spline_evaluator');
+var setConvert = require('./set_convert');
+var map2dArray = require('./map_2d_array');
+var map1dArray = require('./map_1d_array');
+var makepath = require('./makepath');
+var extendFlat = require('../../lib/extend').extendFlat;
+
+function normalize (x) {
+    var x
+}
+
+module.exports = function calcLabels (trace, axis) {
+    var i;
+
+    var labels = axis._labels = [];
+    var gridlines = axis._gridlines;
+
+    for (i = 0; i < gridlines.length; i++) {
+        var gridline = gridlines[i];
+
+        labels.push({
+            text: gridline.value.toFixed(3),
+            endAnchor: true,
+            xy: gridline.xy(0),
+            dxy: gridline.dxy(0, 0),
+            axis: gridline.axis,
+            length: gridline.crossAxis.length
+        });
+
+        labels.push({
+            text: gridline.value.toFixed(3),
+            endAnchor: false,
+            xy: gridline.xy(gridline.crossLength - 1),
+            dxy: gridline.dxy(gridline.crossLength - 2, 1),
+            axis: gridline.axis,
+            length: gridline.crossAxis.length
+        });
+    }
+};
diff --git a/src/traces/carpet/create_j_derivative_evaluator.js b/src/traces/carpet/create_j_derivative_evaluator.js
@@ -61,10 +61,18 @@ module.exports = function (arrays, asmoothing, bsmoothing) {
             var ov = 1 - v;
             for (k = 0; k < arrays.length; k++) {
                 ak = arrays[k];
-                f0 = 3 * ((u2 - 1) * ak[i0][j0    ] + ou2 * ak[i0][j0    ] + u * (2 - 3 * u) * ak[i0][j0    ] + u2 * ak[i0][j0    ]);
-                f1 = 3 * ((u2 - 1) * ak[i0][j0 + 1] + ou2 * ak[i0][j0 + 1] + u * (2 - 3 * u) * ak[i0][j0 + 1] + u2 * ak[i0][j0 + 1]);
 
-                out[k] = ov * f0 + v * f1;
+                f0 = ak[i0    ][j0 + 1] - ak[i0    ][j0];
+                f1 = ak[i0 + 1][j0 + 1] - ak[i0 + 1][j0];
+                f2 = ak[i0 + 2][j0 + 1] - ak[i0 + 2][j0];
+                f3 = ak[i0 + 3][j0 + 1] - ak[i0 + 3][j0];
+
+                out[k] = ou3 * f0 + 3 * (ou2 * u * f1 + ou * u2 * f2) + u3 * f3;
+
+                // mathematically equivalent:
+                //f0 = ou3 * ak[i0][j0    ] + 3 * (ou2 * u * ak[i0 + 1][j0    ] + ou * u2 * ak[i0 + 2][j0    ]) + u3 * ak[i0 + 3][j0    ];
+                //f1 = ou3 * ak[i0][j0 + 1] + 3 * (ou2 * u * ak[i0 + 1][j0 + 1] + ou * u2 * ak[i0 + 2][j0 + 1]) + u3 * ak[i0 + 3][j0 + 1];
+                //out[k] = f1 - f0;
             }
             return out;
         };
@@ -95,8 +103,8 @@ module.exports = function (arrays, asmoothing, bsmoothing) {
             var ov = 1 - v;
             for (k = 0; k < arrays.length; k++) {
                 ak = arrays[k];
-                f0 = ak[i0 + 1][j0] - ak[i0][j0];
-                f1 = ak[i0 + 1][j0 + 1] - ak[i0][j0 + 1];
+                f0 = ak[i0][j0 + 1] - ak[i0][j0];
+                f1 = ak[i0 + 1][j0 + 1] - ak[i0 + 1][j0];
 
                 out[k] = ov * f0 + v * f1;
             }
diff --git a/src/traces/carpet/plot.js b/src/traces/carpet/plot.js
diff --git a/src/traces/carpet/set_convert.js b/src/traces/carpet/set_convert.js
