stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/geo/azimuthal-equal-area-test.js

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert"),
+    projectionTestSuite = require("./projection-test-suite");
+
+var suite = vows.describe("d3.geo.azimuthalEqualArea");
+
+suite.addBatch({
+  "azimuthalEqualArea": {
+    topic: load("geo/azimuthal-equal-area").expression("d3.geo.azimuthalEqualArea"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 470.78325089,   51.18095336]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 448.09318291,   57.65281089]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 484.55622556,   96.45697185]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 428.30355841,  405.56446813]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 499.82677711,   55.68926131]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  452.67706228]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,   47.32293772]]
+    }),
+    "translated to 0,0 and at scale 1": projectionTestSuite({
+      topic: function(projection) { return projection().translate([0, 0]).scale(1); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [   0.00000000,    0.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349120], [  -0.06144499,   -1.32546031]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.21271211,   -1.28231459]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.03037484,   -1.02362019]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.34464294,    1.03709645]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.13217851,   -1.29540492]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    1.35118042]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -1.35118042]]
+    })
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geo/azimuthal-equidistant-test.js

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert"),
+    projectionTestSuite = require("./projection-test-suite");
+
+var suite = vows.describe("d3.geo.azimuthalEquidistant");
+
+suite.addBatch({
+  "azimuthalEquidistant": {
+    topic: load("geo/azimuthal-equidistant").expression("d3.geo.azimuthalEquidistant"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 469.92237700,   32.61061747]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 445.26741926,   40.61796552]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 484.78328535,   88.80514528]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 425.30773539,  414.57947189]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 501.59066113,   38.40245747]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  472.52947963]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,   27.47052037]]
+    }),
+    "translated to 0,0 and at scale 1": projectionTestSuite({
+      topic: function(projection) { return projection().translate([0, 0]).scale(1); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [   0.00000000,    0.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349120], [  -0.06718415,   -1.44926255]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.23155054,   -1.39588023]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.03188857,   -1.07463236]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.36461510,    1.09719648]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.14393774,   -1.41065028]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    1.48352986]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -1.48352986]]
+    })
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/geo/benchmark.js

@@ -0,0 +1,83 @@
+var fs = require("fs"),
+    d3 = require("../../");
+
+var formatNumber = d3.format(",.02r"),
+    projection = d3.geo.stereographic().clipAngle(150),
+    path = d3.geo.path().projection(projection),
+    graticule = d3.geo.graticule().step([1, 1]),
+    circle = d3.geo.circle().angle(30),
+    n = 10,
+    o,
+    then;
+
+o = circle();
+then = Date.now();
+
+for (var i = 0, k = 0; i < n * 1000; i++, k++) {
+  path(o);
+}
+
+console.log("Single circle: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+o = JSON.parse(fs.readFileSync("./test/data/us-counties.json")).features;
+then = Date.now();
+
+for (var i = 0, k = 0; i < n; i++, k++) {
+  for (var j = 0, m = o.length; j < m; ++j) {
+    path(o[j]);
+  }
+}
+
+console.log("U.S. counties (separate): " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+o = JSON.parse(fs.readFileSync("./test/data/us-counties.json"));
+then = Date.now();
+
+for (var i = 0, k = 0; i < n; i++, k++) {
+  path(o);
+}
+
+console.log("U.S. counties: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+o = graticule();
+then = Date.now();
+
+for (var i = 0, k = 0; i < n; i++, k++) {
+  path(o);
+}
+
+console.log("Dense graticule: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+o = {type: "GeometryCollection", geometries: d3.range(-180, 180, 1).map(function(x) {
+  return circle.origin([x, 0])();
+})};
+then = Date.now();
+
+for (var i = 0, k = 0; i < n; i++, k++) {
+  path(o);
+}
+
+console.log("Circle polygons: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+o = spiral();
+then = Date.now();
+
+for (var i = 0, k = 0; i < n; i++, k++) {
+  path(o);
+}
+
+console.log("Spiral polygons: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+
+function spiral() {
+  var n = 1e4,
+      dy = 5;
+
+  var spiral = d3.range(0, 1 + 1 / n, 1 / n).map(function(t) {
+      return [(360 * 10 * t) % 360 - 180, -90 + dy + (90 - dy) * 2 * t];
+  }).concat(d3.range(1, 0, -1 / n).map(function(t) {
+      return [(360 * 10 * t) % 360 - 180, -90 + (90 - dy) * 2 * t];
+  }));
+  spiral.push(spiral[0]);
+
+  return {type: "Polygon", coordinates: [spiral]};
+}

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

@@ -0,0 +1,265 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.bounds");
+
+suite.addBatch({
+  "bounds": {
+    topic: load("geo/bounds").expression("d3.geo.bounds"),
+    "Feature": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "Feature",
+        geometry: {
+          type: "MultiPoint",
+          coordinates: [[-123, 39], [-122, 38]]
+        }
+      }), [[-123, 38], [-122, 39]]);
+    },
+    "FeatureCollection": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            geometry: {
+              type: "Point",
+              coordinates: [-123, 39]
+            }
+          },
+          {
+            type: "Feature",
+            geometry: {
+              type: "Point",
+              coordinates: [-122, 38]
+            }
+          }
+        ]
+      }), [[-123, 38], [-122, 39]]);
+    },
+    "GeometryCollection": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "GeometryCollection",
+        geometries: [
+          {
+            type: "Point",
+            coordinates: [-123, 39]
+          },
+          {
+            type: "Point",
+            coordinates: [-122, 38]
+          }
+        ]
+      }), [[-123, 38], [-122, 39]]);
+    },
+    "LineString": {
+      "simple": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "LineString",
+          coordinates: [[-123, 39], [-122, 38]]
+        }), [[-123, 38], [-122, 39]]);
+      },
+      "containing coincident points": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "LineString",
+          coordinates: [[-123, 39], [-122, 38], [-122, 38]]
+        }), [[-123, 38], [-122, 39]]);
+      },
+      "meridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "LineString",
+          coordinates: [[0, 0], [0, 1], [0, 60]]
+        }), [[0, 0], [0, 60]]);
+      },
+      "equator": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "LineString",
+          coordinates: [[0, 0], [1, 0], [60, 0]]
+        }), [[0, 0], [60, 0]]);
+      },
+      "containing an inflection point": {
+        "in the Northern hemisphere": function(bounds) {
+          assert.inDelta(bounds({
+            type: "LineString",
+            coordinates: [[-45, 60], [45, 60]]
+          }), [[-45, 60], [45, 67.792345]], 1e-6);
+        },
+        "in the Southern hemisphere": function(bounds) {
+          assert.inDelta(bounds({
+            type: "LineString",
+            coordinates: [[-45, -60], [45, -60]]
+          }), [[-45, -67.792345], [45, -60]], 1e-6);
+        }
+      }
+    },
+    "MultiLineString": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "MultiLineString",
+        coordinates: [[[-123, 39], [-122, 38]]]
+      }), [[-123, 38], [-122, 39]]);
+    },
+    "MultiPoint": {
+      "simple": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-123, 39], [-122, 38]]
+        }), [[-123, 38], [-122, 39]]);
+      },
+      "two points near antimeridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-179, 39], [179, 38]]
+        }), [[179, 38], [-179, 39]]);
+      },
+      "two points near antimeridian, two points near primary meridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-179, 39], [179, 38], [-1, 0], [1, 0]]
+        }), [[-1, 0], [-179, 39]]);
+      },
+      "two points near primary meridian, two points near antimeridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-1, 0], [1, 0], [-179, 39], [179, 38]]
+        }), [[-1, 0], [-179, 39]]);
+      },
+      "four mixed points near primary meridian and antimeridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-1, 0], [-179, 39], [1, 0], [179, 38]]
+        }), [[-1, 0], [-179, 39]]);
+      },
+      "three points near antimeridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[178, 38], [179, 39], [-179, 37]]
+        }), [[178, 37], [-179, 39]]);
+      },
+      "various points near antimeridian": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "MultiPoint",
+          coordinates: [[-179, 39], [-179, 38], [178, 39], [-178, 38]]
+        }), [[178, 38], [-178, 39]]);
+      },
+    },
+    "MultiPolygon": function(bounds) {
+      assert.inDelta(bounds({
+        type: "MultiPolygon",
+        coordinates: [
+          [[[-123, 39], [-122, 39], [-122, 38], [-123, 39]],
+          [[10, 20], [20, 20], [20, 10], [10, 10], [10, 20]]]
+        ]
+      }), [[-123, 10], [20, 39.001067]], 1e-6);
+    },
+    "Point": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "Point",
+        coordinates: [-123, 39]
+      }), [[-123, 39], [-123, 39]]);
+    },
+    "Polygon": {
+      "simple": function(bounds) {
+        assert.inDelta(bounds({
+          type: "Polygon",
+          coordinates: [[[-123, 39], [-122, 39], [-122, 38], [-123, 39]]]
+        }), [[-123, 38], [-122, 39.001067]], 1e-6);
+      },
+      "larger than a hemisphere": {
+        "small, counter-clockwise": function(bounds) {
+          assert.deepEqual(bounds({
+            type: "Polygon",
+            coordinates: [[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]]
+          }), [[-180, -90], [180, 90]]);
+        },
+        "large lat-lon rectangle": function(bounds) {
+          assert.inDelta(bounds({
+            type: "Polygon",
+            coordinates: [[[-170, 80], [0, 80], [170, 80], [170, -80], [0, -80], [-170, -80], [-170, 80]]]
+          }), [[-170, -89.119552], [170, 89.119552]], 1e-6);
+        },
+        "South pole": function(bounds) {
+          assert.inDelta(bounds({
+            type: "Polygon",
+            coordinates: [[[10, 80], [170, 80], [-170, 80], [-10, 80], [10, 80]]]
+          }), [[-180, -90], [180, 88.246216]], 1e-6);
+        },
+        "excluding both poles": function(bounds) {
+          assert.inDelta(bounds({
+            type: "Polygon",
+            coordinates: [[[10, 80], [170, 80], [-170, 80], [-10, 80], [-10, 0], [-10, -80], [-170, -80], [170, -80], [10, -80], [10, 0], [10, 80]]]
+          }), [[10, -88.246216], [-10, 88.246216]], 1e-6);
+        }
+      },
+      "South pole": function(bounds) {
+        assert.deepEqual(bounds({
+          type: "Polygon",
+          coordinates: [[[-60, -80], [60, -80], [180, -80], [-60, -80]]]
+        }), [[-180, -90], [180, -80]]);
+      },
+      "ring": function(bounds) {
+        assert.inDelta(bounds({
+          type: "Polygon",
+          coordinates: [
+            [[-60, -80], [60, -80], [180, -80], [-60, -80]],
+            [[-60, -89], [180, -89], [60, -89], [-60, -89]]
+          ]
+        }), [[-180, -89.499961], [180, -80]], 1e-6);
+      }
+    },
+    "NestedCollection": function(bounds) {
+      assert.deepEqual(bounds({
+        type: "FeatureCollection",
+        features: [
+          {
+            type: "Feature",
+            geometry: {
+              type: "GeometryCollection",
+              geometries: [
+                {
+                  type: "Point",
+                  coordinates: [-120,47]
+                },
+                {
+                  type: "Point",
+                  coordinates: [-119,46]
+                }
+              ]
+            }
+          }
+        ]
+      }), [[-120,46], [-119,47]]);
+    },
+    "null geometries": {
+      "Feature": function(bounds) {
+        var b = bounds({type: "Feature", geometry: null});
+        assert.isNaN(b[0][0]);
+        assert.isNaN(b[0][1]);
+        assert.isNaN(b[1][0]);
+        assert.isNaN(b[1][1]);
+      },
+      "MultiPoint": function(bounds) {
+        var b = bounds({type: "MultiPoint", coordinates: []});
+        assert.isNaN(b[0][0]);
+        assert.isNaN(b[0][1]);
+        assert.isNaN(b[1][0]);
+        assert.isNaN(b[1][1]);
+      },
+      "MultiLineString": function(bounds) {
+        var b = bounds({type: "MultiLineString", coordinates: []});
+        assert.isNaN(b[0][0]);
+        assert.isNaN(b[0][1]);
+        assert.isNaN(b[1][0]);
+        assert.isNaN(b[1][1]);
+      },
+      "MultiPolygon": function(bounds) {
+        var b = bounds({type: "MultiPolygon", coordinates: []});
+        assert.isNaN(b[0][0]);
+        assert.isNaN(b[0][1]);
+        assert.isNaN(b[1][0]);
+        assert.isNaN(b[1][1]);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,187 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.centroid");
+
+suite.addBatch({
+  "centroid": {
+    topic: load("geo/centroid").expression("d3.geo.centroid"),
+
+    "the centroid of a point is itself": function(centroid) {
+      assert.inDelta(centroid({type: "Point", coordinates: [0, 0]}), [0, 0], 1e-6);
+      assert.inDelta(centroid({type: "Point", coordinates: [1, 1]}), [1, 1], 1e-6);
+      assert.inDelta(centroid({type: "Point", coordinates: [2, 3]}), [2, 3], 1e-6);
+      assert.inDelta(centroid({type: "Point", coordinates: [-4, -5]}), [-4, -5], 1e-6);
+    },
+
+    "the centroid of a set of points is the (spherical) average of its constituent members": function(centroid) {
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [0, 0]}, {type: "Point", coordinates: [1, 2]}]}), [0.499847, 1.000038], 1e-6);
+      assert.inDelta(centroid({type: "MultiPoint", coordinates: [[0, 0], [1, 2]]}), [0.499847, 1.000038], 1e-6);
+      assert.inDelta(centroid({type: "MultiPoint", coordinates: [[179, 0], [-179, 0]]}), [180, 0], 1e-6);
+    },
+
+    "the centroid of a set of points and their antipodes is ambiguous": function(centroid) {
+      assert.ok(centroid({type: "MultiPoint", coordinates: [[0, 0], [180, 0]]}).every(isNaN));
+      assert.ok(centroid({type: "MultiPoint", coordinates: [[0, 0], [90, 0], [180, 0], [-90, 0]]}).every(isNaN));
+      assert.ok(centroid({type: "MultiPoint", coordinates: [[0, 0], [0, 90], [180, 0], [0, -90]]}).every(isNaN));
+    },
+
+    "the centroid of the empty set of points is ambiguous": function(centroid) {
+      assert.ok(centroid({type: "MultiPoint", coordinates: []}).every(isNaN));
+    },
+
+    "the centroid of a line string is the (spherical) average of its constituent great arc segments": function(centroid) {
+      assert.inDelta(centroid({type: "LineString", coordinates: [[0, 0], [1, 0]]}), [.5, 0], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[0, 0], [0, 90]]}), [0, 45], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[0, 0], [0, 45], [0, 90]]}), [0, 45], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[-1, -1], [1, 1]]}), [0, 0], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[-60, -1], [60, 1]]}), [0, 0], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[179, -1], [-179, 1]]}), [180, 0], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[-179, 0], [0, 0], [179, 0]]}), [0, 0], 1e-6);
+      assert.inDelta(centroid({type: "LineString", coordinates: [[-180, -90], [0, 0], [0, 90]]}), [0, 0], 1e-6);
+    },
+
+    "the centroid of a great arc from a point to its antipode is ambiguous": function(centroid) {
+      assert.ok(centroid({type: "LineString", coordinates: [[180, 0], [0, 0]]}).every(isNaN));
+      assert.ok(centroid({type: "MultiLineString", coordinates: [[[0, -90], [0, 90]]]}).every(isNaN));
+    },
+
+    "the centroid of a set of line strings is the (spherical) average of its constituent great arc segments": function(centroid) {
+      assert.inDelta(centroid({type: "MultiLineString", coordinates: [[[0, 0], [0, 2]]]}), [0, 1], 1e-6);
+    },
+
+    "a line of zero length is treated as points": function(centroid) {
+      assert.inDelta(centroid({type: "LineString", coordinates: [[1, 1], [1, 1]]}), [1, 1], 1e-6);
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [0, 0]}, {type: "LineString", coordinates: [[1, 2], [1, 2]]}]}), [0.666534, 1.333408], 1e-6);
+    },
+
+    "an empty polygon with non-zero extent is treated as a line": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[1, 1], [2, 1], [3, 1], [2, 1], [1, 1]]]}), [2, 1.000076], 1e-6);
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [0, 0]}, {type: "Polygon", coordinates: [[[1, 2], [1, 2], [1, 2], [1, 2]]]}]}), [0.799907, 1.600077], 1e-6);
+    },
+
+    "an empty polygon with zero extent is treated as a point": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[1, 1], [1, 1], [1, 1], [1, 1]]]}), [1, 1], 1e-6);
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [0, 0]}, {type: "Polygon", coordinates: [[[1, 2], [1, 2], [1, 2], [1, 2]]]}]}), [0.799907, 1.600077], 1e-6);
+    },
+
+    "the centroid of the equator is ambiguous": function(centroid) {
+      assert.ok(centroid({type: "LineString", coordinates: [[0, 0], [120, 0], [-120, 0], [0, 0]]}).every(isNaN));
+    },
+
+    "the centroid of a polygon is the (spherical) average of its surface": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -90], [0, 0], [0, 90], [1, 0], [0, -90]]]}), [.5, 0], 1e-6);
+      assert.inDelta(centroid({type: "Polygon", coordinates: [_.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90, 1e-6);
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
+    },
+
+    "the centroid of a set of polygons is the (spherical) average of its surface": function(centroid) {
+      var circle = _.geo.circle();
+      assert.inDelta(centroid({
+        type: "MultiPolygon",
+        coordinates: [
+          circle.angle(45).origin([0, 0])().coordinates,
+          circle.angle(60).origin([180, 0])().coordinates
+        ]
+      }), [180, 0], 1e-6);
+    },
+
+    "the centroid of a lune is the (spherical) average of its surface": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -90], [0, 0], [0, 90], [1, 0], [0, -90]]]}), [.5, 0], 1e-6);
+    },
+
+    "the centroid of a small circle is its origin": {
+      "5°": function(centroid) {
+        assert.inDelta(centroid(_.geo.circle().angle(5).origin([30, 45])()), [30, 45], 1e-6);
+      },
+      "135°": function(centroid) {
+        assert.inDelta(centroid(_.geo.circle().angle(135).origin([30, 45])()), [30, 45], 1e-6);
+      },
+      "South Pole": function(centroid) {
+        assert.equal(centroid({type: "Polygon", coordinates: [_.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90);
+      },
+      "equator": function(centroid) {
+        assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
+      },
+      "equator with coincident points": function(centroid) {
+        assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
+      },
+      "other": function(centroid) {
+        assert.inDelta(centroid({type: "Polygon", coordinates: [[[-180, 0], [-180, 10], [-179, 10], [-179, 0], [-180, 0]]]}), [-179.5, 4.987448], 1e-6);
+      },
+      "concentric rings": function(centroid) {
+        var circle = _.geo.circle().origin([0, 45]),
+            coordinates = circle.angle(60)().coordinates;
+        coordinates.push(circle.angle(45)().coordinates[0].reverse());
+        assert.inDelta(centroid({type: "Polygon", coordinates: coordinates}), [0, 45], 1e-6);
+      }
+    },
+
+    "the centroid of a spherical square on the equator": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
+    },
+
+    "the centroid of a spherical square touching the antimeridian": function(centroid) {
+      assert.inDelta(centroid({type: "Polygon", coordinates: [[[-180, 0], [-180, 10], [-179, 10], [-179, 0], [-180, 0]]]}), [-179.5, 4.987448], 1e-6);
+    },
+
+    "concentric rings": function(centroid) {
+      var circle = _.geo.circle().origin([0, 45]),
+          coordinates = circle.angle(60)().coordinates;
+      coordinates.push(circle.angle(45)().coordinates[0].reverse());
+      assert.inDelta(centroid({type: "Polygon", coordinates: coordinates}), [0, 45], 1e-6);
+    },
+
+    "the centroid of a sphere is ambiguous": function(centroid) {
+      assert.ok(centroid({type: "Sphere"}).every(isNaN));
+    },
+
+    "the centroid of a feature is the centroid of its constituent geometry": function(centroid) {
+      assert.inDelta(centroid({type: "Feature", geometry: {type: "LineString", coordinates: [[1, 1], [1, 1]]}}), [1, 1], 1e-6);
+      assert.inDelta(centroid({type: "Feature", geometry: {type: "Point", coordinates: [1, 1]}}), [1, 1], 1e-6);
+      assert.inDelta(centroid({type: "Feature", geometry: {type: "Polygon", coordinates: [[[0, -90], [0, 0], [0, 90], [1, 0], [0, -90]]]}}), [.5, 0], 1e-6);
+    },
+
+    "the centroid of a feature collection is the centroid of its constituent geometry": function(centroid) {
+      assert.inDelta(centroid({type: "FeatureCollection", features: [
+        {type: "Feature", geometry: {type: "LineString", coordinates: [[179, 0], [180, 0]]}},
+        {type: "Feature", geometry: {type: "Point", coordinates: [0, 0]}}
+      ]}), [179.5, 0], 1e-6);
+    },
+
+    "the centroid of a non-empty line string and a point only considers the line string": function(centroid) {
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [
+        {type: "LineString", coordinates: [[179, 0], [180, 0]]},
+        {type: "Point", coordinates: [0, 0]}
+      ]}), [179.5, 0], 1e-6);
+    },
+
+    "the centroid of a non-empty polygon, a non-empty line string and a point only considers the polygon": function(centroid) {
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [
+        {type: "Polygon", coordinates: [[[-180, 0], [-180, 1], [-179, 1], [-179, 0], [-180, 0]]]},
+        {type: "LineString", coordinates: [[179, 0], [180, 0]]},
+        {type: "Point", coordinates: [0, 0]}
+      ]}), [-179.5, 0.500006], 1e-6);
+      assert.inDelta(centroid({type: "GeometryCollection", geometries: [
+        {type: "Point", coordinates: [0, 0]},
+        {type: "LineString", coordinates: [[179, 0], [180, 0]]},
+        {type: "Polygon", coordinates: [[[-180, 0], [-180, 1], [-179, 1], [-179, 0], [-180, 0]]]}
+      ]}), [-179.5, 0.500006], 1e-6);
+    },
+
+    "the centroid of the sphere and a point is the point": function(centroid) {
+      assert.deepEqual(centroid({type: "GeometryCollection", geometries: [
+        {type: "Sphere"},
+        {type: "Point", coordinates: [0, 0]}
+      ]}), [0, 0]);
+      assert.deepEqual(centroid({type: "GeometryCollection", geometries: [
+        {type: "Point", coordinates: [0, 0]},
+        {type: "Sphere"}
+      ]}), [0, 0]);
+    }
+  }
+});
+
+suite.export(module);