Merge pull request #651 from plotly/heatmap-1-xy

Fix heatmap brick generation edge cases

Author: etpinard

src/traces/heatmap/calc.js

@@ -173,36 +173,43 @@ function makeBoundArray(trace, arrayIn, v0In, dvIn, numbricks, ax) {
         dv,
         i;
 
-    if(Array.isArray(arrayIn) && !isHist && (ax.type !== 'category')) {
+    var isArrayOfTwoItemsOrMore = Array.isArray(arrayIn) && arrayIn.length > 1;
+
+    if(isArrayOfTwoItemsOrMore && !isHist && (ax.type !== 'category')) {
         arrayIn = arrayIn.map(ax.d2c);
         var len = arrayIn.length;
 
         // given vals are brick centers
-        // hopefully length==numbricks, but use this method even if too few are supplied
+        // hopefully length === numbricks, but use this method even if too few are supplied
         // and extend it linearly based on the last two points
         if(len <= numbricks) {
             // contour plots only want the centers
             if(isContour || isGL2D) arrayOut = arrayIn.slice(0, numbricks);
-            else if(numbricks === 1) arrayOut = [arrayIn[0] - 0.5, arrayIn[0] + 0.5];
+            else if(numbricks === 1) {
+                arrayOut = [arrayIn[0] - 0.5, arrayIn[0] + 0.5];
+            }
             else {
                 arrayOut = [1.5 * arrayIn[0] - 0.5 * arrayIn[1]];
+
                 for(i = 1; i < len; i++) {
                     arrayOut.push((arrayIn[i - 1] + arrayIn[i]) * 0.5);
                 }
+
                 arrayOut.push(1.5 * arrayIn[len - 1] - 0.5 * arrayIn[len - 2]);
             }
 
             if(len < numbricks) {
                 var lastPt = arrayOut[arrayOut.length - 1],
                     delta = lastPt - arrayOut[arrayOut.length - 2];
+
                 for(i = len; i < numbricks; i++) {
                     lastPt += delta;
                     arrayOut.push(lastPt);
                 }
             }
         }
         else {
-            // hopefully length==numbricks+1, but do something regardless:
+            // hopefully length === numbricks+1, but do something regardless:
             // given vals are brick boundaries
             return isContour ?
                 arrayIn.slice(0, numbricks) :  // we must be strict for contours
@@ -211,14 +218,17 @@ function makeBoundArray(trace, arrayIn, v0In, dvIn, numbricks, ax) {
     }
     else {
         dv = dvIn || 1;
-        if(v0In === undefined) v0 = 0;
+
+        if(Array.isArray(arrayIn) && arrayIn.length === 1) v0 = arrayIn[0];
+        else if(v0In === undefined) v0 = 0;
         else if(isHist || ax.type === 'category') v0 = v0In;
         else v0 = ax.d2c(v0In);
 
         for(i = (isContour || isGL2D) ? 0 : -0.5; i < numbricks; i++) {
             arrayOut.push(v0 + dv * i);
         }
     }
+
     return arrayOut;
 }
 

test/jasmine/assets/custom_matchers.js

@@ -4,21 +4,76 @@ module.exports = {
     toBeCloseToArray: function() {
         return {
             compare: function(actual, expected, precision) {
-                if(precision !== 0) {
-                    precision = Math.pow(10, -precision) / 2 || 0.005;
-                }
+                precision = coercePosition(precision);
 
                 var tested = actual.map(function(element, i) {
                     return Math.abs(expected[i] - element) < precision;
                 });
 
-                var passed = tested.indexOf(false) < 0;
+                var passed = (
+                    expected.length === actual.length &&
+                    tested.indexOf(false) < 0
+                );
 
                 return {
                     pass: passed,
                     message: 'Expected ' + actual + ' to be close to ' + expected + '.'
                 };
             }
         };
+    },
+
+    // toBeCloseTo... but for 2D arrays
+    toBeCloseTo2DArray: function() {
+        return {
+            compare: function(actual, expected, precision) {
+                precision = coercePosition(precision);
+
+                var passed = true;
+
+                if(expected.length !== actual.length) passed = false;
+                else {
+                    for(var i = 0; i < expected.length; ++i) {
+                        if(expected[i].length !== actual[i].length) {
+                            passed = false;
+                            break;
+                        }
+
+                        for(var j = 0; j < expected[i].length; ++j) {
+                            var isClose = Math.abs(expected[i][j] - actual[i][j]) < precision;
+
+                            if(!isClose) {
+                                passed = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                var message = [
+                    'Expected',
+                    arrayToStr(actual.map(arrayToStr)),
+                    'to be close to',
+                    arrayToStr(expected.map(arrayToStr))
+                ].join(' ');
+
+                return {
+                    pass: passed,
+                    message: message
+                };
+            }
+        };
     }
 };
+
+function coercePosition(precision) {
+    if(precision !== 0) {
+        precision = Math.pow(10, -precision) / 2 || 0.005;
+    }
+
+    return precision;
+}
+
+function arrayToStr(array) {
+    return '[ ' + array.join(', ') + ' ]';
+}