mdarray-sol 0.1.0-java

data/node_modules/dc/node_modules/d3/src/geo/clip-antimeridian.js

@@ -0,0 +1,95 @@
+import "../core/true";
+import "../math/abs";
+import "../math/trigonometry";
+import "clip";
+
+var d3_geo_clipAntimeridian = d3_geo_clip(
+    d3_true,
+    d3_geo_clipAntimeridianLine,
+    d3_geo_clipAntimeridianInterpolate,
+    [-π, -π / 2]);
+
+// 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λ = abs(λ1 - λ0);
+      if (abs(dλ - π) < ε) { // line crosses a pole
+        listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ);
+        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 (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε;
+        if (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 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 * halfπ;
+    listener.point(-π,  φ);
+    listener.point( 0,  φ);
+    listener.point( π,  φ);
+    listener.point( π,  0);
+    listener.point( π, -φ);
+    listener.point( 0, -φ);
+    listener.point(-π, -φ);
+    listener.point(-π,  0);
+    listener.point(-π,  φ);
+  } else if (abs(from[0] - to[0]) > ε) {
+    var s = from[0] < to[0] ? π : -π;
+    φ = direction * s / 2;
+    listener.point(-s, φ);
+    listener.point( 0, φ);
+    listener.point( s, φ);
+  } else {
+    listener.point(to[0], to[1]);
+  }
+}

data/node_modules/dc/node_modules/d3/src/geo/clip-circle.js

@@ -0,0 +1,178 @@
+import "../math/abs";
+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,
+      notHemisphere = abs(cr) > ε, // TODO optimise for this common case
+      interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians);
+
+  return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-π, radius - π]);
+
+  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 = 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] < (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;
+  }
+}

data/node_modules/dc/node_modules/d3/src/geo/clip-extent.js

@@ -0,0 +1,196 @@
+import "../arrays/merge";
+import "../math/abs";
+import "../math/trigonometry";
+import "../geom/clip-line";
+import "geo";
+import "clip";
+import "clip-polygon";
+
+var d3_geo_clipExtentMAX = 1e9;
+
+d3.geo.clipExtent = function() {
+  var x0, y0, x1, y1,
+      stream,
+      clip,
+      clipExtent = {
+        stream: function(output) {
+          if (stream) stream.valid = false;
+          stream = clip(output);
+          stream.valid = true; // allow caching by d3.geo.path
+          return stream;
+        },
+        extent: function(_) {
+          if (!arguments.length) return [[x0, y0], [x1, y1]];
+          clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]);
+          if (stream) stream.valid = false, stream = null;
+          return clipExtent;
+        }
+      };
+  return clipExtent.extent([[0, 0], [960, 500]]);
+};
+
+function d3_geo_clipExtent(x0, y0, x1, y1) {
+  return function(listener) {
+    var listener_ = listener,
+        bufferListener = d3_geo_clipBufferListener(),
+        clipLine = d3_geom_clipLine(x0, y0, x1, y1),
+        segments,
+        polygon,
+        ring;
+
+    var clip = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        listener = bufferListener;
+        segments = [];
+        polygon = [];
+        clean = true;
+      },
+      polygonEnd: function() {
+        listener = listener_;
+        segments = d3.merge(segments);
+        var clipStartInside = insidePolygon([x0, y1]),
+            inside = clean && clipStartInside,
+            visible = segments.length;
+        if (inside || visible) {
+          listener.polygonStart();
+          if (inside) {
+            listener.lineStart();
+            interpolate(null, null, 1, listener);
+            listener.lineEnd();
+          }
+          if (visible) {
+            d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener);
+          }
+          listener.polygonEnd();
+        }
+        segments = polygon = ring = null;
+      }
+    };
+
+    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 && d3_cross2d(a, b, p) > 0) ++wn;
+          } else {
+            if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn;
+          }
+          a = b;
+        }
+      }
+      return wn !== 0;
+    }
+
+    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 pointVisible(x, y) {
+      return x0 <= x && x <= x1 && y0 <= y && y <= y1;
+    }
+
+    function point(x, y) {
+      if (pointVisible(x, y)) listener.point(x, y);
+    }
+
+    var x__, y__, v__, // first point
+        x_, y_, v_, // previous point
+        first,
+        clean;
+
+    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_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x));
+      y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y));
+      var v = pointVisible(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 l = {a: {x: x_, y: y_}, b: {x: x, y: y}};
+          if (clipLine(l)) {
+            if (!v_) {
+              listener.lineStart();
+              listener.point(l.a.x, l.a.y);
+            }
+            listener.point(l.b.x, l.b.y);
+            if (!v) listener.lineEnd();
+            clean = false;
+          } else if (v) {
+            listener.lineStart();
+            listener.point(x, y);
+            clean = false;
+          }
+        }
+      }
+      x_ = x, y_ = y, v_ = v;
+    }
+
+    return clip;
+  };
+
+  function corner(p, direction) {
+    return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3
+        : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1
+        : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0
+        : direction > 0 ? 3 : 2; // abs(p[1] - y1) < ε
+  }
+
+  function compare(a, b) {
+    return comparePoints(a.x, b.x);
+  }
+
+  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];
+  }
+}