stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/geo/point-in-polygon-mock.js

@@ -0,0 +1,18 @@
+import "../../src/geo/point-in-polygon";
+import "../../src/math/trigonometry";
+
+d3.geo.pointInPolygon = function(polygon) {
+  polygon = polygon.map(function(ring) {
+    ring = ring.map(pointRadians);
+    ring.pop();
+    return ring;
+  });
+
+  return function(point) {
+    return d3_geo_pointInPolygon(pointRadians(point), polygon);
+  };
+
+  function pointRadians(point) {
+    return [point[0] * d3_radians, point[1] * d3_radians];
+  }
+};

data/lib/stripmem/public/components/d3/test/geo/point-in-polygon-test.js

@@ -0,0 +1,352 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.pointInPolygon");
+
+suite.addBatch({
+  "d3.geo.pointInPolygon": {
+    topic: load("../test/geo/point-in-polygon-mock").expression("d3.geo.pointInPolygon"),
+    "empty": function(pointInPolygon) {
+      assert.ok(!pointInPolygon([])([0, 0]));
+    },
+    "simple": {
+      topic: function(pointInPolygon) {
+        return pointInPolygon([[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]]);
+      },
+      "outside": function(pointInPolygon) {
+        assert.ok(!pointInPolygon([.1, 2]));
+      },
+      "inside": function(pointInPolygon) {
+        assert.ok(pointInPolygon([.1, .1]));
+      }
+    },
+    "small circle": {
+      topic: function(pointInPolygon) {
+        return pointInPolygon(_.geo.circle().angle(60)().coordinates);
+      },
+      "outside": function(pointInPolygon) {
+        assert.ok(!pointInPolygon([-180, 0]));
+      },
+      "inside": function(pointInPolygon) {
+        assert.ok(pointInPolygon([1, 1]));
+      }
+    },
+    "South pole": {
+      topic: function(pointInPolygon) {
+        return pointInPolygon([
+          [[-60, -80], [60, -80], [180, -80], [-60, -80]]
+        ]);
+      },
+      "outside": function(pointInPolygon) {
+        assert.ok(!pointInPolygon([0, 0]));
+      },
+      "inside": function(pointInPolygon) {
+        assert.ok(pointInPolygon([0, -85]));
+      }
+    },
+    "North pole": {
+      topic: function(pointInPolygon) {
+        return pointInPolygon([
+          [[60, 80], [-60, 80], [-180, 80], [60, 80]]
+        ]);
+      },
+      "outside": function(pointInPolygon) {
+        assert.ok(!pointInPolygon([0, 0]));
+      },
+      "inside": function(pointInPolygon) {
+        assert.ok(pointInPolygon([0, 85]));
+      }
+    },
+    "larger than hemisphere": {
+      "near [0°, 0°]": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([.1, .1]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([2, .1]));
+        }
+      },
+      "South pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[-60, 80], [60, 80], [180, 80], [-60, 80]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 85]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 0]));
+        }
+      },
+      "North pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[60, -80], [-60, -80], [-180, -80], [60, -80]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, -85]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 0]));
+        }
+      },
+      "circle with radius 120°": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon(_.geo.circle().angle(120)().coordinates);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([-180, 0]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([-90, 0]));
+        }
+      },
+      "narrow strip hole, length 340°": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[-170, -1], [0, -1], [170, -1], [170, 1], [0, 1], [-170, 1], [-170, -1]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 0]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 20]));
+        }
+      }
+    },
+    "ring": {
+      "near [0°, 0°]": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]],
+            [[.4, .4], [.6, .4], [.6, .6], [.4, .6], [.4, .4]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([.5, .5]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([.1, .5]));
+        }
+      },
+      "equatorial": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[0, -10], [-120, -10], [120, -10], [0, -10]],
+            [[0, 10], [120, 10], [-120, 10], [0, 10]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 20]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 0]));
+        }
+      },
+      "excluding both poles": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[10, 10], [-10, 10], [-10, -10], [10, -10], [10, 10]].reverse(),
+            [[170, 10], [170, -10], [-170, -10], [-170, 10], [170, 10]].reverse()
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 90]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 0]));
+        }
+      },
+      "containing both poles": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[10, 10], [-10, 10], [-10, -10], [10, -10], [10, 10]],
+            [[170, 10], [170, -10], [-170, -10], [-170, 10], [170, 10]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 0]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 20]));
+        }
+      },
+      "containing the South pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[10, 10], [-10, 10], [-10, -10], [10, -10], [10, 10]],
+            [[0, 80], [120, 80], [-120, 80], [0, 80]]
+          ]);
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 90]));
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, -90]));
+        }
+      },
+      "containing the North pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[10, 10], [-10, 10], [-10, -10], [10, -10], [10, 10]].reverse(),
+            [[0, 80], [120, 80], [-120, 80], [0, 80]].reverse()
+          ]);
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 90]));
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, -90]));
+        }
+      }
+    },
+    "self-intersecting": {
+      "near [0°, 0°]": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[0, 0], [1, 0], [1, 3], [3, 3], [3, 1], [0, 1], [0, 0]]
+          ]);
+        },
+        "inside": {
+          "counter-clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([.5, .5]));
+          },
+          "clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([2, 2]));
+          }
+        },
+        "outside": {
+          "counter-clockwise region": function(pointInPolygon) {
+            assert.ok(!pointInPolygon([15, .5]));
+          },
+          "clockwise region": function(pointInPolygon) {
+            assert.ok(!pointInPolygon([12, 2]));
+          }
+        }
+      },
+      "near the South pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[-10, -80], [120, -80], [-120, -80], [10, -85], [10, -75], [-10, -75], [-10, -80]]
+          ]);
+        },
+        "inside": {
+          "counter-clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([0, -76]));
+          },
+          "clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([0, -89]));
+          }
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 0]));
+        }
+      },
+      "near the North pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([
+            [[-10, 80], [-10, 75], [10, 75], [10, 85], [-120, 80], [120, 80], [-10, 80]]
+          ]);
+        },
+        "inside": {
+          "clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([0, 76]));
+          },
+          "counter-clockwise region": function(pointInPolygon) {
+            assert.ok(pointInPolygon([0, 89]));
+          }
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 0]));
+        }
+      }
+    },
+    "touching a pole": {
+      "hemisphere touching the South pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon(_.geo.circle().angle(90)().coordinates);
+        },
+        "origin is inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([0, 0]));
+        }
+      },
+      "triangle touching the South pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([[[180, -90], [-45, 0], [45, 0], [180, -90]]]);
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([-44, 0]));
+          assert.ok(pointInPolygon([0, 0]));
+          assert.ok(pointInPolygon([0, -30]));
+          assert.ok(pointInPolygon([30, -80]));
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([-46, 0]));
+          assert.ok(!pointInPolygon([0, 1]));
+          assert.ok(!pointInPolygon([-90, -80]));
+        }
+      },
+      "triangle touching the South pole (2)": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([[[-45, 0], [45, 0], [180, -90], [-45, 0]]]);
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([-44, 0]));
+          assert.ok(pointInPolygon([0, 0]));
+          assert.ok(pointInPolygon([0, -30]));
+          assert.ok(pointInPolygon([30, -80]));
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([-46, 0]));
+          assert.ok(!pointInPolygon([0, 1]));
+          assert.ok(!pointInPolygon([-90, -80]));
+        }
+      },
+      "triangle touching the South pole (3)": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([[[180, -90], [-135, 0], [135, 0], [180, -90]]]);
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([180, 0]));
+          assert.ok(pointInPolygon([150, 0]));
+          assert.ok(pointInPolygon([180, -30]));
+          assert.ok(pointInPolygon([150, -80]));
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([0, 0]));
+          assert.ok(!pointInPolygon([180, 1]));
+          assert.ok(!pointInPolygon([-90, -80]));
+        }
+      },
+      "triangle touching the North pole": {
+        topic: function(pointInPolygon) {
+          return pointInPolygon([[[180, 90], [45, 0], [-45, 0], [180, 90]]]);
+        },
+        "inside": function(pointInPolygon) {
+          assert.ok(pointInPolygon([-44, 10]));
+          assert.ok(pointInPolygon([0, 10]));
+          assert.ok(pointInPolygon([30, 80]));
+        },
+        "outside": function(pointInPolygon) {
+          assert.ok(!pointInPolygon([-90, 0]));
+          assert.ok(!pointInPolygon([0, -1]));
+          assert.ok(!pointInPolygon([0, -80]));
+          assert.ok(!pointInPolygon([-90, 1]));
+          assert.ok(!pointInPolygon([-90, 80]));
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geo/projection-test-suite.js

@@ -0,0 +1,29 @@
+var assert = require("../assert"),
+    _ = require("../../"),
+    format = _.format("13.8f");
+
+module.exports = function(suite, mapping) {
+
+  for (var place in mapping) {
+    suite[place] = test(mapping[place][0], mapping[place][1]);
+  }
+
+  function test(location, point) {
+    return function(projection) {
+      var actualLocation = projection.invert(point),
+          actualPoint = projection(location);
+      try {
+        assert.inDelta([actualPoint, actualLocation], [point, location], 1e-5);
+      } catch (e) {
+        e.message = "project [["
+            + location.map(format).join(", ") + "], [" + actualPoint.map(format).join(", ")
+            + "]]\n         invert [["
+            + actualLocation.map(format).join(", ") + "], [" + point.map(format).join(", ")
+            + "]]";
+        throw e;
+      }
+    };
+  }
+
+  return suite;
+};

data/lib/stripmem/public/components/d3/test/geo/projection-test.js

@@ -0,0 +1,58 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.projection");
+
+suite.addBatch({
+  "projection": {
+    topic: load("geo/projection").expression("d3.geo.projection"),
+    "a custom invertible projection": {
+      topic: function(projection) {
+        function forward(λ, φ) { return [λ, φ]; }
+        forward.invert = function(x, y) {};
+        return projection(forward);
+      },
+
+      "invert": {
+        "can return undefined": function(projection) {
+          assert.isUndefined(projection.invert([0, 0]));
+        }
+      },
+
+      "scale": {
+        "defaults to 150": function(projection) {
+          assert.equal(projection.scale(), 150);
+        },
+        "is coerced to a number": function(projection) {
+          assert.strictEqual(projection.scale("400"), projection);
+          assert.strictEqual(projection.scale(), 400);
+        }
+      },
+
+      "translate": {
+        "defaults to [480, 250]": function(projection) {
+          assert.deepEqual(projection.translate(), [480, 250]);
+        },
+        "is coerced to two numbers": function(projection) {
+          assert.strictEqual(projection.translate(["23", "141"]), projection);
+          assert.strictEqual(projection.translate()[0], 23);
+          assert.strictEqual(projection.translate()[1], 141);
+        }
+      },
+
+      "rotate": {
+        "defaults to [0, 0, 0]": function(projection) {
+          assert.deepEqual(projection.rotate(), [0, 0, 0]);
+        },
+        "is coerced to three numbers": function(projection) {
+          assert.strictEqual(projection.rotate(["23", "41"]), projection);
+          assert.strictEqual(projection.rotate()[0], 23);
+          assert.strictEqual(projection.rotate()[1], 41);
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geo/rotation-test.js

@@ -0,0 +1,35 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.rotation");
+
+suite.addBatch({
+  "rotation": {
+    topic: load("geo/rotation").expression("d3.geo.rotation"),
+    "a rotation of [+90°, 0°]": {
+      topic: function(rotation) {
+        return rotation([90, 0]);
+      },
+      "only rotates longitude": function(rotation) {
+        assert.inDelta(rotation([0, 0]), [90, 0], 1e-6);
+      },
+      "wraps around when crossing the antimeridian": function(rotation) {
+        assert.inDelta(rotation([150, 0]), [-120, 0], 1e-6);
+      }
+    },
+    "a rotation of [-45°, -45°]": {
+      topic: function(rotation) {
+        return rotation([-45, 45]);
+      },
+      "rotates longitude and latitude": function(rotation) {
+        assert.inDelta(rotation([0, 0]), [-54.73561, 30], 1e-6);
+      },
+      "inverse rotation of longitude and latitude": function(rotation) {
+        assert.inDelta(rotation.invert([-54.73561, 30]), [0, 0], 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geo/stereographic-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.stereographic");
+
+suite.addBatch({
+  "stereographic": {
+    topic: load("geo/stereographic").expression("d3.geo.stereographic"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 473.84094732,  117.14003304]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 459.00877672,  123.45642208]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 482.65216217,  160.62316700]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 449.13660231,  342.87385937]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 493.06074697,  121.99919699]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  387.44967610]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,  112.55032390]]
+    }),
+    "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.04106035,   -0.88573312]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.13994149,   -0.84362385]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.01768108,   -0.59584555]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.20575598,    0.61915906]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.08707165,   -0.85333869]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    0.91633117]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -0.91633117]]
+    })
+  }
+});
+
+suite.export(module);