source: TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/csml_wms.py @ 2693

# Copyright (C) 2007 STFC & NERC (Science and Technology Facilities Council).
# This software may be distributed under the terms of the
# Q Public License, version 1.0 or later.
# http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt
"""
Example WMS controller driven by CSML.

@author: Stephen Pascoe

"""
from ows_server.lib.base import *
from ows_server.lib.decorators import *
from ows_server.lib import grid_util, render
from ows_server.lib.csml_cache import csmlCache, extractCache
import ows_server.lib.validators as V

from elementtree import ElementTree as ET

from ows_common import exceptions as OWS_E
from ows_common.wms import *
from ows_common.common import BoundingBox
from ows_common.domain import ValuesUnit, PossibleValues

import cdms
import os, sys
from cStringIO import StringIO
import MA

class CsmlWmsController(OwsController):

    _ows_parameters = {
        'Format': make_domain(['text/xml']),
        'ExceptionFormat': make_domain(['text/xml']),
        }

    #_ows_constraints = {
        # MaximumLayerLevels
        # MaximumWidth
        # MaximumWidth
    #    }


    def _iterDimensions(self, feature):
        """
        Retrieve the non-geospatial dimensions of a feature.

        @return: generator of dimension names

        """
        # Waiting for this feature to be implemented
        #lat = feature.getLatitude()
        #lon = feature.getLongitude()
        lat = 'latitude'; lon = 'longitude'
        
        for axis_name in feature.getDomain():
            if axis_name not in [lat, lon]:
                yield axis_name

    def _loadFeatureDimensions(self, feature):
        dims = {}
        domain = feature.getDomain()
        for axis_name in self._iterDimensions(feature):
            axis = domain[axis_name]
            dims[axis_name] = Dimension(possibleValues=PossibleValues.fromAllowedValues(axis),
                                        #!TODO: see ticket:770 for how to populate this
                                        valuesUnit=ValuesUnit(uoms=[''],
                                                              referenceSystems=['']))
        return dims

    def _loadFeatureSummary(self, feature):
        dims = self._loadFeatureDimensions(feature)
        
        return WmsDatasetSummary(identifier=feature.id,
                                 titles=[feature.description.CONTENT],
                                 boundingBoxes=[BoundingBox([-180,-90], [180,90],
                                                            crs='CRS:84')],
                                 dimensions=dims,               
                                 )

    def _loadCapabilities(self):
        """
        Overriding subclass to add layer capabilities

        """
        # Get default capabilities from superclass
        sm = super(CsmlWmsController, self)._loadCapabilities()

        # For WMS 1.3.0 compatibility we need a single root DatasetSummary
        ds = WmsDatasetSummary(titles=['Root Dataset'], datasetSummaries=[],
                               CRSs=['CRS:84'])
        # Add a DatasetSummary for each feature        
        for f_n in c.dataset.getFeatureList():
            feature_ds = self._loadFeatureSummary(c.dataset.getFeature(f_n))
            ds.datasetSummaries.append(feature_ds)

        sm.contents = Contents(datasetSummaries=[ds])
        return sm

    
    @operation
    @parameter('Format', possibleValues=['text/xml'])
    @parameter('Service', possibleValues=['WMS'], required=True)
    @parameter('Version', possibleValues=['1.3.0'])
    def GetCapabilities(self, file, service=None, version=None):
        """
        @note: format and updatesequence parameters are not supported
            by this WMS.

        """
        # Populate the context object with information required by the template
        c.dataset = csmlCache[file]

        return self._renderCapabilities('ows/wms_capabilities')


    @operation
    @parameter('Version', possibleValues=['1.3.0'], required=True)
    @parameter('Layers', required=True, validator=V.single_layer)
    @parameter('Styles', required=True)
    @parameter('CRS', possibleValues=['CRS:84'], required=True)
    @parameter('Bbox', required=True, validator=V.bbox_2d)
    @parameter('Width', required=True, validator=V.integer('Width'))
    @parameter('Height', required=True, validator=V.integer('Height'))
    @parameter('Format', required=True)
    @parameter('Transparent', validator=V.boolean('Transparent'))
    @parameter('Bgcolor')
    @parameter('Exceptions')
    # Dimension parameters Time, Elevation, etc. are handled separately
    def GetMap(self, file, version, layers, styles, crs, bbox, width, height, format,
               transparent=False, bgcolor=None, exceptions=None):

        # Retrieve dataset and selected feature
        dataset = csmlCache[file]
        feature = dataset.getFeature(layers)
        if feature is None:
            raise OWS_E.InvalidParameterValue('Layer not found', 'layers')

        # Clean up bbox.  Openlayers can request some very strange bboxes.  It is trimmed
        # here and the implications for the image's aspect ratio is calculated in
        # render.render_variable()
        #!TODO: This could be done better.
        #x1 = max(-180., min(180., bbox[0]))
        #x2 = max(-180., min(180., bbox[2]))
        #y1 = max(-90., min(90., bbox[1]))
        #y2 = max(-90., min(90., bbox[3]))

        # Define the extraction selector
        #sel = dict(latitude=(y1, y2), longitude=(x1, x2))

        # Parse dimensions.
        sel = {}
        for dim in self._iterDimensions(feature):
            # For the moment hard-code time in.  We don't support any other dimension yet.
            if dim.lower() != 'time':
                raise ValueError('Only lat, lon and time are supported domain axes')
            
            try:
                sel[dim] = self.ows_params[dim]
            except KeyError:
                raise OWS_E.MissingParameterValue('%s dimension not specified' % dim, dim)

        # Get the entire lat/lon slice from the extractCache
        var = extractCache[feature, sel]

        # Do geographical subsetting in cdms
        var = var(latitude=(bbox[1], bbox[3]), longitude=(bbox[0], bbox[2]), squeeze=1)

        # Deduce min and max
        #!TODO: How do we get the min/max?
        #varmin = MA.minimum(var, None)
        #varmax = MA.maximum(var, None)
        varmin=0; varmax=100

        # Render variable to a PIL image
        img = render.render_variable(var, bbox, width, height, varmin, varmax)

        # Serialise it to PNG
        buf = StringIO()
        img.save(buf, 'PNG')

        return Response(content=buf.getvalue(), mimetype='image/png')