source: TI02-CSML/trunk/csml/csmllibs/csmldataiface.py @ 3043

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI02-CSML/trunk/csml/csmllibs/csmldataiface.py@3043
Revision 3043, 25.6 KB checked in by domlowe, 12 years ago (diff)

more sensible error returned when file permissions or paths not set.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2
3#**************************************************************************************
4#csmldataIface.py
5#contains classes for interfacing with various files
6#currently supports cdunif (NetCDF, PP, Grib(untested)) And Nappy (NASAAmes)
7#use by instantiating the factory class: DataInterface
8#v0.00 30th November 2005
9#Dominic Lowe, BADC
10#**************************************************************************************
11
12import pdb
13import cdms 
14import Numeric
15
16try:
17    import nappy 
18except ImportError:
19    pass
20    #print 'could not import NASAAmes interface'
21import string
22import sys
23import csml.csmllibs.csmltime
24# This is required to prevent Numeric arrays being truncated when printed.
25import MA
26MA.set_print_limit(0)
27
28# Generic mathematical expression solver, required by the raw and image
29# interfaces
30import NumericTransform
31
32try:
33    # Part of the PIL. Required for ImageFileInterface:
34    import Image
35except ImportError:
36    print 'could not import Image'
37    pass
38
39try:
40    # Required for RawFileInterface:
41    import struct
42except ImportError:
43    print 'could not import struct'
44    pass
45
46
47class DataInterface(object):
48        #Use DataInterface and setInterfaceType to instantiate the correct
49        #subclass for data
50        def __init__(self):
51                self.iface ='None'
52               
53        def setInterfaceType(self,interfaceType):
54                # function returns approprate data interface
55                #set interfaceType: should correspond to available datainterface subclasses
56                self.iface =interfaceType
57                if self.iface == 'nappy':
58                        return NappyInterface()
59                elif self.iface == 'cdunif':
60                        return cdunifInterface()
61                elif self.iface == 'raw':
62                        return RawFileInterface()
63                elif self.iface == 'image':
64                        return ImageFileInterface()
65               
66               
67        def getUnknownInterfaceType(self, filename):
68                #if the interface type is not known at the time of instantiation, then use
69                #this function to examine the file and return the correct interface (if it exists).
70                fileExtension = str(filename)[-3:]
71                if fileExtension == '.nc':
72                        return cdunifInterface()
73                if fileExtension == 'qxf':
74                        return cdunifInterface()
75                elif fileExtension == '.pp':
76                        return cdunifInterface()
77                elif fileExtension == 'ctl':
78                        return cdunifInterface()
79                elif fileExtension == 'xml':
80                        return cdmlInterface()
81                elif fileExtensions == 'png' or fileExtension == 'gif':
82                        return ImageFileInterface()
83                else:
84                        try:
85                                nappy.readFFI(filename) in [1001,1010,1020,2010,2110,2160,2310,3010,4010]
86                                return NappyInterface()
87                        except:
88                                print "Could not establish file type"
89                                print "See csmldataiface.py"
90                       
91       
92                                                       
93class AbstractDI(object):               
94        #Abstract data interface class
95        #does nothing, but contains templates for methods required for a data interface class
96        #individual interfaces (e.g NappyInterface) should override these methods
97
98        def __init__(self):
99                self.extractType=''
100                self.extractPrefix = ''
101                                       
102        def openFile(self, filename):
103           #opens file, must be overwritten by subclass
104            raise NotImplementedError 
105               
106        def closeFile(self):
107           #closes file, probably needs to be overwritten by subclass
108            try:
109                self.file.close()
110            except:
111                raise NotImplementedError
112         
113        def setAxis(self,axis):
114           #'set' the name of the current axis , must be overwritten by subclass
115           #this may just involve a stub (see NASAAmes interface) or may involve
116           #calling a real set method of the underlying api (see cdunif Interface)
117           raise NotImplementedError 
118                       
119        def getDataForAxis(self):
120            #return all data for axis, must be overwritten by subclass
121           raise NotImplementedError   
122       
123        def setVariable(self,varname):
124             #As for setAxis, 'set' the name of the current axis , must be overwritten by subclass
125             raise NotImplementedError
126       
127        def getDataForVar(self):
128            #return all data for variable, must be overwritten by subclass
129           raise NotImplementedError   
130       
131        def getSubsetOfDataForVar(self,**kwargs):
132            #return subset of data for variable, must be overwritten by subclass
133            raise NotImplementedError
134       
135       
136class NappyInterface(AbstractDI):       
137        # Data Interface for Nappy (NASA Ames Processing in Python)
138   
139        def __init__(self):
140                self.extractType='NASAAmesExtract'
141                self.extractPrefix = '_naextract_'
142                                         
143        def openFile(self, filename):
144                #print 'opening NA file: ' + str(filename)
145                self.file=nappy.openNAFile(filename)
146                #print 'reading data....'
147                #self.file.readData()
148                #print 'nappyopen ' + filename
149
150        def getListOfAxes(self):
151                axes=self.file.XNAME
152                #print 'before units stripped' + str(axes)
153                axes=self.stripunits(axes)
154                #print 'after units stripped' + str(axes)
155                return axes
156
157        def setAxis(self,axis):
158                axes = self.getListOfAxes()
159                self.axisstub=axes.index(axis)
160
161        def getAxisAttribute(self, att):
162                #need to do something here...? maybe
163                attValue=None
164                return attValue
165
166        def getTimeUnits(self):
167                axes = self.getListOfAxes()
168                for axis in axes:
169                        if string.find(string.upper(axis),'SECONDS SINCE') != -1:
170                                #found possible time axis.
171                                if axis[-3:]=='UTC':
172                                    units =string.lower(axis[:-4]) #hack!
173                                    units=units.replace('/','-') #try and clean it up
174                                else:
175                                    units=string.lower(axis)
176                                break
177                        elif string.find(string.upper(axis),'HOURS SINCE') != -1:
178                                #found possible time axis.
179                                units =(str(axis))
180                                break
181                        elif string.find(string.upper(axis),'DAYS SINCE') != -1:
182                                #found possible time axis.
183                                units =(str(axis))
184                                break
185                       
186                #revisit with udunits python library?
187                return units
188
189
190        def getDataForAxis(self):           
191            if self.file.X == None:
192                    #print 'reading data....'
193                    self.file.readData()
194            for x in self.file.X:
195                pass
196                #print type(x)
197           
198           
199            d=Numeric.array(self.file.X)
200           
201            if type(self.file.X[1])==list:
202            #if len(self.file.X) > 0:
203                    data = self.file.X[self.axisstub]
204            else:
205                    data =self.file.X
206            #print data
207            data=Numeric.array(data)
208            return data
209
210        def getSizeOfAxis(self,axis):
211
212                #check this function is okay
213                #is time always the first dimension in NA??
214                axes = self.getListOfAxes()
215                axisPosition=axes.index(axis)
216                #print "axis position" + str( axisPosition)
217                #print "NX" + str(self.file.NX)
218                try :
219                        axisSize=self.file.NX[axisPosition-1]
220                except:
221                        axisSize ='Unknown axis size'
222                return axisSize
223
224        def getListofVariables(self):
225                variableList=self.stripunits(self.file.VNAME)
226                return variableList
227
228        def setVariable(self,varname):
229                vlist=self.getListofVariables()
230                self.varstub=vlist.index(varname)
231
232        def getVariableAxes(self):
233                #hmm, now with Nasa Ames the Axis will be the same for all variables.
234                #so just use the getListOfAxes function again
235                #I think... check this!
236                varAxesList=self.getListOfAxes()
237                return varAxesList
238
239        def getVariableAttribute(self,attName):
240                if attName =='units':
241                        #strip the units (attribute) from the variable
242                        unitslist=self.getUnits(self.file.VNAME)
243                        attribValue = unitslist[self.varstub]
244                        try:
245                                attribValue = unitslist[self.varstub]
246                        except:
247                                attribValue = 'unknown'
248                else:
249                        attribValue = 'unknown'
250                return attribValue
251
252        def getDataForVar(self):
253            #NOTE TO SELF:
254            #Review this function (and in fact all of nasa ames data interface...)
255                if self.file.V == None:
256                        #print 'reading data....'
257                        self.file.readData()
258
259                try:
260                    if type(self.file.V[1])==list:
261                        data = self.file.V[self.varstub]
262                #else:
263                #       data =self.file.X
264                #       print data
265                    return data
266                except:
267                    data = self.file.X
268                   # print data
269                    return data
270
271        def getArraySizeOfVar(self):
272        #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
273
274                dimlist=self.file.NX
275                varsize =1
276                for item in dimlist:
277                        varsize = varsize * item
278                        #print "VARSISZE" + str(varsize)
279                return varsize
280
281        def getShapeOfVar(self):
282            #this should return a list.
283            varShape = []
284            for item in self.file.NX:
285                varShape.append(item)
286            return varShape
287
288        def getLowLimits(self):
289                lowlims = ""
290                for i in range (0, len(self.file.NX)):
291                        #for now, assume low limit is always of form 1 1 1 ..
292                        lowlims =lowlims + str(1)  +' '
293                return lowlims
294
295        def getHighLimits(self):
296                highlims = ""
297                for i in range (0, len(self.file.NX)):
298                        dimValue = self.file.NX[i]
299                        highlims =highlims  + str(dimValue) +' '
300                return highlims
301
302
303        def stripunits(self,listtostrip):
304                #strips units of measure from list
305                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
306                #becomes ['Universal time', 'Altitude', 'Latitude', 'Longitude']
307                cleanlist = []
308                for item in listtostrip:
309                        openbracket=string.find(item,'(')
310                        if openbracket != -1:
311                                #if brackets exist, strip units.
312                                item=item[:openbracket-1]
313                        cleanlist.append(item)
314                return cleanlist
315
316        def getUnits(self,listwithunits):
317                #gets units from list
318                #eg ['Universal time (hours)', 'Altitude (km)', 'Latitude (degrees)', 'Longitude (degrees)']
319                #becomes ['hours', 'km', 'degrees', 'degrees']
320                unitlist=[]
321                for item in listwithunits:
322                        openbracket=string.find(item,'(')
323                        item = item[openbracket+1:-1]
324                        unitlist.append(item)
325                return unitlist
326
327        def getTimes(self):
328                #This function attempts to determine the time axis and read the time data
329                #it may well not manage it.
330                axes = self.getListOfAxes()
331                for axis in axes:
332                        if string.find(string.upper(axis),'TIME') != -1:
333                                #found possible time axis.
334                                self.setAxis(axis)
335                                times=self.getDataForAxis()
336                                break
337                        elif string.find(string.upper(axis),'SECONDS SINCE') != -1:
338                                #found possible time axis.
339                                self.setAxis(axis)
340                                times=self.getDataForAxis()
341                                break
342                        elif string.find(string.upper(axis),'HOURS SINCE') != -1:
343                                #found possible time axis.
344                                self.setAxis(axis)
345                                times=self.getDataForAxis()
346                                break
347                        elif string.find(string.upper(axis),'DAYS SINCE') != -1:
348                                #found possible time axis.
349                                self.setAxis(axis)
350                                times=self.getDataForAxis()
351                                break
352                times=Numeric.array(times)
353                return times
354
355
356
357class cdunifInterface(AbstractDI):
358    #Data Interface for cdunif (netcdf & pp formats & grib (not tested with grib)
359
360    def __init__(self):
361        #these are just temporary values until we can determine whether the
362        #file is netcdf pp or grib
363        self.extractType='cdunifExtract'
364        self.extractPrefix = '_cdunifextract_'
365   
366    def openFile(self, filename):
367        self._filename=filename
368        self.file=cdms.open(filename)
369       
370        #now we have the file name can properly determine extractType/Prefix
371        fileExtension = str(filename)[-3:]
372        if fileExtension == '.nc':
373            self.extractType = 'NetCDFExtract'
374            self.extractPrefix = '_ncextract_'
375        elif fileExtension == '.qxf':
376            self.extractType = 'NetCDFExtract'
377            self.extractPrefix = '_ncextract_'
378        elif fileExtension == '.pp':
379            self.extractType  = 'PPExtract'
380            self.extractPrefix = '_ppextract_'
381        elif fileExtension == 'ctl':
382            self.extractType = 'GRIBExtract'
383            self.extractPrefix = '_gribextract_'
384        elif fileExtension == 'xml': 
385            self.extractType = 'NetCDFExtract'  #okay this isn't true, but ok for testing
386            self.extractPrefix = '_ncextract__' 
387    def getListOfAxes(self):
388        axes=self.file.dimensions.keys()
389        return axes
390
391    def getSizeOfAxis(self,axis):
392        axisSize=self.file.dimensions[axis]
393        return axisSize
394
395    def getListofVariables(self):
396        variableList=self.file.variables.keys()
397
398        # Hack to test if removing climatology_bounds fixes pywms bug
399        if 'climatology_bounds' in variableList:
400            variableList.remove('climatology_bounds')
401
402        return variableList
403
404    def setAxis(self,axis):
405        if not hasattr(self, 'file'):
406            raise Exception, 'Could not open/find underlying file: %s  -  If you are the system maintainer check file paths and permissions'%self._filename
407        self.axisobj=self.file.getAxis(axis)
408
409           
410
411    def getAxisAttribute(self, att):
412        attValue=self.axisobj.attributes[att]
413        return attValue
414   
415    def getTimeUnits(self):
416        #this does the same as getAxisAttribute, but is a separate function as different formats handle time differently.
417        return self.getAxisAttribute('units')
418
419    def getDataForAxis(self):
420        data = self.axisobj.getValue()
421        return data
422
423    def setVariable(self,varname):
424        self.varobj=self.file.variables[varname]
425
426    def getVariableAxes(self):
427        varAxesList=self.varobj.getAxisIds()
428        return varAxesList
429
430    def getVariableAttribute(self,attName):
431        if attName == '_FillValue':
432            try:
433                attribValue=self.varobj._FillValue
434                attribValue=attribValue.toscalar()
435            except:
436                try:
437                    attribValue=self.varobj.missing_value
438                    attribValue=attribValue.toscalar()
439                except:
440                    attribValue = None 
441        else:
442            attribValue = self.varobj.getattribute(attName)
443        return attribValue
444
445    def getDataForVar(self):
446        data = self.varobj.getValue()
447        return data
448   
449    def _fixLongitudeRequest(self, **kwargs):
450        lonkey='longitude'
451        if lonkey in kwargs.keys():   #this test needs to be much more robust...!
452            if  type(kwargs[lonkey]) is tuple:
453                newkws=[]
454                for val in kwargs[lonkey]:
455                    newval=((val + 180) % 360) - 180
456                    newkws.append(newval)
457               
458                 #lon = ((t_lon + 180) % 360) - 180
459                #lonmin=kwargs[lonkey][0] - (kwargs[lonkey][0]/180)*360.0
460                #lonmax=kwargs[lonkey][1] - (kwargs[lonkey][1]/180)*360.0
461               
462                #if newkws[0] > newkws[1]:
463                    #flip=[newkws[1], newkws[0]]
464                    #newkws=flip
465                kwargs[lonkey]=tuple(newkws)
466        return kwargs
467
468    def getSubsetOfDataForVar(self, **kwargs):     
469           
470               
471        #put any slicing indices aside for later and use names   
472        try:
473            upper=kwargs['upper']
474            del kwargs['upper']
475        except:
476            pass
477        try:
478            lower=kwargs['lower']
479            del kwargs['lower']
480        except:
481            pass
482        #kwargs=self._fixLongitudeRequest(**kwargs)
483        #return self.file(self.varobj.id,**kwargs)
484        try:
485            #takes keyword args defining subset eg
486            #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0))
487            subset=None
488            lonkey='longitude'
489            if lonkey in kwargs.keys():   #this test needs to be much more robust...!
490                if  type(kwargs[lonkey]) is tuple:
491                    if kwargs[lonkey][0] > kwargs[lonkey][1]:
492                        #subsetting greenwich meridian around 0
493                        lonMin = kwargs[lonkey][0]
494                        lonMax =kwargs[lonkey][1]
495                        kwargs[lonkey]=(0.1, lonMax)
496                        subset1=self.file(self.varobj.id,**kwargs)
497                        kwargs[lonkey]=(lonMin,360)
498                        try:
499                            subset2=self.file(self.varobj.id,**kwargs)
500                            longitudeAxis=subset1.getAxisIndex(lonkey)
501                            #concatenate arrays along longitude             
502                            subset = cdms.MV.concatenate([subset2,subset1],axis=longitudeAxis)
503                        except:
504                            subset=subset1
505            if type(subset) is not cdms.tvariable.TransientVariable:
506                subset=self.file(self.varobj.id,**kwargs)
507        except:             
508                return None
509                #try and slice with indices instead
510        return subset
511   
512   
513    def getArraySizeOfVar(self):
514    #iterates through all dimensions in variable to get array size i.e a 3x3x3 array would have a size of 27
515        var = self.varobj
516        size = var.shape
517        varsize = 1
518        for item in size:
519            varsize = item *varsize
520        return varsize
521
522    def getShapeOfVar(self):
523        varShape = []
524        for item in self.varobj.shape:
525            varShape.append(item)
526        return varShape
527
528    def getLowLimits(self):
529        dimNames = self.varobj.getAxisIds()
530        lowlims = ""
531        for i in range (1, len(dimNames)):
532            #for now, assume low limit is always of form 1 1 1 ..
533            lowlims =lowlims + str(1)  +' '
534        return lowlims
535
536    def getHighLimits(self):
537        dimNames = self.varobj.getAxisIds()
538        highlims = ""
539        for i in range (1, len(dimNames)):
540            dimValue = self.file.dimensions[dimNames[i]]
541            highlims =highlims  + str(dimValue) +' '
542        return highlims
543       
544   
545class cdmlInterface(cdunifInterface):
546    #this is more  or less the cdunif interface but a few methods have been overwritten
547    def __init__(self):
548        #this all needs to be revisited in csml v2.
549        self.extractType='cdmlExtract'
550        self.extractPrefix = '_cdmlextract_'
551       
552    def getListOfAxes(self):
553        axes=self.file.axes.keys() 
554        return axes
555
556    def getSizeOfAxis(self,axis):
557        axisSize=self.file.axes[axis].length
558        return axisSize
559
560
561class RawFileInterface(AbstractDI):
562
563   def __init__(self):
564      self.extractType   = 'rawExtract'
565      self.extractPrefix = '_rawextract_'
566 
567 
568   def openFile(self, filename):
569      self.file = open(filename, "rb")
570
571
572   def closeFile(self):
573      self.file.close()
574
575
576   # Read the data from the raw file into a multidimensional Numeric array
577   def readFile(self, **kwargs):
578        # Determine the numeric type:
579        if 'numericType' in kwargs:
580            try:
581                numericTypeCode = {
582                    'uint8':Numeric.UInt8,
583                    'uint16':Numeric.UInt16,
584                    'uint32':Numeric.UInt32,
585                    'int8':Numeric.Int8,
586                    'int16':Numeric.Int16,
587                    'int32':Numeric.Int32,
588                    'float':Numeric.Float32,
589                    'double':Numeric.Float64
590                }[kwargs['numericType']]
591            except KeyError:
592                raise TypeError("Invalid numericType: " + str(kwargs['numericType']))
593        else:
594            raise KeyError("numericType is mandatory.")
595       
596        # Read the file into a numpy array:
597        self.data = Numeric.fromstring(self.file.read(), numericTypeCode)
598        # If necessary, swap the byte order:
599        if 'endianess' in kwargs:
600            if ((kwargs['endianness'] == 'little' and not Numeric.LittleEndian) or (kwargs['endianness'] == 'big' and Numeric.LittleEndian)):
601                self.data = self.data.byteswapped()   
602        # Declare the shape of the array:
603        dimensions = map(int,kwargs['dimensions'])
604        dimensions.reverse()
605        self.data.shape = tuple(dimensions)
606        # If numericTransform or fillValue were provided, store them as
607        # attributes.
608        if 'numericTransform' in kwargs:
609            self.numericTransform = NumericTransform.infixExpression(kwargs['numericTransform'])
610        if 'fillValue' in kwargs:
611            self.fillValue = kwargs['fillValue']
612   
613   # Return the fill value, if set, and transform if necessary:
614   def getFillValue(self):
615      # Both fillValue and numericTransform attributes may or may
616      # not exist...
617      try:
618         return self.numericTransform.solve( n = float(self.fillValue) )
619      except AttributeError:
620         try:
621            return self.fillValue
622         except AttributeError:
623            return None
624
625
626   # This is a just a special case of getSubsetOfDataForVar. To avoid
627   # duplication of code, just subset the entire array. (getSubset.. is
628   # optimised for this case)
629   def getDataForVar(self):
630      return self.getSubsetOfDataForVar(lower = (0,)*len(self.data.shape),
631                                        upper = self.data.shape)
632
633
634   # Subset the n-dimensional file based on array indices. Accepts parameters
635   # in the form of e.g.
636   #
637   # getSubsetOfDataForVar( lower=(0,0), upper=(1,2) )
638   #
639   # Note: The rank of the required subset, must exactly match the
640   # rank of the original data: len(lower) == len(upper) == rank of file
641   #
642   def getSubsetOfDataForVar(self, **kwargs):
643      # Assume subset parameters are passed as: lower=(0,0) upper=(512,512)
644      if 'lower' not in kwargs or 'upper' not in kwargs:
645         # Have not specified any subset parameters that we recognise, so raise
646         # an exception:
647         raise NotImplementedError("Only supports subsetting with lower+upper array indices")
648      elif not len(kwargs['lower']) == len(kwargs['upper']) == len(self.data.shape):
649         # Rank of subset is not the same as rank of full data array. so raise
650         # an exception:
651         raise NotImplementedError("Only supports subsets of same rank as full dataset")
652      elif Numeric.sometrue(Numeric.greater(kwargs['upper'], self.data.shape)):
653         # Requested upper bound of subset is beyond the size of the the full
654         # data array, so raise an exception
655         raise IndexError("Subset out of range")
656      elif Numeric.sometrue(Numeric.less( kwargs['upper'], Numeric.zeros(len(self.data.shape)))):
657         # Requested lower bound of subset is beyond the size of the the full
658         # data array, so raise an exception
659         raise IndexError("Subset out of range")
660      elif Numeric.sometrue(Numeric.less_equal(kwargs['upper'], kwargs['lower'])):
661         # lower bound <= upper_bound for at least one dimension, so raise an
662         # exception
663         raise IndexError("Upper bound less than lower bound")
664      elif tuple(kwargs['lower']) == (0,)*len(self.data.shape) and tuple(kwargs['upper']) == self.data.shape:
665         # Special case of requested subset == entire data file.
666         subset = self.data
667      else:
668         # We are okay to subset.
669
670         # I cant see any nice (and speedy) way of subsetting a Numeric
671         # array of arbitrary rank without the use of eval. By doing it
672         # this way, we can make use of the (possible) acceleration provided
673         # by Numeric/NumPy.
674         slices = []
675         for i in range(len(self.data.shape)):
676            lower = int(kwargs['lower'][i])
677            upper = int(kwargs['upper'][i]) 
678            slices.append(str(lower)+':'+str(upper))
679         subset = eval("self.data["+','.join(slices)+"]")
680
681      # Attempt to perform the numericTransform on the data array, if we get
682      # AttributeError, it most likely means that numericTransform was not
683      # specified, so return the data as-is
684      try:
685         return self.numericTransform.solve( n = subset )
686      except AttributeError:
687         return subset.copy()
688
689
690# Interface for reading data from image files. Requires PIL Image module.
691class ImageFileInterface(RawFileInterface):
692   def __init__(self):
693      self.extractType   = 'imageExtract'
694      self.extractPrefix = '_imageextract_'
695   
696   def image2array(self,im):
697       #Adapted from code by Fredrik Lundh, http://www.pythonware.com
698       #http://effbot.org/zone/pil-numpy.htm
699        if im.mode not in ("L", "F"):
700            raise ValueError, "can only convert single-layer images"
701        if im.mode == "L":
702            a = Numeric.fromstring(im.tostring(), Numeric.UnsignedInt8)
703        else:
704            a = Numeric.fromstring(im.tostring(), Numeric.Float32)
705        a.shape = im.size[1], im.size[0]
706        return a
707
708   def openFile(self, filename):
709      self.file = Image.open(filename)
710
711   def closeFile(self):
712      self.file = None #...Image does not seem to have a close() method.
713
714   def readFile(self, **kwargs):
715      # Convert the image to a Numeric array
716     
717      self.data=self.image2array(self.file)
718      #slower method:
719      #self.data = Numeric.array(self.file.getdata())
720
721      if 'numericTransform' in kwargs:
722         # numericTransform was specified, so compile the expression:
723         self.numericTransform = NumericTransform.infixExpression(kwargs['numericTransform'])
724      if 'fillValue' in kwargs:
725         self.fillValue = kwargs['fillValue']
726
727class HDF5Interface(AbstractDI):
728    #Data Interface for HDF5
729    def __init__(self):
730        self.extractType='hdfExtract'
731        self.extractPrefix='_hdfextract_'
732   
733    def openFile(self, filename):
734        #some code to open the file
735        pass
736
737    def setAxis(self,axis):
738        #some code to set an axis to be queried, may not need to do much, depending on your format
739        pass
740       
741    def getDataForAxis(self):
742        #some code to return the values for an axis
743        return data
744
745    def setVariable(self,varname):
746        #some code to set a variable to be queried, may not need to do much, depending on your format
747        pass
748
749    def getDataForVar(self):
750        #some code to return all values for a variable
751        return data
752
753    def getSubsetOfDataForVar(self, **kwargs):
754        #takes keyword args defining subset eg
755        #subset=getSubsetOfDataForVar(latitude=(0.,10.0), longitude=(90, 100.0), ...)
756        #and returns a subset of data for tha variable
757        return data
758
759    def closeFile(self):
760        #some code to close the file
761        pass
Note: See TracBrowser for help on using the repository browser.