refactoring, and renamings in tilegrid.js (related to continous zooming)

src/ol/tilegrid/tilegrid.js

@@ -80,7 +80,7 @@ ol.TileGrid.prototype.forEachTileCoordParent = function(tileCoord, callback) {
   var tileCoordExtent = this.getTileCoordExtent(tileCoord);
   var z = tileCoord.z - 1;
   while (z >= 0) {
-    if (callback(z, this.getExtentTileBounds(z, tileCoordExtent))) {
+    if (callback(z, this.getTileBoundsForExtentAndZ(tileCoordExtent, z))) {
       return;
     }
     --z;
@@ -97,13 +97,27 @@ ol.TileGrid.prototype.getExtent = function() {
 
 
 /**
- * @param {number} z Z.
  * @param {ol.Extent} extent Extent.
+ * @param {number} z Z.
  * @return {ol.TileBounds} Tile bounds.
  */
-ol.TileGrid.prototype.getExtentTileBounds = function(z, extent) {
+ol.TileGrid.prototype.getTileBoundsForExtentAndZ = function(extent, z) {
-  var min = this.getTileCoord(z, new ol.Coordinate(extent.minX, extent.minY));
+  var resolution = this.getResolution(z);
-  var max = this.getTileCoord(z, new ol.Coordinate(extent.maxX, extent.maxY));
+  return this.getTileBoundsForExtentAndResolution(extent, resolution);
+};
+
+
+/**
+ * @param {ol.Extent} extent Extent.
+ * @param {number} resolution Resolution.
+ * @return {ol.TileBounds} Tile bounds.
+ */
+ol.TileGrid.prototype.getTileBoundsForExtentAndResolution = function(
+    extent, resolution) {
+  var min = this.getTileCoordForCoordAndResolution(
+      new ol.Coordinate(extent.minX, extent.minY), resolution);
+  var max = this.getTileCoordForCoordAndResolution(
+      new ol.Coordinate(extent.maxX, extent.maxY), resolution);
   return new ol.TileBounds(min.x, min.y, max.x, max.y);
 };
 
@@ -142,31 +156,25 @@ ol.TileGrid.prototype.getResolutions = function() {
 
 
 /**
- * @param {number} z Z.
  * @param {ol.Coordinate} coordinate Coordinate.
+ * @param {number} z Z.
  * @return {ol.TileCoord} Tile coordinate.
  */
-ol.TileGrid.prototype.getTileCoord = function(z, coordinate) {
+ol.TileGrid.prototype.getTileCoordForCoordAndZ = function(coordinate, z) {
-  var origin = this.getOrigin(z);
   var resolution = this.getResolution(z);
-  var tileSize = this.getTileSize();
+  return this.getTileCoordForCoordAndResolution(coordinate, resolution);
-  var x, y;
-  x = Math.floor((coordinate.x - origin.x) / (tileSize.width * resolution));
-  y = Math.floor((coordinate.y - origin.y) / (tileSize.height * resolution));
-  return new ol.TileCoord(z, x, y);
 };
 
 
 /**
- * @param {number} z Z.
- * @param {number} resolution Resolution.
  * @param {ol.Coordinate} coordinate Coordinate.
+ * @param {number} resolution Resolution.
  * @return {ol.TileCoord} Tile coordinate.
  */
-ol.TileGrid.prototype.getTileCoordForArbitraryResolution = function(
+ol.TileGrid.prototype.getTileCoordForCoordAndResolution = function(
-    z, resolution, coordinate) {
+    coordinate, resolution) {
-  var resolutionForZ = this.getResolution(z);
+  var z = this.getZForResolution(resolution);
-  var scale = resolution / resolutionForZ;
+  var scale = resolution / this.getResolution(z);
   var origin = this.getOrigin(z);
 
   var offsetFromOrigin = new ol.Coordinate(
@@ -182,9 +190,8 @@ ol.TileGrid.prototype.getTileCoordForArbitraryResolution = function(
   y = Math.floor(offsetFromOrigin.y / tileSize.height);
 
   var tileCoord = new ol.TileCoord(z, x, y);
-  var tileCoordPixelBounds =
+  var tileCoordPixelBounds = this.getPixelBoundsForTileCoordAndResolution(
-      this.getTileCoordPixelBoundsForArbitraryResolution(
+      tileCoord, resolution);
-          tileCoord, resolution);
 
   // adjust x to allow for stretched tiles
   if (offsetFromOrigin.x < tileCoordPixelBounds.minX) {
@@ -255,10 +262,9 @@ ol.TileGrid.prototype.getTileCoordExtent = function(tileCoord) {
  * @param {number} resolution Resolution.
  * @return {ol.PixelBounds} Pixel bounds.
  */
-ol.TileGrid.prototype.getTileCoordPixelBoundsForArbitraryResolution = function(
+ol.TileGrid.prototype.getPixelBoundsForTileCoordAndResolution = function(
     tileCoord, resolution) {
-  var resolutionForZ = this.getResolution(tileCoord.z);
+  var scale = resolution / this.getResolution(tileCoord.z);
-  var scale = resolution / resolutionForZ;
   var tileSize = this.getTileSize();
   tileSize = new ol.Size(tileSize.width / scale,
                          tileSize.height / scale);
@@ -267,7 +273,6 @@ ol.TileGrid.prototype.getTileCoordPixelBoundsForArbitraryResolution = function(
   maxX = Math.round((tileCoord.x + 1) * tileSize.width);
   minY = Math.round(tileCoord.y * tileSize.height);
   maxY = Math.round((tileCoord.y + 1) * tileSize.height);
-
   return new ol.PixelBounds(minX, minY, maxX, maxY);
 };
 

src/ol/tilegrid/tilegrid_test.js

@@ -78,22 +78,26 @@ function testGetTileCoord() {
   var tileGrid = new ol.TileGrid(resolutions, extent, origin, tileSize);
   var tileCoord;
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(0, 0));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(0, 0), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(0, 100000));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(0, 100000), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(10, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(100000, 0));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(100000, 0), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(10, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(100000, 100000));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(100000, 100000), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(10, tileCoord.x);
   assertEquals(10, tileCoord.y);
@@ -107,29 +111,33 @@ function testGetTileCoordYSouth() {
   var tileGrid = new ol.TileGrid(resolutions, extent, origin, tileSize);
   var tileCoord;
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(0, 0));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(0, 0), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-10, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(0, 100000));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(0, 100000), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(100000, 0));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(100000, 0), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(10, tileCoord.x);
   assertEquals(-10, tileCoord.y);
 
-  tileCoord = tileGrid.getTileCoord(3, new ol.Coordinate(100000, 100000));
+  tileCoord = tileGrid.getTileCoordForCoordAndZ(
+      new ol.Coordinate(100000, 100000), 3);
   assertEquals(3, tileCoord.z);
   assertEquals(10, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
 }
 
-function testGetTileCoordForArbitraryResolution() {
+function testGetTileCoordForCoordAndResolution() {
 
   var tileSize = new ol.Size(256, 256);
   var tileGrid = new ol.TileGrid([10], extent, origin, tileSize);
@@ -139,78 +147,78 @@ function testGetTileCoordForArbitraryResolution() {
 
   // gets the first tile at the origin
   coordinate = new ol.Coordinate(0, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets one tile northwest of the origin
   coordinate = new ol.Coordinate(-1280, 1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(-1, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets one tile northeast of the origin
   coordinate = new ol.Coordinate(1280, 1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets one tile southeast of the origin
   coordinate = new ol.Coordinate(1280, -1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 
   // gets one tile southwest of the origin
   coordinate = new ol.Coordinate(-1280, -1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(-1, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 
   // gets the tile to the east when on the edge
   coordinate = new ol.Coordinate(2560, -1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(1, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 
   // gets the tile to the north when on the edge
   coordinate = new ol.Coordinate(1280, -2560);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 
   // pixels are top aligned to the origin
   coordinate = new ol.Coordinate(1280, -2559.999);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 
   // pixels are left aligned to the origin
   coordinate = new ol.Coordinate(2559.999, -1280);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 10, coordinate);
+      coordinate, 10);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-1, tileCoord.y);
 }
 
-function testGetTileCoordForArbitraryResolutionFractional() {
+function testGetTileCoordForCoordAndResolutionFractional() {
 
   var tileSize = new ol.Size(256, 256);
   var tileGrid = new ol.TileGrid([1 / 3], extent, origin, tileSize);
@@ -225,80 +233,80 @@ function testGetTileCoordForArbitraryResolutionFractional() {
 
   // gets the first tile at the origin
   coordinate = new ol.Coordinate(0, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 1,0 tile at 256/3,0
   coordinate = new ol.Coordinate(256 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(1, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // still gets the 1,0 tile at 512/3,0 - wider tile
   coordinate = new ol.Coordinate(512 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(1, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 2,0 tile at 513/3,0
   coordinate = new ol.Coordinate(513 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(2, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 3,0 tile at 768/3,0
   coordinate = new ol.Coordinate(768 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(3, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 4,0 tile at 1024/3,0
   coordinate = new ol.Coordinate(1024 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(4, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // still gets the 4,0 tile at 1280/3,0 - wider tile
   coordinate = new ol.Coordinate(1280 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(4, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 5,0 tile at 1281/3,0
   coordinate = new ol.Coordinate(1281 / 3, 0);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(5, tileCoord.x);
   assertEquals(0, tileCoord.y);
 
   // gets the 0,1 tile at 0,-256/3
   coordinate = new ol.Coordinate(0, -256 / 3);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-2, tileCoord.y);
 
   // still gets the 0,1 tile at 0,-512/3 - taller tile
   coordinate = new ol.Coordinate(0, -512 / 3);
-  tileCoord = tileGrid.getTileCoordForArbitraryResolution(
+  tileCoord = tileGrid.getTileCoordForCoordAndResolution(
-      0, 1, coordinate);
+      coordinate, 1);
   assertEquals(0, tileCoord.z);
   assertEquals(0, tileCoord.x);
   assertEquals(-2, tileCoord.y);
@@ -358,25 +366,25 @@ function testGetExtentTileBounds() {
   var e = new ol.Extent(45000, 5000, 55000, 15000);
   var tileBounds;
 
-  tileBounds = tileGrid.getExtentTileBounds(0, e);
+  tileBounds = tileGrid.getTileBoundsForExtentAndZ(e, 0);
   assertEquals(0, tileBounds.minY);
   assertEquals(0, tileBounds.minX);
   assertEquals(0, tileBounds.maxX);
   assertEquals(0, tileBounds.maxY);
 
-  tileBounds = tileGrid.getExtentTileBounds(1, e);
+  tileBounds = tileGrid.getTileBoundsForExtentAndZ(e, 1);
   assertEquals(0, tileBounds.minX);
   assertEquals(0, tileBounds.minY);
   assertEquals(1, tileBounds.maxX);
   assertEquals(0, tileBounds.maxY);
 
-  tileBounds = tileGrid.getExtentTileBounds(2, e);
+  tileBounds = tileGrid.getTileBoundsForExtentAndZ(e, 2);
   assertEquals(1, tileBounds.minX);
   assertEquals(0, tileBounds.minY);
   assertEquals(2, tileBounds.maxX);
   assertEquals(0, tileBounds.maxY);
 
-  tileBounds = tileGrid.getExtentTileBounds(3, e);
+  tileBounds = tileGrid.getTileBoundsForExtentAndZ(e, 3);
   assertEquals(4, tileBounds.minX);
   assertEquals(0, tileBounds.minY);
   assertEquals(5, tileBounds.maxX);

src/ol/tilestore/tilestore_test.js

@@ -12,25 +12,32 @@ function testXYZ() {
   var coordinate = new ol.Coordinate(829330.2064098881, 5933916.615134273);
   var tileUrl;
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(0, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 0));
   assertEquals('0/0/0', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(1, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 1));
   assertEquals('1/1/0', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(2, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 2));
   assertEquals('2/2/1', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(3, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 3));
   assertEquals('3/4/2', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(4, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 4));
   assertEquals('4/8/5', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(5, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 5));
   assertEquals('5/16/11', tileUrl);
 
-  tileUrl = tileStore.getTileCoordUrl(tileGrid.getTileCoord(6, coordinate));
+  tileUrl = tileStore.getTileCoordUrl(
+      tileGrid.getTileCoordForCoordAndZ(coordinate, 6));
   assertEquals('6/33/22', tileUrl);
 
 }

src/ol/webgl/tilelayerrenderer.js

@@ -227,7 +227,7 @@ ol.webgl.TileLayerRenderer.prototype.redraw = function() {
   var tileStore = tileLayer.getStore();
   var tileGrid = tileStore.getTileGrid();
   var z = tileGrid.getZForResolution(resolution);
-  var tileBounds = tileGrid.getExtentTileBounds(z, extent);
+  var tileBounds = tileGrid.getTileBoundsForExtentAndZ(extent, z);
   var tileBoundsSize = tileBounds.getSize();
   var tileSize = tileGrid.getTileSize();