cartesian 2dMap: implement sorting of categorical axes

src/traces/heatmap/calc.js

@@ -64,14 +64,17 @@ module.exports = function calc(gd, trace) {
         } else {
             x = trace.x ? xa.makeCalcdata(trace, 'x') : [];
             y = trace.y ? ya.makeCalcdata(trace, 'y') : [];
+
+            trace._x = x;
+            trace._y = y;
         }
 
         x0 = trace.x0;
         dx = trace.dx;
         y0 = trace.y0;
         dy = trace.dy;
 
-        z = clean2dArray(zIn, trace.transpose);
+        z = clean2dArray(zIn, trace.transpose, trace, xa, ya);
 
         if(isContour || trace.connectgaps) {
             trace._emptypoints = findEmpties(z);

src/traces/heatmap/clean_2d_array.js

@@ -10,7 +10,7 @@
 
 var isNumeric = require('fast-isnumeric');
 
-module.exports = function clean2dArray(zOld, transpose) {
+module.exports = function clean2dArray(zOld, transpose, trace, xa, ya) {
     var rowlen, collen, getCollen, old2new, i, j;
 
     function cleanZvalue(v) {
@@ -30,12 +30,23 @@ module.exports = function clean2dArray(zOld, transpose) {
         old2new = function(zOld, i, j) { return zOld[i][j]; };
     }
 
+    var xMap = function(i) {return i;};
+    var yMap = function(i) {return i;};
+    if(trace && trace.type !== 'carpet' && trace.type !== 'contourcarpet') {
+        if(ya && ya.type === 'category') {
+            if(trace._y.length) yMap = function(i) {return trace._y[i];};
+        }
+        if(xa && xa.type === 'category') {
+            if(trace._x.length) xMap = function(i) {return trace._x[i];};
+        }
+    }
+
     var zNew = new Array(rowlen);
 
     for(i = 0; i < rowlen; i++) {
         collen = getCollen(zOld, i);
         zNew[i] = new Array(collen);
-        for(j = 0; j < collen; j++) zNew[i][j] = cleanZvalue(old2new(zOld, i, j));
+        for(j = 0; j < collen; j++) zNew[i][j] = cleanZvalue(old2new(zOld, yMap(i), xMap(j)));
     }
 
     return zNew;

test/image/mocks/heatmap_categoryorder.json

@@ -0,0 +1,26 @@
+{
+  "layout": {
+    "xaxis": {
+      "type": "category",
+      "categoryorder": "category descending"
+    },
+    "yaxis": {
+      "type": "category",
+      "categoryorder": "category descending"
+    },
+    "height": 400,
+    "width": 400
+  },
+  "data": [{
+    "type": "heatmap",
+
+    "x": [3, 2, 1, 0],
+    "y": ["d", "c", "b", "a"],
+    "z": [
+      [100, 75, 50, 0],
+      [90, 65, 40, 0],
+      [80, 55, 30, 0],
+      [0, 0, 0, 0]
+    ]
+  }]
+}

test/jasmine/tests/heatmap_test.js

@@ -491,6 +491,51 @@ describe('heatmap calc', function() {
         expect(out.y).toBeCloseToArray([0, 4, 8]);
         expect(out.z).toBeCloseTo2DArray([[1, 2, 3], [3, 1, 2]]);
     });
+
+    it('should handle axis categoryorder', function() {
+        var mock = require('@mocks/heatmap_categoryorder');
+        var data = mock.data[0];
+        var layout = mock.layout;
+
+        // sort x axis categories
+        var mockLayout = Lib.extendDeep({}, layout);
+        var out = _calc(data, mockLayout);
+        mockLayout.xaxis.categoryorder = 'category ascending';
+        var out1 = _calc(data, mockLayout);
+
+        expect(out._xcategories).toEqual(out1._xcategories.reverse());
+        // Check z data is also sorted
+        for(var i = 0; i < out.z.length; i++) {
+            expect(out1.z[i]).toEqual(out.z[i].reverse());
+        }
+
+        // sort y axis categories
+        mockLayout = Lib.extendDeep({}, layout);
+        out = _calc(data, mockLayout);
+        mockLayout.yaxis.categoryorder = 'category ascending';
+        out1 = _calc(data, mockLayout);
+
+        expect(out._ycategories).toEqual(out1._ycategories.reverse());
+        // Check z data is also sorted
+        expect(out1.z).toEqual(out.z.reverse());
+    });
+
+    it('should handle axis categoryarray', function() {
+        var mock = require('@mocks/heatmap_categoryorder');
+        var data = mock.data[0];
+        var layout = mock.layout;
+
+        layout.xaxis.categoryorder = 'array';
+        layout.xaxis.categoryarray = [2, 3, 0, 1];
+        layout.yaxis.categoryorder = 'array';
+        layout.yaxis.categoryarray = ['a', 'd', 'b', 'c'];
+
+        var out = _calc(data, layout);
+
+        expect(out._xcategories).toEqual(layout.xaxis.categoryarray, 'xaxis should reorder');
+        expect(out._ycategories).toEqual(layout.yaxis.categoryarray, 'yaxis should reorder');
+        expect(out.z[0][0]).toEqual(65);
+    });
 });
 
 describe('heatmap plot', function() {