Add barpolar traces

src/lib/angles.js

@@ -10,25 +10,119 @@
 
 var PI = Math.PI;
 
-exports.deg2rad = function(deg) {
+function deg2rad(deg) {
     return deg / 180 * PI;
-};
+}
 
-exports.rad2deg = function(rad) {
+function rad2deg(rad) {
     return rad / PI * 180;
-};
+}
 
-exports.wrap360 = function(deg) {
+function wrap360(deg) {
     var out = deg % 360;
     return out < 0 ? out + 360 : out;
-};
+}
 
-exports.wrap180 = function(deg) {
+function wrap180(deg) {
     if(Math.abs(deg) > 180) deg -= Math.round(deg / 360) * 360;
     return deg;
-};
+}
 
-exports.isFullCircle = function(sector) {
+/* is sector a full circle?
+ * ... this comes up a lot in SVG path-drawing routines
+ *
+ * @param {2-item array} sector sector angles in *degrees*
+ * @return {boolean}
+ */
+function isFullCircle(sector) {
     var arc = Math.abs(sector[1] - sector[0]);
     return arc === 360;
+}
+
+/* angular delta between angle 'a' and 'b'
+ *
+ * solution taken from: https://stackoverflow.com/a/2007279
+ *
+ * @param {number} a : first angle in *radians*
+ * @param {number} b : second angle in *radians*
+ * @return {number} angular delta in *radians*
+ */
+function angleDelta(a, b) {
+    var d = b - a;
+    return Math.atan2(Math.sin(d), Math.cos(d));
+}
+
+/* angular distance between angle 'a' and 'b'
+ *
+ * @param {number} a : first angle in *radians*
+ * @param {number} b : second angle in *radians*
+ * @return {number} angular distance in *radians*
+ */
+function angleDist(a, b) {
+    return Math.abs(angleDelta(a, b));
+}
+
+/* is angle inside sector?
+ *
+ * @param {number} a : angle to test in *radians*
+ * @param {2-item array} sector : sector angles in *degrees*
+ * @param {boolean}
+ */
+function isAngleInsideSector(a, sector) {
+    if(isFullCircle(sector)) return true;
+
+    var s0, s1;
+
+    if(sector[0] < sector[1]) {
+        s0 = sector[0];
+        s1 = sector[1];
+    } else {
+        s0 = sector[1];
+        s1 = sector[0];
+    }
+
+    s0 = wrap360(s0);
+    s1 = wrap360(s1);
+    if(s0 > s1) s1 += 360;
+
+    var a0 = wrap360(rad2deg(a));
+    var a1 = a0 + 360;
+
+    return (a0 >= s0 && a0 <= s1) || (a1 >= s0 && a1 <= s1);
+}
+
+/* is pt (r,a) inside sector?
+ *
+ * @param {number} r : pt's radial coordinate
+ * @param {number} a : pt's angular coordinate in *radians*
+ * @param {2-item array} rRng : sector's radial range
+ * @param {2-item array} sector : sector angles in *degrees*
+ * @return {boolean}
+ */
+function isPtInsideSector(r, a, rRng, sector) {
+    if(!isAngleInsideSector(a, sector)) return false;
+
+    var r0, r1;
+
+    if(rRng[0] < rRng[1]) {
+        r0 = rRng[0];
+        r1 = rRng[1];
+    } else {
+        r0 = rRng[1];
+        r1 = rRng[0];
+    }
+
+    return r >= r0 && r <= r1;
+}
+
+module.exports = {
+    deg2rad: deg2rad,
+    rad2deg: rad2deg,
+    wrap360: wrap360,
+    wrap180: wrap180,
+    angleDelta: angleDelta,
+    angleDist: angleDist,
+    isFullCircle: isFullCircle,
+    isAngleInsideSector: isAngleInsideSector,
+    isPtInsideSector: isPtInsideSector
 };

src/lib/index.js

@@ -87,7 +87,11 @@ lib.deg2rad = anglesModule.deg2rad;
 lib.rad2deg = anglesModule.rad2deg;
 lib.wrap360 = anglesModule.wrap360;
 lib.wrap180 = anglesModule.wrap180;
+lib.angleDelta = anglesModule.angleDelta;
+lib.angleDist = anglesModule.angleDist;
 lib.isFullCircle = anglesModule.isFullCircle;
+lib.isAngleInsideSector = anglesModule.isAngleInsideSector;
+lib.isPtInsideSector = anglesModule.isPtInsideSector;
 
 var geom2dModule = require('./geometry2d');
 lib.segmentsIntersect = geom2dModule.segmentsIntersect;

src/plots/polar/polar.js

@@ -38,6 +38,8 @@ var rad2deg = Lib.rad2deg;
 var wrap360 = Lib.wrap360;
 var wrap180 = Lib.wrap180;
 var isFullCircle = Lib.isFullCircle;
+var isAngleInsideSector = Lib.isAngleInsideSector;
+var angleDelta = Lib.angleDelta;
 
 function Polar(gd, id) {
     this.id = id;
@@ -501,7 +503,9 @@ proto.updateAngularAxis = function(fullLayout, polarLayout) {
     // the range w.r.t sector, so that sectors that cross 360 can
     // show all their ticks.
     if(ax.type === 'category') {
-        ax._tickFilter = function(d) { return isAngleInSector(t2g(d), sector); };
+        ax._tickFilter = function(d) {
+            return isAngleInsideSector(t2g(d), sector);
+        };
     }
 
     ax._transfn = function(d) {
@@ -1194,16 +1198,12 @@ proto.updateAngularDrag = function(fullLayout, polarLayout) {
 
 proto.isPtInside = function(d) {
     var sector = this.sector;
-    var thetag = this.angularAxis.c2g(d.theta);
-
-    if(!isAngleInSector(thetag, sector)) {
-        return false;
-    }
-
     var vangles = this.vangles;
+    var thetag = this.angularAxis.c2g(d.theta);
     var radialAxis = this.radialAxis;
     var radialRange = radialAxis.range;
     var r = radialAxis.c2r(d.r);
+    var rRng = radialAxis.range;
 
     var r0, r1;
     if(radialRange[1] >= radialRange[0]) {
@@ -1214,6 +1214,7 @@ proto.isPtInside = function(d) {
         r1 = radialRange[0];
     }
 
+    return Lib.isPtInsideSector(r, thetag, rRng, sector);
     if(vangles) {
         var polygonIn = polygonTester(makePolygon(r0, sector, vangles));
         var polygonOut = polygonTester(makePolygon(r1, sector, vangles));
@@ -1291,35 +1292,12 @@ function computeSectorBBox(sector) {
     return [x0, y0, x1, y1];
 }
 
-function isAngleInSector(rad, sector) {
-    if(isFullCircle(sector)) return true;
-
-    var s0 = wrap360(sector[0]);
-    var s1 = wrap360(sector[1]);
-    if(s0 > s1) s1 += 360;
-
-    var deg = wrap360(rad2deg(rad));
-    var nextTurnDeg = deg + 360;
-
-    return (deg >= s0 && deg <= s1) ||
-        (nextTurnDeg >= s0 && nextTurnDeg <= s1);
-}
-
 function snapToVertexAngle(a, vangles) {
-    function angleDeltaAbs(va) {
-        return Math.abs(angleDelta(a, va));
-    }
-
-    var ind = findIndexOfMin(vangles, angleDeltaAbs);
+    var fn = function(v) { return Lib.angleDist(a, v); };
+    var ind = findIndexOfMin(vangles, fn);
     return vangles[ind];
 }
 
-// taken from https://stackoverflow.com/a/2007279
-function angleDelta(a, b) {
-    var d = b - a;
-    return Math.atan2(Math.sin(d), Math.cos(d));
-}
-
 function findIndexOfMin(arr, fn) {
     fn = fn || Lib.identity;