stripchart 0.0.3

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

@@ -0,0 +1,101 @@
+import "../core/true";
+import "../math/trigonometry";
+import "clip";
+import "point-in-polygon";
+
+var d3_geo_clipAntimeridian = d3_geo_clip(
+    d3_true,
+    d3_geo_clipAntimeridianLine,
+    d3_geo_clipAntimeridianInterpolate,
+    d3_geo_clipAntimeridianPolygonContains);
+
+// Takes a line and cuts into visible segments. Return values:
+//   0: there were intersections or the line was empty.
+//   1: no intersections.
+//   2: there were intersections, and the first and last segments should be
+//      rejoined.
+function d3_geo_clipAntimeridianLine(listener) {
+  var λ0 = NaN,
+      φ0 = NaN,
+      sλ0 = NaN,
+      clean; // no intersections
+
+  return {
+    lineStart: function() {
+      listener.lineStart();
+      clean = 1;
+    },
+    point: function(λ1, φ1) {
+      var sλ1 = λ1 > 0 ? π : -π,
+          dλ = Math.abs(λ1 - λ0);
+      if (Math.abs(dλ - π) < ε) { // line crosses a pole
+        listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? π / 2 : -π / 2);
+        listener.point(sλ0, φ0);
+        listener.lineEnd();
+        listener.lineStart();
+        listener.point(sλ1, φ0);
+        listener.point( λ1, φ0);
+        clean = 0;
+      } else if (sλ0 !== sλ1 && dλ >= π) { // line crosses antimeridian
+        // handle degeneracies
+        if (Math.abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
+        if (Math.abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε;
+        φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1);
+        listener.point(sλ0, φ0);
+        listener.lineEnd();
+        listener.lineStart();
+        listener.point(sλ1, φ0);
+        clean = 0;
+      }
+      listener.point(λ0 = λ1, φ0 = φ1);
+      sλ0 = sλ1;
+    },
+    lineEnd: function() {
+      listener.lineEnd();
+      λ0 = φ0 = NaN;
+    },
+    // if there are intersections, we always rejoin the first and last segments.
+    clean: function() { return 2 - clean; }
+  };
+}
+
+function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) {
+  var cosφ0,
+      cosφ1,
+      sinλ0_λ1 = Math.sin(λ0 - λ1);
+  return Math.abs(sinλ0_λ1) > ε
+      ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1)
+                 - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0))
+                 / (cosφ0 * cosφ1 * sinλ0_λ1))
+      : (φ0 + φ1) / 2;
+}
+
+function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) {
+  var φ;
+  if (from == null) {
+    φ = direction * π / 2;
+    listener.point(-π,  φ);
+    listener.point( 0,  φ);
+    listener.point( π,  φ);
+    listener.point( π,  0);
+    listener.point( π, -φ);
+    listener.point( 0, -φ);
+    listener.point(-π, -φ);
+    listener.point(-π,  0);
+    listener.point(-π,  φ);
+  } else if (Math.abs(from[0] - to[0]) > ε) {
+    var s = (from[0] < to[0] ? 1 : -1) * π;
+    φ = direction * s / 2;
+    listener.point(-s, φ);
+    listener.point( 0, φ);
+    listener.point( s, φ);
+  } else {
+    listener.point(to[0], to[1]);
+  }
+}
+
+var d3_geo_clipAntimeridianPoint = [-π, 0];
+
+function d3_geo_clipAntimeridianPolygonContains(polygon) {
+  return d3_geo_pointInPolygon(d3_geo_clipAntimeridianPoint, polygon);
+}

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

@@ -0,0 +1,182 @@
+import "../math/trigonometry";
+import "cartesian";
+import "clip";
+import "circle";
+import "spherical";
+import "point-in-polygon";
+
+// Clip features against a small circle centered at [0°, 0°].
+function d3_geo_clipCircle(radius) {
+  var cr = Math.cos(radius),
+      smallRadius = cr > 0,
+      point = [radius, 0],
+      notHemisphere = Math.abs(cr) > ε, // TODO optimise for this common case
+      interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
+
+  return d3_geo_clip(visible, clipLine, interpolate, polygonContains);
+
+  function visible(λ, φ) {
+    return Math.cos(λ) * Math.cos(φ) > cr;
+  }
+
+  // Takes a line and cuts into visible segments. Return values used for
+  // polygon clipping:
+  //   0: there were intersections or the line was empty.
+  //   1: no intersections.
+  //   2: there were intersections, and the first and last segments should be
+  //      rejoined.
+  function clipLine(listener) {
+    var point0, // previous point
+        c0, // code for previous point
+        v0, // visibility of previous point
+        v00, // visibility of first point
+        clean; // no intersections
+    return {
+      lineStart: function() {
+        v00 = v0 = false;
+        clean = 1;
+      },
+      point: function(λ, φ) {
+        var point1 = [λ, φ],
+            point2,
+            v = visible(λ, φ),
+            c = smallRadius
+              ? v ? 0 : code(λ, φ)
+              : v ? code(λ + (λ < 0 ? π : -π), φ) : 0;
+        if (!point0 && (v00 = v0 = v)) listener.lineStart();
+        // Handle degeneracies.
+        // TODO ignore if not clipping polygons.
+        if (v !== v0) {
+          point2 = intersect(point0, point1);
+          if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) {
+            point1[0] += ε;
+            point1[1] += ε;
+            v = visible(point1[0], point1[1]);
+          }
+        }
+        if (v !== v0) {
+          clean = 0;
+          if (v) {
+            // outside going in
+            listener.lineStart();
+            point2 = intersect(point1, point0);
+            listener.point(point2[0], point2[1]);
+          } else {
+            // inside going out
+            point2 = intersect(point0, point1);
+            listener.point(point2[0], point2[1]);
+            listener.lineEnd();
+          }
+          point0 = point2;
+        } else if (notHemisphere && point0 && smallRadius ^ v) {
+          var t;
+          // If the codes for two points are different, or are both zero,
+          // and there this segment intersects with the small circle.
+          if (!(c & c0) && (t = intersect(point1, point0, true))) {
+            clean = 0;
+            if (smallRadius) {
+              listener.lineStart();
+              listener.point(t[0][0], t[0][1]);
+              listener.point(t[1][0], t[1][1]);
+              listener.lineEnd();
+            } else {
+              listener.point(t[1][0], t[1][1]);
+              listener.lineEnd();
+              listener.lineStart();
+              listener.point(t[0][0], t[0][1]);
+            }
+          }
+        }
+        if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) {
+          listener.point(point1[0], point1[1]);
+        }
+        point0 = point1, v0 = v, c0 = c;
+      },
+      lineEnd: function() {
+        if (v0) listener.lineEnd();
+        point0 = null;
+      },
+      // Rejoin first and last segments if there were intersections and the first
+      // and last points were visible.
+      clean: function() { return clean | ((v00 && v0) << 1); }
+    };
+  }
+
+  // Intersects the great circle between a and b with the clip circle.
+  function intersect(a, b, two) {
+    var pa = d3_geo_cartesian(a),
+        pb = d3_geo_cartesian(b);
+
+    // We have two planes, n1.p = d1 and n2.p = d2.
+    // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2).
+    var n1 = [1, 0, 0], // normal
+        n2 = d3_geo_cartesianCross(pa, pb),
+        n2n2 = d3_geo_cartesianDot(n2, n2),
+        n1n2 = n2[0], // d3_geo_cartesianDot(n1, n2),
+        determinant = n2n2 - n1n2 * n1n2;
+
+    // Two polar points.
+    if (!determinant) return !two && a;
+
+    var c1 =  cr * n2n2 / determinant,
+        c2 = -cr * n1n2 / determinant,
+        n1xn2 = d3_geo_cartesianCross(n1, n2),
+        A = d3_geo_cartesianScale(n1, c1),
+        B = d3_geo_cartesianScale(n2, c2);
+    d3_geo_cartesianAdd(A, B);
+
+    // Solve |p(t)|^2 = 1.
+    var u = n1xn2,
+        w = d3_geo_cartesianDot(A, u),
+        uu = d3_geo_cartesianDot(u, u),
+        t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1);
+
+    if (t2 < 0) return;
+
+    var t = Math.sqrt(t2),
+        q = d3_geo_cartesianScale(u, (-w - t) / uu);
+    d3_geo_cartesianAdd(q, A);
+    q = d3_geo_spherical(q);
+    if (!two) return q;
+
+    // Two intersection points.
+    var λ0 = a[0],
+        λ1 = b[0],
+        φ0 = a[1],
+        φ1 = b[1],
+        z;
+    if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z;
+    var δλ = λ1 - λ0,
+        polar = Math.abs(δλ - π) < ε,
+        meridian = polar || δλ < ε;
+
+    if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z;
+
+    // Check that the first point is between a and b.
+    if (meridian
+        ? polar
+          ? φ0 + φ1 > 0 ^ q[1] < (Math.abs(q[0] - λ0) < ε ? φ0 : φ1)
+          : φ0 <= q[1] && q[1] <= φ1
+        : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) {
+      var q1 = d3_geo_cartesianScale(u, (-w + t) / uu);
+      d3_geo_cartesianAdd(q1, A);
+      return [q, d3_geo_spherical(q1)];
+    }
+  }
+
+  // Generates a 4-bit vector representing the location of a point relative to
+  // the small circle's bounding box.
+  function code(λ, φ) {
+    var r = smallRadius ? radius : π - radius,
+        code = 0;
+    if (λ < -r) code |= 1; // left
+    else if (λ > r) code |= 2; // right
+    if (φ < -r) code |= 4; // below
+    else if (φ > r) code |= 8; // above
+    return code;
+  }
+
+  function polygonContains(polygon) {
+    return d3_geo_pointInPolygon(point, polygon);
+  }
+}

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

@@ -0,0 +1,94 @@
+import "../math/trigonometry";
+import "spherical";
+
+// General spherical polygon clipping algorithm: takes a polygon, cuts it into
+// visible line segments and rejoins the segments by interpolating along the
+// clip edge.
+function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) {
+  var subject = [],
+      clip = [];
+
+  segments.forEach(function(segment) {
+    if ((n = segment.length - 1) <= 0) return;
+    var n, p0 = segment[0], p1 = segment[n];
+
+    // If the first and last points of a segment are coincident, then treat as
+    // a closed ring.
+    // TODO if all rings are closed, then the winding order of the exterior
+    // ring should be checked.
+    if (d3_geo_sphericalEqual(p0, p1)) {
+      listener.lineStart();
+      for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
+      listener.lineEnd();
+      return;
+    }
+
+    var a = {point: p0, points: segment, other: null, visited: false, entry: true, subject: true},
+        b = {point: p0, points: [p0], other: a, visited: false, entry: false, subject: false};
+    a.other = b;
+    subject.push(a);
+    clip.push(b);
+    a = {point: p1, points: [p1], other: null, visited: false, entry: false, subject: true};
+    b = {point: p1, points: [p1], other: a, visited: false, entry: true, subject: false};
+    a.other = b;
+    subject.push(a);
+    clip.push(b);
+  });
+  clip.sort(compare);
+  d3_geo_clipPolygonLinkCircular(subject);
+  d3_geo_clipPolygonLinkCircular(clip);
+  if (!subject.length) return;
+
+  if (inside) for (var i = 1, e = !inside(clip[0].point), n = clip.length; i < n; ++i) {
+    clip[i].entry = (e = !e);
+  }
+
+  var start = subject[0],
+      current,
+      points,
+      point;
+  while (1) {
+    // Find first unvisited intersection.
+    current = start;
+    while (current.visited) if ((current = current.next) === start) return;
+    points = current.points;
+    listener.lineStart();
+    do {
+      current.visited = current.other.visited = true;
+      if (current.entry) {
+        if (current.subject) {
+          for (var i = 0; i < points.length; i++) listener.point((point = points[i])[0], point[1]);
+        } else {
+          interpolate(current.point, current.next.point, 1, listener);
+        }
+        current = current.next;
+      } else {
+        if (current.subject) {
+          points = current.prev.points;
+          for (var i = points.length; --i >= 0;) listener.point((point = points[i])[0], point[1]);
+        } else {
+          interpolate(current.point, current.prev.point, -1, listener);
+        }
+        current = current.prev;
+      }
+      current = current.other;
+      points = current.points;
+    } while (!current.visited);
+    listener.lineEnd();
+  }
+}
+
+function d3_geo_clipPolygonLinkCircular(array) {
+  if (!(n = array.length)) return;
+  var n,
+      i = 0,
+      a = array[0],
+      b;
+  while (++i < n) {
+    a.next = b = array[i];
+    b.prev = a;
+    a = b;
+  }
+  a.next = b = array[0];
+  b.prev = a;
+}

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

@@ -0,0 +1,212 @@
+import "../arrays/merge";
+import "../math/trigonometry";
+import "clip";
+import "clip-polygon";
+
+var d3_geo_clipViewMAX = 1e9;
+
+function d3_geo_clipView(x0, y0, x1, y1) {
+  return function(listener) {
+    var listener_ = listener,
+        bufferListener = d3_geo_clipBufferListener(),
+        segments,
+        polygon,
+        ring;
+
+    var clip = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        listener = bufferListener;
+        segments = [];
+        polygon = [];
+      },
+      polygonEnd: function() {
+        listener = listener_;
+        if ((segments = d3.merge(segments)).length) {
+          listener.polygonStart();
+          d3_geo_clipPolygon(segments, compare, inside, interpolate, listener);
+          listener.polygonEnd();
+        } else if (insidePolygon([x0, y0])) {
+          listener.polygonStart(), listener.lineStart();
+          interpolate(null, null, 1, listener);
+          listener.lineEnd(), listener.polygonEnd();
+        }
+        segments = polygon = ring = null;
+      }
+    };
+
+    function inside(point) {
+      var a = corner(point, -1),
+          i = insidePolygon([a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0]);
+      return i;
+    }
+
+    function insidePolygon(p) {
+      var wn = 0, // the winding number counter
+          n = polygon.length,
+          y = p[1];
+
+      for (var i = 0; i < n; ++i) {
+        for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) {
+          b = v[j];
+          if (a[1] <= y) {
+            if (b[1] >  y && isLeft(a, b, p) > 0) ++wn;
+          } else {
+            if (b[1] <= y && isLeft(a, b, p) < 0) --wn;
+          }
+          a = b;
+        }
+      }
+      return wn !== 0;
+    }
+
+    function isLeft(a, b, c) {
+      return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
+    }
+
+    function interpolate(from, to, direction, listener) {
+      var a = 0, a1 = 0;
+      if (from == null ||
+          (a = corner(from, direction)) !== (a1 = corner(to, direction)) ||
+          comparePoints(from, to) < 0 ^ direction > 0) {
+        do {
+          listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0);
+        } while ((a = (a + direction + 4) % 4) !== a1);
+      } else {
+        listener.point(to[0], to[1]);
+      }
+    }
+
+    function visible(x, y) {
+      return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+    }
+
+    function point(x, y) {
+      if (visible(x, y)) listener.point(x, y);
+    }
+
+    var x__, y__, v__, // first point
+        x_, y_, v_, // previous point
+        first;
+
+    function lineStart() {
+      clip.point = linePoint;
+      if (polygon) polygon.push(ring = []);
+      first = true;
+      v_ = false;
+      x_ = y_ = NaN;
+    }
+
+    function lineEnd() {
+      // TODO rather than special-case polygons, simply handle them separately.
+      // Ideally, coincident intersection points should be jittered to avoid
+      // clipping issues.
+      if (segments) {
+        linePoint(x__, y__);
+        if (v__ && v_) bufferListener.rejoin();
+        segments.push(bufferListener.buffer());
+      }
+      clip.point = point;
+      if (v_) listener.lineEnd();
+    }
+
+    function linePoint(x, y) {
+      x = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, x));
+      y = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, y));
+      var v = visible(x, y);
+      if (polygon) ring.push([x, y]);
+      if (first) {
+        x__ = x, y__ = y, v__ = v;
+        first = false;
+        if (v) {
+          listener.lineStart();
+          listener.point(x, y);
+        }
+      } else {
+        if (v && v_) listener.point(x, y);
+        else {
+          var a = [x_, y_],
+              b = [x, y];
+          if (clipLine(a, b)) {
+            if (!v_) {
+              listener.lineStart();
+              listener.point(a[0], a[1]);
+            }
+            listener.point(b[0], b[1]);
+            if (!v) listener.lineEnd();
+          } else if (v) {
+            listener.lineStart();
+            listener.point(x, y);
+          }
+        }
+      }
+      x_ = x, y_ = y, v_ = v;
+    }
+
+    return clip;
+  };
+
+  function corner(p, direction) {
+    return Math.abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3
+        : Math.abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1
+        : Math.abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0
+        : direction > 0 ? 3 : 2; // Math.abs(p[1] - y1) < ε
+  }
+
+  function compare(a, b) {
+    return comparePoints(a.point, b.point);
+  }
+
+  function comparePoints(a, b) {
+    var ca = corner(a, 1),
+        cb = corner(b, 1);
+    return ca !== cb ? ca - cb
+        : ca === 0 ? b[1] - a[1]
+        : ca === 1 ? a[0] - b[0]
+        : ca === 2 ? a[1] - b[1]
+        : b[0] - a[0];
+  }
+
+  // Liang–Barsky line clipping.
+  function clipLine(a, b) {
+    var dx = b[0] - a[0],
+        dy = b[1] - a[1],
+        t = [0, 1];
+
+    if (Math.abs(dx) < ε && Math.abs(dy) < ε) return x0 <= a[0] && a[0] <= x1 && y0 <= a[1] && a[1] <= y1;
+
+    if (d3_geo_clipViewT(x0 - a[0],  dx, t) &&
+        d3_geo_clipViewT(a[0] - x1, -dx, t) &&
+        d3_geo_clipViewT(y0 - a[1],  dy, t) &&
+        d3_geo_clipViewT(a[1] - y1, -dy, t)) {
+      if (t[1] < 1) {
+        b[0] = a[0] + t[1] * dx;
+        b[1] = a[1] + t[1] * dy;
+      }
+      if (t[0] > 0) {
+        a[0] += t[0] * dx;
+        a[1] += t[0] * dy;
+      }
+      return true;
+    }
+
+    return false;
+  }
+}
+
+function d3_geo_clipViewT(num, denominator, t) {
+  if (Math.abs(denominator) < ε) return num <= 0;
+
+  var u = num / denominator;
+
+  if (denominator > 0) {
+    if (u > t[1]) return false;
+    if (u > t[0]) t[0] = u;
+  } else {
+    if (u < t[0]) return false;
+    if (u < t[1]) t[1] = u;
+  }
+  return true;
+}