Add barpolar traces

lib/barpolar.js

@@ -0,0 +1,11 @@
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = require('../src/traces/barpolar');

lib/index.js

@@ -53,7 +53,8 @@ Plotly.register([
     require('./candlestick'),
 
     require('./scatterpolar'),
-    require('./scatterpolargl')
+    require('./scatterpolargl'),
+    require('./barpolar')
 ]);
 
 // transforms

src/lib/angles.js

@@ -10,25 +10,234 @@
 
 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;
+}
+
+// common to pathArc, pathSector and pathAnnulus
+function _path(r0, r1, a0, a1, cx, cy, isClosed) {
+    cx = cx || 0;
+    cy = cy || 0;
+
+    var isCircle = isFullCircle([a0, a1].map(rad2deg));
+    var aStart, aMid, aEnd;
+    var rStart, rEnd;
+
+    if(isCircle) {
+        aStart = 0;
+        aMid = PI;
+        aEnd = 2 * PI;
+    } else {
+        if(a0 < a1) {
+            aStart = a0;
+            aEnd = a1;
+        } else {
+            aStart = a1;
+            aEnd = a0;
+        }
+    }
+
+    if(r0 < r1) {
+        rStart = r0;
+        rEnd = r1;
+    } else {
+        rStart = r1;
+        rEnd = r0;
+    }
+
+    // N.B. svg coordinates here, where y increases downward
+    function pt(r, a) {
+        return [r * Math.cos(a) + cx, cy - r * Math.sin(a)];
+    }
+
+    var largeArc = Math.abs(aEnd - aStart) <= PI ? 0 : 1;
+    function arc(r, a, cw) {
+        return 'A' + [r, r] + ' ' + [0, largeArc, cw] + ' ' + pt(r, a);
+    }
+
+    var p;
+
+    if(isCircle) {
+        if(rStart === null) {
+            p = 'M' + pt(rEnd, aStart) +
+                arc(rEnd, aMid, 0) +
+                arc(rEnd, aEnd, 0) + 'Z';
+        } else {
+            p = 'M' + pt(rStart, aStart) +
+                arc(rStart, aMid, 0) +
+                arc(rStart, aEnd, 0) + 'Z' +
+                'M' + pt(rEnd, aStart) +
+                arc(rEnd, aMid, 1) +
+                arc(rEnd, aEnd, 1) + 'Z';
+        }
+    } else {
+        if(rStart === null) {
+            p = 'M' + pt(rEnd, aStart) + arc(rEnd, aEnd, 0);
+            if(isClosed) p += 'L0,0Z';
+        } else {
+            p = 'M' + pt(rStart, aStart) +
+                'L' + pt(rEnd, aStart) +
+                arc(rEnd, aEnd, 0) +
+                'L' + pt(rStart, aEnd) +
+                arc(rStart, aStart, 1) + 'Z';
+        }
+    }
+
+    return p;
+}
+
+/* path an arc
+ *
+ * @param {number} r : radius
+ * @param {number} a0 : first angular coordinate
+ * @param {number} a1 : second angular coordinate
+ * @param {number (optional)} cx : x coordinate of center
+ * @param {number (optional)} cy : y coordinate of center
+ * @return {string} svg path
+ */
+function pathArc(r, a0, a1, cx, cy) {
+    return _path(null, r, a0, a1, cx, cy, 0);
+}
+
+/* path a sector
+ *
+ * @param {number} r : radius
+ * @param {number} a0 : first angular coordinate
+ * @param {number} a1 : second angular coordinate
+ * @param {number (optional)} cx : x coordinate of center
+ * @param {number (optional)} cy : y coordinate of center
+ * @return {string} svg path
+ */
+function pathSector(r, a0, a1, cx, cy) {
+    return _path(null, r, a0, a1, cx, cy, 1);
+}
+
+/* path an annulus
+ *
+ * @param {number} r0 : first radial coordinate
+ * @param {number} r1 : second radial coordinate
+ * @param {number} a0 : first angular coordinate
+ * @param {number} a1 : second angular coordinate
+ * @param {number (optional)} cx : x coordinate of center
+ * @param {number (optional)} cy : y coordinate of center
+ * @return {string} svg path
+ */
+function pathAnnulus(r0, r1, a0, a1, cx, cy) {
+    return _path(r0, r1, a0, a1, cx, cy, 1);
+}
+
+module.exports = {
+    deg2rad: deg2rad,
+    rad2deg: rad2deg,
+    wrap360: wrap360,
+    wrap180: wrap180,
+    angleDelta: angleDelta,
+    angleDist: angleDist,
+    isFullCircle: isFullCircle,
+    isAngleInsideSector: isAngleInsideSector,
+    isPtInsideSector: isPtInsideSector,
+    pathArc: pathArc,
+    pathSector: pathSector,
+    pathAnnulus: pathAnnulus
 };

src/lib/index.js

@@ -62,6 +62,7 @@ lib.sorterAsc = searchModule.sorterAsc;
 lib.sorterDes = searchModule.sorterDes;
 lib.distinctVals = searchModule.distinctVals;
 lib.roundUp = searchModule.roundUp;
+lib.findIndexOfMin = searchModule.findIndexOfMin;
 
 var statsModule = require('./stats');
 lib.aggNums = statsModule.aggNums;
@@ -87,7 +88,14 @@ 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;
+lib.pathArc = anglesModule.pathArc;
+lib.pathSector = anglesModule.pathSector;
+lib.pathAnnulus = anglesModule.pathAnnulus;
 
 var geom2dModule = require('./geometry2d');
 lib.segmentsIntersect = geom2dModule.segmentsIntersect;
@@ -729,7 +737,7 @@ lib.ensureSingle = function(parent, nodeType, className, enterFn) {
     var sel = parent.select(nodeType + (className ? '.' + className : ''));
     if(sel.size()) return sel;
 
-    var layer = parent.append(nodeType).classed(className, true);
+    var layer = parent.append(nodeType).classed(className || '', true);
     if(enterFn) layer.call(enterFn);
 
     return layer;

src/lib/search.js

@@ -11,6 +11,7 @@
 
 var isNumeric = require('fast-isnumeric');
 var loggers = require('./loggers');
+var identity = require('./identity');
 
 // don't trust floating point equality - fraction of bin size to call
 // "on the line" and ensure that they go the right way specified by
@@ -113,3 +114,26 @@ exports.roundUp = function(val, arrayIn, reverse) {
     }
     return arrayIn[low];
 };
+
+/* find index in array 'arr' that minimizes 'fn'
+ *
+ * @param {array} arr : array where to search
+ * @param {fn (optional)} fn : function to minimize,
+ *   if not given, fn is the identity function
+ * @return {integer}
+ */
+exports.findIndexOfMin = function(arr, fn) {
+    fn = fn || identity;
+
+    var min = Infinity;
+    var ind;
+
+    for(var i = 0; i < arr.length; i++) {
+        var v = fn(arr[i]);
+        if(v < min) {
+            min = v;
+            ind = i;
+        }
+    }
+    return ind;
+};

src/plots/plots.js

@@ -2602,7 +2602,7 @@ function doCrossTraceCalc(gd) {
                     fullLayout[sp];
 
                 for(j = 0; j < methods.length; j++) {
-                    methods[j](gd, spInfo);
+                    methods[j](gd, spInfo, sp);
                 }
             }
         }