fix edge-ray intersection edge cases

Author: etpinard

src/plots/polar/polar.js

@@ -758,7 +758,6 @@ proto.updateMainDrag = function(fullLayout, polarLayout) {
     function findEnclosingVertexAngles(a) {
         var cycleIndex = makeCycleIndexFn(vangles.length);
         var i0 = findIndexOfMin(vangles, function(v) {
-            if(!isAngleInSector(v, sector)) return Infinity;
             var adelta = angleDelta(v, a);
             return adelta > 0 ? adelta : Infinity;
         });
@@ -823,8 +822,8 @@ proto.updateMainDrag = function(fullLayout, polarLayout) {
         // match origin for asymmetric polygons
         if(vangles) {
             var offset = findPolygonOffset(radius, sector, vangles);
-            x0 += offset.left;
-            y0 += offset.top;
+            x0 += cxx + offset[0];
+            y0 += cyy + offset[1];
         }
 
         switch(dragModeNow) {
@@ -1323,7 +1322,7 @@ function findIndexOfMin(arr, fn) {
     return ind;
 }
 
-// find intersection of 'v0' <-> 'v1' edge with a 'radial' line
+// find intersection of 'v0' <-> 'v1' edge with a ray at angle 'a'
 // (i.e. a line that starts from the origin at angle 'a')
 // given an (xp,yp) pair on the 'v0' <-> 'v1' line
 // (N.B. 'v0' and 'v1' are angles in radians)
@@ -1334,28 +1333,40 @@ function findIntersectionXY(v0, v1, a, xpyp) {
     var yp = xpyp[1];
     var dsin = clampTiny(Math.sin(v1) - Math.sin(v0));
     var dcos = clampTiny(Math.cos(v1) - Math.cos(v0));
-
-    if(dsin && dcos) {
-        // given
-        //  g(x) := v0 -> v1 line = m * x + b
-        //  h(x) := mr * x
-        // solve g(xstar) = h(xstar)
-        var m = dsin / dcos;
-        var b = yp - m * xp;
-        var mr = Math.sin(a) / Math.cos(a);
-        xstar = b / (mr - m);
-        ystar = mr * xstar;
-    } else {
-        var r;
-        if(dcos) {
+    var tanA = Math.tan(a);
+    var cotanA = clampTiny(1 / tanA);
+    var m = dsin / dcos;
+    var b = yp - m * xp;
+
+    if(cotanA) {
+        if(dsin && dcos) {
+            // given
+            //  g(x) := v0 -> v1 line = m*x + b
+            //  h(x) := ray at angle 'a' = m*x = tanA*x
+            // solve g(xstar) = h(xstar)
+            xstar = b / (tanA - m);
+            ystar = tanA * xstar;
+        } else if(dcos) {
             // horizontal v0 -> v1
-            r = yp / Math.sin(v0);
+            xstar = yp * cotanA;
+            ystar = yp;
         } else {
-            // vertical v0 -> va
-            r = xp / Math.cos(v0);
+            // vertical v0 -> v1
+            xstar = xp;
+            ystar = xp * tanA;
+        }
+    } else {
+        // vertical ray
+        if(dsin && dcos) {
+            xstar = 0;
+            ystar = b;
+        } else if(dcos) {
+            xstar = 0;
+            ystar = yp;
+        } else {
+            // does this case exists?
+            xstar = ystar = NaN;
         }
-        xstar = r * Math.cos(a);
-        ystar = r * Math.sin(a);
     }
 
     return [xstar, ystar];
@@ -1365,7 +1376,7 @@ function findIntersectionXY(v0, v1, a, xpyp) {
 // rearranged into 0 = a*x^2 + b * x + c
 //
 // where f(x) = m*x + t + yp
-// and   x01 = (-b +/- del) / (2*a)
+// and   (x0, x1) = (-b +/- del) / (2*a)
 function findXYatLength(l, m, xp, yp) {
     var t = -m * xp;
     var a = m * m + 1;
@@ -1454,15 +1465,14 @@ function makePolygon(r, sector, vangles) {
 function findPolygonOffset(r, sector, vangles) {
     var minX = Infinity;
     var minY = Infinity;
+    var vertices = makePolygon(r, sector, vangles);
 
-    for(var i = 0; i < vangles.length; i++) {
-        var va = vangles[i];
-        if(isAngleInSector(va, sector)) {
-            minX = Math.min(minX, r * Math.cos(va));
-            minY = Math.min(minY, -r * Math.sin(va));
-        }
+    for(var i = 0; i < vertices.length; i++) {
+        var v = vertices[i];
+        minX = Math.min(minX, v[0]);
+        minY = Math.min(minY, -v[1]);
     }
-    return {top: minY + r, left: minX + r};
+    return [minX, minY];
 }
 
 function invertY(pts0) {
@@ -1564,6 +1574,7 @@ function strRotate(angle) {
     return 'rotate(' + angle + ')';
 }
 
+// to more easily catch 'almost zero' numbers in if-else blocks
 function clampTiny(v) {
     return Math.abs(v) > 1e-10 ? v : 0;
 }

test/image/baselines/polar_polygon-grids.png

@@ -38,6 +38,20 @@
       "theta": ["b"],
       "name": "out-of-polygon (should not see it)",
       "subplot": "polar4"
+    },
+    {
+      "type": "scatterpolar",
+      "r": [5, 4, 2, 4, 5, 5],
+      "theta": ["b", "c", "d", "e", "a", "b"],
+      "fill": "toself",
+      "subplot": "polar5"
+    },
+    {
+      "type": "scatterpolar",
+      "r": [5, 4, 2, 4, 5, 5],
+      "theta": ["b", "c", "d", "e", "a", "b"],
+      "fill": "toself",
+      "subplot": "polar6"
     }
   ],
   "layout": {
@@ -96,6 +110,29 @@
         "range": [0, 400]
       }
     },
+    "polar5": {
+      "gridshape": "linear",
+      "domain": {
+        "x": [0.4, 0.6],
+        "y": [0.4, 0.6]
+      },
+      "angularaxis": {
+        "direction": "clockwise",
+        "tickfont": {"color": "red"}
+      },
+      "sector": [-90, 90]
+    },
+    "polar6": {
+      "gridshape": "linear",
+      "domain": {
+        "x": [0.8, 1],
+        "y": [0.45, 0.65]
+      },
+      "angularaxis": {
+        "tickfont": {"color": "blue" }
+      },
+      "sector": [0, 180]
+    },
     "width": 550,
     "height": 550,
     "margin": {"l": 40, "r": 40, "b": 60, "t": 20, "pad": 0},

test/image/mocks/polar_polygon-grids.json

@@ -1292,8 +1292,7 @@ describe('Test polar *gridshape linear* interactions', function() {
                     [-142.658, -46.353], [-88.167, 121.352],
                     [88.167, 121.352], [142.658, -46.352],
                     [0, -150], [-142.658, -46.352],
-                    [-142.658, -46.352],
-                    [-88.167, 121.352],
+                    [-142.658, -46.352], [-88.167, 121.352],
                     [88.167, 121.352], [142.658, -46.352],
                     [0, -150], [-142.658, -46.352],
                     [-49.261, -16.005], [-30.445, 41.904],
@@ -1308,6 +1307,33 @@ describe('Test polar *gridshape linear* interactions', function() {
                 ]
             });
         })
+        .then(function() {
+            return Plotly.relayout(gd, 'polar.sector', [-90, 90]);
+        })
+        .then(function() { return _dragStart([200, 200], [200, 230]); })
+        .then(function() {
+            _assertAndDragEnd('half-sector, drag outward', {
+                zoombox: [
+                    [0, 121.352], [88.167, 121.352],
+                    [142.658, -46.352], [0, -150],
+                    [0, -150], [0, 0],
+                    [0, 121.352], [0, 121.352],
+                    [88.167, 121.352], [142.658, -46.352],
+                    [0, -150], [0, -150],
+                    [0, 0], [0, 121.352],
+                    [0, 71.329], [51.823, 71.329],
+                    [83.852, -27.245], [0, -88.16778784387097],
+                    [0, -88.167], [0, 0],
+                    [0, 71.329]
+                ],
+                corners: [
+                    [73.602, 10.771], [65.877, 34.548],
+                    [62.073, 33.312], [69.798, 9.535],
+                    [121.177, 26.229], [113.452, 50.006],
+                    [109.648, 48.770], [117.373, 24.993]
+                ]
+            });
+        })
         .catch(failTest)
         .then(done);
     });