diff --git a/src/ol/tilegrid/tilegrid.js b/src/ol/tilegrid/tilegrid.js index 7a0fecf81e..86ae3229a4 100644 --- a/src/ol/tilegrid/tilegrid.js +++ b/src/ol/tilegrid/tilegrid.js @@ -183,10 +183,10 @@ ol.tilegrid.TileGrid.prototype.getTileRangeExtent = function(z, tileRange) { */ ol.tilegrid.TileGrid.prototype.getTileRangeForExtentAndResolution = function( extent, resolution) { - var min = this.getTileCoordForCoordAndResolution( + var min = this.getTileCoordForCoordAndResolution_( new ol.Coordinate(extent.minX, extent.minY), resolution); - var max = this.getTileCoordForCoordAndResolution( - new ol.Coordinate(extent.maxX, extent.maxY), resolution); + var max = this.getTileCoordForCoordAndResolution_( + new ol.Coordinate(extent.maxX, extent.maxY), resolution, true); return new ol.TileRange(min.x, min.y, max.x, max.y); }; @@ -233,46 +233,48 @@ ol.tilegrid.TileGrid.prototype.getTileCoordExtent = function(tileCoord) { /** + * Get the tile coordinate for the given map coordinate and resolution. This + * method considers that coordinates that intersect tile boundaries should be + * assigned the higher tile coordinate. + * * @param {ol.Coordinate} coordinate Coordinate. * @param {number} resolution Resolution. * @return {ol.TileCoord} Tile coordinate. */ ol.tilegrid.TileGrid.prototype.getTileCoordForCoordAndResolution = function( coordinate, resolution) { + return this.getTileCoordForCoordAndResolution_(coordinate, resolution); +}; + + +/** + * @param {ol.Coordinate} coordinate Coordinate. + * @param {number} resolution Resolution. + * @param {boolean=} opt_reverseIntersectionPolicy Instead of letting edge + * intersections go to the higher tile coordinate, let edge intersections + * go to the lower tile coordinate. + * @return {ol.TileCoord} Tile coordinate. + * @private + */ +ol.tilegrid.TileGrid.prototype.getTileCoordForCoordAndResolution_ = function( + coordinate, resolution, opt_reverseIntersectionPolicy) { var z = this.getZForResolution(resolution); var scale = resolution / this.getResolution(z); var origin = this.getOrigin(z); - - var offsetFromOrigin = new ol.Coordinate( - Math.floor((coordinate.x - origin.x) / resolution), - Math.floor((coordinate.y - origin.y) / resolution)); - var tileSize = this.getTileSize(); - tileSize = new ol.Size(tileSize.width / scale, - tileSize.height / scale); - var x, y; - x = Math.floor(offsetFromOrigin.x / tileSize.width); - y = Math.floor(offsetFromOrigin.y / tileSize.height); + var x = scale * (coordinate.x - origin.x) / (resolution * tileSize.width); + var y = scale * (coordinate.y - origin.y) / (resolution * tileSize.height); - var tileCoord = new ol.TileCoord(z, x, y); - var tileCoordPixelBounds = this.getPixelBoundsForTileCoordAndResolution( - tileCoord, resolution); - - // adjust x to allow for stretched tiles - if (offsetFromOrigin.x < tileCoordPixelBounds.minX) { - tileCoord.x -= 1; - } else if (offsetFromOrigin.x >= tileCoordPixelBounds.maxX) { - tileCoord.x += 1; - } - // adjust y to allow for stretched tiles - if (offsetFromOrigin.y < tileCoordPixelBounds.minY) { - tileCoord.y -= 1; - } else if (offsetFromOrigin.y >= tileCoordPixelBounds.maxY) { - tileCoord.y += 1; + if (!opt_reverseIntersectionPolicy) { + x = Math.floor(x); + y = Math.floor(y); + } else { + x = Math.ceil(x) - 1; + y = Math.ceil(y) - 1; } - return tileCoord; + return new ol.TileCoord(z, x, y); }; @@ -284,7 +286,7 @@ ol.tilegrid.TileGrid.prototype.getTileCoordForCoordAndResolution = function( ol.tilegrid.TileGrid.prototype.getTileCoordForCoordAndZ = function(coordinate, z) { var resolution = this.getResolution(z); - return this.getTileCoordForCoordAndResolution(coordinate, resolution); + return this.getTileCoordForCoordAndResolution_(coordinate, resolution); }; diff --git a/src/ol/tilerange.js b/src/ol/tilerange.js index e1baa169f8..76d3d7437c 100644 --- a/src/ol/tilerange.js +++ b/src/ol/tilerange.js @@ -7,6 +7,9 @@ goog.require('ol.TileCoord'); /** + * A representation of a contiguous block of tiles. A tile range is specified + * by its min/max tile coordinates and is inclusive of coordinates. + * * @constructor * @extends {ol.Rectangle} * @param {number} minX Minimum X. @@ -15,7 +18,27 @@ goog.require('ol.TileCoord'); * @param {number} maxY Maximum Y. */ ol.TileRange = function(minX, minY, maxX, maxY) { - goog.base(this, minX, minY, maxX, maxY); + + /** + * @type {number} + */ + this.minX = minX; + + /** + * @type {number} + */ + this.minY = minY; + + /** + * @type {number} + */ + this.maxX = maxX; + + /** + * @type {number} + */ + this.maxY = maxY; + }; goog.inherits(ol.TileRange, ol.Rectangle); diff --git a/test/spec/ol/tilegrid.test.js b/test/spec/ol/tilegrid.test.js index 3831522c4b..4916bf802b 100644 --- a/test/spec/ol/tilegrid.test.js +++ b/test/spec/ol/tilegrid.test.js @@ -289,11 +289,11 @@ describe('ol.tilegrid.TileGrid', function() { }); }); - describe('getTileCoordForCoordAndResolution fractional', function() { - it('returns the expected TileCoord', function() { - var tileSize = new ol.Size(256, 256); + + describe('getTileCoordForCoordAndResolution_', function() { + it('returns higher tile coord for intersections by default', function() { var tileGrid = new ol.tilegrid.TileGrid({ - resolutions: [1 / 3], + resolutions: resolutions, extent: extent, origin: origin, tileSize: tileSize @@ -302,91 +302,53 @@ describe('ol.tilegrid.TileGrid', function() { var coordinate; var tileCoord; - // These tests render at a resolution of 1. Because the layer's - // closest resolution is 1/3, the images are scaled by 1/3. - // In this scenario, every third tile will be one pixel wider when - // rendered (0,0 is normal; 1,0 is wider; 0,1 is taller; etc.) - - // gets the first tile at the origin + // gets higher tile for edge intersection coordinate = new ol.Coordinate(0, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); + tileCoord = tileGrid.getTileCoordForCoordAndResolution_( + coordinate, 100); + expect(tileCoord.z).toEqual(3); expect(tileCoord.x).toEqual(0); expect(tileCoord.y).toEqual(0); - // gets the 1,0 tile at 256/3,0 - coordinate = new ol.Coordinate(256 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(1); - expect(tileCoord.y).toEqual(0); + // gets higher tile for edge intersection + coordinate = new ol.Coordinate(100000, 100000); + tileCoord = tileGrid.getTileCoordForCoordAndResolution_( + coordinate, 100); + expect(tileCoord.z).toEqual(3); + expect(tileCoord.x).toEqual(10); + expect(tileCoord.y).toEqual(10); - // still gets the 1,0 tile at 512/3,0 - wider tile - coordinate = new ol.Coordinate(512 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(1); - expect(tileCoord.y).toEqual(0); - - // gets the 2,0 tile at 513/3,0 - coordinate = new ol.Coordinate(513 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(2); - expect(tileCoord.y).toEqual(0); - - // gets the 3,0 tile at 768/3,0 - coordinate = new ol.Coordinate(768 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(3); - expect(tileCoord.y).toEqual(0); - - // gets the 4,0 tile at 1024/3,0 - coordinate = new ol.Coordinate(1024 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(4); - expect(tileCoord.y).toEqual(0); - - // still gets the 4,0 tile at 1280/3,0 - wider tile - coordinate = new ol.Coordinate(1280 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(4); - expect(tileCoord.y).toEqual(0); - - // gets the 5,0 tile at 1281/3,0 - coordinate = new ol.Coordinate(1281 / 3, 0); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(5); - expect(tileCoord.y).toEqual(0); - - // gets the 0,1 tile at 0,-256/3 - coordinate = new ol.Coordinate(0, -256 / 3); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(0); - expect(tileCoord.y).toEqual(-2); - - // still gets the 0,1 tile at 0,-512/3 - taller tile - coordinate = new ol.Coordinate(0, -512 / 3); - tileCoord = tileGrid.getTileCoordForCoordAndResolution( - coordinate, 1); - expect(tileCoord.z).toEqual(0); - expect(tileCoord.x).toEqual(0); - expect(tileCoord.y).toEqual(-2); }); + + it('handles alt intersection policy', function() { + var tileGrid = new ol.tilegrid.TileGrid({ + resolutions: resolutions, + extent: extent, + origin: origin, + tileSize: tileSize + }); + + var coordinate; + var tileCoord; + + // can get lower tile for edge intersection + coordinate = new ol.Coordinate(0, 0); + tileCoord = tileGrid.getTileCoordForCoordAndResolution_( + coordinate, 100, true); + expect(tileCoord.z).toEqual(3); + expect(tileCoord.x).toEqual(-1); + expect(tileCoord.y).toEqual(-1); + + // gets higher tile for edge intersection + coordinate = new ol.Coordinate(100000, 100000); + tileCoord = tileGrid.getTileCoordForCoordAndResolution_( + coordinate, 100, true); + expect(tileCoord.z).toEqual(3); + expect(tileCoord.x).toEqual(9); + expect(tileCoord.y).toEqual(9); + + }); + }); describe('getTileCoordCenter', function() { @@ -443,6 +405,46 @@ describe('ol.tilegrid.TileGrid', function() { }); }); + describe('getTileRangeForExtentAndResolution', function() { + it('returns the expected TileRange', function() { + var tileGrid = new ol.tilegrid.TileGrid({ + resolutions: resolutions, + extent: extent, + origin: origin, + tileSize: tileSize + }); + var tileRange; + + tileRange = tileGrid.getTileRangeForExtentAndResolution(extent, + resolutions[0]); + expect(tileRange.minY).toEqual(0); + expect(tileRange.minX).toEqual(0); + expect(tileRange.maxX).toEqual(0); + expect(tileRange.maxY).toEqual(0); + + tileRange = tileGrid.getTileRangeForExtentAndResolution(extent, + resolutions[1]); + expect(tileRange.minX).toEqual(0); + expect(tileRange.minY).toEqual(0); + expect(tileRange.maxX).toEqual(1); + expect(tileRange.maxY).toEqual(1); + + tileRange = tileGrid.getTileRangeForExtentAndResolution(extent, + resolutions[2]); + expect(tileRange.minX).toEqual(0); + expect(tileRange.minY).toEqual(0); + expect(tileRange.maxX).toEqual(3); + expect(tileRange.maxY).toEqual(3); + + tileRange = tileGrid.getTileRangeForExtentAndResolution(extent, + resolutions[3]); + expect(tileRange.minX).toEqual(0); + expect(tileRange.minY).toEqual(0); + expect(tileRange.maxX).toEqual(9); + expect(tileRange.maxY).toEqual(9); + }); + }); + describe('getTileRangeForExtentAndZ', function() { it('returns the expected TileRange', function() { var tileGrid = new ol.tilegrid.TileGrid({ diff --git a/test/spec/ol/tilerange.test.js b/test/spec/ol/tilerange.test.js index fd59068325..6906c57e78 100644 --- a/test/spec/ol/tilerange.test.js +++ b/test/spec/ol/tilerange.test.js @@ -2,6 +2,20 @@ goog.provide('ol.test.TileRange'); describe('ol.TileRange', function() { + describe('constructor', function() { + it('creates a range', function() { + var range = new ol.TileRange(1, 2, 3, 4); + expect(range).toBeA(ol.TileRange); + }); + + it('can represent a range of one tile', function() { + var range = new ol.TileRange(2, 3, 2, 3); + expect(range).toBeA(ol.TileRange); + expect(range.getHeight()).toBe(1); + expect(range.getWidth()).toBe(1); + }); + }); + describe('contains', function() { it('returns the expected value', function() { var tileRange = new ol.TileRange(1, 1, 3, 3); @@ -53,6 +67,36 @@ describe('ol.TileRange', function() { }); }); + describe('equals', function() { + it('determines equivalence of two ranges', function() { + var one = new ol.TileRange(0, 1, 2, 4); + var same = new ol.TileRange(0, 1, 2, 4); + var diff1 = new ol.TileRange(0, 1, 2, 5); + var diff2 = new ol.TileRange(0, 1, 3, 4); + var diff3 = new ol.TileRange(0, 2, 2, 4); + var diff4 = new ol.TileRange(1, 1, 2, 4); + expect(one.equals(same)).toBe(true); + expect(one.equals(diff1)).toBe(false); + expect(one.equals(diff2)).toBe(false); + expect(one.equals(diff3)).toBe(false); + expect(one.equals(diff4)).toBe(false); + }); + }); + + describe('extent', function() { + it('modifies range so it includes another', function() { + var one = new ol.TileRange(0, 1, 2, 4); + var other = new ol.TileRange(-1, 10, -3, 12); + one.extend(other); + + expect(one.minX).toBe(-1); + expect(one.minY).toBe(1); + expect(one.maxX).toBe(2); + expect(one.maxY).toBe(12); + + }); + }); + describe('getSize', function() { it('returns the expected size', function() { var tileRange = new ol.TileRange(0, 1, 2, 4); @@ -62,6 +106,29 @@ describe('ol.TileRange', function() { }); }); + describe('intersects', function() { + it('determines if two ranges overlap', function() { + var one = new ol.TileRange(0, 1, 2, 4); + var overlapsRight = new ol.TileRange(2, 1, 4, 4); + var overlapsLeft = new ol.TileRange(-3, 1, 0, 4); + var overlapsTop = new ol.TileRange(0, 4, 2, 5); + var overlapsBottom = new ol.TileRange(0, -3, 2, 1); + expect(one.intersects(overlapsLeft)).toBe(true); + expect(one.intersects(overlapsRight)).toBe(true); + expect(one.intersects(overlapsTop)).toBe(true); + expect(one.intersects(overlapsBottom)).toBe(true); + + var right = new ol.TileRange(3, 1, 5, 4); + var left = new ol.TileRange(-3, 1, -1, 4); + var above = new ol.TileRange(0, 5, 2, 6); + var below = new ol.TileRange(0, -3, 2, 0); + expect(one.intersects(right)).toBe(false); + expect(one.intersects(left)).toBe(false); + expect(one.intersects(above)).toBe(false); + expect(one.intersects(below)).toBe(false); + }); + }); + }); goog.require('ol.TileRange');