source: TI05-delivery/ows_framework/branches/ows_framework-refactor/ows_common/ows_common/pylons/wms_controller.py @ 3571

"""
WMS controller for OGC Web Services (OWS).

@author: Stephen Pascoe
"""

from cStringIO import StringIO

from matplotlib.cm import get_cmap
from pylons import request, response, c

import logging
log = logging.getLogger(__name__)

import Image

from ows_common.model.wms import WmsDatasetSummary, Dimension
from ows_common.model import PossibleValues, BoundingBox, Contents
from ows_common.pylons import ows_controller
from ows_common.exceptions import *
from ows_common import bbox_util

class WMSController(ows_controller.OWSController):
    """
    Subclass this controller in a pylons application and set the layerMapper
    class attribute to implement a WMS.

    @cvar layerMapper: an ows_common.service.wms_iface.ILayerMapper object.

    """
    layerMapper = None
    
    _pilImageFormats = {
        'image/png': 'PNG',
        'image/jpg': 'JPEG',
        'image/gif': 'GIF',
        'image/tiff': 'TIFF'
        }
    _layerSlabCache = {}

    #-------------------------------------------------------------------------
    # Attributes required by OWSController

    service = 'WMS'
    owsOperations = ows_controller.OWSController.owsOperations + ['GetMap', 'GetContext',
                                                                  'GetInfo']
    validVersions = ['1.1.1']

    #-------------------------------------------------------------------------

    def __before__(self, **kwargs):
        """
        This default implementation of __before__() will pass all routes
        arguments to the layer mapper to retrieve a list of layers for
        this WMS.

        It will be called automatically by pylons before each action method.

        @todo: The layer mapper needs to come from somewhere.

        """
        self.layers = self.layerMapper.map(**kwargs)

    #-------------------------------------------------------------------------
    # Methods implementing stubs in OWSController

    def _renderCapabilities(self, version, format):
        t = ows_controller.templateLoader.load('wms_capabilities_1_1_1.xml')
        return t.generate(c=c).render()

    def _loadCapabilities(self):
        """
        @note: Assumes self.layers has already been created by __before__().

        """
        ows_controller.addOperation('GetMap', formats=self._pilImageFormats.keys())
        ows_controller.addOperation('GetInfo')
        log.debug('Loading capabilities contents')
        c.capabilities.contents = Contents()
        for layerName, layer in self.layers.items():
            log.debug('Loading layer %s' % layerName)

            # Get CRS/BBOX pairs
            bboxObjs = []
            for crs in layer.crss:
                bbox = layer.getBBox(crs)
                bboxObjs.append(BoundingBox(bbox[:2], bbox[2:], crs=crs))
            # Get dimensions
            dims = {}
            for dimName, dim in layer.dimensions.items():
                dims[dimName] = Dimension(valuesUnit=dim.units,
                                          unitSymbol=dim.units,
                                          possibleValues=
                                            PossibleValues.fromAllowedValues(dim.extent))
            # Create the ows_common object
            ds = WmsDatasetSummary(identifier=layerName,
                                   titles=[layer.title],
                                   CRSs=layer.crss,
                                   boundingBoxes=bboxObjs,
                                   abstracts=[layer.abstract],
                                   dimensions=dims)

            c.capabilities.contents.datasetSummaries.append(ds)

    #-------------------------------------------------------------------------
    # OWS Operation methods
    
    def GetMap(self):

        # Housekeeping
        version = self.getOwsParam('version', default=self.validVersions[0])
        if version not in self.validVersions:
            raise InvalidParameterValue('Version %s not supported' % version,
                                        'version')
        styles = self.getOwsParam('styles', default='')
        transparent = self.getOwsParam('transparent', default='FALSE')
        bgcolor = self.getOwsParam('bgcolor', default='0xFFFFFF')

        # Layer handling
        layerName = self.getOwsParam('layers')
        if ',' in layerName:
            raise InvalidParameterValue(
                'Multi-layer GetMap requests are not supported', 'layers')
        try:
            layerObj = self.layers[layerName]
        except KeyError:
            raise InvalidParameterValue('Layer %s not found' % layerName, 'layers')

        
        # Coordinate parameters
        bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(','))
        width = int(self.getOwsParam('width'))
        height = int(self.getOwsParam('height'))
        srs = self.getOwsParam('srs')
        if srs not in layerObj.crss:
            raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs))

        # Get format
        format = self.getOwsParam('format')
        if format not in self._pilImageFormats:
            raise InvalidParameterValue(
                'Format %s not supported' % format, 'format')

        # Dimension handling
        dimValues = {}
        for dimName, dim in layerObj.dimensions.items():
            defaultValue = dim.extent[0]
            dimValues[dimName] = self.getOwsParam(dimName, default=defaultValue)
            
        #---------------------------------------------------------------------
        # The real work
        #!TODO: Minimum and maximum values
        
        # Find the slab in the cache first
        cacheKey = layerObj.getCacheKey(srs, dimValues)

        slab = self._layerSlabCache.get(cacheKey)
        if slab is None:
            slab = layerObj.getSlab(srs, dimValues, dict(minValue=0, maxValue=100))
            if cacheKey is not None:
                self._layerSlabCache[cacheKey] = slab

        # We must request a bbox within the layer's bbox.
        lbbox = layerObj.getBBox(srs)
        ibbox = bbox_util.intersection(bbox, lbbox)

        log.debug('bbox = %s' % (bbox,))
        log.debug('lbbox = %s' % (lbbox,))
        log.debug('ibbox = %s' % (ibbox,))

        # If bbox is not within layerObj.bbox then we need to calculate the
        # pixel offset of the inner bbox, request the right width/height
        # and paste the image into a blank background
        if bbox == ibbox:
            img = slab.getImage(bbox, width, height)
            log.debug('slab image.size = %s' % (img.size,))
        else:
            sx, sy = bbox_util.relativeSize(ibbox, bbox)
            log.debug('scaling: %s,%s' % (sx, sy))
            img1 = slab.getImage(ibbox, int(width*sx), int(height*sy))
            log.debug('inner image.size = %s' % (img1.size,))

            img = Image.new('RGBA', (width, height))
            pxOrigin = bbox_util.geoToPixel(ibbox[0], ibbox[3], bbox, width, height)
            log.debug('pxOrigin = %s' % (pxOrigin,))
            img.paste(img1, pxOrigin)
            

        # IE < 7 doesn't display the alpha layer right.  Here we sniff the
        # user agent and remove the alpha layer if necessary.
        try:
            ua = request.headers['User-Agent']
        except:
            pass
        else:
            if 'MSIE' in ua and 'MSIE 7' not in ua:
                img = img.convert('RGB')

        buf = StringIO()
        img.save(buf, self._pilImageFormats[format])

        response.headers['Content-Type'] = format
        response.write(buf.getvalue())

        return request

    def GetContext(self):
        """
        Return a WebMap Context document for a given set of layers.

        """
        # Parameters
        layers = self.getOwsParam('layers', default=None)

        # Filter self.layers for selected layers
        if layers is not None:
            newLayerMap = {}
            for layerName in layers.split(','):
                try:
                    newLayerMap[layerName] = self.layers[layerName]
                except KeyError:
                    raise InvalidParameterValue('Layer %s not found' % layerName,
                                                'layers')
                    
            self.layers = newLayerMap

        # Automatically select the first bbox/crs for the first layer
        aLayer = self.layers.values()[0]
        crs = aLayer.crss[0]
        bb = aLayer.getBBox(crs)
        c.bbox = BoundingBox(bb[:2], bb[2:], crs)

        # Initialise as if doing GetCapabilities
        ows_controller.initCapabilities()
        self._loadCapabilities()

        response.headers['Content-Type'] = 'text/xml'
        t = ows_controller.templateLoader.load('wms_context_1_1_1.xml')
        return t.generate(c=c).render()


    def GetInfo(self):
        from pprint import pformat
        request.headers['Content-Type'] = 'text/ascii'
        response.write('Some info about this service\n')
        for layer in model.ukcip02.layers:
            response.write('Layer %s: %s\n' % (layer, pformat(g.ukcip02_layers[layer].__dict__)))