Don't derive ol.TileRange from ol.Rectangle

src/ol/tilegrid/tilegrid.js

@@ -228,7 +228,7 @@ ol.tilegrid.TileGrid.prototype.getTileRangeForExtentAndResolution =
   this.getTileCoordForXYAndResolution_(
       extent.maxX, extent.maxY, resolution, true, tileCoord);
   return ol.TileRange.createOrUpdate(
-      minX, minY, tileCoord.x, tileCoord.y, opt_tileRange);
+      minX, tileCoord.x, minY, tileCoord.y, opt_tileRange);
 };
 
 

src/ol/tilegrid/xyztilegrid.js

@@ -46,8 +46,8 @@ ol.tilegrid.XYZ.prototype.getTileCoordChildTileRange =
     function(tileCoord, opt_tileRange) {
   if (tileCoord.z < this.maxZoom_) {
     return ol.TileRange.createOrUpdate(
-        tileCoord.x << 1, tileCoord.y << 1,
+        tileCoord.x << 1, tileCoord.x + 1 << 1,
-        tileCoord.x + 1 << 1, tileCoord.y + 1 << 1,
+        tileCoord.y << 1, tileCoord.y + 1 << 1,
         opt_tileRange);
   } else {
     return null;
@@ -61,7 +61,7 @@ ol.tilegrid.XYZ.prototype.getTileCoordChildTileRange =
 ol.tilegrid.XYZ.prototype.forEachTileCoordParentTileRange =
     function(tileCoord, callback, opt_obj, opt_tileRange) {
   var tileRange = ol.TileRange.createOrUpdate(
-      0, 0, tileCoord.x, tileCoord.y, opt_tileRange);
+      0, tileCoord.x, 0, tileCoord.y, opt_tileRange);
   var z;
   for (z = tileCoord.z - 1; z >= 0; --z) {
     tileRange.minX = tileRange.maxX >>= 1;

src/ol/tilerange.js

@@ -1,7 +1,7 @@
 goog.provide('ol.TileRange');
 
 goog.require('goog.asserts');
-goog.require('ol.Rectangle');
+goog.require('ol.Size');
 goog.require('ol.TileCoord');
 
 
@@ -11,13 +11,12 @@ goog.require('ol.TileCoord');
  * by its min/max tile coordinates and is inclusive of coordinates.
  *
  * @constructor
- * @extends {ol.Rectangle}
  * @param {number} minX Minimum X.
- * @param {number} minY Minimum Y.
  * @param {number} maxX Maximum X.
+ * @param {number} minY Minimum Y.
  * @param {number} maxY Maximum Y.
  */
-ol.TileRange = function(minX, minY, maxX, maxY) {
+ol.TileRange = function(minX, maxX, minY, maxY) {
 
   /**
    * @type {number}
@@ -27,12 +26,12 @@ ol.TileRange = function(minX, minY, maxX, maxY) {
   /**
    * @type {number}
    */
-  this.minY = minY;
+  this.maxX = maxX;
 
   /**
    * @type {number}
    */
-  this.maxX = maxX;
+  this.minY = minY;
 
   /**
    * @type {number}
@@ -40,7 +39,6 @@ ol.TileRange = function(minX, minY, maxX, maxY) {
   this.maxY = maxY;
 
 };
-goog.inherits(ol.TileRange, ol.Rectangle);
 
 
 /**
@@ -49,15 +47,15 @@ goog.inherits(ol.TileRange, ol.Rectangle);
  */
 ol.TileRange.boundingTileRange = function(var_args) {
   var tileCoord0 = arguments[0];
-  var tileRange = new ol.TileRange(tileCoord0.x, tileCoord0.y,
+  var tileRange = new ol.TileRange(tileCoord0.x, tileCoord0.x,
-                                   tileCoord0.x, tileCoord0.y);
+                                   tileCoord0.y, tileCoord0.y);
   var i, tileCoord;
   for (i = 1; i < arguments.length; ++i) {
     tileCoord = arguments[i];
     goog.asserts.assert(tileCoord.z == tileCoord0.z);
     tileRange.minX = Math.min(tileRange.minX, tileCoord.x);
-    tileRange.minY = Math.min(tileRange.minY, tileCoord.y);
     tileRange.maxX = Math.max(tileRange.maxX, tileCoord.x);
+    tileRange.minY = Math.min(tileRange.minY, tileCoord.y);
     tileRange.maxY = Math.max(tileRange.maxY, tileCoord.y);
   }
   return tileRange;
@@ -66,21 +64,21 @@ ol.TileRange.boundingTileRange = function(var_args) {
 
 /**
  * @param {number} minX Minimum X.
- * @param {number} minY Minimum Y.
  * @param {number} maxX Maximum X.
+ * @param {number} minY Minimum Y.
  * @param {number} maxY Maximum Y.
  * @param {ol.TileRange|undefined} tileRange TileRange.
  * @return {ol.TileRange} Tile range.
  */
-ol.TileRange.createOrUpdate = function(minX, minY, maxX, maxY, tileRange) {
+ol.TileRange.createOrUpdate = function(minX, maxX, minY, maxY, tileRange) {
   if (goog.isDef(tileRange)) {
     tileRange.minX = minX;
-    tileRange.minY = minY;
     tileRange.maxX = maxX;
+    tileRange.minY = minY;
     tileRange.maxY = maxY;
     return tileRange;
   } else {
-    return new ol.TileRange(minX, minY, maxX, maxY);
+    return new ol.TileRange(minX, maxX, minY, maxY);
   }
 };
 
@@ -106,7 +104,35 @@ ol.TileRange.prototype.containsTileRange = function(tileRange) {
 
 
 /**
- * @inheritDoc
+ * @param {ol.TileRange} tileRange Tile range.
+ * @return {boolean} Equals.
+ */
+ol.TileRange.prototype.equals = function(tileRange) {
+  return this.minX == tileRange.minX && this.minY == tileRange.minY &&
+      this.maxX == tileRange.maxX && this.maxY == tileRange.maxY;
+};
+
+
+/**
+ * @param {ol.TileRange} tileRange Tile range.
+ */
+ol.TileRange.prototype.extend = function(tileRange) {
+  if (tileRange.minX < this.minX) {
+    this.minX = tileRange.minX;
+  }
+  if (tileRange.maxX > this.maxX) {
+    this.maxX = tileRange.maxX;
+  }
+  if (tileRange.minY < this.minY) {
+    this.minY = tileRange.minY;
+  }
+  if (tileRange.maxY > this.maxY) {
+    this.maxY = tileRange.maxY;
+  }
+};
+
+
+/**
  * @return {number} Height.
  */
 ol.TileRange.prototype.getHeight = function() {
@@ -115,9 +141,28 @@ ol.TileRange.prototype.getHeight = function() {
 
 
 /**
- * @inheritDoc
+ * @return {ol.Size} Size.
+ */
+ol.TileRange.prototype.getSize = function() {
+  return new ol.Size(this.getWidth(), this.getHeight());
+};
+
+
+/**
  * @return {number} Width.
  */
 ol.TileRange.prototype.getWidth = function() {
   return this.maxX - this.minX + 1;
 };
+
+
+/**
+ * @param {ol.TileRange} tileRange Tile range.
+ * @return {boolean} Intersects.
+ */
+ol.TileRange.prototype.intersects = function(tileRange) {
+  return this.minX <= tileRange.maxX &&
+      this.maxX >= tileRange.minX &&
+      this.minY <= tileRange.maxY &&
+      this.maxY >= tileRange.minY;
+};

test/spec/ol/tilegrid/xyztilegrid.test.js

@@ -21,8 +21,8 @@ describe('ol.tilegrid.XYZ', function() {
           function(z, tileRange) {
             zs.push(z);
             tileRanges.push(new ol.TileRange(
-                tileRange.minX, tileRange.minY,
+                tileRange.minX, tileRange.maxX,
-                tileRange.maxX, tileRange.maxY));
+                tileRange.minY, tileRange.maxY));
             return false;
           });
 
@@ -31,32 +31,32 @@ describe('ol.tilegrid.XYZ', function() {
 
       expect(zs[0]).to.eql(4);
       expect(tileRanges[0].minX).to.eql(5);
-      expect(tileRanges[0].minY).to.eql(10);
       expect(tileRanges[0].maxX).to.eql(5);
+      expect(tileRanges[0].minY).to.eql(10);
       expect(tileRanges[0].maxY).to.eql(10);
 
       expect(zs[1]).to.eql(3);
       expect(tileRanges[1].minX).to.eql(2);
-      expect(tileRanges[1].minY).to.eql(5);
       expect(tileRanges[1].maxX).to.eql(2);
+      expect(tileRanges[1].minY).to.eql(5);
       expect(tileRanges[1].maxY).to.eql(5);
 
       expect(zs[2]).to.eql(2);
       expect(tileRanges[2].minX).to.eql(1);
-      expect(tileRanges[2].minY).to.eql(2);
       expect(tileRanges[2].maxX).to.eql(1);
+      expect(tileRanges[2].minY).to.eql(2);
       expect(tileRanges[2].maxY).to.eql(2);
 
       expect(zs[3]).to.eql(1);
       expect(tileRanges[3].minX).to.eql(0);
-      expect(tileRanges[3].minY).to.eql(1);
       expect(tileRanges[3].maxX).to.eql(0);
+      expect(tileRanges[3].minY).to.eql(1);
       expect(tileRanges[3].maxY).to.eql(1);
 
       expect(zs[4]).to.eql(0);
       expect(tileRanges[4].minX).to.eql(0);
-      expect(tileRanges[4].minY).to.eql(0);
       expect(tileRanges[4].maxX).to.eql(0);
+      expect(tileRanges[4].minY).to.eql(0);
       expect(tileRanges[4].maxY).to.eql(0);
 
     });

test/spec/ol/tilerange.test.js

@@ -4,12 +4,12 @@ describe('ol.TileRange', function() {
 
   describe('constructor', function() {
     it('creates a range', function() {
-      var range = new ol.TileRange(1, 2, 3, 4);
+      var range = new ol.TileRange(1, 3, 2, 4);
       expect(range).to.be.a(ol.TileRange);
     });
 
     it('can represent a range of one tile', function() {
-      var range = new ol.TileRange(2, 3, 2, 3);
+      var range = new ol.TileRange(2, 2, 3, 3);
       expect(range).to.be.a(ol.TileRange);
       expect(range.getHeight()).to.be(1);
       expect(range.getWidth()).to.be(1);
@@ -18,7 +18,7 @@ describe('ol.TileRange', function() {
 
   describe('contains', function() {
     it('returns the expected value', function() {
-      var tileRange = new ol.TileRange(1, 1, 3, 3);
+      var tileRange = new ol.TileRange(1, 3, 1, 3);
       expect(tileRange.contains(new ol.TileCoord(0, 0, 0))).to.not.be();
       expect(tileRange.contains(new ol.TileCoord(0, 0, 1))).to.not.be();
       expect(tileRange.contains(new ol.TileCoord(0, 0, 2))).to.not.be();
@@ -53,8 +53,8 @@ describe('ol.TileRange', function() {
           new ol.TileCoord(3, 1, 3),
           new ol.TileCoord(3, 2, 0));
       expect(tileRange.minX).to.eql(1);
-      expect(tileRange.minY).to.eql(0);
       expect(tileRange.maxX).to.eql(2);
+      expect(tileRange.minY).to.eql(0);
       expect(tileRange.maxY).to.eql(3);
     });
 
@@ -69,12 +69,12 @@ describe('ol.TileRange', function() {
 
   describe('equals', function() {
     it('determines equivalence of two ranges', function() {
-      var one = new ol.TileRange(0, 1, 2, 4);
+      var one = new ol.TileRange(0, 2, 1, 4);
-      var same = new ol.TileRange(0, 1, 2, 4);
+      var same = new ol.TileRange(0, 2, 1, 4);
-      var diff1 = new ol.TileRange(0, 1, 2, 5);
+      var diff1 = new ol.TileRange(0, 2, 1, 5);
-      var diff2 = new ol.TileRange(0, 1, 3, 4);
+      var diff2 = new ol.TileRange(0, 3, 1, 4);
       var diff3 = new ol.TileRange(0, 2, 2, 4);
-      var diff4 = new ol.TileRange(1, 1, 2, 4);
+      var diff4 = new ol.TileRange(1, 2, 1, 4);
       expect(one.equals(same)).to.be(true);
       expect(one.equals(diff1)).to.be(false);
       expect(one.equals(diff2)).to.be(false);
@@ -85,13 +85,13 @@ describe('ol.TileRange', function() {
 
   describe('extent', function() {
     it('modifies range so it includes another', function() {
-      var one = new ol.TileRange(0, 1, 2, 4);
+      var one = new ol.TileRange(0, 2, 1, 4);
-      var other = new ol.TileRange(-1, 10, -3, 12);
+      var other = new ol.TileRange(-1, -3, 10, 12);
       one.extend(other);
 
       expect(one.minX).to.be(-1);
-      expect(one.minY).to.be(1);
       expect(one.maxX).to.be(2);
+      expect(one.minY).to.be(1);
       expect(one.maxY).to.be(12);
 
     });
@@ -99,7 +99,7 @@ describe('ol.TileRange', function() {
 
   describe('getSize', function() {
     it('returns the expected size', function() {
-      var tileRange = new ol.TileRange(0, 1, 2, 4);
+      var tileRange = new ol.TileRange(0, 2, 1, 4);
       var size = tileRange.getSize();
       expect(size.width).to.eql(3);
       expect(size.height).to.eql(4);
@@ -108,20 +108,20 @@ describe('ol.TileRange', function() {
 
   describe('intersects', function() {
     it('determines if two ranges overlap', function() {
-      var one = new ol.TileRange(0, 1, 2, 4);
+      var one = new ol.TileRange(0, 2, 1, 4);
-      var overlapsRight = new ol.TileRange(2, 1, 4, 4);
+      var overlapsRight = new ol.TileRange(2, 4, 1, 4);
-      var overlapsLeft = new ol.TileRange(-3, 1, 0, 4);
+      var overlapsLeft = new ol.TileRange(-3, 0, 1, 4);
-      var overlapsTop = new ol.TileRange(0, 4, 2, 5);
+      var overlapsTop = new ol.TileRange(0, 2, 4, 5);
-      var overlapsBottom = new ol.TileRange(0, -3, 2, 1);
+      var overlapsBottom = new ol.TileRange(0, 2, -3, 1);
       expect(one.intersects(overlapsLeft)).to.be(true);
       expect(one.intersects(overlapsRight)).to.be(true);
       expect(one.intersects(overlapsTop)).to.be(true);
       expect(one.intersects(overlapsBottom)).to.be(true);
 
-      var right = new ol.TileRange(3, 1, 5, 4);
+      var right = new ol.TileRange(3, 5, 1, 4);
-      var left = new ol.TileRange(-3, 1, -1, 4);
+      var left = new ol.TileRange(-3, -1, 1, 4);
-      var above = new ol.TileRange(0, 5, 2, 6);
+      var above = new ol.TileRange(0, 2, 5, 6);
-      var below = new ol.TileRange(0, -3, 2, 0);
+      var below = new ol.TileRange(0, 2, -3, 0);
       expect(one.intersects(right)).to.be(false);
       expect(one.intersects(left)).to.be(false);
       expect(one.intersects(above)).to.be(false);