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

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

correct url for cf converions

  • 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.NetCDFExtract()
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        #timeHref is used to store a referencable timepositionlist for reuse
113        if not hasattr(self, 'timeHref'):
114            self.timeHref = None
115        ##add an axisName element(s) for  each spatial dimension.
116        #and an ordinate element
117        axes=''
118        for axis in dimNames:
119            axes =axes + ' '+ axis
120        ordinates=[]
121        for dimName in enumerate(dimNames):
122            ord=cp.GridOrdinateDescription()               
123            #map the grid axis to the crs axis
124            #default to empty element
125            ord.coordAxisLabel=cp.csString('')
126            ord.gridAxesSpanned=cp.csString('')
127            for axis in axisorder:
128                if axisorder[axis]==dimName[0]:
129                    ord.coordAxisLabel=cp.csString(axis)
130                    ord.gridAxesSpanned=cp.csString(dimName[1])
131                    break
132            seqRule= cp.SequenceRule()
133            seqRule.CONTENT='Linear'
134            seqRule.axisOrder='+1'  #TO DO. Work this out.
135            ord.sequenceRule=seqRule           
136            sptList=csml.parser.SpatialOrTemporalPositionList()
137            sptList.id =csml.csmllibs.csmlextra.getRandomID()
138            if dimName[1]==self.timedim:
139                #this is the time dimension. handle calendaring etc when getting the data.
140                if self.timestorage=='fileextract':
141                    #look up file extract name in dictionary
142                    #(axisid stored in dictionary = current filename + variable name)
143                    axisid=self.repfilename+dimName[1]
144                    sptList.timePositionList=cp.TimePositionList(self.fileExtractDictionary[axisid])
145                else:
146                    if self.timeHref == None:
147                        self.timeHref=sptList.id
148                        timeposList=cp.TimePositionList()
149                        timeposList.CONTENT=self.timeString
150                        timeposList.frame='ndg:%s'%self.caltype
151                        sptList.timePositionList=timeposList
152                    else:
153                        sptList.href='#' +self.timeHref
154                        sptList.show='embed'
155                        sptList.arcrole='http://ndg.nerc.ac.uk/xlinkUsage/insert#timePositionList'
156                        sptList.role='http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor'
157                        sptList.timePositionList=cp.TimePositionList()                                       
158            else:  #for all other dimensions, create ordinates
159                if self.spatialstorage=='fileextract':
160                    #look up file extract name in dictionary
161                    #(axisid stored in dictionary = current filename + variable name)
162                    axisid=self.repfilename+dimName[1]
163                    #sptList.coordinateList=cp.csString('#'+ self.fileExtractDictionary[axisid]) #todo, fix xlink
164                    sptList.href='#'+self.fileExtractDictionary[axisid]
165                    sptList.show='embed'
166                    sptList.arcrole='http://ndg.nerc.ac.uk/xlinkUsage/insert#coordinateList'
167                    sptList.role='http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor'
168                else:
169                    #store inline
170                    self.DI.setAxis(dimName[1])
171                    sptList.coordinateList=cp.csString(csml.csmllibs.csmlextra.cleanString(str(self.DI.getDataForAxis())))
172
173            ord.coordAxisValues=sptList
174            gcT.addChildElem('gridOrdinates',ord)             
175        return gcT
176       
177    def __getLocation(self):
178        #attempts to get a fixed location, eg for a ProfileSeriesFeature.
179        lonval=None
180        latval=None
181        heightval=None
182        vars=self.DI.getListofVariables()
183        cat = csml.csmllibs.csmlcrs.CRSCatalogue()
184        axes=[]
185        for var in vars:
186            self.DI.setVariable(var)
187            unitname=self.DI.getVariableAttribute('units')
188            unittype=cat.getUnitType(unitname)
189            if unittype == 'latitude':
190                latval=self.DI.getDataForVar()
191                axes.append(unittype)
192            elif unittype == 'longitude':
193                lonval=self.DI.getDataForVar() 
194                axes.append(unittype)
195            elif unittype=='height':
196                heightval=self.DI.getDataForVar() 
197                axes.append(unittype)
198               
199        #returns lat lon height, but note that any of these may be None     
200        crs=cat.determineCRS(knownCRSAxes =axes) #TODO, may need to rethink csmlcrs module a bit
201        srsName= crs[0].srsName
202        return latval, lonval, heightval, srsName
203       
204    def __getCRS(self,varName,catalogue):
205        self.DI.setVariable(varName)
206        dimNames=self.DI.getVariableAxes() 
207        if len(dimNames) <= 1:
208                #it's an axis or bounds not a feature, try next variable
209            return None, None, None
210        unitlist=[]
211        for dim in dimNames:
212            self.DI.setAxis(dim)
213            units=self.DI.getAxisAttribute('units')  #need to make special case of units in DI layer
214            unitlist.append(units)   
215        crs, axisorder=catalogue.determineCRS(dimNames,unitlist)
216        return crs, axisorder, dimNames
217   
218    def __getStdName(self, varName):
219        '''look for the 'standard_name' attribute. Assumes it's a cf compliant standard_name. If not found returns None'''
220        self.DI.setVariable(varName)
221        sn=self.DI.getVariableAttribute('standard_name')   
222        if sn is None:
223            sname = None
224        else:
225            sname='http://cfconventions.org/standard_names/%s'%sn       
226        return sname
227   
228   
229    def __featureMetadata(self,feature, varName):
230        feature.id=csml.csmllibs.csmlextra.getRandomID()
231        feature.name=csml.parser.csString(varName)
232        desc = self._getDescriptiveName(self.DI)
233        feature.description=csml.parser.csString(desc)
234       
235    def __getGMLRangeset(self,varName):
236        #GML RANGESET
237        rs=csml.parser.RangeSet()
238        self.DI.setVariable(varName)
239        arrSz = self.DI.getArraySizeOfVar()
240        try:
241            strUom = self.DI.getVariableAttribute('units')
242            strUom=strUom.replace(' ','.')
243            if strUom=='':
244                strUom='dimensionless_or_units_not_determined'
245        except AttributeError:
246            # if units attribute doesn't exist:
247            strUom ="dimensionless-or_units_not_determined"
248        if self.valuestorage=='inline':
249            #TO DO, store the rangeset inline - use Datablock class???
250            pass
251        else:
252            #store the rangeSet as an aggregatedArray
253            aa=cp.AggregatedArray()
254            aa.arraySize=cp.csString(arrSz)
255            aa.uom=cp.csString(strUom)
256            aa.aggType=cp.csString('new') #can it be anything else?
257            aa.aggIndex=cp.csString('1')
258            #FileExtract (fe) element will be NetCDF/GRIB/PPExtract element (As defined earlier in ExtractType)
259            self.extractType= self.DI.extractType
260            fe = self._getCorrectExtractType()
261            varSize=self.DI.getShapeOfVar()
262            varSize=csml.csmllibs.csmlextra.cleanString1(str(varSize))
263            fe.arraySize=cp.csString(varSize)
264            fl=cp.FileList()
265            fl.fileNames=cp.csString(self.filesinDir)
266            fe.fileList=fl
267            fe.variableName=cp.csString(varName)
268            aa.components=[fe]
269            aa.id=csml.csmllibs.csmlextra.getRandomID()
270            if hasattr(self.ds_element, 'storageDescriptor'):
271                self.ds_element.storageDescriptor.descriptors.append(aa)
272            else:
273                sd =csml.parser.CSMLStorageDescriptor()
274                sd.descriptors=[aa]
275                setattr(self.ds_element, 'storageDescriptor',sd)
276            va=csml.parser.ValueArray()
277            vc=csml.parser.MeasureOrNullList()
278            vc.href='#%s'%aa.id
279            vc.arcrole="http://ndg.nerc.ac.uk/xlinkUsage/insert#QuantityList"
280            vc.role="http://ndg.nerc.ac.uk/fileFormat/csmlStorageDescriptor"
281            vc.show='embed'
282            vc.uom=strUom
283            va.valueComponent=vc
284            va.id=csml.csmllibs.csmlextra.getRandomID()
285            rs.valueArray=va
286        return rs
287   
288   
289    #the following functions are for creation of specific feature types (and call the __functions above)
290    def createCSMLGridSeriesFeatures(self):
291        #This method assumes that the variables (features) are shared across identically structured files
292        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
293        representativeFiles=self.ffmap.getRepresentativeFiles()
294        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
295        for repfile in representativeFiles:
296            #get the names of all the variables in the files:
297            allVarNames, numFeatures = self.__getVarInfo(repfile)
298            #Create a GridSeriesFeature for each variable:
299            for i in range(0, numFeatures):
300                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
301                if crs == None:
302                    continue            #try next variable
303                gsFeature=cp.GridSeriesFeature()
304                self.__featureMetadata(gsFeature,allVarNames[i])
305                #VALUE (coverage)
306                gsCoverage=cp.GridSeriesCoverage()
307                gsCoverage.id = csml.csmllibs.csmlextra.getRandomID()
308                gsDomain=cp.GridSeriesDomain()
309                gsDomain.id = csml.csmllibs.csmlextra.getRandomID()
310                gsDomain.srsName=crs.srsName
311                gsDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
312                gsDomain.srsDimension=crs.srsDimension
313                gsDomain.dimension=gsDomain.srsDimension
314                if crs.units is not None:
315                    gsDomain.uomLabels=crs.units
316                else:
317                    gsDomain.uomLabels="could not get units"
318                aLabels=''
319                for dim in dimNames:
320                    aLabels=aLabels + dim + ' '
321                gsDomain.aLabels=cp.csString(aLabels)
322                limits=cp.GridEnvelope()
323                limits.low=cp.csString('0 0 0')
324                limits.high=cp.csString('0 0 0')
325                gsDomain.limits=limits
326                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
327                gsDomain.coordTransformTable=gcT
328                gsCoverage.gridSeriesDomain=gsDomain
329               
330                #COVERAGE FUNCTION
331                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
332                #gsCoverage.coverageFunction=cp.csString(mr)
333                rs=self.__getGMLRangeset(allVarNames[i])
334               
335                #RANGESET
336                gsCoverage.rangeSet=rs
337               
338                #phenomenon
339                param=self.__getStdName(allVarNames[i])               
340                if not param:
341                    param='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i]
342                gsFeature.parameter=csml.parser.Phenomenon(href=param)                               
343                gsFeature.value=gsCoverage
344                self.fms.append(gsFeature)
345            self.DI.closeFile()
346    ###End of createCSMLGridSeriesFeatures###
347   
348    def createCSMLProfileSeriesFeatures(self):
349        #This method assumes that the variables (features) are shared across identically structured files
350        #should be supplied with a featurefilemap object (see csmlfiles for FileMapMaker)
351        representativeFiles=self.ffmap.getRepresentativeFiles()
352        cat=csml.csmllibs.csmlcrs.CRSCatalogue()
353        for repfile in representativeFiles:
354            #get the names of all the variables in the files:
355            allVarNames, numFeatures = self.__getVarInfo(repfile)
356            #Create a ProfileSeriesFeature for each variable:
357            for i in range(0, numFeatures):
358                crs,axisorder, dimNames=self.__getCRS(allVarNames[i], cat)
359                if crs == None:
360                    print 'none'
361                    continue            #try next variable
362                psFeature=cp.ProfileSeriesFeature()
363                self.__featureMetadata(psFeature,allVarNames[i])
364                #VALUE (coverage)
365                psCoverage=cp.ProfileSeriesCoverage()
366                psDomain=cp.ProfileSeriesDomain()
367                psDomain.srsName=crs.srsName
368                psDomain.axisLabels=crs.axisLabels # note this is the xml attribute axisLabels, not the child element (aLabels)
369                psDomain.srsDimension=crs.srsDimension
370                if crs.units is not None:
371                    psDomain.uomLabels=crs.units
372                else:
373                    psDomain.uomLabels="could not get units"
374                aLabels=''
375                for dim in dimNames:
376                    aLabels=aLabels + dim + ' '
377                psDomain.aLabels=cp.csString(aLabels)
378                gcT=self.__getGridCoordinatesTable(dimNames, crs,axisorder)
379                psDomain.coordTransformTable=gcT
380                psCoverage.profileSeriesDomain=psDomain
381               
382                ##COVERAGE FUNCTION
383                #mr =csml.csmllibs.csmlextra.getMappingRule(len(dimNames))
384                #psCoverage.coverageFunction=cp.csString(mr)
385                rs=self.__getGMLRangeset(allVarNames[i])
386               
387                #RANGESET
388                psCoverage.rangeSet=rs
389                psFeature.parameter=csml.parser.Phenomenon(href='http://badc.rl.ac.uk/localparams#%s'%allVarNames[i])
390                psFeature.value=psCoverage
391                (latval, lonval, heightval, srs)=self.__getLocation()
392                posString ='%s %s %s'%(latval, lonval, heightval)
393               
394                psFeature.location=csml.parser.DirectPositionList(CONTENT=posString, srsName=srs)
395                self.fms.append(psFeature)
396            self.DI.closeFile()
397    ###End of createCSMLProfileSeriesFeatures###
398
399        #BELOW THIS POINT ALL NEEDS REWRITING
400####################################
401    def createCSMLPointSeriesFeatures(self): 
402
403        representativeFiles=self.ffmap.getRepresentativeFiles()
404        for repfile in representativeFiles:
405            self.repfilename,self.listOfFiles=self._populateListOfFiles(repfile)
406            self._getFilesAndTimes()
407            DI = csml.csmllibs.csmldataiface.DataInterface()
408            DI=DI.getUnknownInterfaceType(self.repfilename)
409            DI.openFile(self.repfilename)
410            allVarNames=DI.getListofVariables()
411            numFeatures=len(allVarNames)       
412            try:
413                DI.setAxis(self.timedim)
414                times=DI.getDataForAxis()
415            except:                     
416                times = DI.getTimes()
417            #Create features:
418            for i in range (0, numFeatures):
419                PointSeriesFeature_element=csml.parser.PointSeriesFeature()
420                if str(allVarNames[i]).upper() in ['ERROR FLAG', 'ERROR']: #might need to extend this list
421                    break
422                PointSeriesFeature_element.id=str(allVarNames[i])
423                desc=self._getDescriptiveName(DI)
424                PointSeriesFeature_element.description=csml.parser.Description(desc)
425                #DOMAIN
426                psDomain=csml.parser.PointSeriesDomain()
427                t=csml.parser.Trajectory()
428                t.srsName='urn:EPSG:geographicCRS:4326' #TO Do
429                t.locations =csml.parser.DirectPositionList(vals='1 1')
430               
431                if self.timestorage =='inline':
432                    tpl =csml.parser.TimePositionList()
433                    tpl.timePositions=self.timeString
434                    tpl.frame='%s:%s'%(self.caltype,self.units)
435                    t.times=tpl
436                else:
437                    # do something to create a single extract for the times (from the representative file).
438                    tpl.timePositions = csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType, repfilename, self.timedim, len(self.timeString.split())) 
439                    tpl.frame='%s:%s'%(self.caltype,self.units)
440               
441               
442#                 if self.timestorage =='inline':
443#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX',str(times))
444#                 else:
445#                     #todo: depends on the file mapping???
446#                     t.times=csmllibs.Parser.TimePositionList('#RefSysX','blah') #blah = dummy times
447#                 print 'times: ' + str(allVarNames[i])
448#                 print len(times)
449#                 print len(listOfFiles)
450#                 arraySize=len(times) * len(listOfFiles)
451#                 fextract=csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,self.timedim,arraySize)
452#                 tplist = csmllibs.Parser.TimePositionList(timePositions=fextract)
453#                 t.times=tplist                                                                   
454                filenames=csml.csmllibs.csmlextra.cleanString(str(self.listOfFiles))
455                psDomain.domainReference=t
456                #RANGESET
457                DI.setVariable(allVarNames[i])
458                try:
459                    strUom = DI.getVariableAttribute('units')
460                    strUom=strUom.replace(' ','.')
461                except AttributeError:
462                    #if units attribute doesn't exist:
463                    strUom ="dimensionless_or_units_not_determined"
464                 
465                try:                   
466                    measuredvalues = DI.getDataForVar()
467                except:
468                    measuredvalues = ' could not get values '
469                rs=csml.parser.RangeSet()
470                if self.valuestorage=='inline':
471                    #encode inline
472                    rs.quantityList=csml.parser.MeasureOrNullList(uom=strUom, val=str(measuredvalues)[1:-1])                         
473                else:
474                    #create a file extract link
475                    arraySize=len(measuredvalues)*len(self.listOfFiles) 
476                    #TODO this needs to be able to handle inline, use VALUESTORAGE to determine which to use:
477                    self.extractType=DI.extractType
478                    fextract=csml.csmllibs.csmlfileextracts.createSingleExtract(self.extractType,filenames,allVarNames[i],arraySize)
479                    qlist = csml.parser.MeasureOrNullList(val=fextract)
480                    rs.quantityList=qlist
481                PointSeriesFeature_element.rangeSet=rs
482                #COVERAGEFUNCTION                           
483                #PARAMETER
484                #need to do parameter and coverageFunction elements
485                PointSeriesFeature_element.domain=psDomain
486                self.fms.append(PointSeriesFeature_element)
487            DI.closeFile()
488       
489
490#This function needs revising in light of a) csml parser and b) new profile feature types
491    def createCSMLProfileFeature(csmldoc, dataset_element, gml_FeatureCollection_element,  ffmap, timedim):
492            representativeFiles=ffmap.getRepresentativeFiles()
493            listOfFiles=[]
494            for repfile in representativeFiles:
495                    repfilename=repfile.getRepresentativeFileName()
496                    listOfFiles.append(repfilename)
497                    relfiles = repfile.getRelatedFiles()
498                    for f in relfiles:
499                            #hopefully there are no related files at the moment!
500                            fname = f.getRelatedFileName()
501                            listOfFiles.append(fname)
502                    #print listOfFiles
503                   
504            for file in listOfFiles:
505                    DI = csmllibs.csmldataiface.DataInterface()
506                    DI=DI.getUnknownInterfaceType(file)
507                    print'opening file'
508                    DI.openFile(file)
509                    print 'getting variables'
510                    allVarNames=DI.getListofVariables()
511                    print 'getting feature count'
512                    numFeatures=len(allVarNames)       
513                   
514                    print "FEATURES"
515                    print "***********"
516                    for i in range (0, len(allVarNames)):
517                            print allVarNames[i]
518                           
519                    for i in range (0, numFeatures):
520                            gml_featureMember_element=csmldoc.createElement("gml:featureMember")
521                            ProfileFeature_element=csmldoc.createElement("ProfileFeature")
522                            ProfileFeature_element.setAttribute('gml:id',str(allVarNames[i]))
523                            gml_description_element = csmldoc.createElement("gml:description")
524                            gml_featureMember_element.appendChild(ProfileFeature_element)
525                            #***********************************************************************
526                            #PointSeriesDomain:
527                            #***********************************************************************
528                            ProfileDomain_element=csmldoc.createElement("ProfileDomain")
529                           
530                           
531                            #***********************************************************************
532                            # domainReference element (and sub-elements)               
533                            #***********************************************************************
534                            domainReference_element=csmldoc.createElement("domainReference")
535                            #orientedPosition_element=csmldoc.createElement("OrientedPosition")
536                            #locations_element=csmldoc.createElement("locations")
537                            #times_element=csmldoc.createElement("times")
538                            #trajectory_element.appendChild(locations_element)
539                            #trajectory_element.appendChild(times_element)
540                            #domainReference_element.appendChild(orientedPosition_element)
541                           
542                            #gml_timePositionList_element = csmldoc.createElement("gml:TimePositionList")
543                            #gml_timePositionList_element.appendChild(csmldoc.createTextNode(self.timeString))
544                            #domainReference_element.appendChild(gml_timePositionList_element)
545                            ProfileDomain_element.appendChild(domainReference_element)
546                            #***********************************************************************
547                            domainComplement_element=csmldoc.createElement("domainComplement")
548                            ProfileDomain_element.appendChild(domainComplement_element)
549                           
550                            #***********************************************************************
551                            # gml:rangeSet_element
552                            #***********************************************************************
553                           
554                            gml_rangeSet_element=csmldoc.createElement("gml:rangeSet") 
555                           
556                            #***********************************************************************
557                            # gml:coverageFunction element (and sub-element MappingRule)               
558                            #***********************************************************************
559                            gml_coverageFunction_element=csmldoc.createElement("gml:coverageFunction")
560                            MappingRule_element=csmldoc.createElement("MappingRule")
561                            #MappingRule_element.setAttribute('scanOrder',csmllibs.csmlextra.getMappingRule(len(dimNames)))
562                            MappingRule_element.setAttribute('scanOrder','tba')
563                            gml_coverageFunction_element.appendChild(MappingRule_element)
564                           
565                           
566                            gml_featureMember_element.appendChild(ProfileDomain_element)
567                            gml_featureMember_element.appendChild(gml_rangeSet_element)
568                            gml_featureMember_element.appendChild(gml_coverageFunction_element)
569                            gml_FeatureCollection_element.appendChild(gml_featureMember_element)       
570                           
571            return 
572                           
573       
Note: See TracBrowser for help on using the repository browser.