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;
diff --git a/src/api/geom/collection.js b/src/api/geom/collection.js
index c1405e7e78..9a93ead0c4 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.<ol.geom.Geometry>} 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;
 };
 
@@ -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 6a636cc839..5d8b9d09b9 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) {
@@ -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
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/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.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.
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 6bc045c1c0..fae064f055 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());
 };
 
 
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/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<ii; ++i) {
         returnValue = listeners[i].handleEvent(opt_evt);
         if (returnValue === false) {
diff --git a/src/ol/geom/Collection.js b/src/ol/geom/Collection.js
index 91ee3f0415..bf57b31506 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.<ol.geom.Geometry>} components An array of components.
- * 
+ *
  * @constructor
  */
 ol.geom.Collection = function(components) {
-    
+
     /**
      * @private
      * @type {Array.<Function>}
@@ -23,19 +23,19 @@ ol.geom.Collection = function(components) {
     this.typeBlacklist_ = [
         ol.geom.Collection
     ];
-    
+
     /**
      * @private
      * @type {Array.<Function>}
      */
     this.typeWhitelist_ = [];
-    
+
     /**
      * @private
      * @type {Array.<ol.geom.Geometry>}
      */
     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.<Function>} 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.<Function>} 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.<Function>} 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.<Function>} 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.<ol.geom.Geometry>} 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.<ol.geom.Geometry>} 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.<Function>} list The List of constructors to check the 
+ * @param {Array.<Function>} 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.
@@ -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
diff --git a/src/ol/geom/Geometry.js b/src/ol/geom/Geometry.js
index 9378df6ebc..2ed4420624 100644
--- a/src/ol/geom/Geometry.js
+++ b/src/ol/geom/Geometry.js
@@ -1,15 +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}
@@ -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..2245be339c
--- /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
diff --git a/src/ol/geom/LineString.js b/src/ol/geom/LineString.js
index af8a857659..23f6e8eb0c 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.<ol.geom.Point>} vertices An array of points building the 
+ * @param {Array.<ol.geom.Point>} 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.<ol.geom.Point>}
      */
     this.vertices_ = vertices;
-    
+
 };
 
 goog.inherits(ol.geom.LineString, ol.geom.Geometry);
 
 /**
  * Sets the LineString's points.
- * 
+ *
  * @return {Array.<ol.geom.Point>} 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.<ol.geom.Point>} 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.
  */
@@ -56,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
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.<ol.geom.Point>} 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.<ol.geom.Point>} 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.<ol.geom.Point>} 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/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/src/ol/layer/TileLayer.js b/src/ol/layer/TileLayer.js
index 29164f7960..19af4a20db 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_);
 
@@ -62,7 +62,7 @@ ol.layer.TileLayer = function() {
      * @private
      * @type {string}
      */
-    this.tileOriginCorner_ = 'bl';
+    this.tileOriginCorner_ = 'tl';
 
     /**
      * @private
@@ -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
@@ -172,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_;
@@ -285,6 +324,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/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.<number>}
+     */
+    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.<number>}
+ */
+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<ii; ++i) {
+        // assumes sorted resolutions
+        candidate = this.layerResolutions_[i];
+        diff = Math.abs(resolution - candidate);
+        if (diff < minDiff) {
+            z = i;
+            r = candidate;
+            minDiff = diff;
+        } else {
+            break;
+        }
+    }
+    return [r, z];
+};
 
 /**
  * @return {goog.math.Size}
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/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/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' );
-    });     
+    });
 });
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');
+        });
+    });
 });
diff --git a/test/spec/ol/layer/TileLayer.test.js b/test/spec/ol/layer/TileLayer.test.js
index f34a1794f8..5bd291d6ef 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;
 
@@ -50,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]);
             });
 
         });
@@ -329,4 +349,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);
+        });
+
+    });
 });
diff --git a/test/spec/ol/renderer/TileLayerRenderer.test.js b/test/spec/ol/renderer/TileLayerRenderer.test.js
index 9061b87dbe..45a1685b30 100644
--- a/test/spec/ol/renderer/TileLayerRenderer.test.js
+++ b/test/spec/ol/renderer/TileLayerRenderer.test.js
@@ -15,5 +15,61 @@ describe("ol.renderer.TileLayerRenderer", function() {
         expect(ol.renderer.TileLayerRenderer.canRender(layer)).toBe(false);
     });
     
+    describe("getPreferredResAndZ_", function() {
+        var layer = new ol.layer.TileLayer();
+        var resolutions = [100, 80, 50, 10, 1, 0.1];
+        layer.setResolutions(resolutions);
+        
+        var container = document.createElement("div");
+        var renderer = new ol.renderer.TileLayerRenderer(container, layer);
+
+        it("gets the max resolution", function() {
+            var pair = renderer.getPreferredResAndZ_(100);
+            expect(pair[0]).toBe(100);
+            expect(pair[1]).toBe(0);
+        });
+
+        it("gets the min resolution", function() {
+            var pair = renderer.getPreferredResAndZ_(0.1);
+            expect(pair[0]).toBe(0.1);
+            expect(pair[1]).toBe(5);
+        });
+
+        it("gets the max when bigger", function() {
+            var pair = renderer.getPreferredResAndZ_(200);
+            expect(pair[0]).toBe(100);
+            expect(pair[1]).toBe(0);
+        });
+
+        it("gets the min when smaller", function() {
+            var pair = renderer.getPreferredResAndZ_(0.01);
+            expect(pair[0]).toBe(0.1);
+            expect(pair[1]).toBe(5);
+        });
+
+        it("gets the first when in the middle", function() {
+            var pair = renderer.getPreferredResAndZ_(90);
+            expect(pair[0]).toBe(100);
+            expect(pair[1]).toBe(0);
+        });
+
+        it("gets the closer when elsewhere", function() {
+            var pair = renderer.getPreferredResAndZ_(89);
+            expect(pair[0]).toBe(80);
+            expect(pair[1]).toBe(1);
+            
+            pair = renderer.getPreferredResAndZ_(49);
+            expect(pair[0]).toBe(50);
+            expect(pair[1]).toBe(2);
+
+            pair = renderer.getPreferredResAndZ_(0.5);
+            expect(pair[0]).toBe(0.1);
+            expect(pair[1]).toBe(5);
+        });
+        
+    });
+    
+    
+    
 });