Changeset 5494


Ignore:
Timestamp:
17/07/09 13:10:24 (10 years ago)
Author:
pnorton
Message:

Moved many of the changes to the 'cows_qesdi' branch of cows so that it is easier to merge them back. Also changed the way that the syles are set, the .styles property is now set when the layer object is created rather than in the controller.

Location:
qesdi/wms_ddc_vis/trunk
Files:
1 added
3 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • qesdi/wms_ddc_vis/trunk

    • Property svn:ignore set to
      .project
      .pydevproject
  • qesdi/wms_ddc_vis/trunk/buildout/buildout.cfg

    r5404 r5494  
    88  ../../image_utils_trunk 
    99  ../../geoplot_trunk 
     10  ../../../cows_qesdi 
    1011 
    1112[wms_ddc_vis] 
     
    2526  csml 
    2627  cows 
     28  nose 
     29  mock 
    2730  setuptools 
    2831  wms_ddc_vis 
  • qesdi/wms_ddc_vis/trunk/development.ini

    r5403 r5494  
    3131# Point to the service-level OWS configuration file 
    3232cows.capabilities_config = %(here)s/capabilities.cfg 
    33 cows.csml.tmpdir = %(here)s/tmp 
    34 cows.csml.csmlstore = %(here)s/csml 
     33cows.csml.tmpdir = /data/pnorton/wms_tmp 
     34cows.csml.csmlstore = /data/pnorton/csml 
    3535cows.csml.colourmap = jet 
    3636cows.csml.publish_dir = %(here)s/publish 
    3737cows.csml.wfsconfig = %(here)s/wfs.cfg 
     38cows.csml.legendfont = /usr/share/fonts/truetype/luxisr.ttf 
    3839 
     40#switches the demo to the wmsviz page 
     41cows.cowsclienturl = http://localhost:5005/wmsviz? 
    3942############################################################################## 
    4043 
     
    4649# for the Cache data, or the Session saves, un-comment the desired settings 
    4750# here: 
    48 #beaker.cache.data_dir = %(here)s/data/cache 
    49 #beaker.session.data_dir = %(here)s/data/sessions 
     51beaker.cache.data_dir = /data/pnorton/beaker_cache 
     52beaker.session.data_dir = /data/pnorton/beaker_sessions 
    5053 
    5154# WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT* 
     
    6568 
    6669[logger_root] 
    67 level = INFO 
     70level = DEBUG 
    6871handlers = console 
    6972 
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/config/routing.py

    r5479 r5494  
    2121 
    2222    map.connect(':fileoruri/wms', controller='csmlwms') 
     23    map.connect(':fileoruri/wms2', controller='csmlwms2') 
    2324    map.connect('wcsroute', ':fileoruri/wcs', controller='csmlwcs') #wcsroute is a named route. 
    2425    map.connect(':fileoruri/wfs', controller='csmlwfs') 
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/controllers/csmlwms.py

    r5483 r5494  
    11import logging 
    2 import Image 
    3 import re 
    4 from StringIO import StringIO 
    5 from pylons import request, response, c 
    6  
    7 from cows import bbox_util 
    8  
    9 from wms_ddc_vis.model.ddc_layer_mapper import DDCLayerMapper 
    10 from wms_ddc_vis.model.ddc_wms_layer import STYLES, RENDERING_OPTIONS 
    112 
    123from cows.pylons.wms_controller import WMSController 
    13 from cows.pylons import ows_controller 
    14  
    15 from cows.model.wms import Style, LegendURL, FormattedURL 
    16 from cows.xml.iso19115_subset import OnlineResource 
    17  
    18 from genshi.template import TemplateLoader, NewTextTemplate 
    19 from pkg_resources import resource_filename 
    20 from routes import url_for 
     4from wms_ddc_vis.model.ddc_layer_mapper import DDCLayerMapper 
    215 
    226log = logging.getLogger(__name__) 
     
    259    layerMapper = DDCLayerMapper() 
    2610 
    27     loader = TemplateLoader( resource_filename('wms_ddc_vis', 'templates'), 
    28                              auto_reload=True, 
    29                            ) 
    30  
    31     JSON_CAPABILITIES_TEMPLATE = "wms_capabilities_json.txt" 
    32     XML_CAPABILITIES_V1_1_1 = "wms_capabilities_1_1_1.xml" 
    33     XML_CAPABILITIES_V1_1_3 = "wms_capabilities_1_3_0.xml" 
    3411     
    3512 
    36     def _renderCapabilities(self, version, format): 
    37          
    38         for ds in c.capabilities.contents.datasetSummaries: 
    39              
    40             onlineRes = OnlineResource(url_for(qualified=True, action='index') + "?request=GetLegend&layers=%s" % ds.identifier) 
    41              
    42             legendURL = LegendURL(630, 80, format='img/png', onlineResource=onlineRes ) 
    43              
    44             gridStyle = Style('grid', 'Grid Boxes', legendURLs=[legendURL] ) 
    45             contourStyle = Style('contour', 'Contour Lines', legendURLs=[legendURL] ) 
    46              
    47             ds.styles = [gridStyle, contourStyle] 
    48              
    49             log.debug("dir(ds) = %s" % (dir(ds),)) 
    50             log.debug("ds.identifier = %s" % (ds.identifier,)) 
    51             log.debug("ds.styles = %s" % (ds.styles,)) 
    52             log.debug("ds.metadata = %s" % (ds.metadata,)) 
    53          
    54         if format == 'application/json': 
    55              
    56             t = self.loader.load(self.JSON_CAPABILITIES_TEMPLATE, 
    57                                                    cls=NewTextTemplate) 
    58         elif version == '1.1.1': 
    59             t = self.loader.load(self.XML_CAPABILITIES_V1_1_1) 
    60         elif version == '1.3.0': 
    61             t = self.loader.load(self.XML_CAPABILITIES_V1_1_3) 
    62         else: 
    63             # We should never get here!  The framework should raise an exception before now. 
    64             raise RuntimeError("Version %s not supported" % version) 
    65          
    66         return t.generate(c=c).render() 
    67  
    68     def _getLayerParam(self, paramName='layers'): 
    69         """ 
    70         Retrieve the layers parameter enforcing the rule of only 
    71         selecting one layer. 
    72  
    73         @param paramName: Overrides the query string parameter name to 
    74             look for.  This is usefull for implementing GetFeatureInfo. 
    75  
    76         """ 
    77         layers = {} 
    78         layerNames = self.getOwsParam(paramName) 
    79          
    80         # Select the first layer if several are requested. 
    81         # This plays nicer with mapClient. 
    82         layerNames = layerNames.split(',') 
    83          
    84         layerObjects = [] 
    85          
    86         for layerName in layerNames: 
    87             try: 
    88                 layerObj = self.layers[layerName] 
    89                 layerObjects.append(layerObj) 
    90 #                layers[layerName] = layerObj 
    91             except KeyError: 
    92                 raise InvalidParameterValue('Layer %s not found' % layerName, 
    93                                         paramName) 
    94  
    95         return layerNames, layerObjects 
    96         #return layers 
    9713 
    9814 
    99          
    100     def _retrieveSlab(self, layerObj, srs, dimValues, style, transparent, renderOpts): 
    101          
    102         # Find the slab in the cache first 
    103         cacheKey = layerObj.getCacheKey(srs, style, transparent, dimValues, renderOpts) 
    104         slab = self._layerSlabCache.get(cacheKey) 
    105          
    106         if slab is None: 
    107              
    108             slab = layerObj.getSlab(srs, style, transparent, dimValues, renderOpts) 
    109              
    110             if cacheKey is not None: 
    111                 self._layerSlabCache[cacheKey] = slab 
    11215 
    113         return slab 
    114  
    115     #------------------------------------------------------------------------- 
    116     # OWS Operation methods 
    117      
    118     def GetMap(self): 
    119  
    120         # Housekeeping 
    121         version = self.getOwsParam('version', default=self.validVersions[0]) 
    122          
    123         if version not in self.validVersions: 
    124             raise InvalidParameterValue('Version %s not supported' % version, 
    125                                         'version') 
    126          
    127          
    128         renderingOptions = {} 
    129         for opt in RENDERING_OPTIONS: 
    130             if self.getOwsParam(opt, default=None) != None: 
    131                 renderingOptions[opt] = self.getOwsParam(opt) 
    132          
    133         log.debug("renderingOptions = %s" % (renderingOptions,)) 
    134          
    135  
    136          
    137         transparent = self.getOwsParam('transparent', default='FALSE') 
    138          
    139         transparent = transparent.lower() == 'true' 
    140          
    141         bgcolor = self.getOwsParam('bgcolor', default='0xFFFFFF') 
    142  
    143         # Layer handling 
    144         layerNames, layerObjects = self._getLayerParam() 
    145 #        layers = self._getLayerParam() 
    146          
    147         log.debug("layerNames = %s" % (layerNames,)) 
    148         log.debug("layerObjects = %s" % (layerObjects,)) 
    149          
    150         styles = self.getOwsParam('styles', default='') 
    151          
    152         if styles != None: 
    153             styles = styles.split(',') 
    154             assert len(styles) == len(layerNames) 
    155          
    156         log.debug("style = %s" % (styles,))         
    157          
    158         # Coordinate parameters 
    159         bbox = tuple(float(x) for x in self.getOwsParam('bbox').split(',')) 
    160         width = int(self.getOwsParam('width')) 
    161         height = int(self.getOwsParam('height')) 
    162  
    163         if version == '1.1.1': 
    164             srs = self.getOwsParam('srs') 
    165         else: 
    166             srs = self.getOwsParam('crs') 
    167  
    168         #if srs not in layerObj.crss: 
    169          #   raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs)) 
    170  
    171         # Get format 
    172         format = self.getOwsParam('format') 
    173         if format not in self._pilImageFormats: 
    174             raise InvalidParameterValue( 
    175                 'Format %s not supported' % format, 'format') 
    176  
    177  
    178         finalImg = Image.new('RGBA', (width, height), (0,0,0,0)) 
    179  
    180         # Multiple Layers handling..   
    181 #        for layerName, layerObj in layers.iteritems(): 
    182         for i in range(len(layerNames)): 
    183              
    184             layerName = layerNames[i] 
    185             layerObj = layerObjects[i] 
    186             if styles != None: 
    187                 style = styles[i] 
    188             else: 
    189                 style = "" 
    190                  
    191             if style == "": 
    192                 style = STYLES.DEFAULT 
    193                  
    194              
    195             if srs not in layerObj.crss: 
    196                 raise InvalidParameterValue('Layer %s does not support SRS %s' % (layerName, srs)) 
    197  
    198             dimValues = self._getDimValues(layerObj) 
    199              
    200             #now need to revert modified dim values (e.g. height_dim) back to dim values the layerMapper understands (e.g. height) 
    201             restoredDimValues={} 
    202             for dim in dimValues: 
    203                 restoredDim=self._mapParamToDim(dim) 
    204                 restoredDimValues[restoredDim]=dimValues[dim] 
    205                  
    206             #------------------------------------------------------- 
    207             # The real work 
    208             #!TODO: Minimum and maximum values 
    209  
    210             slab = self._retrieveSlab(layerObj, srs, restoredDimValues, style, 
    211                                       transparent, renderingOptions) 
    212  
    213             # We must request a bbox within the layer's bbox. 
    214             lbbox = layerObj.getBBox(srs) 
    215             ibbox = bbox_util.intersection(bbox, lbbox) 
    216  
    217             log.debug('bbox = %s' % (bbox,)) 
    218             log.debug('lbbox = %s' % (lbbox,)) 
    219             log.debug('ibbox = %s' % (ibbox,)) 
    220  
    221             log.debug("width, height = %s, %s" % (width, height,)) 
    222             img = slab.getImage(bbox, width, height) 
    223              
    224             log.debug("img = %s format=%s, size=%s, mode=%s" % (img, img.format, img.size, img.mode)) 
    225             log.debug("finalImg = %s format=%s, size=%s, mode=%s" % (finalImg, finalImg.format, finalImg.size, finalImg.mode)) 
    226  
    227             finalImg = Image.composite(finalImg, img, finalImg)     
    228  
    229              
    230         # IE < 7 doesn't display the alpha layer right.  Here we sniff the 
    231         # user agent and remove the alpha layer if necessary. 
    232         try: 
    233             ua = request.headers['User-Agent'] 
    234         except: 
    235             pass 
    236         else: 
    237             if 'MSIE' in ua and 'MSIE 7' not in ua: 
    238                 finalImg = finalImg.convert('RGB') 
    239  
    240         buf = StringIO() 
    241         finalImg.save(buf, self._pilImageFormats[format]) 
    242  
    243         response.headers['Content-Type'] = format 
    244         response.write(buf.getvalue()) 
    245  
    246     def GetLegend(self): 
    247         """ 
    248         Return an image of the legend. 
    249  
    250         """ 
    251         # Parameters 
    252         layerName, layerObj = self._getLayerParamInfo() 
    253         format = self._getFormatParam() 
    254  
    255         # This hook alows extra arguments to be passed to the layer backend.  It 
    256         # is required for UKCP. 
    257 #        renderOpts = dict(request_params=self._owsParams) 
    258       
    259         renderingOptions = {} 
    260         for opt in RENDERING_OPTIONS: 
    261             if self.getOwsParam(opt, default=None) != None: 
    262                 renderingOptions[opt] = self.getOwsParam(opt) 
    263          
    264 #        log.debug("renderingOptions = %s" % (renderingOptions,)) 
    265  
    266         img = layerObj.getLegendImage(renderOpts=renderingOptions) 
    267  
    268         buf = StringIO() 
    269         img.save(buf, self._pilImageFormats[format]) 
    270  
    271         response.headers['Content-Type'] = format 
    272         response.write(buf.getvalue()) 
    273  
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_layer_mapper.py

    r5403 r5494  
    105105             
    106106            title, abstract, dimensions, units, crss=self._getInfo(feature)             
    107             layermap[feature.id] = DDCWmsLayer(title,abstract, dimensions, units, crss, feature) 
     107            layermap[feature.id] = DDCWmsLayer(title,abstract, dimensions, units, crss, feature, 
     108                                               name=feature.id) 
    108109             
    109110        if len(layermap) > 0: 
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_wms_layer.py

    r5479 r5494  
    1616log = logging.getLogger(__name__) 
    1717 
    18 from cows.service.imps.csmlbackend.wms_csmllayer import CSMLwmsLayerSlab 
    1918from wms_ddc_vis.model.ddc_wms_layer_slab import DDCWmsLayerSlab 
    2019from wms_ddc_vis.model.ddc_wms_layer_slab_contour import DDCWmsLayerSlabContour 
     
    2928import ImageDraw 
    3029 
     30from cows.model.wms import Style, LegendURL, FormattedURL 
     31from cows.xml.iso19115_subset import OnlineResource 
     32 
     33from routes import url_for 
    3134 
    3235class STYLES: 
     
    3538    DEFAULT = GRID 
    3639 
    37 RENDERING_OPTIONS = ['cmap', 'cmap_min', 'cmap_max', 'num_levels', 'show_grid'] 
    38  
    3940class DDCWmsLayer(IwmsLayer): 
    4041     
    4142     
    42     def __init__(self, title, abstract, dimensions, units, crss, feature): 
     43    def __init__(self, title, abstract, dimensions, units, crss, feature, 
     44                 name=None): 
    4345        self.featureInfoFormats=None #NotImplemented 
    4446        self.title=title 
     
    5052        self.legendSize=(630,80) 
    5153        self._minval=0 
    52         self._maxval=10.0 #dummy values  
     54        self._maxval=10.0 #dummy values 
     55        self.name = name 
     56         
     57        self.styles = self._buildStyles() 
     58          
    5359        try:  
    5460            bb = self._feature.getCSMLBoundingBox().getBox() 
     
    7177             
    7278        self.featureinfofilecache={} #used for caching netcdf file in getFeatureInfo 
    73          
     79     
    7480    def getBBox(self, crs): 
    7581        """ 
     
    8591        #raise NotImplementedError 
    8692         
    87     def getSlab(self, crs, style, transparent, dimValues=None, renderOpts={}): 
     93    def getSlab(self, crs, style, dimValues, transparent, bgcolor,  
     94                    additionalParams={}): 
    8895        """ 
    8996        Creates a slab of the layer in a particular CRS and set of 
     
    98105        #create netcdf for whole lat/lon for given dimValues, use to init slab 
    99106        """ 
    100  
    101         log.debug('getSlab(%s, %s) renderOpts = %s' % (crs, dimValues, renderOpts)) 
    102          
     107        
    103108        #unicode conversion 
    104109        for dimval in dimValues: 
     
    111116         
    112117         
    113               
     118        netcdf = self._getNetcdfVar(dimValues) 
     119 
     120        bbox=self.getBBox(crs) 
     121         
     122        slabClass = self._getSlabClass(style) 
     123         
     124        slab = slabClass(netcdf, self.title, crs, dimValues, transparent, bbox, additionalParams) 
     125         
     126        self._minval=slab.minval #needed for legend rendering. 
     127        self._maxval=slab.maxval 
     128         
     129        return slab         
     130   
     131    def _getNetcdfVar(self, dimValues): 
     132        "Opens up the csml and retrieves the variable described by the dimensions" 
     133         
    114134        if type(self._feature) == csml.parser.GridSeriesFeature: 
    115135             
    116136            randomname= csml.csmllibs.csmlextra.getRandomID() + '.nc' 
    117              
    118             log.debug("self._feature = %s" % (self._feature,)) 
    119              
    120             log.debug("dir(self._feature) = %s" % (dir(self._feature),)) 
    121              
    122             log.debug("self._feature.id = %s" % (self._feature.id,)) 
    123             log.debug("self._feature.name = %s" % (self._feature.name,)) 
    124             log.debug("self._feature.getTimeAxis() = %s" % (self._feature.getTimeAxis(),)) 
    125             
    126             log.debug("config['tmpdir'] = %s" % (config['tmpdir'],)) 
    127             log.debug("randomname = %s" % (randomname,)) 
    128             log.debug("dimValues = %s" % (dimValues,)) 
    129137             
    130138            result= self._feature.subsetToGridSeries(config['tmpdir'],  
     
    138146            os.system('rm %s'%result[1]) 
    139147             
    140             bbox=self.getBBox(crs) 
    141              
    142             if style == STYLES.CONTOUR: 
    143                 slabClass = DDCWmsLayerSlabContour 
    144             elif style == STYLES.GRID: 
    145                 slabClass = DDCWmsLayerSlab 
    146             else: 
    147                 raise Exception("Unknown style %s" % (style,)) 
    148              
    149             slab = slabClass(netcdf, self, crs, dimValues, transparent, renderOpts, bbox) 
    150              
    151             self._minval=slab.minval #needed for legend rendering. 
    152             self._maxval=slab.maxval 
    153              
    154             return slab 
    155148        else: 
    156149            raise NotImplementedError 
    157150         
    158     def getCacheKey(self, crs, style, transparent, dimValues=None, renderOpts={}): 
     151        return netcdf 
     152     
     153    def _getSlabClass(self, style): 
     154        "Gets the slab class for a style value" 
     155         
     156        if style == None or style == "": 
     157            style = STYLES.DEFAULT 
     158             
     159        if style == STYLES.CONTOUR: 
     160            slabClass = DDCWmsLayerSlabContour 
     161        elif style == STYLES.GRID: 
     162            slabClass = DDCWmsLayerSlab 
     163        else: 
     164            raise Exception("Unknown style %s" % (style,)) 
     165         
     166        return slabClass 
     167                         
     168         
     169    def getCacheKey(self, crs, style, dimValues, transparent, bgcolor,  
     170                    additionalParams={}):  
    159171        """ 
    160172        Create a unique key for use in caching a slab. 
     
    167179 
    168180        """ 
     181 
    169182        dimList = list(dimValues.items()) 
    170183        dimList.sort() 
    171         return '%s:%s:%s:%s:%s:%s' % (self._feature.id, crs, style, transparent, dimList, renderOpts) 
     184 
     185        #set the default style if none provided 
     186        if style == None or style == "": 
     187            s = STYLES.DEFAULT 
     188        else: 
     189            s = style 
     190             
     191        return '%s:%s:%s:%s:%s:%s:%s' % (self._feature.id, crs, s, dimList, 
     192                                      transparent, bgcolor, additionalParams) 
    172193 
    173194    def getFeatureInfo(self, format, crs, point, dimValues): 
     
    235256        return value 
    236257 
    237     def getLegendImage(self, orientation='horizontal', renderOpts={}): 
     258    def getLegendImage(self, width=None, height=None, orientation='horizontal', renderOpts={}): 
    238259        """ 
    239260        Create an image of the colourbar for this layer. 
     
    242263 
    243264        """ 
    244         width = self.legendSize[0] 
    245         height = self.legendSize[1] 
    246          
    247         # if width and height specified in the GetLegend request parameters 
    248         # then use them instead of the default values 
    249         if 'width' in renderOpts: 
    250                 width = renderOpts['width'] 
    251         if 'height' in renderOpts: 
    252                 height = renderOpts['height'] 
    253                  
    254 #        cmap = cm.get_cmap(config['colourmap']) 
     265        if width == None: 
     266            width = self.legendSize[0] 
     267             
     268        if height == None: 
     269            height = self.legendSize[1] 
     270         
    255271        parser = DDCRenderOptionsParser(renderOpts,None) 
    256         cmap = parser.getOption('cmap') 
    257272 
    258273        im = geoplot.colour_bar.getColourBarImage(width, height,  
    259                                              label='Units of measure: %s'%str(self.units),  
    260                                              cmap=cmap,  
     274                                             label='Units of measure: %s' % str(self.units),  
     275                                             cmap=parser.getOption('cmap'),  
    261276                                             cmapRange=(self._minval, self._maxval),  
    262277                                             orientation=orientation) 
    263278         
    264279        return im 
    265          
    266 #        renderer=RGBARenderer(self._minval, self._maxval) 
    267 #         
    268 #        if orientation =='vertical': 
    269 #            legendImage= renderer.renderColourbar(630, 30, cmap, isVertical=True) 
    270 #        else: 
    271 #            legendImage= renderer.renderColourbar(630, 30, cmap, isVertical=False) 
    272 #                
    273 #        imageWithLabels=Image.new('RGBA', (630, 80), "white") 
    274 #        imageWithLabels.paste(legendImage, (0,0)) 
    275 #         
    276 #        #add minvalue label 
    277 #        minvalueImg=self._simpletxt2image(str(self._minval), (49,25)) 
    278 #        imageWithLabels.paste(minvalueImg,(0,40)) 
    279 #         
    280 #        #add midvalue  label 
    281 #        midvalue=self._minval+(self._maxval-self._minval)/2 
    282 #         
    283 #        #add maxvalue label 
    284 #        midvalueImg=self._simpletxt2image(str(midvalue),(49,25)) 
    285 #        imageWithLabels.paste(midvalueImg,(280,40)) 
    286 #         
    287 #        #add maxvalue label 
    288 #        maxvalueImg=self._simpletxt2image(str(self._maxval), (49,25)) 
    289 #        imageWithLabels.paste(maxvalueImg,(575,40)) 
    290 #         
    291 #        #add units: 
    292 #        unitsImg=self._simpletxt2image('Units of measure: %s'%str(self.units), (200,25)) 
    293 #        imageWithLabels.paste(unitsImg,(240,60)) 
    294 #              
    295 ##        return imageWithLabels                          
    296 #        return imageWithLabels.resize((width, height))  
    297      
    298     def _simpletxt2image(self, text, size): 
    299         image = Image.new('RGBA',size,"white") 
    300         fontfullpath = config['legendfont'] 
    301         ifo = ImageFont.truetype(fontfullpath,16) 
    302         draw = ImageDraw.Draw(image) 
    303         draw.text((0, 0), text, font=ifo,fill=(100, 123, 165)) 
    304         return image 
     280     
     281    def _buildStyles(self): 
     282        onlineRes = OnlineResource(url_for(qualified=True, action='index') + "?request=GetLegend&layers=%s" % self.name) 
     283         
     284        legendURL = LegendURL(630, 80, format='img/png', onlineResource=onlineRes ) 
     285         
     286        gridStyle = Style(STYLES.GRID, 'Grid Boxes', legendURLs=[legendURL] ) 
     287        contourStyle = Style(STYLES.CONTOUR, 'Contour Lines', legendURLs=[legendURL] ) 
     288         
     289        return [gridStyle, contourStyle]         
  • qesdi/wms_ddc_vis/trunk/lib/wms_ddc_vis/model/ddc_wms_layer_slab.py

    r5479 r5494  
    2020    They should be pickleable to enable memcached support in the future. 
    2121 
    22     @ivar layer: The source ILayer instance. 
    2322    @ivar crs: The coordinate reference system. 
    2423    @ivar dimValues: A mapping of dimension values of this view. 
     
    2726    """ 
    2827 
    29     def __init__(self, netcdf, layer, crs, dimValues, transparent, renderOpts, bbox): 
     28    def __init__(self, netcdf, title, crs, dimValues, transparent, bbox, renderOpts): 
    3029         
    31         log.debug("Creating slab: netcdf = %s, layer = %s, crs = %s, dimValues = %s, renderOpts = %s, bbox = %s" % (netcdf, layer, crs, dimValues, renderOpts, bbox)) 
    32  
    3330        self._netcdf=netcdf 
    34         self.layer = layer 
     31        self.title = title 
    3532        self.crs = crs 
    3633        self.dimValues = dimValues 
     
    3835        self.bbox=bbox 
    3936         
    40         self.variable =  self._netcdf(self.layer.title, squeeze=1)  
     37        self.variable =  self._netcdf(self.title, squeeze=1)  
    4138         
    4239        self.minval = self.variable.min() 
Note: See TracChangeset for help on using the changeset viewer.