stripchart 0.0.3

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

@@ -0,0 +1,135 @@
+import "../arrays/merge";
+import "../core/noop";
+import "../math/trigonometry";
+import "clip-polygon";
+
+function d3_geo_clip(pointVisible, clipLine, interpolate, polygonContains) {
+  return function(listener) {
+    var line = clipLine(listener);
+
+    var clip = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        clip.point = pointRing;
+        clip.lineStart = ringStart;
+        clip.lineEnd = ringEnd;
+        segments = [];
+        polygon = [];
+        listener.polygonStart();
+      },
+      polygonEnd: function() {
+        clip.point = point;
+        clip.lineStart = lineStart;
+        clip.lineEnd = lineEnd;
+
+        segments = d3.merge(segments);
+        if (segments.length) {
+          d3_geo_clipPolygon(segments, d3_geo_clipSort, null, interpolate, listener);
+        } else if (polygonContains(polygon)) {
+          listener.lineStart();
+          interpolate(null, null, 1, listener);
+          listener.lineEnd();
+        }
+        listener.polygonEnd();
+        segments = polygon = null;
+      },
+      sphere: function() {
+        listener.polygonStart();
+        listener.lineStart();
+        interpolate(null, null, 1, listener);
+        listener.lineEnd();
+        listener.polygonEnd();
+      }
+    };
+
+    function point(λ, φ) { if (pointVisible(λ, φ)) listener.point(λ, φ); }
+    function pointLine(λ, φ) { line.point(λ, φ); }
+    function lineStart() { clip.point = pointLine; line.lineStart(); }
+    function lineEnd() { clip.point = point; line.lineEnd(); }
+
+    var segments;
+
+    var buffer = d3_geo_clipBufferListener(),
+        ringListener = clipLine(buffer),
+        polygon,
+        ring;
+
+    function pointRing(λ, φ) {
+      ringListener.point(λ, φ);
+      ring.push([λ, φ]);
+    }
+
+    function ringStart() {
+      ringListener.lineStart();
+      ring = [];
+    }
+
+    function ringEnd() {
+      pointRing(ring[0][0], ring[0][1]);
+      ringListener.lineEnd();
+
+      var clean = ringListener.clean(),
+          ringSegments = buffer.buffer(),
+          segment,
+          n = ringSegments.length;
+
+      ring.pop();
+      polygon.push(ring);
+      ring = null;
+
+      if (!n) return;
+
+      // No intersections.
+      if (clean & 1) {
+        segment = ringSegments[0];
+        var n = segment.length - 1,
+            i = -1,
+            point;
+        listener.lineStart();
+        while (++i < n) listener.point((point = segment[i])[0], point[1]);
+        listener.lineEnd();
+        return;
+      }
+
+      // Rejoin connected segments.
+      // TODO reuse bufferListener.rejoin()?
+      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+
+      segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
+    }
+
+    return clip;
+  };
+}
+
+function d3_geo_clipSegmentLength1(segment) {
+  return segment.length > 1;
+}
+
+function d3_geo_clipBufferListener() {
+  var lines = [],
+      line;
+  return {
+    lineStart: function() { lines.push(line = []); },
+    point: function(λ, φ) { line.push([λ, φ]); },
+    lineEnd: d3_noop,
+    buffer: function() {
+      var buffer = lines;
+      lines = [];
+      line = null;
+      return buffer;
+    },
+    rejoin: function() {
+      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+    }
+  };
+}
+
+// Intersection points are sorted along the clip edge. For both antimeridian
+// cutting and circle clipping, the same comparison is used.
+function d3_geo_clipSort(a, b) {
+  return ((a = a.point)[0] < 0 ? a[1] - π / 2 - ε : π / 2 - a[1])
+       - ((b = b.point)[0] < 0 ? b[1] - π / 2 - ε : π / 2 - b[1]);
+}

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

@@ -0,0 +1,12 @@
+function d3_geo_compose(a, b) {
+
+  function compose(x, y) {
+    return x = a(x, y), b(x[0], x[1]);
+  }
+
+  if (a.invert && b.invert) compose.invert = function(x, y) {
+    return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+  };
+
+  return compose;
+}

data/lib/stripchart/public/components/d3/src/geo/conic-conformal.js

@@ -0,0 +1,36 @@
+import "../math/trigonometry";
+import "conic";
+import "geo";
+import "projection";
+
+function d3_geo_conicConformal(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      t = function(φ) { return Math.tan(π / 4 + φ / 2); },
+      n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)),
+      F = cosφ0 * Math.pow(t(φ0), n) / n;
+
+  if (!n) return d3_geo_mercator;
+
+  function forward(λ, φ) {
+    var ρ = Math.abs(Math.abs(φ) - π / 2) < ε ? 0 : F / Math.pow(t(φ), n);
+    return [
+      ρ * Math.sin(n * λ),
+      F - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = F - y,
+        ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      2 * Math.atan(Math.pow(F / ρ, 1 / n)) - π / 2
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicConformal = function() {
+  return d3_geo_conic(d3_geo_conicConformal);
+}).raw = d3_geo_conicConformal;

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

@@ -0,0 +1,33 @@
+import "../math/trigonometry";
+import "geo";
+import "conic";
+import "projection";
+
+function d3_geo_conicEqualArea(φ0, φ1) {
+  var sinφ0 = Math.sin(φ0),
+      n = (sinφ0 + Math.sin(φ1)) / 2,
+      C = 1 + sinφ0 * (2 * n - sinφ0),
+      ρ0 = Math.sqrt(C) / n;
+
+  function forward(λ, φ) {
+    var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
+    return [
+      ρ * Math.sin(λ *= n),
+      ρ0 - ρ * Math.cos(λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = ρ0 - y;
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n))
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicEqualArea = function() {
+  return d3_geo_conic(d3_geo_conicEqualArea);
+}).raw = d3_geo_conicEqualArea;

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

@@ -0,0 +1,35 @@
+import "../math/trigonometry";
+import "conic";
+import "equirectangular";
+import "geo";
+import "projection";
+
+function d3_geo_conicEquidistant(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0),
+      G = cosφ0 / n + φ0;
+
+  if (Math.abs(n) < ε) return d3_geo_equirectangular;
+
+  function forward(λ, φ) {
+    var ρ = G - φ;
+    return [
+      ρ * Math.sin(n * λ),
+      G - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = G - y;
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y)
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicEquidistant = function() {
+  return d3_geo_conic(d3_geo_conicEquidistant);
+}).raw = d3_geo_conicEquidistant;

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

@@ -0,0 +1,16 @@
+import "../math/trigonometry";
+import "projection";
+
+function d3_geo_conic(projectAt) {
+  var φ0 = 0,
+      φ1 = π / 3,
+      m = d3_geo_projectionMutator(projectAt),
+      p = m(φ0, φ1);
+
+  p.parallels = function(_) {
+    if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180];
+    return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+  };
+
+  return p;
+}

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

@@ -0,0 +1,13 @@
+import "../math/trigonometry";
+import "geo";
+
+// Length returned in radians; multiply by radius for distance.
+d3.geo.distance = function(a, b) {
+  var Δλ = (b[0] - a[0]) * d3_radians,
+      φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians,
+      sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ),
+      sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0),
+      sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1),
+      t;
+  return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
+};

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

@@ -0,0 +1,10 @@
+import "geo";
+import "projection";
+
+function d3_geo_equirectangular(λ, φ) {
+  return [λ, φ];
+}
+
+(d3.geo.equirectangular = function() {
+  return d3_geo_projection(d3_geo_equirectangular);
+}).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;

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

@@ -0,0 +1 @@
+d3.geo = {};

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

@@ -0,0 +1,12 @@
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_gnomonic = d3_geo_azimuthal(
+  function(cosλcosφ) { return 1 / cosλcosφ; },
+  Math.atan
+);
+
+(d3.geo.gnomonic = function() {
+  return d3_geo_projection(d3_geo_gnomonic);
+}).raw = d3_geo_gnomonic;

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

@@ -0,0 +1,102 @@
+import "../arrays/range";
+import "../math/trigonometry";
+import "geo";
+
+d3.geo.graticule = function() {
+  var x1, x0, X1, X0,
+      y1, y0, Y1, Y0,
+      dx = 10, dy = dx, DX = 90, DY = 360,
+      x, y, X, Y,
+      precision = 2.5;
+
+  function graticule() {
+    return {type: "MultiLineString", coordinates: lines()};
+  }
+
+  function lines() {
+    return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X)
+        .concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y))
+        .concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return Math.abs(x % DX) > ε; }).map(x))
+        .concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return Math.abs(y % DY) > ε; }).map(y));
+  }
+
+  graticule.lines = function() {
+    return lines().map(function(coordinates) { return {type: "LineString", coordinates: coordinates}; });
+  };
+
+  graticule.outline = function() {
+    return {
+      type: "Polygon",
+      coordinates: [
+        X(X0).concat(
+        Y(Y1).slice(1),
+        X(X1).reverse().slice(1),
+        Y(Y0).reverse().slice(1))
+      ]
+    };
+  };
+
+  graticule.extent = function(_) {
+    if (!arguments.length) return graticule.minorExtent();
+    return graticule.majorExtent(_).minorExtent(_);
+  };
+
+  graticule.majorExtent = function(_) {
+    if (!arguments.length) return [[X0, Y0], [X1, Y1]];
+    X0 = +_[0][0], X1 = +_[1][0];
+    Y0 = +_[0][1], Y1 = +_[1][1];
+    if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+    return graticule.precision(precision);
+  };
+
+  graticule.minorExtent = function(_) {
+    if (!arguments.length) return [[x0, y0], [x1, y1]];
+    x0 = +_[0][0], x1 = +_[1][0];
+    y0 = +_[0][1], y1 = +_[1][1];
+    if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+    if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+    return graticule.precision(precision);
+  };
+
+  graticule.step = function(_) {
+    if (!arguments.length) return graticule.minorStep();
+    return graticule.majorStep(_).minorStep(_);
+  };
+
+  graticule.majorStep = function(_) {
+    if (!arguments.length) return [DX, DY];
+    DX = +_[0], DY = +_[1];
+    return graticule;
+  };
+
+  graticule.minorStep = function(_) {
+    if (!arguments.length) return [dx, dy];
+    dx = +_[0], dy = +_[1];
+    return graticule;
+  };
+
+  graticule.precision = function(_) {
+    if (!arguments.length) return precision;
+    precision = +_;
+    x = d3_geo_graticuleX(y0, y1, 90);
+    y = d3_geo_graticuleY(x0, x1, precision);
+    X = d3_geo_graticuleX(Y0, Y1, 90);
+    Y = d3_geo_graticuleY(X0, X1, precision);
+    return graticule;
+  };
+
+  return graticule
+      .majorExtent([[-180, -90 + ε], [180, 90 - ε]])
+      .minorExtent([[-180, -80 - ε], [180, 80 + ε]]);
+};
+
+function d3_geo_graticuleX(y0, y1, dy) {
+  var y = d3.range(y0, y1 - ε, dy).concat(y1);
+  return function(x) { return y.map(function(y) { return [x, y]; }); };
+}
+
+function d3_geo_graticuleY(x0, x1, dx) {
+  var x = d3.range(x0, x1 - ε, dx).concat(x1);
+  return function(y) { return x.map(function(x) { return [x, y]; }); };
+}

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

@@ -0,0 +1,42 @@
+import "../core/source";
+import "../core/target";
+import "geo";
+import "distance";
+
+// @deprecated use {type: "LineString"} or d3.geo.distance instead.
+d3.geo.greatArc = function() {
+  var source = d3_source, source_,
+      target = d3_target, target_;
+
+  function greatArc() {
+    return {type: "LineString", coordinates: [
+      source_ || source.apply(this, arguments),
+      target_ || target.apply(this, arguments)
+    ]};
+  }
+
+  greatArc.distance = function() {
+    return d3.geo.distance(
+      source_ || source.apply(this, arguments),
+      target_ || target.apply(this, arguments)
+    );
+  };
+
+  greatArc.source = function(_) {
+    if (!arguments.length) return source;
+    source = _, source_ = typeof _ === "function" ? null : _;
+    return greatArc;
+  };
+
+  greatArc.target = function(_) {
+    if (!arguments.length) return target;
+    target = _, target_ = typeof _ === "function" ? null : _;
+    return greatArc;
+  };
+
+  greatArc.precision = function() {
+    return arguments.length ? greatArc : 0;
+  };
+
+  return greatArc;
+};