stripchart 0.0.3

data/lib/stripchart/public/components/d3/src/geo/azimuthal-equal-area.js

@@ -0,0 +1,12 @@
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(
+  function(cosλcosφ) { return Math.sqrt(2 / (1 + cosλcosφ)); },
+  function(ρ) { return 2 * Math.asin(ρ / 2); }
+);
+
+(d3.geo.azimuthalEqualArea = function() {
+  return d3_geo_projection(d3_geo_azimuthalEqualArea);
+}).raw = d3_geo_azimuthalEqualArea;

data/lib/stripchart/public/components/d3/src/geo/azimuthal-equidistant.js

@@ -0,0 +1,13 @@
+import "../core/identity";
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(
+  function(cosλcosφ) { var c = Math.acos(cosλcosφ); return c && c / Math.sin(c); },
+  d3_identity
+);
+
+(d3.geo.azimuthalEquidistant = function() {
+  return d3_geo_projection(d3_geo_azimuthalEquidistant);
+}).raw = d3_geo_azimuthalEquidistant;

data/lib/stripchart/public/components/d3/src/geo/azimuthal.js

@@ -0,0 +1,25 @@
+// Abstract azimuthal projection.
+function d3_geo_azimuthal(scale, angle) {
+  function azimuthal(λ, φ) {
+    var cosλ = Math.cos(λ),
+        cosφ = Math.cos(φ),
+        k = scale(cosλ * cosφ);
+    return [
+      k * cosφ * Math.sin(λ),
+      k * Math.sin(φ)
+    ];
+  }
+
+  azimuthal.invert = function(x, y) {
+    var ρ = Math.sqrt(x * x + y * y),
+        c = angle(ρ),
+        sinc = Math.sin(c),
+        cosc = Math.cos(c);
+    return [
+      Math.atan2(x * sinc, ρ * cosc),
+      Math.asin(ρ && y * sinc / ρ)
+    ];
+  };
+
+  return azimuthal;
+}

data/lib/stripchart/public/components/d3/src/geo/bounds.js

@@ -0,0 +1,169 @@
+import "../core/identity";
+import "../core/noop";
+import "geo";
+import "stream";
+import "area";
+import "cartesian";
+import "spherical";
+
+d3.geo.bounds = (function() {
+  var λ0, φ0, λ1, φ1, // bounds
+      λ_, // previous λ-coordinate
+      λ__, φ__, // first point
+      p0, // previous 3D point
+      dλSum,
+      ranges,
+      range;
+
+  var bound = {
+    point: point,
+    lineStart: lineStart,
+    lineEnd: lineEnd,
+
+    polygonStart: function() {
+      bound.point = ringPoint;
+      bound.lineStart = ringStart;
+      bound.lineEnd = ringEnd;
+      dλSum = 0;
+      d3_geo_area.polygonStart();
+    },
+    polygonEnd: function() {
+      d3_geo_area.polygonEnd();
+      bound.point = point;
+      bound.lineStart = lineStart;
+      bound.lineEnd = lineEnd;
+      if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90);
+      else if (dλSum > ε) φ1 = 90;
+      else if (dλSum < -ε) φ0 = -90;
+      range[0] = λ0, range[1] = λ1;
+    }
+  };
+
+  function point(λ, φ) {
+    ranges.push(range = [λ0 = λ, λ1 = λ]);
+    if (φ < φ0) φ0 = φ;
+    if (φ > φ1) φ1 = φ;
+  }
+
+  function linePoint(λ, φ) {
+    var p = d3_geo_cartesian([λ * d3_radians, φ * d3_radians]);
+    if (p0) {
+      var normal = d3_geo_cartesianCross(p0, p),
+          equatorial = [normal[1], -normal[0], 0],
+          inflection = d3_geo_cartesianCross(equatorial, normal);
+      d3_geo_cartesianNormalize(inflection);
+      inflection = d3_geo_spherical(inflection);
+      var dλ = λ - λ_,
+          s = dλ > 0 ? 1 : -1,
+          λi = inflection[0] * d3_degrees * s,
+          antimeridian = Math.abs(dλ) > 180;
+      if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+        var φi = inflection[1] * d3_degrees;
+        if (φi > φ1) φ1 = φi;
+      } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) {
+        var φi = -inflection[1] * d3_degrees;
+        if (φi < φ0) φ0 = φi;
+      } else {
+        if (φ < φ0) φ0 = φ;
+        if (φ > φ1) φ1 = φ;
+      }
+      if (antimeridian) {
+        if (λ < λ_) {
+          if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+        } else {
+          if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+        }
+      } else {
+        if (λ1 >= λ0) {
+          if (λ < λ0) λ0 = λ;
+          if (λ > λ1) λ1 = λ;
+        } else {
+          if (λ > λ_) {
+            if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ;
+          } else {
+            if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ;
+          }
+        }
+      }
+    } else {
+      point(λ, φ);
+    }
+    p0 = p, λ_ = λ;
+  }
+
+  function lineStart() { bound.point = linePoint; }
+  function lineEnd() {
+    range[0] = λ0, range[1] = λ1;
+    bound.point = point;
+    p0 = null;
+  }
+
+  function ringPoint(λ, φ) {
+    if (p0) {
+      var dλ = λ - λ_;
+      dλSum += Math.abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ;
+    } else λ__ = λ, φ__ = φ;
+    d3_geo_area.point(λ, φ);
+    linePoint(λ, φ);
+  }
+
+  function ringStart() {
+    d3_geo_area.lineStart();
+  }
+
+  function ringEnd() {
+    ringPoint(λ__, φ__);
+    d3_geo_area.lineEnd();
+    if (Math.abs(dλSum) > ε) λ0 = -(λ1 = 180);
+    range[0] = λ0, range[1] = λ1;
+    p0 = null;
+  }
+
+  // Finds the left-right distance between two longitudes.
+  // This is almost the same as (λ1 - λ0 + 360°) % 360°, except that we want
+  // the distance between ±180° to be 360°.
+  function angle(λ0, λ1) { return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1; }
+
+  function compareRanges(a, b) { return a[0] - b[0]; }
+
+  function withinRange(x, range) {
+    return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+  }
+
+  return function(feature) {
+    φ1 = λ1 = -(λ0 = φ0 = Infinity);
+    ranges = [];
+
+    d3.geo.stream(feature, bound);
+
+    var n = ranges.length;
+    if (n) {
+      // First, sort ranges by their minimum longitudes.
+      ranges.sort(compareRanges);
+
+      // Then, merge any ranges that overlap.
+      for (var i = 1, a = ranges[0], b, merged = [a]; i < n; ++i) {
+        b = ranges[i];
+        if (withinRange(b[0], a) || withinRange(b[1], a)) {
+          if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+          if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+        } else {
+          merged.push(a = b);
+        }
+      }
+
+      // Finally, find the largest gap between the merged ranges.
+      // The final bounding box will be the inverse of this gap.
+      var best = -Infinity, dλ;
+      for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) {
+        b = merged[i];
+        if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1];
+      }
+    }
+    ranges = range = null;
+
+    return λ0 === Infinity || φ0 === Infinity
+        ? [[NaN, NaN], [NaN, NaN]]
+        : [[λ0, φ0], [λ1, φ1]];
+  };
+})();

data/lib/stripchart/public/components/d3/src/geo/cartesian.js

@@ -0,0 +1,47 @@
+// TODO
+// cross and scale return new vectors,
+// whereas add and normalize operate in-place
+
+function d3_geo_cartesian(spherical) {
+  var λ = spherical[0],
+      φ = spherical[1],
+      cosφ = Math.cos(φ);
+  return [
+    cosφ * Math.cos(λ),
+    cosφ * Math.sin(λ),
+    Math.sin(φ)
+  ];
+}
+
+function d3_geo_cartesianDot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+function d3_geo_cartesianCross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+
+function d3_geo_cartesianAdd(a, b) {
+  a[0] += b[0];
+  a[1] += b[1];
+  a[2] += b[2];
+}
+
+function d3_geo_cartesianScale(vector, k) {
+  return [
+    vector[0] * k,
+    vector[1] * k,
+    vector[2] * k
+  ];
+}
+
+function d3_geo_cartesianNormalize(d) {
+  var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+  d[0] /= l;
+  d[1] /= l;
+  d[2] /= l;
+}

data/lib/stripchart/public/components/d3/src/geo/centroid.js

@@ -0,0 +1,149 @@
+import "../core/noop";
+import "../math/trigonometry";
+import "geo";
+import "stream";
+
+d3.geo.centroid = function(object) {
+  d3_geo_centroidW0 = d3_geo_centroidW1 =
+  d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 =
+  d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 =
+  d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0;
+  d3.geo.stream(object, d3_geo_centroid);
+
+  var x = d3_geo_centroidX2,
+      y = d3_geo_centroidY2,
+      z = d3_geo_centroidZ2,
+      m = x * x + y * y + z * z;
+
+  // If the area-weighted centroid is undefined, fall back to length-weighted centroid.
+  if (m < ε2) {
+    x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1;
+    // If the feature has zero length, fall back to arithmetic mean of point vectors.
+    if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0;
+    m = x * x + y * y + z * z;
+    // If the feature still has an undefined centroid, then return.
+    if (m < ε2) return [NaN, NaN];
+  }
+
+  return [Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees];
+};
+
+var d3_geo_centroidW0,
+    d3_geo_centroidW1,
+    d3_geo_centroidX0,
+    d3_geo_centroidY0,
+    d3_geo_centroidZ0,
+    d3_geo_centroidX1,
+    d3_geo_centroidY1,
+    d3_geo_centroidZ1,
+    d3_geo_centroidX2,
+    d3_geo_centroidY2,
+    d3_geo_centroidZ2;
+
+var d3_geo_centroid = {
+  sphere: d3_noop,
+  point: d3_geo_centroidPoint,
+  lineStart: d3_geo_centroidLineStart,
+  lineEnd: d3_geo_centroidLineEnd,
+  polygonStart: function() {
+    d3_geo_centroid.lineStart = d3_geo_centroidRingStart;
+  },
+  polygonEnd: function() {
+    d3_geo_centroid.lineStart = d3_geo_centroidLineStart;
+  }
+};
+
+// Arithmetic mean of Cartesian vectors.
+function d3_geo_centroidPoint(λ, φ) {
+  λ *= d3_radians;
+  var cosφ = Math.cos(φ *= d3_radians);
+  d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ));
+}
+
+function d3_geo_centroidPointXYZ(x, y, z) {
+  ++d3_geo_centroidW0;
+  d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0;
+  d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0;
+  d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0;
+}
+
+function d3_geo_centroidLineStart() {
+  var x0, y0, z0; // previous point
+
+  d3_geo_centroid.point = function(λ, φ) {
+    λ *= d3_radians;
+    var cosφ = Math.cos(φ *= d3_radians);
+    x0 = cosφ * Math.cos(λ);
+    y0 = cosφ * Math.sin(λ);
+    z0 = Math.sin(φ);
+    d3_geo_centroid.point = nextPoint;
+    d3_geo_centroidPointXYZ(x0, y0, z0);
+  };
+
+  function nextPoint(λ, φ) {
+    λ *= d3_radians;
+    var cosφ = Math.cos(φ *= d3_radians),
+        x = cosφ * Math.cos(λ),
+        y = cosφ * Math.sin(λ),
+        z = Math.sin(φ),
+        w = Math.atan2(
+          Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w),
+          x0 * x + y0 * y + z0 * z);
+    d3_geo_centroidW1 += w;
+    d3_geo_centroidX1 += w * (x0 + (x0 = x));
+    d3_geo_centroidY1 += w * (y0 + (y0 = y));
+    d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+    d3_geo_centroidPointXYZ(x0, y0, z0);
+  }
+}
+
+function d3_geo_centroidLineEnd() {
+  d3_geo_centroid.point = d3_geo_centroidPoint;
+}
+
+// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
+// J. Applied Mechanics 42, 239 (1975).
+function d3_geo_centroidRingStart() {
+  var λ00, φ00, // first point
+      x0, y0, z0; // previous point
+
+  d3_geo_centroid.point = function(λ, φ) {
+    λ00 = λ, φ00 = φ;
+    d3_geo_centroid.point = nextPoint;
+    λ *= d3_radians;
+    var cosφ = Math.cos(φ *= d3_radians);
+    x0 = cosφ * Math.cos(λ);
+    y0 = cosφ * Math.sin(λ);
+    z0 = Math.sin(φ);
+    d3_geo_centroidPointXYZ(x0, y0, z0);
+  };
+
+  d3_geo_centroid.lineEnd = function() {
+    nextPoint(λ00, φ00);
+    d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd;
+    d3_geo_centroid.point = d3_geo_centroidPoint;
+  };
+
+  function nextPoint(λ, φ) {
+    λ *= d3_radians;
+    var cosφ = Math.cos(φ *= d3_radians),
+        x = cosφ * Math.cos(λ),
+        y = cosφ * Math.sin(λ),
+        z = Math.sin(φ),
+        cx = y0 * z - z0 * y,
+        cy = z0 * x - x0 * z,
+        cz = x0 * y - y0 * x,
+        m = Math.sqrt(cx * cx + cy * cy + cz * cz),
+        u = x0 * x + y0 * y + z0 * z,
+        v = m && -d3_acos(u) / m, // area weight
+        w = Math.atan2(m, u); // line weight
+    d3_geo_centroidX2 += v * cx;
+    d3_geo_centroidY2 += v * cy;
+    d3_geo_centroidZ2 += v * cz;
+    d3_geo_centroidW1 += w;
+    d3_geo_centroidX1 += w * (x0 + (x0 = x));
+    d3_geo_centroidY1 += w * (y0 + (y0 = y));
+    d3_geo_centroidZ1 += w * (z0 + (z0 = z));
+    d3_geo_centroidPointXYZ(x0, y0, z0);
+  }
+}

data/lib/stripchart/public/components/d3/src/geo/circle.js

@@ -0,0 +1,81 @@
+import "../math/trigonometry";
+import "cartesian";
+import "geo";
+import "rotation";
+import "spherical";
+
+d3.geo.circle = function() {
+  var origin = [0, 0],
+      angle,
+      precision = 6,
+      interpolate;
+
+  function circle() {
+    var center = typeof origin === "function" ? origin.apply(this, arguments) : origin,
+        rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert,
+        ring = [];
+
+    interpolate(null, null, 1, {
+      point: function(x, y) {
+        ring.push(x = rotate(x, y));
+        x[0] *= d3_degrees, x[1] *= d3_degrees;
+      }
+    });
+
+    return {type: "Polygon", coordinates: [ring]};
+  }
+
+  circle.origin = function(x) {
+    if (!arguments.length) return origin;
+    origin = x;
+    return circle;
+  };
+
+  circle.angle = function(x) {
+    if (!arguments.length) return angle;
+    interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians);
+    return circle;
+  };
+
+  circle.precision = function(_) {
+    if (!arguments.length) return precision;
+    interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians);
+    return circle;
+  };
+
+  return circle.angle(90);
+};
+
+// Interpolates along a circle centered at [0°, 0°], with a given radius and
+// precision.
+function d3_geo_circleInterpolate(radius, precision) {
+  var cr = Math.cos(radius),
+      sr = Math.sin(radius);
+  return function(from, to, direction, listener) {
+    if (from != null) {
+      from = d3_geo_circleAngle(cr, from);
+      to = d3_geo_circleAngle(cr, to);
+      if (direction > 0 ? from < to: from > to) from += direction * 2 * π;
+    } else {
+      from = radius + direction * 2 * π;
+      to = radius;
+    }
+    var point;
+    for (var step = direction * precision, t = from; direction > 0 ? t > to : t < to; t -= step) {
+      listener.point((point = d3_geo_spherical([
+        cr,
+        -sr * Math.cos(t),
+        -sr * Math.sin(t)
+      ]))[0], point[1]);
+    }
+  };
+}
+
+// Signed angle of a cartesian point relative to [cr, 0, 0].
+function d3_geo_circleAngle(cr, point) {
+  var a = d3_geo_cartesian(point);
+  a[0] -= cr;
+  d3_geo_cartesianNormalize(a);
+  var angle = d3_acos(-a[1]);
+  return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI);
+}