Changeset 5500 for qesdi


Ignore:
Timestamp:
21/07/09 14:03:29 (10 years ago)
Author:
pnorton
Message:

Added some JSON to describe the rendering options. Also moved all the common layer slab code to a base slab object.

Location:
qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis
Files:
1 added
2 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/controllers/csmlwms.py

    r5494 r5500  
    44from wms_ddc_vis.model.ddc_layer_mapper import DDCLayerMapper 
    55 
     6from wms_ddc_vis.lib.base import request, response 
     7 
    68log = logging.getLogger(__name__) 
    79 
    810class CsmlwmsController(WMSController): 
    911    layerMapper = DDCLayerMapper() 
     12     
     13    owsOperations = (WMSController.owsOperations + ['GetDisplayOptions',]) 
     14     
     15    def GetDisplayOptions(self): 
     16         
     17        json ="""{ 
     18    "common":[  
     19            { 
     20                "type":"select", 
     21                "name":"cmap", 
     22                "options":["bone","jet", "copper", "grey", "winter"], 
     23            }, 
     24            { 
     25                "type":"value", 
     26                "name":"cmap_min", 
     27            }, 
     28            { 
     29                "type":"value", 
     30                "name":"cmap_max", 
     31            },                         
     32        ], 
     33    "grid":[], 
     34    "contour":[] 
     35}""" 
    1036 
    11      
     37        request.headers['Content-Type'] = 'application/json' 
     38        response.write(json) 
    1239 
    13  
    14  
    15  
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_render_options_parser.py

    r5479 r5500  
    99class DDCRenderOptionsParser(object): 
    1010     
    11     def __init__(self, renderOptions, variable): 
     11    def __init__(self, renderOptions, varMin, varMax): 
    1212        self._renderOptions = renderOptions 
    13         self._variable = variable 
     13        self._variableMin = varMin 
     14        self._variableMax = varMax 
    1415         
    1516    def getOption(self, optionName): 
     
    5657     
    5758    def _get_default_cmap_min(self): 
    58         return self._variable.min(); 
     59        return self._variableMin; 
    5960     
    6061    def _get_cmap_max(self): 
     
    6263     
    6364    def _get_default_cmap_max(self): 
    64         return self._variable.max(); 
     65        return self._variableMax; 
    6566  
    6667  
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_wms_layer.py

    r5494 r5500  
    2828import ImageDraw 
    2929 
    30 from cows.model.wms import Style, LegendURL, FormattedURL 
     30from cows.model.wms import Style, LegendURL, FormattedURL, MetadataURL 
    3131from cows.xml.iso19115_subset import OnlineResource 
    3232 
     
    5656         
    5757        self.styles = self._buildStyles() 
     58        self.metadataURLs = self._buildMetadataURL() 
    5859          
    5960        try:  
     
    105106        #create netcdf for whole lat/lon for given dimValues, use to init slab 
    106107        """ 
    107         
     108        log.debug("additionalParams = %s" % (additionalParams,)) 
     109        log.debug("bgcolor = %s" % (bgcolor,)) 
     110        log.debug("transparent = %s" % (transparent,)) 
     111        log.debug("dimValues = %s" % (dimValues,)) 
     112         
    108113        #unicode conversion 
    109114        for dimval in dimValues: 
     
    269274            height = self.legendSize[1] 
    270275         
    271         parser = DDCRenderOptionsParser(renderOpts,None) 
     276        parser = DDCRenderOptionsParser(renderOpts, self._minval, self._maxval) 
     277         
     278        cmapRange = (parser.getOption('cmap_min'), parser.getOption('cmap_max')) 
    272279 
    273280        im = geoplot.colour_bar.getColourBarImage(width, height,  
    274281                                             label='Units of measure: %s' % str(self.units),  
    275282                                             cmap=parser.getOption('cmap'),  
    276                                              cmapRange=(self._minval, self._maxval),  
     283                                             cmapRange=cmapRange,  
    277284                                             orientation=orientation) 
    278285         
     
    287294        contourStyle = Style(STYLES.CONTOUR, 'Contour Lines', legendURLs=[legendURL] ) 
    288295         
    289         return [gridStyle, contourStyle]         
     296        return [gridStyle, contourStyle] 
     297     
     298    def _buildMetadataURL(self): 
     299        onlineRes = OnlineResource(url_for(qualified=True, action='index') +\ 
     300                                    "?request=GetDisplayOptions&layers=%s" % self.name) 
     301         
     302        displayMetadata = MetadataURL(metadataType='display_options', format='application/json', onlineResource=onlineRes) 
     303         
     304        return [displayMetadata]  
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_wms_layer_slab.py

    r5494 r5500  
    22import logging 
    33 
    4 from matplotlib import cm 
    5 from cows.service.wms_iface import IwmsLayerSlab 
    6 from cows.service.imps.csmlbackend.config import config 
    7  
    84from geoplot.layer_drawer_grid import LayerDrawerGrid 
    95 
    10 from wms_ddc_vis.model.ddc_render_options_parser import DDCRenderOptionsParser 
     6from wms_ddc_vis.model.ddc_wms_layer_slab_base import DDCWmsLayerSlabBase 
    117 
    128log = logging.getLogger(__name__) 
    139 
    14 class DDCWmsLayerSlab(IwmsLayerSlab): 
    15     """ 
    16     Implements LayerSlab 
    17     Represents a particular horizontal slice of a WMS layer. 
     10class DDCWmsLayerSlab(DDCWmsLayerSlabBase): 
    1811 
    19     ILayerSlab objects are designed to be convenient to cache. 
    20     They should be pickleable to enable memcached support in the future. 
    21  
    22     @ivar crs: The coordinate reference system. 
    23     @ivar dimValues: A mapping of dimension values of this view. 
    24     @ivar renderOpts: The renderOpts used to create this view. 
    25     @ivar bbox: The bounding box as a 4-tuple. 
    26     """ 
    27  
    28     def __init__(self, netcdf, title, crs, dimValues, transparent, bbox, renderOpts): 
    2912         
    30         self._netcdf=netcdf 
    31         self.title = title 
    32         self.crs = crs 
    33         self.dimValues = dimValues 
    34         self.renderOpts=renderOpts 
    35         self.bbox=bbox 
    36          
    37         self.variable =  self._netcdf(self.title, squeeze=1)  
    38          
    39         self.minval = self.variable.min() 
    40         self.maxval = self.variable.max() 
    41          
    42         self.parser = DDCRenderOptionsParser(renderOpts, self.variable) 
     13    def _setupLayerDrawer(self): 
    4314         
    4415        cmapRange = (self.parser.getOption('cmap_min'), self.parser.getOption('cmap_max')) 
    4516         
    46         self.ld = LayerDrawerGrid(self.variable,  
    47                                   cmap=self.parser.getOption('cmap'),  
    48                               showGridLines=False,  
    49                               cmapRange=cmapRange, 
    50                               transparent=transparent) 
    51      
    52     def getImage(self, bbox, width, height): 
    53         """ 
    54         Create an image of a sub-bbox of a given size. 
    55  
    56         @ivar bbox: A bbox 4-tuple. 
    57         @ivar width: width in pixels.`   
    58         @ivar height: height in pixels. 
    59         @return: A PIL Image object. 
    60  
    61         """ 
    62  
    63         log.debug('getImage(%s, %s, %s)' % (bbox, width, height)) 
     17        ld = LayerDrawerGrid(self.variable,  
     18                             cmap=self.parser.getOption('cmap'),  
     19                             showGridLines=False,  
     20                             cmapRange=cmapRange, 
     21                             transparent=self.transparent) 
    6422         
    65         xLimits = (bbox[0], bbox[2]) 
    66         yLimits = (bbox[1], bbox[3]) 
    67                          
    68         st = time.time() 
    69         im = self.ld.makeImage(xLimits, yLimits, width, height) 
    70          
    71         log.debug("generated grid image id=%s (%sx%s, lon=%s, lat=%s in %.2fs" % \ 
    72                   (self.variable.id, width, height, xLimits, yLimits,  time.time() - st,)) 
    73          
    74         return im 
     23        return ld 
     24  
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_wms_layer_slab_contour.py

    r5479 r5500  
    1  
    21import logging 
    32import time 
    43 
    5 from matplotlib import cm 
    6 from cows.service.wms_iface import IwmsLayerSlab 
    7 from cows.service.imps.csmlbackend.config import config 
    8  
    9 from wms_ddc_vis.model.ddc_render_options_parser import DDCRenderOptionsParser 
    10  
    114from geoplot.layer_drawer_contour import LayerDrawerContour 
    125 
     6from wms_ddc_vis.model.ddc_wms_layer_slab_base import DDCWmsLayerSlabBase 
    137 
    148log = logging.getLogger(__name__) 
    159 
    16 class DDCWmsLayerSlabContour(IwmsLayerSlab): 
    17     """ 
    18     Implements LayerSlab 
    19     Represents a particular horizontal slice of a WMS layer. 
     10class DDCWmsLayerSlabContour(DDCWmsLayerSlabBase): 
    2011 
    21     ILayerSlab objects are designed to be convenient to cache. 
    22     They should be pickleable to enable memcached support in the future. 
    23  
    24     @ivar layer: The source ILayer instance. 
    25     @ivar crs: The coordinate reference system. 
    26     @ivar dimValues: A mapping of dimension values of this view. 
    27     @ivar renderOpts: The renderOpts used to create this view. 
    28     @ivar bbox: The bounding box as a 4-tuple. 
    29     """ 
    30  
    31     def __init__(self, netcdf, layer, crs, dimValues, transparent, renderOpts, bbox): 
    32          
    33         log.debug("Creating slab: netcdf = %s, layer = %s, crs = %s, dimValues = %s, renderOpts = %s, bbox = %s" % (netcdf, layer, crs, dimValues, renderOpts, bbox)) 
    34  
    35         self._netcdf=netcdf 
    36         self.layer = layer 
    37         self.crs = crs 
    38         self.dimValues = dimValues 
    39         self.renderOpts=renderOpts 
    40         self.bbox=bbox 
    41          
    42         self.variable =  self._netcdf(self.layer.title, squeeze=1)  
    43          
    44         self.minval = self.variable.min() 
    45         self.maxval = self.variable.max() 
    46          
    47         self.parser = DDCRenderOptionsParser(renderOpts, self.variable) 
     12    def _setupLayerDrawer(self): 
    4813         
    4914        cmapRange = (self.parser.getOption('cmap_min'), self.parser.getOption('cmap_max')) 
    50                  
    51         self.ld = LayerDrawerContour(self.variable,  
     15         
     16        ld = LayerDrawerContour(self.variable,  
    5217                                     cmap=self.parser.getOption('cmap'),  
    5318                                     cmapRange=cmapRange, 
    54                                      transparent=transparent) 
     19                                     transparent=self.transparent) 
     20         
     21        return ld 
     22 
     23 
    5524                
    5625     
    57     def getImage(self, bbox, width, height): 
    58         """ 
    59         Create an image of a sub-bbox of a given size. 
    6026 
    61         @ivar bbox: A bbox 4-tuple. 
    62         @ivar width: width in pixels.`   
    63         @ivar height: height in pixels. 
    64         @return: A PIL Image object. 
    65  
    66         """ 
    67  
    68         log.debug('getImage(%s, %s, %s) ' % (bbox, width, height)) 
    69          
    70         xLimits = (bbox[0], bbox[2]) 
    71         yLimits = (bbox[1], bbox[3]) 
    72                          
    73         st = time.time() 
    74         im = self.ld.makeImage(xLimits, yLimits, width, height) 
    75          
    76         log.debug("generated contour image id=%s (%sx%s, lon=%s, lat=%s in %.2fs" % \ 
    77                   (self.variable.id, width, height, xLimits, yLimits,  time.time() - st,)) 
    78          
    79         return im 
    80  
Note: See TracChangeset for help on using the changeset viewer.