Ticket #1243: fractional.patch

tests/test_Map.html

@@ -958 +958 @@
-             se.toString(),
-             "map extent not restricted with null restrictedExtent for se");
-    }
+    
+    function test_Map_getResolutionForZoom(t) {
+        t.plan(2);
+        var map = new OpenLayers.Map("map");
+        var res = map.getResolutionForZoom();
+        t.eq(res, null, "getResolutionForZoom returns null for no base layer");
+        map.fractionalZoom = true;
+        var layer = new OpenLayers.Layer("test", {isBaseLayer: true});
+        layer.getResolutionForZoom = function() {
+            t.ok(true, "getResolutionForZoom calls base layer getResolutionForZoom");
+        }
+        map.addLayer(layer);
+        var res = map.getResolutionForZoom();
+        layer.destroy();
+        map.destroy();
+    }
-
-    function test_99_Map_destroy (t) {
-        t.plan( 3 );    

tests/test_Layer.html

@@ -176 +176 @@
-
-    function test_06_Layer_getZoomForResolution(t) {
-
-8
+12
-
-        var layer = new OpenLayers.Layer('Test Layer');
-
+
+
-        //make some dummy resolutions
-        layer.resolutions = [128, 64, 32, 16, 8, 4, 2];
-        
@@ -193 +194 @@
-
-        t.eq(layer.getZoomForResolution(65, true), 1, "closest res");
-        t.eq(layer.getZoomForResolution(63, true), 1, "closest res");
+        
+        layer.map.fractionalZoom = true;
+        t.eq(layer.getZoomForResolution(64), 1,
+             "(fractionalZoom) correct zoom for res in array");
+        t.eq(layer.getZoomForResolution(48).toPrecision(6), (1.5).toPrecision(6),
+             "(fractionalZoom) linear scaling for res between entries");
+        t.eq(layer.getZoomForResolution(200).toPrecision(6), (0).toPrecision(6),
+             "(fractionalZoom) doesn't return zoom below zero");
+        t.eq(layer.getZoomForResolution(1).toPrecision(6), (layer.resolutions.length - 1).toPrecision(6),
+             "(fractionalZoom) doesn't return zoom above highest index");
-
-    }
-    
@@ -301 +312 @@
-        t.ok(layer.imageOffset.equals(desiredImageOffset), "image offset correctly calculated");
-        t.ok(layer.imageSize.equals(desiredImageSize), "image size correctly calculated");
-    }
+    
+    function test_Layer_getResolution(t) {
+        t.plan(1);
+        var layer = new OpenLayers.Layer("test");
+        layer.map = {
+            getZoom: function() {return "foo";}
+        };
+        layer.getResolutionForZoom = function(zoom) {
+            t.eq(zoom, "foo", "getResolution calls getResolutionForZoom");
+        }
+        layer.getResolution();
+        layer.map = null;
+        layer.destroy();
+    }
+    
+    function test_Layer_getResolutionForZoom(t) {
+        t.plan(5);
+        var layer = new OpenLayers.Layer("test");
+        layer.map = {fractionalZoom: false};
+        layer.resolutions = ["zero", "one", "two"];
+        t.eq(layer.getResolutionForZoom(0), "zero",
+             "(fractionalZoom false) returns resolution for given index");
+        t.eq(layer.getResolutionForZoom(0.9), "one",
+             "(fractionalZoom false) returns resolution for float index");
+        
+        layer.resolutions = [2, 4, 6, 8];
+        layer.map.fractionalZoom = true;
+        t.eq(layer.getResolutionForZoom(1).toPrecision(6), (4).toPrecision(6),
+             "(fractionalZoom true) returns resolution for integer zoom");
+        t.eq(layer.getResolutionForZoom(1.5).toPrecision(6), (5).toPrecision(6),
+             "(fractionalZoom true) returns resolution for float zoom");             
+        t.eq(layer.getResolutionForZoom(3.5).toPrecision(6), (8).toPrecision(6),
+             "(fractionalZoom true) returns resolution for zoom beyond res length - 1");
+        
+    }
-
-
-

lib/OpenLayers/Map.js

@@ -67 +67 @@
-    id: null,
-    
-    /**
+     * Property: fractionalZoom
+     * {Boolean} For a base layer that supports it, allow the map resolution
+     *     to be set to a value between one of the values in the resolutions
+     *     array.  Default is false.
+     */
+    fractionalZoom: false,
+    
+    /**
-     * APIProperty: events
-     * {<OpenLayers.Events>} An events object that handles all 
-     *                       events on the map
@@ -1266 +1274 @@
-            if(zoom == null) { 
-                zoom = this.getZoom(); 
-            }
-
-
-
-
+
-            var extent = this.calculateBounds(lonlat, resolution); 
-            if(!this.restrictedExtent.containsBounds(extent)) {
-                var maxCenter = this.restrictedExtent.getCenterLonLat(); 
@@ -1326 +1331 @@
-
-            if (zoomChanged) {
-                this.zoom = zoom;
-baseLayer.getResolution(
+getResolutionForZoom(zoom
-                // zoom level has changed, increment viewRequestID.
-                this.viewRequestID++;
-            }    
@@ -1595 +1600 @@
-    },
-
-    /**
+     * APIMethod: getResolutionForZoom
+     * 
+     * Parameter:
+     * zoom - {Float}
+     * 
+     * Returns:
+     * {Float} A suitable resolution for the specified zoom.  If no baselayer
+     *     is set, returns null.
+     */
+    getResolutionForZoom: function(zoom) {
+        var resolution = null;
+        if(this.baseLayer) {
+            resolution = this.baseLayer.getResolutionForZoom(zoom);
+        }
+        return resolution;
+    },
+
+    /**
-     * APIMethod: getZoomForResolution
-     * 
-     * Parameter:

lib/OpenLayers/Control/Navigation.js

@@ -137 +137 @@
-        var size    = this.map.getSize();
-        var deltaX  = size.w/2 - evt.xy.x;
-        var deltaY  = evt.xy.y - size.h/2;
-resolutions[newZoom]
+getResolutionForZoom(newZoom)
-        var zoomPoint = this.map.getLonLatFromPixel(evt.xy);
-        var newCenter = new OpenLayers.LonLat(
-                            zoomPoint.lon + deltaX * newRes,

lib/OpenLayers/Layer.js

@@ -758 +758 @@
-     */
-    getResolution: function() {
-        var zoom = this.map.getZoom();
-resolutions[zoom]
+getResolutionForZoom(zoom)
-    },
-
-    /** 
@@ -813 +813 @@
-    },
-
-    /**
+     * APIMethod: getResolutionForZoom
+     * 
+     * Parameter:
+     * zoom - {Float}
+     * 
+     * Returns:
+     * {Float} A suitable resolution for the specified zoom.
+     */
+    getResolutionForZoom: function(zoom) {
+        zoom = Math.max(0, Math.min(zoom, this.resolutions.length - 1));
+        var resolution;
+        if(this.map.fractionalZoom) {
+            var low = Math.floor(zoom);
+            var high = Math.ceil(zoom);
+            resolution = this.resolutions[high] +
+                ((zoom-low) * (this.resolutions[low]-this.resolutions[high]));
+        } else {
+            resolution = this.resolutions[Math.round(zoom)];
+        }
+        return resolution;
+    },
+
+    /**
-     * APIMethod: getZoomForResolution
-     * 
-     * Parameters:
@@ -831 +854 @@
-     *     value and the 'closest' specification.
-     */
-    getZoomForResolution: function(resolution, closest) {
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                    break;
-                }
-
+
+
+
+
-            } else {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-            }
+            zoom = Math.max(0, i-1);
-        }
-Math.max(0, i-1)
+zoom
-    },
-    
-    /**

examples/fractional-zoom.html

@@ +1 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <style type="text/css">
+        #map {
+            width: 512px;
+            height: 256px;
+            border: 1px solid gray;
+        }
+    </style>
+    <script src="../lib/OpenLayers.js"></script>
+    <script type="text/javascript">
+        var map;
+
+        function init() {
+            map = new OpenLayers.Map('map');
+            var wms = new OpenLayers.Layer.WMS(
+                "OpenLayers WMS",
+                "http://labs.metacarta.com/wms/vmap0",
+                {layers: 'basic'}
+            );
+            map.addLayers([wms]);
+
+            map.events.register("moveend", null, displayZoom);
+            map.addControl( new OpenLayers.Control.LayerSwitcher() );
+
+            map.zoomToMaxExtent();
+            
+            update(document.getElementById("fractional"));
+            
+        }
+        
+        function displayZoom() {
+            document.getElementById("zoom").innerHTML = map.zoom.toFixed(4);
+        }
+        
+        function update(input) {
+            map.fractionalZoom = input.checked;
+        }
+    </script>
+  </head>
+  <body onload="init()">
+    <h1 id="title">Fractional Zoom Example</h1>
+
+    <div id="tags">
+    </div>
+    <p id="shortdesc">
+            Shows the use of a map with fractional (or non-discrete) zoom levels.
+    </p>
+
+    <div id="map"></div>
+        <input type="checkbox" name="fractional"
+               id="fractional" checked="checked" onclick="update(this)" />
+        <label for="fractional">Fractional Zoom</label>
+        (zoom: <span id="zoom"></span>)
+        <br /><br />
+    <div id="docs">
+            <p>
+            Setting the map.fractionalZoom property to true allows zooming to
+            an arbitrary level (between the min and max resolutions).  This
+            can be demonstrated by shift-dragging a box to zoom to an arbitrary
+            extent.
+            </p>
+    </div>
+  </body>
+</html>
+
+
+
+