leaflet-ruby 0.3.beta1

data/lib/leaflet/src/geo/projection/Projection.LonLat.js

@@ -0,0 +1,10 @@
+
+L.Projection.LonLat = {
+	project: function (latlng) {
+		return new L.Point(latlng.lng, latlng.lat);
+	},
+
+	unproject: function (point, unbounded) {
+		return new L.LatLng(point.y, point.x, unbounded);
+	}
+};

data/lib/leaflet/src/geo/projection/Projection.Mercator.js

@@ -0,0 +1,51 @@
+
+L.Projection.Mercator = {
+	MAX_LATITUDE: 85.0840591556,
+
+	R_MINOR: 6356752.3142,
+	R_MAJOR: 6378137,
+
+	project: function (/*LatLng*/ latlng) /*-> Point*/ {
+		var d = L.LatLng.DEG_TO_RAD,
+			max = this.MAX_LATITUDE,
+			lat = Math.max(Math.min(max, latlng.lat), -max),
+			r = this.R_MAJOR,
+			r2 = this.R_MINOR,
+			x = latlng.lng * d * r,
+			y = lat * d,
+			tmp = r2 / r,
+			eccent = Math.sqrt(1.0 - tmp * tmp),
+			con = eccent * Math.sin(y);
+
+		con = Math.pow((1 - con) / (1 + con), eccent * 0.5);
+
+		var ts = Math.tan(0.5 * ((Math.PI * 0.5) - y)) / con;
+		y = -r2 * Math.log(ts);
+
+		return new L.Point(x, y);
+	},
+
+	unproject: function (/*Point*/ point, /*Boolean*/ unbounded) /*-> LatLng*/ {
+		var d = L.LatLng.RAD_TO_DEG,
+			r = this.R_MAJOR,
+			r2 = this.R_MINOR,
+			lng = point.x * d / r,
+			tmp = r2 / r,
+			eccent = Math.sqrt(1 - (tmp * tmp)),
+			ts = Math.exp(- point.y / r2),
+			phi = (Math.PI / 2) - 2 * Math.atan(ts),
+			numIter = 15,
+			tol = 1e-7,
+			i = numIter,
+			dphi = 0.1,
+			con;
+
+		while ((Math.abs(dphi) > tol) && (--i > 0)) {
+			con = eccent * Math.sin(phi);
+			dphi = (Math.PI / 2) - 2 * Math.atan(ts * Math.pow((1.0 - con) / (1.0 + con), 0.5 * eccent)) - phi;
+			phi += dphi;
+		}
+
+		return new L.LatLng(phi * d, lng, unbounded);
+	}
+};

data/lib/leaflet/src/geo/projection/Projection.SphericalMercator.js

@@ -0,0 +1,23 @@
+
+L.Projection.SphericalMercator = {
+	MAX_LATITUDE: 85.0511287798,
+
+	project: function (/*LatLng*/ latlng) /*-> Point*/ {
+		var d = L.LatLng.DEG_TO_RAD,
+			max = this.MAX_LATITUDE,
+			lat = Math.max(Math.min(max, latlng.lat), -max),
+			x = latlng.lng * d,
+			y = lat * d;
+		y = Math.log(Math.tan((Math.PI / 4) + (y / 2)));
+
+		return new L.Point(x, y);
+	},
+
+	unproject: function (/*Point*/ point, /*Boolean*/ unbounded) /*-> LatLng*/ {
+		var d = L.LatLng.RAD_TO_DEG,
+			lng = point.x * d,
+			lat = (2 * Math.atan(Math.exp(point.y)) - (Math.PI / 2)) * d;
+
+		return new L.LatLng(lat, lng, unbounded);
+	}
+};

data/lib/leaflet/src/geo/projection/Projection.js

@@ -0,0 +1,5 @@
+/*
+ * L.Projection contains various geographical projections used by CRS classes.
+ */
+
+L.Projection = {};

data/lib/leaflet/src/geometry/Bounds.js

@@ -0,0 +1,50 @@
+/*
+ * L.Bounds represents a rectangular area on the screen in pixel coordinates.
+ */
+
+L.Bounds = L.Class.extend({
+	initialize: function (min, max) {	//(Point, Point) or Point[]
+		if (!min) {
+			return;
+		}
+		var points = (min instanceof Array ? min : [min, max]);
+		for (var i = 0, len = points.length; i < len; i++) {
+			this.extend(points[i]);
+		}
+	},
+
+	// extend the bounds to contain the given point
+	extend: function (/*Point*/ point) {
+		if (!this.min && !this.max) {
+			this.min = new L.Point(point.x, point.y);
+			this.max = new L.Point(point.x, point.y);
+		} else {
+			this.min.x = Math.min(point.x, this.min.x);
+			this.max.x = Math.max(point.x, this.max.x);
+			this.min.y = Math.min(point.y, this.min.y);
+			this.max.y = Math.max(point.y, this.max.y);
+		}
+	},
+
+	getCenter: function (round)/*->Point*/ {
+		return new L.Point(
+				(this.min.x + this.max.x) / 2,
+				(this.min.y + this.max.y) / 2, round);
+	},
+
+	contains: function (/*Bounds or Point*/ obj)/*->Boolean*/ {
+		var min, max;
+
+		if (obj instanceof L.Bounds) {
+			min = obj.min;
+			max = obj.max;
+		} else {
+			min = max = obj;
+		}
+
+		return (min.x >= this.min.x) &&
+				(max.x <= this.max.x) &&
+				(min.y >= this.min.y) &&
+				(max.y <= this.max.y);
+	}
+});

data/lib/leaflet/src/geometry/LineUtil.js

@@ -0,0 +1,194 @@
+/*
+ * L.LineUtil contains different utility functions for line segments
+ * and polylines (clipping, simplification, distances, etc.)
+ */
+
+L.LineUtil = {
+
+	// Simplify polyline with vertex reduction and Douglas-Peucker simplification.
+	// Improves rendering performance dramatically by lessening the number of points to draw.
+
+	simplify: function (/*Point[]*/ points, /*Number*/ tolerance) {
+		if (!tolerance || !points.length) {
+			return points.slice();
+		}
+
+		// stage 1: vertex reduction
+		points = this.reducePoints(points, tolerance);
+
+		// stage 2: Douglas-Peucker simplification
+		points = this.simplifyDP(points, tolerance);
+
+		return points;
+	},
+
+	// distance from a point to a segment between two points
+	pointToSegmentDistance:  function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) {
+		return Math.sqrt(this._sqPointToSegmentDist(p, p1, p2));
+	},
+
+	closestPointOnSegment: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) {
+		var point = this._sqClosestPointOnSegment(p, p1, p2);
+		point.distance = Math.sqrt(point._sqDist);
+		return point;
+	},
+
+	// Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm
+	simplifyDP: function (points, tol) {
+		var maxDist2 = 0,
+			index = 0,
+			t2 = tol * tol,
+			len = points.length,
+			i, dist2;
+
+		if (len < 3) {
+			return points;
+		}
+
+		for (i = 0; i < len - 1; i++) {
+			dist2 = this._sqPointToSegmentDist(points[i], points[0], points[len - 1]);
+			if (dist2 > maxDist2) {
+				index = i;
+				maxDist2 = dist2;
+			}
+		}
+
+		var part1, part2;
+
+		if (maxDist2 >= t2) {
+			part1 = points.slice(0, index);
+			part2 = points.slice(index);
+
+			part1 = this.simplifyDP(part1, tol);
+			part2 = this.simplifyDP(part2, tol);
+
+			return part1.concat(part2);
+		} else {
+			return [points[0], points[len - 1]];
+		}
+	},
+
+	// reduce points that are too close to each other to a single point
+	reducePoints: function (points, tol) {
+		var reducedPoints = [points[0]],
+			t2 = tol * tol;
+
+		for (var i = 1, prev = 0, len = points.length; i < len; i++) {
+			if (this._sqDist(points[i], points[prev]) < t2) {
+				continue;
+			}
+			reducedPoints.push(points[i]);
+			prev = i;
+		}
+		if (prev < len - 1) {
+			reducedPoints.push(points[len - 1]);
+		}
+		return reducedPoints;
+	},
+
+	/*jshint bitwise:false */ // temporarily allow bitwise oprations
+
+	// Cohen-Sutherland line clipping algorithm.
+	// Used to avoid rendering parts of a polyline that are not currently visible.
+
+	clipSegment: function (a, b, bounds, useLastCode) {
+		var min = bounds.min,
+			max = bounds.max;
+
+		var codeA = useLastCode ? this._lastCode : this._getBitCode(a, bounds),
+			codeB = this._getBitCode(b, bounds);
+
+		// save 2nd code to avoid calculating it on the next segment
+		this._lastCode = codeB;
+
+		while (true) {
+			// if a,b is inside the clip window (trivial accept)
+			if (!(codeA | codeB)) {
+				return [a, b];
+			// if a,b is outside the clip window (trivial reject)
+			} else if (codeA & codeB) {
+				return false;
+			// other cases
+			} else {
+				var codeOut = codeA || codeB,
+					p = this._getEdgeIntersection(a, b, codeOut, bounds),
+					newCode = this._getBitCode(p, bounds);
+
+				if (codeOut === codeA) {
+					a = p;
+					codeA = newCode;
+				} else {
+					b = p;
+					codeB = newCode;
+				}
+			}
+		}
+	},
+
+	_getEdgeIntersection: function (a, b, code, bounds) {
+		var dx = b.x - a.x,
+			dy = b.y - a.y,
+			min = bounds.min,
+			max = bounds.max;
+
+		if (code & 8) { // top
+			return new L.Point(a.x + dx * (max.y - a.y) / dy, max.y);
+		} else if (code & 4) { // bottom
+			return new L.Point(a.x + dx * (min.y - a.y) / dy, min.y);
+		} else if (code & 2) { // right
+			return new L.Point(max.x, a.y + dy * (max.x - a.x) / dx);
+		} else if (code & 1) { // left
+			return new L.Point(min.x, a.y + dy * (min.x - a.x) / dx);
+		}
+	},
+
+	_getBitCode: function (/*Point*/ p, bounds) {
+		var code = 0;
+
+		if (p.x < bounds.min.x) { // left
+			code |= 1;
+		} else if (p.x > bounds.max.x) { // right
+			code |= 2;
+		}
+		if (p.y < bounds.min.y) { // bottom
+			code |= 4;
+		} else if (p.y > bounds.max.y) { // top
+			code |= 8;
+		}
+
+		return code;
+	},
+
+	/*jshint bitwise:true */
+
+	// square distance (to avoid unnecessary Math.sqrt calls)
+	_sqDist: function (p1, p2) {
+		var dx = p2.x - p1.x,
+			dy = p2.y - p1.y;
+		return dx * dx + dy * dy;
+	},
+
+	// return closest point on segment with attribute _sqDist - square distance to segment
+	_sqClosestPointOnSegment: function (p, p1, p2) {
+		var x2 = p2.x - p1.x,
+			y2 = p2.y - p1.y,
+			apoint = p1;
+		if (x2 || y2) {
+			var dot = (p.x - p1.x) * x2 + (p.y - p1.y) * y2,
+				t = dot / this._sqDist(p1, p2);
+
+			if (t > 1) {
+				apoint = p2;
+			} else if (t > 0) {
+				apoint = new L.Point(p1.x + x2 * t, p1.y + y2 * t);
+			}
+		}
+		apoint._sqDist = this._sqDist(p, apoint);
+		return apoint;
+	},
+
+	// distance from a point to a segment between two points
+	_sqPointToSegmentDist: function (p, p1, p2) {
+		return this._sqClosestPointOnSegment(p, p1, p2)._sqDist;
+	}
+};

data/lib/leaflet/src/geometry/Point.js

@@ -0,0 +1,66 @@
+/*
+ * L.Point represents a point with x and y coordinates.
+ */
+
+L.Point = function (/*Number*/ x, /*Number*/ y, /*Boolean*/ round) {
+	this.x = (round ? Math.round(x) : x);
+	this.y = (round ? Math.round(y) : y);
+};
+
+L.Point.prototype = {
+	add: function (point) {
+		return this.clone()._add(point);
+	},
+
+	_add: function (point) {
+		this.x += point.x;
+		this.y += point.y;
+		return this;
+	},
+
+	subtract: function (point) {
+		return this.clone()._subtract(point);
+	},
+
+	// destructive subtract (faster)
+	_subtract: function (point) {
+		this.x -= point.x;
+		this.y -= point.y;
+		return this;
+	},
+
+	divideBy: function (num, round) {
+		return new L.Point(this.x / num, this.y / num, round);
+	},
+
+	multiplyBy: function (num) {
+		return new L.Point(this.x * num, this.y * num);
+	},
+
+	distanceTo: function (point) {
+		var x = point.x - this.x,
+			y = point.y - this.y;
+		return Math.sqrt(x * x + y * y);
+	},
+
+	round: function () {
+		return this.clone()._round();
+	},
+
+	// destructive round
+	_round: function () {
+		this.x = Math.round(this.x);
+		this.y = Math.round(this.y);
+		return this;
+	},
+
+	clone: function () {
+		return new L.Point(this.x, this.y);
+	},
+
+	toString: function () {
+		return 'Point(' +
+				L.Util.formatNum(this.x) + ', ' +
+				L.Util.formatNum(this.y) + ')';
+	}
+};

data/lib/leaflet/src/geometry/PolyUtil.js

@@ -0,0 +1,59 @@
+/*
+ * L.PolyUtil contains utilify functions for polygons (clipping, etc.).
+ */
+
+/*jshint bitwise:false */ // allow bitwise oprations here
+
+L.PolyUtil = {};
+
+/*
+ * Sutherland-Hodgeman polygon clipping algorithm.
+ * Used to avoid rendering parts of a polygon that are not currently visible.
+ */
+L.PolyUtil.clipPolygon = function (points, bounds) {
+	var min = bounds.min,
+		max = bounds.max,
+		clippedPoints,
+		edges = [1, 4, 2, 8],
+		i, j, k,
+		a, b,
+		len, edge, p,
+		lu = L.LineUtil;
+
+	for (i = 0, len = points.length; i < len; i++) {
+		points[i]._code = lu._getBitCode(points[i], bounds);
+	}
+
+	// for each edge (left, bottom, right, top)
+	for (k = 0; k < 4; k++) {
+		edge = edges[k];
+		clippedPoints = [];
+
+		for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+			a = points[i];
+			b = points[j];
+
+			// if a is inside the clip window
+			if (!(a._code & edge)) {
+				// if b is outside the clip window (a->b goes out of screen)
+				if (b._code & edge) {
+					p = lu._getEdgeIntersection(b, a, edge, bounds);
+					p._code = lu._getBitCode(p, bounds);
+					clippedPoints.push(p);
+				}
+				clippedPoints.push(a);
+
+			// else if b is inside the clip window (a->b enters the screen)
+			} else if (!(b._code & edge)) {
+				p = lu._getEdgeIntersection(b, a, edge, bounds);
+				p._code = lu._getBitCode(p, bounds);
+				clippedPoints.push(p);
+			}
+		}
+		points = clippedPoints;
+	}
+
+	return points;
+};
+
+/*jshint bitwise:true */