test handling of cmin, cmax and z that are zero or negative

Author: bmaranville

test/jasmine/tests/colorbar_test.js

@@ -589,5 +589,56 @@ describe('Test colorbar:', function() {
             // // Verify a linear tick like '500' was NOT generated
             expect(tickTexts).not.toContain('500');
         });
+
+        it('should fall back to a linear colorbar when zmin is explicitly non-positive, instead of a NaN-derived range', function(done) {
+            Plotly.newPlot(gd, [{
+                type: 'heatmap',
+                z: [[-5, 10, 100], [10, 100, 1000]],
+                zmin: -5,
+                zmax: 1000,
+                colorbar: {
+                    type: 'log',
+                    tickmode: 'auto'
+                }
+            }])
+            .then(function() {
+                var ax;
+                gd._fullLayout._infolayer.selectAll('g.colorbar').each(function(opts) {
+                    ax = opts._axis;
+                });
+
+                // a log colorbar can't represent a non-positive zmin, so the
+                // whole colorbar (and its mocked axis) falls back to linear
+                // instead of producing a NaN/folded log range
+                expect(gd._fullData[0].colorbar.type).toBe('linear');
+                expect(ax.type).toBe('linear');
+                expect(ax.range).toEqual([-5, 1000]);
+            })
+            .then(done, done.fail);
+        });
+
+        it('should mask out non-positive z values and stay log when autoscaling with mixed-sign data', function(done) {
+            Plotly.newPlot(gd, [{
+                type: 'heatmap',
+                z: [[-5, 2, 100], [10, 100, 1000]],
+                colorbar: {
+                    type: 'log',
+                    tickmode: 'auto'
+                }
+            }])
+            .then(function() {
+                var ax;
+                gd._fullLayout._infolayer.selectAll('g.colorbar').each(function(opts) {
+                    ax = opts._axis;
+                });
+
+                expect(gd._fullData[0].colorbar.type).toBe('log');
+                expect(ax.type).toBe('log');
+                // -5 is masked out of autorange; smallest positive value (2) is zmin
+                expect(ax.range[0]).toBeCloseTo(Math.log10(2), 5);
+                expect(ax.range[1]).toBeCloseTo(Math.log10(1000), 5);
+            })
+            .then(done, done.fail);
+        });
     });
 });

test/jasmine/tests/colorscale_test.js

@@ -654,6 +654,53 @@ describe('Test colorscale:', function() {
             expect(fullLayout.coloraxis.cmax).toBe(4);
             expect(fullLayout.coloraxis._cmax).toBe(4);
         });
+
+        it('should fall back to a linear colorbar when zmin/zmax is explicitly non-positive for a log colorbar', function() {
+            trace = {
+                type: 'heatmap',
+                z: [[-5, 10, 100], [10, 100, 1000]],
+                zmin: -5,
+                zmax: 1000,
+                zauto: false,
+                colorbar: {type: 'log'}
+            };
+            gd = _supply(trace);
+            calcColorscale(gd, trace, {vals: trace.z, containerStr: '', cLetter: 'z'});
+
+            expect(trace.colorbar.type).toBe('linear');
+            expect(trace._zmin).toBe(-5);
+            expect(trace._zmax).toBe(1000);
+        });
+
+        it('should fall back to a linear colorbar when autoscaling finds no positive values for a log colorbar', function() {
+            trace = {
+                type: 'heatmap',
+                z: [[-5, -10], [-100, -1]],
+                colorbar: {type: 'log'}
+            };
+            gd = _supply(trace);
+            calcColorscale(gd, trace, {vals: trace.z, containerStr: '', cLetter: 'z'});
+
+            expect(trace.colorbar.type).toBe('linear');
+            expect(trace._zmin).toBe(-100);
+            expect(trace._zmax).toBe(-1);
+        });
+
+        it('should mask out non-positive values when autoscaling a log colorbar, like log cartesian axes do', function() {
+            trace = {
+                type: 'heatmap',
+                z: [[-5, 2, 100], [10, 100, 1000]],
+                colorbar: {type: 'log'}
+            };
+            gd = _supply(trace);
+            calcColorscale(gd, trace, {vals: trace.z, containerStr: '', cLetter: 'z'});
+
+            // stays log - there is positive data to scale from
+            expect(trace.colorbar.type).toBe('log');
+            // -5 is masked out; the smallest positive value (2) becomes zmin
+            expect(trace._zmin).toBe(2);
+            expect(trace._zmax).toBe(1000);
+        });
     });
 
     describe('extractScale + makeColorScaleFunc', function() {
@@ -1247,7 +1294,42 @@ describe('Test colorscale restyle calls:', function() {
             expect(colorFn(0)).toEqual('rgba(0,0,0,0)');
             expect(colorFn(-10)).toEqual('rgba(0,0,0,0)');
         });
-        
+
+        it('should return numeric rgba arrays (not strings) when called with returnArray/noNumericCheck, as heatmap rendering does', function() {
+            var trace = {
+                cmin: 1,
+                cmax: 100,
+                colorscale: [
+                    [0, 'rgb(0, 0, 0)'],
+                    [1, 'rgb(200, 100, 50)']
+                ],
+                colorbar: {
+                    type: 'log'
+                }
+            };
+
+            var colorFn = makeColorScaleFuncFromTrace(trace, {noNumericCheck: true, returnArray: true});
+
+            // log10(1) = 0 -> maps to 0% of the scale
+            var cLow = colorFn(1);
+            expect(cLow).toEqual([0, 0, 0, 1]);
+            expect(typeof cLow[0]).toBe('number');
+
+            // log10(100) = 2 -> maps to 100% of the scale
+            var cHigh = colorFn(100);
+            expect(cHigh).toEqual([200, 100, 50, 1]);
+
+            // zero/negative must clamp to a numeric transparent array, not a css string,
+            // since callers like heatmap/plot.js index directly into the result (c[0], c[1], c[2])
+            var cZero = colorFn(0);
+            expect(cZero).toEqual([0, 0, 0, 0]);
+            expect(typeof cZero[0]).toBe('number');
+
+            var cNeg = colorFn(-10);
+            expect(cNeg).toEqual([0, 0, 0, 0]);
+            expect(typeof cNeg[0]).toBe('number');
+        });
+
         it('should safely fall back to linear if type is undefined or linear', function() {
             var trace = {
                 cmin: 1,