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

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

fixed bounding box aggregation code

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