Changeset 337

Timestamp:

08/21/08 04:03:40 (3 months ago)

Author:

arneke

Message:

This commit makes GeoWebCache nearly SRS agnostic and compatible with Ionic WMS servers (limited testing). The XML configuration still needs to be updated.

Location:

trunk/geowebcache/src

Files:

• main/java/org/geowebcache/GeoWebCacheDispatcher.java (modified) (2 diffs)
• main/java/org/geowebcache/demo/Demo.java (modified) (6 diffs)
• main/java/org/geowebcache/layer/Grid.java (modified) (6 diffs)
• main/java/org/geowebcache/layer/GridCalculator.java (moved) (moved from trunk/geowebcache/src/main/java/org/geowebcache/util/wms/GridCalculator.java) (10 diffs)
• main/java/org/geowebcache/layer/SRS.java (modified) (1 diff)
• main/java/org/geowebcache/layer/TileLayer.java (modified) (15 diffs)
• main/java/org/geowebcache/layer/wms/WMSHttpHelper.java (modified) (5 diffs)
• main/java/org/geowebcache/layer/wms/WMSLayer.java (modified) (14 diffs)
• main/java/org/geowebcache/layer/wms/WMSMetaTile.java (modified) (3 diffs)
• main/java/org/geowebcache/seeder/MTSeeder.java (modified) (2 diffs)
• main/java/org/geowebcache/seeder/SeedTask.java (modified) (2 diffs)
• main/java/org/geowebcache/service/Parameters.java (modified) (8 diffs)
• main/java/org/geowebcache/service/Request.java (modified) (1 diff)
• main/java/org/geowebcache/service/kml/KMLDebugGridLayer.java (modified) (1 diff)
• main/java/org/geowebcache/service/kml/KMLService.java (modified) (5 diffs)
• main/java/org/geowebcache/service/kml/KMZHelper.java (modified) (1 diff)
• main/java/org/geowebcache/service/wms/WMSParameters.java (modified) (3 diffs)
• main/java/org/geowebcache/service/wms/WMSService.java (modified) (6 diffs)
• main/java/org/geowebcache/util/GetCapabilitiesConfiguration.java (modified) (3 diffs)
• main/java/org/geowebcache/util/XMLConfiguration.java (modified) (1 diff)
• main/java/org/geowebcache/util/wms/BBOX.java (modified) (3 diffs)
• main/webapp/WEB-INF/geowebcache-servlet.xml (modified) (2 diffs)
• main/webapp/states_epsg4326.html (modified) (2 diffs)
• main/webapp/states_epsg900913.html (modified) (2 diffs)
• test/java/org/geowebcache/layer/GridCalculatorTest.java (moved) (moved from trunk/geowebcache/src/test/java/org/geowebcache/utils/wms/GridCalculatorTest.java) (13 diffs)
• test/java/org/geowebcache/layer/wms/MetaTileTest.java (modified) (5 diffs)

trunk/geowebcache/src/main/java/org/geowebcache/GeoWebCacheDispatcher.java

@@ -21 +21 @@
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.net.URL;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -39 +38 @@
 import org.geowebcache.service.Service;
 import org.geowebcache.tile.Tile;
-import org.springframework.core.io.Resource;
 import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.servlet.ModelAndView;

trunk/geowebcache/src/main/java/org/geowebcache/demo/Demo.java

@@ -9 +9 @@
 
 import org.geowebcache.GeoWebCacheException;
+import org.geowebcache.layer.Grid;
 import org.geowebcache.layer.SRS;
 import org.geowebcache.layer.TileLayer;
@@ -38 +39 @@
             }
 
+            SRS srs = null;
             if (srsStr != null) {
-                if (!layer.supportsProjection(new SRS(srsStr))) {
-                    throw new GeoWebCacheException("Unsupported SRS " + srsStr);
-                }
+                srs = SRS.getSRS(srsStr);
             } else {
-                srsStr = SRS.getEPSG900913().toString();
+                srs = SRS.getEPSG900913();
             }
-            page = generateHTML(layer, srsStr, formatStr);
+            page = generateHTML(layer, srs, formatStr);
 
         } else {
@@ -105 +105 @@
     }
     
-    private static String generateHTML(TileLayer layer, String srsStr, String formatStr) 
+    private static String generateHTML(TileLayer layer, SRS srs, String formatStr) 
     throws GeoWebCacheException {
         String layerName = layer.getName();
         String mime = layer.getDefaultMimeType().getFormat();
-        int srsIdx = layer.getSRSIndex(new SRS(srsStr));
+        //int srsIdx = layer.getSRSIndex(SRS.getSRS(srsStr));
         
         BBOX bbox = null;
         BBOX zoomBounds = null;
         String res = "";
-        if(srsStr.equalsIgnoreCase("EPSG:900913")) {
+        Grid grid = layer.getGrid(srs);
+        
+        if(srs.getNumber() == 900913) {
             //res = "resolutions: [156543.03,78271.52,39135.76,19567.88,9783.94,4891.97],\n";
             res = "resolutions: " + getEPSG900913Resolutions() + ",\n";
             bbox = new BBOX(-20037508.34,-20037508.34,20037508.34,20037508.34);
-        } else if(srsStr.equalsIgnoreCase("EPSG:4326")) {
+        } else if(srs.getNumber() == 4326) {
             res = "resolutions: " + getEPSG4326Resolutions() + ",\n";
             bbox = new BBOX(-180.0,-90.0,180.0,90.0);
@@ -131 +133 @@
         //    zoomBounds = bbox;
         //}
-        zoomBounds = layer.getBounds(srsIdx);
+        zoomBounds = grid.getBounds();
         
         
@@ -137 +139 @@
             "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head>\n"
             +"<meta http-equiv=\"imagetoolbar\" content=\"no\">\n"
-            +"<title>"+layerName+" "+srsStr+" "+mime+"</tile>\n"
+            +"<title>"+layerName+" "+srs.toString()+" "+mime+"</tile>\n"
             +"<style type=\"text/css\">\n"
             +"body { font-family: sans-serif; font-weight: bold; font-size: .8em; }\n"
@@ -152 +154 @@
             +"var mapOptions = { \n"
             + res
-            +"projection: new OpenLayers.Projection('"+srsStr+"'),\n"
+            +"projection: new OpenLayers.Projection('"+srs.toString()+"'),\n"
             +"maxExtent: new OpenLayers.Bounds("+bbox.toString()+") \n};\n"
             +"map = new OpenLayers.Map('map', mapOptions );\n"

trunk/geowebcache/src/main/java/org/geowebcache/layer/Grid.java

@@ -17 +17 @@
 package org.geowebcache.layer;
 
+import java.util.List;
+
+import org.geowebcache.GeoWebCacheException;
 import org.geowebcache.util.wms.BBOX;
 
 /**
  * Grid Class - Each TileLayer keeps a list of Grid Objects
- * 
- * 
  */
 
 public class Grid {
-    private BBOX bounds = null;
-
-    private BBOX gridbounds = null;
-
-    private SRS projection = null;
-
-    public Grid(SRS projection, BBOX bounds, BBOX gridBounds) {
-        this.projection = projection;
+    private SRS gridSRS = null;
+    
+    protected BBOX bounds = null;
+    
+    protected BBOX gridBounds = null;
+    
+    protected double[] resolutions = null;
+    
+    private volatile transient GridCalculator gridCalculator;
+    
+    private volatile int zoomStart = 0;
+    
+    private volatile int zoomStop = 25;
+    
+    public Grid(SRS srs, BBOX bounds, BBOX gridBounds, double[] resolutions) {
+        this.gridSRS = srs;
         this.bounds = bounds;
-        this.gridbounds = gridBounds;
+        this.gridBounds = gridBounds;
+        this.resolutions = resolutions;
     }
     
@@ -57 +67 @@
      */
     public void setGridBounds(BBOX gridbounds) {
-        this.gridbounds = gridbounds;
+        this.gridBounds = gridbounds;
     }
     /**
@@ -65 +75 @@
     public void setGridBounds(String gridbounds) {
 
-        this.gridbounds = new BBOX(gridbounds);
+        this.gridBounds = new BBOX(gridbounds);
     }
     /**
@@ -71 +81 @@
      * @param projection - SRS
      */
-    public void setProjection(SRS projection) {
-        this.projection = projection;
+    public void setSRS(SRS srs) {
+        this.gridSRS = srs;
     }
     /**
@@ -78 +88 @@
      * @return
      */
-    public SRS getProjection() {
-        return this.projection;
+    public SRS getSRS() {
+        return this.gridSRS;
     }
     /**
@@ -93 +103 @@
      */
     public BBOX getGridBounds() {
-        return this.gridbounds;
+        return this.gridBounds;
+    }
+    
+    public int getZoomStart() {
+        return this.zoomStart;
+    }
+    
+    public int getZoomStop() {
+        return this.zoomStop;
+    }
+    
+    public void setResolutions(double[] resolutions) {
+        this.resolutions = resolutions;
+    }
+    
+    public double[] getResolutions() throws GeoWebCacheException {
+        return getGridCalculator().getResolutions();
+    }
+    
+    public GridCalculator getGridCalculator() throws GeoWebCacheException {
+        GridCalculator ret = gridCalculator;
+        if (ret == null) {
+            synchronized (this) {
+                ret = gridCalculator;
+                if (gridCalculator == null) {
+                    gridCalculator = ret = initGridCalculator();
+                }
+            }
+        }
+        return ret;
     }
 
+    private GridCalculator initGridCalculator() throws GeoWebCacheException {
+        return new GridCalculator(this);
+    }
 }

trunk/geowebcache/src/main/java/org/geowebcache/layer/GridCalculator.java

@@ -15 +15 @@
  * @author Arne Kepp, The Open Planning Project, Copyright 2008
  */
-package org.geowebcache.util.wms;
-
-import java.util.Arrays;
+package org.geowebcache.layer;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.geowebcache.GeoWebCacheException;
-import org.geowebcache.layer.BadTileException;
-import org.geowebcache.layer.OutOfBoundsException;
-import org.geowebcache.service.ServiceException;
+import org.geowebcache.util.wms.BBOX;
 
 public class GridCalculator {
-    private static Log log = LogFactory
-            .getLog(org.geowebcache.util.wms.GridCalculator.class);
-
-    private BBOX gridBounds = null;
-
+    private static Log log = LogFactory.getLog(org.geowebcache.layer.GridCalculator.class);
+
+    // We may want to change this later
+    private static final int TILEPIXELS = 256;
+    
+    //private BBOX gridBounds = null;
+    private Grid grid;
+    
+    public final static double[] RESOLUTIONS4326 = 
+        GridCalculator.getResolutionArray(180.0, TILEPIXELS, 26);
+    
+    public final static double[] RESOLUTIONS900913 = 
+        GridCalculator.getResolutionArray(20037508.34*2,TILEPIXELS, 26);
+    
     // The following are the width of the actual layer
     private double gridWidth;
 
     private double gridHeight;
-
+    
+    // This is what the grid looks like at zoomlevel 0
+    private int gridX = -1;
+    
+    private int gridY = -1;
+    
+    private double[] resolutions;
+    
     // The following are for a tile, zoomed out all the way
-    private double maxTileWidth;
-
-    private double maxTileHeight;
+    //private double maxTileWidth;
+
+    //private double maxTileHeight;
 
     private int zoomStart;
 
     private int zoomStop;
-
-    //private int metaWidth;
-
-    //private int metaHeight;
-
-    // Used for unprojected profiles
-    private int gridConstant;
     
     // Special treatment of "zoomed out tile" for EPSG 4326
-    private boolean worldBoundsCoverTwoTiles = false;
+    //private boolean worldBoundsCoverTwoTiles = false;
 
     private int[] zoomedOutGridLoc = null;
@@ -60 +65 @@
     private int[][] boundsGridLevels = null;
 
-    // TODO this code does not handle coordinate systems where the base
-    // height
-    // is bigger than the width
-    // private double layerHeight;
-
-    public GridCalculator(BBOX gridBounds, BBOX layerBounds, int zoomStart,
-            int zoomStop, int metaWidth, int metaHeight, double maxTileWidth,
-            double maxTileHeight) {
-
-        this.gridBounds = gridBounds;
-        this.zoomStart = zoomStart;
-        this.zoomStop = zoomStop;
+    public GridCalculator(Grid grid) throws GeoWebCacheException {
+
+        this.grid = grid;
+        this.zoomStart = 0;
+        this.zoomStop = 25;
         //this.metaWidth = metaWidth;
         //this.metaHeight = metaHeight;
 
+        this.resolutions = grid.resolutions;
+        
+        //BBOX layerBounds = grid.bounds;
+        BBOX gridBounds = grid.gridBounds;
+        
         // Calculate
         gridWidth = gridBounds.coords[2] - gridBounds.coords[0];
         gridHeight = gridBounds.coords[3] - gridBounds.coords[1];
 
-        this.maxTileWidth = maxTileWidth;
-        this.maxTileHeight = maxTileHeight;
-        this.gridConstant = (int) Math.round(gridWidth / gridHeight - 1.0);
-
-        boundsGridLevels = calculateGridBounds(layerBounds);
-        
-        if(     this.gridConstant > 0 
-                && layerBounds.coords[0] < 0.0 
-                && layerBounds.coords[2] > 0.0) {
-            worldBoundsCoverTwoTiles = true;
+        // Figure out the rest
+        determineGrid();
+        
+        boundsGridLevels = calculateGridBounds(grid.bounds);
+    }
+    
+    private void determineGrid() throws GeoWebCacheException {
+        if(grid.resolutions == null) {
+            // Figure out the approriate resolutions
+            
+            double ratio = gridWidth / gridHeight;
+            
+            // Allow 2.5% slack
+            if(Math.abs(ratio - 1.0) < 0.025) {
+                gridX = 1;
+                gridY = 1;
+            }
+            
+            // Otherwise we'll try to expand it to an integer grid,
+            // failing that we'll just increase the smaller bounds
+            // to make the box square
+            if(ratio > 1.0) {
+                // Wider than tall
+                if(Math.abs(ratio - Math.round(ratio)) < 0.025) {
+                    gridY = 1;
+                    gridX = (int) Math.round(ratio);
+                } else {
+                    // I give up, expanding Y bounds
+                    gridX = gridY = 1;
+                    gridHeight = gridWidth;
+                }
+                determineResolutions();
+            } else {
+                // Taller than wide
+                ratio = gridHeight / gridWidth;
+                if(Math.abs(ratio - Math.round(ratio)) < 0.025) {
+                    gridY = (int) Math.round(ratio);
+                    gridX = 1;
+                } else {
+                    // I give up, expanding X bounds
+                    gridX = gridY = 1;
+                    gridWidth = gridHeight;
+                }
+                determineResolutions();
+            }
+        } else {
+            double denominator = grid.resolutions[0]* GridCalculator.TILEPIXELS;
+            this.gridX = (int) Math.round(gridWidth / denominator);
+            this.gridY = (int) Math.round(gridHeight / denominator);
+        }
+    }
+    
+    private void determineResolutions() throws GeoWebCacheException {
+        double baseResolution;
+        
+        // We use the smaller one 
+        if(gridY == 1) {
+            baseResolution = gridHeight / GridCalculator.TILEPIXELS;
+        } else if (gridX == 1) {
+            baseResolution = gridWidth / GridCalculator.TILEPIXELS;
+        } else {
+            throw new GeoWebCacheException("Unable to find height or width to calculate resolution array.");
+        }
+        
+        this.resolutions = new double[this.zoomStop - this.zoomStart + 1];
+        for(int i=this.zoomStart; i<= this.zoomStop; i++) {
+            this.resolutions[i] = baseResolution;
+            baseResolution = baseResolution / 2;
         }
     }
 
     private int[][] calculateGridBounds(BBOX layerBounds) {
+        BBOX gridBounds = grid.gridBounds;
+        
         // We'll just waste a few bytes, for cheap lookups
         int[][] gridLevels = new int[zoomStop + 1][4];
 
-        double tileWidth = maxTileWidth;
-        double tileHeight = maxTileHeight;
-
-        int tileCountX = (int) Math.round(gridWidth / maxTileWidth);
-        int tileCountY = (int) Math.round(gridHeight / maxTileHeight);
+        //int tileCountX = (int) Math.round(gridWidth / resolutions[0]);
+        //int tileCountY = (int) Math.round(gridHeight / resolutions[0]);
 
         //int metaLarger = (metaHeight > metaWidth) ? metaHeight : metaWidth;
@@ -111 +171 @@
         for (int level = 0; level <= zoomStop; level++) {
             //System.out.println("--- Level "+level+"----");
-            
+            double tileDelta = resolutions[level] * GridCalculator.TILEPIXELS;
             
             // Min X
-            rawNumber[0] = (layerBounds.coords[0] - gridBounds.coords[0]) / tileWidth;
+            rawNumber[0] = (layerBounds.coords[0] - gridBounds.coords[0]) / tileDelta;
             gridLevels[level][0] = (int) Math.floor(rawNumber[0]);
             
             // Min Y
-            rawNumber[1] = (layerBounds.coords[1] - gridBounds.coords[1]) / tileHeight;
+            rawNumber[1] = (layerBounds.coords[1] - gridBounds.coords[1]) / tileDelta;
             gridLevels[level][1] = (int) Math.floor(rawNumber[1]);
             
@@ -125 +185 @@
             
             // Max X
-            rawNumber[2] = (layerBounds.coords[2] - gridBounds.coords[0] - 0.0001) / tileWidth;
+            rawNumber[2] = (layerBounds.coords[2] - gridBounds.coords[0] - 0.00001) / tileDelta;
             gridLevels[level][2] = (int) Math.floor(rawNumber[2]);
             
             // Max Y
-            rawNumber[3] = (layerBounds.coords[3] - gridBounds.coords[1] - 0.0001) / tileHeight;
+            rawNumber[3] = (layerBounds.coords[3] - gridBounds.coords[1] - 0.00001) / tileDelta;
             gridLevels[level][3] = (int) Math.floor(rawNumber[3]);
 
@@ -139 +199 @@
             // + metaLarger);
 
-            // Adjust for metatiling if appropriate
-//            if (tileCountX > metaLarger || tileCountY > metaLarger) {
-//                // Round down
-//                gridLevels[level][0] = gridLevels[level][0]
-//                        - (gridLevels[level][0] % metaWidth);
-//                // Round down
-//                gridLevels[level][1] = gridLevels[level][1]
-//                        - (gridLevels[level][1] % metaHeight);
-//                // Naive round up
-//                gridLevels[level][2] = gridLevels[level][2]
-//                        - (gridLevels[level][2] % metaWidth) + (metaWidth - 1);
-//                // Naive round up
-//                gridLevels[level][3] = gridLevels[level][3]
-//                        - (gridLevels[level][3] % metaHeight)
-//                        + (metaHeight - 1);
-//
-//                //System.out.println("postAdjust: " +
-//                // Arrays.toString(gridLevels[level]));
-//
-//                // Fix for naive round ups, imagine applying a 3x3 metatile to a
-//                // 4x4 grid
-//                if (gridLevels[level][2] >= tileCountX) {
-//                    gridLevels[level][2] = tileCountX - 1;
-//                }
-//                if (gridLevels[level][3] >= tileCountY) {
-//                    gridLevels[level][3] = tileCountY - 1;
-//                }
-//                //System.out.println("postFix: " +
-//                // Arrays.toString(gridLevels[level]));
-//            }
-
-            // For the next round
-            tileWidth = tileWidth / 2;
-            tileHeight = tileHeight / 2;
-
-            tileCountX = tileCountX * 2;
-            tileCountY = tileCountY * 2;
+            //tileCountX = tileCountX * 2;
+            //tileCountY = tileCountY * 2;
         }
         return gridLevels;
@@ -210 +235 @@
         double reqTileWidth = tileBounds.coords[2] - tileBounds.coords[0];
 
-        double zoomLevel = Math.log(gridWidth / reqTileWidth) / Math.log(2);
-        
-        long roundedZoomLevel = Math.round(zoomLevel);
-        if(Math.abs(zoomLevel - (double) roundedZoomLevel) > 0.05) {
-            throw new BadTileException("The bounds result in a zoom level of "+zoomLevel+
-                        ", expected something within 0.05 of an integer, check " + tileBounds.toString());
-        }
+        //Arrays.binarySearch(a, key)
+        //double zoomLevel = Math.log(gridWidth / reqTileWidth) / Math.log(2);
+        
+        //long roundedZoomLevel = Math.round(zoomLevel);
+
         
         // (Z) Zoom level
         // For EPSG 4326, reqTileWidth = 0.087 log(4096) / log(2) - 1; -> 11
-        retVals[2] = (int) roundedZoomLevel
-                - gridConstant;
-
-        double tileWidth = gridWidth / (Math.pow(2, retVals[2] + gridConstant));
-
+        retVals[2] = this.binarySearchForResolution(reqTileWidth / GridCalculator.TILEPIXELS);
+
+        double tileWidth = resolutions[retVals[2]] * GridCalculator.TILEPIXELS;
+
+        // Get the bounds
+        BBOX layerBounds = grid.bounds;
+        BBOX gridBounds = grid.gridBounds;
+        
         // X
         double xdiff = tileBounds.coords[0] - gridBounds.coords[0];
@@ -290 +316 @@
      */
     public BBOX bboxFromGridLocation(int[] gridLoc) {
-        double tileWidth = gridWidth / Math.pow(2, gridLoc[2] + gridConstant);
-
+        //double tileWidth = gridWidth / Math.pow(2, gridLoc[2] + gridConstant);
+        double tileWidth = resolutions[gridLoc[2]] * GridCalculator.TILEPIXELS;
+        
+        BBOX gridBounds = grid.gridBounds;
+        
         return new BBOX(gridBounds.coords[0] + tileWidth * gridLoc[0],
                 gridBounds.coords[1] + tileWidth * gridLoc[1],
@@ -309 +338 @@
 
     public BBOX bboxFromGridBounds(int[] gridLocBounds) {
-        double tileWidth = gridWidth
-                / Math.pow(2, gridLocBounds[4] + gridConstant);
-
+        //double tileWidth = gridWidth
+        //        / Math.pow(2, gridLocBounds[4] + gridConstant);
+        
+        double tileWidth = GridCalculator.TILEPIXELS * resolutions[gridLocBounds[4]];
+        
+        BBOX gridBounds = grid.gridBounds;
+        
         return new BBOX(gridBounds.coords[0] + tileWidth * gridLocBounds[0],
                 gridBounds.coords[1] + tileWidth * gridLocBounds[1],
@@ -388 +421 @@
             return zoomedOutGridLoc;
         }
-
+        
+        //TODO fix negative number to return more than one top tile
+        
         // Exception for EPSG:4326, which can zoom out to two tiles
-        if (worldBoundsCoverTwoTiles) {
+        if (gridX == 2 && gridY == 1) {
             zoomedOutGridLoc = new int[3];
             zoomedOutGridLoc[0] = -1;
@@ -416 +451 @@
     }
     
-    public double[] getResolutions(int widthPixels) {
-        double[] ret = new double[zoomStop - zoomStart + 1];
-        double tileWidth = maxTileWidth / widthPixels;
-        
-        for(int i=0; i<ret.length; i++) {
-            ret[i] = tileWidth;
-            tileWidth = tileWidth / 2;
-        }
-        
-        return ret;
-    }
+    public double[] getResolutions() {
+