Work out carpet interpolation

Author: rreusser

src/traces/carpet/evaluate_cubic.js renamed to lib/scattercarpet.js

@@ -8,4 +8,4 @@
 
 'use strict';
 
-module.exports = function (f1, f2, f3, f4, t)
+module.exports = require('../src/traces/scattercarpet');

src/components/drawing/spline_evaluator.js

@@ -0,0 +1,97 @@
+/**
+* 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';
+
+// generalized Catmull-Rom splines, per
+// http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
+var CatmullRomExp = 0.5;
+function makeControlPoints(p0, p1, p2, smoothness) {
+  var d1x = p0[0] - p1[0],
+      d1y = p0[1] - p1[1],
+      d2x = p2[0] - p1[0],
+      d2y = p2[1] - p1[1],
+      d1a = Math.pow(d1x * d1x + d1y * d1y, CatmullRomExp / 2),
+      d2a = Math.pow(d2x * d2x + d2y * d2y, CatmullRomExp / 2),
+      numx = (d2a * d2a * d1x - d1a * d1a * d2x) * smoothness,
+      numy = (d2a * d2a * d1y - d1a * d1a * d2y) * smoothness,
+      denom1 = 3 * d2a * (d1a + d2a),
+      denom2 = 3 * d1a * (d1a + d2a);
+    var dxL = p1[0] + (denom1 && numx / denom1);
+    var dyL = p1[1] + (denom1 && numy / denom1);
+    var dxU = p1[0] - (denom2 && numx / denom2);
+    var dyU = p1[1] - (denom2 && numy / denom2);
+
+  return [[dxL, dyL], [dxU, dyU]];
+}
+
+/*
+ * Computes centripetal catmull-rom control points. These shouldn't be confused
+ * with tangents, which are slightly different. Specifically, the length of the
+ * tangent vector is
+ *
+ *   degree * (control point - reference point)
+ *
+ * In other words, it really doesn't make too much of a difference whether we
+ * work with tangents or control points.
+ */
+module.exports.computeControlPoints = function (pts, smoothness) {
+    var tangents = [];
+    for(i = 1; i < pts.length - 1; i++) {
+        tangents.push(makeControlPoints(pts[i - 1], pts[i], pts[i + 1], smoothness));
+    }
+    return tangents;
+}
+
+module.exports.evaluateSpline = function evaluateSpline (t, pts, controlpts, smoothness) {
+    var n = pts.length;
+    if (n < 3) {
+        var x = (1 - t) * pts[0][0] + t * pts[1][0];
+        var y = (1 - t) * pts[0][1] + t * pts[1][1];
+        return [x, y];
+    } else {
+        // Compute the controlpts *once* at the beginning, and store them:
+        var a, b, c, d, p0, p1, p2, p3, i, t, ot;
+        param = Math.max(0, Math.min(n - 1, param));
+        i = Math.min(Math.floor(param), n - 2);
+        t = param - i;
+        ot = 1 - t;
+
+        p0 = pts[i];
+        p3 = pts[i + 1];
+
+        if (i === 0 || i === n - 2) {
+            // Evaluate the quadratic first and last segments;
+            p1 = i === 0 ? controlpts[i][0] : controlpts[i - 1][1];
+            a = ot * ot;
+            b = 2 * ot * t;
+            c = t * t;
+            return [
+                a * p0[0] + b * p1[0] + c * p3[0],
+                a * p0[1] + b * p1[1] + c * p3[1]
+            ];
+        } else {
+        // Evaluate internal cubic spline segments:
+            p1 = controlpts[i - 1][1];
+            p2 = controlpts[i][0];
+            p3 = pts[i + 1];
+
+            a = ot * ot * ot;
+            b = 3 * ot * ot * t;
+            c = 3 * ot * t * t;
+            d = t * t * t;
+
+            return [
+                a * p0[0] + b * p1[0] + c * p2[0] + d * p3[0],
+                a * p0[1] + b * p1[1] + c * p2[1] + d * p3[1]
+            ];
+        }
+    }
+}
+

src/traces/carpet/calc.js

@@ -14,7 +14,9 @@ var arrayMinmax = require('./array_minmax');
 var search = require('../../lib/search').findBin;
 var computeControlPoints = require('./compute_control_points');
 var map2dArray = require('./map_2d_array');
-var evaluateControlPoints = require('./evaluate_control_points');
+var createSplineEvaluator = require('./create_spline_evaluator');
+var setConvert = require('./set_convert');
+var calcGridlines = require('./calc_gridlines');
 
 module.exports = function calc(gd, trace) {
     var xa = Axes.getFromId(gd, trace.xaxis || 'x'),
@@ -30,7 +32,7 @@ module.exports = function calc(gd, trace) {
     if(trace._cheater) {
         var avals = aax.cheatertype === 'index' ? a.length : a
         var bvals = bax.cheatertype === 'index' ? b.length : b;
-        xdata = cheaterBasis(avals, bvals, trace.cheaterslope);
+        trace.x = xdata = cheaterBasis(avals, bvals, trace.cheaterslope);
     } else {
         xdata = trace.x;
     }
@@ -61,162 +63,20 @@ module.exports = function calc(gd, trace) {
     trace.xp = map2dArray(trace.xp, x, xa.c2p);
     trace.yp = map2dArray(trace.yp, y, ya.c2p);
 
-    // Next compute the control points in whichever directions are necessary:
-    var result = computeControlPoints(trace.xctrl, trace.yctrl, x, y, aax.smoothing, bax.smoothing);
-    trace.xctrl = result[0];
-    trace.yctrl = result[1];
+    // Create conversions from one coordinate system to another:
+    setConvert(trace, xa, ya);
 
+    trace._agrid = calcGridlines(trace, 'a', 'b', xa, ya);
+    trace._bgrid = calcGridlines(trace, 'b', 'a', xa, ya);
 
-    console.log('evaluateControlPoints(:', evaluateControlPoints([trace.xctrl, trace.yctrl], 0.5, 0.5));
-
-
-    //trace.ab2c = getConvert(x, y, a, b, aax.smoothing, bax.smoothing);
-
-    // This is just a transposed function that will be useful in making
-    // the computations a/b-agnostic:
-    //trace.ba2c = function (b, a) { return trace.ab2c(a, b); }
-
-    //var agrid = makeGridLines(a, aax);
-    //var bgrid = makeGridLines(b, bax);
-
-    //trace.aaxis._tickinfo = agrid;
-    //trace.baxis._tickinfo = bgrid;
-
-    var cd0 = {
+    return [{
         x: x,
         y: y,
         a: a,
         b: b
-    };
-
-    return [cd0];
+    }];
 };
 
-
-
-/*
- * Interpolate in the b-direction along constant-a lines
- *   x, y: 2D data arrays to be interpolated
- *   aidx: index of the a gridline along which to evaluate
- *   bidx0: lower-index of the b cell in which to interpolate
- *   tb: an interpolant in [0, 1]
- */
-/*function interpolateConstA (x, y, aidx, bidx0, tb, bsmoothing) {
-    if (bsmoothing) {
-        return [
-            x[aidx][bidx0] * (1 - tb) + x[aidx][bidx0 + 1] * tb,
-            y[aidx][bidx0] * (1 - tb) + y[aidx][bidx0 + 1] * tb
-        ];
-    } else {
-        return [
-            x[aidx][bidx0] * (1 - tb) + x[aidx][bidx0 + 1] * tb,
-            y[aidx][bidx0] * (1 - tb) + y[aidx][bidx0 + 1] * tb
-        ];
-    }
-}*/
-
-/*
- * Interpolate in the a and b directions
- *   x, y: 2D data arrays to be interpolated
- *   aidx0: lower index of the a cell in which to interpolatel
- *   bidx0: lower index of the b cell in which to interpolate
- *   ta: an interpolant for the a direction in [0, 1]
- *   tb: an interpolant for the b direction in [0, 1]
- */
-/*function interpolateAB (x, y, aidx0, ta, bidx0, tb, asmoothing, bsmoothing) {
-    if (asmoothing) {
-        var xy0 = interpolateConstA(x, y, aidx0, bidx0, tb, bsmoothing);
-        var xy1 = interpolateConstA(x, y, aidx0 + 1, bidx0, tb, bsmoothing);
-
-        return [
-            xy0[0] * (1 - ta) + xy1[0] * ta,
-            xy0[1] * (1 - ta) + xy1[1] * ta
-        ];
-    } else {
-        var xy0 = interpolateConstA(x, y, aidx0, bidx0, tb, bsmoothing);
-        var xy1 = interpolateConstA(x, y, aidx0 + 1, bidx0, tb, bsmoothing);
-
-        return [
-            xy0[0] * (1 - ta) + xy1[0] * ta,
-            xy0[1] * (1 - ta) + xy1[1] * ta
-        ];
-    }
-}*/
-
-/*
- * Return a function that converts a/b coordinates to x/y values
- */
-/*function getConvert (x, y, a, b, asmoothing, bsmoothing) {
-    return function (aval, bval) {
-        // Get the lower-indices of the box in which the point falls:
-        var aidx = Math.min(search(aval, a), a.length - 2);
-        var bidx = Math.min(search(bval, b), b.length - 2);
-
-        var ta = (aval - a[aidx]) / (a[aidx + 1] - a[aidx]);
-        var tb = (bval - b[bidx]) / (b[bidx + 1] - b[bidx]);
-
-        return interpolateAB(x, y, aidx, ta, bidx, tb, asmoothing, bsmoothing);
-    };
-}*/
-
-/*
- * Interpret the tick properties to return indices, interpolants,
- * and values of grid lines
- *
- * Output is:
- *      ilower: lower index of the cell in which the gridline lies
- *      interpolant: fractional distance of this gridline to the next cell (in [0, 1])
- *      values: value of the axis coordinate at each respective gridline
- */
-/*function makeGridLines (data, axis) {
-    var gridlines = [];
-    var t = [];
-    var i0 = [];
-    var i1 = [];
-    var values = [];
-    switch(axis.tickmode) {
-    case 'array':
-        var start = axis.arraytick0 % axis.arraydtick;
-        var step = axis.arraydtick;
-        var end = data.length;
-        // This could be optimized, but we'll convert this to a/b space and then do
-        // the interpolation in
-        for (var i = start; i < end; i += step) {
-            // If it's the end point, we'll use the end of the previous range to
-            // avoid going out of bounds:
-            var endshift = i >= end - 1 ? 1 : 0;
-
-            gridlines.push({
-                param: i,
-                idx: i - endshift,
-                tInterp: endshift,
-                value: data[i]
-            });
-        }
-        break;
-    case 'linear':
-        var v1 = getLinspaceStartingPoint(data[0], axis.tick0, axis.dtick);
-        var n = Math.ceil((data[data.length - 1] - v1) / axis.dtick);
-
-        // This could be optimized, but we'll convert this to a/b space and then do
-        // the interpolation in
-        for (var i = 0; i < n; i++) {
-            var val = v1 + axis.dtick * i;
-            var idx = Math.min(search(val, data), data.length - 2);
-            gridlines.push({
-                param: (val - data[0]) / (data[data.length - 1] - data[0]) * data.length,
-                idx: idx,
-                tInterp: (val - data[idx]) / (data[idx + 1] - data[idx]),
-                value: val
-            });
-        }
-    }
-
-    console.log('gridlines:', gridlines);
-
-    return gridlines;
-}*/
-
 /*
  * Given a data range from starting at x1, this function computes the first
  * point distributed along x0 + n * dx that lies within the range.