WMS Tile Caching

Goal
The goal of a WMS Tile Caching proposal, perhaps WMS-C for short, is to find a way to optimize the delivery of map imagery across the Internet. The proposal needs to offer ideally some means by which map clients can fetch tiles from existing servers, in such a way that the images can be cached on the server, or at an intermediate location, or even be completely pre-generated, if desired. Further, the proposal needs to offer a way of advertising that a cached tile set is available for a given layer from a particular WMS or WMS proxy. The proposal should leverage the existing investment in OGC-compliant WMS servers on the 'Net.

The two main questions to be addressed are:
 * 1) How does a server advertise its cacheable image tiles?
 * 2) How does a client request possibly cached image tiles?

WMS-C as WMS Profile
One approach to take might be to define WMS-C (as in Web Mapping Service - Cached) as a constrained profile of OGC WMS that permits servers to optimize their image generation, and allows tiles to be cached at intermediate points. A WMS-C service would likely only deliver images for bounding boxes aligned to a given rectangular origin and grid, and only at particular scale levels.

The basic idea is that, unlike with WMS, two different requests for a given WMS-C tile should form the exact same HTTP GET request. This invites several constraints on WMS GetMap requests:


 * 1) Minimal query string arguments (i.e. no optional arguments permitted, versus &sect;7.2)
 * 2) Fixed query string argument ordering and case (versus &sect;6.4.1; q.v. also &sect;7.2.2, Table 8)
 * 3) Fixed range of possible bounding boxes, computed from the WMS-C profile parameters
 * 4) Fixed precision on bounding box values (clarifying &sect;6.5.6)
 * 5) Fixed tile size in pixels
 * 6) Fixed layer name and/or layer name ordering
 * 7) Fixed styling
 * 8) Fixed output format

Some means of identifying these constraints programmatically on a per-server basis, a la GetCapabilities might be desirable. From the table below, it appears that minimum/maximum scale (and scale quantization factor, which should probably never be other than 2) are the only suggested tiling regime parameters that would be difficult to directly express in a WMS GetCapabilities document. Is there some existing way to add custom parameters to a GetCapabilities declaration?

Note that the LAYERS, STYLES, SRS, HEIGHT, WIDTH, and FORMAT arguments to a GetMap request would become fixed for a particular WMS-C tiled layer, but the WMS specification would still require the inclusion of these arguments in every WMS-C request (&sect; 7.2).

A WMS-C proxy or server should be free to return an exception or a redirect, if it receives a WMS request that is not WMS-C compliant, or involves a bounding box that does not correspond to a single tile in the cache.

Calculating Valid Tile Extents for a Given Request
WMS tile caching implies fixed scale or zoom levels. Typically, each valid scale level would be half that of the next larger scale. It would be worth writing reference code to help developers figure out which tiles they need to load to cover a given bounding box at a given scale.

Other Considerations

 * Would non-rectangular tessellations yield more efficient results? If so, which tessellations to consider? Also, are the processing and bandwidth advantages of a non-rectangular tessellation outweighed by the potential implementation complexity?
 * Norm Vine rightly points out that a tile request basically boils (or should boil down to) Layer + Zoom Level + Row + Column. Can we define an even simpler method for requesting tiles from servers in the know? How are those capabilities advertised, if not shoehorned into WMS? Note that WorldWind basically already has a mechanism for this. Their tiling requests basically look like:

http://domain.tld/service?L=0&X=1&Y=2
 * Like all caching schemes, WMS-C caches would need to be cognizant of expiration. Easy with using the proper HTTP headers. There is a wide range of freshness/staleness, with OpenStreetMap being highly volatile, and Landsat being pretty stable (until the ice caps melt ;).
 * Several people (particularly Paul Spencer and Chris Schmidt) have argued that a separate GetTile request should be used. This topic probably warrants discussion.

Distributed Caching

 * A WMS-C standard would permit tile caching through Coral. However, the World Wind community's experience has been that using Coral to serve tiles results in frustratingly high latency.
 * Alternately, one could do peer-to-peer tile caching optimized specifically for geographic space, which might still suffer the latency issues associated with P2P networks.

Existing Tiling Schemes

 * Mikel Maron's description of OnEarth's LandSat tiling scheme
 * World Wind's LandSat tiling scheme: PDF, wiki
 * World Wind QuadTileSet sample description, forum discussion, sample PHP code to fetch WW tiles for a given WMS GetMap request
 * osgPlanet's C++ code for tiling the Earth
 * WorldWind Example code for tiling the Earth (needs Proj.4 and GDAL libraries)DSTile and Tilepack
 * OnEarth's code for intercepting WW requests and converting into WMS requests and caching them from Lucian Plesa
 * Casey Chestnut explains Microsoft Virtual Earth's tiling scheme + code to experiment with the URL's
 * GeoOdyssey's TileShare scheme
 * Chuck Stein's GeoFusion presentation from GEON (warning: PowerPoint)

Note: WW and OnEarth's schemes are pretty much identical, the WW client just allows you to specify arbitrary tile sizes, coverages and number of levels to accomodate a given client.

Related Projects

 * osgPlanet
 * NASA WorldWind (wiki)
 * worldKit
 * Community MapBuilder
 * ka-Map!
 * other AJAX map clients, presumably

Interested Parties
Note: Interested parties should join the existing low-volume EOGEO mailing list dedicated to this topic.


 * Schuyler Erle
 * Allan Doyle
 * Norman Vine
 * Josh Lieberman
 * Adam Hill
 * David Bitner
 * Mikel Maron
 * Michael P. Gerlek
 * Steven M. Ottens
 * Paul Spencer
 * Bryan Hall
 * Tim Schaub
 * add yourself