keep domainpad a bit for bit no-op when it is not set

The three places that build the plot rect from `domain` were changed to read
_offset and _length instead. That round trips through pixel space, and the
result is not exactly the value it started from: splom cell domains came back
about one ulp out, which moved rasterised markers enough to fail the
splom_*-nodiag image baselines even though no padding was involved.

Add the resolved padding to the original expressions instead, and expose it as
ax._padStart / ax._padEnd for those callers. Adding a literal zero is exact, so
an unpadded plot now produces the same numbers it always did.

Also list domainpad in swapAxisGroup's noSwapAttrs, next to domain: its keys are
named for screen edges, so swapping x and y would need them remapped.

Author: SharadhNaidu

src/plots/cartesian/axes.js

@@ -4605,7 +4605,10 @@ function swapAxisGroup(gd, xIds, yIds) {
     var allAxKeys = Object.keys(axAttrs);
 
     var noSwapAttrs = [
-        'anchor', 'domain', 'overlaying', 'position', 'side', 'tickangle', 'editType'
+        // domainpad sits with domain here: its keys are named for screen edges, so
+        // swapping x and y would have to remap left/right onto top/bottom
+        'anchor', 'domain', 'domainpad', 'overlaying', 'position', 'side',
+        'tickangle', 'editType'
     ];
     var numericTypes = ['linear', 'log'];
 

src/plots/cartesian/set_convert.js

@@ -618,6 +618,12 @@ module.exports = function setConvert(ax, fullLayout) {
         }
 
         ax._length = bandLength - padStart - padEnd;
+        // the resolved padding, for the few places that build the plot rect from
+        // `domain` themselves and would otherwise miss it. They add these instead of
+        // rebuilding from _offset and _length, which would round trip through pixel
+        // space and lose a bit or two even when there is no padding at all.
+        ax._padStart = padStart;
+        ax._padEnd = padEnd;
 
         if(isY) {
             ax._offset = gs.t + (1 - ax.domain[1]) * gs.h + padStart;

src/traces/scattergl/plot.js

@@ -17,22 +17,31 @@ var styleTextSelection = require('./edit_style').styleTextSelection;
 var reglPrecompiled = {};
 
 function getViewport(fullLayout, xaxis, yaxis, plotGlPixelRatio) {
-    // This is the same rectangle the svg side draws into, only measured up from the
-    // bottom of the figure instead of down from the top. Read it off _offset and
-    // _length rather than working it out from `domain` again, so that anything which
-    // moves the plot area by a pixel amount - `domainpad`, say - lands here as well.
-    var height = fullLayout.height;
-
-    var left = xaxis._offset;
-    var right = xaxis._offset + xaxis._length;
-    var bottom = height - (yaxis._offset + yaxis._length);
-    var top = height - yaxis._offset;
+    var gs = fullLayout._size;
+    var width = fullLayout.width * plotGlPixelRatio;
+    var height = fullLayout.height * plotGlPixelRatio;
+
+    var l = gs.l * plotGlPixelRatio;
+    var b = gs.b * plotGlPixelRatio;
+    var r = gs.r * plotGlPixelRatio;
+    var t = gs.t * plotGlPixelRatio;
+    var w = gs.w * plotGlPixelRatio;
+    var h = gs.h * plotGlPixelRatio;
+
+    // `domainpad` takes pixels off the plot area that `domain` knows nothing about.
+    // Add it to the expressions below rather than rebuilding the rect from _offset
+    // and _length: that would round trip through pixel space and shift this rect by
+    // a fraction of a pixel even on plots with no padding at all.
+    var padL = (xaxis._padStart || 0) * plotGlPixelRatio;
+    var padR = (xaxis._padEnd || 0) * plotGlPixelRatio;
+    var padT = (yaxis._padStart || 0) * plotGlPixelRatio;
+    var padB = (yaxis._padEnd || 0) * plotGlPixelRatio;
 
     return [
-        left * plotGlPixelRatio,
-        bottom * plotGlPixelRatio,
-        right * plotGlPixelRatio,
-        top * plotGlPixelRatio
+        l + xaxis.domain[0] * w + padL,
+        b + yaxis.domain[0] * h + padB,
+        (width - r) - (1 - xaxis.domain[1]) * w - padR,
+        (height - t) - (1 - yaxis.domain[1]) * h - padT
     ];
 }
 

src/traces/splom/base_plot.js

@@ -90,6 +90,7 @@ function updateGrid(gd) {
 function makeGridData(gd) {
     var plotGlPixelRatio = gd._context.plotGlPixelRatio;
     var fullLayout = gd._fullLayout;
+    var gs = fullLayout._size;
     var fullView = [
         0, 0,
         fullLayout.width * plotGlPixelRatio,
@@ -135,9 +136,9 @@ function makeGridData(gd) {
 
         // ya.l2p assumes top-to-bottom coordinate system (a la SVG),
         // we need to compute bottom-to-top offsets and slopes.
-        // Flip the axis' own bottom edge rather than rebuilding it from `domain`,
-        // so pixel adjustments to the plot area such as `domainpad` come along:
-        var yOffset = fullLayout.height - (ya._offset + ya._length);
+        // `domainpad` is added on rather than folded in by reading _offset, so that
+        // an unpadded axis lands on exactly the pixel it always did:
+        var yOffset = gs.b + ya.domain[0] * gs.h + (ya._padEnd || 0);
         var ym = -ya._m;
         var yb = -ym * ya.r2l(ya.range[0], ya.calendar);
         var x, y;

src/traces/splom/plot.js

@@ -42,12 +42,11 @@ function plotOne(gd, cd0) {
     viewOpts.domains = new Array(visibleLength);
 
     // regl-splom places each cell as a fraction of the viewport below, which is the
-    // whole plot area. Derive those fractions from where the axes actually ended up
-    // rather than from `domain`, otherwise anything that shifts the plot area in
-    // pixels - `domainpad` - would move the axes but leave the points behind.
-    // regl counts y up from the bottom, so the y pair comes back reversed.
-    function xFraction(px) { return (px - gs.l) / gs.w; }
-    function yFraction(px) { return (fullLayout.height - px - gs.b) / gs.h; }
+    // whole plot area, so `domainpad` has to be folded in as a fraction too or the
+    // cells keep their unpadded size while the axes move. Added to `domain` rather
+    // than recovered from _offset and _length, which would round trip through pixel
+    // space and nudge every cell a little even with no padding set.
+    function padFrac(px, total) { return (px || 0) / total; }
 
     for(k = 0; k < visibleDims.length; k++) {
         i = visibleDims[k];
@@ -59,16 +58,16 @@ function plotOne(gd, cd0) {
         if(xa) {
             rng[0] = xa._rl[0];
             rng[2] = xa._rl[1];
-            dmn[0] = xFraction(xa._offset);
-            dmn[2] = xFraction(xa._offset + xa._length);
+            dmn[0] = xa.domain[0] + padFrac(xa._padStart, gs.w);
+            dmn[2] = xa.domain[1] - padFrac(xa._padEnd, gs.w);
         }
 
         ya = AxisIDs.getFromId(gd, trace._diag[i][1]);
         if(ya) {
             rng[1] = ya._rl[0];
             rng[3] = ya._rl[1];
-            dmn[1] = yFraction(ya._offset + ya._length);
-            dmn[3] = yFraction(ya._offset);
+            dmn[1] = ya.domain[0] + padFrac(ya._padEnd, gs.h);
+            dmn[3] = ya.domain[1] - padFrac(ya._padStart, gs.h);
         }
     }
 

test/jasmine/tests/axes_test.js

@@ -8903,6 +8903,43 @@ describe('axis domainpad', function() {
         .then(done, done.fail);
     });
 
+    it('should leave every number exactly as it was when no padding is set', function(done) {
+        // The pad has to be a true no-op at its default. Rebuilding the plot rect
+        // from _offset and _length instead of adding the pad to `domain` shifted
+        // webgl output by a fraction of a pixel on unpadded plots, which is enough
+        // to move rasterised markers and fail an image baseline. Compare with ===,
+        // not toBeCloseTo, because that is the size of the mistake being guarded.
+        Plotly.newPlot(gd, [
+            {y: [1, 2, 3]},
+            {y: [2, 1, 3], xaxis: 'x2', yaxis: 'y2'}
+        ], {
+            width: 600, height: 500, margin: {l: 80, r: 80, t: 100, b: 80},
+            xaxis: {domain: [0, 0.3103448275862069], anchor: 'y'},
+            yaxis: {domain: [0.6896551724137931, 1], anchor: 'x'},
+            xaxis2: {domain: [0.3448275862068966, 0.6551724137931034], anchor: 'y2'},
+            yaxis2: {domain: [0, 0.3103448275862069], anchor: 'x2'}
+        })
+        .then(function() {
+            var fl = gd._fullLayout;
+            var gs = fl._size;
+
+            ['xaxis', 'yaxis', 'xaxis2', 'yaxis2'].forEach(function(name) {
+                var ax = fl[name];
+                var isY = name.charAt(0) === 'y';
+                var wantOffset = isY ?
+                    gs.t + (1 - ax.domain[1]) * gs.h :
+                    gs.l + ax.domain[0] * gs.w;
+                var wantLength = (isY ? gs.h : gs.w) * (ax.domain[1] - ax.domain[0]);
+
+                expect(ax._offset).withContext(name + ' offset').toBe(wantOffset);
+                expect(ax._length).withContext(name + ' length').toBe(wantLength);
+                expect(ax._padStart).withContext(name + ' padStart').toBe(0);
+                expect(ax._padEnd).withContext(name + ' padEnd').toBe(0);
+            });
+        })
+        .then(done, done.fail);
+    });
+
     it('should not drift when the axis gets rescaled again and again', function(done) {
         // setScale runs several times per draw, so the padding has to be read
         // fresh each time rather than piled onto the previous result