Changeset 4270 for cows

Timestamp:

02/10/08 12:08:51 (13 years ago)

Author:

domlowe

Message:

moving wms_csmllayer code

Location:

cows/trunk/cows/service/imps

Files:

• csmlbackend/csmltests/test_csmllayer.py (moved) (moved from cows/trunk/cows/service/imps/test_csmllayer.py)
• csmlbackend/wms_csmllayer.py (modified) (1 diff)
• wms_csmllayer.py (modified) (1 diff)

cows/trunk/cows/service/imps/csmlbackend/wms_csmllayer.py

@@ +1 @@
+"""
+implementation of ILayerMapper, ILayer, IDimension, ILayerSlab interfaces, as defined in wms_iface.py
+
+"""
+import os, string
+import csml
+try:
+    import cdms2 as cdms
+except:
+    import cdms
+import Image
+from copy import copy
+from pywms.render_imp import RGBARenderer
+from matplotlib import cm
+import genutil
+from pylons import config, request, session  #config must have tmpfilebuffer and csmlstore values
+import cdtime
+import logging
+log = logging.getLogger(__name__)
+import ConfigParser
+
+from cows.service.wxs_iface import ILayerMapper
+from cows.service.wms_iface import IwmsLayer, IwmsDimension, IwmsLayerSlab
+
+try:
+    from ndgUtils import ndgObject, ndgRetrieve
+except:
+    log.warning("ndgUtils library could not be loaded, files in the eXist database won't be available, although you should still be able to access files from the csmlstore directory referenced in the ini file.")
+
+
+
+
+class CSMLLayerMapper(ILayerMapper):
+    """
+    Map keyword arguments to a collection of layers.
+    Supports the retrieval of sets of layers according to arbitary
+    keyword/value pairs.
+    Implements  ILayerMapper 
+    
+    """
+    def __init__(self):
+        self.layermapcache={}
+    
+    def _getInfo(self, feature):
+        ''' given a csml feature, return info about the layer/feature
+        @return:   title, abstract, dimensions, units, crss '''
+
+        try:
+            title=feature.name.CONTENT
+        except:
+            title=''
+        try:
+            abstract=feature.description.CONTENT
+        except:
+            abstract=title
+        
+        units=feature.getDomainUnits()
+        dimensions={}
+        tmpunits=copy(units)
+        tmpunits.reverse()
+        domain = feature.getDomain()
+        for dim in feature.getAxisLabels():
+            nextdim=CSMLDimension(domain, dim, tmpunits.pop())
+            if dim not in ['latitude', 'longitude']:
+                dimensions[dim]=nextdim
+        crs=feature.getNativeCRS()
+        crss=[self._crscat.getCRS(crs).twoD]
+        if 'EPSG:4326' in crss:
+            crss.append('CRS:84')
+            crss.append('WGS84')
+        return title, abstract, dimensions, units, crss
+        
+        
+
+    def _get_csml_doc(self, fileoruri):
+        """
+        Gets a csml document from file or exist when passed a file name or uri         
+               
+        Note, access control is not implemented on file access, only on exist access.
+        
+        """
+        if string.find(fileoruri,'__NDG-A0__') == -1:
+            #it's a local file not an identifier, read from local csmlstore
+            file=fileoruri
+            csml_dir = config['csmlstore']
+            path = os.path.join(csml_dir, file)
+            if os.path.exists(path+'.csml'):
+                f = path+'.csml'
+            elif os.path.exists(path+'.xml'):
+                f = path +'.xml'
+            else:
+                raise ValueError("Cannot find CSML file %s" % file)
+            
+            d = csml.parser.Dataset()
+            d.parse(f)
+        
+        else:
+            #it's an NDG identifier, get the document from exist.
+            uri=fileoruri 
+            uriN=ndgObject(uri)
+            conflocation=config['ndgconfig']
+            cf=ConfigParser.ConfigParser()
+            cf.read(conflocation)
+            status,x=ndgRetrieve(uriN, cf, discovery=0)
+            d=csml.parser.Dataset()
+            d.parse(x)                         
+        return d
+    
+    def map(self, **kwargs):
+        """
+        Given csml.parser.Dataset object list the names of
+        all layers available.
+        
+        @return: A mapping of layer names to ILayer implementations.
+        @raise ValueError: If no layers are available for these keywords. 
+        """
+        fileoruri=kwargs['fileoruri']
+        if fileoruri in self.layermapcache.keys():
+            #we've accessed this layer map before, get it from the cache dictionary
+            return self.layermapcache[fileoruri]
+         
+        ds = self._get_csml_doc(fileoruri)
+        layermap={}
+        self._crscat=csml.csmllibs.csmlcrs.CRSCatalogue()
+        for feature in csml.csmllibs.csmlextra.listify(ds.featureCollection.featureMembers):
+            title, abstract, dimensions, units, crss=self._getInfo(feature)
+            layermap[feature.id]=CSMLLayer(title,abstract, dimensions, units, crss, feature)
+        if len(layermap) > 0:
+            self.layermapcache[fileoruri]=layermap
+            return layermap
+        else:
+            raise ValueError
+
+
+class CSMLLayer(IwmsLayer):
+    """
+     representing a WMS layer.    Implements ILayer
+
+    @ivar title: The layer title.  As seen in the Capabilities document.
+    @ivar abstract:  Abstract as seen in the Capabilities document.
+    @ivar dimensions: A dictionary of IDimension objects.
+    @ivar units: A string describing the units.
+    @ivar crss: A sequence of SRS/CRSs supported by this layer.
+
+    @todo: Do we need minValue/maxValue?
+
+    """
+    
+    def __init__(self, title, abstract, dimensions, units, crss, feature):
+        self.featureInfoFormats=None #NotImplemented
+        self.title=title
+        self.abstract=abstract
+        self.dimensions=dimensions
+        self.units=units
+        self.crss=crss
+        self._feature=feature
+        self.legendSize=(30,100)
+        bb= self._feature.getCSMLBoundingBox().getBox()
+        #convert 0 - 360 to -180, 180 as per common WMS convention
+        if abs(bb[2]-bb[0]) >= 359 and abs(bb[2]-bb[0]) < 361:
+            bb[0], bb[2]=-180, 180
+        self.wgs84BBox = bb
+        self.featureInfoFormats = ['text/html']
+        try:
+            self.wgs84BBox = self.getBBox('EPSG:4326')
+        except:
+            raise ValueError("Layer must provide a bounding box in EPSG:4326 "
+                             "coordinates for compatibility with WMS-1.3.0")
+        self.featureinfofilecache={} #used for caching netcdf file in getFeatureInfo
+        
+    def getBBox(self, crs):
+        """
+        @return: A 4-typle of the bounding box in the given coordinate
+            reference system.
+        """
+        #bb= self._feature.getCSMLBoundingBox().getBox()
+        #convert 0 - 360 to -180, 180 as per common WMS convention
+        #if abs(bb[2]-bb[0]) >= 359 and abs(bb[2]-bb[0]) < 361:
+        #    bb[0], bb[2]=-180, 180
+        #self.wgs84BBox = bb
+        return self.wgs84BBox
+        #raise NotImplementedError
+        
+    def getSlab(self, crs, dimValues=None, renderOpts={}):
+        """
+        Creates a slab of the layer in a particular CRS and set of
+        dimensions.
+
+        @param crs: The coordinate reference system.
+        @param dimValues: A mapping of dimension names to dimension values
+            as specified in the IDimension.extent
+        @param renderOpts: A generic mapping object for passing rendering
+            options
+        @return: An object implementing ILayerSlab
+        #create netcdf for whole lat/lon for given dimValues, use to init slab
+        """
+
+        log.debug('getSlab(%s, %s)' % (crs, dimValues))
+        
+        #unicode conversion
+        for dimval in dimValues:
+            if dimval != 'time':
+                dimValues[dimval]=float(dimValues[dimval])
+            else:
+                #remove any trailing Zs from time string
+                if dimValues[dimval] [-1:] in ['Z', 'z']:
+                    dimValues[dimval]=dimValues[dimval][:-1]
+        if type(self._feature) == csml.parser.GridSeriesFeature:
+            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc'
+            result= self._feature.subsetToGridSeries(config['tmpfilebuffer'], ncname=randomname, **dimValues)
+            #for now have to read netcdf back from 
+            #disk (limitiation of CSML api)
+            netcdf=cdms.open(result[1])
+            #and then delete the temporary file
+            os.system('rm %s'%result[1])
+            bbox=self.getBBox(crs)
+            return CSMLLayerSlab(netcdf, self, crs, dimValues, renderOpts, bbox)
+        else:
+            raise NotImplementedError
+        
+    def getCacheKey(self, crs, dimValues=None, renderOpts={}):
+        """
+        Create a unique key for use in caching a slab.
+
+        The intention here is that most of the work should be done when
+        instantiating an ILayerSlab object.  These can be cached by the
+        server for future use.  The server will first call getCacheKey()
+        for the slab creation arguments and if the key is in it's cache
+        it will use a pre-generated ILayerSlab object.
+
+        """
+        dimList = list(dimValues.items())
+        dimList.sort()
+        return '%s:%s' % (crs, dimList)
+
+    def getFeatureInfo(self, format, crs, point, dimValues):
+        """
+        Return a response string descibing the feature at a given
+        point in a given CRS.
+
+        Currently only "html" is supported as output format
+
+        @param format: One of self.featureInfoFormats.  Defines which
+            format the response will be in.
+        @param crs: One of self.crss
+        @param point: a tuple (x, y) in the supplied crs of the point
+            being selected.
+        @param dimValues: A mapping of dimension names to dimension values.
+        @return: A string containing the response.
+
+        """
+        
+        #cached netcdf is indexed by a tuple of feature id and dimvalues - i.e. typically a particular time and Z value for that feature.
+        #look in dictionary for cached copy, and if so use that as the file object.
+        dictindex=str((self._feature.id, dimValues))
+        if dictindex in self.featureinfofilecache:
+            log.debug('calling cache')
+            f=self.featureinfofilecache[dictindex]
+        else: #else, use the csml api to subset the feature afresh
+            log.debug('not calling cache')
+            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc'
+            result= self._feature.subsetToGridSeries(config['tmpfilebuffer'], ncname=randomname, **dimValues)
+            #for now have to read netcdf back from disk (limitation of CSML api)
+            f=cdms.open(result[1])
+            #append to cache:
+            self.featureinfofilecache[dictindex]=f
+            #and then delete the temporary file
+            os.system('rm %s'%result[1])
+        
+        netcdf = f(self.title)  #netcdf here is a cdms transient variable
+        
+       
+        #Now grab the netCDF object for the point specified.
+        #The reason for the 'cob' option is so that if the grid the data 
+        #is defined on does not have a grid point at the point specified, 
+        #we should  still get the nearest location
+        
+        t_point = netcdf(latitude=(point[1], point[1], 'cob'), longitude=(point[0], point[0], 'cob'))
+        #now get the value recorded at this location
+        value = t_point.getValue().tolist()
+        log.debug(value)
+        log.debug(t_point.fill_value())
+        #and the fill_value too
+        fill_value = t_point.fill_value()
+        #value is actually embedded in a multi dimensional list, 
+        #so we need to extract the actual value from the list
+        while type(value) is list:
+                value = value[0]
+
+        #now check if the value is actually the fill_value rather than 
+        #a value recorded at the point specified
+        log.debug('%s %s' % (value, fill_value))
+        if (2*fill_value) == value:
+                value = "No value found at position: "+str(point[1])+", "+str(point[0])
+        else:
+                value = "Value found at position: "+str(point[1])+", "+str(point[0])+" is: "+str(value)
+        # finally return the value
+        return value
+
+
+class CSMLDimension(IwmsDimension):
+    """
+    implements IDimension
+    @ivar units: The units string.
+    @ivar extent: Sequence of extent values.
+
+    """
+    
+    def __init__(self, domain, dimname, unit):
+        self.units = unit
+        self.extent = []
+        #patch to handle current limitations of multiple time dimension scanning in csml. 
+        if string.lower(self.units)[:10] in ['days_since', 'seconds_si', 'minutes_si', 'hours_sinc','months _sin', 'years_sinc']:
+            if type(domain[dimname][0]) is not str   :
+                tunits=self.units.replace('_', ' ')
+                for val in domain[dimname]:
+                    csmltime= csml.csmllibs.csmltime.UDtimeToCSMLtime(cdtime.reltime(float(val), tunits).tocomp())
+                    self.extent.append(csmltime)
+            else:
+                for val in domain[dimname]:
+                    self.extent.append(str(val))
+        else:
+            for val in domain[dimname]:
+                self.extent.append(str(val))
+        #for time axis replace units with iso string
+        if dimname == 'time':
+            self.units='ISO8601'
+       
+class CSMLLayerSlab(IwmsLayerSlab):
+    """
+    Implements LayerSlab
+    Represents a particular horizontal slice of a WMS layer.
+
+    ILayerSlab objects are designed to be convenient to cache.
+    They should be pickleable to enable memcached support in the future.
+
+    @ivar layer: The source ILayer instance.
+    @ivar crs: The coordinate reference system.
+    @ivar dimValues: A mapping of dimension values of this view.
+    @ivar renderOpts: The renderOpts used to create this view.
+    @ivar bbox: The bounding box as a 4-tuple.
+    """
+    
+    def __init__(self, netcdf, layer, crs, dimValues, renderOpts, bbox):
+        self._netcdf=netcdf
+        self.layer = layer
+        self.crs = crs
+        self.dimValues = dimValues
+        self.renderOpts=renderOpts
+        self.bbox=bbox
+        
+        #set colour map for ALL images from this slab
+        v=self._netcdf(layer.title)
+        tvar=v(squeeze=1)
+        #get the min and max values to use for the colourmapping.
+        #change the fill values to ensure they aren't picked up as false max/mins.
+        tvar.missing_value=999999999
+        value=tvar.getValue()
+        self.minval=min(min(l) for l in value)
+        tvar.missing_value=-0.000000001
+        value=tvar.getValue()
+        self.maxval=max(max(l) for l in value)
+
+        
+    def getImage(self, bbox, width, height):
+        """
+        Create an image of a sub-bbox of a given size.
+
+        @ivar bbox: A bbox 4-tuple.
+        @ivar width: width in pixels.`  
+        @ivar height: height in pixels.
+        @return: A PIL Image object.
+
+        """
+
+        log.debug('getImage(%s, %s, %s)' % (bbox, width, height))
+        
+
+        cmap=eval(config['colourmap']) # renderOpts is hook for colourmap, for now use config
+        grid=Grid(self.layer, self._netcdf, bbox, width, height)
+        #how to handle varmin,varmax? ..read array?
+        #minval, maxval=genutil.minmax(grid.value)
+        #minval=min(min(l) for l in grid.value)
+        #maxval=max(max(l) for l in grid.value)
+        minval=self.minval
+        maxval=self.maxval
+        renderer=RGBARenderer(minval, maxval)         
+        return renderer.renderGrid(grid, bbox, width, height, cmap)
+    
+class Grid(object):
+    """A class encapsulating a simple regularly spaced, rectilinear
+    grid.  This is the only type of grid pywms is expected to
+    understand and adaptors should be provided to connect to
+    underlying implementations such as cdms or csml.
+
+    @cvar crs: Coordinate reference system
+
+    @ivar x0: coordinate of the lower left corner.
+    @ivar y0: coordinate of the lower left corner.
+    @ivar dx: The x grid spacing.
+    @ivar dy: The y grid spacing.
+    @ivar nx: The number of x grid points.
+    @ivar ny: The number of y grid points.
+    @ivar value: A masked array of the grid values.
+    @ivar ix: The dimension index of longidude in value
+    @ivar iy: The dimension index of latitude in value
+    @ivar long_name: The name of the field.
+    @ivar units: The units of the field.
+    """
+    def __init__(self, layer, netcdf, bbox, width, height):
+        #we know the axes are called latitude and longitude as the CSML code has written it:
+        v=netcdf(layer.title)
+        tvar=v(latitude=(bbox[1], bbox[3]), longitude=(bbox[0],bbox[2]),squeeze=1)
+        order=tvar.getOrder()
+        #array of data
+        self.value=tvar.getValue()
+        if order == 'xy':
+            self.ix=0
+            self.iy=1
+        else:
+            self.ix=1
+            self.iy=0
+        lat = tvar.getLatitude()
+        lon = tvar.getLongitude()
+        self.x0=lon[0]
+        self.y0=lat[0]
+        self.dx=abs(lon[0]-lon[1])
+        self.dy=abs(lat[0]-lat[1])
+        
+    
+
+        
+
+        self.nx=len(lon)
+        self.ny=len(lat)
+        self.long_name=tvar.id  #TODO, get long name from feature
+        self.units=tvar.units

cows/trunk/cows/service/imps/wms_csmllayer.py

@@ -1 @@
-"""
-implementation of ILayerMapper, ILayer, IDimension, ILayerSlab interfaces, as defined in wms_iface.py
-
-"""
-import os, string
-import csml
-try:
-    import cdms2 as cdms
-except:
-    import cdms
-import Image
-from copy import copy
-from pywms.render_imp import RGBARenderer
-from matplotlib import cm
-import genutil
-from pylons import config, request, session  #config must have tmpfilebuffer and csmlstore values
-import cdtime
-import logging
-log = logging.getLogger(__name__)
-import ConfigParser
-
-from cows.service.wxs_iface import ILayerMapper
-from cows.service.wms_iface import IwmsLayer, IwmsDimension, IwmsLayerSlab
-
-try:
-    from ndgUtils import ndgObject, ndgRetrieve
-except:
-    log.warning("ndgUtils library could not be loaded, files in the eXist database won't be available, although you should still be able to access files from the csmlstore directory referenced in the ini file.")
-
-
-
-
-class CSMLLayerMapper(ILayerMapper):
-    """
-    Map keyword arguments to a collection of layers.
-    Supports the retrieval of sets of layers according to arbitary
-    keyword/value pairs.
-    Implements  ILayerMapper 
-    
-    """
-    def __init__(self):
-        self.layermapcache={}
-    
-    def _getInfo(self, feature):
-        ''' given a csml feature, return info about the layer/feature
-        @return:   title, abstract, dimensions, units, crss '''
-
-        try:
-            title=feature.name.CONTENT
-        except:
-            title=''
-        try:
-            abstract=feature.description.CONTENT
-        except:
-            abstract=title
-        
-        units=feature.getDomainUnits()
-        dimensions={}
-        tmpunits=copy(units)
-        tmpunits.reverse()
-        domain = feature.getDomain()
-        for dim in feature.getAxisLabels():
-            nextdim=CSMLDimension(domain, dim, tmpunits.pop())
-            if dim not in ['latitude', 'longitude']:
-                dimensions[dim]=nextdim
-        crs=feature.getNativeCRS()
-        crss=[self._crscat.getCRS(crs).twoD]
-        if 'EPSG:4326' in crss:
-            crss.append('CRS:84')
-            crss.append('WGS84')
-        return title, abstract, dimensions, units, crss
-        
-        
-
-    def _get_csml_doc(self, fileoruri):
-        """
-        Gets a csml document from file or exist when passed a file name or uri         
-               
-        Note, access control is not implemented on file access, only on exist access.
-        
-        """
-        if string.find(fileoruri,'__NDG-A0__') == -1:
-            #it's a local file not an identifier, read from local csmlstore
-            file=fileoruri
-            csml_dir = config['csmlstore']
-            path = os.path.join(csml_dir, file)
-            if os.path.exists(path+'.csml'):
-                f = path+'.csml'
-            elif os.path.exists(path+'.xml'):
-                f = path +'.xml'
-            else:
-                raise ValueError("Cannot find CSML file %s" % file)
-            
-            d = csml.parser.Dataset()
-            d.parse(f)
-        
-        else:
-            #it's an NDG identifier, get the document from exist.
-            uri=fileoruri 
-            uriN=ndgObject(uri)
-            conflocation=config['ndgconfig']
-            cf=ConfigParser.ConfigParser()
-            cf.read(conflocation)
-            status,x=ndgRetrieve(uriN, cf, discovery=0)
-            d=csml.parser.Dataset()
-            d.parse(x)                         
-        return d
-    
-    def map(self, **kwargs):
-        """
-        Given csml.parser.Dataset object list the names of
-        all layers available.
-        
-        @return: A mapping of layer names to ILayer implementations.
-        @raise ValueError: If no layers are available for these keywords. 
-        """
-        fileoruri=kwargs['fileoruri']
-        if fileoruri in self.layermapcache.keys():
-            #we've accessed this layer map before, get it from the cache dictionary
-            return self.layermapcache[fileoruri]
-         
-        ds = self._get_csml_doc(fileoruri)
-        layermap={}
-        self._crscat=csml.csmllibs.csmlcrs.CRSCatalogue()
-        for feature in csml.csmllibs.csmlextra.listify(ds.featureCollection.featureMembers):
-            title, abstract, dimensions, units, crss=self._getInfo(feature)
-            layermap[feature.id]=CSMLLayer(title,abstract, dimensions, units, crss, feature)
-        if len(layermap) > 0:
-            self.layermapcache[fileoruri]=layermap
-            return layermap
-        else:
-            raise ValueError
-
-
-class CSMLLayer(IwmsLayer):
-    """
-     representing a WMS layer.    Implements ILayer
-
-    @ivar title: The layer title.  As seen in the Capabilities document.
-    @ivar abstract:  Abstract as seen in the Capabilities document.
-    @ivar dimensions: A dictionary of IDimension objects.
-    @ivar units: A string describing the units.
-    @ivar crss: A sequence of SRS/CRSs supported by this layer.
-
-    @todo: Do we need minValue/maxValue?
-
-    """
-    
-    def __init__(self, title, abstract, dimensions, units, crss, feature):
-        self.featureInfoFormats=None #NotImplemented
-        self.title=title
-        self.abstract=abstract
-        self.dimensions=dimensions
-        self.units=units
-        self.crss=crss
-        self._feature=feature
-        self.legendSize=(30,100)
-        bb= self._feature.getCSMLBoundingBox().getBox()
-        #convert 0 - 360 to -180, 180 as per common WMS convention
-        if abs(bb[2]-bb[0]) >= 359 and abs(bb[2]-bb[0]) < 361:
-            bb[0], bb[2]=-180, 180
-        self.wgs84BBox = bb
-        self.featureInfoFormats = ['text/html']
-        try:
-            self.wgs84BBox = self.getBBox('EPSG:4326')
-        except:
-            raise ValueError("Layer must provide a bounding box in EPSG:4326 "
-                             "coordinates for compatibility with WMS-1.3.0")
-        self.featureinfofilecache={} #used for caching netcdf file in getFeatureInfo
-        
-    def getBBox(self, crs):
-        """
-        @return: A 4-typle of the bounding box in the given coordinate
-            reference system.
-        """
-        #bb= self._feature.getCSMLBoundingBox().getBox()
-        #convert 0 - 360 to -180, 180 as per common WMS convention
-        #if abs(bb[2]-bb[0]) >= 359 and abs(bb[2]-bb[0]) < 361:
-        #    bb[0], bb[2]=-180, 180
-        #self.wgs84BBox = bb
-        return self.wgs84BBox
-        #raise NotImplementedError
-        
-    def getSlab(self, crs, dimValues=None, renderOpts={}):
-        """
-        Creates a slab of the layer in a particular CRS and set of
-        dimensions.
-
-        @param crs: The coordinate reference system.
-        @param dimValues: A mapping of dimension names to dimension values
-            as specified in the IDimension.extent
-        @param renderOpts: A generic mapping object for passing rendering
-            options
-        @return: An object implementing ILayerSlab
-        #create netcdf for whole lat/lon for given dimValues, use to init slab
-        """
-
-        log.debug('getSlab(%s, %s)' % (crs, dimValues))
-        
-        #unicode conversion
-        for dimval in dimValues:
-            if dimval != 'time':
-                dimValues[dimval]=float(dimValues[dimval])
-            else:
-                #remove any trailing Zs from time string
-                if dimValues[dimval] [-1:] in ['Z', 'z']:
-                    dimValues[dimval]=dimValues[dimval][:-1]
-        if type(self._feature) == csml.parser.GridSeriesFeature:
-            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc'
-            result= self._feature.subsetToGridSeries(config['tmpfilebuffer'], ncname=randomname, **dimValues)
-            #for now have to read netcdf back from 
-            #disk (limitiation of CSML api)
-            netcdf=cdms.open(result[1])
-            #and then delete the temporary file
-            os.system('rm %s'%result[1])
-            bbox=self.getBBox(crs)
-            return CSMLLayerSlab(netcdf, self, crs, dimValues, renderOpts, bbox)
-        else:
-            raise NotImplementedError
-        
-    def getCacheKey(self, crs, dimValues=None, renderOpts={}):
-        """
-        Create a unique key for use in caching a slab.
-
-        The intention here is that most of the work should be done when
-        instantiating an ILayerSlab object.  These can be cached by the
-        server for future use.  The server will first call getCacheKey()
-        for the slab creation arguments and if the key is in it's cache
-        it will use a pre-generated ILayerSlab object.
-
-        """
-        dimList = list(dimValues.items())
-        dimList.sort()
-        return '%s:%s' % (crs, dimList)
-
-    def getFeatureInfo(self, format, crs, point, dimValues):
-        """
-        Return a response string descibing the feature at a given
-        point in a given CRS.
-
-        Currently only "html" is supported as output format
-
-        @param format: One of self.featureInfoFormats.  Defines which
-            format the response will be in.
-        @param crs: One of self.crss
-        @param point: a tuple (x, y) in the supplied crs of the point
-            being selected.
-        @param dimValues: A mapping of dimension names to dimension values.
-        @return: A string containing the response.
-
-        """
-        
-        #cached netcdf is indexed by a tuple of feature id and dimvalues - i.e. typically a particular time and Z value for that feature.
-        #look in dictionary for cached copy, and if so use that as the file object.
-        dictindex=str((self._feature.id, dimValues))
-        if dictindex in self.featureinfofilecache:
-            log.debug('calling cache')
-            f=self.featureinfofilecache[dictindex]
-        else: #else, use the csml api to subset the feature afresh
-            log.debug('not calling cache')
-            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc'
-            result= self._feature.subsetToGridSeries(config['tmpfilebuffer'], ncname=randomname, **dimValues)
-            #for now have to read netcdf back from disk (limitation of CSML api)
-            f=cdms.open(result[1])
-            #append to cache:
-            self.featureinfofilecache[dictindex]=f
-            #and then delete the temporary file
-            os.system('rm %s'%result[1])
-        
-        netcdf = f(self.title)  #netcdf here is a cdms transient variable
-        
-       
-        #Now grab the netCDF object for the point specified.
-        #The reason for the 'cob' option is so that if the grid the data 
-        #is defined on does not have a grid point at the point specified, 
-        #we should  still get the nearest location
-        
-        t_point = netcdf(latitude=(point[1], point[1], 'cob'), longitude=(point[0], point[0], 'cob'))
-        #now get the value recorded at this location
-        value = t_point.getValue().tolist()
-        log.debug(value)
-        log.debug(t_point.fill_value())
-        #and the fill_value too
-        fill_value = t_point.fill_value()
-        #value is actually embedded in a multi dimensional list, 
-        #so we need to extract the actual value from the list
-        while type(value) is list:
-                value = value[0]
-
-        #now check if the value is actually the fill_value rather than 
-        #a value recorded at the point specified
-        log.debug('%s %s' % (value, fill_value))
-        if (2*fill_value) == value:
-                value = "No value found at position: "+str(point[1])+", "+str(point[0])
-        else:
-                value = "Value found at position: "+str(point[1])+", "+str(point[0])+" is: "+str(value)
-        # finally return the value
-        return value
-
-
-class CSMLDimension(IwmsDimension):
-    """
-    implements IDimension
-    @ivar units: The units string.
-    @ivar extent: Sequence of extent values.
-
-    """
-    
-    def __init__(self, domain, dimname, unit):
-        self.units = unit
-        self.extent = []
-        #patch to handle current limitations of multiple time dimension scanning in csml. 
-        if string.lower(self.units)[:10] in ['days_since', 'seconds_si', 'minutes_si', 'hours_sinc','months _sin', 'years_sinc']:
-            if type(domain[dimname][0]) is not str   :
-                tunits=self.units.replace('_', ' ')
-                for val in domain[dimname]:
-                    csmltime= csml.csmllibs.csmltime.UDtimeToCSMLtime(cdtime.reltime(float(val), tunits).tocomp())
-                    self.extent.append(csmltime)
-            else:
-                for val in domain[dimname]:
-                    self.extent.append(str(val))
-        else:
-            for val in domain[dimname]:
-                self.extent.append(str(val))
-        #for time axis replace units with iso string
-        if dimname == 'time':
-            self.units='ISO8601'
-       
-class CSMLLayerSlab(IwmsLayerSlab):
-    """
-    Implements LayerSlab
-    Represents a particular horizontal slice of a WMS layer.
-
-    ILayerSlab objects are designed to be convenient to cache.
-    They should be pickleable to enable memcached support in the future.
-
-    @ivar layer: The source ILayer instance.
-    @ivar crs: The coordinate reference system.
-    @ivar dimValues: A mapping of dimension values of this view.
-    @ivar renderOpts: The renderOpts used to create this view.
-    @ivar bbox: The bounding box as a 4-tuple.
-    """
-    
-    def __init__(self, netcdf, layer, crs, dimValues, renderOpts, bbox):
-        self._netcdf=netcdf
-        self.layer = layer
-        self.crs = crs
-        self.dimValues = dimValues
-        self.renderOpts=renderOpts
-        self.bbox=bbox
-        
-        #set colour map for ALL images from this slab
-        v=self._netcdf(layer.title)
-        tvar=v(squeeze=1)
-        #get the min and max values to use for the colourmapping.
-        #change the fill values to ensure they aren't picked up as false max/mins.
-        tvar.missing_value=999999999
-        value=tvar.getValue()
-        self.minval=min(min(l) for l in value)
-        tvar.missing_value=-0.000000001
-        value=tvar.getValue()
-        self.maxval=max(max(l) for l in value)
-
-        
-    def getImage(self, bbox, width, height):
-        """
-        Create an image of a sub-bbox of a given size.
-
-        @ivar bbox: A bbox 4-tuple.
-        @ivar width: width in pixels.`  
-        @ivar height: height in pixels.
-        @return: A PIL Image object.
-
-        """
-
-        log.debug('getImage(%s, %s, %s)' % (bbox, width, height))
-        
-
-        cmap=eval(config['colourmap']) # renderOpts is hook for colourmap, for now use config
-        grid=Grid(self.layer, self._netcdf, bbox, width, height)
-        #how to handle varmin,varmax? ..read array?
-        #minval, maxval=genutil.minmax(grid.value)
-        #minval=min(min(l) for l in grid.value)
-        #maxval=max(max(l) for l in grid.value)
-        minval=self.minval
-        maxval=self.maxval
-        renderer=RGBARenderer(minval, maxval)         
-        return renderer.renderGrid(grid, bbox, width, height, cmap)
-    
-class Grid(object):
-    """A class encapsulating a simple regularly spaced, rectilinear
-    grid.  This is the only type of grid pywms is expected to
-    understand and adaptors should be provided to connect to
-    underlying implementations such as cdms or csml.
-
-    @cvar crs: Coordinate reference system
-
-    @ivar x0: coordinate of the lower left corner.
-    @ivar y0: coordinate of the lower left corner.
-    @ivar dx: The x grid spacing.
-    @ivar dy: The y grid spacing.
-    @ivar nx: The number of x grid points.
-    @ivar ny: The number of y grid points.
-    @ivar value: A masked array of the grid values.
-    @ivar ix: The dimension index of longidude in value
-    @ivar iy: The dimension index of latitude in value
-    @ivar long_name: The name of the field.
-    @ivar units: The units of the field.
-    """
-    def __init__(self, layer, netcdf, bbox, width, height):
-        #we know the axes are called latitude and longitude as the CSML code has written it:
-        v=netcdf(layer.title)
-        tvar=v(latitude=(bbox[1], bbox[3]), longitude=(bbox[0],bbox[2]),squeeze=1)
-        order=tvar.getOrder()
-        #array of data
-        self.value=tvar.getValue()
-        if order == 'xy':
-            self.ix=0
-            self.iy=1
-        else:
-            self.ix=1
-            self.iy=0
-        lat = tvar.getLatitude()
-        lon = tvar.getLongitude()
-        self.x0=lon[0]
-        self.y0=lat[0]
-        self.dx=abs(lon[0]-lon[1])
-        self.dy=abs(lat[0]-lat[1])
-        
-    
-
-        
-
-        self.nx=len(lon)
-        self.ny=len(lat)
-        self.long_name=tvar.id  #TODO, get long name from feature
-        self.units=tvar.units