stripchart 0.0.3

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

@@ -0,0 +1,32 @@
+import "geo";
+import "area";
+import "bounds";
+import "centroid";
+import "circle";
+import "distance";
+import "graticule";
+import "greatArc";
+import "interpolate";
+import "length";
+import "path";
+import "path-area";
+import "path-buffer";
+import "path-centroid";
+import "path-context";
+import "projection";
+import "rotation";
+import "stream";
+import "albers";
+import "albers-usa";
+import "azimuthal";
+import "azimuthal-equal-area";
+import "azimuthal-equidistant";
+import "conic-conformal";
+import "conic-equal-area";
+import "conic-equidistant";
+import "equirectangular";
+import "gnomonic";
+import "mercator";
+import "orthographic";
+import "stereographic";
+import "transverse-mercator";

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

@@ -0,0 +1,38 @@
+import "../math/trigonometry";
+import "geo";
+
+d3.geo.interpolate = function(source, target) {
+  return d3_geo_interpolate(
+    source[0] * d3_radians, source[1] * d3_radians,
+    target[0] * d3_radians, target[1] * d3_radians
+  );
+};
+
+function d3_geo_interpolate(x0, y0, x1, y1) {
+  var cy0 = Math.cos(y0),
+      sy0 = Math.sin(y0),
+      cy1 = Math.cos(y1),
+      sy1 = Math.sin(y1),
+      kx0 = cy0 * Math.cos(x0),
+      ky0 = cy0 * Math.sin(x0),
+      kx1 = cy1 * Math.cos(x1),
+      ky1 = cy1 * Math.sin(x1),
+      d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))),
+      k = 1 / Math.sin(d);
+
+  var interpolate = d ? function(t) {
+    var B = Math.sin(t *= d) * k,
+        A = Math.sin(d - t) * k,
+        x = A * kx0 + B * kx1,
+        y = A * ky0 + B * ky1,
+        z = A * sy0 + B * sy1;
+    return [
+      Math.atan2(y, x) * d3_degrees,
+      Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees
+    ];
+  } : function() { return [x0 * d3_degrees, y0 * d3_degrees]; };
+
+  interpolate.distance = d;
+
+  return interpolate;
+};

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

@@ -0,0 +1,43 @@
+import "../core/noop";
+import "../math/trigonometry";
+import "geo";
+import "stream";
+
+d3.geo.length = function(object) {
+  d3_geo_lengthSum = 0;
+  d3.geo.stream(object, d3_geo_length);
+  return d3_geo_lengthSum;
+};
+
+var d3_geo_lengthSum;
+
+var d3_geo_length = {
+  sphere: d3_noop,
+  point: d3_noop,
+  lineStart: d3_geo_lengthLineStart,
+  lineEnd: d3_noop,
+  polygonStart: d3_noop,
+  polygonEnd: d3_noop
+};
+
+function d3_geo_lengthLineStart() {
+  var λ0, sinφ0, cosφ0;
+
+  d3_geo_length.point = function(λ, φ) {
+    λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
+    d3_geo_length.point = nextPoint;
+  };
+
+  d3_geo_length.lineEnd = function() {
+    d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
+  };
+
+  function nextPoint(λ, φ) {
+    var sinφ = Math.sin(φ *= d3_radians),
+        cosφ = Math.cos(φ),
+        t = Math.abs((λ *= d3_radians) - λ0),
+        cosΔλ = Math.cos(t);
+    d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
+    λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
+  }
+}

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

@@ -0,0 +1,48 @@
+import "../math/trigonometry";
+import "geo";
+import "projection";
+
+function d3_geo_mercator(λ, φ) {
+  return [λ, Math.log(Math.tan(π / 4 + φ / 2))];
+}
+
+d3_geo_mercator.invert = function(x, y) {
+  return [x, 2 * Math.atan(Math.exp(y)) - π / 2];
+};
+
+function d3_geo_mercatorProjection(project) {
+  var m = d3_geo_projection(project),
+      scale = m.scale,
+      translate = m.translate,
+      clipExtent = m.clipExtent,
+      clipAuto;
+
+  m.scale = function() {
+    var v = scale.apply(m, arguments);
+    return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
+  };
+
+  m.translate = function() {
+    var v = translate.apply(m, arguments);
+    return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
+  };
+
+  m.clipExtent = function(_) {
+    var v = clipExtent.apply(m, arguments);
+    if (v === m) {
+      if (clipAuto = _ == null) {
+        var k = π * scale(), t = translate();
+        clipExtent([[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]);
+      }
+    } else if (clipAuto) {
+      v = null;
+    }
+    return v;
+  };
+
+  return m.clipExtent(null);
+}
+
+(d3.geo.mercator = function() {
+  return d3_geo_mercatorProjection(d3_geo_mercator);
+}).raw = d3_geo_mercator;

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

@@ -0,0 +1,12 @@
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_orthographic = d3_geo_azimuthal(
+  function() { return 1; },
+  Math.asin
+);
+
+(d3.geo.orthographic = function() {
+  return d3_geo_projection(d3_geo_orthographic);
+}).raw = d3_geo_orthographic;

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

@@ -0,0 +1,40 @@
+import "../core/noop";
+
+// TODO Unify this code with d3.geom.polygon area?
+
+var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
+  point: d3_noop,
+  lineStart: d3_noop,
+  lineEnd: d3_noop,
+
+  // Only count area for polygon rings.
+  polygonStart: function() {
+    d3_geo_pathAreaPolygon = 0;
+    d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
+  },
+  polygonEnd: function() {
+    d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
+    d3_geo_pathAreaSum += Math.abs(d3_geo_pathAreaPolygon / 2);
+  }
+};
+
+function d3_geo_pathAreaRingStart() {
+  var x00, y00, x0, y0;
+
+  // For the first point, …
+  d3_geo_pathArea.point = function(x, y) {
+    d3_geo_pathArea.point = nextPoint;
+    x00 = x0 = x, y00 = y0 = y;
+  };
+
+  // For subsequent points, …
+  function nextPoint(x, y) {
+    d3_geo_pathAreaPolygon += y0 * x - x0 * y;
+    x0 = x, y0 = y;
+  }
+
+  // For the last point, return to the start.
+  d3_geo_pathArea.lineEnd = function() {
+    nextPoint(x00, y00);
+  };
+}

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

@@ -0,0 +1,21 @@
+import "../core/noop";
+
+var d3_geo_pathBoundsX0,
+    d3_geo_pathBoundsY0,
+    d3_geo_pathBoundsX1,
+    d3_geo_pathBoundsY1;
+
+var d3_geo_pathBounds = {
+  point: d3_geo_pathBoundsPoint,
+  lineStart: d3_noop,
+  lineEnd: d3_noop,
+  polygonStart: d3_noop,
+  polygonEnd: d3_noop
+};
+
+function d3_geo_pathBoundsPoint(x, y) {
+  if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
+  if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
+  if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
+  if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
+}

data/lib/stripchart/public/components/d3/src/geo/path-buffer.js

@@ -0,0 +1,59 @@
+function d3_geo_pathBuffer() {
+  var pointCircle = d3_geo_pathBufferCircle(4.5),
+      buffer = [];
+
+  var stream = {
+    point: point,
+
+    // While inside a line, override point to moveTo then lineTo.
+    lineStart: function() { stream.point = pointLineStart; },
+    lineEnd: lineEnd,
+
+    // While inside a polygon, override lineEnd to closePath.
+    polygonStart: function() { stream.lineEnd = lineEndPolygon; },
+    polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
+
+    pointRadius: function(_) {
+      pointCircle = d3_geo_pathBufferCircle(_);
+      return stream;
+    },
+
+    result: function() {
+      if (buffer.length) {
+        var result = buffer.join("");
+        buffer = [];
+        return result;
+      }
+    }
+  };
+
+  function point(x, y) {
+    buffer.push("M", x, ",", y, pointCircle);
+  }
+
+  function pointLineStart(x, y) {
+    buffer.push("M", x, ",", y);
+    stream.point = pointLine;
+  }
+
+  function pointLine(x, y) {
+    buffer.push("L", x, ",", y);
+  }
+
+  function lineEnd() {
+    stream.point = point;
+  }
+
+  function lineEndPolygon() {
+    buffer.push("Z");
+  }
+
+  return stream;
+}
+
+function d3_geo_pathBufferCircle(radius) {
+  return "m0," + radius
+      + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius
+      + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius
+      + "z";
+}

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

@@ -0,0 +1,78 @@
+import "centroid";
+
+// TODO Unify this code with d3.geom.polygon centroid?
+// TODO Enforce positive area for exterior, negative area for interior?
+
+var d3_geo_pathCentroid = {
+  point: d3_geo_pathCentroidPoint,
+
+  // For lines, weight by length.
+  lineStart: d3_geo_pathCentroidLineStart,
+  lineEnd: d3_geo_pathCentroidLineEnd,
+
+  // For polygons, weight by area.
+  polygonStart: function() {
+    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
+  },
+  polygonEnd: function() {
+    d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
+    d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
+  }
+};
+
+function d3_geo_pathCentroidPoint(x, y) {
+  d3_geo_centroidX0 += x;
+  d3_geo_centroidY0 += y;
+  ++d3_geo_centroidZ0;
+}
+
+function d3_geo_pathCentroidLineStart() {
+  var x0, y0;
+
+  d3_geo_pathCentroid.point = function(x, y) {
+    d3_geo_pathCentroid.point = nextPoint;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  };
+
+  function nextPoint(x, y) {
+    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+    d3_geo_centroidX1 += z * (x0 + x) / 2;
+    d3_geo_centroidY1 += z * (y0 + y) / 2;
+    d3_geo_centroidZ1 += z;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  }
+}
+
+function d3_geo_pathCentroidLineEnd() {
+  d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+}
+
+function d3_geo_pathCentroidRingStart() {
+  var x00, y00, x0, y0;
+
+  // For the first point, …
+  d3_geo_pathCentroid.point = function(x, y) {
+    d3_geo_pathCentroid.point = nextPoint;
+    d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
+  };
+
+  // For subsequent points, …
+  function nextPoint(x, y) {
+    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+    d3_geo_centroidX1 += z * (x0 + x) / 2;
+    d3_geo_centroidY1 += z * (y0 + y) / 2;
+    d3_geo_centroidZ1 += z;
+
+    z = y0 * x - x0 * y;
+    d3_geo_centroidX2 += z * (x0 + x);
+    d3_geo_centroidY2 += z * (y0 + y);
+    d3_geo_centroidZ2 += z * 3;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  }
+
+  // For the last point, return to the start.
+  d3_geo_pathCentroid.lineEnd = function() {
+    nextPoint(x00, y00);
+  };
+}

data/lib/stripchart/public/components/d3/src/geo/path-context.js

@@ -0,0 +1,49 @@
+import "../core/noop";
+import "../math/trigonometry";
+
+function d3_geo_pathContext(context) {
+  var pointRadius = 4.5;
+
+  var stream = {
+    point: point,
+
+    // While inside a line, override point to moveTo then lineTo.
+    lineStart: function() { stream.point = pointLineStart; },
+    lineEnd: lineEnd,
+
+    // While inside a polygon, override lineEnd to closePath.
+    polygonStart: function() { stream.lineEnd = lineEndPolygon; },
+    polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
+
+    pointRadius: function(_) {
+      pointRadius = _;
+      return stream;
+    },
+
+    result: d3_noop
+  };
+
+  function point(x, y) {
+    context.moveTo(x, y);
+    context.arc(x, y, pointRadius, 0, 2 * π);
+  }
+
+  function pointLineStart(x, y) {
+    context.moveTo(x, y);
+    stream.point = pointLine;
+  }
+
+  function pointLine(x, y) {
+    context.lineTo(x, y);
+  }
+
+  function lineEnd() {
+    stream.point = point;
+  }
+
+  function lineEndPolygon() {
+    context.closePath();
+  }
+
+  return stream;
+}

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

@@ -0,0 +1,97 @@
+import "../core/identity";
+import "../math/trigonometry";
+import "albers-usa";
+import "area";
+import "bounds";
+import "centroid";
+import "geo";
+import "path-area";
+import "path-bounds";
+import "path-buffer";
+import "path-centroid";
+import "path-context";
+import "projection";
+import "resample";
+import "stream";
+
+d3.geo.path = function() {
+  var pointRadius = 4.5,
+      projection,
+      context,
+      projectStream,
+      contextStream,
+      cacheStream;
+
+  function path(object) {
+    if (object) {
+      if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+      if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
+      d3.geo.stream(object, cacheStream);
+    }
+    return contextStream.result();
+  }
+
+  path.area = function(object) {
+    d3_geo_pathAreaSum = 0;
+    d3.geo.stream(object, projectStream(d3_geo_pathArea));
+    return d3_geo_pathAreaSum;
+  };
+
+  path.centroid = function(object) {
+    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, projectStream(d3_geo_pathCentroid));
+    return d3_geo_centroidZ2 ? [d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2]
+        : d3_geo_centroidZ1 ? [d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1]
+        : d3_geo_centroidZ0 ? [d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0]
+        : [NaN, NaN];
+  };
+
+  path.bounds = function(object) {
+    d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
+    d3.geo.stream(object, projectStream(d3_geo_pathBounds));
+    return [[d3_geo_pathBoundsX0, d3_geo_pathBoundsY0], [d3_geo_pathBoundsX1, d3_geo_pathBoundsY1]];
+  };
+
+  path.projection = function(_) {
+    if (!arguments.length) return projection;
+    projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
+    return reset();
+  };
+
+  path.context = function(_) {
+    if (!arguments.length) return context;
+    contextStream = (context = _) == null ? new d3_geo_pathBuffer : new d3_geo_pathContext(_);
+    if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+    return reset();
+  };
+
+  path.pointRadius = function(_) {
+    if (!arguments.length) return pointRadius;
+    pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+    return path;
+  };
+
+  function reset() {
+    cacheStream = null;
+    return path;
+  }
+
+  return path.projection(d3.geo.albersUsa()).context(null);
+};
+
+function d3_geo_pathProjectStream(project) {
+  var resample = d3_geo_resample(function(λ, φ) { return project([λ * d3_degrees, φ * d3_degrees]); });
+  return function(stream) {
+    stream = resample(stream);
+    return {
+      point: function(λ, φ) { stream.point(λ * d3_radians, φ * d3_radians); },
+      sphere: function() { stream.sphere(); },
+      lineStart: function() { stream.lineStart(); },
+      lineEnd: function() { stream.lineEnd(); },
+      polygonStart: function() { stream.polygonStart(); },
+      polygonEnd: function() { stream.polygonEnd(); }
+    };
+  };
+}