Changeset 3323

Timestamp:

06/12/07 14:03:59 (1 year ago)

Author:

euzuro

Message:

patch for #487 -- dateline wrapping

Files:

• trunk/openlayers/examples/wrapDateLine.html (added)
• trunk/openlayers/lib/OpenLayers/BaseTypes.js (modified) (2 diffs)
• trunk/openlayers/lib/OpenLayers/Layer.js (modified) (5 diffs)
• trunk/openlayers/lib/OpenLayers/Layer/KaMap.js (modified) (1 diff)
• trunk/openlayers/lib/OpenLayers/Layer/MapServer.js (modified) (1 diff)
• trunk/openlayers/lib/OpenLayers/Layer/TMS.js (modified) (1 diff)
• trunk/openlayers/lib/OpenLayers/Layer/WMS.js (modified) (1 diff)
• trunk/openlayers/lib/OpenLayers/Layer/WorldWind.js (modified) (1 diff)
• trunk/openlayers/lib/OpenLayers/Map.js (modified) (1 diff)
• trunk/openlayers/tests/BaseTypes/test_Bounds.html (modified) (1 diff)
• trunk/openlayers/tests/BaseTypes/test_LonLat.html (modified) (1 diff)
• trunk/openlayers/tests/Layer/test_WrapDateLine.html (added)
• trunk/openlayers/tests/list-tests.html (modified) (1 diff)

trunk/openlayers/lib/OpenLayers/BaseTypes.js

@@ -298 +298 @@
-        }
-        return equals;
+    },
+    
+    /**
+     * @param {OpenLayers.Bounds} maxExtent
+     * 
+     * @returns A copy of this lonlat, but wrapped around the "dateline" (as
+     *           specified by the borders of maxExtent)
+     * @type OpenLayers.LonLat
+     */
+    wrapDateLine: function(maxExtent) {    
+
+        var newLonLat = this.clone();
+    
+        if (maxExtent) {
+            //shift right?
+            while (newLonLat.lon < maxExtent.left) {
+                newLonLat.lon +=  maxExtent.getWidth();
+            }    
+           
+            //shift left?
+            while (newLonLat.lon > maxExtent.right) {
+                newLonLat.lon -= maxExtent.getWidth();
+            }    
+        }
+                
+        return newLonLat;
-    },
-    
@@ -667 +693 @@
-    },
-
+    /**
+     * @param {OpenLayers.Bounds} maxExtent
+     * @param {Object} options
+     *     @option {float} leftTolerance Allow for a margin of error with the 
+     *                                    'left' value of this bound.
+     *                                    Default is 0
+     *     @option {float} rightTolerance Allow for a margin of error with the 
+     *                                     'right' value of this bound.
+     *                                     Default is 0
+     * 
+     * @returns A copy of this bounds, but wrapped around the "dateline" (as
+     *           specified by the borders of maxExtent). Note that this 
+     *           function only returns a different bounds value if this bounds
+     *           is *entirely* outside of the maxExtent. If this bounds 
+     *           straddles the dateline (is part in/part out of maxExtent),
+     *           the returned bounds will be merely a copy of this one.
+     * @type OpenLayers.Bounds
+     */
+    wrapDateLine: function(maxExtent, options) {    
+        options = options || new Object();
+        
+        var leftTolerance = options.leftTolerance || 0;
+        var rightTolerance = options.rightTolerance || 0;
+
+        var newBounds = this.clone();
+    
+        if (maxExtent) {
+
+           //shift right?
+           while ( newBounds.left < maxExtent.left && 
+                   (newBounds.right - rightTolerance) <= maxExtent.left ) { 
+                newBounds = newBounds.add(maxExtent.getWidth(), 0);
+           }
+
+           //shift left?
+           while ( (newBounds.left + leftTolerance) >= maxExtent.right && 
+                   newBounds.right > maxExtent.right ) { 
+                newBounds = newBounds.add(-maxExtent.getWidth(), 0);
+           }
+        }
+                
+        return newBounds;
+    },
+    
-    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Bounds"

trunk/openlayers/lib/OpenLayers/Layer.js

@@ -140 +140 @@
-    /** @type Boolean */
-    displayOutsideMaxExtent: false,
+
+    /** wrapDateLine -- #487 for more info.   
+     * 
+     * @type @Boolean 
+     */
+    wrapDateLine: false,
-    
-    
@@ -165 +171 @@
-            this.events = new OpenLayers.Events(this, this.div, 
-                                                this.EVENT_TYPES);
+        }
+
+        if (this.wrapDateLine) {
+            this.displayOutsideMaxExtent = true;
-        }
-    },
@@ -617 +627 @@
-                lonlat = new OpenLayers.LonLat(center.lon + delta_x * res ,
-                                             center.lat - delta_y * res); 
+
+                if (this.wrapDateLine) {
+                    lonlat = lonlat.wrapDateLine(this.maxExtent);
+                }
-            } // else { DEBUG STATEMENT }
-        }
@@ -643 +657 @@
-    
-    /**
-     * Adjusts the extent of a bounds in map units by the layer's gutter
-     * in pixels.
-     * 
-     * @param {OpenLayers.Bounds} bounds
-     * @type OpenLayers.Bounds
-     * @return A bounds adjusted in height and width by the gutter
-     */
-    adjustBoundsByGutter: function(bounds) {
-        var mapGutter = this.gutter * this.map.getResolution();
-        bounds = new OpenLayers.Bounds(bounds.left - mapGutter,
-                                       bounds.bottom - mapGutter,
-                                       bounds.right + mapGutter,
-                                       bounds.top + mapGutter);
-        return bounds;
-    },
-    
-    /**
-     * Sets the opacity for the entire layer (all images)
-     * @param {Float} opacity
@@ -682 +679 @@
-    },
-
+    /**
+    * This function will take a bounds, and if wrapDateLine option is set
+    * on the layer, it will return a bounds which is wrapped around the world.
+    * We do not wrap for bounds which *cross* the maxExtent.left/right, only
+    * bounds which are entirely to the left or entirely to the right.
+    *
+    * @param {OpenLayers.Bounds} bounds
+    * @private
+    */
+    adjustBounds: function (bounds) {
+
+        if (this.gutter) {
+            // Adjust the extent of a bounds in map units by the 
+            // layer's gutter in pixels.
+            var mapGutter = this.gutter * this.map.getResolution();
+            bounds = new OpenLayers.Bounds(bounds.left - mapGutter,
+                                           bounds.bottom - mapGutter,
+                                           bounds.right + mapGutter,
+                                           bounds.top + mapGutter);
+        }
+
+        if (this.wrapDateLine) {
+            // wrap around the date line, within the limits of rounding error
+            var wrappingOptions = { 
+                'rightTolerance':this.getResolution()
+            };    
+            bounds = bounds.wrapDateLine(this.maxExtent, wrappingOptions);
+                              
+        }
+        return bounds;
+    },
+
-    /** @final @type String */
-    CLASS_NAME: "OpenLayers.Layer"

trunk/openlayers/lib/OpenLayers/Layer/KaMap.js

@@ -50 +50 @@
-     */
-    getURL: function (bounds) {
+        bounds = this.adjustBounds(bounds);
-        var mapRes = this.map.getResolution();
-        var scale = Math.round((this.map.getScale() * 10000)) / 10000;

trunk/openlayers/lib/OpenLayers/Layer/MapServer.js

@@ -88 +88 @@
-     */
-    getURL: function (bounds) {
-
-
-
+
-        // Make a list, so that getFullRequestString uses literal "," 
-        var extent = [bounds.left, bounds. bottom, bounds.right, bounds.top];

trunk/openlayers/lib/OpenLayers/Layer/TMS.js

@@ -72 +72 @@
-     */
-    getURL: function (bounds) {
+        bounds = this.adjustBounds(bounds);
-        var res = this.map.getResolution();
-        var x = (bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w);

trunk/openlayers/lib/OpenLayers/Layer/WMS.js

@@ -95 +95 @@
-     */
-    getURL: function (bounds) {
-
-
-
+
-        return this.getFullRequestString(
-                     {BBOX:bounds.toBBOX(),

trunk/openlayers/lib/OpenLayers/Layer/WorldWind.js

@@ -70 +70 @@
-     */
-    getURL: function (bounds) {
+        bounds = this.adjustBounds(bounds);
-        var zoom = this.getZoom();
-        var extent = this.map.getMaxExtent();

trunk/openlayers/lib/OpenLayers/Map.js

@@ -1169 +1169 @@
-     */
-    zoomToExtent: function(bounds) {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    },
-

trunk/openlayers/tests/BaseTypes/test_Bounds.html

@@ -380 +380 @@
-
-     }
+     
+     
+     function test_16_Bounds_wrapDateLine(t) {
+        t.plan( 13 );
+        
+        var testBounds, wrappedBounds, desiredBounds;
+
+        var maxExtent = new OpenLayers.Bounds(-10,-10,10,10);
+        var exactBounds = maxExtent.clone();
+        var simpleBounds = new OpenLayers.Bounds( -5,-5,5,5);
+
+
+
+    //bad maxextent
+        testBounds = simpleBounds.clone();
+        wrappedBounds = testBounds.wrapDateLine(null);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds with a bad maxextent does nothing");
+
+
+
+    //exactly inside 
+        testBounds = exactBounds.clone();
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(exactBounds), "wrapping a bounds precisely within (equal to) maxextent does nothing");
+
+
+    //inside 
+        testBounds = simpleBounds.clone();
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds within maxextent does nothing");
+    
+// LEFT //
+
+    //straddling left
+        testBounds = simpleBounds.add(-10,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(testBounds), "wrapping a bounds that straddles the left of maxextent does nothing");
+    
+    //left rightTolerance
+        testBounds = simpleBounds.add(-14,0);
+        wrappedBounds = 
+            testBounds.wrapDateLine(maxExtent, {'rightTolerance': 1} );
+        desiredBounds = simpleBounds.add(6,0);
+        t.ok(wrappedBounds.equals(desiredBounds), "wrapping a bounds rightTolerance left of maxextent works");
+
+    //exactly left
+        testBounds = exactBounds.add(-20,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(exactBounds), "wrapping an exact bounds once left of maxextent works");
+    
+    //left
+        testBounds = simpleBounds.add(-20,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds once left of maxextent works");
+    
+    //way left
+        testBounds = simpleBounds.add(-200,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds way left of maxextent works");
+
+// RIGHT //
+
+    //straddling right
+        testBounds = simpleBounds.add(10,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(testBounds), "wrapping a bounds that straddles the right of maxextent does nothing");
+    
+    //right leftTolerance
+        testBounds = simpleBounds.add(14,0);
+        wrappedBounds = 
+            testBounds.wrapDateLine(maxExtent, {'leftTolerance': 1} );
+        desiredBounds = simpleBounds.add(-6,0);
+        t.ok(wrappedBounds.equals(desiredBounds), "wrapping a bounds leftTolerance right of maxextent works");
+    
+    //exactly right
+        testBounds = exactBounds.add(20,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(exactBounds), "wrapping an exact bounds once right of maxextent works");
+    
+    //right
+        testBounds = simpleBounds.add(20,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds once right of maxextent works");
+    
+    //way right
+        testBounds = simpleBounds.add(200,0);
+        wrappedBounds = testBounds.wrapDateLine(maxExtent);
+        t.ok(wrappedBounds.equals(simpleBounds), "wrapping a bounds way right of maxextent works");
+
+
+
+      }
-
-  // -->

trunk/openlayers/tests/BaseTypes/test_LonLat.html

@@ -89 +89 @@
-    }
-
+    function test_08_LonLat_wrapDateLine(t) {
+        t.plan( 6 );
+
+        var goodLL = new OpenLayers.LonLat(0,0);
+        var testLL, wrappedLL;
+
+  //bad maxextent
+        var maxExtent = null;
+
+        testLL = goodLL.clone();
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll with a bad maxextent does nothing");
+        
+        
+  //good maxextent
+        maxExtent = new OpenLayers.Bounds(-10,-10,10,10);
+
+    //inside
+        testLL = goodLL.clone();
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll within the maxextent does nothing");
+        
+    //left
+        testLL = goodLL.add(-20,0);
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll once left of maxextent works");
+        
+    //way left
+        testLL = goodLL.add(-200,0);
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll way left of maxextent works");
+
+    //right
+        testLL = goodLL.add(20,0);
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll once right of maxextent works");
+        
+    //way right
+        testLL = goodLL.add(200,0);
+        wrappedLL = testLL.wrapDateLine(maxExtent);
+        t.ok(wrappedLL.equals(goodLL), "wrapping a ll way right of maxextent works");
+
+    }
+
-  // -->
-  </script>

trunk/openlayers/tests/list-tests.html

@@ -50 +50 @@
-    <li>Layer/test_Vector.html</li>
-    <li>Layer/test_GML.html</li>
+    <li>Layer/test_WrapDateLine.html</li>
-    <li>test_Tile.html</li>
-    <li>Tile/test_Image.html</li>