Changeset 671


Ignore:
Timestamp:
10/03/06 15:51:43 (14 years ago)
Author:
domlowe
Message:

Profile feature, profile series feature added, coveragefunction not complete

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/newparser/Parser.py

    r658 r671  
    6565 
    6666def XML(tag): 
    67     return myQName(nsXML.tag) 
     67    return myQName(nsXML,tag) 
     68 
     69def OM(tag): 
     70    return myQName(nsOM,tag) 
    6871 
    6972def checkArrayAttrib(obj,attrib): 
     
    380383    def toXML(self,csmlFrag): 
    381384        csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag) 
    382         frag = Element(CSML('fileName')) 
    383         frag.text = self.fileName 
    384         csmlFrag.append(frag) 
     385        if hasattr(self,'fileName'): 
     386            frag = Element(CSML('fileName')) 
     387            frag.text = self.fileName 
     388            csmlFrag.append(frag) 
    385389        return csmlFrag 
    386390 
     
    437441    def toXML(self,csmlFrag): 
    438442        csmlFrag = AbstractFileExtract.toXML(self,csmlFrag) 
    439         frag = Element(CSML('variableName')) 
    440         frag.text = self.variableName 
    441         csmlFrag.append(frag) 
     443        if hasattr(self, 'variableName'): 
     444            frag = Element(CSML('variableName')) 
     445            frag.text = self.variableName 
     446            csmlFrag.append(frag) 
    442447        return csmlFrag 
    443448 
     
    485490        return csmlFrag 
    486491 
     492class DirectPositionList: 
     493    #class representing a DirectPositionList 
     494    def __init__(self): 
     495        pass 
     496    def fromXML(self,csmlFrag): 
     497        self.text=csmlFrag.text 
     498        if csmlFrag.attrib.has_key('srsName'): 
     499            self.srsName=csmlFrag.attrib['srsName'] 
     500    def toXML(self,csmlFrag):  
     501        csmlFrag.text=self.text 
     502        if hasattr(self,'srsName'): 
     503            csmlFrag.attrib['srsName']=self.srsName 
     504        return csmlFrag 
     505 
    487506class AbstractDiscreteCoverage(AbstractGML): 
    488507     #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes 
    489508    #GML AbstractDiscreteCoverage Class 
    490      
    491     def __init__(self,*args,**kwargs): 
     509    def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs): 
    492510        AbstractGML.__init__(self,*args,**kwargs) 
    493     def fromXML(self,csmlFrag): 
    494         AbstractGML.fromXML(self,csmlFrag) 
    495     def toXML(self,csmlFrag): 
    496         AbstractGML.toXML(self,csmlFrag) 
    497         return csmlFrag 
    498          
    499 class AbstractCoverageFeature(AbstractDiscreteCoverage): 
    500     #CSML Abstract Coverage FT class  
    501     #     AbstractCoverageFeature(): 
    502     #       +gml:boundedBy[0..*]: AbstractFeature 
    503     #       +csml:_Domain 
    504     #       + gml:rangeSet 
    505     #       + gml:coverageFunction[0..*] 
    506     #       + parameter:om:PhenomenonPropertyType 
    507     def __init__(self,boundedBy=None,_Domain=None,rangeSet=None, coverageFunction=None, parameter=None, *args,**kwargs): 
    508         AbstractDiscreteCoverage.__init__(self,*args,**kwargs) 
    509         if boundedBy: 
    510             self.boundedBy=boundedBy 
    511         if _Domain: 
    512             self._Domain=_Domain 
    513511        if rangeSet: 
    514512            self.rangeSet=rangeSet 
    515513        if coverageFunction: 
    516514            self.coverageFunction=coverageFunction 
     515 
     516    def fromXML(self,csmlFrag): 
     517        AbstractGML.fromXML(self,csmlFrag) 
     518        for frag in csmlFrag.getchildren(): 
     519            if frag.tag == GML('rangeSet'): 
     520                self.rangeSet=RangeSet() 
     521                self.rangeSet.fromXML(frag) 
     522            if frag.tag == GML('coverageFunction'): 
     523                pass #TO DO!!  
     524 
     525 
     526    def toXML(self,csmlFrag): 
     527        AbstractGML.toXML(self,csmlFrag) 
     528        if hasattr(self,'rangeSet'): 
     529            frag = Element(GML('rangeSet')) 
     530            RangeSet.toXML(self.rangeSet,frag) 
     531            csmlFrag.append(frag) 
     532 
     533        #to DO : CoverageFunction 
     534        return csmlFrag 
     535         
     536class AbstractCoverageFeature(AbstractDiscreteCoverage): 
     537    #CSML Abstract Coverage FT class  
     538    #     AbstractCoverageFeature(AbstractDiscreteCoverage) 
     539    #       + om:parameter:PhenomenonPropertyType 
     540     
     541    def __init__(self, parameter=None, *args,**kwargs): 
     542        AbstractDiscreteCoverage.__init__(self,*args,**kwargs) 
    517543        if parameter: 
    518544            self.parameter=parameter 
     
    520546        AbstractDiscreteCoverage.fromXML(self,csmlFrag) 
    521547        for frag in csmlFrag.getchildren(): 
    522             if frag.tag == GML('boundedBy'): 
    523                 #hmmm check this one is right. 
    524                 checkArrayAttrib(self,'boundedBy') 
    525                 self.boundedBy.append(frag.text) 
    526             if frag.tag == CSML('_Domain'): 
    527                 self._Domain = _Domain() 
    528                 self._Domain.fromXML(frag) 
     548            if frag.tag == CSML('parameter'): 
     549                self.parameter=None 
     550                if frag.getchildren() == []: 
     551                    if frag.attrib.has_key(XLINK('href')): 
     552                        self.href = frag.attrib[XLINK('href')] 
     553                elif frag.getchildren()[0].tag == OM('Phenomenon'): 
     554                    self.parameter = Phenomenon() 
     555                elif frag.getchildren()[0].tag == OM('CompositePhenomenon'): 
     556                    self.parameter = CompositePhenomenon() 
     557                elif frag.getchildren()[0].tag == OM('ParametrisedPhenomenon'): 
     558                    self.parameter = ParametrisedPhenomenon() 
     559                if hasattr(self,'parameter'): 
     560                    if self.parameter is not None: 
     561                        self.parameter.fromXML(frag) 
     562 
    529563    def toXML(self,csmlFrag): 
    530564        AbstractDiscreteCoverage.toXML(self,csmlFrag) 
    531         return csmlFrag 
    532  
    533  
    534  
    535  
     565         
     566        if hasattr(self,'parameter'): 
     567            frag = Element(CSML('parameter')) 
     568            if self.parameter is not None: 
     569                if type(self.parameter) is not str: 
     570                    self.parameter.toXML(frag) 
     571            if hasattr(self, 'href'): 
     572                frag.attrib[XLINK('href')] = self.href 
     573            csmlFrag.append(frag) 
     574        return csmlFrag 
     575 
     576     
    536577class AbstractStaticCoverageFeature(AbstractCoverageFeature): 
    537578    #CSML Abstract Static Coverage FT class  
     
    568609        for frag in csmlFrag.getchildren(): 
    569610            if frag.tag == CSML('domainReference'): 
    570                 self.domainReference = domainReference() 
    571                 self.domainReference.fromXML(frag) 
     611                subfrag=frag.getchildren()[0] 
     612                if subfrag.tag==CSML('Position'): 
     613                    self.domainReference=Position() 
     614                elif subfrag.tag == CSML('Trajectory'): 
     615                    self.domainReference=Trajectory() 
     616                elif subfrag.tag==CSML('OrientedPosition'): 
     617                    self.domainReference=OrientedPosition() 
     618                elif subfrag.tag == CSML('OrientedTrajectory'): 
     619                    self.domainReference=OrientedTrajectory() 
     620                self.domainReference.fromXML(subfrag) 
    572621            if frag.tag == CSML('domainComplement'): 
    573                 self.domainComplement = domainComplement() 
    574                 self.domainComplement.fromXML(frag) 
     622                subfrag=frag.getchildren()[0] 
     623                if subfrag.tag==CSML('DirectPositionList'): 
     624                    self.domainComplement=DirectPositionList() 
     625                    self.domainComplement.fromXML(subfrag) 
     626                elif subfrag.tag==CSML('Grid'): 
     627                    self.domainComplement=Grid() 
     628                    self.domainComplement.fromXML(subfrag) 
    575629    def toXML(self,csmlFrag): 
    576630        if hasattr(self,'domainReference'): 
    577631            frag = Element(CSML('domainReference')) 
    578             domainReference.toXML(self.domainReference,frag) 
    579             csmlFrag.append(frag) 
     632            #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object 
     633            #self.domainReference.toXML(frag) 
     634            if isinstance(self.domainReference,OrientedPosition): 
     635                subFrag=Element(CSML('OrientedPosition')) 
     636                self.domainReference.toXML(subFrag) 
     637                frag.append(subFrag) 
     638                csmlFrag.append(frag) 
     639            elif isinstance(self.domainReference,OrientedTrajectory): 
     640                subFrag=Element(CSML('OrientedTrajectory')) 
     641                self.domainReference.toXML(subFrag) 
     642                frag.append(subFrag) 
     643                csmlFrag.append(frag)        
     644            elif isinstance(self.domainReference,Position): 
     645                subFrag=Element(CSML('Position')) 
     646                self.domainReference.toXML(subFrag) 
     647                frag.append(subFrag) 
     648                csmlFrag.append(frag) 
     649            elif isinstance(self.domainReference,Trajectory): 
     650                subFrag=Element(CSML('Trajectory')) 
     651                self.domainReference.toXML(subFrag) 
     652                frag.append(subFrag) 
     653                csmlFrag.append(frag) 
    580654        if hasattr(self,'domainComplement'): 
    581              frag = Element(CSML('domainComplement')) 
    582              domainComplement.toXML(self.domainComplement,frag) 
    583              csmlFrag.append(frag) 
    584         return csmlFrag 
    585  
    586 class boundedBy: 
    587     #CSML boundedBy class 
    588      
    589     # boundedBy() 
    590     # +gml:EnvelopeWithTimePeriod 
    591      
    592     def __init__(self,EnvelopeWithTimePeriod=None): 
    593         if EnvelopeWithTimePeriod: 
    594             self.EnvelopeWithTimePeriod=EnvelopeWithTimePeriod() 
    595     def fromXML(self, csmlFrag): 
    596         for frag in csmlFrag.getchildren(): 
    597             if frag.tag == GML ('EnvelopeWithTimePeriod'): 
    598                 self.EnvelopeWithTimePeriod=EnvelopeWithTimePeriod() 
    599                 EnvelopeWithTimePeriod.fromXML(self.EnvelopeWithTimePeriod,frag) 
    600     def toXML(self,csmlFrag): 
    601         if hasattr(self, 'EnvelopeWithTimePeriod'): 
    602             frag = Element(GML('EnvelopeWithTimePeriod')) 
    603             EnvelopeWithTimePeriod.toXML(self.EnvelopeWithTimePeriod, frag) 
    604             csmlFrag.append(frag) 
    605         return csmlFrag 
    606      
     655            frag = Element(CSML('domainComplement')) 
     656            if isinstance(self.domainComplement,DirectPositionList): 
     657                    subFrag=Element(CSML('DirectPositionList')) 
     658                    self.domainComplement.toXML(subFrag) 
     659                    frag.append(subFrag) 
     660                    csmlFrag.append(frag) 
     661            elif isinstance(self.domainComplement,Grid): 
     662                    subFrag=Element(CSML('Grid')) 
     663                    self.domainComplement.toXML(subFrag) 
     664                    frag.append(subFrag) 
     665                    csmlFrag.append(frag) 
     666        return csmlFrag 
     667 
     668 
    607669class EnvelopeWithTimePeriod: 
    608670    # CSML EnvelopeWithTimePeriod class 
     
    624686            self.timePosition2=timePosition2 
    625687    def fromXML(self,csmlFrag): 
    626         for frag in csmlFrag.getchildren(): 
     688        EnvTPfrag=csmlFrag.getchildren()[0] 
     689        for frag in EnvTPfrag.getchildren(): 
    627690            if frag.attrib.has_key('srsName'): 
    628691                self.srsName=frag.attrib['srsName'] 
     
    658721 
    659722         
    660 class direction: 
     723class DirectionVectorList: 
    661724    def __init__(self, horizontalAngle=None, verticalAngle=None): 
    662725        if horizontalAngle: 
     
    688751                frag.attrib['uom'] = self.uom_V 
    689752            csmlFrag.append(frag) 
     753 
    690754         
    691755class Position: 
     
    715779                self.time=frag.text 
    716780    def toXML(self,csmlFrag): 
     781        #subFrag = Element(CSML('Position')) 
    717782        if hasattr(self,'uomLabels'): 
    718783            csmlFrag.attrib['uomLabels'] = self.uomLabels 
     
    740805        for frag in csmlFrag.getchildren(): 
    741806            if frag.tag==CSML('direction'): 
    742                 self.direction=direction() 
    743                 direction.fromXML(self.direction,frag) 
     807                self.direction=DirectionVectorList() 
     808                DirectionVectorList.fromXML(self.direction,frag) 
    744809    def toXML(self, csmlFrag): 
    745810        Position.toXML(self,csmlFrag) 
    746811        if hasattr(self,'direction'): 
    747812            frag = Element(CSML('direction')) 
    748             direction.toXML(self.direction,frag) 
    749             csmlFrag.append(frag) 
    750                     
     813            DirectionVectorList.toXML(self.direction,frag) 
     814            csmlFrag.append(frag) 
     815        return csmlFrag 
     816         
     817 
     818 
    751819class Trajectory: 
    752820    def __init__(self,srsName=None,locations=None,times=None): 
     
    780848        return csmlFrag 
    781849 
    782 class valueComponents: 
    783     def __init__(self): 
    784         pass 
    785     def fromXML(self,csmlFrag): 
    786 #         for frag in csmlFrag.getchildren(): 
    787 #                 if frag.tag == GML('measure'): 
    788 #                     checkArrayAttrib(self,'members') 
    789 #                     self.members.append(....) 
    790 #                     self.members[-1].fromXML(frag) 
    791         pass 
     850class OrientedTrajectory(Trajectory): 
     851    def __init__(self, direction=None, *args,**kwargs): 
     852        Trajectory.__init__(self, *args,**kwargs) 
     853        if direction: 
     854             self.direction=direction 
     855    def fromXML(self,csmlFrag): 
     856        Trajectory.fromXML(self, csmlFrag) 
     857        for frag in csmlFrag.getchildren(): 
     858            if frag.tag==CSML('direction'): 
     859                self.direction=DirectionVectorList() 
     860                DirectionVectorList.fromXML(self.direction,frag) 
    792861    def toXML(self, csmlFrag): 
    793         return csmlFrag 
    794  
     862        Trajectory.toXML(self,csmlFrag) 
     863        if hasattr(self,'direction'): 
     864            frag = Element(CSML('direction')) 
     865            DirectionVectorList.toXML(self.direction,frag) 
     866            csmlFrag.append(frag) 
     867        return csmlFrag 
     868 
     869 
     870class Measure: 
     871    def __init__(self, uom=None): 
     872        if uom: 
     873            self.uom=uom 
     874    def fromXML(self,csmlFrag): 
     875                self.measure=csmlFrag.text 
     876                if csmlFrag.attrib.has_key('uom'): 
     877                    self.uom = csmlFrag.attrib['uom'] 
     878    def toXML(self, csmlFrag): 
     879        if hasattr(self,'measure'): 
     880            frag = Element(GML('measure')) 
     881            frag.text = self.measure 
     882            if hasattr(self,'uom'): 
     883                frag.attrib[('uom')] = self.uom 
     884            csmlFrag.append(frag) 
     885        return csmlFrag 
     886 
     887 
     888     
    795889class CompositeValue: 
    796     def __init__(self): 
    797         pass 
    798     def fromXML(self,csmlFrag): 
    799           for frag in csmlFrag.getchildren(): 
     890    def __init__(self, valueComponents=None): 
     891        if valueComponents: 
     892            self.valueComponents=valueComponents 
     893    def fromXML(self,csmlFrag): 
     894         
     895        for frag in csmlFrag.getchildren(): 
    800896            if frag.tag == GML('valueComponents'): 
    801                 self.valueComponents=valueComponents() 
    802                 valueComponents.fromXML(self.valueComponents,frag)  
     897                self.valueComponents = [] 
     898                for subFrag in frag.getchildren():                     
     899                    if subFrag.tag == GML('measure'): 
     900                        self.valueComponents.append(Measure()) 
     901                        self.valueComponents[-1].fromXML(subFrag) 
     902 
    803903    def toXML(self, csmlFrag): 
    804         if hasattr(self,'valueComponents'): 
     904         if hasattr(self,'valueComponents'): 
    805905            frag=Element(GML('valueComponents')) 
    806             valueComponents.toXML(self.valueComponents,frag) 
    807             csmlFrag.append(frag) 
    808         return csmlFrag 
     906            for valueComponent in self.valueComponents: 
     907                if isinstance(valueComponent,Measure): 
     908                    Measure.toXML(valueComponent,frag) 
     909            csmlFrag.append(frag) 
     910         return csmlFrag 
    809911     
    810 class rangeParameters: 
    811     def __init__(self, CompositeValue=None): 
    812         if CompositeValue: 
    813             self.CompositeValue=CompositeValue 
    814     def fromXML(self,csmlFrag): 
    815         for frag in csmlFrag.getchildren(): 
    816             if frag.tag == GML('CompositeValue'): 
    817                 self.CompositeValue=CompositeValue() 
    818                 CompositeValue.fromXML(self.CompositeValue,frag)  
    819     def toXML(self,csmlFrag): 
    820         if hasattr(self,'CompositeValue'): 
    821             frag=Element(GML('CompositeValue')) 
    822             CompositeValue.toXML(self.CompositeValue,frag) 
    823             csmlFrag.append(frag) 
    824         return csmlFrag 
     912 
    825913     
    826914class DataBlock: 
     
    835923        for frag in csmlFrag.getchildren(): 
    836924            if frag.tag == GML('rangeParameters'): 
    837                 self.rangeParameters=rangeParameters() 
    838                 rangeParameters.fromXML(self.rangeParameters,frag) 
     925                for subFrag in frag.getchildren(): 
     926                    if subFrag.tag==GML('CompositeValue'): 
     927                        self.rangeParameters=CompositeValue() 
     928                        CompositeValue.fromXML(self.rangeParameters,subFrag) 
     929            if frag.tag == GML('doubleOrNullTupleList'): 
     930                self.doubleOrNullTupleList=frag.text 
    839931    def toXML(self,csmlFrag): 
    840932        if hasattr(self, 'rangeParameters'): 
    841933            frag=Element(GML('rangeParameters')) 
    842             rangeParameters.toXML(self.rangeParameters, frag) 
    843             csmlFrag.append(frag) 
     934            subFrag=Element(GML('CompositeValue')) 
     935            CompositeValue.toXML(self.rangeParameters, subFrag) 
     936            frag.append(subFrag) 
     937            csmlFrag.append(frag) 
     938        if hasattr(self,'doubleOrNullTupleList'): 
     939            frag=Element(GML('doubleOrNullTupleList')) 
     940            frag.text=self.doubleOrNullTupleList 
     941            csmlFrag.append(frag) 
     942        return csmlFrag 
     943 
     944class Phenomenon(AbstractGML): 
     945    #class Obs& Measures: PhenomenonProperty 
     946    #Note, in this does not really inherit from AbstractGML, but for CMSL  
     947    #purposes it is used  to pick up the basic description, id, name attributes 
     948    def __init__(self,*args,**kwargs): 
     949         #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None. 
     950        self.MetaDataProperty=None 
     951        AbstractGML.__init__(self, self.MetaDataProperty,*args,**kwargs) 
     952    def fromXML(self,csmlFrag): 
     953        AbstractGML.fromXML(self,csmlFrag) 
     954 
     955class CompositePhenomenon(Phenomenon): 
     956    def __init__(self,*args,**kwargs): 
     957        Phenomenon.__init__(self,*args,**kwargs) 
     958    def fromXML(self,csmlFrag): 
     959        Phenomenon.fromXML(self,csmlFrag) 
     960    def toXML(self,csmlFrag): 
     961        Phenomenon.toXML(self,csmlFrag) 
    844962        return csmlFrag 
    845963     
    846  
    847     #class GML DataBlock 
    848 class rangeSet: 
    849 #class GML rangeSet 
    850  
    851         # rangeSet() 
     964class ParametrisedPhenomenon(Phenomenon): 
     965    def __init__(self,*args,**kwargs): 
     966        Phenomenon.__init__(self,*args,**kwargs) 
     967    def fromXML(self,csmlFrag): 
     968        Phenomenon.fromXML(self,csmlFrag) 
     969    def toXML(self,csmlFrag): 
     970        Phenomenon.toXML(self,csmlFrag) 
     971        return csmlFrag 
     972 
     973class RangeSet: 
     974#class GML RangeSet   
     975 
     976        # RangeSet() 
    852977        # +gml:ValueArray 
    853978        # +gml:_ScalarValueList 
    854979        # +gml:DataBlock 
    855980        # +gml:File 
    856     #class GML rangeSet 
    857     def __init__(self,QuantityList=None, DataBlock=None): 
     981    #class GML RangeSet 
     982    def __init__(self,QuantityList=None, DataBlock=None, ArrayDescriptor=None): 
    858983        if QuantityList: 
    859984            self.QuantityList=QuantityList 
    860985        if DataBlock: 
    861986            self.DataBlock=DataBlock 
     987        if ArrayDescriptor: 
     988            self.ArrayDescriptor=ArrayDescriptor 
     989             
    862990    def fromXML(self,csmlFrag): 
    863991        for frag in csmlFrag.getchildren(): 
     
    866994                if frag.attrib.has_key('uom'): 
    867995                    self.uom = frag.attrib['uom'] 
    868             if frag.tag==GML('DataBlock'): 
     996            elif frag.tag==GML('DataBlock'): 
    869997                self.DataBlock=DataBlock() 
    870998                DataBlock.fromXML(self.DataBlock, frag) 
     999            elif frag.tag == CSML('NetCDFExtract'): 
     1000                self.ArrayDescriptor=NetCDFExtract() 
     1001                NetCDFExtract.fromXML(self.ArrayDescriptor,frag) 
     1002            elif frag.tag == CSML('NASAmesExtract'): 
     1003                self.ArrayDescriptor=NASAAmesExtract() 
     1004                NASAAmesExtract.fromXML(self.ArrayDescriptor,frag) 
     1005            elif frag.tag == CSML('GRIBExtract'): 
     1006                self.ArrayDescriptor=GRIBExtract() 
     1007                GRIBExtract.fromXML(self.ArrayDescriptor,frag) 
    8711008    def toXML(self, csmlFrag): 
    8721009        if hasattr(self,'QuantityList'): 
     
    8801017            DataBlock.toXML(self.DataBlock,frag) 
    8811018            csmlFrag.append(frag) 
    882         return csmlFrag 
    883  
    884  
    885 class domainReference: 
    886     def __init__(self): 
    887         pass 
    888     def fromXML(self,csmlFrag): 
    889         for frag in csmlFrag.getchildren(): 
    890             if frag.tag==CSML('Position'): 
    891                 self.Position=Position() 
    892                 self.Position.fromXML(frag) 
    893             elif frag.tag == CSML('Trajectory'): 
    894                 self.Trajectory=Trajectory() 
    895                 self.Trajectory.fromXML(frag) 
    896             elif frag.tag==CSML('OrientedPosition'): 
    897                 self.OrientedPosition=OrientedPosition() 
    898                 self.OrientedPosition.fromXML(frag) 
    899             elif frag.tag == CSML('OrientedTrajectory'): 
    900                 self.OrientedTrajectory=OrientedTrajectory() 
    901                 self.OrientedTrajectory.fromXML(frag) 
    902  
    903     def toXML(self,csmlFrag): 
    904         if hasattr(self,'Position'): 
    905              frag = Element(CSML('Position')) 
    906              Position.toXML(self.Position,frag) 
    907              csmlFrag.append(frag) 
    908         elif hasattr(self,'Trajectory'): 
    909              frag = Element(CSML('Trajectory')) 
    910              Trajectory.toXML(self.Trajectory,frag) 
    911              csmlFrag.append(frag) 
    912         elif hasattr(self,'OrientedPosition'): 
    913              frag = Element(CSML('OrientedPosition')) 
    914              OrientedPosition.toXML(self.OrientedPosition,frag) 
    915              csmlFrag.append(frag) 
    916         elif hasattr(self,'OrientedTrajectory'): 
    917              frag = Element(CSML('OrientedTrajectory')) 
    918              OrientedTrajectory.toXML(self.OrientedTrajectory,frag) 
    919              csmlFrag.append(frag) 
    920         return csmlFrag 
    921  
    922 class domainComplement: 
    923     def __init__(self): 
    924         pass 
    925     def fromXML(self,csmlFrag): 
    926         for frag in csmlFrag.getchildren(): 
    927             if frag.tag==CSML('DirectPositionList'): 
    928                 self.DirectPositionList=frag.text 
    929                 if frag.attrib.has_key('srsName'): 
    930                     self.srsName=frag.attrib['srsName'] 
    931             elif frag.tag == CSML('Grid'): 
    932                 self.Grid=Grid() 
    933                 self.Grid.fromXML(frag) 
    934     def toXML(self,csmlFrag): 
    935         if hasattr(self,'DirectPositionList'): 
    936              frag = Element(CSML('DirectPositionList')) 
    937              frag.text=self.DirectPositionList 
    938              if hasattr(self, 'srsName'): 
    939                  frag.attrib['srsName']=self.srsName 
    940              csmlFrag.append(frag) 
    941         elif hasattr(self,'Grid'): 
    942              frag = Element(CSML('Grid')) 
    943              Grid.toXML(self.Grid,frag) 
    944              csmlFrag.append(frag) 
    945         return csmlFrag 
    946      
     1019        if hasattr(self,'ArrayDescriptor'): 
     1020            if isinstance(self.ArrayDescriptor,NetCDFExtract): 
     1021                frag=Element(CSML('NetCDFExtract')) 
     1022                NetCDFExtract.toXML(self.ArrayDescriptor,frag) 
     1023                csmlFrag.append(frag) 
     1024            elif isinstance(self.ArrayDescriptor,NASAAmesExtract): 
     1025                frag=Element(CSML('NASAAmesExtract')) 
     1026                NASAAmesExtract.toXML(self.ArrayDescriptor,frag) 
     1027                csmlFrag.append(frag) 
     1028            elif isinstance(self.ArrayDescriptor,GRIBExtract): 
     1029                frag=Element(CSML('GRIBExtract')) 
     1030                GRIBAmesExtract.toXML(self.ArrayDescriptor,frag) 
     1031                csmlFrag.append(frag) 
     1032                 
     1033        return csmlFrag 
     1034 
    9471035class PointDomain(AbstractDomain): 
    9481036    def __init__(self,*args,**kwargs): 
     
    10001088 
    10011089class PointFeature(AbstractStaticCoverageFeature): 
    1002  
    10031090    #CSML PointFeature class 
    10041091    #       PointFeature(AbstractStaticCoverageFeatureType): 
    1005     #       + gml:boundedBy[0..1] 
    10061092    #      +PointDomain 
    1007     #      +gml:rangeSet 
    1008     #      +gml:coverageFunction[0..1] 
    1009     #      +parameter:om:PhenomenonPropertyType 
    1010     def __init__(self,boundedBy=None, PointDomain=None,rangeSet=None,coverageFunction=None, parameter=None,*args,**kwargs): 
     1093    def __init__(self, PointDomain=None,*args,**kwargs): 
    10111094        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) 
    1012         if boundedBy: 
    1013             self.boundedBy=boundedBy 
    10141095        if PointDomain: 
    10151096            self.PointDomain=PointDomain 
    1016         if rangeSet: 
    1017             self.rangeSet=rangeSet 
    1018         if coverageFunction: 
    1019             self.coverageFunction=coverageFunction 
    1020         if parameter: 
    1021             self.parameter=parameter 
    10221097    def fromXML(self,csmlFrag): 
    10231098        AbstractStaticCoverageFeature.fromXML(self,csmlFrag) 
    1024  
    1025         for frag in csmlFrag.getchildren(): 
    1026             if frag.tag == GML('boundedBy'): 
    1027                 self.boundedBy = boundedBy() 
    1028                 self.boundedBy.fromXML(frag) 
     1099        for frag in csmlFrag.getchildren(): 
    10291100            if frag.tag == CSML('PointDomain'): 
    10301101                self.PointDomain = PointDomain() 
    10311102                self.PointDomain.fromXML(frag) 
    1032             if frag.tag == GML('rangeSet'): 
    1033                 self.rangeSet=rangeSet() 
    1034                 self.rangeSet.fromXML(frag) 
    1035             if frag.tag == CSML('parameter'): 
    1036                 self.parameter = frag.text 
    1037                 print frag.attrib 
    1038                 if frag.attrib.has_key(XLINK('href')): 
    1039                     self.href = frag.attrib[XLINK('href')] 
    1040  
    1041 # #             if frag.tag == GML('coverageFunction'): 
    1042 #                 checkArrayAttrib(self,'coverageFunction') 
    1043 #                 self.coverageFunction.append(frag.text) 
    1044 ##        else: 
    1045 ##            raise Exception('Unexpected element: "'+frag.tag+'"') 
    10461103    def toXML(self,csmlFrag): 
    10471104        AbstractStaticCoverageFeature.toXML(self,csmlFrag) 
    10481105        if hasattr(self,'PointDomain'): 
    1049              frag = Element(CSML('PointDomain')) 
    1050              PointDomain.toXML(self.PointDomain,frag) 
    1051              csmlFrag.append(frag) 
    1052         if hasattr(self,'rangeSet'): 
    1053              frag = Element(GML('rangeSet')) 
    1054              rangeSet.toXML(self.rangeSet,frag) 
    1055              csmlFrag.append(frag) 
    1056         if hasattr(self,'parameter'): 
    1057              frag = Element(CSML('parameter')) 
    1058              frag.text=self.parameter 
    1059              csmlFrag.append(frag) 
    1060         if hasattr(self,'href'): 
    1061              frag.attrib[XLINK('href')] = self.href 
    1062         csmlFrag.append(frag) 
     1106            frag = Element(CSML('PointDomain')) 
     1107            PointDomain.toXML(self.PointDomain,frag) 
     1108            if hasattr(self,'href'): 
     1109                frag.attrib[XLINK('href')] = self.href 
     1110            csmlFrag.append(frag) 
    10631111        return csmlFrag 
    10641112 
     
    10671115    #CSML PointSeriesFeature class 
    10681116    #       PointSeriesFeature(AbstractStaticCoverageFeatureType): 
    1069     #       + gml:boundedBy[0..1] 
    10701117    #      +PointSeriesDomain 
    1071     #      +gml:rangeSet 
    1072     #      +gml:coverageFunction[0..1] 
    1073     #      +parameter:om:PhenomenonPropertyType 
    1074     def __init__(self,boundedBy=None,PointSeriesDomain=None,rangeSet=None,coverageFunction=None, parameter=None,*args,**kwargs): 
     1118 
     1119    def __init__(self,PointSeriesDomain=None,*args,**kwargs): 
    10751120        AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs) 
    1076         if boundedBy: 
    1077             self.boundedBy 
    10781121        if PointSeriesDomain: 
    10791122            self.PointSeriesDomain=PointSeriesDomain 
    1080         if rangeSet: 
    1081             self.rangeSet=rangeSet 
    1082         if coverageFunction: 
    1083             self.coverageFunction=coverageFunction 
    1084         if parameter: 
    1085             self.parameter=parameter 
    10861123    def fromXML(self,csmlFrag): 
    10871124        AbstractSeriesCoverageFeature.fromXML(self,csmlFrag) 
    10881125        for frag in csmlFrag.getchildren(): 
    1089             if frag.tag == GML('boundedBy'): 
    1090                 self.boundedBy=boundedBy() 
    1091                 self.boundedBy.fromXML(frag) 
    10921126            if frag.tag == CSML('PointSeriesDomain'): 
    10931127                self.PointSeriesDomain = PointSeriesDomain() 
    10941128                self.PointSeriesDomain.fromXML(frag) 
    1095             if frag.tag == GML('rangeSet'): 
    1096                 self.rangeSet=rangeSet() 
    1097                 self.rangeSet.fromXML(frag) 
    1098             if frag.tag == CSML('parameter'): 
    1099                 self.parameter = frag.text 
    1100                 print frag.attrib 
    1101                 if frag.attrib.has_key(XLINK('href')): 
    1102                     self.href = frag.attrib[XLINK('href')] 
    11031129    def toXML(self,csmlFrag): 
    11041130        AbstractSeriesCoverageFeature.toXML(self,csmlFrag) 
    1105         if hasattr(self, 'boundedBy'): 
    1106             frag = Element(GML('boundedBy')) 
    1107             boundedBy.toXML(self.boundedBy,frag) 
    11081131        if hasattr(self,'PointSeriesDomain'): 
    11091132             frag = Element(CSML('PointSeriesDomain')) 
    11101133             PointSeriesDomain.toXML(self.PointSeriesDomain,frag) 
    11111134             csmlFrag.append(frag) 
    1112         if hasattr(self,'rangeSet'): 
    1113              frag = Element(GML('rangeSet')) 
    1114              rangeSet.toXML(self.rangeSet,frag) 
    1115              csmlFrag.append(frag) 
    1116         if hasattr(self,'parameter'): 
    1117              frag = Element(CSML('parameter')) 
    1118              frag.text=self.parameter 
    1119              csmlFrag.append(frag) 
    1120         if hasattr(self,'href'): 
    1121              frag.attrib[XLINK('href')] = self.href 
    1122         csmlFrag.append(frag) 
    11231135        return csmlFrag 
    11241136 
     
    11261138     #CSML ProfileFeature class 
    11271139    #       ProfileFeature(AbstractStaticCoverageFeature): 
    1128     #       + gml:boundedBy[0..1] 
    11291140    #      +ProfileDomain 
    1130     #      +gml:rangeSet 
    1131     #      +gml:coverageFunction[0..1] 
    1132     #      +parameter:om:PhenomenonPropertyType 
    1133     def __init__(self,boundedBy=None, ProfileDomain=None,rangeSet=None,coverageFunction=None, parameter=None,*args,**kwargs): 
     1141 
     1142    def __init__(self,ProfileDomain=None,*args,**kwargs): 
    11341143        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) 
    1135         if boundedBy: 
    1136             self.boundedBy=boundedBy 
    11371144        if ProfileDomain: 
    11381145            self.ProfileDomain=ProfileDomain 
    1139         if rangeSet: 
    1140             self.rangeSet=rangeSet 
    1141         if coverageFunction: 
    1142             self.coverageFunction=coverageFunction 
    1143         if parameter: 
    1144             self.parameter=parameter 
    11451146    def fromXML(self,csmlFrag): 
    11461147        AbstractStaticCoverageFeature.fromXML(self,csmlFrag) 
    1147  
    1148         for frag in csmlFrag.getchildren(): 
    1149             if frag.tag == GML('boundedBy'): 
    1150                 self.boundedBy = boundedBy() 
    1151                 self.boundedBy.fromXML(frag) 
     1148        for frag in csmlFrag.getchildren(): 
    11521149            if frag.tag == CSML('ProfileDomain'): 
    11531150                self.ProfileDomain = ProfileDomain() 
    11541151                self.ProfileDomain.fromXML(frag) 
    1155             if frag.tag == GML('rangeSet'): 
    1156                 self.rangeSet=rangeSet() 
    1157                 self.rangeSet.fromXML(frag) 
    1158             if frag.tag == CSML('parameter'): 
    1159                 self.parameter = frag.text 
    1160                 print frag.attrib 
    1161                 if frag.attrib.has_key(XLINK('href')): 
    1162                     self.href = frag.attrib[XLINK('href')] 
    1163  
    1164 # #             if frag.tag == GML('coverageFunction'): 
    1165 #                 checkArrayAttrib(self,'coverageFunction') 
    1166 #                 self.coverageFunction.append(frag.text) 
    1167 ##        else: 
    1168 ##            raise Exception('Unexpected element: "'+frag.tag+'"') 
    11691152    def toXML(self,csmlFrag): 
    11701153        AbstractStaticCoverageFeature.toXML(self,csmlFrag) 
     
    11731156             ProfileDomain.toXML(self.ProfileDomain,frag) 
    11741157             csmlFrag.append(frag) 
    1175         if hasattr(self,'rangeSet'): 
    1176              frag = Element(GML('rangeSet')) 
    1177              rangeSet.toXML(self.rangeSet,frag) 
     1158        return csmlFrag 
     1159 
     1160 
     1161class ProfileSeriesFeature(AbstractStaticCoverageFeature): 
     1162#CSML ProfileSeriesFeature class 
     1163    #       ProfileSeriesFeature(AbstractStaticCoverageFeature): 
     1164    #      +ProfileSeriesDomain 
     1165 
     1166    def __init__(self,ProfileDomain=None,*args,**kwargs): 
     1167        AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) 
     1168        if ProfileDomain: 
     1169            self.ProfileSeriesDomain=ProfileSeriesDomain 
     1170    def fromXML(self,csmlFrag): 
     1171        AbstractStaticCoverageFeature.fromXML(self,csmlFrag) 
     1172        for frag in csmlFrag.getchildren(): 
     1173            if frag.tag == CSML('ProfileSeriesDomain'): 
     1174                self.ProfileSeriesDomain = ProfileSeriesDomain() 
     1175                self.ProfileSeriesDomain.fromXML(frag) 
     1176    def toXML(self,csmlFrag): 
     1177        AbstractStaticCoverageFeature.toXML(self,csmlFrag) 
     1178        if hasattr(self,'ProfileSeriesDomain'): 
     1179             frag = Element(CSML('ProfileSeriesDomain')) 
     1180             ProfileSeriesDomain.toXML(self.ProfileSeriesDomain,frag) 
    11781181             csmlFrag.append(frag) 
    1179         if hasattr(self,'parameter'): 
    1180              frag = Element(CSML('parameter')) 
    1181              frag.text=self.parameter 
    1182              csmlFrag.append(frag) 
    1183         if hasattr(self,'href'): 
    1184              frag.attrib[XLINK('href')] = self.href 
    1185         csmlFrag.append(frag) 
    1186         return csmlFrag 
    1187  
    1188  
    1189 class ProfileSeriesFeature: 
    1190     def __init__(self): 
    1191         pass 
    1192     def fromXML(self,csmlFrag): 
    1193         pass 
    1194     def toXML(self,csmlFrag): 
    1195         return csmlFrag 
     1182        return csmlFrag 
     1183 
    11961184 
    11971185class GridFeature: 
     
    12201208     
    12211209class AbstractFeature(AbstractGML): 
    1222     def __init__(self): 
    1223         pass 
     1210    def __init__(self,boundedBy=None,*args,**kwargs): 
     1211        AbstractGML.__init__(self,*args,**kwargs) 
     1212        if boundedBy: 
     1213            self.boundedBy=boundedBy 
    12241214    def fromXML(self,csmlFrag): 
    12251215        AbstractGML.fromXML(self,csmlFrag) 
     1216        for frag in csmlFrag.getchildren(): 
     1217            if frag.tag == GML('boundedBy'): 
     1218                self.boundedBy = EnvelopeWithTimePeriod() 
     1219                self.boundedBy.fromXML(frag) 
    12261220    def toXML(self,csmlFrag): 
    12271221        AbstractGML.toXML(self,csmlFrag) 
    1228         return csmlFrag 
    1229  
    1230  
     1222        if hasattr(self,'boundedBy'): 
     1223             superfrag = Element(GML('boundedBy')) 
     1224             frag = Element (GML('EnvelopeWithTimePeriod')) 
     1225             EnvelopeWithTimePeriod.toXML(self.boundedBy,frag) 
     1226             superfrag.append(frag) 
     1227             csmlFrag.append(superfrag) 
     1228        return csmlFrag 
     1229 
     1230  
    12311231 
    12321232class AbstractFeatureCollection(AbstractFeature): 
     
    12691269    def toXML(self,csmlFrag): 
    12701270        AbstractFeature.toXML(self,csmlFrag) 
    1271         i=0 
    12721271        for member in self.members: 
    12731272            if isinstance(member,PointFeature): 
    12741273                superFrag=Element(GML('FeatureMember')) 
    12751274                frag=Element(CSML('PointFeature')) 
    1276                 PointFeature.toXML(self.members[i],frag) 
     1275                PointFeature.toXML(member,frag) 
    12771276                superFrag.append(frag) 
    12781277                csmlFrag.append(superFrag) 
     
    12801279                superFrag=Element(GML('FeatureMember')) 
    12811280                frag=Element(CSML('ProfileFeature')) 
    1282                 ProfileFeature.toXML(self.members[i],frag) 
     1281                ProfileFeature.toXML(member,frag) 
    12831282                superFrag.append(frag) 
    12841283                csmlFrag.append(superFrag) 
     
    12861285                superFrag=Element(GML('FeatureMember')) 
    12871286                frag=Element(CSML('GridFeature')) 
    1288                 GridFeature.toXML(self.members[i],frag) 
     1287                GridFeature.toXML(member,frag) 
    12891288                superFrag.append(frag) 
    12901289                csmlFrag.append(superFrag) 
     
    12921291                superFrag=Element(GML('FeatureMember')) 
    12931292                frag=Element(CSML('PointSeriesFeature')) 
    1294                 PointSeriesFeature.toXML(self.members[i],frag) 
     1293                PointSeriesFeature.toXML(member,frag) 
    12951294                superFrag.append(frag) 
    12961295                csmlFrag.append(superFrag) 
     
    12981297                superFrag=Element(GML('FeatureMember')) 
    12991298                frag=Element(CSML('ProfileSeriesFeature')) 
    1300                 ProfileSeriesFeature.toXML(self.members[i],frag) 
     1299                ProfileSeriesFeature.toXML(member,frag) 
    13011300                superFrag.append(frag) 
    13021301                csmlFrag.append(superFrag) 
     
    13041303                superFrag=Element(GML('FeatureMember')) 
    13051304                frag=Element(CSML('GridSeriesFeature')) 
    1306                 GridSeriesFeature.toXML(self.members[i],frag) 
     1305                GridSeriesFeature.toXML(member,frag) 
    13071306                superFrag.append(frag) 
    13081307                csmlFrag.append(superFrag) 
     
    13101309                superFrag=Element(GML('FeatureMember')) 
    13111310                frag=Element(CSML('TrajectoryFeature')) 
    1312                 TrajectoryFeature.toXML(self.members[i],frag) 
     1311                TrajectoryFeature.toXML(member,frag) 
    13131312                superFrag.append(frag) 
    13141313                csmlFrag.append(superFrag) 
    1315             i=i+1 
    13161314         
    13171315        return csmlFrag 
     
    13201318    """GML FeatureCollection class 
    13211319        FeatureCollection() 
    1322         +boundedBy[1] 
    13231320        +FeatureMembers[0..*] 
    13241321    """ 
    1325     def __init__(self,boundedBy=None): 
    1326         if boundedBy: 
    1327             self.boundedBy=boundedBy 
    1328     def fromXML(self,csmlFrag): 
    1329         for frag in csmlFrag.getchildren(): 
    1330             if frag.tag == GML('boundedBy'): 
    1331                 self.boundedBy=boundedBy() 
    1332                 boundedBy.fromXML(self.boundedBy,frag) 
     1322    def __init__(self): 
     1323        AbstractFeatureCollection.__init__(self) 
     1324    def fromXML(self,csmlFrag): 
    13331325        AbstractFeatureCollection.fromXML(self,csmlFrag) 
    13341326    def toXML(self,csmlFrag): 
    1335         if hasattr(self,'boundedBy'): 
    1336             frag = Element(GML('boundedBy')) 
    1337             boundedBy.toXML(self.boundedBy, frag) 
    1338             csmlFrag.append(frag) 
    13391327        AbstractFeatureCollection.toXML(self,csmlFrag) 
    13401328        return csmlFrag 
Note: See TracChangeset for help on using the changeset viewer.