/**

 * Returns a function that, given a GeoJSON object (e.g., a feature), returns

 * the corresponding SVG path. The function can be customized by overriding the

 * projection. Point features are mapped to circles with a default radius of

 * 4.5px; the radius can be specified either as a constant or a function that

 * is evaluated per object.

 */

d3.geo.path = function() {

  var pointRadius = 4.5,

      pointCircle = d3_path_circle(pointRadius),

      projection = d3.geo.albersUsa();

  function path(d, i) {

    if (typeof pointRadius === "function") {

      pointCircle = d3_path_circle(pointRadius.apply(this, arguments));

    }

    return pathType(d) || null;

  }

  function project(coordinates) {

    return projection(coordinates).join(",");

  }

  var pathType = d3_geo_type({

    FeatureCollection: function(o) {

      var path = [],

          features = o.features,

          i = -1, // features.index

          n = features.length;

      while (++i < n) path.push(pathType(features[i].geometry));

      return path.join("");

    },

    Feature: function(o) {

      return pathType(o.geometry);

    },

    Point: function(o) {

      return "M" + project(o.coordinates) + pointCircle;

    },

    MultiPoint: function(o) {

      var path = [],

          coordinates = o.coordinates,

          i = -1, // coordinates.index

          n = coordinates.length;

      while (++i < n) path.push("M", project(coordinates[i]), pointCircle);

      return path.join("");

    },

    LineString: function(o) {

      var path = ["M"],

          coordinates = o.coordinates,

          i = -1, // coordinates.index

          n = coordinates.length;

      while (++i < n) path.push(project(coordinates[i]), "L");

      path.pop();

      return path.join("");

    },

    MultiLineString: function(o) {

      var path = [],

          coordinates = o.coordinates,

          i = -1, // coordinates.index

          n = coordinates.length,

          subcoordinates, // coordinates[i]

          j, // subcoordinates.index

          m; // subcoordinates.length

      while (++i < n) {

        subcoordinates = coordinates[i];

        j = -1;

        m = subcoordinates.length;

        path.push("M");

        while (++j < m) path.push(project(subcoordinates[j]), "L");

        path.pop();

      }

      return path.join("");

    },

    Polygon: function(o) {

      var path = [],

          coordinates = o.coordinates,

          i = -1, // coordinates.index

          n = coordinates.length,

          subcoordinates, // coordinates[i]

          j, // subcoordinates.index

          m; // subcoordinates.length

      while (++i < n) {

        subcoordinates = coordinates[i];

        j = -1;

        if ((m = subcoordinates.length - 1) > 0) {

          path.push("M");

          while (++j < m) path.push(project(subcoordinates[j]), "L");

          path[path.length - 1] = "Z";

        }

      }

      return path.join("");

    },

    MultiPolygon: function(o) {

      var path = [],

          coordinates = o.coordinates,

          i = -1, // coordinates index

          n = coordinates.length,

          subcoordinates, // coordinates[i]

          j, // subcoordinates index

          m, // subcoordinates.length

          subsubcoordinates, // subcoordinates[j]

          k, // subsubcoordinates index

          p; // subsubcoordinates.length

      while (++i < n) {

        subcoordinates = coordinates[i];

        j = -1;

        m = subcoordinates.length;

        while (++j < m) {

          subsubcoordinates = subcoordinates[j];

          k = -1;

          if ((p = subsubcoordinates.length - 1) > 0) {

            path.push("M");

            while (++k < p) path.push(project(subsubcoordinates[k]), "L");

            path[path.length - 1] = "Z";

          }

        }

      }

      return path.join("");

    },

    GeometryCollection: function(o) {

      var path = [],

          geometries = o.geometries,

          i = -1, // geometries index

          n = geometries.length;

      while (++i < n) path.push(pathType(geometries[i]));

      return path.join("");

    }

  });

  var areaType = path.area = d3_geo_type({

    FeatureCollection: function(o) {

      var area = 0,

          features = o.features,

          i = -1, // features.index

          n = features.length;

      while (++i < n) area += areaType(features[i]);

      return area;

    },

    Feature: function(o) {

      return areaType(o.geometry);

    },

    Polygon: function(o) {

      return polygonArea(o.coordinates);

    },

    MultiPolygon: function(o) {

      var sum = 0,

          coordinates = o.coordinates,

          i = -1, // coordinates index

          n = coordinates.length;

      while (++i < n) sum += polygonArea(coordinates[i]);

      return sum;

    },

    GeometryCollection: function(o) {

      var sum = 0,

          geometries = o.geometries,

          i = -1, // geometries index

          n = geometries.length;

      while (++i < n) sum += areaType(geometries[i]);

      return sum;

    }

  }, 0);

  function polygonArea(coordinates) {

    var sum = area(coordinates[0]), // exterior ring

        i = 0, // coordinates.index

        n = coordinates.length;

    while (++i < n) sum -= area(coordinates[i]); // holes

    return sum;

  }

  function polygonCentroid(coordinates) {

    var polygon = d3.geom.polygon(coordinates[0].map(projection)), // exterior ring

        area = polygon.area(),

        centroid = polygon.centroid(area < 0 ? (area *= -1, 1) : -1),

        x = centroid[0],

        y = centroid[1],

        z = area,

        i = 0, // coordinates index

        n = coordinates.length;

    while (++i < n) {

      polygon = d3.geom.polygon(coordinates[i].map(projection)); // holes

      area = polygon.area();

      centroid = polygon.centroid(area < 0 ? (area *= -1, 1) : -1);

      x -= centroid[0];

      y -= centroid[1];

      z -= area;

    }

    return [x, y, 6 * z]; // weighted centroid

  }

  var centroidType = path.centroid = d3_geo_type({

    // TODO FeatureCollection

    // TODO Point

    // TODO MultiPoint

    // TODO LineString

    // TODO MultiLineString

    // TODO GeometryCollection

    Feature: function(o) {

      return centroidType(o.geometry);

    },

    Polygon: function(o) {

      var centroid = polygonCentroid(o.coordinates);

      return [centroid[0] / centroid[2], centroid[1] / centroid[2]];

    },

    MultiPolygon: function(o) {

      var area = 0,

          coordinates = o.coordinates,

          centroid,

          x = 0,

          y = 0,

          z = 0,

          i = -1, // coordinates index

          n = coordinates.length;

      while (++i < n) {

        centroid = polygonCentroid(coordinates[i]);

        x += centroid[0];

        y += centroid[1];

        z += centroid[2];

      }

      return [x / z, y / z];

    }

  });

  function area(coordinates) {

    return Math.abs(d3.geom.polygon(coordinates.map(projection)).area());

  }

  path.projection = function(x) {

    projection = x;

    return path;

  };

  path.pointRadius = function(x) {

    if (typeof x === "function") pointRadius = x;

    else {

      pointRadius = +x;

      pointCircle = d3_path_circle(pointRadius);

    }

    return path;

  };

  return path;

};

function d3_path_circle(radius) {

  return "m0," + radius

      + "a" + radius + "," + radius + " 0 1,1 0," + (-2 * radius)

      + "a" + radius + "," + radius + " 0 1,1 0," + (+2 * radius)

      + "z";

}