source: TI02-CSML/trunk/csml/csmllibs/csmlfeaturetypes.py @ 2377

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

fixed Xlinking in SpatialOrTemporalLists? fixed uom attribute

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2#**************************************************************************************
3#csmlfeaturetypes.py
4#For creating CSML featuretypes
5#v0.5 split off 11th November 2005
6#Dominic Lowe, BADC
7#**************************************************************************************
8
9import csml.parser as cp
10import csml.csmllibs
11import sys
12import pdb
13   
14
15class featureBuilder(object):
16    def __init__(self, dataset_element, featureCollection_element, ffmap,fileExtractDictionary, timedim, timestorage,spatialstorage,valuestorage):
17        self.ds_element=dataset_element
18        self.featureCollection = featureCollection_element
19        self.ffmap = ffmap
20        self.fileExtractDictionary = fileExtractDictionary
21        self.timedim = timedim
22        self.timestorage=timestorage
23        self.spatialstorage=spatialstorage
24        self.valuestorage=valuestorage
25               
26        #empty list to hold featureMembers
27        self.fms =[]
28               
29        #at the moment, only one featuretype per CSML Dataset is supported.
30        #get the featuretype of the first representative file in the ffmap object
31        self.featuretype=  self.ffmap.getRepresentativeFiles()[0].getFeatureType()
32       #and create the features
33        print 'determining feature type'
34        print self.featuretype
35        if self.featuretype == 'GridSeries':
36            self.createCSMLGridSeriesFeatures()
37        elif self.featuretype == 'PointSeries':       
38            self.createCSMLPointSeriesFeatures()
39        elif self.featuretype == 'ProfileSeries':       
40            self.createCSMLProfileSeriesFeatures()
41        #after the features have been generated append all featureMembers to the feature collection
42        self.featureCollection.featureMembers=self.fms
43       
44    #Some internal methods that are of use to all feature types:
45    def _getDescriptiveName(self,DI):
46        #given a data interface class with the variable or axis set, try to get a descriptive name
47        #eg. long name
48        try:
49            descName=DI.getVariableAttribute('long_name')
50            descName
51        except AttributeError:
52            descName = "missing name"
53        descName=descName.replace('&','&') #remove ampersands TODO- extend this
54        return descName
55   
56    def _populateListOfFiles(self,repfile):
57        #given a representative file, get list of files: one representative file + all related files
58        listOfFiles=[]
59        repfilename=repfile.getRepresentativeFileName()
60        listOfFiles.append(repfilename)
61        relfiles = repfile.getRelatedFiles()
62        for f in relfiles:
63            fname = f.getRelatedFileName()
64            listOfFiles.append(fname)
65        return repfilename,listOfFiles
66       
67    def _getFilesAndTimes(self):
68        #TODO try and speed up csmllibs.csmltime.getFileTimeList
69        OrderedFileTimeList,self.caltype,self.units = csml.csmllibs.csmltime.getFileTimeList(self.listOfFiles,self.timedim)
70        #build strings to hold times/filenames for current gridseriesfeature
71        self.timeString =''
72        self.filesinDir = ''
73        lastf=''
74        for j in range (0, len(OrderedFileTimeList)):
75            t= OrderedFileTimeList[j][0]
76            f = OrderedFileTimeList[j][1]
77            self.timeString = self.timeString + ' ' + str(t)
78            if f != lastf:
79                self.filesinDir = self.filesinDir + ' ' + f
80                lastf=f
81           
82    def _getCorrectExtractType(self):
83        #returns an empty parser file extract object of the correct type.
84        if self.extractType=='NetCDFExtract':
85            fe = csml.parser.NetCDFExtract()
86        if self.extractType=='NASAAmesExtract':
87            fe = csml.parser.NASAAmesExtract()
88        if self.extractType=='GRIBExtract':
89            fe = csml.parser.GRIBExtract()
90        if self.extractType=='PPExtract':
91            fe = csml.parser.PPExtract()
92        return fe
93       
94   
95   
96    #the following __functions are used by all or most feature types:
97   
98    def __getVarInfo(self, representativeFile):
99        self.repfilename,self.listOfFiles=self._populateListOfFiles(representativeFile)
100        self._getFilesAndTimes()
101        #Open representative file and create feature members:
102        self.DI = csml.csmllibs.csmldataiface.DataInterface()
103        self.DI=self.DI.getUnknownInterfaceType(self.repfilename)
104        self.DI.openFile(self.repfilename)
105        allVarNames=self.DI.getListofVariables()
106        numFeatures=len(allVarNames)
107        return allVarNames, numFeatures
108   
109    def __getGridCoordinatesTable(self,dimNames, crs,axisorder):
110        #referenceableGrid/GridCoordinatesTable
111        gcT=cp.GridCoordinatesTable()
112        ##add an axisName element(s) for  each spatial dimension.
113        #and an ordinate element
114        axes=''
115        for axis in dimNames:
116            axes =axes + ' '+ axis
117        ordinates=[]
118        for dimName in enumerate(dimNames):
119            ord=cp.GridOrdinateDescription()               
120            #map the grid axis to the crs axis
121            #default to empty element
122            ord.coordAxisLabel=cp.csString('')
123            ord.gridAxesSpanned=cp.csString('')
124            for axis in axisorder:
125                if axisorder[axis]==dimName[0]:
126                    ord.coordAxisLabel=cp.csString(axis)
127                    ord.gridAxesSpanned=cp.csString(dimName[1])
128                    break
129            seqRule= cp.SequenceRule()
130            seqRule.CONTENT='Linear'
131            seqRule.axisOrder='+1'  #TO DO. Work this out.
132            ord.sequenceRule=seqRule
133            sptList=cp.SpatialOrTemporalPositionList()
134            sptList.id =csml.csmllibs.csmlextra.getRandomID()
135            if dimName[1]==self.timedim:
136                #this is the time dimension. handle calendaring etc when getting the data.
137                if self.timestorage=='fileextract':
138                    #look up file extract name in dictionary
139                    #(axisid stored in dictionary = current filename + variable name)
140                    axisid=self.repfilename+dimName[1]
141                    sptList.timePositionList=cp.TimePositionList(self.fileExtractDictionary[axisid])
142                else:
143                    #store times inline
144                    self.DI.setAxis(dimName[1])
145                    timeposList=cp.TimePositionList()
146                    timeposList.CONTENT=self.timeString
147                    timeposList.frame='ndg:%s:%s'%(self.caltype,self.units)
148                    sptList.timePositionList=timeposList
149            else:  #for all other dimensions, create ordinates
150                if self.spatialstorage=='fileextract':
151                    #look up file extract name in dictionary
152                    #(axisid stored in dictionary = current filename + variable name)
153                    axisid=self.repfilename+dimName[1]
154                    #sptList.coordinateList=cp.csString('#'+ self.fileExtractDictionary[axisid]) #todo, fix xlink
155                    sptList.href='#'+self.fileExtractDictionary[axisid]
156                    sptList.show='embed'
157                    sptList.arcrole='http://ndg.nerc.ac.uk/xlinkUsage/insert#coordinateList'
158                    sptList.role='http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor'
159                else:
160                    #store inline
161                    self.DI.setAxis(dimName[1])
162                    sptList.coordinateList=cp.csString(csml.csmllibs.csmlextra.cleanString(str(self.DI.getDataForAxis())))
163            ord.coordAxisValues=sptList
164            gcT.addChildElem('gridOrdinates',ord)                         
165        return gcT
166       
167    def __getLocation(self):
168        #attempts to get a fixed location, eg for a ProfileSeriesFeature.
169        lonval=None
170        latval=None
171        heightval=None
172        vars=self.DI.getListofVariables()
173        cat = csml.csmllibs.csmlcrs.CRSCatalogue()
174        axes=[]
175        for var in vars:
176            self.DI.setVariable(var)
177            unitname=self.DI.getVariableAttribute('units')
178            unittype=cat.getUnitType(unitname)
179            if unittype == 'latitude':
180                latval=self.DI.getDataForVar()
181                axes.append(unittype)
182            elif unittype == 'longitude':
183                lonval=self.DI.getDataForVar() 
184                axes.append(unittype)
185            elif unittype=='height':
186                heightval=self.DI.getDataForVar() 
187                axes.append(unittype)
188               
189        #returns lat lon height, but note that any of these may be None     
190        crs=cat.determineCRS(knownCRSAxes =axes) #TODO, may need to rethink csmlcrs module a bit
191        srsName= crs[0].srsName
192        return latval, lonval, heightval, srsName
193       
194    def __getCRS(self,varName,catalogue):
195        self.DI.setVariable(varName)
196        dimNames=self.DI.getVariableAxes() 
197        if len(dimNames) <= 1:
198                #it's an axis or bounds not a feature, try next variable
199            return None, None, None
200        unitlist=[]
201        for dim in dimNames:
202            self.DI.setAxis(dim)
203            units=self.DI.getAxisAttribute('units')  #need to make special case of units in DI layer
204            unitlist.append(units)   
205        crs, axisorder=catalogue.determineCRS(dimNames,unitlist)
206        return crs, axisorder, dimNames
207   
208    def __featureMetadata(self,feature, varName):
209        feature.id=str(varName)
210        desc = self._getDescriptiveName(self.DI)
211        feature.description=csml.parser.csString(desc)
212       
213    def __getGMLRangeset(self,varName):
214        #GML RANGESET
215        rs=csml.parser.RangeSet()
216        self.DI.setVariable(varName)
217        arrSz = self.DI.getArraySizeOfVar()
218        try:
219            strUom = self.DI.getVariableAttribute('units')
220            strUom=strUom.replace(' ','')
221            if strUom=='':
222                strUom='dimensionless_or_units_not_determined'
223        except AttributeError:
224            # if units attribute doesn't exist:
225            strUom ="dimensionless-or_units_not_determined"
226        if self.valuestorage=='inline':
227            #TO DO, store the rangeset inline - use Datablock class???
228            pass
229        else:
230            #store the rangeSet as an aggregatedArray
231            aa=cp.AggregatedArray()
232            aa.arraySize=cp.csString(arrSz)
233            aa.uom=cp.csString(strUom)
234            aa.aggType=cp.csString('new') #can it be anything else?
235            aa.aggIndex=cp.csString('1')
236            #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
237            self.extractType= self.DI.extractType
238            fe = self._getCorrectExtractType()
239            varSize=self.DI.getShapeOfVar()
240            varSize=csml.csmllibs.csmlextra.cleanString1(str(varSize))
241            fe.arraySize=cp.csString(varSize)
242            fl=cp.FileList()
243            fl.fileNames=cp.csString(self.filesinDir)
244            fe.fileList=fl
245            fe.variableName=cp.csString(varName)
246            aa.components=[fe]
247            aa.id=csml.csmllibs.csmlextra.getRandomID()
248            if hasattr(self.ds_element, 'storageDescriptor'):
249                self.ds_element.storageDescriptor.descriptors.append(aa)
250            else:
251                sd =csml.parser.CSMLStorageDescriptor()
252                sd.descriptors=aa
253                setattr(self.ds_element, 'storageDescriptor',sd)
254            #rs.aggregatedArray=aa
255            va=csml.parser.ValueArray()
256            vc=csml.parser.ValueComponent()
257            vc.href='#%s'%aa.id
258            vc.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList"
259            vc.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor"
260            vc.show='embed'
261            ql=csml.parser.MeasureOrNullList()
262            ql.uom=strUom
263            vc.quantityList=ql
264            va.valueComponent=vc
265            va.id=csml.csmllibs.csmlextra.getRandomID()
266            rs.valueArray=va
267        return rs
268   
269   
270    #the following functions are for creation of specific feature types (and call the __functions above)
271    def createCSMLGridSeriesFeatures(self):
272        #This method assumes that the variables (features) are shared across identically structured files
273        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
274        representativeFiles=self.ffmap.getRepresentativeFiles()
275        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
276        for repfile in representativeFiles:
277            #get the names of all the variables in the files:
278            allVarNames, numFeatures = self.__getVarInfo(repfile)
279            #Create a GridSeriesFeature for each variable:
280            for i in range(0, numFeatures):
281                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
282                if crs == None:
283                    continue            #try next variable
284                gsFeature=cp.GridSeriesFeature()
285                self.__featureMetadata(gsFeature,allVarNames[i])
286                #VALUE (coverage)
287                gsCoverage=cp.GridSeriesCoverage()
288                gsCoverage.id = csml.csmllibs.csmlextra.getRandomID()
289                gsDomain=cp.GridSeriesDomain()
290                gsDomain.id = csml.csmllibs.csmlextra.getRandomID()
291                gsDomain.srsName=crs.srsName
292                gsDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
293                gsDomain.srsDimension=crs.srsDimension
294                gsDomain.dimension=gsDomain.srsDimension
295                aLabels=''
296                for dim in dimNames:
297                    aLabels=aLabels + dim + ' '
298                gsDomain.aLabels=cp.csString(aLabels)
299                limits=cp.GridEnvelope()
300                limits.low=cp.csString('0 0 0')
301                limits.high=cp.csString('0 0 0')
302                gsDomain.limits=limits
303                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
304                gsDomain.coordTransformTable=gcT
305                gsCoverage.gridSeriesDomain=gsDomain
306               
307                #COVERAGE FUNCTION
308                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
309                #gsCoverage.coverageFunction=cp.csString(mr)
310                rs=self.__getGMLRangeset(allVarNames[i])
311               
312                #RANGESET
313                gsCoverage.rangeSet=rs
314                gsFeature.parameter=csml.parser.Phenomenon(href='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i])
315                gsFeature.value=gsCoverage
316                self.fms.append(gsFeature)
317            self.DI.closeFile()
318    ###End of createCSMLGridSeriesFeatures###
319   
320    def createCSMLProfileSeriesFeatures(self):
321        #This method assumes that the variables (features) are shared across identically structured files
322        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
323        representativeFiles=self.ffmap.getRepresentativeFiles()
324        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
325        for repfile in representativeFiles:
326            #get the names of all the variables in the files:
327            allVarNames, numFeatures = self.__getVarInfo(repfile)
328            #Create a ProfileSeriesFeature for each variable:
329            for i in range(0, numFeatures):
330                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
331                if crs == None:
332                    print 'none'
333                    continue            #try next variable
334                psFeature=cp.ProfileSeriesFeature()
335                self.__featureMetadata(psFeature,allVarNames[i])
336                #VALUE (coverage)
337                psCoverage=cp.ProfileSeriesCoverage()
338                psDomain=cp.ProfileSeriesDomain()
339                psDomain.srsName=crs.srsName
340                psDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
341                psDomain.srsDimension=crs.srsDimension
342                aLabels=''
343                for dim in dimNames:
344                    aLabels=aLabels + dim + ' '
345                psDomain.aLabels=cp.csString(aLabels)
346                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
347                psDomain.coordTransformTable=gcT
348                psCoverage.profileSeriesDomain=psDomain
349               
350                ##COVERAGE FUNCTION
351                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
352                #psCoverage.coverageFunction=cp.csString(mr)
353                rs=self.__getGMLRangeset(allVarNames[i])
354               
355                #RANGESET
356                psCoverage.rangeSet=rs
357                psFeature.parameter=csml.parser.Phenomenon(href='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i])
358                psFeature.value=psCoverage
359                (latval, lonval, heightval, srs)=self.__getLocation()
360                posString ='%s %s %s'%(latval, lonval, heightval)
361               
362                psFeature.location=csml.parser.DirectPositionList(CONTENT=posString, srsName=srs)
363                self.fms.append(psFeature)
364            self.DI.closeFile()
365    ###End of createCSMLProfileSeriesFeatures###
366
367        #BELOW THIS POINT ALL NEEDS REWRITING
368####################################
369    def createCSMLPointSeriesFeatures(self): 
370
371        representativeFiles=self.ffmap.getRepresentativeFiles()
372        for repfile in representativeFiles:
373            self.repfilename,self.listOfFiles=self._populateListOfFiles(repfile)
374            self._getFilesAndTimes()
375            DI = csml.csmllibs.csmldataiface.DataInterface()
376            DI=DI.getUnknownInterfaceType(self.repfilename)
377            DI.openFile(self.repfilename)
378            allVarNames=DI.getListofVariables()
379            numFeatures=len(allVarNames)       
380            try:
381                DI.setAxis(self.timedim)
382                times=DI.getDataForAxis()
383            except:                     
384                times = DI.getTimes()
385            #Create features:
386            for i in range (0, numFeatures):
387                PointSeriesFeature_element=csml.parser.PointSeriesFeature()
388                if str(allVarNames[i]).upper() in ['ERROR FLAG', 'ERROR']: #might need to extend this list
389                    break
390                PointSeriesFeature_element.id=str(allVarNames[i])
391                desc=self._getDescriptiveName(DI)
392                PointSeriesFeature_element.description=csml.parser.Description(desc)
393                #DOMAIN
394                psDomain=csml.parser.PointSeriesDomain()
395                t=csml.parser.Trajectory()
396                t.srsName='urn:EPSG:geographicCRS:4326' #TO Do
397                t.locations =csml.parser.DirectPositionList(vals='1 1')
398               
399                if self.timestorage =='inline':
400                    tpl =csml.parser.TimePositionList()
401                    tpl.timePositions=self.timeString
402                    tpl.frame='%s:%s'%(self.caltype,self.units)
403                    t.times=tpl
404                else:
405                    # do something to create a single extract for the times (from the representative file).
406                    tpl.timePositions = csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split())) 
407                    tpl.frame='%s:%s'%(self.caltype,self.units)
408               
409               
410#                 if self.timestorage =='inline':
411#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX',str(times))
412#                 else:
413#                     #todo: depends on the file mapping???
414#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX','blah') #blah = dummy times
415#                 print 'times: ' + str(allVarNames[i])
416#                 print len(times)
417#                 print len(listOfFiles)
418#                 arraySize=len(times) * len(listOfFiles)
419#                 fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,self.timedim,arraySize)
420#                 tplist = csmllibs.Parser.TimePositionList(timePositions=fextract)
421#                 t.times=tplist                                                                   
422                filenames=csml.csmllibs.csmlextra.cleanString(str(self.listOfFiles))
423                psDomain.domainReference=t
424                #RANGESET
425                DI.setVariable(allVarNames[i])
426                try:
427                    strUom = DI.getVariableAttribute('units')
428                    strUom=strUom.replace(' ','')
429                except AttributeError:
430                    #if units attribute doesn't exist:
431                    strUom ="dimensionless_or_units_not_determined"
432                 
433                try:                   
434                    measuredvalues = DI.getDataForVar()
435                except:
436                    measuredvalues = ' could not get values '
437                rs=csml.parser.RangeSet()
438                if self.valuestorage=='inline':
439                    #encode inline
440                    rs.quantityList=csml.parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                         
441                else:
442                    #create a file extract link
443                    arraySize=len(measuredvalues)*len(self.listOfFiles) 
444                    #TODO this needs to be able to handle inline, use VALUESTORAGE to determine which to use:
445                    self.extractType=DI.extractType
446                    fextract=csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,allVarNames[i],arraySize)
447                    qlist = csml.parser.MeasureOrNullList(val=fextract)
448                    rs.quantityList=qlist
449                PointSeriesFeature_element.rangeSet=rs
450                #COVERAGEFUNCTION                           
451                #PARAMETER
452                #need to do parameter and coverageFunction elements
453                PointSeriesFeature_element.domain=psDomain
454                self.fms.append(PointSeriesFeature_element)
455            DI.closeFile()
456       
457
458#This function needs revising in light of a) csml parser and b) new profile feature types
459    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
460            representativeFiles=ffmap.getRepresentativeFiles()
461            listOfFiles=[]
462            for repfile in representativeFiles:
463                    repfilename=repfile.getRepresentativeFileName()
464                    listOfFiles.append(repfilename)
465                    relfiles = repfile.getRelatedFiles()
466                    for f in relfiles:
467                            #hopefully there are no related files at the moment!
468                            fname = f.getRelatedFileName()
469                            listOfFiles.append(fname)
470                    #print listOfFiles
471                   
472            for file in listOfFiles:
473                    DI = csmllibs.csmldataiface.DataInterface()
474                    DI=DI.getUnknownInterfaceType(file)
475                    print'opening file'
476                    DI.openFile(file)
477                    print 'getting variables'
478                    allVarNames=DI.getListofVariables()
479                    print 'getting feature count'
480                    numFeatures=len(allVarNames)       
481                   
482                    print "FEATURES"
483                    print "***********"
484                    for i in range (0, len(allVarNames)):
485                            print allVarNames[i]
486                           
487                    for i in range (0, numFeatures):
488                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
489                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
490                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
491                            gml_description_element = csmldoc.createElement("gml:description")
492                            gml_featureMember_element.appendChild(ProfileFeature_element)
493                            #***********************************************************************
494                            #PointSeriesDomain:
495                            #***********************************************************************
496                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
497                           
498                           
499                            #***********************************************************************
500                            # domainReference element (and sub-elements)               
501                            #***********************************************************************
502                            domainReference_element=csmldoc.createElement("domainReference")
503                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
504                            #locations_element=csmldoc.createElement("locations")
505                            #times_element=csmldoc.createElement("times")
506                            #trajectory_element.appendChild(locations_element)
507                            #trajectory_element.appendChild(times_element)
508                            #domainReference_element.appendChild(orientedPosition_element)
509                           
510                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
511                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(self.timeString))
512                            #domainReference_element.appendChild(gml_timePositionList_element)
513                            ProfileDomain_element.appendChild(domainReference_element)
514                            #***********************************************************************
515                            domainComplement_element=csmldoc.createElement("domainComplement")
516                            ProfileDomain_element.appendChild(domainComplement_element)
517                           
518                            #***********************************************************************
519                            # gml:rangeSet_element
520                            #***********************************************************************
521                           
522                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
523                           
524                            #***********************************************************************
525                            # gml:coverageFunction element (and sub-element MappingRule)               
526                            #***********************************************************************
527                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
528                            MappingRule_element=csmldoc.createElement("MappingRule")
529                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
530                            MappingRule_element.setAttribute('scanOrder','tba')
531                            gml_coverageFunction_element.appendChild(MappingRule_element)
532                           
533                           
534                            gml_featureMember_element.appendChild(ProfileDomain_element)
535                            gml_featureMember_element.appendChild(gml_rangeSet_element)
536                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
537                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
538                           
539            return 
540                           
541       
Note: See TracBrowser for help on using the repository browser.