#627 Adding read-only tilecache layer. Many thanks to crschmidt for the tests here.

git-svn-id: http://svn.openlayers.org/trunk/openlayers@3763 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
2007-07-16 17:46:35 +00:00
parent cae56a65f0
commit b5035f9c7c
4 changed files with 230 additions and 0 deletions
--- a/lib/OpenLayers/Layer/TileCache.js
+++ b/lib/OpenLayers/Layer/TileCache.js
@@ -0,0 +1,170 @@
+/* Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD licence.
+ * See http://svn.openlayers.org/trunk/openlayers/repository-license.txt 
+ * for the full text of the license. */
+
+
+/**
+ * @requires OpenLayers/Layer/Grid.js
+ *
+ * Class: OpenLayers.Layer.TileCache
+ *
+ * Inherits from:
+ *  - <OpenLayers.Layer.Grid>
+ */
+OpenLayers.Layer.TileCache = OpenLayers.Class.create();
+OpenLayers.Layer.TileCache.prototype = 
+  OpenLayers.Class.inherit( OpenLayers.Layer.Grid, {
+
+    /** 
+     * APIProperty: reproject
+     * {Boolean}
+     **/
+    reproject: false,
+    
+    /** 
+     * APIProperty: isBaseLayer
+     * {Boolean}
+     **/
+    isBaseLayer: true,
+    
+    /**
+     * APIProperty: tileOrigin
+     * {<OpenLayers.LonLat>} 
+     **/
+    tileOrigin: null,
+    
+    /** 
+     * APIProperty: format
+     * {String}
+     **/
+    format: 'image/png',
+
+    /**
+    * Constructor: OpenLayers.Layer.TileCache
+    *
+    * Parameters:
+    * name - {String} 
+    * url - {String} 
+    * layername - {String} 
+    * options - {Object} Hashtable of extra options to tag onto the layer
+    */
+    initialize: function(name, url, layername, options) {
+        options = OpenLayers.Util.extend({maxResolution: 180/256}, options);
+        this.layername = layername;
+        OpenLayers.Layer.Grid.prototype.initialize.apply(this,
+                                                         [name, url, {}, options]);
+        this.extension = this.format.split('/')[1].toLowerCase();
+        this.extension = (this.extension == 'jpeg') ? 'jpg' : this.extension;
+    },    
+
+    /**
+     * APIMethod: clone
+     * obj - {Object} 
+     * 
+     * Returns:
+     * An exact clone of this <OpenLayers.Layer.TileCache>
+     */
+    clone: function (obj) {
+        
+        if (obj == null) {
+            obj = new OpenLayers.Layer.TileCache(this.name,
+                                           this.url,
+                                           this.options);
+        }
+
+        //get all additions from superclasses
+        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
+
+        // copy/set any non-init, non-simple values here
+
+        return obj;
+    },    
+    
+    /**
+     * Method: getURL
+     *
+     * Parameters:
+     * bounds - {OpenLayers.Bounds} 
+     * 
+     * Returns:
+     * A string with the layer's url and parameters and also the 
+     *      passed-in bounds and appropriate tile size specified as 
+     *      parameters
+     */
+    getURL: function(bounds) {
+        var res = this.map.getResolution();
+        var bbox = this.maxExtent;
+        var size = this.tileSize;
+        var tileX = Math.floor((bounds.left - bbox.left) / (res * size.w));
+        var tileY = Math.floor((bounds.bottom - bbox.bottom) / (res * size.h));
+        var tileZ = this.map.zoom;
+        /**
+         * Zero-pad a positive integer.
+         * number - {Int} 
+         * length - {Int} 
+         
+         * Returns:
+         * A zero-padded string
+         */
+        function zeroPad(number, length) {
+            number = String(number);
+            var zeros = [];
+            for(var i=0; i<length; ++i) {
+                zeros.push('0');
+            }
+            return zeros.join('').substring(0, length - number.length) + number;
+        }
+        var components = [
+            this.layername,
+            zeroPad(tileZ, 2),
+            zeroPad(parseInt(tileX / 1000000), 3),
+            zeroPad((parseInt(tileX / 1000) % 1000), 3),
+            zeroPad((parseInt(tileX) % 1000), 3),
+            zeroPad(parseInt(tileY / 1000000), 3),
+            zeroPad((parseInt(tileY / 1000) % 1000), 3),
+            zeroPad((parseInt(tileY) % 1000), 3) + '.' + this.extension
+        ];
+        var path = components.join('/'); 
+        var url = this.url;
+        if (url instanceof Array) {
+            url = this.selectUrl(path, url);
+        }
+        url = (url[url.length - 1] == '/') ? url : url + '/';
+        return url + path;
+    },
+
+    /**
+    * Method: addTile
+    * addTile creates a tile, initializes it, and 
+    * adds it to the layer div. 
+    *
+    * Parameters: 
+    * bounds - {<OpenLayers.Bounds>} 
+    *
+    * Returns:
+    * The added {<OpenLayers.Tile.Image>}
+    */
+    addTile:function(bounds, position) {
+        var url = this.getURL(bounds);
+        return new OpenLayers.Tile.Image(this, position, bounds, 
+                                             url, this.tileSize);
+    },
+
+    /** 
+     * Method: setMap
+     * When the layer is added to a map, then we can fetch our origin 
+     *  (if we don't have one.) 
+     * 
+     * Parameters:
+     * map - {<OpenLayers.Map>} 
+     */
+    setMap: function(map) {
+        OpenLayers.Layer.Grid.prototype.setMap.apply(this, arguments);
+        if (!this.tileOrigin) { 
+            this.tileOrigin = new OpenLayers.LonLat(this.map.maxExtent.left,
+                                                    this.map.maxExtent.bottom);
+        }
+    },
+
+    CLASS_NAME: "OpenLayers.Layer.TileCache"
+});