TileStache.Core
index
/Users/migurski/Sites/TileStache/TileStache/Core.py

The core class bits of TileStache.
 
Two important classes can be found here.
 
Layer represents a set of tiles in TileStache. It keeps references to
providers, projections, a Configuration instance, and other details required
for to the storage and rendering of a tile set. Layers are represented in the
configuration file as a dictionary:
 
    {
      "cache": ...,
      "layers": 
      {
        "example-name":
        {
            "provider": { ... },
            "metatile": { ... },
            "stale lock timeout": ...,
            "projection": ...
        }
      }
    }
 
- "provider" refers to a Provider, explained in detail in TileStache.Providers.
- "metatile" optionally makes it possible for multiple individual tiles to be
  rendered at one time, for greater speed and efficiency. This is commonly used
  for the Mapnik provider. See below for more information on metatiles.
- "projection" names a geographic projection, explained in TileStache.Geography.
  If omitted, defaults to spherical mercator.
- "stale lock timeout" is an optional number of seconds to wait before forcing
  a lock that might be stuck. This is defined on a per-layer basis, rather than
  for an entire cache at one time, because you may have different expectations
  for the rendering speeds of different layer configurations. Defaults to 15.
 
The public-facing URL of a single tile for this layer might look like this:
 
    http://example.com/tilestache.cgi/example-name/0/0/0.png
 
Metatile represents a larger area to be rendered at one time. Metatiles are
represented in the configuration file as a dictionary:
 
    {
        "rows": 4,
        "columns": 4,
        "buffer": 64
    }
 
- "rows" and "columns" are the height and width of the metatile measured in
  tiles. This example metatile is four rows tall and four columns wide, so it
  will render sixteen tiles simultaneously.
- "buffer" is a buffer area around the metatile, measured in pixels. This is
  useful for providers with labels or icons, where it's necessary to draw a
  bit extra around the edges to ensure that text is not cut off. This example
  metatile has a buffer of 64 pixels, so the resulting metatile will be 1152
  pixels square: 4 rows x 256 pixels + 2 x 64 pixel buffer.

 
Classes
       
Layer
Metatile
exceptions.Exception(exceptions.BaseException)
KnownUnknown

 
class KnownUnknown(exceptions.Exception)
    There are known unknowns. That is to say, there are things that we now know we don't know.
 
This exception gets thrown in a couple places where common mistakes are made.
 
 
Method resolution order:
KnownUnknown
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.Exception:
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature

Data and other attributes inherited from exceptions.Exception:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
class Layer
    Layer.
 
Properties:
- provider: render provider, see Providers module.
- config: Configuration instance, see Config module.
- projection: geographic projection, see Geography module.
- metatile: some information on drawing many tiles at once.
- stale_lock_timeout: number of seconds until a cache lock is forced.
 
  Methods defined here:
__init__(self, config, projection, metatile, stale_lock_timeout=15)
doMetatile(self)
Return True if we have a real metatile and the provider is OK with it.
envelope(self, coord)
Projected rendering envelope (xmin, ymin, xmax, ymax) for a Coordinate.
metaEnvelope(self, coord)
Projected rendering envelope (xmin, ymin, xmax, ymax) for a metatile.
metaSize(self, coord)
Pixel width and height of full rendered image for a metatile.
metaSubtiles(self, coord)
List of all coords in a metatile and their x, y offsets in a parent image.
name(self)
Figure out what I'm called, return a name if there is one.
render(self, coord, format)
Render a tile for a coordinate, return PIL Image-like object.
 
Perform metatile slicing here as well, if required, writing the
full set of rendered tiles to cache as we go.

 
class Metatile
    Some basic characteristics of a metatile.
 
Properties:
- rows: number of tile rows this metatile covers vertically.
- columns: number of tile columns this metatile covers horizontally.
- buffer: pixel width of outer edge.
 
  Methods defined here:
__init__(self, buffer=0, rows=1, columns=1)
allCoords(self, coord)
Return a list of coordinates for a complete metatile.
 
Results are guaranteed to be ordered left-to-right, top-to-bottom.
firstCoord(self, coord)
Return a new coordinate for the upper-left corner of a metatile.
 
This is useful as a predictable way to refer to an entire metatile
by one of its sub-tiles, currently needed to do locking correctly.
isForReal(self)
Return True if this is really a metatile with a buffer or multiple tiles.
 
A default 1x1 metatile with buffer=0 is not for real.