(function (root, factory) {
// Node.
if(typeof module === 'object' && typeof module.exports === 'object') {
exports = module.exports = factory();
}
// Browser Global.
if(typeof window === "object") {
root.Terraformer = factory();
}
}(this, function(){
"use strict";
var exports = {},
EarthRadius = 6378137,
DegreesPerRadian = 57.295779513082320,
RadiansPerDegree = 0.017453292519943,
MercatorCRS = {
"type": "link",
"properties": {
"href": "http://spatialreference.org/ref/sr-org/6928/ogcwkt/",
"type": "ogcwkt"
}
},
GeographicCRS = {
"type": "link",
"properties": {
"href": "http://spatialreference.org/ref/epsg/4326/ogcwkt/",
"type": "ogcwkt"
}
};
/*
Internal: isArray function
*/
function isArray(obj) {
return Object.prototype.toString.call(obj) === "[object Array]";
}
/*
Internal: safe warning
*/
function warn() {
var args = Array.prototype.slice.apply(arguments);
if (typeof console !== undefined && console.warn) {
console.warn.apply(console, args);
}
}
/*
Internal: Extend one object with another.
*/
function extend(destination, source) {
for (var k in source) {
if (source.hasOwnProperty(k)) {
destination[k] = source[k];
}
}
return destination;
}
/*
Public: Calculate an bounding box for a geojson object
*/
function calculateBounds (geojson) {
if(geojson.type){
switch (geojson.type) {
case 'Point':
return [ geojson.coordinates[0], geojson.coordinates[1], geojson.coordinates[0], geojson.coordinates[1]];
case 'MultiPoint':
return calculateBoundsFromArray(geojson.coordinates);
case 'LineString':
return calculateBoundsFromArray(geojson.coordinates);
case 'MultiLineString':
return calculateBoundsFromNestedArrays(geojson.coordinates);
case 'Polygon':
return calculateBoundsFromNestedArrays(geojson.coordinates);
case 'MultiPolygon':
return calculateBoundsFromNestedArrayOfArrays(geojson.coordinates);
case 'Feature':
return geojson.geometry? calculateBounds(geojson.geometry) : null;
case 'FeatureCollection':
return calculateBoundsForFeatureCollection(geojson);
case 'GeometryCollection':
return calculateBoundsForGeometryCollection(geojson);
default:
throw new Error("Unknown type: " + geojson.type);
}
}
return null;
}
/*
Internal: Calculate an bounding box from an nested array of positions
[
[
[ [lng, lat],[lng, lat],[lng, lat] ]
]
[
[lng, lat],[lng, lat],[lng, lat]
]
[
[lng, lat],[lng, lat],[lng, lat]
]
]
*/
function calculateBoundsFromNestedArrays (array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i = 0; i < array.length; i++) {
var inner = array[i];
for (var j = 0; j < inner.length; j++) {
var lonlat = inner[j];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
}
return [x1, y1, x2, y2 ];
}
/*
Internal: Calculate a bounding box from an array of arrays of arrays
[
[ [lng, lat],[lng, lat],[lng, lat] ]
[ [lng, lat],[lng, lat],[lng, lat] ]
[ [lng, lat],[lng, lat],[lng, lat] ]
]
*/
function calculateBoundsFromNestedArrayOfArrays (array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i = 0; i < array.length; i++) {
var inner = array[i];
for (var j = 0; j < inner.length; j++) {
var innerinner = inner[j];
for (var k = 0; k < innerinner.length; k++) {
var lonlat = innerinner[k];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
}
}
return [x1, y1, x2, y2];
}
/*
Internal: Calculate a bounding box from an array of positions
[
[lng, lat],[lng, lat],[lng, lat]
]
*/
function calculateBoundsFromArray (array) {
var x1 = null, x2 = null, y1 = null, y2 = null;
for (var i = 0; i < array.length; i++) {
var lonlat = array[i];
var lon = lonlat[0];
var lat = lonlat[1];
if (x1 === null) {
x1 = lon;
} else if (lon < x1) {
x1 = lon;
}
if (x2 === null) {
x2 = lon;
} else if (lon > x2) {
x2 = lon;
}
if (y1 === null) {
y1 = lat;
} else if (lat < y1) {
y1 = lat;
}
if (y2 === null) {
y2 = lat;
} else if (lat > y2) {
y2 = lat;
}
}
return [x1, y1, x2, y2 ];
}
/*
Internal: Calculate an bounding box for a feature collection
*/
function calculateBoundsForFeatureCollection(featureCollection){
var extents = [], extent;
for (var i = featureCollection.features.length - 1; i >= 0; i--) {
extent = calculateBounds(featureCollection.features[i].geometry);
extents.push([extent[0],extent[1]]);
extents.push([extent[2],extent[3]]);
}
return calculateBoundsFromArray(extents);
}
/*
Internal: Calculate an bounding box for a geometry collection
*/
function calculateBoundsForGeometryCollection(geometryCollection){
var extents = [], extent;
for (var i = geometryCollection.geometries.length - 1; i >= 0; i--) {
extent = calculateBounds(geometryCollection.geometries[i]);
extents.push([extent[0],extent[1]]);
extents.push([extent[2],extent[3]]);
}
return calculateBoundsFromArray(extents);
}
function calculateEnvelope(geojson){
var bounds = calculateBounds(geojson);
return {
x: bounds[0],
y: bounds[1],
w: Math.abs(bounds[0] - bounds[2]),
h: Math.abs(bounds[1] - bounds[3])
};
}
/*
Internal: Convert radians to degrees. Used by spatial reference converters.
*/
function radToDeg(rad) {
return rad * DegreesPerRadian;
}
/*
Internal: Convert degrees to radians. Used by spatial reference converters.
*/
function degToRad(deg) {
return deg * RadiansPerDegree;
}
/*
Internal: Loop over each array in a geojson object and apply a function to it. Used by spatial reference converters.
*/
function eachPosition(coordinates, func) {
for (var i = 0; i < coordinates.length; i++) {
// we found a number so lets convert this pair
if(typeof coordinates[i][0] === "number"){
coordinates[i] = func(coordinates[i]);
}
// we found an coordinates array it again and run THIS function against it
if(typeof coordinates[i] === "object"){
coordinates[i] = eachPosition(coordinates[i], func);
}
}
return coordinates;
}
/*
Public: Convert a GeoJSON Position object to Geographic (4326)
*/
function positionToGeographic(position) {
var x = position[0];
var y = position[1];
return [radToDeg(x / EarthRadius) - (Math.floor((radToDeg(x / EarthRadius) + 180) / 360) * 360), radToDeg((Math.PI / 2) - (2 * Math.atan(Math.exp(-1.0 * y / EarthRadius))))];
}
/*
Public: Convert a GeoJSON Position object to Web Mercator (102100)
*/
function positionToMercator(position) {
var lng = position[0];
var lat = Math.max(Math.min(position[1], 89.99999), -89.99999);
return [degToRad(lng) * EarthRadius, EarthRadius/2.0 * Math.log( (1.0 + Math.sin(degToRad(lat))) / (1.0 - Math.sin(degToRad(lat))) )];
}
/*
Public: Apply a function agaist all positions in a geojson object. Used by spatial reference converters.
*/
function applyConverter(geojson, converter, noCrs){
if(geojson.type === "Point") {
geojson.coordinates = converter(geojson.coordinates);
} else if(geojson.type === "Feature") {
geojson.geometry = applyConverter(geojson.geometry, converter, true);
} else if(geojson.type === "FeatureCollection") {
for (var f = 0; f < geojson.features.length; f++) {
geojson.features[f] = applyConverter(geojson.features[f], converter, true);
}
} else if(geojson.type === "GeometryCollection") {
for (var g = 0; g < geojson.geometries.length; g++) {
geojson.geometries[g] = applyConverter(geojson.geometries[g], converter, true);
}
} else {
geojson.coordinates = eachPosition(geojson.coordinates, converter);
}
if(!noCrs){
if(converter === positionToMercator){
geojson.crs = MercatorCRS;
}
}
if(converter === positionToGeographic){
delete geojson.crs;
}
return geojson;
}
/*
Public: Convert a GeoJSON object to ESRI Web Mercator (102100)
*/
function toMercator(geojson) {
return applyConverter(geojson, positionToMercator);
}
/*
Convert a GeoJSON object to Geographic coordinates (WSG84, 4326)
*/
function toGeographic(geojson) {
return applyConverter(geojson, positionToGeographic);
}
/*
Internal: -1,0,1 comparison function
*/
function cmp(a, b) {
if(a < b) {
return -1;
} else if(a > b) {
return 1;
} else {
return 0;
}
}
/*
Internal: used for sorting
*/
function compSort(p1, p2) {
if (p1[0] > p2[0]) {
return -1;
} else if (p1[0] < p2[0]) {
return 1;
} else if (p1[1] > p2[1]) {
return -1;
} else if (p1[1] < p2[1]) {
return 1;
} else {
return 0;
}
}
/*
Internal: used to determine turn
*/
function turn(p, q, r) {
// Returns -1, 0, 1 if p,q,r forms a right, straight, or left turn.
return cmp((q[0] - p[0]) * (r[1] - p[1]) - (r[0] - p[0]) * (q[1] - p[1]), 0);
}
/*
Internal: used to determine euclidean distance between two points
*/
function euclideanDistance(p, q) {
// Returns the squared Euclidean distance between p and q.
var dx = q[0] - p[0];
var dy = q[1] - p[1];
return dx * dx + dy * dy;
}
function nextHullPoint(points, p) {
// Returns the next point on the convex hull in CCW from p.
var q = p;
for(var r in points) {
var t = turn(p, q, points[r]);
if(t === -1 || t === 0 && euclideanDistance(p, points[r]) > euclideanDistance(p, q)) {
q = points[r];
}
}
return q;
}
function convexHull(points) {
// implementation of the Jarvis March algorithm
// adapted from http://tixxit.wordpress.com/2009/12/09/jarvis-march/
if(points.length === 0) {
return [];
} else if(points.length === 1) {
return points;
}
// Returns the points on the convex hull of points in CCW order.
var hull = [points.sort(compSort)[0]];
for(var p = 0; p < hull.length; p++) {
var q = nextHullPoint(points, hull[p]);
if(q !== hull[0]) {
hull.push(q);
}
}
return hull;
}
function isConvex(points) {
var ltz;
for (var i = 0; i < points.length - 3; i++) {
var p1 = points[i];
var p2 = points[i + 1];
var p3 = points[i + 2];
var v = [p2[0] - p1[0], p2[1] - p1[1]];
// p3.x * v.y - p3.y * v.x + v.x * p1.y - v.y * p1.x
var res = p3[0] * v[1] - p3[1] * v[0] + v[0] * p1[1] - v[1] * p1[0];
if (i === 0) {
if (res < 0) {
ltz = true;
} else {
ltz = false;
}
} else {
if (ltz && (res > 0) || !ltz && (res < 0)) {
return false;
}
}
}
return true;
}
function coordinatesContainPoint(coordinates, point) {
var contains = false;
for(var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {
if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||
(coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&
(point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {
contains = !contains;
}
}
return contains;
}
function polygonContainsPoint(polygon, point) {
if (polygon && polygon.length) {
if (polygon.length === 1) { // polygon with no holes
return coordinatesContainPoint(polygon[0], point);
} else { // polygon with holes
if (coordinatesContainPoint(polygon[0], point)) {
for (var i = 1; i < polygon.length; i++) {
if (coordinatesContainPoint(polygon[i], point)) {
return false; // found in hole
}
}
return true;
} else {
return false;
}
}
} else {
return false;
}
}
function edgeIntersectsEdge(a1, a2, b1, b2) {
var ua_t = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);
var ub_t = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);
var u_b = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);
if ( u_b !== 0 ) {
var ua = ua_t / u_b;
var ub = ub_t / u_b;
if ( 0 <= ua && ua <= 1 && 0 <= ub && ub <= 1 ) {
return true;
}
}
return false;
}
function isNumber(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
function arraysIntersectArrays(a, b) {
if (isNumber(a[0][0])) {
if (isNumber(b[0][0])) {
for (var i = 0; i < a.length - 1; i++) {
for (var j = 0; j < b.length - 1; j++) {
if (edgeIntersectsEdge(a[i], a[i + 1], b[j], b[j + 1])) {
return true;
}
}
}
} else {
for (var k = 0; k < b.length; k++) {
if (arraysIntersectArrays(a, b[k])) {
return true;
}
}
}
} else {
for (var l = 0; l < a.length; l++) {
if (arraysIntersectArrays(a[l], b)) {
return true;
}
}
}
return false;
}
/*
Internal: Returns a copy of coordinates for s closed polygon
*/
function closedPolygon(coordinates) {
var outer = [ ];
for (var i = 0; i < coordinates.length; i++) {
var inner = coordinates[i].slice();
if (pointsEqual(inner[0], inner[inner.length - 1]) === false) {
inner.push(inner[0]);
}
outer.push(inner);
}
return outer;
}
function pointsEqual(a, b) {
for (var i = 0; i < a.length; i++) {
if (a[i] !== b[i]) {
return false;
}
}
return true;
}
function coordinatesEqual(a, b) {
if (a.length !== b.length) {
return false;
}
var na = a.slice().sort(compSort);
var nb = b.slice().sort(compSort);
for (var i = 0; i < na.length; i++) {
if (na[i].length !== nb[i].length) {
return false;
}
for (var j = 0; j < na.length; j++) {
if (na[i][j] !== nb[i][j]) {
return false;
}
}
}
return true;
}
/*
Internal: An array of variables that will be excluded form JSON objects.
*/
var excludeFromJSON = ["length"];
/*
Internal: Base GeoJSON Primitive
*/
function Primitive(geojson){
if(geojson){
switch (geojson.type) {
case 'Point':
return new Point(geojson);
case 'MultiPoint':
return new MultiPoint(geojson);
case 'LineString':
return new LineString(geojson);
case 'MultiLineString':
return new MultiLineString(geojson);
case 'Polygon':
return new Polygon(geojson);
case 'MultiPolygon':
return new MultiPolygon(geojson);
case 'Feature':
return new Feature(geojson);
case 'FeatureCollection':
return new FeatureCollection(geojson);
case 'GeometryCollection':
return new GeometryCollection(geojson);
default:
throw new Error("Unknown type: " + geojson.type);
}
}
}
Primitive.prototype.toMercator = function(){
return toMercator(this);
};
Primitive.prototype.toGeographic = function(){
return toGeographic(this);
};
Primitive.prototype.envelope = function(){
return calculateEnvelope(this);
};
Primitive.prototype.bbox = function(){
return calculateBounds(this);
};
Primitive.prototype.convexHull = function(){
var coordinates = [ ], i, j;
if (this.type === 'Point') {
return null;
} else if (this.type === 'LineString' || this.type === 'MultiPoint') {
if (this.coordinates && this.coordinates.length >= 3) {
coordinates = this.coordinates;
} else {
return null;
}
} else if (this.type === 'Polygon' || this.type === 'MultiLineString') {
if (this.coordinates && this.coordinates.length > 0) {
for (i = 0; i < this.coordinates.length; i++) {
coordinates = coordinates.concat(this.coordinates[i]);
}
if(coordinates.length < 3){
return null;
}
} else {
return null;
}
} else if (this.type === 'MultiPolygon') {
if (this.coordinates && this.coordinates.length > 0) {
for (i = 0; i < this.coordinates.length; i++) {
for (j = 0; j < this.coordinates[i].length; j++) {
coordinates = coordinates.concat(this.coordinates[i][j]);
}
}
if(coordinates.length < 3){
return null;
}
} else {
return null;
}
} else if(this.type === "Feature"){
var primitive = new Primitive(this.geometry);
return primitive.convexHull();
}
return new Polygon({
type: 'Polygon',
coordinates: closedPolygon([convexHull(coordinates)])
});
};
Primitive.prototype.toJSON = function(){
var obj = {};
for (var key in this) {
if (this.hasOwnProperty(key) && excludeFromJSON.indexOf(key) === -1) {
obj[key] = this[key];
}
}
obj.bbox = calculateBounds(this);
return obj;
};
Primitive.prototype.contains = function(primitive){
return new Primitive(primitive).within(this);
};
Primitive.prototype.within = function(primitive) {
var coordinates, i, j, contains;
// if we are passed a feature, use the polygon inside instead
if (primitive.type === 'Feature') {
primitive = primitive.geometry;
}
// point.within(point) :: equality
if (primitive.type === "Point") {
if (this.type === "Point") {
return pointsEqual(this.coordinates, primitive.coordinates);
}
}
// point.within(multilinestring)
if (primitive.type === "MultiLineString") {
if (this.type === "Point") {
for (i = 0; i < primitive.coordinates.length; i++) {
var linestring = { type: "LineString", coordinates: primitive.coordinates[i] };
if (this.within(linestring)) {
return true;
}
}
}
}
// point.within(linestring), point.within(multipoint)
if (primitive.type === "LineString" || primitive.type === "MultiPoint") {
if (this.type === "Point") {
for (i = 0; i < primitive.coordinates.length; i++) {
if (this.coordinates.length !== primitive.coordinates[i].length) {
return false;
}
if (pointsEqual(this.coordinates, primitive.coordinates[i])) {
return true;
}
}
}
}
if (primitive.type === "Polygon") {
// polygon.within(polygon)
if (this.type === "Polygon") {
// check for equal polygons
if (primitive.coordinates.length === this.coordinates.length) {
for (i = 0; i < this.coordinates.length; i++) {
if (coordinatesEqual(this.coordinates[i], primitive.coordinates[i])) {
return true;
}
}
}
if (this.coordinates.length && polygonContainsPoint(primitive.coordinates, this.coordinates[0][0])) {
return !arraysIntersectArrays(closedPolygon(this.coordinates), closedPolygon(primitive.coordinates));
} else {
return false;
}
// point.within(polygon)
} else if (this.type === "Point") {
return polygonContainsPoint(primitive.coordinates, this.coordinates);
// linestring/multipoint withing polygon
} else if (this.type === "LineString" || this.type === "MultiPoint") {
if (!this.coordinates || this.coordinates.length === 0) {
return false;
}
for (i = 0; i < this.coordinates.length; i++) {
if (polygonContainsPoint(primitive.coordinates, this.coordinates[i]) === false) {
return false;
}
}
return true;
// multilinestring.within(polygon)
} else if (this.type === "MultiLineString") {
for (i = 0; i < this.coordinates.length; i++) {
var ls = new LineString(this.coordinates[i]);
if (ls.within(primitive) === false) {
contains++;
return false;
}
}
return true;
// multipolygon.within(polygon)
} else if (this.type === "MultiPolygon") {
for (i = 0; i < this.coordinates.length; i++) {
var p1 = new Primitive({ type: "Polygon", coordinates: this.coordinates[i] });
if (p1.within(primitive) === false) {
return false;
}
}
return true;
}
}
if (primitive.type === "MultiPolygon") {
// point.within(multipolygon)
if (this.type === "Point") {
if (primitive.coordinates.length) {
for (i = 0; i < primitive.coordinates.length; i++) {
coordinates = primitive.coordinates[i];
if (polygonContainsPoint(coordinates, this.coordinates) && arraysIntersectArrays([this.coordinates], primitive.coordinates) === false) {
return true;
}
}
}
return false;
// polygon.within(multipolygon)
} else if (this.type === "Polygon") {
for (i = 0; i < this.coordinates.length; i++) {
if (primitive.coordinates[i].length === this.coordinates.length) {
for (j = 0; j < this.coordinates.length; j++) {
if (coordinatesEqual(this.coordinates[j], primitive.coordinates[i][j])) {
return true;
}
}
}
}
if (arraysIntersectArrays(this.coordinates, primitive.coordinates) === false) {
if (primitive.coordinates.length) {
for (i = 0; i < primitive.coordinates.length; i++) {
coordinates = primitive.coordinates[i];
if (polygonContainsPoint(coordinates, this.coordinates[0][0]) === false) {
contains = false;
} else {
contains = true;
}
}
return contains;
}
}
// linestring.within(multipolygon), multipoint.within(multipolygon)
} else if (this.type === "LineString" || this.type === "MultiPoint") {
for (i = 0; i < primitive.coordinates.length; i++) {
var p = { type: "Polygon", coordinates: primitive.coordinates[i] };
if (this.within(p)) {
return true;
}
return false;
}
// multilinestring.within(multipolygon)
} else if (this.type === "MultiLineString") {
for (i = 0; i < this.coordinates.length; i++) {
var lines = new LineString(this.coordinates[i]);
if (lines.within(primitive) === false) {
return false;
}
}
return true;
// multipolygon.within(multipolygon)
} else if (this.type === "MultiPolygon") {
for (i = 0; i < primitive.coordinates.length; i++) {
var mpoly = { type: "Polygon", coordinates: primitive.coordinates[i] };
if (this.within(mpoly) === false) {
return false;
}
}
return true;
}
}
// default to false
return false;
};
Primitive.prototype.intersects = function(primitive) {
// if we are passed a feature, use the polygon inside instead
if (primitive.type === 'Feature') {
primitive = primitive.geometry;
}
var p = new Primitive(primitive);
if (this.within(primitive) || p.within(this)) {
return true;
}
if (this.type !== 'Point' && this.type !== 'MultiPoint' &&
primitive.type !== 'Point' && primitive.type !== 'MultiPoint') {
return arraysIntersectArrays(this.coordinates, primitive.coordinates);
} else if (this.type === 'Feature') {
// in the case of a Feature, use the internal primitive for intersection
var inner = new Primitive(this.geometry);
return inner.intersects(primitive);
}
warn("Type " + this.type + " to " + primitive.type + " intersection is not supported by intersects");
return false;
};
/*
GeoJSON Point Class
new Point();
new Point(x,y,z,wtf);
new Point([x,y,z,wtf]);
new Point([x,y]);
new Point({
type: "Point",
coordinates: [x,y]
});
*/
function Point(input){
var args = Array.prototype.slice.call(arguments);
if(input && input.type === "Point" && input.coordinates){
extend(this, input);
} else if(input && isArray(input)) {
this.coordinates = input;
} else if(args.length >= 2) {
this.coordinates = args;
} else {
throw "Terraformer: invalid input for Terraformer.Point";
}
this.type = "Point";
}
Point.prototype = new Primitive();
Point.prototype.constructor = Point;
/*
GeoJSON MultiPoint Class
new MultiPoint();
new MultiPoint([[x,y], [x1,y1]]);
new MultiPoint({
type: "MultiPoint",
coordinates: [x,y]
});
*/
function MultiPoint(input){
if(input && input.type === "MultiPoint" && input.coordinates){
extend(this, input);
} else if(isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiPoint";
}
this.type = "MultiPoint";
}
MultiPoint.prototype = new Primitive();
MultiPoint.prototype.constructor = MultiPoint;
MultiPoint.prototype.forEach = function(func){
for (var i = 0; i < this.coordinates.length; i++) {
func.apply(this, [this.coordinates[i], i, this.coordinates]);
}
return this;
};
MultiPoint.prototype.addPoint = function(point){
this.coordinates.push(point);
return this;
};
MultiPoint.prototype.insertPoint = function(point, index){
this.coordinates.splice(index, 0, point);
return this;
};
MultiPoint.prototype.removePoint = function(remove){
if(typeof remove === "number"){
this.coordinates.splice(remove, 1);
} else {
this.coordinates.splice(this.coordinates.indexOf(remove), 1);
}
return this;
};
MultiPoint.prototype.get = function(i){
return new Point(this.coordinates[i]);
};
/*
GeoJSON LineString Class
new LineString();
new LineString([[x,y], [x1,y1]]);
new LineString({
type: "LineString",
coordinates: [x,y]
});
*/
function LineString(input){
if(input && input.type === "LineString" && input.coordinates){
extend(this, input);
} else if(isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.LineString";
}
this.type = "LineString";
}
LineString.prototype = new Primitive();
LineString.prototype.constructor = LineString;
LineString.prototype.addVertex = function(point){
this.coordinates.push(point);
return this;
};
LineString.prototype.insertVertex = function(point, index){
this.coordinates.splice(index, 0, point);
return this;
};
LineString.prototype.removeVertex = function(remove){
this.coordinates.splice(remove, 1);
return this;
};
/*
GeoJSON MultiLineString Class
new MultiLineString();
new MultiLineString([ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ]);
new MultiLineString({
type: "MultiLineString",
coordinates: [ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ]
});
*/
function MultiLineString(input){
if(input && input.type === "MultiLineString" && input.coordinates){
extend(this, input);
} else if(isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiLineString";
}
this.type = "MultiLineString";
}
MultiLineString.prototype = new Primitive();
MultiLineString.prototype.constructor = MultiLineString;
MultiLineString.prototype.forEach = function(func){
for (var i = 0; i < this.coordinates.length; i++) {
func.apply(this, [this.coordinates[i], i, this.coordinates ]);
}
};
MultiLineString.prototype.get = function(i){
return new LineString(this.coordinates[i]);
};
/*
GeoJSON Polygon Class
new Polygon();
new Polygon([ [[x,y], [x1,y1], [x2,y2]] ]);
new Polygon({
type: "Polygon",
coordinates: [ [[x,y], [x1,y1], [x2,y2]] ]
});
*/
function Polygon(input){
if(input && input.type === "Polygon" && input.coordinates){
extend(this, input);
} else if(isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.Polygon";
}
this.type = "Polygon";
}
Polygon.prototype = new Primitive();
Polygon.prototype.constructor = Polygon;
Polygon.prototype.addVertex = function(point){
this.insertVertex(point, this.coordinates[0].length - 1);
return this;
};
Polygon.prototype.insertVertex = function(point, index){
this.coordinates[0].splice(index, 0, point);
return this;
};
Polygon.prototype.removeVertex = function(remove){
this.coordinates[0].splice(remove, 1);
return this;
};
Polygon.prototype.close = function() {
this.coordinates = closedPolygon(this.coordinates);
};
Polygon.prototype.hasHoles = function() {
return this.coordinates.length > 1;
};
Polygon.prototype.holes = function() {
var holes = [];
if (this.hasHoles()) {
for (var i = 1; i < this.coordinates.length; i++) {
holes.push(new Polygon([this.coordinates[i]]));
}
}
return holes;
};
/*
GeoJSON MultiPolygon Class
new MultiPolygon();
new MultiPolygon([ [ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ] ]);
new MultiPolygon({
type: "MultiPolygon",
coordinates: [ [ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ] ]
});
*/
function MultiPolygon(input){
if(input && input.type === "MultiPolygon" && input.coordinates){
extend(this, input);
} else if(isArray(input)) {
this.coordinates = input;
} else {
throw "Terraformer: invalid input for Terraformer.MultiPolygon";
}
this.type = "MultiPolygon";
}
MultiPolygon.prototype = new Primitive();
MultiPolygon.prototype.constructor = MultiPolygon;
MultiPolygon.prototype.forEach = function(func){
for (var i = 0; i < this.coordinates.length; i++) {
func.apply(this, [this.coordinates[i], i, this.coordinates ]);
}
};
MultiPolygon.prototype.get = function(i){
return new Polygon(this.coordinates[i]);
};
MultiPolygon.prototype.close = function(){
var outer = [];
this.forEach(function(polygon){
outer.push(closedPolygon(polygon));
});
this.coordinates = outer;
return this;
};
/*
GeoJSON Feature Class
new Feature();
new Feature({
type: "Feature",
geometry: {
type: "Polygon",
coordinates: [ [ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ] ]
}
});
new Feature({
type: "Polygon",
coordinates: [ [ [[x,y], [x1,y1]], [[x2,y2], [x3,y3]] ] ]
});
*/
function Feature(input){
if(input && input.type === "Feature"){
extend(this, input);
} else if(input && input.type && input.coordinates) {
this.geometry = input;
} else {
throw "Terraformer: invalid input for Terraformer.Feature";
}
this.type = "Feature";
}
Feature.prototype = new Primitive();
Feature.prototype.constructor = Feature;
/*
GeoJSON FeatureCollection Class
new FeatureCollection();
new FeatureCollection([feature, feature1]);
new FeatureCollection({
type: "FeatureCollection",
coordinates: [feature, feature1]
});
*/
function FeatureCollection(input){
if(input && input.type === "FeatureCollection" && input.features){
extend(this, input);
} else if(isArray(input)) {
this.features = input;
} else {
throw "Terraformer: invalid input for Terraformer.FeatureCollection";
}
this.type = "FeatureCollection";
}
FeatureCollection.prototype = new Primitive();
FeatureCollection.prototype.constructor = FeatureCollection;
FeatureCollection.prototype.forEach = function(func){
for (var i = 0; i < this.features.length; i++) {
func.apply(this, [this.features[i], i, this.features]);
}
};
FeatureCollection.prototype.get = function(id){
var found;
this.forEach(function(feature){
if(feature.id === id){
found = feature;
}
});
return new Feature(found);
};
/*
GeoJSON GeometryCollection Class
new GeometryCollection();
new GeometryCollection([geometry, geometry1]);
new GeometryCollection({
type: "GeometryCollection",
coordinates: [geometry, geometry1]
});
*/
function GeometryCollection(input){
if(input && input.type === "GeometryCollection" && input.geometries){
extend(this, input);
} else if(isArray(input)) {
this.geometries = input;
} else if(input.coordinates && input.type){
this.type = "GeometryCollection";
this.geometries = [input];
} else {
throw "Terraformer: invalid input for Terraformer.GeometryCollection";
}
this.type = "GeometryCollection";
}
GeometryCollection.prototype = new Primitive();
GeometryCollection.prototype.constructor = GeometryCollection;
GeometryCollection.prototype.forEach = function(func){
for (var i = 0; i < this.geometries.length; i++) {
func.apply(this, [this.geometries[i], i, this.geometries]);
}
};
GeometryCollection.prototype.get = function(i){
return new Primitive(this.geometries[i]);
};
function createCircle(center, radius, interpolate){
var mercatorPosition = positionToMercator(center);
var steps = interpolate || 64;
var polygon = {
type: "Polygon",
coordinates: [[]]
};
for(var i=1; i<=steps; i++) {
var radians = i * (360/steps) * Math.PI / 180;
polygon.coordinates[0].push([mercatorPosition[0] + radius * Math.cos(radians), mercatorPosition[1] + radius * Math.sin(radians)]);
}
polygon.coordinates = closedPolygon(polygon.coordinates);
return toGeographic(polygon);
}
function Circle (center, radius, interpolate) {
var steps = interpolate || 64;
var rad = radius || 250;
if(!center || center.length < 2 || !rad || !steps) {
throw new Error("Terraformer: missing parameter for Terraformer.Circle");
}
extend(this, new Feature({
type: "Feature",
geometry: createCircle(center, rad, steps),
properties: {
radius: rad,
center: center,
steps: steps
}
}));
}
Circle.prototype = new Primitive();
Circle.prototype.constructor = Circle;
Circle.prototype.recalculate = function(){
this.geometry = createCircle(this.properties.center, this.properties.radius, this.properties.steps);
return this;
};
Circle.prototype.center = function(coordinates){
if(coordinates){
this.properties.center = coordinates;
this.recalculate();
}
return this.properties.center;
};
Circle.prototype.radius = function(radius){
if(radius){
this.properties.radius = radius;
this.recalculate();
}
return this.properties.radius;
};
Circle.prototype.steps = function(steps){
if(steps){
this.properties.steps = steps;
this.recalculate();
}
return this.properties.steps;
};
Circle.prototype.toJSON = function() {
var output = Primitive.prototype.toJSON.call(this);
return output;
};
exports.Primitive = Primitive;
exports.Point = Point;
exports.MultiPoint = MultiPoint;
exports.LineString = LineString;
exports.MultiLineString = MultiLineString;
exports.Polygon = Polygon;
exports.MultiPolygon = MultiPolygon;
exports.Feature = Feature;
exports.FeatureCollection = FeatureCollection;
exports.GeometryCollection = GeometryCollection;
exports.Circle = Circle;
exports.toMercator = toMercator;
exports.toGeographic = toGeographic;
exports.Tools = {};
exports.Tools.positionToMercator = positionToMercator;
exports.Tools.positionToGeographic = positionToGeographic;
exports.Tools.applyConverter = applyConverter;
exports.Tools.toMercator = toMercator;
exports.Tools.toGeographic = toGeographic;
exports.Tools.createCircle = createCircle;
exports.Tools.calculateBounds = calculateBounds;
exports.Tools.calculateEnvelope = calculateEnvelope;
exports.Tools.coordinatesContainPoint = coordinatesContainPoint;
exports.Tools.polygonContainsPoint = polygonContainsPoint;
exports.Tools.arraysIntersectArrays = arraysIntersectArrays;
exports.Tools.coordinatesContainPoint = coordinatesContainPoint;
exports.Tools.coordinatesEqual = coordinatesEqual;
exports.Tools.convexHull = convexHull;
exports.Tools.isConvex = isConvex;
exports.MercatorCRS = MercatorCRS;
exports.GeographicCRS = GeographicCRS;
return exports;
}));
