stripchart 0.0.3

data/lib/stripchart/public/components/d3/src/geo/point-in-polygon.js

@@ -0,0 +1,71 @@
+import "geo";
+import "area";
+import "cartesian";
+import "../math/trigonometry";
+
+function d3_geo_pointInPolygon(point, polygon) {
+  var meridian = point[0],
+      parallel = point[1],
+      meridianNormal = [Math.sin(meridian), -Math.cos(meridian), 0],
+      polarAngle = 0,
+      polar = false,
+      southPole = false,
+      winding = 0;
+  d3_geo_areaRingSum.reset();
+
+  for (var i = 0, n = polygon.length; i < n; ++i) {
+    var ring = polygon[i],
+        m = ring.length;
+    if (!m) continue;
+    var point0 = ring[0],
+        λ0 = point0[0],
+        φ0 = point0[1] / 2 + π / 4,
+        sinφ0 = Math.sin(φ0),
+        cosφ0 = Math.cos(φ0),
+        j = 1;
+
+    while (true) {
+      if (j === m) j = 0;
+      point = ring[j];
+      var λ = point[0],
+          φ = point[1] / 2 + π / 4,
+          sinφ = Math.sin(φ),
+          cosφ = Math.cos(φ),
+          dλ = λ - λ0,
+          antimeridian = Math.abs(dλ) > π,
+          k = sinφ0 * sinφ;
+      d3_geo_areaRingSum.add(Math.atan2(k * Math.sin(dλ), cosφ0 * cosφ + k * Math.cos(dλ)));
+
+      if (Math.abs(φ) < ε) southPole = true;
+      polarAngle += antimeridian ? dλ + (dλ >= 0 ? 2 : -2) * π : dλ;
+
+      // Are the longitudes either side of the point's meridian, and are the
+      // latitudes smaller than the parallel?
+      if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) {
+        var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point));
+        d3_geo_cartesianNormalize(arc);
+        var intersection = d3_geo_cartesianCross(meridianNormal, arc);
+        d3_geo_cartesianNormalize(intersection);
+        var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]);
+        if (parallel > φarc) {
+          winding += antimeridian ^ dλ >= 0 ? 1 : -1;
+        }
+      }
+      if (!j++) break;
+      λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point;
+    }
+    if (Math.abs(polarAngle) > ε) polar = true;
+  }
+
+  // First, determine whether the South pole is inside or outside:
+  //
+  // It is inside if:
+  // * the polygon doesn't wind around it, and its area is negative (counter-clockwise).
+  // * otherwise, if the polygon winds around it in a clockwise direction.
+  //
+  // Second, count the (signed) number of times a segment crosses a meridian
+  // from the point to the South pole.  If it is zero, then the point is the
+  // same side as the South pole.
+
+  return (!southPole && !polar && d3_geo_areaRingSum < 0 || polarAngle < -ε) ^ (winding & 1);
+}

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

@@ -0,0 +1,132 @@
+import "../core/identity";
+import "../core/rebind";
+import "../math/trigonometry";
+import "clip-antimeridian";
+import "clip-circle";
+import "clip-view";
+import "compose";
+import "geo";
+import "path";
+import "resample";
+import "rotation";
+import "stream";
+
+d3.geo.projection = d3_geo_projection;
+d3.geo.projectionMutator = d3_geo_projectionMutator;
+
+function d3_geo_projection(project) {
+  return d3_geo_projectionMutator(function() { return project; })();
+}
+
+function d3_geo_projectionMutator(projectAt) {
+  var project,
+      rotate,
+      projectRotate,
+      projectResample = d3_geo_resample(function(x, y) { x = project(x, y); return [x[0] * k + δx, δy - x[1] * k]; }),
+      k = 150, // scale
+      x = 480, y = 250, // translate
+      λ = 0, φ = 0, // center
+      δλ = 0, δφ = 0, δγ = 0, // rotate
+      δx, δy, // center
+      preclip = d3_geo_clipAntimeridian,
+      postclip = d3_identity,
+      clipAngle = null,
+      clipExtent = null,
+      stream;
+
+  function projection(point) {
+    point = projectRotate(point[0] * d3_radians, point[1] * d3_radians);
+    return [point[0] * k + δx, δy - point[1] * k];
+  }
+
+  function invert(point) {
+    point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k);
+    return point && [point[0] * d3_degrees, point[1] * d3_degrees];
+  }
+
+  projection.stream = function(output) {
+    if (stream) stream.valid = false;
+    stream = d3_geo_projectionRadiansRotate(rotate, preclip(projectResample(postclip(output))));
+    stream.valid = true; // allow caching by d3.geo.path
+    return stream;
+  };
+
+  projection.clipAngle = function(_) {
+    if (!arguments.length) return clipAngle;
+    preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians);
+    return invalidate();
+  };
+
+  projection.clipExtent = function(_) {
+    if (!arguments.length) return clipExtent;
+    clipExtent = _;
+    postclip = _ == null ? d3_identity : d3_geo_clipView(_[0][0], _[0][1], _[1][0], _[1][1]);
+    return invalidate();
+  };
+
+  projection.scale = function(_) {
+    if (!arguments.length) return k;
+    k = +_;
+    return reset();
+  };
+
+  projection.translate = function(_) {
+    if (!arguments.length) return [x, y];
+    x = +_[0];
+    y = +_[1];
+    return reset();
+  };
+
+  projection.center = function(_) {
+    if (!arguments.length) return [λ * d3_degrees, φ * d3_degrees];
+    λ = _[0] % 360 * d3_radians;
+    φ = _[1] % 360 * d3_radians;
+    return reset();
+  };
+
+  projection.rotate = function(_) {
+    if (!arguments.length) return [δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees];
+    δλ = _[0] % 360 * d3_radians;
+    δφ = _[1] % 360 * d3_radians;
+    δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0;
+    return reset();
+  };
+
+  d3.rebind(projection, projectResample, "precision");
+
+  function reset() {
+    projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project);
+    var center = project(λ, φ);
+    δx = x - center[0] * k;
+    δy = y + center[1] * k;
+    return invalidate();
+  }
+
+  function invalidate() {
+    if (stream) {
+      stream.valid = false;
+      stream = null;
+    }
+    return projection;
+  }
+
+  return function() {
+    project = projectAt.apply(this, arguments);
+    projection.invert = project.invert && invert;
+    return reset();
+  };
+}
+
+function d3_geo_projectionRadiansRotate(rotate, stream) {
+  return {
+    point: function(x, y) {
+      y = rotate(x * d3_radians, y * d3_radians), x = y[0];
+      stream.point(x > π ? x - 2 * π : x < -π ? x + 2 * π : x, y[1]);
+    },
+    sphere: function() { stream.sphere(); },
+    lineStart: function() { stream.lineStart(); },
+    lineEnd: function() { stream.lineEnd(); },
+    polygonStart: function() { stream.polygonStart(); },
+    polygonEnd: function() { stream.polygonEnd(); }
+  };
+}

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

@@ -0,0 +1,98 @@
+import "../math/trigonometry";
+import "cartesian";
+import "stream";
+
+function d3_geo_resample(project) {
+  var δ2 = .5, // precision, px²
+      cosMinDistance = Math.cos(30 * d3_radians), // cos(minimum angular distance)
+      maxDepth = 16;
+
+  function resample(stream) {
+    var λ00, φ00, x00, y00, a00, b00, c00, // first point
+        λ0, x0, y0, a0, b0, c0; // previous point
+
+    var resample = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() { stream.polygonStart(); resample.lineStart = ringStart; },
+      polygonEnd: function() { stream.polygonEnd(); resample.lineStart = lineStart; }
+    };
+
+    function point(x, y) {
+      x = project(x, y);
+      stream.point(x[0], x[1]);
+    }
+
+    function lineStart() {
+      x0 = NaN;
+      resample.point = linePoint;
+      stream.lineStart();
+    }
+
+    function linePoint(λ, φ) {
+      var c = d3_geo_cartesian([λ, φ]), p = project(λ, φ);
+      resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
+      stream.point(x0, y0);
+    }
+
+    function lineEnd() {
+      resample.point = point;
+      stream.lineEnd();
+    }
+
+    function ringStart() {
+      lineStart();
+      resample.point = ringPoint;
+      resample.lineEnd = ringEnd;
+    }
+
+    function ringPoint(λ, φ) {
+      linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0;
+      resample.point = linePoint;
+    }
+
+    function ringEnd() {
+      resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream);
+      resample.lineEnd = lineEnd;
+      lineEnd();
+    }
+
+    return resample;
+  }
+
+  function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) {
+    var dx = x1 - x0,
+        dy = y1 - y0,
+        d2 = dx * dx + dy * dy;
+    if (d2 > 4 * δ2 && depth--) {
+      var a = a0 + a1,
+          b = b0 + b1,
+          c = c0 + c1,
+          m = Math.sqrt(a * a + b * b + c * c),
+          φ2 = Math.asin(c /= m),
+          λ2 = Math.abs(Math.abs(c) - 1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a),
+          p = project(λ2, φ2),
+          x2 = p[0],
+          y2 = p[1],
+          dx2 = x2 - x0,
+          dy2 = y2 - y0,
+          dz = dy * dx2 - dx * dy2;
+      if (dz * dz / d2 > δ2 // perpendicular projected distance
+          || Math.abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 // midpoint close to an end
+          || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance
+        resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream);
+        stream.point(x2, y2);
+        resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream);
+      }
+    }
+  }
+
+  resample.precision = function(_) {
+    if (!arguments.length) return Math.sqrt(δ2);
+    maxDepth = (δ2 = _ * _) > 0 && 16;
+    return resample;
+  };
+
+  return resample;
+}

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

@@ -0,0 +1,72 @@
+import "../math/trigonometry";
+import "equirectangular";
+import "geo";
+
+d3.geo.rotation = function(rotate) {
+  rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0);
+
+  function forward(coordinates) {
+    coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+    return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+  }
+
+  forward.invert = function(coordinates) {
+    coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians);
+    return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates;
+  };
+
+  return forward;
+};
+
+// Note: |δλ| must be < 2π
+function d3_geo_rotation(δλ, δφ, δγ) {
+  return δλ ? (δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ))
+    : d3_geo_rotationλ(δλ))
+    : (δφ || δγ ? d3_geo_rotationφγ(δφ, δγ)
+    : d3_geo_equirectangular);
+}
+
+function d3_geo_forwardRotationλ(δλ) {
+  return function(λ, φ) {
+    return λ += δλ, [λ > π ? λ - 2 * π : λ < -π ? λ + 2 * π : λ, φ];
+  };
+}
+
+function d3_geo_rotationλ(δλ) {
+  var rotation = d3_geo_forwardRotationλ(δλ);
+  rotation.invert = d3_geo_forwardRotationλ(-δλ);
+  return rotation;
+}
+
+function d3_geo_rotationφγ(δφ, δγ) {
+  var cosδφ = Math.cos(δφ),
+      sinδφ = Math.sin(δφ),
+      cosδγ = Math.cos(δγ),
+      sinδγ = Math.sin(δγ);
+
+  function rotation(λ, φ) {
+    var cosφ = Math.cos(φ),
+        x = Math.cos(λ) * cosφ,
+        y = Math.sin(λ) * cosφ,
+        z = Math.sin(φ),
+        k = z * cosδφ + x * sinδφ;
+    return [
+      Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ),
+      d3_asin(k * cosδγ + y * sinδγ)
+    ];
+  }
+
+  rotation.invert = function(λ, φ) {
+    var cosφ = Math.cos(φ),
+        x = Math.cos(λ) * cosφ,
+        y = Math.sin(λ) * cosφ,
+        z = Math.sin(φ),
+        k = z * cosδγ - y * sinδγ;
+    return [
+      Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ),
+      d3_asin(k * cosδφ - x * sinδφ)
+    ];
+  };
+
+  return rotation;
+}

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

@@ -0,0 +1,12 @@
+import "../math/trigonometry";
+
+function d3_geo_spherical(cartesian) {
+  return [
+    Math.atan2(cartesian[1], cartesian[0]),
+    d3_asin(cartesian[2])
+  ];
+}
+
+function d3_geo_sphericalEqual(a, b) {
+  return Math.abs(a[0] - b[0]) < ε && Math.abs(a[1] - b[1]) < ε;
+}

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

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

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

@@ -0,0 +1,71 @@
+import "geo";
+
+d3.geo.stream = function(object, listener) {
+  if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) {
+    d3_geo_streamObjectType[object.type](object, listener);
+  } else {
+    d3_geo_streamGeometry(object, listener);
+  }
+};
+
+function d3_geo_streamGeometry(geometry, listener) {
+  if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) {
+    d3_geo_streamGeometryType[geometry.type](geometry, listener);
+  }
+}
+
+var d3_geo_streamObjectType = {
+  Feature: function(feature, listener) {
+    d3_geo_streamGeometry(feature.geometry, listener);
+  },
+  FeatureCollection: function(object, listener) {
+    var features = object.features, i = -1, n = features.length;
+    while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener);
+  }
+};
+
+var d3_geo_streamGeometryType = {
+  Sphere: function(object, listener) {
+    listener.sphere();
+  },
+  Point: function(object, listener) {
+    var coordinate = object.coordinates;
+    listener.point(coordinate[0], coordinate[1]);
+  },
+  MultiPoint: function(object, listener) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length, coordinate;
+    while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]);
+  },
+  LineString: function(object, listener) {
+    d3_geo_streamLine(object.coordinates, listener, 0);
+  },
+  MultiLineString: function(object, listener) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0);
+  },
+  Polygon: function(object, listener) {
+    d3_geo_streamPolygon(object.coordinates, listener);
+  },
+  MultiPolygon: function(object, listener) {
+    var coordinates = object.coordinates, i = -1, n = coordinates.length;
+    while (++i < n) d3_geo_streamPolygon(coordinates[i], listener);
+  },
+  GeometryCollection: function(object, listener) {
+    var geometries = object.geometries, i = -1, n = geometries.length;
+    while (++i < n) d3_geo_streamGeometry(geometries[i], listener);
+  }
+};
+
+function d3_geo_streamLine(coordinates, listener, closed) {
+  var i = -1, n = coordinates.length - closed, coordinate;
+  listener.lineStart();
+  while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]);
+  listener.lineEnd();
+}
+
+function d3_geo_streamPolygon(coordinates, listener) {
+  var i = -1, n = coordinates.length;
+  listener.polygonStart();
+  while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1);
+  listener.polygonEnd();
+}