(function(){d3.geo = {};

var d3_geo_radians = Math.PI / 180;

// TODO clip input coordinates on opposite hemisphere

d3.geo.azimuthal = function() {

  var mode = "orthographic", // or stereographic, gnomonic, equidistant or equalarea

      origin,

      scale = 200,

      translate = [480, 250],

      x0,

      y0,

      cy0,

      sy0;

  function azimuthal(coordinates) {

    var x1 = coordinates[0] * d3_geo_radians - x0,

        y1 = coordinates[1] * d3_geo_radians,

        cx1 = Math.cos(x1),

        sx1 = Math.sin(x1),

        cy1 = Math.cos(y1),

        sy1 = Math.sin(y1),

        cc = mode !== "orthographic" ? sy0 * sy1 + cy0 * cy1 * cx1 : null,

        c,

        k = mode === "stereographic" ? 1 / (1 + cc)

          : mode === "gnomonic" ? 1 / cc

          : mode === "equidistant" ? (c = Math.acos(cc), c ? c / Math.sin(c) : 0)

          : mode === "equalarea" ? Math.sqrt(2 / (1 + cc))

          : 1,

        x = k * cy1 * sx1,

        y = k * (sy0 * cy1 * cx1 - cy0 * sy1);

    return [

      scale * x + translate[0],

      scale * y + translate[1]

    ];

  }

  azimuthal.invert = function(coordinates) {

    var x = (coordinates[0] - translate[0]) / scale,

        y = (coordinates[1] - translate[1]) / scale,

        p = Math.sqrt(x * x + y * y),

        c = mode === "stereographic" ? 2 * Math.atan(p)

          : mode === "gnomonic" ? Math.atan(p)

          : mode === "equidistant" ? p

          : mode === "equalarea" ? 2 * Math.asin(.5 * p)

          : Math.asin(p),

        sc = Math.sin(c),

        cc = Math.cos(c);

    return [

      (x0 + Math.atan2(x * sc, p * cy0 * cc + y * sy0 * sc)) / d3_geo_radians,

      Math.asin(cc * sy0 - (p ? (y * sc * cy0) / p : 0)) / d3_geo_radians

    ];

  };

  azimuthal.mode = function(x) {

    if (!arguments.length) return mode;

    mode = x + "";

    return azimuthal;

  };

  azimuthal.origin = function(x) {

    if (!arguments.length) return origin;

    origin = x;

    x0 = origin[0] * d3_geo_radians;

    y0 = origin[1] * d3_geo_radians;

    cy0 = Math.cos(y0);

    sy0 = Math.sin(y0);

    return azimuthal;

  };

  azimuthal.scale = function(x) {

    if (!arguments.length) return scale;

    scale = +x;

    return azimuthal;

  };

  azimuthal.translate = function(x) {

    if (!arguments.length) return translate;

    translate = [+x[0], +x[1]];

    return azimuthal;

  };

  return azimuthal.origin([0, 0]);

};

// Derived from Tom Carden's Albers implementation for Protovis.

// http://gist.github.com/476238

// http://mathworld.wolfram.com/AlbersEqual-AreaConicProjection.html

d3.geo.albers = function() {

  var origin = [-98, 38],

      parallels = [29.5, 45.5],

      scale = 1000,

      translate = [480, 250],

      lng0, // d3_geo_radians * origin[0]

      n,

      C,

      p0;

  function albers(coordinates) {

    var t = n * (d3_geo_radians * coordinates[0] - lng0),

        p = Math.sqrt(C - 2 * n * Math.sin(d3_geo_radians * coordinates[1])) / n;

    return [

      scale * p * Math.sin(t) + translate[0],

      scale * (p * Math.cos(t) - p0) + translate[1]

    ];

  }

  albers.invert = function(coordinates) {

    var x = (coordinates[0] - translate[0]) / scale,

        y = (coordinates[1] - translate[1]) / scale,

        p0y = p0 + y,

        t = Math.atan2(x, p0y),

        p = Math.sqrt(x * x + p0y * p0y);

    return [

      (lng0 + t / n) / d3_geo_radians,

      Math.asin((C - p * p * n * n) / (2 * n)) / d3_geo_radians

    ];

  };

  function reload() {

    var phi1 = d3_geo_radians * parallels[0],

        phi2 = d3_geo_radians * parallels[1],

        lat0 = d3_geo_radians * origin[1],

        s = Math.sin(phi1),

        c = Math.cos(phi1);

    lng0 = d3_geo_radians * origin[0];

    n = .5 * (s + Math.sin(phi2));

    C = c * c + 2 * n * s;

    p0 = Math.sqrt(C - 2 * n * Math.sin(lat0)) / n;

    return albers;

  }

  albers.origin = function(x) {

    if (!arguments.length) return origin;

    origin = [+x[0], +x[1]];

    return reload();

  };

  albers.parallels = function(x) {

    if (!arguments.length) return parallels;

    parallels = [+x[0], +x[1]];

    return reload();

  };

  albers.scale = function(x) {

    if (!arguments.length) return scale;

    scale = +x;

    return albers;

  };

  albers.translate = function(x) {

    if (!arguments.length) return translate;

    translate = [+x[0], +x[1]];

    return albers;

  };

  return reload();

};

// A composite projection for the United States, 960x500. The set of standard

// parallels for each region comes from USGS, which is published here:

// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers

// TODO allow the composite projection to be rescaled?

d3.geo.albersUsa = function() {

  var lower48 = d3.geo.albers();

  var alaska = d3.geo.albers()

      .origin([-160, 60])

      .parallels([55, 65]);

  var hawaii = d3.geo.albers()

      .origin([-160, 20])

      .parallels([8, 18]);

  var puertoRico = d3.geo.albers()

      .origin([-60, 10])

      .parallels([8, 18]);

  function albersUsa(coordinates) {

    var lon = coordinates[0],

        lat = coordinates[1];

    return (lat > 50 ? alaska

        : lon < -140 ? hawaii

        : lat < 21 ? puertoRico

        : lower48)(coordinates);

  }

  albersUsa.scale = function(x) {

    if (!arguments.length) return lower48.scale();

    lower48.scale(x);

    alaska.scale(x * .6);

    hawaii.scale(x);

    puertoRico.scale(x * 1.5);

    return albersUsa.translate(lower48.translate());

  };

  albersUsa.translate = function(x) {

    if (!arguments.length) return lower48.translate();

    var dz = lower48.scale() / 1000,

        dx = x[0],

        dy = x[1];

    lower48.translate(x);

    alaska.translate([dx - 400 * dz, dy + 170 * dz]);

    hawaii.translate([dx - 190 * dz, dy + 200 * dz]);

    puertoRico.translate([dx + 580 * dz, dy + 430 * dz]);

    return albersUsa;

  };

  return albersUsa.scale(lower48.scale());

};

d3.geo.bonne = function() {

  var scale = 200,

      translate = [480, 250],

      x0, // origin longitude in radians

      y0, // origin latitude in radians

      y1, // parallel latitude in radians

      c1; // cot(y1)

  function bonne(coordinates) {

    var x = coordinates[0] * d3_geo_radians - x0,

        y = coordinates[1] * d3_geo_radians - y0;

    if (y1) {

      var p = c1 + y1 - y, E = x * Math.cos(y) / p;

      x = p * Math.sin(E);

      y = p * Math.cos(E) - c1;

    } else {

      x *= Math.cos(y);

      y *= -1;

    }

    return [

      scale * x + translate[0],

      scale * y + translate[1]

    ];

  }

  bonne.invert = function(coordinates) {

    var x = (coordinates[0] - translate[0]) / scale,

        y = (coordinates[1] - translate[1]) / scale;

    if (y1) {

      var c = c1 + y, p = Math.sqrt(x * x + c * c);

      y = c1 + y1 - p;

      x = x0 + p * Math.atan2(x, c) / Math.cos(y);

    } else {

      y *= -1;

      x /= Math.cos(y);

    }

    return [

      x / d3_geo_radians,

      y / d3_geo_radians

    ];

  };

  // 90° for Werner, 0° for Sinusoidal

  bonne.parallel = function(x) {

    if (!arguments.length) return y1 / d3_geo_radians;

    c1 = 1 / Math.tan(y1 = x * d3_geo_radians);

    return bonne;

  };

  bonne.origin = function(x) {

    if (!arguments.length) return [x0 / d3_geo_radians, y0 / d3_geo_radians];

    x0 = x[0] * d3_geo_radians;

    y0 = x[1] * d3_geo_radians;

    return bonne;

  };

  bonne.scale = function(x) {

    if (!arguments.length) return scale;

    scale = +x;

    return bonne;

  };

  bonne.translate = function(x) {

    if (!arguments.length) return translate;

    translate = [+x[0], +x[1]];

    return bonne;

  };

  return bonne.origin([0, 0]).parallel(45);

};

d3.geo.equirectangular = function() {

  var scale = 500,

      translate = [480, 250];

  function equirectangular(coordinates) {

    var x = coordinates[0] / 360,

        y = -coordinates[1] / 360;

    return [

      scale * x + translate[0],

      scale * y + translate[1]

    ];

  }

  equirectangular.invert = function(coordinates) {

    var x = (coordinates[0] - translate[0]) / scale,

        y = (coordinates[1] - translate[1]) / scale;

    return [

      360 * x,

      -360 * y

    ];

  };

  equirectangular.scale = function(x) {

    if (!arguments.length) return scale;

    scale = +x;

    return equirectangular;

  };

  equirectangular.translate = function(x) {

    if (!arguments.length) return translate;

    translate = [+x[0], +x[1]];

    return equirectangular;

  };

  return equirectangular;

};

d3.geo.mercator = function() {

  var scale = 500,

      translate = [480, 250];

  function mercator(coordinates) {

    var x = coordinates[0] / 360,