From 6f9f1783bd58ef143b8594e8a060f703d0bb98c1 Mon Sep 17 00:00:00 2001 From: Petr Pridal Date: Fri, 22 Jun 2012 14:48:49 +0200 Subject: [PATCH 01/18] The demo of compilation with library in a different ways. --- demo/{hello.html => hello-compiled.html} | 0 demo/{hello.json => hello-compiled.json} | 1 - demo/{hello-epi.json => hello-epi-compiled.json} | 3 +-- demo/hello-epi.js | 10 ++++++++-- demo/hello.js | 4 ++-- 5 files changed, 11 insertions(+), 7 deletions(-) rename demo/{hello.html => hello-compiled.html} (100%) rename demo/{hello.json => hello-compiled.json} (99%) rename demo/{hello-epi.json => hello-epi-compiled.json} (95%) diff --git a/demo/hello.html b/demo/hello-compiled.html similarity index 100% rename from demo/hello.html rename to demo/hello-compiled.html diff --git a/demo/hello.json b/demo/hello-compiled.json similarity index 99% rename from demo/hello.json rename to demo/hello-compiled.json index 6578a75419..5cab96f3ea 100644 --- a/demo/hello.json +++ b/demo/hello-compiled.json @@ -25,7 +25,6 @@ // "generateExports": true // }, - "checks": { // acceptable values are "ERROR", "WARNING", and "OFF" "accessControls": "WARNING", diff --git a/demo/hello-epi.json b/demo/hello-epi-compiled.json similarity index 95% rename from demo/hello-epi.json rename to demo/hello-epi-compiled.json index 9c4046a0cc..ac42ce4866 100644 --- a/demo/hello-epi.json +++ b/demo/hello-epi-compiled.json @@ -4,8 +4,7 @@ "output-file": "hello-epi-compiled.js", "inputs": [ - "hello-epi.js", - "../src/ol.js" + "hello-epi.js" ], "paths": [ "../src" diff --git a/demo/hello-epi.js b/demo/hello-epi.js index b63eb18fa3..2b6ba9467f 100644 --- a/demo/hello-epi.js +++ b/demo/hello-epi.js @@ -1,8 +1,14 @@ /* This is a code which is going to be compiled together with the library */ +goog.require('ol.Map'); +goog.require('ol.layer.OSM'); +goog.require('ol.Loc'); + +goog.require('goog.dom'); + function init() { - var map = new ol.Map() - // .render('map') + var map = new ol.Map(); + map.setContainer(goog.dom.getElement('map')); map.setLayers( [ new ol.layer.OSM() ] ); map.setCenter( new ol.Loc(45, 5)); map.setZoom(10); diff --git a/demo/hello.js b/demo/hello.js index 08fcfadbed..90cfcae4e1 100644 --- a/demo/hello.js +++ b/demo/hello.js @@ -2,9 +2,9 @@ function init() { var map = ol.map() - .render('map') + .renderTo('map') .layers([ol.layer.osm()]) .center([45, 5]) .zoom(10); } -window['init'] = init; \ No newline at end of file +window['init'] = init; From 6cfb942ff9c05c9b43eb5870ee5c8b03229a491a Mon Sep 17 00:00:00 2001 From: Petr Pridal Date: Fri, 22 Jun 2012 14:53:12 +0200 Subject: [PATCH 02/18] Fix the calls of .transform in internal code. It should be .doTransform. --- src/ol/Bounds.js | 10 +++++----- src/ol/Map.js | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/ol/Bounds.js b/src/ol/Bounds.js index 36b40e3086..3d77562522 100644 --- a/src/ol/Bounds.js +++ b/src/ol/Bounds.js @@ -53,7 +53,7 @@ ol.Bounds.prototype.setProjection = function(projection) { ol.Bounds.prototype.intersects = function(bounds) { var otherProj = bounds.getProjection(); if (!goog.isNull(otherProj) && !goog.isNull(this.projection_)) { - bounds = bounds.transform(this.projection_); + bounds = bounds.doTransform(this.projection_); } return goog.base(this, "intersects", bounds.toUnreferencedBounds()); }; @@ -70,13 +70,13 @@ ol.Bounds.prototype.doTransform = function(proj) { throw new Error("Bounds must have a projection before transforming."); } var tl = new ol.Loc( - this.minX_, this.maxY_, undefined, this.projection_).transform(proj); + this.minX_, this.maxY_, undefined, this.projection_).doTransform(proj); var tr = new ol.Loc( - this.maxX_, this.maxY_, undefined, this.projection_).transform(proj); + this.maxX_, this.maxY_, undefined, this.projection_).doTransform(proj); var bl = new ol.Loc( - this.minX_, this.minY_, undefined, this.projection_).transform(proj); + this.minX_, this.minY_, undefined, this.projection_).doTransform(proj); var br = new ol.Loc( - this.maxX_, this.minY_, undefined, this.projection_).transform(proj); + this.maxX_, this.minY_, undefined, this.projection_).doTransform(proj); var x = [tl.getX(), tr.getX(), bl.getX(), br.getX()].sort(); var y = [tl.getY(), tr.getY(), bl.getY(), br.getY()].sort(); diff --git a/src/ol/Map.js b/src/ol/Map.js index 125b12e776..5e9f3bcf7e 100644 --- a/src/ol/Map.js +++ b/src/ol/Map.js @@ -143,7 +143,7 @@ ol.Map.DEFAULT_CONTROLS = ["navigation"]; */ ol.Map.prototype.getCenter = function() { var proj = this.getUserProjection(); - return this.center_.transform(proj); + return this.center_.doTransform(proj); }; @@ -271,7 +271,7 @@ ol.Map.prototype.setCenter = function(center) { proj = this.getUserProjection(); center.setProjection(proj); } - this.center_ = center.transform(this.getProjection()); + this.center_ = center.doTransform(this.getProjection()); }; From 71a804c5e039c9fe87b36679b4881aa284699ef1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Lemoine?= Date: Fri, 22 Jun 2012 15:16:46 +0200 Subject: [PATCH 03/18] [ol.layer.TileLayer] add a getTileForXYZ func --- src/ol/Tile.js | 18 +++++++++--------- src/ol/layer/TileLayer.js | 21 ++++++++++++++++++++- test/spec/ol/layer/TileLayer.test.js | 22 ++++++++++++++++++++++ 3 files changed, 51 insertions(+), 10 deletions(-) diff --git a/src/ol/Tile.js b/src/ol/Tile.js index 838c592c2d..fe3b715d47 100644 --- a/src/ol/Tile.js +++ b/src/ol/Tile.js @@ -9,9 +9,9 @@ goog.require('ol.event.Events'); * The Tile class. * @constructor * @param {string} url - * @param {ol.Bounds} bounds + * @param {ol.Bounds|undefined} opt_bounds */ -ol.Tile = function(url, bounds) { +ol.Tile = function(url, opt_bounds) { /** * @private @@ -21,9 +21,9 @@ ol.Tile = function(url, bounds) { /** * @private - * @type {ol.Bounds} + * @type {ol.Bounds|undefined} */ - this.bounds_ = bounds; + this.bounds_ = opt_bounds; /** * @private @@ -66,7 +66,7 @@ ol.Tile.prototype.createImage = function() { * Load the tile. A tile should loaded only once. */ ol.Tile.prototype.load = function() { - goog.asserts.assert(!this.loaded && this.loading_); + goog.asserts.assert(!this.loaded && !this.loading_); this.loading_ = true; this.img_.src = this.url_; }; @@ -81,7 +81,7 @@ ol.Tile.prototype.getUrl = function() { /** * Get the tile bounds. - * @return {ol.Bounds} + * @return {ol.Bounds|undefined} */ ol.Tile.prototype.getBounds = function() { return this.bounds_; @@ -155,15 +155,15 @@ ol.Tile.createImage = (function() { * for the tiles. * @param {number} width * @param {number} height - * @return {function(new:ol.Tile, string, ol.Bounds)} + * @return {function(new:ol.Tile, string, ol.Bounds=)} */ ol.Tile.createConstructor = function(width, height) { /** * @constructor * @extends {ol.Tile} */ - var Tile = function(url, bounds) { - goog.base(this, url, bounds); + var Tile = function(url, opt_bounds) { + goog.base(this, url, opt_bounds); }; goog.inherits(Tile, ol.Tile); /** @inheritDoc */ diff --git a/src/ol/layer/TileLayer.js b/src/ol/layer/TileLayer.js index 29164f7960..146e56b1b4 100644 --- a/src/ol/layer/TileLayer.js +++ b/src/ol/layer/TileLayer.js @@ -42,7 +42,7 @@ ol.layer.TileLayer = function() { /** * @protected - * @type {function(new:ol.Tile, string, ol.Bounds)} + * @type {function(new:ol.Tile, string, ol.Bounds=)} */ this.Tile = ol.Tile.createConstructor(this.tileWidth_, this.tileHeight_); @@ -285,6 +285,25 @@ ol.layer.TileLayer.prototype.getTile = function(url, bounds) { return tile; }; +/** + * Get a tile from the cache, or create a tile and add to + * the cache. + * @param {number} x + * @param {number} y + * @param {number} z + */ +ol.layer.TileLayer.prototype.getTileForXYZ = function(x, y, z) { + var url = this.url_.replace('{x}', x + '') + .replace('{y}', y + '') + .replace('{z}', z + ''); + var tile = this.cache_.get(url); + if (!goog.isDef(tile)) { + tile = new this.Tile(url); + this.cache_.set(tile.getUrl(), tile); + } + return tile; +}; + /** * Get data from the layer. This is the layer's main API function. * @param {ol.Bounds} bounds diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js index f34a1794f8..275b273480 100644 --- a/test/spec/ol/layer/TileLayer.test.js +++ b/test/spec/ol/layer/TileLayer.test.js @@ -329,4 +329,26 @@ describe('ol.layer.TileLayer', function() { }); }); + + describe('get a tile', function() { + var layer; + + beforeEach(function() { + layer = new ol.layer.TileLayer(); + layer.setUrl('/{z}/{x}/{y}'); + layer.setResolutions([1, 0.5, 0.25]); + layer.setTileOrigin(-128, 128); + }); + + it('returns the expected tile', function() { + var tile = layer.getTileForXYZ(1, 2, 2); + expect(tile.getUrl()).toEqual('/2/1/2'); + //var bounds = tile.getBounds(); + //expect(bounds.getMinX()).toEqual(-64); + //expect(bounds.getMinY()).toEqual(0); + //expect(bounds.getMaxX()).toEqual(0); + //expect(bounds.getMaxY()).toEqual(64); + }); + + }); }); From ef06bee2225c6d4b1254ebab4013c1665a81d740 Mon Sep 17 00:00:00 2001 From: Tim Schaub Date: Fri, 22 Jun 2012 15:42:42 +0200 Subject: [PATCH 04/18] Allowing people to set up things backwards. --- src/ol/layer/TileLayer.js | 39 ++++++++++++++++++++++++++++ test/spec/ol/layer/TileLayer.test.js | 20 ++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/src/ol/layer/TileLayer.js b/src/ol/layer/TileLayer.js index 146e56b1b4..ba6e7066bf 100644 --- a/src/ol/layer/TileLayer.js +++ b/src/ol/layer/TileLayer.js @@ -70,6 +70,18 @@ ol.layer.TileLayer = function() { */ this.maxResolution_ = undefined; + /** + * @private + * @type {boolean} + */ + this.xRight_ = true; + + /** + * @private + * @type {boolean} + */ + this.yDown_ = true; + /** * @private * @type {number|undefined} @@ -92,6 +104,33 @@ ol.layer.TileLayer = function() { goog.inherits(ol.layer.TileLayer, ol.layer.Layer); +/** + * @return {boolean} The tile index increases from left to right. + */ +ol.layer.TileLayer.prototype.getXRight = function() { + return this.xRight_; +}; + +/** + * @return {boolean} The tile index increases from top to bottom. + */ +ol.layer.TileLayer.prototype.getYDown = function() { + return this.yDown_; +}; + +/** + * @param {boolean} right The tile index increases from left to right. + */ +ol.layer.TileLayer.prototype.setXRight = function(right) { + this.xRight_ = right; +}; + +/** + * @param {boolean} down The tile index increases from top to bottom. + */ +ol.layer.TileLayer.prototype.setYDown = function(down) { + this.yDown_ = down; +}; /** * Get layer extent. Return null if the layer has no extent diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js index 275b273480..3c6ccd8481 100644 --- a/test/spec/ol/layer/TileLayer.test.js +++ b/test/spec/ol/layer/TileLayer.test.js @@ -22,6 +22,26 @@ describe('ol.layer.TileLayer', function() { }); }); + describe('axis orientation', function() { + var layer = new ol.layer.TileLayer(); + + it('increases from left to right by default', function() { + expect(layer.getXRight()).toBe(true); + }); + it('increases from top to bottom by default', function() { + expect(layer.getYDown()).toBe(true); + }); + + it('allows people to set things backwards', function() { + var backwards = new ol.layer.TileLayer(); + backwards.setXRight(false); + expect(backwards.getXRight()).toBe(false); + backwards.setYDown(false); + expect(backwards.getYDown()).toBe(false); + }); + + }); + describe('get tile origin', function() { var layer; From 1df7c048b84c7accef5c52c4de759815aee64a69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Lemoine?= Date: Fri, 22 Jun 2012 15:41:37 +0200 Subject: [PATCH 05/18] [ol.layer.TileLayer] tileOriginCorner is tl by default --- src/ol/layer/TileLayer.js | 2 +- test/spec/ol/layer/TileLayer.test.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ol/layer/TileLayer.js b/src/ol/layer/TileLayer.js index ba6e7066bf..d56f4a55a8 100644 --- a/src/ol/layer/TileLayer.js +++ b/src/ol/layer/TileLayer.js @@ -62,7 +62,7 @@ ol.layer.TileLayer = function() { * @private * @type {string} */ - this.tileOriginCorner_ = 'bl'; + this.tileOriginCorner_ = 'tl'; /** * @private diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js index 3c6ccd8481..5bd291d6ef 100644 --- a/test/spec/ol/layer/TileLayer.test.js +++ b/test/spec/ol/layer/TileLayer.test.js @@ -70,7 +70,7 @@ describe('ol.layer.TileLayer', function() { it('returns the expected origin', function() { var origin = layer.getTileOrigin(); - expect(origin).toEqual([-180, -90]); + expect(origin).toEqual([-180, 90]); }); }); From e5c3dcfe098ceeeba3857ae6a16cd133aa2263ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Lemoine?= Date: Fri, 22 Jun 2012 15:43:00 +0200 Subject: [PATCH 06/18] [ol.layer.TileLayer] fix maxResolution calculation --- src/ol/layer/TileLayer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ol/layer/TileLayer.js b/src/ol/layer/TileLayer.js index d56f4a55a8..19af4a20db 100644 --- a/src/ol/layer/TileLayer.js +++ b/src/ol/layer/TileLayer.js @@ -211,7 +211,7 @@ ol.layer.TileLayer.prototype.getMaxResolution = function() { if (!goog.isNull(extent)) { this.maxResolution_ = Math.max( (extent.getMaxX() - extent.getMinX()) / this.tileWidth_, - (extent.getMaxY() - extent.getMaxX()) / this.tileHeight_); + (extent.getMaxY() - extent.getMinY()) / this.tileHeight_); } } return this.maxResolution_; From 65ae7eb7a7f385ed08fb414b878b705001f010df Mon Sep 17 00:00:00 2001 From: ahocevar Date: Fri, 22 Jun 2012 15:58:33 +0200 Subject: [PATCH 07/18] Adding 'object' property to event object. --- src/ol/event/Events.js | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/ol/event/Events.js b/src/ol/event/Events.js index d333176e1e..ca65cf4438 100644 --- a/src/ol/event/Events.js +++ b/src/ol/event/Events.js @@ -219,6 +219,8 @@ ol.event.Events.prototype.unregister = function(type, listener, opt_scope) { * * @param {string} type The type of the event to trigger. * @param {Object=} opt_evt The event object that will be passed to listeners. + * This object will always have a 'type' property with the event type and + * an 'object' property referencing this Events instance. * * @return {boolean} The last listener return. If a listener returns false, * the chain of listeners will stop getting called. @@ -228,8 +230,9 @@ ol.event.Events.prototype.triggerEvent = function(type, opt_evt) { listeners = goog.events.getListeners(this, type, true) .concat(goog.events.getListeners(this, type, false)); if (arguments.length === 1) { - opt_evt = {type: type}; + opt_evt = {'type': type}; } + opt_evt['object'] = this.object_; for (var i=0, ii=listeners.length; i Date: Fri, 22 Jun 2012 16:14:07 +0200 Subject: [PATCH 08/18] Get closest resolution. --- src/ol/renderer/TileLayerRenderer.js | 28 +++++++++- .../ol/renderer/TileLayerRenderer.test.js | 56 +++++++++++++++++++ 2 files changed, 83 insertions(+), 1 deletion(-) diff --git a/src/ol/renderer/TileLayerRenderer.js b/src/ol/renderer/TileLayerRenderer.js index 0ea501e38b..df7e66098e 100644 --- a/src/ol/renderer/TileLayerRenderer.js +++ b/src/ol/renderer/TileLayerRenderer.js @@ -26,6 +26,12 @@ ol.renderer.TileLayerRenderer = function(container, layer) { * @private */ this.rendererdBounds_ = null; + + /** + * @type {Array.} + */ + this.layerResolutions_ = layer.getResolutions(); + /** * @type {number|undefined} @@ -43,7 +49,27 @@ ol.renderer.TileLayerRenderer = function(container, layer) { goog.inherits(ol.renderer.TileLayerRenderer, ol.renderer.LayerRenderer); - +/** + * @param {number} resolution + * @return {Array.} + */ +ol.renderer.TileLayerRenderer.prototype.getPreferredResAndZ_ = function(resolution) { + var minDiff = Number.POSITIVE_INFINITY; + var candidate, diff, z, r; + for (var i=0, ii=this.layerResolutions_.length; i Date: Fri, 22 Jun 2012 16:05:03 +0200 Subject: [PATCH 09/18] Add a basic geometry interface --- src/ol/geom/Geometry.js | 21 ++++++++++++++++++--- src/ol/geom/IGeometry.js | 27 +++++++++++++++++++++++++++ 2 files changed, 45 insertions(+), 3 deletions(-) create mode 100644 src/ol/geom/IGeometry.js diff --git a/src/ol/geom/Geometry.js b/src/ol/geom/Geometry.js index 9378df6ebc..c8ef578e90 100644 --- a/src/ol/geom/Geometry.js +++ b/src/ol/geom/Geometry.js @@ -1,11 +1,13 @@ goog.provide('ol.geom.Geometry'); +goog.require('ol.geom.IGeometry'); goog.require('ol.Bounds'); /** * Creates ol.Geometry objects. * * @export + * @implements {ol.geom.IGeometry} * @constructor */ ol.geom.Geometry = function() { @@ -34,10 +36,23 @@ ol.geom.Geometry.prototype.setBounds = function(bounds) { }; /** - * @returns ol.Loc + * Returns the centroid of the geometry. + * + * @returns {ol.geom.Point} The centroid of the geometry. */ ol.geom.Geometry.prototype.getCentroid = function() { - //FIXME: stub only to get popups working - return new ol.Loc(-76,45); + // throw an error to enforce subclasses to implement it properly + ol.error('ol.geom.Geometry: getCentroid must be implemented by subclasses'); + return null; }; +/** + * Returns the area of the geometry. + * + * @returns {number} The area of the geometry. + */ +ol.geom.Geometry.prototype.getArea = function() { + // throw an error to enforce subclasses to implement it properly + ol.error('ol.geom.Geometry: getArea must be implemented by subclasses'); + return 0; +}; diff --git a/src/ol/geom/IGeometry.js b/src/ol/geom/IGeometry.js new file mode 100644 index 0000000000..c950be388a --- /dev/null +++ b/src/ol/geom/IGeometry.js @@ -0,0 +1,27 @@ +goog.provide('ol.geom.IGeometry'); + +//goog.require('ol.geom.Point'); +//goog.require('ol.Bounds'); + +/** + * Interface for geometry classes forcing ol.geom.* classes to implement + * expected functionality. + * + * @interface + */ +ol.geom.IGeometry = function(){}; + +/** + * @return {ol.geom.Point} The centroid of the geometry. + */ +ol.geom.IGeometry.prototype.getCentroid = function(){}; + +/** + * @return {ol.Bounds|undefined} The centroid of the geometry. + */ +ol.geom.IGeometry.prototype.getBounds = function(){}; + +/** + * @return {number} The area of the geometry. + */ +ol.geom.IGeometry.prototype.getArea = function(){}; \ No newline at end of file From 1456e234e264919b76a12b16b9adc130447dfed1 Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:11:17 +0200 Subject: [PATCH 10/18] Whitespace changes only. --- src/ol/geom/Geometry.js | 10 +++++----- src/ol/geom/IGeometry.js | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/ol/geom/Geometry.js b/src/ol/geom/Geometry.js index c8ef578e90..2ed4420624 100644 --- a/src/ol/geom/Geometry.js +++ b/src/ol/geom/Geometry.js @@ -1,17 +1,17 @@ -goog.provide('ol.geom.Geometry'); +goog.provide('ol.geom.Geometry'); goog.require('ol.geom.IGeometry'); goog.require('ol.Bounds'); /** * Creates ol.Geometry objects. - * + * * @export * @implements {ol.geom.IGeometry} * @constructor */ ol.geom.Geometry = function() { - + /** * @private * @type {ol.Bounds|undefined} @@ -37,7 +37,7 @@ ol.geom.Geometry.prototype.setBounds = function(bounds) { /** * Returns the centroid of the geometry. - * + * * @returns {ol.geom.Point} The centroid of the geometry. */ ol.geom.Geometry.prototype.getCentroid = function() { @@ -48,7 +48,7 @@ ol.geom.Geometry.prototype.getCentroid = function() { /** * Returns the area of the geometry. - * + * * @returns {number} The area of the geometry. */ ol.geom.Geometry.prototype.getArea = function() { diff --git a/src/ol/geom/IGeometry.js b/src/ol/geom/IGeometry.js index c950be388a..2245be339c 100644 --- a/src/ol/geom/IGeometry.js +++ b/src/ol/geom/IGeometry.js @@ -4,9 +4,9 @@ goog.provide('ol.geom.IGeometry'); //goog.require('ol.Bounds'); /** - * Interface for geometry classes forcing ol.geom.* classes to implement + * Interface for geometry classes forcing ol.geom.* classes to implement * expected functionality. - * + * * @interface */ ol.geom.IGeometry = function(){}; From 09d7f15fb26fdb76e3bac73509cf76c672369780 Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:15:49 +0200 Subject: [PATCH 11/18] Give points a getCentroid/centroid method. --- src/api/geom/point.js | 23 +++++++++++------ src/ol/geom/Point.js | 37 +++++++++++++++++++-------- test/spec/api/geom/point.test.js | 43 ++++++++++++++++++++++++++++++++ test/spec/ol/geom/Point.test.js | 23 +++++++++++++++++ 4 files changed, 109 insertions(+), 17 deletions(-) diff --git a/src/api/geom/point.js b/src/api/geom/point.js index 601ea2e047..bf8434b243 100644 --- a/src/api/geom/point.js +++ b/src/api/geom/point.js @@ -1,4 +1,4 @@ -goog.provide('ol.geom.point'); +goog.provide('ol.geom.point'); goog.require('ol.geom.Point'); goog.require('ol.projection'); @@ -14,23 +14,23 @@ ol.PointLike; * @return {ol.geom.Point} Point. */ ol.geom.point = function(opt_arg){ - + if (opt_arg instanceof ol.geom.Point) { return opt_arg; } - + var x = 0; var y = 0; var z; var projection; - + if (arguments.length == 1 && goog.isDef(opt_arg)) { if (goog.isArray(opt_arg)) { x = opt_arg[0]; y = opt_arg[1]; z = opt_arg[2]; projection = opt_arg[3]; - + } else if (goog.isObject(opt_arg)) { x = opt_arg['x']; y = opt_arg['y']; @@ -43,7 +43,7 @@ ol.geom.point = function(opt_arg){ if (goog.isDef(projection)) { projection = ol.projection(projection); } - + var p = new ol.geom.Point(x,y,z,projection); return p; }; @@ -110,4 +110,13 @@ ol.geom.Point.prototype.projection = function(opt_arg){ else { return this.getProjection(); } -}; \ No newline at end of file +}; + +/** + * Returns the centroid of this point; which is a clone of the point itself. + * + * @return {ol.geom.Point} The centroid. + */ +ol.geom.Point.prototype.centroid = function() { + return this.getCentroid(); +}; diff --git a/src/ol/geom/Point.js b/src/ol/geom/Point.js index bcc4d07b78..c1471b3809 100644 --- a/src/ol/geom/Point.js +++ b/src/ol/geom/Point.js @@ -7,17 +7,17 @@ goog.require('ol.coord.AccessorInterface'); goog.require('ol.base'); /** - * Creates ol.geom.Point objects. - * + * Creates ol.geom.Point objects. + * * @export * @extends {ol.geom.Geometry} * @param {number} x X. * @param {number} y Y. * @param {number=} opt_z Z. * @param {ol.Projection=} opt_projection Projection. - * + * * @implements {ol.coord.AccessorInterface} - * + * * @constructor */ ol.geom.Point = function(x, y, opt_z, opt_projection) { @@ -26,19 +26,19 @@ ol.geom.Point = function(x, y, opt_z, opt_projection) { * @type {number} */ this.x_ = x; - + /** * @private * @type {number} */ this.y_ = y; - + /** * @private * @type {number|undefined} */ this.z_ = opt_z; - + /** * @private * @type {ol.Projection} @@ -109,12 +109,12 @@ ol.geom.Point.prototype.setZ = function(z) { }; /** - * Transform this point to another coordinate reference system. This + * Transform this point to another coordinate reference system. This * requires that this point has a projection set already (if not, an error * will be thrown). Returns a new point object and does not modify this * point. * - * @param {string|!ol.Projection} proj The destination projection. Can be + * @param {string|!ol.Projection} proj The destination projection. Can be * supplied as a projection instance of a string identifier. * @returns {!ol.geom.Point} A new location. */ @@ -140,7 +140,24 @@ ol.geom.Point.prototype._transform = function(proj) { ol.error(msg); } ol.Projection.transform(point, sourceProj, proj); - + return new ol.geom.Point(point['x'], point['y'], this.z_, proj); }; +/** + * Returns the centroid of the point. + * + * @returns {ol.geom.Point} The centroid of the point. + */ +ol.geom.Point.prototype.getCentroid = function() { + return new ol.geom.Point(this.x_, this.y_, this.z_, this.projection_); +}; + +/** + * Returns the area of the geometry whcih is always 0. + * + * @returns {number} The area of the point (always 0). + */ +ol.geom.Point.prototype.getArea = function() { + return 0; +}; diff --git a/test/spec/api/geom/point.test.js b/test/spec/api/geom/point.test.js index 897d1490a9..75bfa50ac3 100644 --- a/test/spec/api/geom/point.test.js +++ b/test/spec/api/geom/point.test.js @@ -166,4 +166,47 @@ describe("ol.geom.point", function() { expect(p_obj.projection()).toEqual(jasmine.any(ol.Projection)); }); }); + + describe("the centroid method is functional", function(){ + it("returns an instance of ol.geom.Point", function(){ + expect(pNoZ_arr.centroid()).toBeA(ol.geom.Point); + expect(pWithZ_arr.centroid()).toBeA(ol.geom.Point); + expect(p_arr.centroid()).toBeA(ol.geom.Point); + + expect(pNoZ_obj.centroid()).toBeA(ol.geom.Point); + expect(pWithZ_obj.centroid()).toBeA(ol.geom.Point); + expect(p_obj.centroid()).toBeA(ol.geom.Point); + }); + + it("does return a clone and not the point itself", function(){ + expect(pNoZ_arr.centroid()).not.toBe(pNoZ_arr); + expect(pWithZ_arr.centroid()).not.toBe(pWithZ_arr); + expect(p_arr.centroid()).not.toBe(p_arr); + + expect(pNoZ_obj.centroid()).not.toBe(pNoZ_obj); + expect(pWithZ_obj.centroid()).not.toBe(pWithZ_obj); + expect(p_obj.centroid()).not.toBe(p_obj); + }); + + it("has the expected coordinates", function(){ + var c1 = pNoZ_arr.centroid(), + c2 = pWithZ_arr.centroid(), + c3 = p_arr.centroid(), + c4 = pNoZ_obj.centroid(), + c5 = pWithZ_obj.centroid(), + c6 = p_obj.centroid(); + + expect(c1.x() + ',' + c1.y()).toBe('21,4'); + expect(c2.x() + ',' + c2.y()).toBe('21,4'); + expect(c3.x() + ',' + c3.y()).toBe('21,4'); + expect(c4.x() + ',' + c4.y()).toBe('21,4'); + expect(c5.x() + ',' + c5.y()).toBe('21,4'); + expect(c6.x() + ',' + c6.y()).toBe('21,4'); + }); + + it("returns point(0,0) when the point was constructed without args", function(){ + var c = pNoArgs.centroid(); + expect(c.x() + ',' + c.y()).toBe('0,0'); + }); + }); }); diff --git a/test/spec/ol/geom/Point.test.js b/test/spec/ol/geom/Point.test.js index 835761a971..6ffcb12b2f 100644 --- a/test/spec/ol/geom/Point.test.js +++ b/test/spec/ol/geom/Point.test.js @@ -123,4 +123,27 @@ describe("ol.geom.Point", function() { }); }); + describe("the getCentroid method is functional", function(){ + it("returns an instance of ol.geom.Point", function(){ + expect(p2Args.getCentroid()).toBeA(ol.geom.Point); + expect(p3Args.getCentroid()).toBeA(ol.geom.Point); + expect(p4Args.getCentroid()).toBeA(ol.geom.Point); + }); + + it("does return a clone and not the point itself", function(){ + expect(p2Args.getCentroid()).not.toBe(p2Args); + expect(p3Args.getCentroid()).not.toBe(p3Args); + expect(p4Args.getCentroid()).not.toBe(p4Args); + }); + + it("has the expected coordinates", function(){ + var c2 = p2Args.getCentroid(), + c3 = p3Args.getCentroid(), + c4 = p4Args.getCentroid(); + + expect(c2.getX() + ',' + c2.getY()).toBe('21,4'); + expect(c3.getX() + ',' + c3.getY()).toBe('21,4'); + expect(c4.getX() + ',' + c4.getY()).toBe('21,4'); + }); + }); }); From e23b1190596c09ae419495aa839663a5e3a82060 Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:20:42 +0200 Subject: [PATCH 12/18] Whitespace changes only. --- src/api/geom/collection.js | 20 +++--- src/api/geom/geometry.js | 4 +- src/api/geom/linestring.js | 16 ++--- src/api/geom/multipoint.js | 20 +++--- src/ol/geom/Collection.js | 44 ++++++------- src/ol/geom/LineString.js | 17 ++--- src/ol/geom/MultiPoint.js | 16 ++--- test/spec/api/geom/collection.test.js | 80 +++++++++++------------ test/spec/api/geom/geom.test.js | 28 ++++---- test/spec/api/geom/linestring.test.js | 94 +++++++++++++-------------- test/spec/api/geom/multipoint.test.js | 94 +++++++++++++-------------- test/spec/ol/geom/Collection.test.js | 62 +++++++++--------- test/spec/ol/geom/LineString.test.js | 56 ++++++++-------- test/spec/ol/geom/MultiPoint.test.js | 60 ++++++++--------- 14 files changed, 306 insertions(+), 305 deletions(-) diff --git a/src/api/geom/collection.js b/src/api/geom/collection.js index c1405e7e78..e8269676a9 100644 --- a/src/api/geom/collection.js +++ b/src/api/geom/collection.js @@ -1,7 +1,7 @@ -goog.provide('ol.geom.collection'); +goog.provide('ol.geom.collection'); goog.require('ol.geom.Collection'); -goog.require('ol.geom.point'); +goog.require('ol.geom.point'); goog.require('ol.projection'); /** @@ -10,11 +10,11 @@ goog.require('ol.projection'); * @return {ol.geom.Collection} Collection. */ ol.geom.collection = function(opt_arg){ - + if (opt_arg instanceof ol.geom.Collection) { return opt_arg; } - + var components = []; if (arguments.length == 1 && goog.isDef(opt_arg)) { if (goog.isArray(opt_arg)) { @@ -35,7 +35,7 @@ ol.geom.collection = function(opt_arg){ throw new Error('ol.geom.collection'); } } - + var c = new ol.geom.Collection(components); return c; }; @@ -50,7 +50,7 @@ ol.geom.Collection.prototype.components = function(opt_arg){ if (arguments.length == 1 && goog.isDef(opt_arg)) { var components = [], allValid = false; - + allValid = goog.array.every(opt_arg, function(geom){ if (geom instanceof ol.geom.Geometry) { components.push(geom); @@ -90,23 +90,23 @@ ol.geom.Collection.prototype.add = function(geom, opt_index){ * @export * @param {Array.} components Some point specifications. * @param {number=} opt_index An optional index to add the components at. If not - * provided, the components will be added to the end of the list of + * provided, the components will be added to the end of the list of * components. * @return {ol.geom.Collection} The Collection instance. */ ol.geom.Collection.prototype.addAll = function(components, opt_index){ var index = this.components_.length; - + if (arguments.length == 2 && goog.isDef(opt_index)) { index = opt_index; } - + goog.array.every(components, function(c){ this.addComponent(c, index); index++; return true; }, this); - + return this; }; diff --git a/src/api/geom/geometry.js b/src/api/geom/geometry.js index 6a636cc839..3e12f9f0e7 100644 --- a/src/api/geom/geometry.js +++ b/src/api/geom/geometry.js @@ -1,4 +1,4 @@ -goog.provide('ol.geom.geometry'); +goog.provide('ol.geom.geometry'); goog.require('ol.geom.Geometry'); @@ -14,7 +14,7 @@ ol.geom.geometry = function(){ /** * @export * @param {ol.Bounds=} opt_arg new Bounds. - * @return {ol.geom.Geometry|ol.Bounds|undefined} either a Geometry (when used as + * @return {ol.geom.Geometry|ol.Bounds|undefined} either a Geometry (when used as * setter) or a Bounds/undefined (if used as getter). */ ol.geom.Geometry.prototype.bounds = function(opt_arg) { diff --git a/src/api/geom/linestring.js b/src/api/geom/linestring.js index 61c0ee28a6..a3c3bc3431 100644 --- a/src/api/geom/linestring.js +++ b/src/api/geom/linestring.js @@ -1,7 +1,7 @@ -goog.provide('ol.geom.linestring'); +goog.provide('ol.geom.linestring'); goog.require('ol.geom.LineString'); -goog.require('ol.geom.point'); +goog.require('ol.geom.point'); goog.require('ol.projection'); /** @@ -10,11 +10,11 @@ goog.require('ol.projection'); * @return {ol.geom.LineString} LineString. */ ol.geom.linestring = function(opt_arg){ - + if (opt_arg instanceof ol.geom.LineString) { return opt_arg; } - + var vertices = []; if (arguments.length == 1 && goog.isDef(opt_arg)) { if (goog.isArray(opt_arg)) { @@ -36,7 +36,7 @@ ol.geom.linestring = function(opt_arg){ throw new Error('ol.geom.linestring'); } } - + var ls = new ol.geom.LineString(vertices); return ls; }; @@ -99,18 +99,18 @@ ol.geom.LineString.prototype.add = function(vertex, opt_index){ ol.geom.LineString.prototype.addAll = function(vertices, opt_index){ var index = this.vertices_.length, v; - + if (arguments.length == 2 && goog.isDef(opt_index)) { index = opt_index; } - + goog.array.every(vertices, function(vertexSpec){ v = ol.geom.point(vertexSpec); this.addVertex(v, index); index++; return true; }, this); - + return this; }; diff --git a/src/api/geom/multipoint.js b/src/api/geom/multipoint.js index e72af8c3c7..5ca6ec317e 100644 --- a/src/api/geom/multipoint.js +++ b/src/api/geom/multipoint.js @@ -1,8 +1,8 @@ -goog.provide('ol.geom.multipoint'); +goog.provide('ol.geom.multipoint'); goog.require('ol.geom.MultiPoint'); -goog.require('ol.geom.point'); -goog.require('ol.geom.collection'); +goog.require('ol.geom.point'); +goog.require('ol.geom.collection'); goog.require('ol.projection'); /** @@ -11,11 +11,11 @@ goog.require('ol.projection'); * @return {ol.geom.MultiPoint} MultiPoint. */ ol.geom.multipoint = function(opt_arg){ - + if (opt_arg instanceof ol.geom.MultiPoint) { return opt_arg; } - + var points = []; if (arguments.length == 1 && goog.isDef(opt_arg)) { if (goog.isArray(opt_arg)) { @@ -37,7 +37,7 @@ ol.geom.multipoint = function(opt_arg){ throw new Error('ol.geom.multipoint'); } } - + var mp = new ol.geom.MultiPoint(points); return mp; }; @@ -99,18 +99,18 @@ ol.geom.MultiPoint.prototype.add = function(point, opt_index){ ol.geom.MultiPoint.prototype.addAll = function(points, opt_index){ var index = this.getPoints().length, p; - + if (arguments.length == 2 && goog.isDef(opt_index)) { index = opt_index; } - + goog.array.every(points, function(pointSpec){ p = ol.geom.point(pointSpec); this.addPoint(p, index); index++; return true; }, this); - + return this; }; @@ -132,6 +132,6 @@ ol.geom.MultiPoint.prototype.remove = function(points){ this.removePoint(p); return true; }, this); - + return this; }; diff --git a/src/ol/geom/Collection.js b/src/ol/geom/Collection.js index 91ee3f0415..78a9becd5e 100644 --- a/src/ol/geom/Collection.js +++ b/src/ol/geom/Collection.js @@ -6,16 +6,16 @@ goog.require('ol.Projection'); goog.require('ol.base'); /** - * Creates ol.geom.Collection objects. - * + * Creates ol.geom.Collection objects. + * * @export * @extends {ol.geom.Geometry} * @param {Array.} components An array of components. - * + * * @constructor */ ol.geom.Collection = function(components) { - + /** * @private * @type {Array.} @@ -23,19 +23,19 @@ ol.geom.Collection = function(components) { this.typeBlacklist_ = [ ol.geom.Collection ]; - + /** * @private * @type {Array.} */ this.typeWhitelist_ = []; - + /** * @private * @type {Array.} */ this.components_ = []; - + if (arguments.length === 1 && goog.isDef(components)) { this.setComponents(components); } @@ -44,14 +44,14 @@ ol.geom.Collection = function(components) { goog.inherits(ol.geom.Collection, ol.geom.Geometry); /** - * Sets the list of disallowed types for the collection. + * Sets the list of disallowed types for the collection. * @param {Array.} typeBlacklist Array of constructors to disallow. */ ol.geom.Collection.prototype.setTypeBlacklist = function(typeBlacklist){ this.typeBlacklist_ = typeBlacklist; }; /** - * Gets the list of disallowed types for the collection. + * Gets the list of disallowed types for the collection. * @return {Array.} Array of constructors to disallow. */ ol.geom.Collection.prototype.getTypeBlacklist = function(){ @@ -59,14 +59,14 @@ ol.geom.Collection.prototype.getTypeBlacklist = function(){ }; /** - * Sets the list of always allowed types for the collection. + * Sets the list of always allowed types for the collection. * @param {Array.} typeWhitelist Array of constructors to allow. */ ol.geom.Collection.prototype.setTypeWhitelist = function(typeWhitelist){ this.typeWhitelist_ = typeWhitelist; }; /** - * Gets the list of always allowed types for the collection. + * Gets the list of always allowed types for the collection. * @return {Array.} Array of constructors to allow. */ ol.geom.Collection.prototype.getTypeWhitelist = function(){ @@ -76,7 +76,7 @@ ol.geom.Collection.prototype.getTypeWhitelist = function(){ /** * Sets the Collection's components. - * + * * @return {Array.} An array of components. */ ol.geom.Collection.prototype.getComponents = function() { @@ -85,12 +85,12 @@ ol.geom.Collection.prototype.getComponents = function() { /** * Gets the Collection's components. - * + * * @param {Array.} components An array of components. */ ol.geom.Collection.prototype.setComponents = function(components) { var allValidTypes = goog.array.every( - components, + components, this.isAllowedComponent, this ); @@ -105,7 +105,7 @@ ol.geom.Collection.prototype.setComponents = function(components) { /** * Adds the given component to the list of components at the specified index. - * + * * @param {ol.geom.Geometry} component A component to be added. * @param {number} index The index where to add. */ @@ -121,14 +121,14 @@ ol.geom.Collection.prototype.addComponent = function(component, index) { /** * Checks whether the passed component is an instance of any of the constructors * listed in the passed list. - * + * * @param {ol.geom.Geometry} component The component to check. - * @param {Array.} list The List of constructors to check the + * @param {Array.} list The List of constructors to check the * component against. - * - * @return {boolean} Whether the passed component is an instance of any of the + * + * @return {boolean} Whether the passed component is an instance of any of the * constructors listed in the passed list. - * + * * @private */ ol.geom.Collection.prototype.isOnList = function(component, list) { @@ -143,9 +143,9 @@ ol.geom.Collection.prototype.isOnList = function(component, list) { }; /** - * Checks whether the passed component is allowed according to the black and + * Checks whether the passed component is allowed according to the black and * whitelists. - * + * * @param {ol.geom.Geometry} component The component to check. * @return {boolean} Whether the passed component is allowed as part of this * collection according to black- and whitelist. diff --git a/src/ol/geom/LineString.js b/src/ol/geom/LineString.js index af8a857659..1f449f0102 100644 --- a/src/ol/geom/LineString.js +++ b/src/ol/geom/LineString.js @@ -2,17 +2,18 @@ goog.provide('ol.geom.LineString'); goog.require('goog.array'); goog.require('ol.geom.Geometry'); +goog.require('ol.geom.Collection'); goog.require('ol.geom.Point'); goog.require('ol.Projection'); /** - * Creates ol.geom.LineString objects. - * + * Creates ol.geom.LineString objects. + * * @export * @extends {ol.geom.Geometry} - * @param {Array.} vertices An array of points building the + * @param {Array.} vertices An array of points building the * linestrings vertices. - * + * * @constructor */ ol.geom.LineString = function(vertices) { @@ -21,14 +22,14 @@ ol.geom.LineString = function(vertices) { * @type {Array.} */ this.vertices_ = vertices; - + }; goog.inherits(ol.geom.LineString, ol.geom.Geometry); /** * Sets the LineString's points. - * + * * @return {Array.} An array of points. */ ol.geom.LineString.prototype.getVertices = function() { @@ -37,7 +38,7 @@ ol.geom.LineString.prototype.getVertices = function() { /** * Gets the LineString's points. - * + * * @param {Array.} vertices An array of points. */ ol.geom.LineString.prototype.setVertices = function(vertices) { @@ -46,7 +47,7 @@ ol.geom.LineString.prototype.setVertices = function(vertices) { /** * Adds the given vertex to the list of vertices at the specified index. - * + * * @param {ol.geom.Point} vertex A point to be added. * @param {number} index The index where to add. */ diff --git a/src/ol/geom/MultiPoint.js b/src/ol/geom/MultiPoint.js index d271c17740..31db595017 100644 --- a/src/ol/geom/MultiPoint.js +++ b/src/ol/geom/MultiPoint.js @@ -4,12 +4,12 @@ goog.require('goog.array'); goog.require('ol.geom.Collection'); /** - * Creates ol.geom.MultiPoint objects. - * + * Creates ol.geom.MultiPoint objects. + * * @export * @extends {ol.geom.Collection} * @param {Array.} points An array of points. - * + * * @constructor */ ol.geom.MultiPoint = function(points) { @@ -18,14 +18,14 @@ ol.geom.MultiPoint = function(points) { if (arguments.length === 1 && goog.isDef(points)) { this.setPoints(points); } - + }; goog.inherits(ol.geom.MultiPoint, ol.geom.Collection); /** * Sets the MultiPoint's points. - * + * * @return {Array.} An array of points. */ ol.geom.MultiPoint.prototype.getPoints = function() { @@ -34,7 +34,7 @@ ol.geom.MultiPoint.prototype.getPoints = function() { /** * Gets the MultiPoint's points. - * + * * @param {Array.} points An array of points. */ ol.geom.MultiPoint.prototype.setPoints = function(points) { @@ -43,7 +43,7 @@ ol.geom.MultiPoint.prototype.setPoints = function(points) { /** * Adds the given point to the list of points at the specified index. - * + * * @param {ol.geom.Point} point A point to be added. * @param {number} index The index where to add. */ @@ -53,7 +53,7 @@ ol.geom.MultiPoint.prototype.addPoint = function(point, index) { /** * Removes the given point from the list of points. - * + * * @param {ol.geom.Point} point A point to be removed. */ ol.geom.MultiPoint.prototype.removePoint = function(point) { diff --git a/test/spec/api/geom/collection.test.js b/test/spec/api/geom/collection.test.js index 23b36bb502..eaff90f748 100644 --- a/test/spec/api/geom/collection.test.js +++ b/test/spec/api/geom/collection.test.js @@ -1,4 +1,4 @@ -describe("ol.geom.collection", function() { +describe("ol.geom.collection", function() { var c; beforeEach(function() { c = ol.geom.collection([ @@ -9,7 +9,7 @@ describe("ol.geom.collection", function() { ]) ]); }); - + afterEach(function() { c = null; }); @@ -18,149 +18,149 @@ describe("ol.geom.collection", function() { expect( c ).toBeA( ol.geom.Collection ); }); }); - + describe("can construct instances without any components", function() { - + it("works with an empty array", function(){ c = ol.geom.collection([]); - + expect( c ).toBeA( ol.geom.Collection ); }); - + it("works without arguments", function(){ c = ol.geom.collection(); - + expect( c ).toBeA( ol.geom.Collection ); }); }); - + describe("the method 'add'", function() { it("exists", function(){ expect( c.add ).toBeA( Function ); }); - + describe("can be used as setter", function(){ it("works with a single point specification and an index", function(){ var p = ol.geom.point([24,7]); c.add(p, 0); - + expect(c.components().length).toBe(3); - + var firstComponent = c.components()[0]; - + expect( firstComponent.x() + ',' + firstComponent.y() ).toBe( '24,7' ); }); - + it("the index is functional", function(){ var p = ol.geom.point([24,7]); c.add(p, 1); - + expect(c.components().length).toBe(3); - + var firstComponent = c.components()[0], // untouched secondComponent = c.components()[1], // this should be ours thirdComponent = c.components()[2]; // shifted here - + expect( firstComponent.x() + ',' + firstComponent.y() ).toBe( '0,1' ); expect( secondComponent.x() + ',' + secondComponent.y() ).toBe( '24,7' ); expect( thirdComponent ).toBeA( ol.geom.LineString ); }); - + it("the index is optional", function(){ var p = ol.geom.point([24,7]); c.add(p); - + expect(c.components().length).toBe(3); - + var thirdComponent = c.components()[2]; expect( thirdComponent.x() + ',' + thirdComponent.y() ).toBe( '24,7' ); }); - + it("returns the collection instance", function(){ var p = ol.geom.point([24,7]); var returned = c.add(p); - + expect(returned).toBe(c); }); }); }); - + describe("the method 'addAll'", function(){ it("exists", function(){ expect( c.addAll ).toBeA( Function ); }); - + describe("can be used as setter", function(){ - + it("works with an array of points and an index", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point([7,11]) ]; c.addAll(ps, 0); - + expect(c.components().length).toBe(4); - + var firstComponent = c.components()[0], secondComponent = c.components()[1]; - + expect( firstComponent.x() + ',' + firstComponent.y() ).toBe( '24,7' ); expect( secondComponent.x() + ',' + secondComponent.y() ).toBe( '7,11' ); }); - + it("the index is functional", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point({x:7, y:11}) ]; c.addAll(ps, 1); - + expect(c.components().length).toBe(4); - + var firstComponent = c.components()[0], // untouched secondComponent = c.components()[1], // this should be ours thirdComponent = c.components()[2], // this should be ours fourthComponent = c.components()[3]; // shifted here - + expect( firstComponent.x() + ',' + firstComponent.y() ).toBe( '0,1' ); expect( secondComponent.x() + ',' + secondComponent.y() ).toBe( '24,7' ); expect( thirdComponent.x() + ',' + thirdComponent.y() ).toBe( '7,11' ); expect( fourthComponent ).toBeA( ol.geom.LineString ); }); - + it("the index is optional", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point({x:7, y:11}) ]; c.addAll(ps); - + expect(c.components().length).toBe(4); - + var thirdComponent = c.components()[2], fourthComponent = c.components()[3]; expect( thirdComponent.x() + ',' + thirdComponent.y() ).toBe( '24,7' ); expect( fourthComponent.x() + ',' + fourthComponent.y() ).toBe( '7,11' ); }); - + it("returns the collection instance", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point({x:7, y:11}) ]; var returned = c.addAll(ps); - + expect(returned).toBe(c); }); }); }); - - + + describe("the method 'remove'", function() { it("exists", function(){ expect( c.add ).toBeA( Function ); }); - + it("works with a single point", function(){ var p = c.components()[0]; c.remove(p); @@ -168,7 +168,7 @@ describe("ol.geom.collection", function() { var firstComponent = c.components()[0]; expect( firstComponent ).toBeA( ol.geom.LineString ); }); - + it("works with an array of point specifications", function(){ var ps = [ c.components()[1], diff --git a/test/spec/api/geom/geom.test.js b/test/spec/api/geom/geom.test.js index 230e238bda..2a3e9f4a20 100644 --- a/test/spec/api/geom/geom.test.js +++ b/test/spec/api/geom/geom.test.js @@ -1,45 +1,45 @@ -describe("ol.geom.geometry", function() { +describe("ol.geom.geometry", function() { var g; - + beforeEach(function() { g = ol.geom.geometry(); }); - + afterEach(function() { g = null; }); - - + + it("constructs instances", function() { expect( g ).toBeA( ol.geom.Geometry ); }); - + it("can set bounds", function() { var oldBounds = g.bounds(); - + expect(oldBounds).toBeUndefined(); - + var b = ol.bounds([0,1,2,3]); g.bounds(b); var gotBounds = g.bounds(); - + expect(gotBounds).not.toBeUndefined(); }); - + it("can get bounds", function() { var b = ol.bounds([0,1,2,3]); g.bounds(b); var gotBounds = g.bounds(); - + expect(gotBounds).toEqual(jasmine.any(ol.Bounds)); - + }); - + it("sets and gets the correct bounds", function() { var b = ol.bounds([0,1,2,3]); g.bounds(b); var gotBounds = g.bounds(); - + expect(gotBounds.minX()).toEqual(0); expect(gotBounds.minY()).toEqual(1); expect(gotBounds.maxX()).toEqual(2); diff --git a/test/spec/api/geom/linestring.test.js b/test/spec/api/geom/linestring.test.js index 356b5b1284..f0adcbc622 100644 --- a/test/spec/api/geom/linestring.test.js +++ b/test/spec/api/geom/linestring.test.js @@ -1,4 +1,4 @@ -describe("ol.geom.linestring", function() { +describe("ol.geom.linestring", function() { var ls; beforeEach(function() { ls = ol.geom.linestring([ @@ -6,7 +6,7 @@ describe("ol.geom.linestring", function() { {x:2, y:3} ]); }); - + afterEach(function() { ls = null; }); @@ -14,58 +14,58 @@ describe("ol.geom.linestring", function() { it("works for the object notation of vertices", function(){ expect( ls ).toBeA( ol.geom.LineString ); }); - + it("works for the array notation of vertices", function(){ ls = ol.geom.linestring([ [0, 1], [2, 3] ]); - + expect( ls ).toBeA( ol.geom.LineString ); }); - + it("works for real vertices", function(){ ls = ol.geom.linestring([ ol.geom.point([0,1]), ol.geom.point([2,3]) ]); - + expect( ls ).toBeA( ol.geom.LineString ); }); }); - + describe("can construct instances without any vertices", function() { - + it("works with an empty array", function(){ ls = ol.geom.linestring([]); - + expect( ls ).toBeA( ol.geom.LineString ); }); - + it("works without arguments", function(){ ls = ol.geom.linestring(); - + expect( ls ).toBeA( ol.geom.LineString ); }); }); - + describe("the method 'add'", function() { it("exists", function(){ expect( ls.add ).toBeA( Function ); }); - + describe("can be used as setter", function(){ it("works with a single vertex specification and an index", function(){ var p = ol.geom.point([24,7]); ls.add(p, 0); - + expect(ls.vertices().length).toBe(3); - + var firstPoint = ls.vertices()[0]; - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with point instance", function(){ ls = ol.geom.linestring(); ls.add(ol.geom.point([24,7])); @@ -73,7 +73,7 @@ describe("ol.geom.linestring", function() { var firstPoint = ls.vertices()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with array specifications", function(){ ls = ol.geom.linestring(); ls.add([24,7]); @@ -81,7 +81,7 @@ describe("ol.geom.linestring", function() { var firstPoint = ls.vertices()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with object specifications", function(){ ls = ol.geom.linestring(); ls.add({x:24,y:7}); @@ -89,117 +89,117 @@ describe("ol.geom.linestring", function() { var firstPoint = ls.vertices()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("the index is functional", function(){ var p = ol.geom.point([24,7]); ls.add(p, 1); - + expect(ls.vertices().length).toBe(3); - + var firstPoint = ls.vertices()[0], // untouched secondPoint = ls.vertices()[1], // this should be ours thirdPoint = ls.vertices()[2]; // shifted here - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' ); expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '2,3' ); }); - + it("the index is optional", function(){ var p = ol.geom.point([24,7]); ls.add(p); - + expect(ls.vertices().length).toBe(3); - + var thirdPoint = ls.vertices()[2]; expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' ); }); - + it("returns the linestring instance", function(){ var p = ol.geom.point([24,7]); var returned = ls.add(p); - + expect(returned).toBe(ls); }); }); }); - + describe("the method 'addAll'", function(){ it("exists", function(){ expect( ls.addAll ).toBeA( Function ); }); - + describe("can be used as setter", function(){ - + it("works with an array of point specifications and an index", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point([7,11]) ]; ls.addAll(ps, 0); - + expect(ls.vertices().length).toBe(4); - + var firstPoint = ls.vertices()[0], secondPoint = ls.vertices()[1]; - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '7,11' ); }); - + it("the index is functional", function(){ var ps = [ [24,7], {x:7, y:11} ]; ls.addAll(ps, 1); - + expect(ls.vertices().length).toBe(4); - + var firstPoint = ls.vertices()[0], // untouched secondPoint = ls.vertices()[1], // this should be ours thirdPoint = ls.vertices()[2], // this should be ours fourthPoint = ls.vertices()[3]; // shifted here - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' ); expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '7,11' ); expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '2,3' ); }); - + it("the index is optional", function(){ var ps = [ [24,7], {x:7, y:11} ]; ls.addAll(ps); - + expect(ls.vertices().length).toBe(4); - + var thirdPoint = ls.vertices()[2], fourthPoint = ls.vertices()[3]; expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' ); expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '7,11' ); }); - + it("returns the linestring instance", function(){ var ps = [ [24,7], {x:7, y:11} ]; var returned = ls.addAll(ps); - + expect(returned).toBe(ls); }); }); }); - - + + describe("the method 'remove'", function() { it("exists", function(){ expect( ls.add ).toBeA( Function ); }); - + it("works with a single point", function(){ var p = ls.vertices()[0]; ls.remove(p); @@ -207,7 +207,7 @@ describe("ol.geom.linestring", function() { var firstPoint = ls.vertices()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '2,3' ); }); - + it("works with an array of point specifications", function(){ var ps = [ ls.vertices()[1], diff --git a/test/spec/api/geom/multipoint.test.js b/test/spec/api/geom/multipoint.test.js index 4170389d3c..a7e409500c 100644 --- a/test/spec/api/geom/multipoint.test.js +++ b/test/spec/api/geom/multipoint.test.js @@ -1,4 +1,4 @@ -describe("ol.geom.multipoint", function() { +describe("ol.geom.multipoint", function() { var mp; beforeEach(function() { mp = ol.geom.multipoint([ @@ -6,7 +6,7 @@ describe("ol.geom.multipoint", function() { {x:2, y:3} ]); }); - + afterEach(function() { mp = null; }); @@ -14,58 +14,58 @@ describe("ol.geom.multipoint", function() { it("works for the object notation of points", function(){ expect( mp ).toBeA( ol.geom.MultiPoint ); }); - + it("works for the array notation of points", function(){ mp = ol.geom.multipoint([ [0, 1], [2, 3] ]); - + expect( mp ).toBeA( ol.geom.MultiPoint ); }); - + it("works for real points", function(){ mp = ol.geom.multipoint([ ol.geom.point([0,1]), ol.geom.point([2,3]) ]); - + expect( mp ).toBeA( ol.geom.MultiPoint ); }); }); - + describe("can construct instances without any points", function() { - + it("works with an empty array", function(){ mp = ol.geom.multipoint([]); - + expect( mp ).toBeA( ol.geom.MultiPoint ); }); - + it("works without arguments", function(){ mp = ol.geom.multipoint(); - + expect( mp ).toBeA( ol.geom.MultiPoint ); }); }); - + describe("the method 'add'", function() { it("exists", function(){ expect( mp.add ).toBeA( Function ); }); - + describe("can be used as setter", function(){ it("works with a single point specification and an index", function(){ var p = ol.geom.point([24,7]); mp.add(p, 0); - + expect(mp.points().length).toBe(3); - + var firstPoint = mp.points()[0]; - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with point instance", function(){ mp = ol.geom.multipoint(); mp.add(ol.geom.point([24,7])); @@ -73,7 +73,7 @@ describe("ol.geom.multipoint", function() { var firstPoint = mp.points()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with array specifications", function(){ mp = ol.geom.multipoint(); mp.add([24,7]); @@ -81,7 +81,7 @@ describe("ol.geom.multipoint", function() { var firstPoint = mp.points()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("works with object specifications", function(){ mp = ol.geom.multipoint(); mp.add({x:24,y:7}); @@ -89,117 +89,117 @@ describe("ol.geom.multipoint", function() { var firstPoint = mp.points()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); }); - + it("the index is functional", function(){ var p = ol.geom.point([24,7]); mp.add(p, 1); - + expect(mp.points().length).toBe(3); - + var firstPoint = mp.points()[0], // untouched secondPoint = mp.points()[1], // this should be ours thirdPoint = mp.points()[2]; // shifted here - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' ); expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '2,3' ); }); - + it("the index is optional", function(){ var p = ol.geom.point([24,7]); mp.add(p); - + expect(mp.points().length).toBe(3); - + var thirdPoint = mp.points()[2]; expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' ); }); - + it("returns the multipoint instance", function(){ var p = ol.geom.point([24,7]); var returned = mp.add(p); - + expect(returned).toBe(mp); }); }); }); - + describe("the method 'addAll'", function(){ it("exists", function(){ expect( mp.addAll ).toBeA( Function ); }); - + describe("can be used as setter", function(){ - + it("works with an array of point specifications and an index", function(){ var ps = [ ol.geom.point([24,7]), ol.geom.point([7,11]) ]; mp.addAll(ps, 0); - + expect(mp.points().length).toBe(4); - + var firstPoint = mp.points()[0], secondPoint = mp.points()[1]; - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '7,11' ); }); - + it("the index is functional", function(){ var ps = [ [24,7], {x:7, y:11} ]; mp.addAll(ps, 1); - + expect(mp.points().length).toBe(4); - + var firstPoint = mp.points()[0], // untouched secondPoint = mp.points()[1], // this should be ours thirdPoint = mp.points()[2], // this should be ours fourthPoint = mp.points()[3]; // shifted here - + expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' ); expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' ); expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '7,11' ); expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '2,3' ); }); - + it("the index is optional", function(){ var ps = [ [24,7], {x:7, y:11} ]; mp.addAll(ps); - + expect(mp.points().length).toBe(4); - + var thirdPoint = mp.points()[2], fourthPoint = mp.points()[3]; expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' ); expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '7,11' ); }); - + it("returns the multipoint instance", function(){ var ps = [ [24,7], {x:7, y:11} ]; var returned = mp.addAll(ps); - + expect(returned).toBe(mp); }); }); }); - - + + describe("the method 'remove'", function() { it("exists", function(){ expect( mp.add ).toBeA( Function ); }); - + it("works with a single point", function(){ var p = mp.points()[0]; mp.remove(p); @@ -207,7 +207,7 @@ describe("ol.geom.multipoint", function() { var firstPoint = mp.points()[0]; expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '2,3' ); }); - + it("works with an array of point specifications", function(){ var ps = [ mp.points()[1], diff --git a/test/spec/ol/geom/Collection.test.js b/test/spec/ol/geom/Collection.test.js index 0986459aab..fa5df0ed6c 100644 --- a/test/spec/ol/geom/Collection.test.js +++ b/test/spec/ol/geom/Collection.test.js @@ -1,6 +1,6 @@ describe("ol.geom.Collection", function() { var c; - + beforeEach(function(){ c = new ol.geom.Collection([ new ol.geom.Point(10,20), @@ -10,25 +10,25 @@ describe("ol.geom.Collection", function() { ]) ]); }); - + afterEach(function(){ c = null; }); - + it("constructs instances", function() { expect( c ).toBeA( ol.geom.Collection ); }); - + it("can construct instances without any components", function() { // empty array c = new ol.geom.Collection([]); expect( c ).toBeA( ol.geom.Collection ); - + // no argument at all c = new ol.geom.Collection(); expect( c ).toBeA( ol.geom.Collection ); }); - + it("cannot construct instances when passed illegal components", function() { // collection cannot contain collections expect(function(){ @@ -36,29 +36,29 @@ describe("ol.geom.Collection", function() { new ol.geom.Collection() ]); }).toThrow(); - + }); - + it("inherits from ol.geom.Geometry", function() { expect( c ).toBeA( ol.geom.Geometry ); }); - + it("has a working getter for components", function() { - + var components = c.getComponents(); - + expect( components ).toBeA( Array ); expect( components.length ).toBe( 2 ); expect( components[0] ).toBeA( ol.geom.Point ); expect( components[1] ).toBeA( ol.geom.LineString ); - + expect( components[0].getX() + ',' + components[0].getY()).toBe( '10,20' ); expect( components[1].getVertices()[0].getX() + ',' + components[1].getVertices()[0].getY()).toBe( '47,11' ); - + }); - + it("has a working setter for components", function() { - + c.setComponents([ new ol.geom.Point(30,40), new ol.geom.LineString([ @@ -66,20 +66,20 @@ describe("ol.geom.Collection", function() { new ol.geom.Point(4,16) ]) ]); - + var components = c.getComponents(); - + expect( components.length ).toBe( 2 ); expect( components[0] ).toBeA( ol.geom.Point ); expect( components[1] ).toBeA( ol.geom.LineString ); - + expect( components[0].getX() + ',' + components[0].getY()).toBe( '30,40' ); expect( components[1].getVertices()[0].getX() + ',' + components[1].getVertices()[0].getY()).toBe( '3,9' ); - + }); - + it("has a method to add components", function() { - + c.addComponent( new ol.geom.Point(30,40), 1 @@ -91,17 +91,17 @@ describe("ol.geom.Collection", function() { ]), 0 ); - + var components = c.getComponents(); - + expect( components.length ).toBe( 4 ); expect( components[0].getVertices()[0].getX() + ',' + components[0].getVertices()[0].getY()).toBe( '5,25' ); expect( components[1].getX() + ',' + components[1].getY()).toBe( '10,20' ); expect( components[2].getX() + ',' + components[2].getY()).toBe( '30,40' ); expect( components[3].getVertices()[0].getX() + ',' + components[3].getVertices()[0].getY()).toBe( '47,11' ); - + }); - + it("cannot add instances of 'ol.geom.Collection'", function(){ expect(function(){ c.addComponent( @@ -112,7 +112,7 @@ describe("ol.geom.Collection", function() { ); }).toThrow(); }); - + it("has a method to remove components", function() { c.setComponents([ new ol.geom.Point(0,10), @@ -120,16 +120,16 @@ describe("ol.geom.Collection", function() { new ol.geom.Point(20,30), new ol.geom.Point(30,40) ]); - + var p = c.getComponents()[2]; // 20,30; - + c.removeComponent( p ); - + var components = c.getComponents(); - + expect( components.length ).toBe( 3 ); expect( components[0].getX() + ',' + components[0].getY()).toBe( '0,10' ); expect( components[1].getX() + ',' + components[1].getY()).toBe( '10,20' ); expect( components[2].getX() + ',' + components[2].getY()).toBe( '30,40' ); - }); + }); }); diff --git a/test/spec/ol/geom/LineString.test.js b/test/spec/ol/geom/LineString.test.js index bf6894706a..4160958b71 100644 --- a/test/spec/ol/geom/LineString.test.js +++ b/test/spec/ol/geom/LineString.test.js @@ -1,6 +1,6 @@ describe("ol.geom.LineString", function() { var ls; - + beforeEach(function(){ ls = new ol.geom.LineString([ new ol.geom.Point(0,0), @@ -9,61 +9,61 @@ describe("ol.geom.LineString", function() { new ol.geom.Point(20,20) ]); }); - + afterEach(function(){ ls = null; }); - + it("constructs instances", function() { expect( ls ).toBeA( ol.geom.LineString ); }); - + it("can construct instances without any points", function() { // empty array mp = new ol.geom.LineString([]); expect( ls ).toBeA( ol.geom.LineString ); - + // no argument at all mp = new ol.geom.LineString(); expect( ls ).toBeA( ol.geom.LineString ); }); - + it("inherits from ol.geom.Geometry", function() { expect( ls ).toBeA( ol.geom.Geometry ); }); - + it("has a working getter for vertices", function() { - + var vertices = ls.getVertices(); - + expect( vertices ).toBeA( Array ); expect( vertices.length ).toBe( 4 ); expect( vertices[0] ).toBeA( ol.geom.Point ); - + expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '0,0' ); - + }); - + it("has a working setter for vertices", function() { - + ls.setVertices([ new ol.geom.Point(30,40), new ol.geom.Point(50,60) ]); - + var vertices = ls.getVertices(); - + expect( vertices.length ).toBe( 2 ); expect( vertices[0] ).toBeA( ol.geom.Point ); expect( vertices[1] ).toBeA( ol.geom.Point ); - + expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '30,40' ); expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '50,60' ); - + }); - + it("has a method to add vertices", function() { - + ls.addVertex( new ol.geom.Point(30,40), 1 @@ -76,9 +76,9 @@ describe("ol.geom.LineString", function() { new ol.geom.Point(-10,0), 0 ); - + var vertices = ls.getVertices(); - + expect( vertices.length ).toBe( 7 ); expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '-10,0' ); expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '0,0' ); @@ -87,9 +87,9 @@ describe("ol.geom.LineString", function() { expect( vertices[4].getX() + ',' + vertices[4].getY()).toBe( '10,10' ); expect( vertices[5].getX() + ',' + vertices[5].getY()).toBe( '10,0' ); expect( vertices[6].getX() + ',' + vertices[6].getY()).toBe( '20,20' ); - + }); - + it("has a method to remove vertices", function() { ls.setVertices([ new ol.geom.Point(0,10), @@ -97,16 +97,16 @@ describe("ol.geom.LineString", function() { new ol.geom.Point(20,30), new ol.geom.Point(30,40) ]); - + var v = ls.getVertices()[2]; // 20,30; - + ls.removeVertex( v ); - + var vertices = ls.getVertices(); - + expect( vertices.length ).toBe( 3 ); expect( vertices[0].getX() + ',' + vertices[0].getY()).toBe( '0,10' ); expect( vertices[1].getX() + ',' + vertices[1].getY()).toBe( '10,20' ); expect( vertices[2].getX() + ',' + vertices[2].getY()).toBe( '30,40' ); - }); + }); }); diff --git a/test/spec/ol/geom/MultiPoint.test.js b/test/spec/ol/geom/MultiPoint.test.js index 95ff8abaa3..ab8d35437e 100644 --- a/test/spec/ol/geom/MultiPoint.test.js +++ b/test/spec/ol/geom/MultiPoint.test.js @@ -1,30 +1,30 @@ describe("ol.geom.MultiPoint", function() { var mp; - + beforeEach(function(){ mp = new ol.geom.MultiPoint([ new ol.geom.Point(10,20) ]); }); - + afterEach(function(){ mp = null; }); - + it("constructs instances", function() { expect( mp ).toBeA( ol.geom.MultiPoint ); }); - + it("can construct instances without any points", function() { // empty array mp = new ol.geom.MultiPoint([]); expect( mp ).toBeA( ol.geom.MultiPoint ); - + // no argument at all mp = new ol.geom.MultiPoint(); expect( mp ).toBeA( ol.geom.MultiPoint ); }); - + it("cannot be constructed with component-types other than 'ol.geom.Point'", function() { expect(function(){ mp = new ol.geom.MultiPoint([ @@ -32,43 +32,43 @@ describe("ol.geom.MultiPoint", function() { ]); }).toThrow(); }); - + it("inherits from ol.geom.Geometry", function() { expect( mp ).toBeA( ol.geom.Geometry ); }); - + it("has a working getter for points", function() { - + var points = mp.getPoints(); - + expect( points ).toBeA( Array ); expect( points.length ).toBe( 1 ); expect( points[0] ).toBeA( ol.geom.Point ); - + expect( points[0].getX() + ',' + points[0].getY()).toBe( '10,20' ); - + }); - + it("has a working setter for points", function() { - + mp.setPoints([ new ol.geom.Point(30,40), new ol.geom.Point(50,60) ]); - + var points = mp.getPoints(); - + expect( points.length ).toBe( 2 ); expect( points[0] ).toBeA( ol.geom.Point ); expect( points[1] ).toBeA( ol.geom.Point ); - + expect( points[0].getX() + ',' + points[0].getY()).toBe( '30,40' ); expect( points[1].getX() + ',' + points[1].getY()).toBe( '50,60' ); - + }); - + it("has a method to add points", function() { - + mp.addPoint( new ol.geom.Point(30,40), 1 @@ -81,17 +81,17 @@ describe("ol.geom.MultiPoint", function() { new ol.geom.Point(-10,0), 0 ); - + var points = mp.getPoints(); - + expect( points.length ).toBe( 4 ); expect( points[0].getX() + ',' + points[0].getY()).toBe( '-10,0' ); expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' ); expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' ); expect( points[3].getX() + ',' + points[3].getY()).toBe( '50,60' ); - + }); - + it("can only add ol.geom.Point as components", function() { expect(function(){ mp.addComponent( @@ -102,7 +102,7 @@ describe("ol.geom.MultiPoint", function() { ); }).toThrow(); }); - + it("has a method to remove points", function() { mp.setPoints([ new ol.geom.Point(0,10), @@ -110,16 +110,16 @@ describe("ol.geom.MultiPoint", function() { new ol.geom.Point(20,30), new ol.geom.Point(30,40) ]); - + var p = mp.getPoints()[2]; // 20,30; - + mp.removePoint( p ); - + var points = mp.getPoints(); - + expect( points.length ).toBe( 3 ); expect( points[0].getX() + ',' + points[0].getY()).toBe( '0,10' ); expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' ); expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' ); - }); + }); }); From 73e07df54407d7ed2781f7aa2a909a47be038aaf Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:24:01 +0200 Subject: [PATCH 13/18] Give geometrues a centroid method. --- src/api/geom/collection.js | 2 +- src/api/geom/geometry.js | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/api/geom/collection.js b/src/api/geom/collection.js index e8269676a9..9a93ead0c4 100644 --- a/src/api/geom/collection.js +++ b/src/api/geom/collection.js @@ -128,6 +128,6 @@ ol.geom.Collection.prototype.remove = function(components){ this.removeComponent(c); return true; }, this); - + return this; }; diff --git a/src/api/geom/geometry.js b/src/api/geom/geometry.js index 3e12f9f0e7..5d8b9d09b9 100644 --- a/src/api/geom/geometry.js +++ b/src/api/geom/geometry.js @@ -24,3 +24,12 @@ ol.geom.Geometry.prototype.bounds = function(opt_arg) { return this.getBounds(); } }; + +/** + * Returns the centroid of the geometry. + * + * @returns {ol.geom.Point} The centroid of the geometry. + */ +ol.geom.Geometry.prototype.centroid = function() { + return this.getCentroid(); +}; \ No newline at end of file From 483c431e1bc5f45243a3103915a4e7e59bf46d00 Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:24:45 +0200 Subject: [PATCH 14/18] A centroid method vor Collections --- src/ol/geom/Collection.js | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/src/ol/geom/Collection.js b/src/ol/geom/Collection.js index 78a9becd5e..bf57b31506 100644 --- a/src/ol/geom/Collection.js +++ b/src/ol/geom/Collection.js @@ -160,9 +160,30 @@ ol.geom.Collection.prototype.isAllowedComponent = function(component){ /** * Removes the given component from the list of components. - * + * * @param {ol.geom.Geometry} component A component to be removed. */ ol.geom.Collection.prototype.removeComponent = function(component) { goog.array.remove(this.components_, component); }; + +/** + * Compute the centroid for this geometry collection. + * + * @returns {ol.geom.Point} The centroid of the collection. + */ +ol.geom.Collection.prototype.getCentroid = function() { + var components = this.getComponents(), + len = components.length, + sum_x = 0, sum_y = 0, + centroid = null; + if (len > 0) { + goog.array.forEach(components, function(component){ + var singleCentroid = component.getCentroid(); + sum_x += singleCentroid.getX(); + sum_y += singleCentroid.getX(); + }); + centroid = new ol.geom.Point(sum_x / len, sum_y / len); + } + return centroid; +}; \ No newline at end of file From 396875c719bfe0ad191d9d347b30075088a82eba Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:25:14 +0200 Subject: [PATCH 15/18] A centroid method for LineStrings --- src/ol/geom/LineString.js | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/ol/geom/LineString.js b/src/ol/geom/LineString.js index 1f449f0102..23f6e8eb0c 100644 --- a/src/ol/geom/LineString.js +++ b/src/ol/geom/LineString.js @@ -57,9 +57,20 @@ ol.geom.LineString.prototype.addVertex = function(vertex, index) { /** * Removes the given vertex from the list of vertices. - * + * * @param {ol.geom.Point} vertex A point to be removed. */ ol.geom.LineString.prototype.removeVertex = function(vertex) { goog.array.remove(this.vertices_, vertex); }; + +/** + * Compute the centroid for this linestring. + * + * @returns {ol.geom.Point} The centroid of the linestring. + */ +ol.geom.LineString.prototype.getCentroid = function() { + var vertices = this.getVertices(), + collection = new ol.geom.Collection(vertices); + return collection.getCentroid(); +}; \ No newline at end of file From b6648475911349940501d502780f28e41f3fe568 Mon Sep 17 00:00:00 2001 From: Marc Jansen Date: Fri, 22 Jun 2012 16:25:43 +0200 Subject: [PATCH 16/18] Add export symbols. --- src/ol.export.js | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/ol.export.js b/src/ol.export.js index 042f8ea6e4..7299dd456a 100644 --- a/src/ol.export.js +++ b/src/ol.export.js @@ -59,6 +59,7 @@ goog.exportProperty(ol.Feature.prototype, 'geometry', ol.Feature.prototype.geome goog.exportSymbol('ol.geom.geometry', ol.geom.geometry); goog.exportSymbol('ol.geom.Geometry', ol.geom.Geometry); goog.exportProperty(ol.geom.Geometry.prototype, 'bounds', ol.geom.Geometry.prototype.bounds); +goog.exportProperty(ol.geom.Geometry.prototype, 'centroid', ol.geom.Geometry.prototype.centroid); // ol.geom.collection goog.exportSymbol('ol.geom.collection', ol.geom.collection); @@ -67,6 +68,7 @@ goog.exportProperty(ol.geom.Collection.prototype, 'components', ol.geom.Collecti goog.exportProperty(ol.geom.Collection.prototype, 'add', ol.geom.Collection.prototype.add); goog.exportProperty(ol.geom.Collection.prototype, 'addAll', ol.geom.Collection.prototype.addAll); goog.exportProperty(ol.geom.Collection.prototype, 'remove', ol.geom.Collection.prototype.remove); +goog.exportProperty(ol.geom.Collection.prototype, 'centroid', ol.geom.Collection.prototype.centroid); // ol.geom.point goog.exportSymbol('ol.geom.point', ol.geom.point); @@ -75,6 +77,7 @@ goog.exportProperty(ol.geom.Point.prototype, 'x', ol.geom.Point.prototype.x); goog.exportProperty(ol.geom.Point.prototype, 'y', ol.geom.Point.prototype.y); goog.exportProperty(ol.geom.Point.prototype, 'z', ol.geom.Point.prototype.z); goog.exportProperty(ol.geom.Point.prototype, 'projection', ol.geom.Point.prototype.projection); +goog.exportProperty(ol.geom.Point.prototype, 'centroid', ol.geom.Point.prototype.centroid); // ol.geom.linestring goog.exportSymbol('ol.geom.linestring', ol.geom.linestring); @@ -83,6 +86,7 @@ goog.exportProperty(ol.geom.LineString.prototype, 'vertices', ol.geom.LineString goog.exportProperty(ol.geom.LineString.prototype, 'add', ol.geom.LineString.prototype.add); goog.exportProperty(ol.geom.LineString.prototype, 'addAll', ol.geom.LineString.prototype.addAll); goog.exportProperty(ol.geom.LineString.prototype, 'remove', ol.geom.LineString.prototype.remove); +goog.exportProperty(ol.geom.LineString.prototype, 'centroid', ol.geom.LineString.prototype.centroid); // ol.geom.multipoint goog.exportSymbol('ol.geom.multipoint', ol.geom.multipoint); @@ -91,6 +95,7 @@ goog.exportProperty(ol.geom.MultiPoint.prototype, 'points', ol.geom.MultiPoint.p goog.exportProperty(ol.geom.MultiPoint.prototype, 'add', ol.geom.MultiPoint.prototype.add); goog.exportProperty(ol.geom.MultiPoint.prototype, 'addAll', ol.geom.MultiPoint.prototype.addAll); goog.exportProperty(ol.geom.MultiPoint.prototype, 'remove', ol.geom.MultiPoint.prototype.remove); +goog.exportProperty(ol.geom.MultiPoint.prototype, 'centroid', ol.geom.MultiPoint.prototype.centroid); // LOOKUP FOR DYNMICALLY REGISTERED CONTROLS DOES NOT RUN WELL NOW IN THE ADVANCED MODE // HACK TO PUSH COMPILER TO NOT STRIP THE NAVIGATION CONTROL. TO BE FIXED. From 3f9fd2f47a6a1b6de16025be067fedf81ac67172 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Lemoine?= Date: Fri, 22 Jun 2012 16:48:34 +0200 Subject: [PATCH 17/18] [ol.TileCache] tile cache size is not 1 --- test/spec/ol/TileCache.test.js | 18 ++++++++++++++++++ test/spec/ol/layer/TileLayer.test.js | 10 +++++----- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/test/spec/ol/TileCache.test.js b/test/spec/ol/TileCache.test.js index a3a8a3140d..bcb80bd52a 100644 --- a/test/spec/ol/TileCache.test.js +++ b/test/spec/ol/TileCache.test.js @@ -1,5 +1,23 @@ describe('ol.TileCache', function() { + describe('add tiles to cache', function() { + var Tile, tilecache; + + beforeEach(function() { + Tile = ol.Tile.createConstructor(200, 200); + tilecache = new ol.TileCache(5); + }); + + it('does add tiles, without exceeding cache size', function() { + for (var i=0; i<6; i++) { + var url = 'url' + i; + var tile = new Tile(url); + tilecache.set(url, tile); + } + expect(tilecache.getCount()).toEqual(5); + }); + }); + describe('exceed the cache capacity', function() { var Tile, tilecache, tile; diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js index 5bd291d6ef..60d837b6cf 100644 --- a/test/spec/ol/layer/TileLayer.test.js +++ b/test/spec/ol/layer/TileLayer.test.js @@ -363,11 +363,11 @@ describe('ol.layer.TileLayer', function() { it('returns the expected tile', function() { var tile = layer.getTileForXYZ(1, 2, 2); expect(tile.getUrl()).toEqual('/2/1/2'); - //var bounds = tile.getBounds(); - //expect(bounds.getMinX()).toEqual(-64); - //expect(bounds.getMinY()).toEqual(0); - //expect(bounds.getMaxX()).toEqual(0); - //expect(bounds.getMaxY()).toEqual(64); + var bounds = tile.getBounds(); + expect(bounds.getMinX()).toEqual(-64); + expect(bounds.getMinY()).toEqual(0); + expect(bounds.getMaxX()).toEqual(0); + expect(bounds.getMaxY()).toEqual(64); }); }); From c501559413f91f92ccee2aab6fccf7da7c3d8285 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89ric=20Lemoine?= Date: Fri, 22 Jun 2012 16:51:28 +0200 Subject: [PATCH 18/18] Revert "[ol.TileCache] tile cache size is not 1" This reverts commit 3f9fd2f47a6a1b6de16025be067fedf81ac67172. --- test/spec/ol/TileCache.test.js | 18 ------------------ test/spec/ol/layer/TileLayer.test.js | 10 +++++----- 2 files changed, 5 insertions(+), 23 deletions(-) diff --git a/test/spec/ol/TileCache.test.js b/test/spec/ol/TileCache.test.js index bcb80bd52a..a3a8a3140d 100644 --- a/test/spec/ol/TileCache.test.js +++ b/test/spec/ol/TileCache.test.js @@ -1,23 +1,5 @@ describe('ol.TileCache', function() { - describe('add tiles to cache', function() { - var Tile, tilecache; - - beforeEach(function() { - Tile = ol.Tile.createConstructor(200, 200); - tilecache = new ol.TileCache(5); - }); - - it('does add tiles, without exceeding cache size', function() { - for (var i=0; i<6; i++) { - var url = 'url' + i; - var tile = new Tile(url); - tilecache.set(url, tile); - } - expect(tilecache.getCount()).toEqual(5); - }); - }); - describe('exceed the cache capacity', function() { var Tile, tilecache, tile; diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js index 60d837b6cf..5bd291d6ef 100644 --- a/test/spec/ol/layer/TileLayer.test.js +++ b/test/spec/ol/layer/TileLayer.test.js @@ -363,11 +363,11 @@ describe('ol.layer.TileLayer', function() { it('returns the expected tile', function() { var tile = layer.getTileForXYZ(1, 2, 2); expect(tile.getUrl()).toEqual('/2/1/2'); - var bounds = tile.getBounds(); - expect(bounds.getMinX()).toEqual(-64); - expect(bounds.getMinY()).toEqual(0); - expect(bounds.getMaxX()).toEqual(0); - expect(bounds.getMaxY()).toEqual(64); + //var bounds = tile.getBounds(); + //expect(bounds.getMinX()).toEqual(-64); + //expect(bounds.getMinY()).toEqual(0); + //expect(bounds.getMaxX()).toEqual(0); + //expect(bounds.getMaxY()).toEqual(64); }); });