1 | #!/usr/bin/env python |
---|
2 | |
---|
3 | from cElementTree import * |
---|
4 | import sys |
---|
5 | from UserString import MutableString |
---|
6 | |
---|
7 | # NOTES |
---|
8 | # ~~~~~ |
---|
9 | # |
---|
10 | # (1) Testing existence in cElementTree. |
---|
11 | # ElementTree structures evaluate as false unless they have child elements: |
---|
12 | # |
---|
13 | # >>> b=Element('blah') |
---|
14 | # >>> dump(b) |
---|
15 | # <blah /> |
---|
16 | # >>> if b: print 'non-null' |
---|
17 | # |
---|
18 | # >>> b.append(Element('moreblah')) |
---|
19 | # >>> dump(b) |
---|
20 | # <blah><moreblah /></blah> |
---|
21 | # >>> if b: print 'non-null' |
---|
22 | # |
---|
23 | # non-null |
---|
24 | # |
---|
25 | # |
---|
26 | # For this reason, existence tests should always be done as: |
---|
27 | # |
---|
28 | # >>> b=Element('blah') |
---|
29 | # >>> if b is not None: print 'non-null' |
---|
30 | # |
---|
31 | # non-null |
---|
32 | # |
---|
33 | # (2) Namesmape processing |
---|
34 | # Everything is namespace qualified in ElementTree. |
---|
35 | # The module provides a utility class QName(uri,tag) with QName().text providing |
---|
36 | # the text representation "{uri}tag" used by ElementTree. Instead, a lightweight |
---|
37 | # equivalent function myQName(uri,tag) has been defined here to do the |
---|
38 | # same thing. Also, CSML(tag), GML(tag), XLINK(tag) provide even shorter cuts. |
---|
39 | # |
---|
40 | # (3) Mandatory elements |
---|
41 | # The basic pattern used in the toXML() method here is to look for those |
---|
42 | # attributes of the class that are expected and add to the XML fragment under |
---|
43 | # construction. Where those attributes are mandatory, however, (i.e. UML |
---|
44 | # multiplicity one), the test is not performed - they are assumed to exist. |
---|
45 | # This eliminates an 'if' statement, but will geneate an error if they don't |
---|
46 | # exist. |
---|
47 | |
---|
48 | nsCSML = 'http://ndg.nerc.ac.uk/csml' |
---|
49 | nsGML = 'http://www.opengis.net/gml' |
---|
50 | nsOM = 'http://www.opengis.net/om' |
---|
51 | nsXLINK = 'http://www.w3.org/1999/xlink' |
---|
52 | nsXML = 'http://ndg.nerc.ac.uk/csml' |
---|
53 | |
---|
54 | def myQName(uri,tag): |
---|
55 | return "{"+uri+"}"+tag |
---|
56 | |
---|
57 | def CSML(tag): |
---|
58 | return myQName(nsCSML,tag) |
---|
59 | |
---|
60 | def GML(tag): |
---|
61 | return myQName(nsGML,tag) |
---|
62 | |
---|
63 | def XLINK(tag): |
---|
64 | return myQName(nsXLINK,tag) |
---|
65 | |
---|
66 | def XML(tag): |
---|
67 | return myQName(nsXML,tag) |
---|
68 | |
---|
69 | def OM(tag): |
---|
70 | return myQName(nsOM,tag) |
---|
71 | |
---|
72 | def checkArrayAttrib(obj,attrib): |
---|
73 | if not hasattr(obj,attrib) or not isinstance(getattr(obj,attrib),list): |
---|
74 | setattr(obj,attrib,[]) |
---|
75 | |
---|
76 | def checkMandatory(obj,*args): |
---|
77 | #check mandatory attributes/elements are present. |
---|
78 | #should be called at the *end* of each fromXML method if that object has mandatory attributes |
---|
79 | for arg in args: |
---|
80 | if not hasattr(obj, arg): |
---|
81 | objtype = str(obj) |
---|
82 | print 'Parse error: Mandatory value missing: ' + str(arg) |
---|
83 | if hasattr(obj,'id'): |
---|
84 | print 'See element with gml:id = ' + obj.id |
---|
85 | sys.exit() |
---|
86 | |
---|
87 | ##class TemplateClass(Base): |
---|
88 | ## def __init__(self,myarg=None,*args,**kwargs): |
---|
89 | ## Base.__init__(self,*args,**kwargs) |
---|
90 | ## # code specific to TemplateClass |
---|
91 | ## def fromXML(self,csmlFrag): |
---|
92 | ## Base.fromXML(self,csmlFrag) |
---|
93 | ## # code specific to TemplateClass |
---|
94 | ## def toXML(self,csmlFrag): |
---|
95 | ## csmlFrag = Base.toXML(self,csmlFrag) |
---|
96 | ## # code specific to TemplateClass |
---|
97 | ## return csmlFrag |
---|
98 | |
---|
99 | class MetaDataProperty: |
---|
100 | """Class representing metadata property (gmlBase.xsd) |
---|
101 | MetaDataProperty: |
---|
102 | +href: URI |
---|
103 | +text: str |
---|
104 | """ |
---|
105 | def __init__(self,href=None, text=None): |
---|
106 | if href: |
---|
107 | self.href = href |
---|
108 | if text: |
---|
109 | self.text=text |
---|
110 | def fromXML(self,csmlFrag): |
---|
111 | if csmlFrag.attrib.has_key(XLINK('href')): |
---|
112 | self.href = csmlFrag.attrib[XLINK('href')] |
---|
113 | for frag in csmlFrag.getchildren(): |
---|
114 | if frag.tag == CSML('text'): |
---|
115 | checkArrayAttrib(self,'text') |
---|
116 | self.text.append(frag.text) |
---|
117 | def toXML(self,csmlFrag): |
---|
118 | if hasattr(self,'href'): |
---|
119 | csmlFrag.attrib[XLINK('href')] = self.href |
---|
120 | if hasattr(self,'text'): |
---|
121 | for txt in self.text: |
---|
122 | frag = Element(CSML('text')) |
---|
123 | frag.text=txt |
---|
124 | csmlFrag.append(frag) |
---|
125 | return csmlFrag |
---|
126 | |
---|
127 | class Description(MutableString): |
---|
128 | """Class representing a GML description element |
---|
129 | Description(string): |
---|
130 | """ |
---|
131 | def __init__(self,val=''): |
---|
132 | MutableString.__init__(self,val) |
---|
133 | def fromXML(self,csmlFrag): |
---|
134 | self.data = csmlFrag.text |
---|
135 | def toXML(self,csmlFrag): |
---|
136 | csmlFrag.text = self.data |
---|
137 | return csmlFrag |
---|
138 | |
---|
139 | class Name(MutableString): |
---|
140 | """Class representing a GML name element |
---|
141 | Name(string): |
---|
142 | +codeSpace[0..1]: anyURI |
---|
143 | """ |
---|
144 | def __init__(self,val='',codeSpace=None): |
---|
145 | MutableString.__init__(self,val) |
---|
146 | if val: |
---|
147 | self.val=val |
---|
148 | if codeSpace: |
---|
149 | self.codeSpace = codeSpace |
---|
150 | def fromXML(self,csmlFrag): |
---|
151 | self.val = csmlFrag.text |
---|
152 | if csmlFrag.attrib.has_key('codeSpace'): |
---|
153 | self.codeSpace = csmlFrag.attrib['codeSpace'] |
---|
154 | def toXML(self,csmlFrag): |
---|
155 | if hasattr(self, 'codeSpace'): |
---|
156 | csmlFrag.attrib['codeSpace'] = self.codeSpace |
---|
157 | if hasattr(self, 'val'): |
---|
158 | csmlFrag.text = self.val |
---|
159 | |
---|
160 | return csmlFrag |
---|
161 | |
---|
162 | class AbstractGML: |
---|
163 | """Base abstract GML type |
---|
164 | |
---|
165 | AbstractGML: |
---|
166 | +id[0..1]: ID |
---|
167 | +metaDataProperty[0..*]: MetaDataProperty |
---|
168 | +description[0..1]: Description |
---|
169 | +name[0..*]: Name |
---|
170 | """ |
---|
171 | def __init__(self,gmlid=None,metaDataProperty=[],description=None,name=[],*args,**kwargs): |
---|
172 | if gmlid: |
---|
173 | self.id = gmlid |
---|
174 | if metaDataProperty: |
---|
175 | self.metaDataProperty = metaDataProperty |
---|
176 | if description: |
---|
177 | self.description = description |
---|
178 | if name: |
---|
179 | self.name = name |
---|
180 | def fromXML(self,csmlFrag): |
---|
181 | if csmlFrag.attrib.has_key(GML('id')): |
---|
182 | self.id = csmlFrag.attrib[GML('id')] |
---|
183 | for frag in csmlFrag.getchildren(): |
---|
184 | if frag.tag == GML('metaDataProperty'): |
---|
185 | checkArrayAttrib(self,'metaDataProperty') |
---|
186 | self.metaDataProperty.append(MetaDataProperty()) |
---|
187 | self.metaDataProperty[-1].fromXML(frag) |
---|
188 | elif frag.tag == GML('description'): |
---|
189 | self.description = Description() |
---|
190 | self.description.fromXML(frag) |
---|
191 | elif frag.tag == GML('name'): |
---|
192 | checkArrayAttrib(self,'name') |
---|
193 | self.name.append(Name()) |
---|
194 | self.name[-1].fromXML(frag) |
---|
195 | def toXML(self,csmlFrag): |
---|
196 | if hasattr(self,'id'): |
---|
197 | csmlFrag.attrib[GML('id')] = self.id |
---|
198 | if hasattr(self,'metaDataProperty'): |
---|
199 | for md in self.metaDataProperty: |
---|
200 | frag = Element(GML('metaDataProperty')) |
---|
201 | frag = MetaDataProperty.toXML(md,frag) |
---|
202 | csmlFrag.append(frag) |
---|
203 | if hasattr(self,'description'): |
---|
204 | frag = Element(GML('description')) |
---|
205 | frag = Description.toXML(self.description,frag) |
---|
206 | csmlFrag.append(frag) |
---|
207 | if hasattr(self,'name'): |
---|
208 | for name in self.name: |
---|
209 | frag = Element(GML('name')) |
---|
210 | frag = Name.toXML(name,frag) |
---|
211 | csmlFrag.append(frag) |
---|
212 | return csmlFrag |
---|
213 | |
---|
214 | |
---|
215 | class SRSReferenceGroup: |
---|
216 | # class to represeent gml:SRSReferenceGroup |
---|
217 | # class SRSReferenceGroup: |
---|
218 | # +srsName[0...]:anyURI |
---|
219 | # # +srsDimension[0...1]:positiveInteger |
---|
220 | def __init__(self,srsName=None,srsDimension=None,*args,**kwargs): |
---|
221 | if srsName: |
---|
222 | self.srsName=srsName |
---|
223 | if srsDimension: |
---|
224 | self.srsDimension=srsDimension |
---|
225 | def fromXML(self,csmlFrag): |
---|
226 | if csmlFrag.attrib.has_key('srsName'): |
---|
227 | self.srsName=csmlFrag.attrib['srsName'] |
---|
228 | if csmlFrag.attrib.has_key('srsDimension'): |
---|
229 | self.srsDimension=csmlFrag.attrib['srsDimension'] |
---|
230 | def toXML(self,csmlFrag): |
---|
231 | if hasattr(self,'srsName'): |
---|
232 | csmlFrag.attrib['srsName']= self.srsName |
---|
233 | if hasattr(self,'srsDimension'): |
---|
234 | csmlFrag.attrib['srsDimension']= self.srsDimension |
---|
235 | return csmlFrag |
---|
236 | |
---|
237 | class SRSInformationGroup: |
---|
238 | # class to represeent gml:SRSInformationGroup |
---|
239 | # class SRSReferenceGroup: |
---|
240 | # +uomLabels[0...]:NCNameList |
---|
241 | # +axisLabels[0...]:NCNameList |
---|
242 | def __init__(self,uomLabels=None,axisLabels=None): |
---|
243 | if uomLabels: |
---|
244 | self.uomLabels=uomLabels |
---|
245 | if axisLabels: |
---|
246 | self.axisLabels=axisLabels |
---|
247 | def fromXML(self,csmlFrag): |
---|
248 | if csmlFrag.attrib.has_key('uomLabels'): |
---|
249 | self.uomLabels=csmlFrag.attrib['uomLabels'] |
---|
250 | if csmlFrag.attrib.has_key('axisLabels'): |
---|
251 | self.axisLabels=csmlFrag.attrib['axisLabels'] |
---|
252 | def toXML(self,csmlFrag): |
---|
253 | if hasattr(self,'axisLabels'): |
---|
254 | csmlFrag.attrib['axisLabels']= self.axisLabels |
---|
255 | if hasattr(self,'uomLabels'): |
---|
256 | csmlFrag.attrib['uomLabels']= self.uomLabels |
---|
257 | return csmlFrag |
---|
258 | |
---|
259 | class AssociationAttributeGroup: |
---|
260 | '''Class to represent gml:AssociationAttributeGroup which is based on the xlink 'simplelink' attribute group (not implemented) |
---|
261 | #class AssociationAttributeGroup |
---|
262 | +xlink:href[0..1]:string |
---|
263 | +xlink:role[0..1]:string |
---|
264 | +xlink:arcrole[0..1]:string |
---|
265 | +xlink:title[0..1]:string |
---|
266 | +xlink:show[0..1]:string |
---|
267 | +xlink:actuate[0..1]:string ''' |
---|
268 | def __init__(self, href=None, role=None,arcrole=None,title=None,show=None,actuate=None): |
---|
269 | if href: |
---|
270 | self.href=href |
---|
271 | if role: |
---|
272 | self.role=role |
---|
273 | if arcrole: |
---|
274 | self.arcrole=arcrole |
---|
275 | if title: |
---|
276 | self.title=title |
---|
277 | if show: |
---|
278 | self.show=show |
---|
279 | if actuate: |
---|
280 | self.actuate=actuate |
---|
281 | def fromXML(self,csmlFrag): |
---|
282 | if csmlFrag.attrib.has_key(XLINK('href')): |
---|
283 | self.href=csmlFrag.attrib[XLINK('href')] |
---|
284 | if csmlFrag.attrib.has_key(XLINK('role')): |
---|
285 | self.role=csmlFrag.attrib[XLINK('role')] |
---|
286 | if csmlFrag.attrib.has_key(XLINK('arcrole')): |
---|
287 | self.arcrole=csmlFrag.attrib[XLINK('arcrole')] |
---|
288 | if csmlFrag.attrib.has_key(XLINK('title')): |
---|
289 | self.title=csmlFrag.attrib[XLINK('title')] |
---|
290 | if csmlFrag.attrib.has_key(XLINK('show')): |
---|
291 | self.show=csmlFrag.attrib[XLINK('show')] |
---|
292 | if csmlFrag.attrib.has_key(XLINK('actuate')): |
---|
293 | self.actuate=csmlFrag.attrib[XLINK('actuate')] |
---|
294 | |
---|
295 | def toXML(self,csmlFrag): |
---|
296 | if hasattr(self,'href'): |
---|
297 | csmlFrag.attrib[XLINK('href')]= self.href |
---|
298 | if hasattr(self,'role'): |
---|
299 | csmlFrag.attrib[XLINK('role')]= self.role |
---|
300 | if hasattr(self,'arcrole'): |
---|
301 | csmlFrag.attrib[XLINK('arcrole')]= self.arcrole |
---|
302 | if hasattr(self,'title'): |
---|
303 | csmlFrag.attrib[XLINK('title')]= self.title |
---|
304 | if hasattr(self,'show'): |
---|
305 | csmlFrag.attrib[XLINK('show')]= self.show |
---|
306 | if hasattr(self,'actuate'): |
---|
307 | csmlFrag.attrib[XLINK('actuate')]= self.actuate |
---|
308 | |
---|
309 | return csmlFrag |
---|
310 | |
---|
311 | class DirectPosition(SRSReferenceGroup,SRSInformationGroup): |
---|
312 | def __init__(self,vals='',*args,**kwargs): |
---|
313 | SRSReferenceGroup.__init__(self,*args,**kwargs) |
---|
314 | SRSInformationGroup.__init__(self,*args,**kwargs) |
---|
315 | if vals: |
---|
316 | self.vals=vals |
---|
317 | def fromXML(self,csmlFrag): |
---|
318 | SRSReferenceGroup.fromXML(self,csmlFrag) |
---|
319 | SRSInformationGroup.fromXML(self,csmlFrag) |
---|
320 | self.vals=csmlFrag.text |
---|
321 | def toXML(self,csmlFrag): |
---|
322 | SRSReferenceGroup.toXML(self,csmlFrag) |
---|
323 | SRSInformationGroup.toXML(self,csmlFrag) |
---|
324 | if hasattr(self,'vals'): |
---|
325 | csmlFrag.text=self.vals |
---|
326 | return csmlFrag |
---|
327 | |
---|
328 | class Definition(AbstractGML): |
---|
329 | #Class Definition(AbstractGML), restricts AbstractGML |
---|
330 | #gml:id is mandatory |
---|
331 | # |
---|
332 | # Definition(AbstractGML): |
---|
333 | # +id[1]: ID |
---|
334 | |
---|
335 | def __init__(self,*args,**kwargs): |
---|
336 | AbstractGML.__init__(self,*args,**kwargs) |
---|
337 | def fromXML(self,csmlFrag): |
---|
338 | AbstractGML.fromXML(self,csmlFrag) |
---|
339 | #checkMandatory(self, 'id') |
---|
340 | if not hasattr(self,'id'): |
---|
341 | #print 'gml:id mandatory value missing in ' + csmlFrag.tag |
---|
342 | #how best to handle the case where there is an xlink to the definition, |
---|
343 | #so the reference to the definition object doesn't actually have an id |
---|
344 | pass |
---|
345 | def toXML(self,csmlFrag): |
---|
346 | csmlFrag=AbstractGML.toXML(self,csmlFrag) |
---|
347 | return csmlFrag |
---|
348 | |
---|
349 | class CodeType(MutableString): |
---|
350 | #Class for gml:CodeType element |
---|
351 | |
---|
352 | #CodeType(MutableString) |
---|
353 | # +codeSpace[0..1]:anyURI |
---|
354 | def __init__(self,val='',codeSpace=None): |
---|
355 | MutableString.__init__(self,val) |
---|
356 | if codeSpace: |
---|
357 | self.codeSpace = codeSpace |
---|
358 | def fromXML(self,csmlFrag): |
---|
359 | self.data = csmlFrag.text |
---|
360 | if csmlFrag.attrib.has_key('codeSpace'): |
---|
361 | self.codeSpace = csmlFrag.attrib['codeSpace'] |
---|
362 | def toXML(self,csmlFrag): |
---|
363 | csmlFrag.text = self.data |
---|
364 | if hasattr(self,'codeSpace'): |
---|
365 | csmlFrag.attrib['codeSpace'] = self.codeSpace |
---|
366 | return csmlFrag |
---|
367 | |
---|
368 | |
---|
369 | |
---|
370 | class TimeIntervalLength: |
---|
371 | # class for gml:TimeIntervalLength (decimal) |
---|
372 | # n.b. have not implemented 'decimal' class |
---|
373 | # +unit[1]: gml:UnitType |
---|
374 | # +radix[0...1]: posint |
---|
375 | # +factor[0...1] :int |
---|
376 | def __init__(self, unit=None, radix=None, factor=None,data=None): |
---|
377 | if unit: |
---|
378 | self.unit =unit |
---|
379 | if radix: |
---|
380 | self.radix=radix |
---|
381 | if factor: |
---|
382 | self.factor=factor |
---|
383 | if data: |
---|
384 | self.data=data |
---|
385 | def fromXML(self, csmlFrag): |
---|
386 | self.data = csmlFrag.text |
---|
387 | if csmlFrag.attrib.has_key('unit'): |
---|
388 | self.unit=csmlFrag.attrib['unit'] |
---|
389 | if csmlFrag.attrib.has_key('radix'): |
---|
390 | self.radix=csmlFrag.attrib['radix'] |
---|
391 | if csmlFrag.attrib.has_key('factor'): |
---|
392 | self.factor=csmlFrag.attrib['factor'] |
---|
393 | checkMandatory(self,'unit') |
---|
394 | def toXML(self,csmlFrag): |
---|
395 | csmlFrag.text=self.data |
---|
396 | if hasattr(self,'unit'): |
---|
397 | csmlFrag.attrib['unit'] = self.unit |
---|
398 | if hasattr(self,'radix'): |
---|
399 | csmlFrag.attrib['radix'] = self.radix |
---|
400 | if hasattr(self,'factor'): |
---|
401 | csmlFrag.attrib['factor'] = self.factor |
---|
402 | return csmlFrag |
---|
403 | |
---|
404 | class TimeCoordinateSystem(Definition): |
---|
405 | #Class for csml:TimeCoordinateSystem(gml:Definition) element |
---|
406 | # + originPosition |
---|
407 | # + interval |
---|
408 | |
---|
409 | ### TO DO! |
---|
410 | #This is wrong, interval should be of type TimeIntervalLength |
---|
411 | # <element name="originPosition" type="gml:TimePositionType"/> |
---|
412 | # <element name="origin" type="gml:TimeInstantPropertyType"/> |
---|
413 | # </choice> |
---|
414 | # <element name="interval" type="gml:TimeIntervalLengthType"/> |
---|
415 | #Or is it okay as is.?? |
---|
416 | |
---|
417 | def __init__(self,originPosition=None,interval=None,unit=None,*args,**kwargs): |
---|
418 | Definition.__init__(self,*args,**kwargs) |
---|
419 | if originPosition: |
---|
420 | self.originPosition=originPosition |
---|
421 | if interval: |
---|
422 | self.interval=interval |
---|
423 | if unit: |
---|
424 | self.unit=unit |
---|
425 | def fromXML(self,csmlFrag): |
---|
426 | Definition.fromXML(self,csmlFrag) |
---|
427 | for frag in csmlFrag.getchildren(): |
---|
428 | if frag.tag == GML('originPosition'): |
---|
429 | self.originPosition=frag.text |
---|
430 | elif frag.tag == GML('interval'): |
---|
431 | self.interval=frag.text |
---|
432 | self.unit = frag.attrib['units'] |
---|
433 | def toXML(self,csmlFrag): |
---|
434 | Definition.toXML(self,csmlFrag) |
---|
435 | if hasattr(self, 'originPosition'): |
---|
436 | frag=Element(GML('originPosition')) |
---|
437 | frag.text=self.originPosition |
---|
438 | csmlFrag.append(frag) |
---|
439 | if hasattr(self, 'interval'): |
---|
440 | frag=Element(GML('interval')) |
---|
441 | frag.text=self.interval |
---|
442 | if hasattr(self,'unit'): |
---|
443 | frag.attrib['units']=self.unit |
---|
444 | csmlFrag.append(frag) |
---|
445 | return csmlFrag |
---|
446 | |
---|
447 | |
---|
448 | class AbstractReferenceSystemBase(Definition): |
---|
449 | # AbstractReferenceSystemBase(Definition) |
---|
450 | # +gml:MetaDataProperty[0...*]:MetaDataProperty |
---|
451 | # +gml:remarks[0...1] |
---|
452 | # +gml:srsName [?] |
---|
453 | |
---|
454 | |
---|
455 | def __init__(self,remarks=None,srsName=None,*args,**kwargs): |
---|
456 | Definition.__init__(self, *args, **kwargs) |
---|
457 | if remarks: |
---|
458 | self.remarks=remarks |
---|
459 | if srsName: |
---|
460 | self.srsName=srsName |
---|
461 | def fromXML(self,csmlFrag): |
---|
462 | Definition.fromXML(self, csmlFrag) |
---|
463 | for frag in csmlFrag.getchildren(): |
---|
464 | if frag.tag==GML('remarks'): |
---|
465 | self.remarks=frag.text |
---|
466 | if frag.tag==GML('srsName'): |
---|
467 | self.srsName=frag.text |
---|
468 | def toXML(self,csmlFrag): |
---|
469 | Definition.toXML(self, csmlFrag) |
---|
470 | if hasattr(self,'remarks'): |
---|
471 | frag = Element(GML('remarks')) |
---|
472 | frag.text=self.remarks |
---|
473 | csmlFrag.append(frag) |
---|
474 | if hasattr(self,'srsName'): |
---|
475 | frag = Element(GML('srsName')) |
---|
476 | frag.text=self.srsName |
---|
477 | csmlFrag.append(frag) |
---|
478 | return csmlFrag |
---|
479 | |
---|
480 | class AbstractReferenceSystem(AbstractReferenceSystemBase): |
---|
481 | #AbstractReferenceSystem(AbstractReferenceSystemBase): |
---|
482 | def __init__(self,*args,**kwargs): |
---|
483 | AbstractReferenceSystemBase.__init__(self, *args, **kwargs) |
---|
484 | def fromXML(self,csmlFrag): |
---|
485 | AbstractReferenceSystemBase.fromXML(self, csmlFrag) |
---|
486 | def toXML(self,csmlFrag): |
---|
487 | AbstractReferenceSystemBase.toXML(self, csmlFrag) |
---|
488 | return csmlFrag |
---|
489 | |
---|
490 | |
---|
491 | class AbstractCRS(AbstractReferenceSystem): |
---|
492 | #AbstractCRS(AbstractReferenceSystem): |
---|
493 | |
---|
494 | def __init__(self,*args,**kwargs): |
---|
495 | AbstractReferenceSystem.__init__(self, *args, **kwargs) |
---|
496 | def fromXML(self,csmlFrag): |
---|
497 | AbstractReferenceSystem.fromXML(self, csmlFrag) |
---|
498 | def toXML(self,csmlFrag): |
---|
499 | AbstractReferenceSystem.toXML(self, csmlFrag) |
---|
500 | return csmlFrag |
---|
501 | |
---|
502 | |
---|
503 | class AbstractTimeReferenceSystem(Definition): |
---|
504 | def __init__(self,*args,**kwargs): |
---|
505 | Definition.__init__(self, *args, **kwargs) |
---|
506 | def fromXML(self,csmlFrag): |
---|
507 | Definition.fromXML(self, csmlFrag) |
---|
508 | def toXML(self,csmlFrag): |
---|
509 | Definition.toXML(self, csmlFrag) |
---|
510 | return csmlFrag |
---|
511 | |
---|
512 | |
---|
513 | class AbstractCoordinateReferenceSystem(AbstractCRS): |
---|
514 | def __init__(self,*args,**kwargs): |
---|
515 | AbstractCRS.__init__(self, *args, **kwargs) |
---|
516 | def fromXML(self,csmlFrag): |
---|
517 | AbstractCRS.fromXML(self, csmlFrag) |
---|
518 | def toXML(self,csmlFrag): |
---|
519 | AbstractCRS.toXML(self, csmlFrag) |
---|
520 | return csmlFrag |
---|
521 | |
---|
522 | |
---|
523 | class DictionaryEntry(AssociationAttributeGroup,AbstractGML): |
---|
524 | def __init__(self,*args,**kwargs): |
---|
525 | pass |
---|
526 | def fromXML(self,csmlFrag): |
---|
527 | pass |
---|
528 | def toXML(self,csmlFrag): |
---|
529 | return csmlFrag |
---|
530 | |
---|
531 | class DatumRef(DictionaryEntry): |
---|
532 | def __init__(self,*args,**kwargs): |
---|
533 | DictionaryEntry.__init__(self, *args, **kwargs) |
---|
534 | def fromXML(self,csmlFrag): |
---|
535 | DictionaryEntry.fromXML(self, csmlFrag) |
---|
536 | def toXML(self,csmlFrag): |
---|
537 | DictionaryEntry.toXML(self, csmlFrag) |
---|
538 | return csmlFrag |
---|
539 | |
---|
540 | class AbstractDatumBase(Definition): |
---|
541 | # <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/> |
---|
542 | # <element ref="gml:remarks" minOccurs="0"> |
---|
543 | # <annotation> |
---|
544 | # <documentation>Comments on this reference system, including source information. </documentation> |
---|
545 | # </annotation> |
---|
546 | # </element> |
---|
547 | # <element ref="gml:datumName"/> |
---|
548 | def __init__(self,metaDataProperty=None,remarks=None,datumName=None,*args,**kwargs): |
---|
549 | Definition.__init__(self,*args,**kwargs) |
---|
550 | if metaDataProperty: |
---|
551 | self.metaDataProperty=metaDataProperty |
---|
552 | if remarks: |
---|
553 | self.remarks=remarks |
---|
554 | if datumName: |
---|
555 | self.datumName=datumName |
---|
556 | def fromXML(self,csmlFrag): |
---|
557 | if csmlFrag.attrib.has_key(GML('metaDataProperty')): |
---|
558 | self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')] |
---|
559 | for frag in csmlFrag.getchildren(): |
---|
560 | if frag.tag==GML('remarks'): |
---|
561 | self.remarks=frag.text |
---|
562 | if frag.tag==GML('datumName'): |
---|
563 | self.datumName=frag.text |
---|
564 | Definition.fromXML(self,csmlFrag) |
---|
565 | def toXML(self,csmlFrag): |
---|
566 | Definition.toXML(self,csmlFrag) |
---|
567 | if hasattr(self,'metaDataProperty'): |
---|
568 | csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty |
---|
569 | if hasattr(self, 'remarks'): |
---|
570 | frag=Element(GML('remarks')) |
---|
571 | frag.text=self.remarks |
---|
572 | csmlFrag.append(frag) |
---|
573 | if hasattr(self, 'datumName'): |
---|
574 | frag=Element(GML('datumName')) |
---|
575 | frag.text=self.datumName |
---|
576 | csmlFrag.append(frag) |
---|
577 | return csmlFrag |
---|
578 | |
---|
579 | class AbstractDatum(AbstractDatumBase): |
---|
580 | # <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded"> |
---|
581 | # <annotation> |
---|
582 | # <documentation>Set of alternative identifications of this datum. The first datumID, if any, is normally the primary identification code, and any others are aliases. </documentation> |
---|
583 | # </annotation> |
---|
584 | # </element> |
---|
585 | # <element ref="gml:anchorPoint" minOccurs="0"/> |
---|
586 | # <element ref="gml:realizationEpoch" minOccurs="0"/> |
---|
587 | # <element ref="gml:validArea" minOccurs="0"/> |
---|
588 | # <element ref="gml:scope" minOccurs="0"/> |
---|
589 | def __init__(self,datumID=None,anchorPoint=None,realizationEpoch=None,validArea=None, scope=None,*args,**kwargs): |
---|
590 | if datumID: |
---|
591 | self.datumID=datumID |
---|
592 | if anchorPoint: |
---|
593 | self.anchorPoint=anchorPoint |
---|
594 | if realizationEpoch: |
---|
595 | self.realizationEpoch=realizationEpoch |
---|
596 | if validArea: |
---|
597 | self.validArea=validArea |
---|
598 | AbstractDatumBase.__init__(self,*args,**kwargs) |
---|
599 | def fromXML(self,csmlFrag): |
---|
600 | AbstractDatumBase.fromXML(self,csmlFrag) |
---|
601 | for frag in csmlFrag.getchildren(): |
---|
602 | if frag.tag==GML('datumID'): |
---|
603 | self.datumID=frag.text |
---|
604 | if frag.tag==GML('anchorPoint'): |
---|
605 | self.anchorPoint=frag.text |
---|
606 | if frag.tag==GML('realizationEpoch'): |
---|
607 | self.realizationEpoch=frag.text |
---|
608 | if frag.tag==GML('validArea'): |
---|
609 | self.validArea=frag.text |
---|
610 | def toXML(self,csmlFrag): |
---|
611 | AbstractDatumBase.toXML(self,csmlFrag) |
---|
612 | if hasattr(self, 'datumID'): |
---|
613 | frag=Element(GML('datumID')) |
---|
614 | frag.text=self.datumID |
---|
615 | csmlFrag.append(frag) |
---|
616 | if hasattr(self, 'anchorPoint'): |
---|
617 | frag=Element(GML('anchorPoint')) |
---|
618 | frag.text=self.anchorPoint |
---|
619 | csmlFrag.append(frag) |
---|
620 | if hasattr(self, 'realizationEpoch'): |
---|
621 | frag=Element(GML('realizationEpoch')) |
---|
622 | frag.text=self.realizationEpoch |
---|
623 | csmlFrag.append(frag) |
---|
624 | if hasattr(self, 'validArea'): |
---|
625 | frag=Element(GML('validArea')) |
---|
626 | frag.text=self.validArea |
---|
627 | csmlFrag.append(frag) |
---|
628 | |
---|
629 | return csmlFrag |
---|
630 | |
---|
631 | class EngineeringDatum(AbstractDatum): |
---|
632 | def __init__(self,*args,**kwargs): |
---|
633 | AbstractDatum.__init__(self,*args,**kwargs) |
---|
634 | def fromXML(self,csmlFrag): |
---|
635 | AbstractDatum.fromXML(self,csmlFrag) |
---|
636 | def toXML(self,csmlFrag): |
---|
637 | AbstractDatum.toXML(self,csmlFrag) |
---|
638 | return csmlFrag |
---|
639 | |
---|
640 | class VerticalDatumType(CodeType): |
---|
641 | def __init__(self,*args,**kwargs): |
---|
642 | CodeType.__init__(self,*args,**kwargs) |
---|
643 | def fromXML(self,csmlFrag): |
---|
644 | CodeType.fromXML(self,csmlFrag) |
---|
645 | def toXML(self,csmlFrag): |
---|
646 | CodeType.toXML(self,csmlFrag) |
---|
647 | return csmlFrag |
---|
648 | |
---|
649 | class VerticalDatum(AbstractDatum): |
---|
650 | def __init__(self,verticalDatumType=None,*args,**kwargs): |
---|
651 | AbstractDatum.__init__(self,*args,**kwargs) |
---|
652 | #Note to Andrew, "Type" is part of the element name here. the element <VerticalDatumType> has type: VerticalDatumTypeType. |
---|
653 | if verticalDatumType: |
---|
654 | self.verticalDatumType=verticalDatumType |
---|
655 | def fromXML(self,csmlFrag): |
---|
656 | AbstractDatum.fromXML(self,csmlFrag) |
---|
657 | for frag in csmlFrag.getchildren(): |
---|
658 | if frag.tag==GML('VerticalDatumType'): |
---|
659 | self.verticalDatumType=VerticalDatumType() |
---|
660 | VerticalDatumType.fromXML(self.verticalDatumType,frag) |
---|
661 | |
---|
662 | def toXML(self,csmlFrag): |
---|
663 | AbstractDatum.toXML(self,csmlFrag) |
---|
664 | if hasattr(self,'verticalDatumType'): |
---|
665 | frag=Element(GML('VerticalDatumType')) |
---|
666 | frag=VerticalDatumType.toXML(self.verticalDatumType,frag) |
---|
667 | return csmlFrag |
---|
668 | |
---|
669 | class TemporalDatumBase(AbstractDatum): |
---|
670 | # <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/> |
---|
671 | # <element ref="gml:datumName"/> |
---|
672 | # <element ref="gml:datumID" minOccurs="0" maxOccurs="unbounded"/> |
---|
673 | # <element ref="gml:validArea" minOccurs="0"/> |
---|
674 | # <element ref="gml:scope" minOccurs="0"/> |
---|
675 | def __init__(self,datumName=None, datumID = None, validArea=None, scope=None,*args,**kwargs): |
---|
676 | AbstractDatum.__init__(self,*args,**kwargs) |
---|
677 | def fromXML(self,csmlFrag): |
---|
678 | AbstractDatum.fromXML(self,csmlFrag) |
---|
679 | for frag in csmlFrag.getchildren(): |
---|
680 | if frag.tag==GML('datumName'): |
---|
681 | self.datumName=frag.text |
---|
682 | if frag.tag==GML('datumID'): |
---|
683 | self.datumID=frag.text |
---|
684 | if frag.tag==GML('validArea'): |
---|
685 | self.validArea=frag.text |
---|
686 | if frag.tag==GML('scope'): |
---|
687 | self.scope=frag.text |
---|
688 | def toXML(self,csmlFrag): |
---|
689 | AbstractDatum.toXML(self,csmlFrag) |
---|
690 | if hasattr(self,'datumName'): |
---|
691 | frag=Element(GML('datumName')) |
---|
692 | frag.text=self.datumName |
---|
693 | if hasattr(self,'datumID'): |
---|
694 | frag=Element(GML('datumID')) |
---|
695 | frag.text=self.datumID |
---|
696 | if hasattr(self,'validArea'): |
---|
697 | frag=Element(GML('validArea')) |
---|
698 | frag.text=self.validArea |
---|
699 | if hasattr(self,'scope'): |
---|
700 | frag=Element(GML('scope')) |
---|
701 | frag.text=self.scope |
---|
702 | return csmlFrag |
---|
703 | |
---|
704 | |
---|
705 | class TemporalDatumType(TemporalDatumBase): |
---|
706 | def __init__(self,*args,**kwargs): |
---|
707 | CodeType.__init__(self,*args,**kwargs) |
---|
708 | def fromXML(self,csmlFrag): |
---|
709 | CodeType.fromXML(self,csmlFrag) |
---|
710 | def toXML(self,csmlFrag): |
---|
711 | CodeType.toXML(self,csmlFrag) |
---|
712 | return csmlFrag |
---|
713 | |
---|
714 | class TemporalDatum(AbstractDatum): |
---|
715 | def __init__(self,origin=None,*args,**kwargs): |
---|
716 | AbstractDatum.__init__(self,*args,**kwargs) |
---|
717 | #Note to Andrew, "Type" is part of the element name here. the element <TemporalDatumType> has type: TemporalDatumTypeType. |
---|
718 | if origin: |
---|
719 | self.origin=origin |
---|
720 | def fromXML(self,csmlFrag): |
---|
721 | AbstractDatum.fromXML(self,csmlFrag) |
---|
722 | for frag in csmlFrag.getchildren(): |
---|
723 | if frag.tag==GML('TemporalDatumType'): |
---|
724 | self.temporalDatumType=TemporalDatumType() |
---|
725 | TemporalDatumType.fromXML(self.temporalDatumType,frag) |
---|
726 | def toXML(self,csmlFrag): |
---|
727 | AbstractDatum.toXML(self,csmlFrag) |
---|
728 | if hasattr(self,'temporalDatumType'): |
---|
729 | frag=Element(GML('TemporalDatumType')) |
---|
730 | frag=TemporalDatumType.toXML(self.temporalDatumType,frag) |
---|
731 | return csmlFrag |
---|
732 | |
---|
733 | class PrimeMeridianBase(Definition): |
---|
734 | # <restriction base="gml:DefinitionType"> |
---|
735 | # <sequence> |
---|
736 | # <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/> |
---|
737 | # <element ref="gml:remarks" minOccurs="0"> |
---|
738 | # <annotation> |
---|
739 | # <documentation>Comments on or information about this prime meridian, including source information. </documentation> |
---|
740 | # </annotation> |
---|
741 | # </element> |
---|
742 | # <element ref="gml:meridianName"/> |
---|
743 | # </sequence> |
---|
744 | # <attribute ref="gml:id" use="required"/> |
---|
745 | # </restriction> |
---|
746 | def __init__(self,metaDataProperty=None, remarks=None, meridianName=None, *args,**kwargs): |
---|
747 | Definition.__init__(self,*args,**kwargs) |
---|
748 | if metaDataProperty: |
---|
749 | self.metaDataProperty=metaDataProperty |
---|
750 | if remarks: |
---|
751 | self.remarks=remarks |
---|
752 | if meridianName: |
---|
753 | self.meridianName=meridianName |
---|
754 | |
---|
755 | def fromXML(self,csmlFrag): |
---|
756 | Definition.fromXML(self,csmlFrag) |
---|
757 | if csmlFrag.attrib.has_key(GML('metaDataProperty')): |
---|
758 | self.metaDataProperty=csmlFrag.attrib[GML('metaDataProperty')] |
---|
759 | for frag in csmlFrag.getchildren(): |
---|
760 | if frag.tag==GML('remarks'): |
---|
761 | self.remarks=frag.text |
---|
762 | if frag.tag==GML('meridianName'): |
---|
763 | self.meridianName=frag.text |
---|
764 | def toXML(self,csmlFrag): |
---|
765 | Definition.toXML(self,csmlFrag) |
---|
766 | if hasattr(self,'metaDataProperty'): |
---|
767 | csmlFrag.attrib[GML('metaDataProperty')]=self.metaDataProperty |
---|
768 | if hasattr(self, 'remarks'): |
---|
769 | frag=Element(GML('remarks')) |
---|
770 | frag.text=self.remarks |
---|
771 | csmlFrag.append(frag) |
---|
772 | if hasattr(self, 'meridianName'): |
---|
773 | frag=Element(GML('meridianName')) |
---|
774 | frag.text=self.meridianName |
---|
775 | csmlFrag.append(frag) |
---|
776 | return csmlFrag |
---|
777 | |
---|
778 | |
---|
779 | |
---|
780 | class PrimeMeridian(PrimeMeridianBase): |
---|
781 | #untested |
---|
782 | def __init__(self,meridianID=None, greenwichLongitude=None, *args,**kwargs): |
---|
783 | PrimeMeridianBase.__init__(self,*args,**kwargs) |
---|
784 | if meridianID: |
---|
785 | self.meridianID=meridianID |
---|
786 | if greenwichLongitude: |
---|
787 | self.greenwichLongitude=greenwichLongitude |
---|
788 | def fromXML(self,csmlFrag): |
---|
789 | PrimeMeridianBase.fromXML(self,csmlFrag) |
---|
790 | if frag.tag==GML('meridianID'): |
---|
791 | self.meridianID=frag.text |
---|
792 | if frag.tag==GML('greenwichLongitude'): |
---|
793 | self.greenwichLongitude=frag.text |
---|
794 | def toXML(self,csmlFrag): |
---|
795 | PrimeMeridianBase.toXML(self,csmlFrag) |
---|
796 | if hasattr(self,'meridianID'): |
---|
797 | frag=Element(GML('meridianID')) |
---|
798 | frag.text=self.meridianID |
---|
799 | csmlFrag.append(frag) |
---|
800 | if hasattr(self,'greenwichLongitude'): |
---|
801 | frag=Element(GML('greenwichLongitude')) |
---|
802 | frag.text=self.greenwichLongitude |
---|
803 | return csmlFrag |
---|
804 | |
---|
805 | class PrimeMeridianRef(DictionaryEntry): |
---|
806 | #untested |
---|
807 | def __init__(self,primeMeridian=None,*args,**kwargs): |
---|
808 | DictionaryEntry.__init__(self,*args,**kwargs) |
---|
809 | if primeMeridian: |
---|
810 | self.primeMeridian=primeMeridian |
---|
811 | def fromXML(self,csmlFrag): |
---|
812 | DictionaryEntry.fromXML(self,csmlFrag) |
---|
813 | for frag in csmlFrag.getchildren(): |
---|
814 | if frag.tag==GML('PrimeMeridian'): |
---|
815 | self.primeMeridian=PrimeMeridian() |
---|
816 | PrimeMeridian.fromXML(self.primeMeridian,frag) |
---|
817 | def toXML(self,csmlFrag): |
---|
818 | DictionaryEntry.toXML(self,csmlFrag) |
---|
819 | if hasattr(self,'primeMeridian'): |
---|
820 | frag=Element(GML('PrimeMeridian')) |
---|
821 | frag=PrimeMeridian.toXML(self.primeMeridian,frag) |
---|
822 | csmlFrag.append(frag) |
---|
823 | return csmlFrag |
---|
824 | |
---|
825 | class GeodeticDatum(AbstractDatum): |
---|
826 | #untested |
---|
827 | #<element ref="gml:usesPrimeMeridian"/> |
---|
828 | #<element ref="gml:usesEllipsoid"/> |
---|
829 | def __init__(self,usesPrimeMeridian=None,usesEllipsoid=None,*args,**kwargs): |
---|
830 | AbstractDatum.__init__(self,*args,**kwargs) |
---|
831 | if usesPrimeMeridian: |
---|
832 | self.usesPrimeMeridian=usesPrimeMeridian |
---|
833 | if usesEllipsoid: |
---|
834 | self.usesEllipsoid=usesEllipsoid |
---|
835 | def fromXML(self,csmlFrag): |
---|
836 | AbstractDatum.fromXML(self,csmlFrag) |
---|
837 | for frag in csmlFrag.getchildren(): |
---|
838 | if frag.tag==GML('usesPrimeMeridian'): |
---|
839 | self.usesPrimeMeridian=PrimeMeridianRef() |
---|
840 | PrimeMeridianRef.fromXML(self.usesPrimeMeridian,frag) |
---|
841 | for frag in csmlFrag.getchildren(): |
---|
842 | if frag.tag==GML('usesEllipsoid'): |
---|
843 | self.usesEllipsoid=EllipsoidRef() |
---|
844 | EllipsoidRef.fromXML(self.usesEllipsoid,frag) |
---|
845 | def toXML(self,csmlFrag): |
---|
846 | AbstractDatum.toXML(self,csmlFrag) |
---|
847 | if hasattr(self,'usesPrimeMeridian'): |
---|
848 | frag=Element(GML('usesPrimeMeridian')) |
---|
849 | frag=PrimeMeridianRef.toXML(self.usesPrimeMeridian,frag) |
---|
850 | csmlFrag.append(frag) |
---|
851 | if hasattr(self,'usesEllipsoid'): |
---|
852 | frag=Element(GML('usesEllipsoid')) |
---|
853 | frag=EllipsoidRef.toXML(self.usesEllipsoid,frag) |
---|
854 | return csmlFrag |
---|
855 | |
---|
856 | |
---|
857 | class EngineeringDatumRef(DatumRef, AssociationAttributeGroup): |
---|
858 | def __init__(self,engineeringDatum=None,*args,**kwargs): |
---|
859 | DatumRef.__init__(self, *args, **kwargs) |
---|
860 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
861 | if engineeringDatum: |
---|
862 | self.engineeringDatum=engineeringDatum |
---|
863 | def fromXML(self,csmlFrag): |
---|
864 | DatumRef.fromXML(self, csmlFrag) |
---|
865 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
866 | for frag in csmlFrag.getchildren(): |
---|
867 | if frag.tag==GML('EngineeringDatum'): |
---|
868 | self.engineeringDatum=EngineeringDatum() |
---|
869 | EngineeringDatum.fromXML(self.engineeringDatum,frag) |
---|
870 | def toXML(self,csmlFrag): |
---|
871 | DatumRef.toXML(self, csmlFrag) |
---|
872 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
873 | if hasattr(self,'engineeringDatum'): |
---|
874 | frag=Element(GML('EngineeringDatum')) |
---|
875 | frag=EngineeringDatum.toXML(self.engineeringDatum,frag) |
---|
876 | csmlFrag.append(frag) |
---|
877 | return csmlFrag |
---|
878 | |
---|
879 | class VerticalDatumRef(DatumRef, AssociationAttributeGroup): |
---|
880 | def __init__(self,verticalDatum=None,*args,**kwargs): |
---|
881 | DatumRef.__init__(self, *args, **kwargs) |
---|
882 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
883 | if verticalDatum: |
---|
884 | self.verticalDatum=verticalDatum |
---|
885 | def fromXML(self,csmlFrag): |
---|
886 | DatumRef.fromXML(self, csmlFrag) |
---|
887 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
888 | for frag in csmlFrag.getchildren(): |
---|
889 | if frag.tag==GML('VerticalDatum'): |
---|
890 | self.verticalDatum=VerticalDatum() |
---|
891 | VerticalDatum.fromXML(self.verticalDatum,frag) |
---|
892 | def toXML(self,csmlFrag): |
---|
893 | DatumRef.toXML(self, csmlFrag) |
---|
894 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
895 | if hasattr(self,'verticalDatum'): |
---|
896 | frag=Element(GML('VerticalDatum')) |
---|
897 | frag=VerticalDatum.toXML(self.verticalDatum,frag) |
---|
898 | csmlFrag.append(frag) |
---|
899 | return csmlFrag |
---|
900 | |
---|
901 | class GeodeticDatumRef(DatumRef,AssociationAttributeGroup): |
---|
902 | def __init__(self,geodeticDatum=None,*args,**kwargs): |
---|
903 | DatumRef.__init__(self, *args, **kwargs) |
---|
904 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
905 | if geodeticDatum: |
---|
906 | self.geodeticDatum=geodeticDatum |
---|
907 | def fromXML(self,csmlFrag): |
---|
908 | DatumRef.fromXML(self, csmlFrag) |
---|
909 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
910 | for frag in csmlFrag.getchildren(): |
---|
911 | if frag.tag==GML('GeodeticDatum'): |
---|
912 | self.geodeticDatum=GeodeticDatum() |
---|
913 | GeodeticDatum.fromXML(self.geodeticDatum,frag) |
---|
914 | def toXML(self,csmlFrag): |
---|
915 | DatumRef.toXML(self, csmlFrag) |
---|
916 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
917 | if hasattr(self,'geodeticDatum'): |
---|
918 | frag=Element(GML('GeodeticDatum')) |
---|
919 | frag=GeodeticDatum.toXML(self.geodeticDatum,frag) |
---|
920 | csmlFrag.append(frag) |
---|
921 | return csmlFrag |
---|
922 | |
---|
923 | class CoordinateSystemAxisBase(Definition): |
---|
924 | def __init__(self,*args,**kwargs): |
---|
925 | Definition.__init__(self, *args, **kwargs) |
---|
926 | def fromXML(self,csmlFrag): |
---|
927 | Definition.fromXML(self, csmlFrag) |
---|
928 | def toXML(self,csmlFrag): |
---|
929 | Definition.toXML(self, csmlFrag) |
---|
930 | return csmlFrag |
---|
931 | |
---|
932 | class CoordinateSystemAxis(CoordinateSystemAxisBase): |
---|
933 | def __init__(self,uom=None,axisIDs=None,axisAbbrev=None, axisDirection=None, *args,**kwargs): |
---|
934 | #gml:uom[1] |
---|
935 | #gml:axisID[0..1]:identifier |
---|
936 | #gml:axisAbbrev[0..1]:string |
---|
937 | #gml:axisDirection[0...1]:string |
---|
938 | CoordinateSystemAxisBase.__init__(self, *args, **kwargs) |
---|
939 | if uom: |
---|
940 | self.uom=uom |
---|
941 | if axisIDs: |
---|
942 | self.axisIDs=axisIDs |
---|
943 | if axisAbbrev: |
---|
944 | self.axisAbbrev=axisAbbrev |
---|
945 | if axisDirection: |
---|
946 | self.axisDirection=axisDirection |
---|
947 | |
---|
948 | def fromXML(self,csmlFrag): |
---|
949 | CoordinateSystemAxisBase.fromXML(self,csmlFrag) |
---|
950 | if csmlFrag.attrib.has_key(GML('uom')): |
---|
951 | self.uom=csmlFrag.attrib[GML('uom')] |
---|
952 | for frag in csmlFrag.getchildren(): |
---|
953 | if frag.tag==GML('axisID'): |
---|
954 | checkArrayAttrib(self,'axisIDs') |
---|
955 | axisID=frag.text |
---|
956 | self.axisIDs.append(axisID) |
---|
957 | if frag.tag==GML('axisAbbrev'): |
---|
958 | self.axisAbbrev=frag.text |
---|
959 | if frag.tag==GML('axisDirection'): |
---|
960 | self.axisDirection=frag.text |
---|
961 | checkMandatory(self,'uom') |
---|
962 | def toXML(self,csmlFrag): |
---|
963 | CoordinateSystemAxisBase.toXML(self,csmlFrag) |
---|
964 | if hasattr(self,'uom'): |
---|
965 | csmlFrag.attrib[GML('uom')]=self.uom |
---|
966 | if hasattr(self,'axisIDs'): |
---|
967 | print 'do something' |
---|
968 | if hasattr(self,'axisAbbrev'): |
---|
969 | frag=Element(GML('axisAbbrev')) |
---|
970 | frag.text=self.axisAbbrev |
---|
971 | csmlFrag.append(frag) |
---|
972 | if hasattr(self,'axisDirection'): |
---|
973 | frag=Element(GML('axisDirection')) |
---|
974 | frag.text=self.axisDirection |
---|
975 | csmlFrag.append(frag) |
---|
976 | return csmlFrag |
---|
977 | |
---|
978 | class CoordinateSystemRef(DictionaryEntry): |
---|
979 | def __init__(self,*args,**kwargs): |
---|
980 | DictionaryEntry.__init__(self, *args, **kwargs) |
---|
981 | def fromXML(self,csmlFrag): |
---|
982 | DictionaryEntry.fromXML(self, csmlFrag) |
---|
983 | def toXML(self,csmlFrag): |
---|
984 | DictionaryEntry.toXML(self, csmlFrag) |
---|
985 | return csmlFrag |
---|
986 | |
---|
987 | class AbstractCoordinateSystemBase(Definition): |
---|
988 | # <element ref="gml:metaDataProperty" minOccurs="0" maxOccurs="unbounded"/> |
---|
989 | # <element ref="gml:remarks" minOccurs="0"> |
---|
990 | # <annotation> |
---|
991 | # <documentation>Comments on or information about this coordinate system, including data source information. </documentation> |
---|
992 | # </annotation> |
---|
993 | # </element> |
---|
994 | # <element ref="gml:csName"/> |
---|
995 | def __init__(self,metaDataProperty=None,remarks=None,csName=None,*args,**kwargs): |
---|
996 | Definition.__init__(self, *args, **kwargs) |
---|
997 | if metaDataProperty: |
---|
998 | self.metaDataProperty=metaDataProperty |
---|
999 | if remarks: |
---|
1000 | self.remarks=remarks |
---|
1001 | if csName: |
---|
1002 | self.csName=csName |
---|
1003 | def fromXML(self,csmlFrag): |
---|
1004 | Definition.fromXML(self, csmlFrag) |
---|
1005 | for frag in csmlFrag.getchildren(): |
---|
1006 | if frag.tag==GML('metaDataProperty'): |
---|
1007 | self.metaDataProperty=MetaDataProperty() |
---|
1008 | MetaDataProperty.fromXML(self.metaDataProperty, frag) |
---|
1009 | if frag.tag==GML('remarks'): |
---|
1010 | self.remarks=frag.text |
---|
1011 | if frag.tag==GML('csName'): |
---|
1012 | self.csName=frag.text |
---|
1013 | |
---|
1014 | def toXML(self,csmlFrag): |
---|
1015 | Definition.toXML(self, csmlFrag) |
---|
1016 | return csmlFrag |
---|
1017 | |
---|
1018 | class AbstractCoordinateSystem(AbstractCoordinateSystemBase): |
---|
1019 | #class AbstractCoordinateSystem |
---|
1020 | #+gml:csid[0...1]:string |
---|
1021 | #+gml:usesAxis[1...*] |
---|
1022 | |
---|
1023 | def __init__(self,csid=None,usesAxes=None,*args,**kwargs): |
---|
1024 | AbstractCoordinateSystemBase.__init__(self, *args, **kwargs) |
---|
1025 | if csid: |
---|
1026 | self.csid=csid |
---|
1027 | if usesAxes: |
---|
1028 | self.usesAxes=usesAxes |
---|
1029 | #usesAxes should be a list containing multiple gml:usesAxis |
---|
1030 | def fromXML(self,csmlFrag): |
---|
1031 | AbstractCoordinateSystemBase.fromXML(self, csmlFrag) |
---|
1032 | for frag in csmlFrag.getchildren(): |
---|
1033 | if frag.tag==GML('csid'): |
---|
1034 | self.csid=frag.text |
---|
1035 | if frag.tag==GML('usesAxis'): |
---|
1036 | checkArrayAttrib(self,'usesAxes') |
---|
1037 | self.usesAxes.append(CoordinateSystemAxis()) |
---|
1038 | self.usesAxes[-1].fromXML(frag.getchildren()[0]) |
---|
1039 | checkMandatory(self,'usesAxes') |
---|
1040 | def toXML(self,csmlFrag): |
---|
1041 | AbstractCoordinateSystemBase.toXML(self, csmlFrag) |
---|
1042 | if hasattr(self,'csid'): |
---|
1043 | frag=Element(GML('csid')) |
---|
1044 | frag.tag=self.csid |
---|
1045 | csmlFrag.append(frag) |
---|
1046 | if hasattr(self,'usesAxes'): |
---|
1047 | for axis in self.usesAxes: |
---|
1048 | frag=Element(GML('usesAxis')) |
---|
1049 | subFrag=Element(GML('CoordinateSystemAxis')) |
---|
1050 | subFrag=axis.toXML(subFrag) |
---|
1051 | frag.append(subFrag) |
---|
1052 | csmlFrag.append(frag) |
---|
1053 | return csmlFrag |
---|
1054 | |
---|
1055 | class LinearCS(AbstractCoordinateSystem): |
---|
1056 | def __init__(self,*args,**kwargs): |
---|
1057 | AbstractCoordinateSystem.__init__(self, *args, **kwargs) |
---|
1058 | def fromXML(self,csmlFrag): |
---|
1059 | AbstractCoordinateSystem.fromXML(self, csmlFrag) |
---|
1060 | def toXML(self,csmlFrag): |
---|
1061 | AbstractCoordinateSystem.toXML(self, csmlFrag) |
---|
1062 | return csmlFrag |
---|
1063 | |
---|
1064 | |
---|
1065 | class EllipsoidalCS(AbstractCoordinateSystem): |
---|
1066 | def __init__(self,*args,**kwargs): |
---|
1067 | AbstractCoordinateSystem.__init__(self, *args, **kwargs) |
---|
1068 | def fromXML(self,csmlFrag): |
---|
1069 | AbstractCoordinateSystem.fromXML(self, csmlFrag) |
---|
1070 | def toXML(self,csmlFrag): |
---|
1071 | AbstractCoordinateSystem.toXML(self, csmlFrag) |
---|
1072 | return csmlFrag |
---|
1073 | |
---|
1074 | class VerticalCS(AbstractCoordinateSystem): |
---|
1075 | def __init__(self,*args,**kwargs): |
---|
1076 | AbstractCoordinateSystem.__init__(self, *args, **kwargs) |
---|
1077 | def fromXML(self,csmlFrag): |
---|
1078 | AbstractCoordinateSystem.fromXML(self, csmlFrag) |
---|
1079 | def toXML(self,csmlFrag): |
---|
1080 | AbstractCoordinateSystem.toXML(self, csmlFrag) |
---|
1081 | return csmlFrag |
---|
1082 | |
---|
1083 | class TemporalCS(AbstractCoordinateSystem): |
---|
1084 | def __init__(self,*args,**kwargs): |
---|
1085 | AbstractCoordinateSystem.__init__(self, *args, **kwargs) |
---|
1086 | def fromXML(self,csmlFrag): |
---|
1087 | AbstractCoordinateSystem.fromXML(self, csmlFrag) |
---|
1088 | def toXML(self,csmlFrag): |
---|
1089 | AbstractCoordinateSystem.toXML(self, csmlFrag) |
---|
1090 | return csmlFrag |
---|
1091 | class EngineeringCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup): |
---|
1092 | #<element ref="gml:usesCS"/>type="gml:CoordinateSystemRefType"> |
---|
1093 | #<element ref="gml:usesEngineeringDatum"/> |
---|
1094 | def __init__(self,usesCS=None, usesEngineeringDatum=None,*args,**kwargs): |
---|
1095 | AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs) |
---|
1096 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
1097 | if usesCS: |
---|
1098 | self.usesCS=usesCS |
---|
1099 | if usesEngineeringDatum: |
---|
1100 | self.usesEngineeringDatum=usesEngineeringDatum |
---|
1101 | def fromXML(self,csmlFrag): |
---|
1102 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
1103 | AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag) |
---|
1104 | for frag in csmlFrag.getchildren(): |
---|
1105 | if frag.tag == GML('usesCS'): |
---|
1106 | subFrag=frag.getchildren()[0] |
---|
1107 | if subFrag.tag==GML('LinearCS'): |
---|
1108 | self.usesCS=LinearCS() |
---|
1109 | LinearCS.fromXML(self.usesCS,subFrag) |
---|
1110 | else: |
---|
1111 | print subFrag.tag + ' Coordinate System not supported' |
---|
1112 | if frag.tag == GML('usesEngineeringDatum'): |
---|
1113 | self.usesEngineeringDatum=EngineeringDatumRef() |
---|
1114 | EngineeringDatumRef.fromXML(self.usesEngineeringDatum,frag) |
---|
1115 | def toXML(self,csmlFrag): |
---|
1116 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
1117 | AbstractCoordinateReferenceSystem.toXML(self, csmlFrag) |
---|
1118 | if hasattr(self, 'usesCS'): |
---|
1119 | frag=Element(GML('usesCS')) |
---|
1120 | if isinstance(self.usesCS,LinearCS): |
---|
1121 | subFrag=Element(GML('LinearCS')) |
---|
1122 | LinearCS.toXML(self.usesCS,subFrag) |
---|
1123 | frag.append(subFrag) |
---|
1124 | csmlFrag.append(frag) |
---|
1125 | if hasattr(self, 'usesEngineeringDatum'): |
---|
1126 | frag=Element(GML('usesEngineeringDatum')) |
---|
1127 | EngineeringDatumRef.toXML(self.usesEngineeringDatum, frag) |
---|
1128 | csmlFrag.append(frag) |
---|
1129 | return csmlFrag |
---|
1130 | |
---|
1131 | class VerticalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup): |
---|
1132 | #<element ref="gml:usesVerticalCS"/>type="gml:VerticalCSRefType"> |
---|
1133 | #<element ref="gml:usesVerticalDatum"/>type="gml:VerticalDatumRefType |
---|
1134 | def __init__(self,usesVerticalCS=None, usesVerticalDatum=None,*args,**kwargs): |
---|
1135 | AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs) |
---|
1136 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
1137 | if usesVerticalCS: |
---|
1138 | self.usesVerticalCS=usesVerticalCS |
---|
1139 | if usesVerticalDatum: |
---|
1140 | self.usesVerticalDatum=usesVerticalDatum |
---|
1141 | def fromXML(self,csmlFrag): |
---|
1142 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
1143 | AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag) |
---|
1144 | for frag in csmlFrag.getchildren(): |
---|
1145 | if frag.tag == GML('usesVerticalCS'): |
---|
1146 | subFrag=frag.getchildren()[0] |
---|
1147 | if subFrag.tag==GML('VerticalCS'): |
---|
1148 | self.usesVerticalCS=VerticalCS() |
---|
1149 | VerticalCS.fromXML(self.usesVerticalCS,subFrag) |
---|
1150 | else: |
---|
1151 | print subFrag.tag + ' Coordinate System not supported' |
---|
1152 | if frag.tag == GML('usesVerticalDatum'): |
---|
1153 | self.usesVerticalDatum=VerticalDatumRef() |
---|
1154 | VerticalDatumRef.fromXML(self.usesVerticalDatum,frag) |
---|
1155 | def toXML(self,csmlFrag): |
---|
1156 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
1157 | AbstractCoordinateReferenceSystem.toXML(self, csmlFrag) |
---|
1158 | if hasattr(self, 'usesVerticalCS'): |
---|
1159 | frag=Element(GML('usesVerticalCS')) |
---|
1160 | if isinstance(self.usesVerticalCS,VerticalCS): |
---|
1161 | subFrag=Element(GML('VerticalCS')) |
---|
1162 | VerticalCS.toXML(self.usesVerticalCS,subFrag) |
---|
1163 | frag.append(subFrag) |
---|
1164 | csmlFrag.append(frag) |
---|
1165 | if hasattr(self, 'usesVerticalDatum'): |
---|
1166 | frag=Element(GML('usesVerticalDatum')) |
---|
1167 | VerticalDatumRef.toXML(self.usesVerticalDatum, frag) |
---|
1168 | csmlFrag.append(frag) |
---|
1169 | return csmlFrag |
---|
1170 | |
---|
1171 | class TemporalCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup): |
---|
1172 | #<element ref="gml:usesTemporalCS"/>type="gml:TemporalCSRefType"> |
---|
1173 | #<element ref="gml:usesTemporalDatum"/>type="gml:TemporalDatumRefType |
---|
1174 | def __init__(self,usesTemporalCS=None, usesTemporalDatum=None,*args,**kwargs): |
---|
1175 | AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs) |
---|
1176 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
1177 | if usesTemporalCS: |
---|
1178 | self.usesTemporalCS=usesTemporalCS |
---|
1179 | if usesTemporalDatum: |
---|
1180 | self.usesTemporalDatum=usesTemporalDatum |
---|
1181 | def fromXML(self,csmlFrag): |
---|
1182 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
1183 | AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag) |
---|
1184 | for frag in csmlFrag.getchildren(): |
---|
1185 | if frag.tag == GML('usesTemporalCS'): |
---|
1186 | subFrag=frag.getchildren()[0] |
---|
1187 | if subFrag.tag==GML('TemporalCS'): |
---|
1188 | self.usesTemporalCS=TemporalCS() |
---|
1189 | TemporalCS.fromXML(self.usesTemporalCS,subFrag) |
---|
1190 | else: |
---|
1191 | print subFrag.tag + ' Coordinate System not supported' |
---|
1192 | if frag.tag == GML('usesTemporalDatum'): |
---|
1193 | self.usesTemporalDatum=TemporalDatumRef() |
---|
1194 | TemporalDatumRef.fromXML(self.usesTemporalDatum,frag) |
---|
1195 | def toXML(self,csmlFrag): |
---|
1196 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
1197 | AbstractCoordinateReferenceSystem.toXML(self, csmlFrag) |
---|
1198 | if hasattr(self, 'usesTemporalCS'): |
---|
1199 | frag=Element(GML('usesTemporalCS')) |
---|
1200 | if isinstance(self.usesTemporalCS,TemporalCS): |
---|
1201 | subFrag=Element(GML('TemporalCS')) |
---|
1202 | TemporalCS.toXML(self.usesTemporalCS,subFrag) |
---|
1203 | frag.append(subFrag) |
---|
1204 | csmlFrag.append(frag) |
---|
1205 | if hasattr(self, 'usesTemporalDatum'): |
---|
1206 | frag=Element(GML('usesTemporalDatum')) |
---|
1207 | TemporalDatumRef.toXML(self.usesTemporalDatum, frag) |
---|
1208 | csmlFrag.append(frag) |
---|
1209 | return csmlFrag |
---|
1210 | class GeographicCRS(AbstractCoordinateReferenceSystem,AssociationAttributeGroup): |
---|
1211 | #<element ref="gml:usesEllipsoidalCS"/> |
---|
1212 | #<element ref="gml:usesGeodeticDatum"/> |
---|
1213 | def __init__(self,usesEllipsoidalCS=None, usesGeodeticDatum=None,*args,**kwargs): |
---|
1214 | AbstractCoordinateReferenceSystem.__init__(self, *args, **kwargs) |
---|
1215 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
1216 | if usesEllipsoidalCS: |
---|
1217 | self.usesEllipsoidalCS=usesEllipsoidalCS |
---|
1218 | if usesGeodeticDatum: |
---|
1219 | self.usesGeodeticDatum=usesGeodeticDatum |
---|
1220 | def fromXML(self,csmlFrag): |
---|
1221 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
1222 | AbstractCoordinateReferenceSystem.fromXML(self, csmlFrag) |
---|
1223 | for frag in csmlFrag.getchildren(): |
---|
1224 | if frag.tag == GML('usesEllipsoidalCS'): |
---|
1225 | subFrag=frag.getchildren()[0] |
---|
1226 | if subFrag.tag==GML('EllipsoidalCS'): |
---|
1227 | self.usesEllipsoidalCS=EllipsoidalCS() |
---|
1228 | EllipsoidalCS.fromXML(self.usesEllipsoidalCS,subFrag) |
---|
1229 | else: |
---|
1230 | print subFrag.tag + ' Coordinate System not supported' |
---|
1231 | if frag.tag == GML('usesGeodeticDatum'): |
---|
1232 | self.usesGeodeticDatum=GeodeticDatumRef() |
---|
1233 | GeodeticDatumRef.fromXML(self.usesEngineeringDatum,frag) |
---|
1234 | def toXML(self,csmlFrag): |
---|
1235 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
1236 | AbstractCoordinateReferenceSystem.toXML(self, csmlFrag) |
---|
1237 | if hasattr(self, 'usesEllipsoidalCS'): |
---|
1238 | frag=Element(GML('usesEllipsoidalCS')) |
---|
1239 | if isinstance(self.usesCS,LinearCS): |
---|
1240 | subFrag=Element(GML('usesEllipsoidalCS')) |
---|
1241 | EllipsoidalCS.toXML(self.usesEllipsoidalCS,subFrag) |
---|
1242 | frag.append(subFrag) |
---|
1243 | csmlFrag.append(frag) |
---|
1244 | if hasattr(self, 'usesEngineeringDatum'): |
---|
1245 | frag=Element(GML('usesGeodeticDatum')) |
---|
1246 | GeodeticDatumRef.toXML(self.usesGeodeticDatum, frag) |
---|
1247 | csmlFrag.append(frag) |
---|
1248 | return csmlFrag |
---|
1249 | |
---|
1250 | class CompoundCRS(AbstractCRS,AssociationAttributeGroup): |
---|
1251 | #untested |
---|
1252 | def __init__(self, includes=None, *args,**kwargs): |
---|
1253 | AbstractCRS.__init__(self, *args, **kwargs) |
---|
1254 | AssociationAttributeGroup.__init__(self, *args, **kwargs) |
---|
1255 | if includes: |
---|
1256 | self.includes=includes |
---|
1257 | def fromXML(self,csmlFrag): |
---|
1258 | AssociationAttributeGroup.fromXML(self, csmlFrag) |
---|
1259 | AbstractCRS.fromXML(self, csmlFrag) |
---|
1260 | for frag in csmlFrag.getchildren(): |
---|
1261 | if frag.tag == GML('includesCRS'): |
---|
1262 | checkArrayAttrib(self,'includes') |
---|
1263 | if frag.getchildren() !=[]: |
---|
1264 | if frag.getchildren()[1].tag==GML('EngineeringCRS'): |
---|
1265 | self.includes.append(EngineeringCRS()) |
---|
1266 | if frag.getchildren()[1].tag==GML('VerticalCRS'): |
---|
1267 | self.includes.append(VerticalCRS()) |
---|
1268 | if frag.getchildren()[1].tag==GML('GeographicCRS'): |
---|
1269 | self.includes.append(GeographicCRS()) |
---|
1270 | #if frag.getchildren()[1].tag==GML('TemporalCRS'): |
---|
1271 | #self.includes.append(TemporalCRS()) |
---|
1272 | self.includes[-1].fromXML(frag.getchildren()[0]) |
---|
1273 | |
---|
1274 | def toXML(self,csmlFrag): |
---|
1275 | AssociationAttributeGroup.toXML(self, csmlFrag) |
---|
1276 | AbstractCoordinateReferenceSystem.toXML(self, csmlFrag) |
---|
1277 | if hasattr(self,'includes'): |
---|
1278 | for crs in self.includes: |
---|
1279 | frag=Element(GML('includesCRS')) |
---|
1280 | if isinstance(crs,EngineeringCRS): |
---|
1281 | subFrag=Element(GML('EngineeringCRS')) |
---|
1282 | subFrag=crs.toXML(subFrag) |
---|
1283 | frag.append(subFrag) |
---|
1284 | csmlFrag.append(frag) |
---|
1285 | if isinstance(crs,VerticalCRS): |
---|
1286 | subFrag=Element(GML('VerticalCRS')) |
---|
1287 | subFrag=crs.toXML(subFrag) |
---|
1288 | frag.append(subFrag) |
---|
1289 | csmlFrag.append(frag) |
---|
1290 | if isinstance(crs,GeographicCRS): |
---|
1291 | subFrag=Element(GML('GeographicCRS')) |
---|
1292 | subFrag=crs.toXML(subFrag) |
---|
1293 | frag.append(subFrag) |
---|
1294 | csmlFrag.append(frag) |
---|
1295 | # if isinstance(crs,TemporalCRS): |
---|
1296 | # subFrag=Element(GML('TemporalCRS')) |
---|
1297 | # subFrag=crs.toXML(subFrag) |
---|
1298 | # frag.append(subFrag) |
---|
1299 | # csmlFrag.append(frag) |
---|
1300 | return csmlFrag |
---|
1301 | |
---|
1302 | class UnitDefinition(Definition): |
---|
1303 | #Class gml:UnitDefinition |
---|
1304 | # +quantityType |
---|
1305 | # +catalogSymbol, codeSpace |
---|
1306 | def __init__(self,quantityType=None,catalogSymbol=None,*args,**kwargs): |
---|
1307 | Definition.__init__(self,*args,**kwargs) |
---|
1308 | if quantityType: |
---|
1309 | self.quantityType=quantityType |
---|
1310 | if catalogSymbol: |
---|
1311 | self.catalogSymbol=catalogSymbol |
---|
1312 | def fromXML(self,csmlFrag): |
---|
1313 | Definition.fromXML(self,csmlFrag) |
---|
1314 | for frag in csmlFrag.getchildren(): |
---|
1315 | if frag.tag == GML('quantityType'): |
---|
1316 | self.quantityType=frag.text |
---|
1317 | elif frag.tag == GML('catalogSymbol'): |
---|
1318 | self.catalogSymbol=CodeType() |
---|
1319 | CodeType.fromXML(self.catalogSymbol, frag) |
---|
1320 | def toXML(self,csmlFrag): |
---|
1321 | Definition.toXML(self,csmlFrag) |
---|
1322 | if hasattr(self, 'quantityType'): |
---|
1323 | frag=Element(GML('quantityType')) |
---|
1324 | frag.text=self.quantityType |
---|
1325 | csmlFrag.append(frag) |
---|
1326 | if hasattr(self, 'catalogSymbol'): |
---|
1327 | frag=Element(GML('catalogSymbol')) |
---|
1328 | CodeType.toXML(self.catalogSymbol,frag) |
---|
1329 | csmlFrag.append(frag) |
---|
1330 | return csmlFrag |
---|
1331 | |
---|
1332 | class Dictionary(Definition): |
---|
1333 | #Class for gml:Dictionary elements |
---|
1334 | # + gml:definitionMembers [1....*] |
---|
1335 | def __init__(self, definitionMembers=None,*args,**kwargs): |
---|
1336 | Definition.__init__(self,*args,**kwargs) |
---|
1337 | if definitionMembers: |
---|
1338 | self.definitionMembers = definitionMembers |
---|
1339 | def fromXML(self,csmlFrag): |
---|
1340 | Definition.fromXML(self,csmlFrag) |
---|
1341 | for frag in csmlFrag.getchildren(): |
---|
1342 | if frag.tag == GML('definitionMember'): |
---|
1343 | checkArrayAttrib(self, 'definitionMembers') |
---|
1344 | subFrag = frag.getchildren()[0] |
---|
1345 | if subFrag.tag == GML('UnitDefinition'): |
---|
1346 | definitionMember=UnitDefinition() |
---|
1347 | definitionMember.fromXML(subFrag) |
---|
1348 | self.definitionMembers.append(definitionMember) |
---|
1349 | elif subFrag.tag == CSML('TimeCoordinateSystem'): |
---|
1350 | definitionMember=TimeCoordinateSystem() |
---|
1351 | definitionMember.fromXML(subFrag) |
---|
1352 | self.definitionMembers.append(definitionMember) |
---|
1353 | elif subFrag.tag == GML('EngineeringCRS'): |
---|
1354 | definitionMember=EngineeringCRS() |
---|
1355 | definitionMember.fromXML(subFrag) |
---|
1356 | self.definitionMembers.append(definitionMember) |
---|
1357 | elif subFrag.tag == GML('GeographicCRS'): |
---|
1358 | definitionMember=GeographicCRS() |
---|
1359 | definitionMember.fromXML(subFrag) |
---|
1360 | self.definitionMembers.append(definitionMember) |
---|
1361 | elif subFrag.tag == GML('VerticalCRS'): |
---|
1362 | definitionMember=VerticalCRS() |
---|
1363 | definitionMember.fromXML(subFrag) |
---|
1364 | self.definitionMembers.append(definitionMember) |
---|
1365 | elif subFrag.tag == GML('TemporalCRS'): |
---|
1366 | definitionMember=TemporalCRS() |
---|
1367 | definitionMember.fromXML(subFrag) |
---|
1368 | self.definitionMembers.append(definitionMember) |
---|
1369 | elif subFrag.tag == GML('CompoundCRS'): |
---|
1370 | definitionMember=CompoundCRS() |
---|
1371 | definitionMember.fromXML(subFrag) |
---|
1372 | self.definitionMembers.append(definitionMember) |
---|
1373 | elif subFrag.tag == OM('Phenomenon'): |
---|
1374 | definitionMember=Phenomenon() |
---|
1375 | definitionMember.fromXML(subFrag) |
---|
1376 | self.definitionMembers.append(definitionMember) |
---|
1377 | #checkMandatory(self,'definitionMembers') |
---|
1378 | #commented out for now - dictionaryEntry is possible |
---|
1379 | def toXML(self,csmlFrag): |
---|
1380 | Definition.toXML(self,csmlFrag) |
---|
1381 | if hasattr(self, 'definitionMembers'): |
---|
1382 | for definitionMember in self.definitionMembers: |
---|
1383 | if isinstance(definitionMember,UnitDefinition): |
---|
1384 | superFrag=Element(GML('definitionMember')) |
---|
1385 | frag=Element(GML('UnitDefinition')) |
---|
1386 | UnitDefinition.toXML(definitionMember,frag) |
---|
1387 | superFrag.append(frag) |
---|
1388 | csmlFrag.append(superFrag) |
---|
1389 | if isinstance(definitionMember,TimeCoordinateSystem): |
---|
1390 | superFrag=Element(GML('definitionMember')) |
---|
1391 | frag=Element(CSML('TimeCoordinateSystem')) |
---|
1392 | TimeCoordinateSystem.toXML(definitionMember,frag) |
---|
1393 | superFrag.append(frag) |
---|
1394 | csmlFrag.append(superFrag) |
---|
1395 | if isinstance(definitionMember,EngineeringCRS): |
---|
1396 | superFrag=Element(GML('definitionMember')) |
---|
1397 | frag=Element(GML('EngineeringCRS')) |
---|
1398 | EngineeringCRS.toXML(definitionMember,frag) |
---|
1399 | superFrag.append(frag) |
---|
1400 | csmlFrag.append(superFrag) |
---|
1401 | if isinstance(definitionMember,Phenomenon): |
---|
1402 | superFrag=Element(GML('definitionMember')) |
---|
1403 | frag=Element(OM('Phenomenon')) |
---|
1404 | Phenomenon.toXML(definitionMember,frag) |
---|
1405 | superFrag.append(frag) |
---|
1406 | csmlFrag.append(superFrag) |
---|
1407 | return csmlFrag |
---|
1408 | |
---|
1409 | |
---|
1410 | class UnitDefinitions(Dictionary): |
---|
1411 | #Class for csml:UnitDefinitions(gml:Dictionary) |
---|
1412 | def __init__(self,*args,**kwargs): |
---|
1413 | Dictionary.__init__(self,*args,**kwargs) |
---|
1414 | def fromXML(self,csmlFrag): |
---|
1415 | Dictionary.fromXML(self,csmlFrag) |
---|
1416 | def toXML(self,csmlFrag): |
---|
1417 | Dictionary.toXML(self,csmlFrag) |
---|
1418 | return csmlFrag |
---|
1419 | |
---|
1420 | class ReferenceSystemDefinitions(Dictionary): |
---|
1421 | def __init__(self,*args,**kwargs): |
---|
1422 | Dictionary.__init__(self,*args,**kwargs) |
---|
1423 | def fromXML(self,csmlFrag): |
---|
1424 | Dictionary.fromXML(self,csmlFrag) |
---|
1425 | def toXML(self,csmlFrag): |
---|
1426 | Dictionary.toXML(self,csmlFrag) |
---|
1427 | return csmlFrag |
---|
1428 | |
---|
1429 | class PhenomenonDefinitions(Dictionary): |
---|
1430 | def __init__(self,*args,**kwargs): |
---|
1431 | Dictionary.__init__(self,*args,**kwargs) |
---|
1432 | def fromXML(self,csmlFrag): |
---|
1433 | Dictionary.fromXML(self,csmlFrag) |
---|
1434 | def toXML(self,csmlFrag): |
---|
1435 | Dictionary.toXML(self,csmlFrag) |
---|
1436 | return csmlFrag |
---|
1437 | |
---|
1438 | class AbstractArrayDescriptor(AbstractGML): |
---|
1439 | """Base abstract class for CSML array descriptors |
---|
1440 | |
---|
1441 | AbstractArrayDescriptor(AbstractGML): |
---|
1442 | +arraySize[1..*]: int |
---|
1443 | +uom[0..1]: anyURI #Amended to also take a 'UnitDefinition' - needed to resolve internal references |
---|
1444 | +numericType[0..1]: string |
---|
1445 | +regExpTransform[0..1]: string |
---|
1446 | +numericTransform[0..1]: string |
---|
1447 | """ |
---|
1448 | def __init__(self,arraySize=None,uom=None,numericType=None, |
---|
1449 | regExpTransform=None,numericTransform=None,*args,**kwargs): |
---|
1450 | AbstractGML.__init__(self,*args,**kwargs) |
---|
1451 | if arraySize: |
---|
1452 | self.arraySize = arraySize |
---|
1453 | if uom: |
---|
1454 | self.uom = uom |
---|
1455 | if numericType: |
---|
1456 | self.numericType = numericType |
---|
1457 | if regExpTransform: |
---|
1458 | self.regExpTransform = regExpTransform |
---|
1459 | if numericTransform: |
---|
1460 | self.numericTransform = numericTransform |
---|
1461 | def fromXML(self,csmlFrag): |
---|
1462 | AbstractGML.fromXML(self,csmlFrag) |
---|
1463 | for frag in csmlFrag.getchildren(): |
---|
1464 | if frag.tag == CSML('arraySize'): |
---|
1465 | self.arraySize = map(int,frag.text.split()) |
---|
1466 | #self.arraySize = frag.text |
---|
1467 | elif frag.tag == CSML('uom'): |
---|
1468 | if frag.getchildren() !=[]: |
---|
1469 | subFrag= frag.getchildren()[0] |
---|
1470 | if subFrag.tag == GML ('UnitDefinition'): |
---|
1471 | self.uom=UnitDefinition() |
---|
1472 | UnitDefinition.fromXML(self.uom, subFrag) |
---|
1473 | else: |
---|
1474 | self.uom=frag.text |
---|
1475 | elif frag.tag == CSML('numericType'): |
---|
1476 | self.numericType = frag.text |
---|
1477 | elif frag.tag == CSML('regExpTransform'): |
---|
1478 | self.regExpTransform = frag.text |
---|
1479 | elif frag.tag == CSML('numericTransform'): |
---|
1480 | self.numericTransform = frag.text |
---|
1481 | checkMandatory(self,'arraySize') |
---|
1482 | def toXML(self,csmlFrag): |
---|
1483 | csmlFrag = AbstractGML.toXML(self,csmlFrag) |
---|
1484 | if hasattr(self,'arraySize'): |
---|
1485 | frag = Element(CSML('arraySize')) |
---|
1486 | frag.text = ' '.join(map(str,self.arraySize)) |
---|
1487 | #frag.text = self.arraySize |
---|
1488 | csmlFrag.append(frag) |
---|
1489 | if hasattr(self,'uom'): |
---|
1490 | frag = Element(CSML('uom')) |
---|
1491 | if isinstance(self.uom,UnitDefinition): |
---|
1492 | subFrag=Element(GML('UnitDefinition')) |
---|
1493 | UnitDefinition.toXML(self.uom,subFrag) |
---|
1494 | frag.append(subFrag) |
---|
1495 | else: |
---|
1496 | frag.text = self.uom |
---|
1497 | csmlFrag.append(frag) |
---|
1498 | if hasattr(self,'numericType'): |
---|
1499 | frag = Element(CSML('numericType')) |
---|
1500 | frag.text = self.numericType |
---|
1501 | csmlFrag.append(frag) |
---|
1502 | if hasattr(self,'regExpTransform'): |
---|
1503 | frag = Element(CSML('regExpTransform')) |
---|
1504 | frag.text = self.regExpTransform |
---|
1505 | csmlFrag.append(frag) |
---|
1506 | if hasattr(self,'numericTransform'): |
---|
1507 | frag = Element(CSML('numericTransform')) |
---|
1508 | frag.text = self.numericTransform |
---|
1509 | csmlFrag.append(frag) |
---|
1510 | return csmlFrag |
---|
1511 | |
---|
1512 | class AggregatedArray(AbstractArrayDescriptor): |
---|
1513 | """CSML class for aggregated array |
---|
1514 | |
---|
1515 | AggregatedArray(AbstractArrayDescriptor): |
---|
1516 | +aggType: string |
---|
1517 | +aggIndex: int |
---|
1518 | +component[1..*]: AbstractArrayDescriptor |
---|
1519 | """ |
---|
1520 | def __init__(self,aggType=None,aggIndex=None,component=[],*args,**kwargs): |
---|
1521 | AbstractArrayDescriptor.__init__(self,*args,**kwargs) |
---|
1522 | if aggType: |
---|
1523 | self.aggType = aggType |
---|
1524 | if aggIndex: |
---|
1525 | self.aggIndex = aggIndex |
---|
1526 | if component: |
---|
1527 | self.component = component |
---|
1528 | def fromXML(self,csmlFrag): |
---|
1529 | AbstractArrayDescriptor.fromXML(self,csmlFrag) |
---|
1530 | for frag in csmlFrag.getchildren(): |
---|
1531 | if frag.tag == CSML('aggType'): |
---|
1532 | self.aggType = frag.text |
---|
1533 | elif frag.tag == CSML('aggIndex'): |
---|
1534 | self.aggIndex = int(frag.text) |
---|
1535 | elif frag.tag == CSML('component'): |
---|
1536 | checkArrayAttrib(self,'component') |
---|
1537 | componentFrag = frag[0] |
---|
1538 | if componentFrag.tag == CSML('AggregatedArray'): |
---|
1539 | self.component.append(AggregatedArray()) |
---|
1540 | elif componentFrag.tag == CSML('InlineArray'): |
---|
1541 | self.component.append(InlineArray()) |
---|
1542 | elif componentFrag.tag == CSML('ArrayGenerator'): |
---|
1543 | self.component.append(ArrayGenerator()) |
---|
1544 | elif componentFrag.tag == CSML('NASAAmesExtract'): |
---|
1545 | self.component.append(NASAAmesExtract()) |
---|
1546 | elif componentFrag.tag == CSML('NetCDFExtract'): |
---|
1547 | self.component.append(NetCDFExtract()) |
---|
1548 | elif componentFrag.tag == CSML('GRIBExtract'): |
---|
1549 | self.component.append(GRIBExtract()) |
---|
1550 | elif componentFrag.tag == CSML('PPExtract'): |
---|
1551 | self.component.append(PPExtract()) |
---|
1552 | ## else: |
---|
1553 | ## raise Exception('Unexpected element: "'+componentFrag.tag+'"') |
---|
1554 | self.component[-1].fromXML(componentFrag) |
---|
1555 | def toXML(self,csmlFrag): |
---|
1556 | csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag) |
---|
1557 | if hasattr(self,'aggType'): |
---|
1558 | frag = Element(CSML('aggType')) |
---|
1559 | frag.text = self.aggType |
---|
1560 | csmlFrag.append(frag) |
---|
1561 | if hasattr(self,'aggIndex'): |
---|
1562 | frag = Element(CSML('aggIndex')) |
---|
1563 | frag.text = str(self.aggIndex) |
---|
1564 | csmlFrag.append(frag) |
---|
1565 | if hasattr(self,'component'): |
---|
1566 | compFrag = Element(CSML('component')) |
---|
1567 | for comp in self.component: |
---|
1568 | if isinstance(comp,AggregatedArray): |
---|
1569 | frag = Element(CSML('AggregatedArray')) |
---|
1570 | frag = AggregatedArray.toXML(comp,frag) |
---|
1571 | elif isinstance(comp,InlineArray): |
---|
1572 | frag = Element(CSML('InlineArray')) |
---|
1573 | frag = InlineArray.toXML(comp,frag) |
---|
1574 | elif isinstance(comp,ArrayGenerator): |
---|
1575 | frag = Element(CSML('ArrayGenerator')) |
---|
1576 | frag = ArrayGenerator.toXML(comp,frag) |
---|
1577 | elif isinstance(comp,NASAAmesExtract): |
---|
1578 | frag = Element(CSML('NASAAmesExtract')) |
---|
1579 | frag = NASAAmesExtract.toXML(comp,frag) |
---|
1580 | elif isinstance(comp,NetCDFExtract): |
---|
1581 | frag = Element(CSML('NetCDFExtract')) |
---|
1582 | frag = NetCDFExtract.toXML(comp,frag) |
---|
1583 | elif isinstance(comp,PPExtract): |
---|
1584 | frag = Element(CSML('PPExtract')) |
---|
1585 | frag = PPExtract.toXML(comp,frag) |
---|
1586 | elif isinstance(comp,GRIBExtract): |
---|
1587 | frag = Element(CSML('GRIBExtract')) |
---|
1588 | frag = GRIBExtract.toXML(comp,frag) |
---|
1589 | compFrag.append(frag) |
---|
1590 | csmlFrag.append(compFrag) |
---|
1591 | return csmlFrag |
---|
1592 | |
---|
1593 | class InlineArray(AbstractArrayDescriptor): |
---|
1594 | pass |
---|
1595 | |
---|
1596 | class ArrayGenerator(AbstractArrayDescriptor): |
---|
1597 | pass |
---|
1598 | |
---|
1599 | class AbstractFileExtract(AbstractArrayDescriptor): |
---|
1600 | """Base abstract clas for CSML file array extract |
---|
1601 | |
---|
1602 | AbstractFileExtract(AbstractArrayDescriptor): |
---|
1603 | +fileName: string |
---|
1604 | """ |
---|
1605 | def __init__(self,fileName=None,*args,**kwargs): |
---|
1606 | AbstractArrayDescriptor.__init__(self,*args,**kwargs) |
---|
1607 | if fileName: |
---|
1608 | self.fileName = fileName |
---|
1609 | def fromXML(self,csmlFrag): |
---|
1610 | AbstractArrayDescriptor.fromXML(self,csmlFrag) |
---|
1611 | for frag in csmlFrag.getchildren(): |
---|
1612 | if frag.tag == CSML('fileName'): |
---|
1613 | self.fileName = frag.text |
---|
1614 | ## else: |
---|
1615 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
1616 | def toXML(self,csmlFrag): |
---|
1617 | csmlFrag = AbstractArrayDescriptor.toXML(self,csmlFrag) |
---|
1618 | if hasattr(self,'fileName'): |
---|
1619 | frag = Element(CSML('fileName')) |
---|
1620 | frag.text = self.fileName |
---|
1621 | csmlFrag.append(frag) |
---|
1622 | return csmlFrag |
---|
1623 | |
---|
1624 | class NASAAmesExtract(AbstractFileExtract): |
---|
1625 | """CSML class for NASA Ames file extract |
---|
1626 | |
---|
1627 | NASAAmesExtract(AbstractFileExtract): |
---|
1628 | +variableName: string |
---|
1629 | +index[0..1]: int |
---|
1630 | """ |
---|
1631 | def __init__(self,variableName=None,index=None,*args,**kwargs): |
---|
1632 | AbstractFileExtract.__init__(self,*args,**kwargs) |
---|
1633 | if variableName: |
---|
1634 | self.variableName = variableName |
---|
1635 | if index: |
---|
1636 | self.index = index |
---|
1637 | def fromXML(self,csmlFrag): |
---|
1638 | AbstractFileExtract.fromXML(self,csmlFrag) |
---|
1639 | for frag in csmlFrag.getchildren(): |
---|
1640 | if frag.tag == CSML('variableName'): |
---|
1641 | self.variableName = frag.text |
---|
1642 | elif frag.tag == CSML('index'): |
---|
1643 | self.index = int(frag.text) |
---|
1644 | ## else: |
---|
1645 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
1646 | def toXML(self,csmlFrag): |
---|
1647 | csmlFrag = AbstractFileExtract.toXML(self,csmlFrag) |
---|
1648 | frag = Element(CSML('variableName')) |
---|
1649 | frag.text = self.variableName |
---|
1650 | csmlFrag.append(frag) |
---|
1651 | if hasattr(self,'index'): |
---|
1652 | frag = Element(CSML('index')) |
---|
1653 | frag.text = str(self.index) |
---|
1654 | csmlFrag.append(frag) |
---|
1655 | return csmlFrag |
---|
1656 | |
---|
1657 | class NetCDFExtract(AbstractFileExtract): |
---|
1658 | """CSML class for netCDF file extract |
---|
1659 | |
---|
1660 | NetCDFExtract(AbstractFileExtract): |
---|
1661 | +variableName: string |
---|
1662 | """ |
---|
1663 | def __init__(self,variableName=None,*args,**kwargs): |
---|
1664 | AbstractFileExtract.__init__(self,*args,**kwargs) |
---|
1665 | if variableName: |
---|
1666 | self.variableName = variableName |
---|
1667 | def fromXML(self,csmlFrag): |
---|
1668 | AbstractFileExtract.fromXML(self,csmlFrag) |
---|
1669 | for frag in csmlFrag.getchildren(): |
---|
1670 | if frag.tag == CSML('variableName'): |
---|
1671 | self.variableName = frag.text |
---|
1672 | ## else: |
---|
1673 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
1674 | checkMandatory(self, 'variableName') |
---|
1675 | def toXML(self,csmlFrag): |
---|
1676 | csmlFrag = AbstractFileExtract.toXML(self,csmlFrag) |
---|
1677 | if hasattr(self, 'variableName'): |
---|
1678 | frag = Element(CSML('variableName')) |
---|
1679 | frag.text = self.variableName |
---|
1680 | csmlFrag.append(frag) |
---|
1681 | return csmlFrag |
---|
1682 | |
---|
1683 | class PPExtract(AbstractFileExtract): |
---|
1684 | """CSML class for PPExtract file extract |
---|
1685 | same as NetCDFExtract |
---|
1686 | PPExtract(AbstractFileExtract): |
---|
1687 | +variableName: string |
---|
1688 | """ |
---|
1689 | def __init__(self,variableName=None,*args,**kwargs): |
---|
1690 | AbstractFileExtract.__init__(self,*args,**kwargs) |
---|
1691 | if variableName: |
---|
1692 | self.variableName = variableName |
---|
1693 | def fromXML(self,csmlFrag): |
---|
1694 | AbstractFileExtract.fromXML(self,csmlFrag) |
---|
1695 | for frag in csmlFrag.getchildren(): |
---|
1696 | if frag.tag == CSML('variableName'): |
---|
1697 | self.variableName = frag.text |
---|
1698 | ## else: |
---|
1699 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
1700 | checkMandatory(self, 'variableName') |
---|
1701 | def toXML(self,csmlFrag): |
---|
1702 | csmlFrag = AbstractFileExtract.toXML(self,csmlFrag) |
---|
1703 | if hasattr(self, 'variableName'): |
---|
1704 | frag = Element(CSML('variableName')) |
---|
1705 | frag.text = self.variableName |
---|
1706 | csmlFrag.append(frag) |
---|
1707 | return csmlFrag |
---|
1708 | |
---|
1709 | class GRIBExtract(AbstractFileExtract): |
---|
1710 | """CSML class for GRIB file extract |
---|
1711 | |
---|
1712 | GRIBExtract(AbstractFileExtract): |
---|
1713 | +parameterCode: int |
---|
1714 | +recordNumber[0..1]: int |
---|
1715 | +fileOffset[0..1]: int |
---|
1716 | """ |
---|
1717 | def __init__(self,parameterCode=None,recordNumber=None,fileOffset=None, *args,**kwargs): |
---|
1718 | AbstractFileExtract.__init__(self,*args,**kwargs) |
---|
1719 | if parameterCode: |
---|
1720 | self.parameterCode = parameterCode |
---|
1721 | if recordNumber: |
---|
1722 | self.recordNumber = recordNumber |
---|
1723 | if fileOffset: |
---|
1724 | self.fileOffset = fileOffset |
---|
1725 | def fromXML(self,csmlFrag): |
---|
1726 | AbstractFileExtract.fromXML(self,csmlFrag) |
---|
1727 | for frag in csmlFrag.getchildren(): |
---|
1728 | if frag.tag == CSML('parameterCode'): |
---|
1729 | self.parameterCode = int(frag.text) |
---|
1730 | elif frag.tag == CSML('recordNumber'): |
---|
1731 | self.recordNumber = int(frag.text) |
---|
1732 | elif frag.tag == CSML('fileOffset'): |
---|
1733 | self.fileOffset = int(frag.text) |
---|
1734 | ## else: |
---|
1735 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
1736 | def toXML(self,csmlFrag): |
---|
1737 | csmlFrag = AbstractFileExtract.toXML(self,csmlFrag) |
---|
1738 | if hasattr(self,'parameterCode'): |
---|
1739 | frag = Element(CSML('parameterCode')) |
---|
1740 | frag.text = str(self.parameterCode) |
---|
1741 | csmlFrag.append(frag) |
---|
1742 | if hasattr(self,'recordNumber'): |
---|
1743 | frag = Element(CSML('recordNumber')) |
---|
1744 | frag.text = str(self.recordNumber) |
---|
1745 | csmlFrag.append(frag) |
---|
1746 | if hasattr(self,'fileOffset'): |
---|
1747 | frag = Element(CSML('fileOffset')) |
---|
1748 | frag.text = str(self.fileOffset) |
---|
1749 | csmlFrag.append(frag) |
---|
1750 | return csmlFrag |
---|
1751 | |
---|
1752 | class DirectPositionList(AssociationAttributeGroup, SRSReferenceGroup,SRSInformationGroup): |
---|
1753 | #class representing a DirectPositionList |
---|
1754 | def __init__(self, order=None, vals=None,*args,**kwargs): |
---|
1755 | if order: |
---|
1756 | self.order=order |
---|
1757 | if vals: |
---|
1758 | self.vals=vals |
---|
1759 | AssociationAttributeGroup.__init__(self,*args,**kwargs) |
---|
1760 | SRSReferenceGroup.__init__(self,*args,**kwargs) |
---|
1761 | SRSInformationGroup.__init__(self,*args,**kwargs) |
---|
1762 | def fromXML(self,csmlFrag): |
---|
1763 | AssociationAttributeGroup.fromXML(self,csmlFrag) |
---|
1764 | SRSReferenceGroup.fromXML(self,csmlFrag) |
---|
1765 | SRSInformationGroup.fromXML(self,csmlFrag) |
---|
1766 | self.vals=csmlFrag.text |
---|
1767 | if csmlFrag.attrib.has_key('order'): |
---|
1768 | self.order=csmlFrag.attrib['order'] |
---|
1769 | def toXML(self,csmlFrag): |
---|
1770 | AssociationAttributeGroup.toXML(self,csmlFrag) |
---|
1771 | SRSReferenceGroup.toXML(self,csmlFrag) |
---|
1772 | SRSInformationGroup.toXML(self,csmlFrag) |
---|
1773 | csmlFrag.text=self.vals |
---|
1774 | if hasattr(self,'order'): |
---|
1775 | csmlFrag.attrib['order']=self.order |
---|
1776 | return csmlFrag |
---|
1777 | |
---|
1778 | class MappingRule(MutableString): |
---|
1779 | """Class representing a GML MappingRule element(string): |
---|
1780 | """ |
---|
1781 | def __init__(self,val=''): |
---|
1782 | MutableString.__init__(self,val) |
---|
1783 | def fromXML(self,csmlFrag): |
---|
1784 | self.data = csmlFrag.text |
---|
1785 | if csmlFrag.attrib.has_key('scanOrder'): |
---|
1786 | self.scanOrder=csmlFrag.attrib['scanOrder'] |
---|
1787 | def toXML(self,csmlFrag): |
---|
1788 | csmlFrag.text = self.data |
---|
1789 | if hasattr(self,'scanOrder'): |
---|
1790 | csmlFrag.attrib['scanOrder']=self.scanOrder |
---|
1791 | return csmlFrag |
---|
1792 | |
---|
1793 | |
---|
1794 | |
---|
1795 | |
---|
1796 | |
---|
1797 | class AbstractDiscreteCoverage(AbstractGML): |
---|
1798 | #note, does not inherit directly from AbstractGML but is sufficient for CSML purposes to inherit the standard GML attributes |
---|
1799 | #GML AbstractDiscreteCoverage Class |
---|
1800 | def __init__(self,rangeSet=None,coverageFunction=None,*args,**kwargs): |
---|
1801 | AbstractGML.__init__(self,*args,**kwargs) |
---|
1802 | if rangeSet: |
---|
1803 | self.rangeSet=rangeSet |
---|
1804 | if coverageFunction: |
---|
1805 | self.coverageFunction=coverageFunction |
---|
1806 | |
---|
1807 | def fromXML(self,csmlFrag): |
---|
1808 | AbstractGML.fromXML(self,csmlFrag) |
---|
1809 | for frag in csmlFrag.getchildren(): |
---|
1810 | if frag.tag == GML('rangeSet'): |
---|
1811 | self.rangeSet=RangeSet() |
---|
1812 | self.rangeSet.fromXML(frag) |
---|
1813 | if frag.tag == GML('coverageFunction'): |
---|
1814 | self.coverageFunction=MappingRule() |
---|
1815 | for subFrag in frag.getchildren(): |
---|
1816 | if subFrag.tag==CSML('MappingRule'): |
---|
1817 | self.coverageFunction.fromXML(subFrag) |
---|
1818 | |
---|
1819 | |
---|
1820 | def toXML(self,csmlFrag): |
---|
1821 | AbstractGML.toXML(self,csmlFrag) |
---|
1822 | if hasattr(self,'rangeSet'): |
---|
1823 | frag = Element(GML('rangeSet')) |
---|
1824 | RangeSet.toXML(self.rangeSet,frag) |
---|
1825 | csmlFrag.append(frag) |
---|
1826 | if hasattr(self,'coverageFunction'): |
---|
1827 | frag = Element(GML('coverageFunction')) |
---|
1828 | subFrag=Element(CSML('MappingRule')) |
---|
1829 | MappingRule.toXML(self.coverageFunction,subFrag) |
---|
1830 | frag.append(subFrag) |
---|
1831 | csmlFrag.append(frag) |
---|
1832 | return csmlFrag |
---|
1833 | |
---|
1834 | class AbstractCoverageFeature(AbstractDiscreteCoverage): |
---|
1835 | #CSML Abstract Coverage FT class |
---|
1836 | # AbstractCoverageFeature(AbstractDiscreteCoverage) |
---|
1837 | # + om:parameter:PhenomenonPropertyType |
---|
1838 | |
---|
1839 | def __init__(self, parameter=None, *args,**kwargs): |
---|
1840 | AbstractDiscreteCoverage.__init__(self,*args,**kwargs) |
---|
1841 | if parameter: |
---|
1842 | self.parameter=parameter |
---|
1843 | def fromXML(self,csmlFrag): |
---|
1844 | AbstractDiscreteCoverage.fromXML(self,csmlFrag) |
---|
1845 | for frag in csmlFrag.getchildren(): |
---|
1846 | if frag.tag == CSML('parameter'): |
---|
1847 | self.parameter=None |
---|
1848 | if frag.getchildren() == []: |
---|
1849 | self.parameter=Phenomenon() |
---|
1850 | self.parameter.fromXML(frag) |
---|
1851 | else: |
---|
1852 | subFrag=frag.getchildren()[0] |
---|
1853 | if subFrag.tag == OM('Phenomenon'): |
---|
1854 | self.parameter = Phenomenon() |
---|
1855 | elif subFrag.tag == OM('CompositePhenomenon'): |
---|
1856 | self.parameter = CompositePhenomenon() |
---|
1857 | elif subFrag.tag == OM('ParameterisedPhenomenon'): |
---|
1858 | self.parameter = ParameterisedPhenomenon() |
---|
1859 | self.parameter.fromXML(subFrag) |
---|
1860 | |
---|
1861 | def toXML(self,csmlFrag): |
---|
1862 | AbstractDiscreteCoverage.toXML(self,csmlFrag) |
---|
1863 | if hasattr(self,'parameter'): |
---|
1864 | frag = Element(CSML('parameter')) |
---|
1865 | if isinstance(self.parameter,ParameterisedPhenomenon): |
---|
1866 | subFrag=Element(OM('ParameterisedPhenomenon')) |
---|
1867 | ParameterisedPhenomenon.toXML(self.parameter,subFrag) |
---|
1868 | frag.append(subFrag) |
---|
1869 | csmlFrag.append(frag) |
---|
1870 | elif isinstance(self.parameter,CompositePhenomenon): |
---|
1871 | subFrag=Element(OM('CompositePhenomenon')) |
---|
1872 | CompositePhenomenon.toXML(self.parameter,subFrag) |
---|
1873 | frag.append(subFrag) |
---|
1874 | csmlFrag.append(frag) |
---|
1875 | elif isinstance(self.parameter,Phenomenon): |
---|
1876 | Phenomenon.toXML(self.parameter,frag) |
---|
1877 | subFrag=Element(OM('Phenomenon')) |
---|
1878 | Phenomenon.toXML(self.parameter,subFrag) |
---|
1879 | if subFrag.attrib != frag.attrib: |
---|
1880 | frag.append(subFrag) |
---|
1881 | csmlFrag.append(frag) |
---|
1882 | |
---|
1883 | |
---|
1884 | #frag.attrib[XLINK('href')] = self.href |
---|
1885 | |
---|
1886 | return csmlFrag |
---|
1887 | |
---|
1888 | |
---|
1889 | class AbstractStaticCoverageFeature(AbstractCoverageFeature): |
---|
1890 | #CSML Abstract Static Coverage FT class |
---|
1891 | def __init__(self,*args,**kwargs): |
---|
1892 | AbstractCoverageFeature.__init__(self,*args,**kwargs) |
---|
1893 | def fromXML(self,csmlFrag): |
---|
1894 | AbstractCoverageFeature.fromXML(self,csmlFrag) |
---|
1895 | def toXML(self,csmlFrag): |
---|
1896 | AbstractCoverageFeature.toXML(self,csmlFrag) |
---|
1897 | return csmlFrag |
---|
1898 | |
---|
1899 | class AbstractSeriesCoverageFeature(AbstractCoverageFeature): |
---|
1900 | #CSML Abstract Series Coverage FT class |
---|
1901 | def __init__(self,*args,**kwargs): |
---|
1902 | AbstractCoverageFeature.__init__(self,*args,**kwargs) |
---|
1903 | def fromXML(self,csmlFrag): |
---|
1904 | AbstractCoverageFeature.fromXML(self,csmlFrag) |
---|
1905 | def toXML(self,csmlFrag): |
---|
1906 | AbstractCoverageFeature.toXML(self,csmlFrag) |
---|
1907 | return csmlFrag |
---|
1908 | |
---|
1909 | class AbstractDomain: |
---|
1910 | #CSML AbstractDomain class |
---|
1911 | # AbstractDomain() |
---|
1912 | # +csml:domainReference |
---|
1913 | # +csml:domainComplement [0...1] |
---|
1914 | |
---|
1915 | def __init__(self,domainReference=None,domainComplement=None, *args,**kwargs): |
---|
1916 | if domainReference: |
---|
1917 | self.domainReference=domainReference |
---|
1918 | if domainComplement: |
---|
1919 | self.domainComplement=domainComplement |
---|
1920 | def fromXML(self,csmlFrag): |
---|
1921 | for frag in csmlFrag.getchildren(): |
---|
1922 | if frag.tag == CSML('domainReference'): |
---|
1923 | subfrag=frag.getchildren()[0] |
---|
1924 | if subfrag.tag==CSML('Position'): |
---|
1925 | self.domainReference=Position() |
---|
1926 | elif subfrag.tag == CSML('Trajectory'): |
---|
1927 | self.domainReference=Trajectory() |
---|
1928 | elif subfrag.tag==CSML('OrientedPosition'): |
---|
1929 | self.domainReference=OrientedPosition() |
---|
1930 | elif subfrag.tag == CSML('OrientedTrajectory'): |
---|
1931 | self.domainReference=OrientedTrajectory() |
---|
1932 | elif subfrag.tag == GML('TimeInstant'): |
---|
1933 | self.domainReference=TimeInstant() |
---|
1934 | elif subfrag.tag == GML('TimePositionList'): |
---|
1935 | self.domainReference=TimePositionList() |
---|
1936 | self.domainReference.fromXML(subfrag) |
---|
1937 | |
---|
1938 | if frag.tag == CSML('domainComplement'): |
---|
1939 | subfrag=frag.getchildren()[0] |
---|
1940 | if subfrag.tag==CSML('DirectPositionList'): |
---|
1941 | self.domainComplement=DirectPositionList() |
---|
1942 | self.domainComplement.fromXML(subfrag) |
---|
1943 | elif subfrag.tag==CSML('Grid'): |
---|
1944 | self.domainComplement=Grid() |
---|
1945 | self.domainComplement.fromXML(subfrag) |
---|
1946 | def toXML(self,csmlFrag): |
---|
1947 | if hasattr(self,'domainReference'): |
---|
1948 | frag = Element(CSML('domainReference')) |
---|
1949 | #Note self.domainReference contains a Position or a Trajectory or a OrientedPosition etc... object |
---|
1950 | #self.domainReference.toXML(frag) |
---|
1951 | if isinstance(self.domainReference,OrientedPosition): |
---|
1952 | subFrag=Element(CSML('OrientedPosition')) |
---|
1953 | self.domainReference.toXML(subFrag) |
---|
1954 | frag.append(subFrag) |
---|
1955 | csmlFrag.append(frag) |
---|
1956 | elif isinstance(self.domainReference,OrientedTrajectory): |
---|
1957 | subFrag=Element(CSML('OrientedTrajectory')) |
---|
1958 | self.domainReference.toXML(subFrag) |
---|
1959 | frag.append(subFrag) |
---|
1960 | csmlFrag.append(frag) |
---|
1961 | elif isinstance(self.domainReference,Position): |
---|
1962 | subFrag=Element(CSML('Position')) |
---|
1963 | self.domainReference.toXML(subFrag) |
---|
1964 | frag.append(subFrag) |
---|
1965 | csmlFrag.append(frag) |
---|
1966 | elif isinstance(self.domainReference,Trajectory): |
---|
1967 | subFrag=Element(CSML('Trajectory')) |
---|
1968 | self.domainReference.toXML(subFrag) |
---|
1969 | frag.append(subFrag) |
---|
1970 | csmlFrag.append(frag) |
---|
1971 | elif isinstance(self.domainReference,TimeInstant): |
---|
1972 | subFrag=Element(GML('TimeInstant')) |
---|
1973 | self.domainReference.toXML(subFrag) |
---|
1974 | frag.append(subFrag) |
---|
1975 | csmlFrag.append(frag) |
---|
1976 | elif isinstance(self.domainReference,TimePositionList): |
---|
1977 | subFrag=Element(GML('TimePositionList')) |
---|
1978 | self.domainReference.toXML(subFrag) |
---|
1979 | frag.append(subFrag) |
---|
1980 | csmlFrag.append(frag) |
---|
1981 | if hasattr(self,'domainComplement'): |
---|
1982 | frag = Element(CSML('domainComplement')) |
---|
1983 | if isinstance(self.domainComplement,DirectPositionList): |
---|
1984 | subFrag=Element(CSML('DirectPositionList')) |
---|
1985 | self.domainComplement.toXML(subFrag) |
---|
1986 | frag.append(subFrag) |
---|
1987 | csmlFrag.append(frag) |
---|
1988 | elif isinstance(self.domainComplement,Grid): |
---|
1989 | subFrag=Element(CSML('Grid')) |
---|
1990 | self.domainComplement.toXML(subFrag) |
---|
1991 | frag.append(subFrag) |
---|
1992 | csmlFrag.append(frag) |
---|
1993 | return csmlFrag |
---|
1994 | |
---|
1995 | |
---|
1996 | class EnvelopeWithTimePeriod: |
---|
1997 | # CSML EnvelopeWithTimePeriod class |
---|
1998 | # EnvelopeWithTimePeriod(): |
---|
1999 | # +gml:lowerCorner:DirectPosition |
---|
2000 | # +gml:upperCorner:DirectPosition |
---|
2001 | # +gml:timePosition [2] ? |
---|
2002 | |
---|
2003 | def __init__(self, srsName=None,lowerCorner=None,upperCorner=None, timePosition=None, timePosition2=None): |
---|
2004 | if srsName: |
---|
2005 | self.srsName=srsName |
---|
2006 | if lowerCorner: |
---|
2007 | self.lowerCorner=lowerCorner |
---|
2008 | if upperCorner: |
---|
2009 | self.upperCorner=upperCorner |
---|
2010 | if timePosition: |
---|
2011 | self.timePosition=timePosition |
---|
2012 | if timePosition2: |
---|
2013 | self.timePosition2=timePosition2 |
---|
2014 | def fromXML(self,csmlFrag): |
---|
2015 | EnvTPfrag=csmlFrag.getchildren()[0] |
---|
2016 | for frag in EnvTPfrag.getchildren(): |
---|
2017 | if frag.attrib.has_key('srsName'): |
---|
2018 | self.srsName=frag.attrib['srsName'] |
---|
2019 | if frag.tag == GML('lowerCorner'): |
---|
2020 | #self.lowerCorner=frag.text |
---|
2021 | self.lowerCorner=DirectPosition() |
---|
2022 | DirectPosition.fromXML(self.lowerCorner, frag) |
---|
2023 | if frag.tag == GML('upperCorner'): |
---|
2024 | #self.upperCorner=frag.text |
---|
2025 | self.upperCorner=DirectPosition() |
---|
2026 | DirectPosition.fromXML(self.upperCorner, frag) |
---|
2027 | if frag.tag == GML('timePosition'): |
---|
2028 | if hasattr(self, 'timePosition'): |
---|
2029 | self.timePosition2=frag.text |
---|
2030 | else: |
---|
2031 | self.timePosition=frag.text |
---|
2032 | def toXML(self,csmlFrag): |
---|
2033 | if hasattr(self,'srsName'): |
---|
2034 | csmlFrag.attrib['srsName'] = self.srsName |
---|
2035 | if hasattr(self,'lowerCorner'): |
---|
2036 | frag=Element(GML('lowerCorner')) |
---|
2037 | # frag.text=self.lowerCorner |
---|
2038 | DirectPosition.toXML(self.lowerCorner,frag) |
---|
2039 | csmlFrag.append(frag) |
---|
2040 | if hasattr(self,'upperCorner'): |
---|
2041 | frag=Element(GML('upperCorner')) |
---|
2042 | #frag.text=self.upperCorner |
---|
2043 | DirectPosition.toXML(self.upperCorner,frag) |
---|
2044 | csmlFrag.append(frag) |
---|
2045 | if hasattr(self,'timePosition'): |
---|
2046 | frag=Element(GML('timePosition')) |
---|
2047 | frag.text=self.timePosition |
---|
2048 | csmlFrag.append(frag) |
---|
2049 | if hasattr(self,'timePosition2'): |
---|
2050 | frag=Element(GML('timePosition')) |
---|
2051 | frag.text=self.timePosition2 |
---|
2052 | csmlFrag.append(frag) |
---|
2053 | return csmlFrag |
---|
2054 | |
---|
2055 | |
---|
2056 | |
---|
2057 | class AngleList: |
---|
2058 | #Should really inherit from MeasureList, but not implemented. |
---|
2059 | #class AngleList |
---|
2060 | #+uom[1]:anyURI |
---|
2061 | #+double[0...1] |
---|
2062 | def __init__(self,uom=None, vals=None): |
---|
2063 | if uom: |
---|
2064 | self.uom=uom |
---|
2065 | if vals: |
---|
2066 | self.vals=vals |
---|
2067 | def fromXML(self,csmlFrag): |
---|
2068 | self.vals=csmlFrag.text |
---|
2069 | if csmlFrag.attrib.has_key('uom'): |
---|
2070 | self.uom = csmlFrag.attrib['uom'] |
---|
2071 | checkMandatory(self,'uom') |
---|
2072 | def toXML(self, csmlFrag): |
---|
2073 | if hasattr(self,'vals'): |
---|
2074 | csmlFrag.text = self.vals |
---|
2075 | if hasattr(self,'uom'): |
---|
2076 | csmlFrag.attrib[('uom')] = self.uom |
---|
2077 | return csmlFrag |
---|
2078 | |
---|
2079 | class DirectionVectorList: |
---|
2080 | def __init__(self, horizontalAngle=None, verticalAngle=None): |
---|
2081 | if horizontalAngle: |
---|
2082 | self.horizontalAngle=horizontalAngle |
---|
2083 | if verticalAngle: |
---|
2084 | self.verticalAngle=verticalAngle |
---|
2085 | def fromXML(self, csmlFrag): |
---|
2086 | for frag in csmlFrag.getchildren(): |
---|
2087 | if frag.tag==GML('horizontalAngle'): |
---|
2088 | self.horizontalAngle=AngleList() |
---|
2089 | AngleList.fromXML(self.horizontalAngle,frag) |
---|
2090 | elif frag.tag==GML('verticalAngle'): |
---|
2091 | self.verticalAngle=AngleList() |
---|
2092 | AngleList.fromXML(self.verticalAngle,frag) |
---|
2093 | def toXML(self,csmlFrag): |
---|
2094 | if hasattr(self,'horizontalAngle'): |
---|
2095 | frag = Element(GML('horizontalAngle')) |
---|
2096 | AngleList.toXML(self.horizontalAngle,frag) |
---|
2097 | csmlFrag.append(frag) |
---|
2098 | if hasattr(self,'verticalAngle'): |
---|
2099 | frag = Element(GML('verticalAngle')) |
---|
2100 | AngleList.toXML(self.verticalAngle,frag) |
---|
2101 | csmlFrag.append(frag) |
---|
2102 | return csmlFrag |
---|
2103 | |
---|
2104 | |
---|
2105 | class Position: |
---|
2106 | def __init__(self,srsName=None,axisLabels=None,uomLabels=None, location=None, time=None,*args,**kwargs): |
---|
2107 | if srsName: |
---|
2108 | self.srsName=srsName |
---|
2109 | if axisLabels: |
---|
2110 | self.axisLabels=axisLabels |
---|
2111 | if uomLabels: |
---|
2112 | self.uomLabels=uomLabels |
---|
2113 | if location: |
---|
2114 | self.location=location |
---|
2115 | if time: |
---|
2116 | self.time = time |
---|
2117 | def fromXML(self,csmlFrag): |
---|
2118 | if csmlFrag.attrib.has_key('srsName'): |
---|
2119 | self.srsName = csmlFrag.attrib['srsName'] |
---|
2120 | if csmlFrag.attrib.has_key('axisLabels'): |
---|
2121 | self.axisLabels = csmlFrag.attrib['axisLabels'] |
---|
2122 | if csmlFrag.attrib.has_key('uomLabels'): |
---|
2123 | self.uomLabels = csmlFrag.attrib['uomLabels'] |
---|
2124 | for frag in csmlFrag.getchildren(): |
---|
2125 | if frag.tag==CSML('location'): |
---|
2126 | self.location=frag.text |
---|
2127 | if frag.tag==CSML('time'): |
---|
2128 | self.time=frag.text |
---|
2129 | def toXML(self,csmlFrag): |
---|
2130 | #subFrag = Element(CSML('Position')) |
---|
2131 | if hasattr(self,'uomLabels'): |
---|
2132 | csmlFrag.attrib['uomLabels'] = self.uomLabels |
---|
2133 | if hasattr(self,'axisLabels'): |
---|
2134 | csmlFrag.attrib['axisLabels'] = self.axisLabels |
---|
2135 | if hasattr(self,'srsName'): |
---|
2136 | csmlFrag.attrib['srsName'] = self.srsName |
---|
2137 | if hasattr(self,'location'): |
---|
2138 | frag = Element(CSML('location')) |
---|
2139 | frag.text=self.location |
---|
2140 | csmlFrag.append(frag) |
---|
2141 | if hasattr(self,'time'): |
---|
2142 | frag = Element(CSML('time')) |
---|
2143 | frag.text=self.time |
---|
2144 | csmlFrag.append(frag) |
---|
2145 | return csmlFrag |
---|
2146 | |
---|
2147 | class OrientedPosition(Position): |
---|
2148 | def __init__(self, direction=None, *args,**kwargs): |
---|
2149 | Position.__init__(self, *args,**kwargs) |
---|
2150 | if direction: |
---|
2151 | self.direction=direction |
---|
2152 | def fromXML(self,csmlFrag): |
---|
2153 | Position.fromXML(self, csmlFrag) |
---|
2154 | for frag in csmlFrag.getchildren(): |
---|
2155 | if frag.tag==CSML('direction'): |
---|
2156 | self.direction=DirectionVectorList() |
---|
2157 | DirectionVectorList.fromXML(self.direction,frag) |
---|
2158 | def toXML(self, csmlFrag): |
---|
2159 | Position.toXML(self,csmlFrag) |
---|
2160 | if hasattr(self,'direction'): |
---|
2161 | frag = Element(CSML('direction')) |
---|
2162 | DirectionVectorList.toXML(self.direction,frag) |
---|
2163 | csmlFrag.append(frag) |
---|
2164 | return csmlFrag |
---|
2165 | |
---|
2166 | |
---|
2167 | |
---|
2168 | class Trajectory(SRSReferenceGroup): |
---|
2169 | def __init__(self,locations=None,times=None,*args,**kwargs): |
---|
2170 | |
---|
2171 | if locations: |
---|
2172 | self.locations=locations |
---|
2173 | if times: |
---|
2174 | self.times = times |
---|
2175 | SRSReferenceGroup.__init__(self,*args,**kwargs) |
---|
2176 | def fromXML(self,csmlFrag): |
---|
2177 | SRSReferenceGroup.fromXML(self,csmlFrag) |
---|
2178 | for frag in csmlFrag.getchildren(): |
---|
2179 | if frag.tag==CSML('locations'): |
---|
2180 | self.locations=DirectPositionList() |
---|
2181 | DirectPositionList.fromXML(self.locations,frag) |
---|
2182 | if frag.tag==CSML('times'): |
---|
2183 | self.times=TimePositionList() |
---|
2184 | TimePositionList.fromXML(self.times,frag) |
---|
2185 | def toXML(self,csmlFrag): |
---|
2186 | SRSReferenceGroup.toXML(self,csmlFrag) |
---|
2187 | if hasattr(self,'srsName'): |
---|
2188 | csmlFrag.attrib['srsName'] = self.srsName |
---|
2189 | if hasattr(self,'locations'): |
---|
2190 | frag = Element(CSML('locations')) |
---|
2191 | frag=DirectPositionList.toXML(self.locations,frag) |
---|
2192 | csmlFrag.append(frag) |
---|
2193 | if hasattr(self,'times'): |
---|
2194 | frag = Element(CSML('times')) |
---|
2195 | TimePositionList.toXML(self.times, frag) |
---|
2196 | csmlFrag.append(frag) |
---|
2197 | return csmlFrag |
---|
2198 | |
---|
2199 | class OrientedTrajectory(Trajectory): |
---|
2200 | def __init__(self, direction=None, *args,**kwargs): |
---|
2201 | Trajectory.__init__(self, *args,**kwargs) |
---|
2202 | if direction: |
---|
2203 | self.direction=direction |
---|
2204 | def fromXML(self,csmlFrag): |
---|
2205 | Trajectory.fromXML(self, csmlFrag) |
---|
2206 | for frag in csmlFrag.getchildren(): |
---|
2207 | if frag.tag==CSML('direction'): |
---|
2208 | self.direction=DirectionVectorList() |
---|
2209 | DirectionVectorList.fromXML(self.direction,frag) |
---|
2210 | def toXML(self, csmlFrag): |
---|
2211 | Trajectory.toXML(self,csmlFrag) |
---|
2212 | if hasattr(self,'direction'): |
---|
2213 | frag = Element(CSML('direction')) |
---|
2214 | DirectionVectorList.toXML(self.direction,frag) |
---|
2215 | csmlFrag.append(frag) |
---|
2216 | return csmlFrag |
---|
2217 | |
---|
2218 | class AbstractGeometryType(AbstractGML): |
---|
2219 | def __init__(self, low=None, high=None): |
---|
2220 | AbstractGML.__init__(self) |
---|
2221 | if low: |
---|
2222 | self.low=low |
---|
2223 | if high: |
---|
2224 | self.high=high |
---|
2225 | def fromXML(self, csmlFrag): |
---|
2226 | AbstractGML.fromXML(self,csmlFrag) |
---|
2227 | def toXML(self,csmlFrag): |
---|
2228 | AbstractGML.toXML(self,csmlFrag) |
---|
2229 | return csmlFrag |
---|
2230 | |
---|
2231 | class GridEnvelope: |
---|
2232 | def __init__(self, low=None, high = None): |
---|
2233 | if low: |
---|
2234 | self.low = low |
---|
2235 | if high: |
---|
2236 | self.high = high |
---|
2237 | def fromXML(self, csmlFrag): |
---|
2238 | frag = csmlFrag.getchildren()[0] |
---|
2239 | for subFrag in frag.getchildren(): |
---|
2240 | if subFrag.tag == GML('low'): |
---|
2241 | self.low=subFrag.text |
---|
2242 | elif subFrag.tag == GML('high'): |
---|
2243 | self.high=subFrag.text |
---|
2244 | def toXML(self,csmlFrag): |
---|
2245 | if hasattr(self, 'low'): |
---|
2246 | frag=Element(GML('low')) |
---|
2247 | frag.text=self.low |
---|
2248 | csmlFrag.append(frag) |
---|
2249 | if hasattr(self, 'high'): |
---|
2250 | frag=Element(GML('high')) |
---|
2251 | frag.text=self.high |
---|
2252 | csmlFrag.append(frag) |
---|
2253 | return csmlFrag |
---|
2254 | |
---|
2255 | class GmlGrid(AbstractGeometryType): |
---|
2256 | #Class GmlGrid, representing a gml:Grid element. |
---|
2257 | # +dimension positiveInteger [1] |
---|
2258 | # +gml:limits (gml:GridLimitsType) </gml:limits> [1] |
---|
2259 | #+gml:axisNames (string) [1..*] |
---|
2260 | def __init__(self,dimension=None,limits=None,axisNames=None): |
---|
2261 | AbstractGeometryType.__init__(self) |
---|
2262 | if dimension: |
---|
2263 | self.dimension=dimension |
---|
2264 | if limits: |
---|
2265 | self.limits=limits |
---|
2266 | if axisNames: |
---|
2267 | self.axisNames=axisNames |
---|
2268 | def fromXML(self, csmlFrag): |
---|
2269 | AbstractGeometryType.fromXML(self,csmlFrag) |
---|
2270 | for frag in csmlFrag.getchildren(): |
---|
2271 | if frag.tag == GML('limits'): |
---|
2272 | self.limits=GridEnvelope() |
---|
2273 | GridEnvelope.fromXML(self.limits,frag) |
---|
2274 | elif frag.tag == GML('axisName'): |
---|
2275 | checkArrayAttrib(self,'axisNames') |
---|
2276 | self.axisNames.append(frag.text) |
---|
2277 | def toXML(self,csmlFrag): |
---|
2278 | AbstractGeometryType.toXML(self,csmlFrag) |
---|
2279 | if hasattr(self, 'limits'): |
---|
2280 | frag=Element(GML('limits')) |
---|
2281 | subFrag =Element(GML('GridEnvelope')) |
---|
2282 | GridEnvelope.toXML(self.limits, subFrag) |
---|
2283 | frag.append(subFrag) |
---|
2284 | csmlFrag.append(frag) |
---|
2285 | if hasattr(self, 'axisNames'): |
---|
2286 | for axis in self.axisNames: |
---|
2287 | frag=Element(GML('axisName')) |
---|
2288 | frag.text =axis |
---|
2289 | csmlFrag.append(frag) |
---|
2290 | return csmlFrag |
---|
2291 | |
---|
2292 | class GridOrdinateDescription: |
---|
2293 | #Class GridOrdinateDescription: |
---|
2294 | #+gridAxesSpanned |
---|
2295 | #+sequenceRule |
---|
2296 | #+definesAxis,attrib -href |
---|
2297 | #+axisValues |
---|
2298 | |
---|
2299 | def __init__(self, gridAxesSpanned=None,sequenceRule=None, definesAxis=None, axisValues=None,href=None): |
---|
2300 | if gridAxesSpanned: |
---|
2301 | self.gridAxesSpanned=gridAxesSpanned |
---|
2302 | if sequenceRule: |
---|
2303 | self.sequenceRule=sequenceRule |
---|
2304 | if definesAxis: |
---|
2305 | self.definesAxis=definesAxis |
---|
2306 | if href: |
---|
2307 | self.href = href |
---|
2308 | if axisValues: |
---|
2309 | self.axisValues=axisValues |
---|
2310 | |
---|
2311 | def fromXML(self,csmlFrag): |
---|
2312 | for frag in csmlFrag.getchildren(): |
---|
2313 | if frag.tag ==CSML('gridAxesSpanned'): |
---|
2314 | self.gridAxesSpanned=frag.text |
---|
2315 | elif frag.tag ==CSML('sequenceRule'): |
---|
2316 | self.sequenceRule=frag.text |
---|
2317 | elif frag.tag ==CSML('definesAxis'): |
---|
2318 | self.definesAxis=frag.text |
---|
2319 | if frag.attrib.has_key(XLINK('href')): |
---|
2320 | self.href = frag.attrib[XLINK('href')] |
---|
2321 | elif frag.tag ==CSML('axisValues'): |
---|
2322 | if frag.getchildren() !=[]: |
---|
2323 | subFrag= frag.getchildren()[0] |
---|
2324 | if subFrag.tag == CSML ('NetCDFExtract'): |
---|
2325 | self.axisValues=NetCDFExtract() |
---|
2326 | NetCDFExtract.fromXML(self.axisValues, subFrag) |
---|
2327 | elif subFrag.tag == CSML ('NASAAmesExtract'): |
---|
2328 | self.axisValues=NASAAmesExtract() |
---|
2329 | NASAAmesExtract.fromXML(self.axisValues, subFrag) |
---|
2330 | elif subFrag.tag == CSML ('GRIBExtract'): |
---|
2331 | self.axisValues=GRIBExtract() |
---|
2332 | GRIBExtract.fromXML(self.axisValues, subFrag) |
---|
2333 | elif subFrag.tag == CSML ('PPExtract'): |
---|
2334 | self.axisValues=PPExtract() |
---|
2335 | PPExtract.fromXML(self.axisValues, subFrag) |
---|
2336 | else: |
---|
2337 | self.axisValues=frag.text |
---|
2338 | |
---|
2339 | |
---|
2340 | def toXML(self, csmlFrag): |
---|
2341 | if hasattr(self, 'gridAxesSpanned'): |
---|
2342 | frag=Element(CSML('gridAxesSpanned')) |
---|
2343 | frag.text = self.gridAxesSpanned |
---|
2344 | csmlFrag.append(frag) |
---|
2345 | if hasattr(self, 'sequenceRule'): |
---|
2346 | frag=Element(CSML('sequenceRule')) |
---|
2347 | frag.text = self.sequenceRule |
---|
2348 | csmlFrag.append(frag) |
---|
2349 | if hasattr(self, 'definesAxis'): |
---|
2350 | frag=Element(CSML('definesAxis')) |
---|
2351 | frag.text = self.definesAxis |
---|
2352 | if hasattr(self, 'href'): |
---|
2353 | frag.attrib[XLINK('href')] = self.href |
---|
2354 | csmlFrag.append(frag) |
---|
2355 | if hasattr(self, 'axisValues'): |
---|
2356 | frag=Element(CSML('axisValues')) |
---|
2357 | if isinstance(self.axisValues,NetCDFExtract): |
---|
2358 | subFrag=Element(CSML('NetCDFExtract')) |
---|
2359 | NetCDFExtract.toXML(self.axisValues,subFrag) |
---|
2360 | frag.append(subFrag) |
---|
2361 | elif isinstance(self.axisValues,NASAAmesExtract): |
---|
2362 | subFrag=Element(CSML('NASAAmesExtract')) |
---|
2363 | NASAAmesExtract.toXML(self.axisValues,subFrag) |
---|
2364 | frag.append(subFrag) |
---|
2365 | elif isinstance(self.axisValues,GRIBExtract): |
---|
2366 | subFrag=Element(CSML('GRIBExtract')) |
---|
2367 | GRIBExtract.toXML(self.axisValues,subFrag) |
---|
2368 | frag.append(subFrag) |
---|
2369 | elif isinstance(self.axisValues,PPExtract): |
---|
2370 | subFrag=Element(CSML('PPExtract')) |
---|
2371 | PPExtract.toXML(self.axisValues,subFrag) |
---|
2372 | frag.append(subFrag) |
---|
2373 | else: |
---|
2374 | frag.text = self.axisValues |
---|
2375 | csmlFrag.append(frag) |
---|
2376 | return csmlFrag |
---|
2377 | |
---|
2378 | |
---|
2379 | class Grid(GmlGrid): |
---|
2380 | #Class GmlGrid representing a gml:Grid |
---|
2381 | # + dimension(attrib) [1] |
---|
2382 | # +ordinate [1..*] |
---|
2383 | def __init__(self,srsName=None,srsDimension=None,dimension=None,ordinates=None): |
---|
2384 | GmlGrid.__init__(self) |
---|
2385 | if srsName: |
---|
2386 | self.srsName=srsName |
---|
2387 | if srsDimension: |
---|
2388 | self.srsDimension=srsDimension |
---|
2389 | if dimension: |
---|
2390 | self.dimension=dimension |
---|
2391 | if ordinates: |
---|
2392 | self.ordinates=ordinates |
---|
2393 | def fromXML(self, csmlFrag): |
---|
2394 | GmlGrid.fromXML(self,csmlFrag) |
---|
2395 | if csmlFrag.attrib.has_key('srsName'): |
---|
2396 | self.srsName = csmlFrag.attrib['srsName'] |
---|
2397 | if csmlFrag.attrib.has_key('srsDimension'): |
---|
2398 | self.srsDimension = csmlFrag.attrib['srsDimension'] |
---|
2399 | if csmlFrag.attrib.has_key('dimension'): |
---|
2400 | self.dimension = csmlFrag.attrib['dimension'] |
---|
2401 | for frag in csmlFrag: |
---|
2402 | if frag.tag==CSML('ordinate'): |
---|
2403 | checkArrayAttrib(self,'ordinates') |
---|
2404 | ordinate=GridOrdinateDescription() |
---|
2405 | GridOrdinateDescription.fromXML(ordinate, frag) |
---|
2406 | self.ordinates.append(ordinate) |
---|
2407 | def toXML(self,csmlFrag): |
---|
2408 | GmlGrid.toXML(self,csmlFrag) |
---|
2409 | if hasattr(self, 'srsName'): |
---|
2410 | csmlFrag.attrib['srsName'] = self.srsName |
---|
2411 | if hasattr(self, 'srsDimension'): |
---|
2412 | csmlFrag.attrib['srsDimension'] = self.srsDimension |
---|
2413 | if hasattr(self, 'dimension'): |
---|
2414 | csmlFrag.attrib['dimension'] = self.dimension |
---|
2415 | |
---|
2416 | if hasattr(self, 'ordinates'): |
---|
2417 | for ordinate in self.ordinates: |
---|
2418 | frag=Element(CSML('ordinate')) |
---|
2419 | GridOrdinateDescription.toXML(ordinate, frag) |
---|
2420 | csmlFrag.append(frag) |
---|
2421 | return csmlFrag |
---|
2422 | |
---|
2423 | class TimeInstant: |
---|
2424 | def __init__(self, timePosition=None): |
---|
2425 | if timePosition: |
---|
2426 | self.timePosition=timePosition |
---|
2427 | def fromXML(self,csmlFrag): |
---|
2428 | for frag in csmlFrag.getchildren(): |
---|
2429 | if frag.tag==GML('timePosition'): |
---|
2430 | self.timePosition=frag.text |
---|
2431 | def toXML(self,csmlFrag): |
---|
2432 | if hasattr(self,'timePosition'): |
---|
2433 | frag = Element(GML('timePosition')) |
---|
2434 | frag.text=self.timePosition |
---|
2435 | csmlFrag.append(frag) |
---|
2436 | return csmlFrag |
---|
2437 | |
---|
2438 | class TimePositionList(AssociationAttributeGroup): |
---|
2439 | #class TimePositionList |
---|
2440 | #+frame[0..1]:anyURI |
---|
2441 | # + calendarEraName [0..1]:string (not implemented) |
---|
2442 | # +indeterminatePosition[0..1]:=gml:TimeIndeterminateValueType (not implemented) |
---|
2443 | def __init__(self, frame=None, timePositions=None,*args, **kwargs): |
---|
2444 | if frame: |
---|
2445 | self.frame=frame |
---|
2446 | if timePositions: |
---|
2447 | self.timePositions=timePositions |
---|
2448 | AssociationAttributeGroup.__init__(self,*args,**kwargs) |
---|
2449 | def fromXML(self,csmlFrag): |
---|
2450 | self.timePositions=csmlFrag.text |
---|
2451 | if csmlFrag.attrib.has_key('frame'): |
---|
2452 | self.frame = csmlFrag.attrib['frame'] |
---|
2453 | AssociationAttributeGroup.fromXML(self,csmlFrag) |
---|
2454 | def toXML(self,csmlFrag): |
---|
2455 | if hasattr(self,'timePositions'): |
---|
2456 | if isinstance(self.timePositions, NASAAmesExtract): |
---|
2457 | subFrag=Element(CSML('NASAAmesExtract')) |
---|
2458 | NASAAmesExtract.toXML(self.timePositions,subFrag) |
---|
2459 | csmlFrag.append(subFrag) |
---|
2460 | elif isinstance(self.timePositions, NetCDFExtract): |
---|
2461 | subFrag=Element(CSML('NetCDFExtract')) |
---|
2462 | NetCDFExtract.toXML(self.timePositions,subFrag) |
---|
2463 | csmlFrag.append(subFrag) |
---|
2464 | elif isinstance(self.timePositions, GRIBExtract): |
---|
2465 | subFrag=Element(CSML('GRIBExtract')) |
---|
2466 | GRIBExtract.toXML(self.timePositions,subFrag) |
---|
2467 | csmlFrag.append(subFrag) |
---|
2468 | elif isinstance(self.timePositions, PPExtract): |
---|
2469 | subFrag=Element(CSML('PPExtract')) |
---|
2470 | PPExtract.toXML(self.timePositions,subFrag) |
---|
2471 | csmlFrag.append(subFrag) |
---|
2472 | else: |
---|
2473 | csmlFrag.text=self.timePositions |
---|
2474 | if hasattr(self,'frame'): |
---|
2475 | csmlFrag.attrib['frame']=self.frame |
---|
2476 | AssociationAttributeGroup.toXML(self,csmlFrag) |
---|
2477 | return csmlFrag |
---|
2478 | |
---|
2479 | class Measure: |
---|
2480 | def __init__(self, uom=None, vals=None): |
---|
2481 | if uom: |
---|
2482 | self.uom=uom |
---|
2483 | if vals: |
---|
2484 | self.vals=vals |
---|
2485 | def fromXML(self,csmlFrag): |
---|
2486 | self.vals=csmlFrag.text |
---|
2487 | if csmlFrag.attrib.has_key('uom'): |
---|
2488 | self.uom = csmlFrag.attrib['uom'] |
---|
2489 | def toXML(self, csmlFrag): |
---|
2490 | frag = Element(GML('measure')) |
---|
2491 | if hasattr(self, 'vals'): |
---|
2492 | frag.text = self.vals |
---|
2493 | if hasattr(self,'uom'): |
---|
2494 | frag.attrib[('uom')] = self.uom |
---|
2495 | csmlFrag.append(frag) |
---|
2496 | return csmlFrag |
---|
2497 | |
---|
2498 | class MeasureOrNullList: |
---|
2499 | #class MeasureOrNullList: |
---|
2500 | # +uom[1]:anyURI |
---|
2501 | #Actually based on doubleOrNullList, but not modelled to that level of detail. |
---|
2502 | |
---|
2503 | def __init__(self, uom=None, val=None): |
---|
2504 | if uom: |
---|
2505 | self.uom=uom |
---|
2506 | if val: |
---|
2507 | self.val=val |
---|
2508 | def fromXML(self,csmlFrag): |
---|
2509 | self.val=csmlFrag.text |
---|
2510 | if csmlFrag.attrib.has_key('uom'): |
---|
2511 | self.uom = csmlFrag.attrib['uom'] |
---|
2512 | def toXML(self, csmlFrag): |
---|
2513 | if hasattr(self,'val'): |
---|
2514 | if isinstance(self.val, NASAAmesExtract): |
---|
2515 | subFrag=Element(CSML('NASAAmesExtract')) |
---|
2516 | NASAAmesExtract.toXML(self.val,subFrag) |
---|
2517 | csmlFrag.append(subFrag) |
---|
2518 | elif isinstance(self.val, NetCDFExtract): |
---|
2519 | subFrag=Element(CSML('NetCDFExtract')) |
---|
2520 | NetCDFExtract.toXML(self.val,subFrag) |
---|
2521 | csmlFrag.append(subFrag) |
---|
2522 | elif isinstance(self.val, GRIBExtract): |
---|
2523 | subFrag=Element(CSML('GRIBExtract')) |
---|
2524 | GRIBExtract.toXML(self.val,subFrag) |
---|
2525 | csmlFrag.append(subFrag) |
---|
2526 | elif isinstance(self.val, PPExtract): |
---|
2527 | subFrag=Element(CSML('PPExtract')) |
---|
2528 | PPExtract.toXML(self.val,subFrag) |
---|
2529 | csmlFrag.append(subFrag) |
---|
2530 | else: |
---|
2531 | csmlFrag.text = self.val |
---|
2532 | if hasattr(self,'uom'): |
---|
2533 | csmlFrag.attrib[('uom')] = self.uom |
---|
2534 | return csmlFrag |
---|
2535 | |
---|
2536 | class CompositeValue: |
---|
2537 | def __init__(self, valueComponents=None): |
---|
2538 | if valueComponents: |
---|
2539 | self.valueComponents=valueComponents |
---|
2540 | def fromXML(self,csmlFrag): |
---|
2541 | for frag in csmlFrag.getchildren(): |
---|
2542 | if frag.tag == GML('valueComponents'): |
---|
2543 | self.valueComponents = [] |
---|
2544 | for subFrag in frag.getchildren(): |
---|
2545 | if subFrag.tag == GML('measure'): |
---|
2546 | self.valueComponents.append(Measure()) |
---|
2547 | self.valueComponents[-1].fromXML(subFrag) |
---|
2548 | |
---|
2549 | def toXML(self, csmlFrag): |
---|
2550 | if hasattr(self,'valueComponents'): |
---|
2551 | frag=Element(GML('valueComponents')) |
---|
2552 | for valueComponent in self.valueComponents: |
---|
2553 | if isinstance(valueComponent,Measure): |
---|
2554 | subFrag=Element(GML('measure')) |
---|
2555 | Measure.toXML(valueComponent,subFrag) |
---|
2556 | frag.append(subFrag) |
---|
2557 | csmlFrag.append(frag) |
---|
2558 | return csmlFrag |
---|
2559 | |
---|
2560 | |
---|
2561 | |
---|
2562 | class DataBlock: |
---|
2563 | #class GML DataBlock |
---|
2564 | |
---|
2565 | #DataBlock() |
---|
2566 | #+gml:rangeParameters |
---|
2567 | def __init__(self,rangeParameters=None, doubleOrNullTupleList=None): |
---|
2568 | if rangeParameters: |
---|
2569 | self.rangeParameters=rangeParameters |
---|
2570 | if doubleOrNullTupleList: |
---|
2571 | self.doubleOrNullTupleList=doubleOrNullTupleList |
---|
2572 | def fromXML(self,csmlFrag): |
---|
2573 | for frag in csmlFrag.getchildren(): |
---|
2574 | if frag.tag == GML('rangeParameters'): |
---|
2575 | for subFrag in frag.getchildren(): |
---|
2576 | if subFrag.tag==GML('CompositeValue'): |
---|
2577 | self.rangeParameters=CompositeValue() |
---|
2578 | CompositeValue.fromXML(self.rangeParameters,subFrag) |
---|
2579 | if frag.tag == GML('doubleOrNullTupleList'): |
---|
2580 | self.doubleOrNullTupleList=frag.text |
---|
2581 | def toXML(self,csmlFrag): |
---|
2582 | if hasattr(self, 'rangeParameters'): |
---|
2583 | frag=Element(GML('rangeParameters')) |
---|
2584 | subFrag=Element(GML('CompositeValue')) |
---|
2585 | CompositeValue.toXML(self.rangeParameters, subFrag) |
---|
2586 | frag.append(subFrag) |
---|
2587 | csmlFrag.append(frag) |
---|
2588 | if hasattr(self,'doubleOrNullTupleList'): |
---|
2589 | frag=Element(GML('doubleOrNullTupleList')) |
---|
2590 | frag.text=self.doubleOrNullTupleList |
---|
2591 | csmlFrag.append(frag) |
---|
2592 | return csmlFrag |
---|
2593 | |
---|
2594 | |
---|
2595 | |
---|
2596 | class TypedCategory: |
---|
2597 | #class om:TypedCategory |
---|
2598 | # +axis (attrib) |
---|
2599 | # + codeSpace (attrib) |
---|
2600 | def __init__(self,axis=None, codeSpace=None,text=None,*args,**kwargs): |
---|
2601 | if axis: |
---|
2602 | self.axis=axis |
---|
2603 | if codeSpace: |
---|
2604 | self.codeSpace=codeSpace |
---|
2605 | if text: |
---|
2606 | self.text=text |
---|
2607 | def fromXML(self,csmlFrag): |
---|
2608 | if csmlFrag.attrib.has_key('axis'): |
---|
2609 | self.axis=csmlFrag.attrib['axis'] |
---|
2610 | if csmlFrag.attrib.has_key('codeSpace'): |
---|
2611 | self.codeSpace=csmlFrag.attrib['codeSpace'] |
---|
2612 | self.text=csmlFrag.text |
---|
2613 | def toXML(self,csmlFrag): |
---|
2614 | if hasattr(self,'axis'): |
---|
2615 | csmlFrag.attrib[('axis')] =self.axis |
---|
2616 | if hasattr(self,'codeSpace'): |
---|
2617 | csmlFrag.attrib[('codeSpace')] =self.codeSpace |
---|
2618 | csmlFrag.text=self.text |
---|
2619 | return csmlFrag |
---|
2620 | |
---|
2621 | class Phenomenon(Definition,AssociationAttributeGroup): |
---|
2622 | #class Obs& Measures: PhenomenonProperty |
---|
2623 | #Note, in this does not really inherit from AbstractGML, but for CMSL |
---|
2624 | #purposes it is used to pick up the basic description, id, name attributes |
---|
2625 | def __init__(self,*args,**kwargs): |
---|
2626 | #Unlike things that really inherit from AbstractGML, Phenomenon does not have a MetaDataProperty, so force it to be None. |
---|
2627 | self.MetaDataProperty=None |
---|
2628 | Definition.__init__(self, MetaDataProperty=self.MetaDataProperty,*args,**kwargs) |
---|
2629 | AssociationAttributeGroup.__init__(self,*args,**kwargs) |
---|
2630 | def fromXML(self,csmlFrag): |
---|
2631 | Definition.fromXML(self,csmlFrag) |
---|
2632 | AssociationAttributeGroup.fromXML(self,csmlFrag) |
---|
2633 | |
---|
2634 | def toXML(self,csmlFrag): |
---|
2635 | csmlFrag=Definition.toXML(self,csmlFrag) |
---|
2636 | csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag) |
---|
2637 | return csmlFrag |
---|
2638 | |
---|
2639 | |
---|
2640 | class OLD_CompositePhenomenon(Phenomenon): |
---|
2641 | #Class om:CompositePhenomenon |
---|
2642 | # + om:componentPhenomenon [1...*] |
---|
2643 | def __init__(self,componentPhenomenon=None,*args,**kwargs): |
---|
2644 | Phenomenon.__init__(self,*args,**kwargs) |
---|
2645 | if componentPhenomenon: |
---|
2646 | self.componentPhenomenon=componentPhenomenon |
---|
2647 | def fromXML(self,csmlFrag): |
---|
2648 | Phenomenon.fromXML(self,csmlFrag) |
---|
2649 | for frag in csmlFrag.getchildren(): |
---|
2650 | if frag.tag == OM('componentPhenomenon'): |
---|
2651 | checkArrayAttrib(self,'componentPhenomenon') |
---|
2652 | self.componentPhenomenon.append(frag.attrib) |
---|
2653 | def toXML(self,csmlFrag): |
---|
2654 | Phenomenon.toXML(self,csmlFrag) |
---|
2655 | if hasattr(self, 'componentPhenomenon'): |
---|
2656 | for cp in self.componentPhenomenon: |
---|
2657 | frag=Element(OM('componentPhenomenon')) |
---|
2658 | frag.attrib= cp |
---|
2659 | csmlFrag.append(frag) |
---|
2660 | return csmlFrag |
---|
2661 | |
---|
2662 | class CompositePhenomenon(Phenomenon): |
---|
2663 | #Class om:CompositePhenomenon |
---|
2664 | # + om:componentPhenomenon [1...*] |
---|
2665 | def __init__(self,componentPhenomena=None,*args,**kwargs): |
---|
2666 | Phenomenon.__init__(self,*args,**kwargs) |
---|
2667 | if componentPhenomena: |
---|
2668 | self.componentPhenomena=componentPhenomena |
---|
2669 | def fromXML(self,csmlFrag): |
---|
2670 | Phenomenon.fromXML(self,csmlFrag) |
---|
2671 | self.componentPhenomena=[] |
---|
2672 | for frag in csmlFrag.getchildren(): |
---|
2673 | if frag.tag == OM('componentPhenomenon'): |
---|
2674 | componentPhenomenon=Phenomenon() |
---|
2675 | Phenomenon.fromXML(componentPhenomenon,frag) |
---|
2676 | self.componentPhenomena.append(componentPhenomenon) |
---|
2677 | def toXML(self,csmlFrag): |
---|
2678 | Phenomenon.toXML(self,csmlFrag) |
---|
2679 | if hasattr(self, 'componentPhenomena'): |
---|
2680 | for phenomenon in self.componentPhenomena: |
---|
2681 | frag=Element(OM('componentPhenomenon')) |
---|
2682 | Phenomenon.toXML(phenomenon,frag) |
---|
2683 | csmlFrag.append(frag) |
---|
2684 | return csmlFrag |
---|
2685 | |
---|
2686 | |
---|
2687 | class ParameterisedPhenomenon(Phenomenon): |
---|
2688 | #Class ParameterisedPhenomenon: |
---|
2689 | # + basePhenomenon |
---|
2690 | # + constraint |
---|
2691 | # + href (attrib) |
---|
2692 | def __init__(self,*args,**kwargs): |
---|
2693 | Phenomenon.__init__(self,*args,**kwargs) |
---|
2694 | def fromXML(self,csmlFrag): |
---|
2695 | Phenomenon.fromXML(self,csmlFrag) |
---|
2696 | for frag in csmlFrag.getchildren(): |
---|
2697 | if frag.tag == OM('basePhenomenon'): |
---|
2698 | self.basePhenomenon=frag.text |
---|
2699 | if frag.attrib.has_key(XLINK('href')): |
---|
2700 | self.href = frag.attrib[XLINK('href')] |
---|
2701 | if frag.tag == OM('constraint'): |
---|
2702 | subFrag=frag.getchildren()[0] |
---|
2703 | if subFrag.tag== OM('TypedCategory'): |
---|
2704 | self.constraint = TypedCategory() |
---|
2705 | #TO DO: what other types are valid? |
---|
2706 | elif subFrag.tag== OM('??'): |
---|
2707 | self.constraint = 123 |
---|
2708 | self.constraint.fromXML(subFrag) |
---|
2709 | def toXML(self,csmlFrag): |
---|
2710 | csmlFrag=Phenomenon.toXML(self,csmlFrag) |
---|
2711 | if hasattr(self,'basePhenomenon'): |
---|
2712 | frag=Element(OM('basePhenomenon')) |
---|
2713 | frag.text=self.basePhenomenon |
---|
2714 | if hasattr(self, 'href'): |
---|
2715 | frag.attrib[XLINK('href')] = self.href |
---|
2716 | csmlFrag.append(frag) |
---|
2717 | if hasattr(self, 'constraint'): |
---|
2718 | frag=Element(OM('constraint')) |
---|
2719 | subFrag=Element(OM('TypedCategory')) |
---|
2720 | subFrag=self.constraint.toXML(subFrag) |
---|
2721 | frag.append(subFrag) |
---|
2722 | csmlFrag.append(frag) |
---|
2723 | return csmlFrag |
---|
2724 | |
---|
2725 | class RangeSet(AssociationAttributeGroup): |
---|
2726 | #class GML RangeSet |
---|
2727 | |
---|
2728 | # RangeSet() |
---|
2729 | # +gml:ValueArray |
---|
2730 | # +gml:_ScalarValueList |
---|
2731 | # +gml:DataBlock |
---|
2732 | # +gml:File |
---|
2733 | #class GML RangeSet |
---|
2734 | def __init__(self,quantityList=None, dataBlock=None, arrayDescriptor=None, aggregatedArray=None,*args,**kwargs): |
---|
2735 | if quantityList: |
---|
2736 | self.quantityList=quantityList |
---|
2737 | if dataBlock: |
---|
2738 | self.dataBlock=dataBlock |
---|
2739 | if arrayDescriptor: |
---|
2740 | self.arrayDescriptor=arrayDescriptor |
---|
2741 | if aggregatedArray: |
---|
2742 | self.aggregatedArray=aggregatedArray |
---|
2743 | AssociationAttributeGroup.__init__(self,*args,**kwargs) |
---|
2744 | |
---|
2745 | def fromXML(self,csmlFrag): |
---|
2746 | for frag in csmlFrag.getchildren(): |
---|
2747 | if frag.tag==GML('QuantityList'): |
---|
2748 | self.quantityList=MeasureOrNullList() |
---|
2749 | MeasureOrNullList.fromXML(self.quantityList,frag) |
---|
2750 | elif frag.tag==GML('DataBlock'): |
---|
2751 | self.dataBlock=DataBlock() |
---|
2752 | DataBlock.fromXML(self.dataBlock, frag) |
---|
2753 | elif frag.tag == CSML('NetCDFExtract'): |
---|
2754 | self.arrayDescriptor=NetCDFExtract() |
---|
2755 | NetCDFExtract.fromXML(self.arrayDescriptor,frag) |
---|
2756 | elif frag.tag == CSML('NASAmesExtract'): |
---|
2757 | self.arrayDescriptor=NASAAmesExtract() |
---|
2758 | NASAAmesExtract.fromXML(self.arrayDescriptor,frag) |
---|
2759 | elif frag.tag == CSML('GRIBExtract'): |
---|
2760 | self.arrayDescriptor=GRIBExtract() |
---|
2761 | GRIBExtract.fromXML(self.ArrayDescriptor,frag) |
---|
2762 | elif frag.tag == CSML('PPExtract'): |
---|
2763 | self.arrayDescriptor=PPExtract() |
---|
2764 | PPExtract.fromXML(self.ArrayDescriptor,frag) |
---|
2765 | elif frag.tag == CSML('AggregatedArray'): |
---|
2766 | self.aggregatedArray=AggregatedArray() |
---|
2767 | AggregatedArray.fromXML(self.aggregatedArray,frag) |
---|
2768 | AssociationAttributeGroup.fromXML(self,csmlFrag) |
---|
2769 | |
---|
2770 | def toXML(self, csmlFrag): |
---|
2771 | if hasattr(self,'quantityList'): |
---|
2772 | frag = Element(GML('QuantityList')) |
---|
2773 | MeasureOrNullList.toXML(self.quantityList,frag) |
---|
2774 | csmlFrag.append(frag) |
---|
2775 | if hasattr(self,'dataBlock'): |
---|
2776 | frag=Element(GML('DataBlock')) |
---|
2777 | DataBlock.toXML(self.dataBlock,frag) |
---|
2778 | csmlFrag.append(frag) |
---|
2779 | if hasattr(self,'aggregatedArray'): |
---|
2780 | frag=Element(CSML('AggregatedArray')) |
---|
2781 | AggregatedArray.toXML(self.aggregatedArray,frag) |
---|
2782 | csmlFrag.append(frag) |
---|
2783 | if hasattr(self,'arrayDescriptor'): |
---|
2784 | if isinstance(self.arrayDescriptor,NetCDFExtract): |
---|
2785 | frag=Element(CSML('NetCDFExtract')) |
---|
2786 | NetCDFExtract.toXML(self.arrayDescriptor,frag) |
---|
2787 | csmlFrag.append(frag) |
---|
2788 | elif isinstance(self.arrayDescriptor,NASAAmesExtract): |
---|
2789 | frag=Element(CSML('NASAAmesExtract')) |
---|
2790 | NASAAmesExtract.toXML(self.arrayDescriptor,frag) |
---|
2791 | csmlFrag.append(frag) |
---|
2792 | elif isinstance(self.arrayDescriptor,GRIBExtract): |
---|
2793 | frag=Element(CSML('GRIBExtract')) |
---|
2794 | GRIBExtract.toXML(self.arrayDescriptor,frag) |
---|
2795 | csmlFrag.append(frag) |
---|
2796 | elif isinstance(self.arrayDescriptor,PPExtract): |
---|
2797 | frag=Element(CSML('PPExtract')) |
---|
2798 | PPAmesExtract.toXML(self.arrayDescriptor,frag) |
---|
2799 | csmlFrag.append(frag) |
---|
2800 | csmlFrag=AssociationAttributeGroup.toXML(self,csmlFrag) |
---|
2801 | return csmlFrag |
---|
2802 | |
---|
2803 | class PointDomain(AbstractDomain): |
---|
2804 | def __init__(self,*args,**kwargs): |
---|
2805 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2806 | def fromXML(self,csmlFrag): |
---|
2807 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2808 | def toXML(self,csmlFrag): |
---|
2809 | AbstractDomain.toXML(self,csmlFrag) |
---|
2810 | return csmlFrag |
---|
2811 | |
---|
2812 | class ProfileDomain(AbstractDomain): |
---|
2813 | def __init__(self,*args,**kwargs): |
---|
2814 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2815 | def fromXML(self,csmlFrag): |
---|
2816 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2817 | def toXML(self,csmlFrag): |
---|
2818 | AbstractDomain.toXML(self,csmlFrag) |
---|
2819 | return csmlFrag |
---|
2820 | |
---|
2821 | class GridDomain(AbstractDomain): |
---|
2822 | def __init__(self,*args,**kwargs): |
---|
2823 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2824 | def fromXML(self,csmlFrag): |
---|
2825 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2826 | def toXML(self,csmlFrag): |
---|
2827 | AbstractDomain.toXML(self,csmlFrag) |
---|
2828 | return csmlFrag |
---|
2829 | |
---|
2830 | class PointSeriesDomain(AbstractDomain): |
---|
2831 | def __init__(self,*args,**kwargs): |
---|
2832 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2833 | def fromXML(self,csmlFrag): |
---|
2834 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2835 | def toXML(self,csmlFrag): |
---|
2836 | AbstractDomain.toXML(self,csmlFrag) |
---|
2837 | return csmlFrag |
---|
2838 | |
---|
2839 | class ProfileSeriesDomain(AbstractDomain): |
---|
2840 | def __init__(self,*args,**kwargs): |
---|
2841 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2842 | def fromXML(self,csmlFrag): |
---|
2843 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2844 | def toXML(self,csmlFrag): |
---|
2845 | AbstractDomain.toXML(self,csmlFrag) |
---|
2846 | return csmlFrag |
---|
2847 | |
---|
2848 | class GridSeriesDomain(AbstractDomain): |
---|
2849 | def __init__(self,*args,**kwargs): |
---|
2850 | AbstractDomain.__init__(self,*args,**kwargs) |
---|
2851 | def fromXML(self,csmlFrag): |
---|
2852 | AbstractDomain.fromXML(self,csmlFrag) |
---|
2853 | def toXML(self,csmlFrag): |
---|
2854 | AbstractDomain.toXML(self,csmlFrag) |
---|
2855 | return csmlFrag |
---|
2856 | |
---|
2857 | class PointFeature(AbstractStaticCoverageFeature): |
---|
2858 | #CSML PointFeature class |
---|
2859 | # PointFeature(AbstractStaticCoverageFeatureType): |
---|
2860 | # +PointDomain |
---|
2861 | def __init__(self, domain=None,*args,**kwargs): |
---|
2862 | AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) |
---|
2863 | if domain: |
---|
2864 | self.domain=domain |
---|
2865 | def __str__(self): |
---|
2866 | return 'PointFeature' |
---|
2867 | def fromXML(self,csmlFrag): |
---|
2868 | AbstractStaticCoverageFeature.fromXML(self,csmlFrag) |
---|
2869 | for frag in csmlFrag.getchildren(): |
---|
2870 | if frag.tag == CSML('PointDomain'): |
---|
2871 | self.domain = PointDomain() |
---|
2872 | self.domain.fromXML(frag) |
---|
2873 | def toXML(self,csmlFrag): |
---|
2874 | AbstractStaticCoverageFeature.toXML(self,csmlFrag) |
---|
2875 | if hasattr(self,'domain'): |
---|
2876 | frag = Element(CSML('PointDomain')) |
---|
2877 | PointDomain.toXML(self.domain,frag) |
---|
2878 | # if hasattr(self,'href'): |
---|
2879 | # frag.attrib[XLINK('href')] = self.href |
---|
2880 | csmlFrag.append(frag) |
---|
2881 | return csmlFrag |
---|
2882 | |
---|
2883 | |
---|
2884 | class PointSeriesFeature(AbstractSeriesCoverageFeature): |
---|
2885 | #CSML PointSeriesFeature class |
---|
2886 | # PointSeriesFeature(AbstractStaticCoverageFeatureType): |
---|
2887 | # +pointSeriesDomain[1]:PointSeriesDomain |
---|
2888 | |
---|
2889 | def __init__(self,domain=None,*args,**kwargs): |
---|
2890 | AbstractSeriesCoverageFeature.__init__(self,*args,**kwargs) |
---|
2891 | if domain: |
---|
2892 | self.domain=domain |
---|
2893 | def __str__(self): |
---|
2894 | return 'PointSeriesFeature' |
---|
2895 | def fromXML(self,csmlFrag): |
---|
2896 | AbstractSeriesCoverageFeature.fromXML(self,csmlFrag) |
---|
2897 | for frag in csmlFrag.getchildren(): |
---|
2898 | if frag.tag == CSML('PointSeriesDomain'): |
---|
2899 | self.domain = PointSeriesDomain() |
---|
2900 | self.domain.fromXML(frag) |
---|
2901 | def toXML(self,csmlFrag): |
---|
2902 | AbstractSeriesCoverageFeature.toXML(self,csmlFrag) |
---|
2903 | if hasattr(self,'domain'): |
---|
2904 | frag = Element(CSML('PointSeriesDomain')) |
---|
2905 | PointSeriesDomain.toXML(self.domain,frag) |
---|
2906 | csmlFrag.append(frag) |
---|
2907 | return csmlFrag |
---|
2908 | |
---|
2909 | class ProfileFeature(AbstractStaticCoverageFeature): |
---|
2910 | #CSML ProfileFeature class |
---|
2911 | # ProfileFeature(AbstractStaticCoverageFeature): |
---|
2912 | # +profileDomain[1]:ProfileDomain |
---|
2913 | |
---|
2914 | def __init__(self,domain=None,*args,**kwargs): |
---|
2915 | AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) |
---|
2916 | if domain: |
---|
2917 | self.domain=domain |
---|
2918 | def __str__(self): |
---|
2919 | return 'ProfileFeature' |
---|
2920 | def fromXML(self,csmlFrag): |
---|
2921 | AbstractStaticCoverageFeature.fromXML(self,csmlFrag) |
---|
2922 | for frag in csmlFrag.getchildren(): |
---|
2923 | if frag.tag == CSML('ProfileDomain'): |
---|
2924 | self.domain = ProfileDomain() |
---|
2925 | ProfileDomain.fromXML(self.domain,frag) |
---|
2926 | def toXML(self,csmlFrag): |
---|
2927 | AbstractStaticCoverageFeature.toXML(self,csmlFrag) |
---|
2928 | if hasattr(self,'domain'): |
---|
2929 | frag = Element(CSML('ProfileDomain')) |
---|
2930 | ProfileDomain.toXML(self.domain,frag) |
---|
2931 | csmlFrag.append(frag) |
---|
2932 | return csmlFrag |
---|
2933 | |
---|
2934 | |
---|
2935 | class ProfileSeriesFeature(AbstractStaticCoverageFeature): |
---|
2936 | #CSML ProfileSeriesFeature class |
---|
2937 | # ProfileSeriesFeature(AbstractStaticCoverageFeature): |
---|
2938 | # +ProfileSeriesDomain |
---|
2939 | |
---|
2940 | def __init__(self,domain=None,*args,**kwargs): |
---|
2941 | AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) |
---|
2942 | if domain: |
---|
2943 | self.domain=domain |
---|
2944 | def __str__(self): |
---|
2945 | return 'ProfileSeriesFeature' |
---|
2946 | def fromXML(self,csmlFrag): |
---|
2947 | AbstractStaticCoverageFeature.fromXML(self,csmlFrag) |
---|
2948 | for frag in csmlFrag.getchildren(): |
---|
2949 | if frag.tag == CSML('ProfileSeriesDomain'): |
---|
2950 | self.domain = ProfileSeriesDomain() |
---|
2951 | ProfileSeriesDomain.fromXML(self.domain,frag) |
---|
2952 | def toXML(self,csmlFrag): |
---|
2953 | AbstractStaticCoverageFeature.toXML(self,csmlFrag) |
---|
2954 | if hasattr(self,'domain'): |
---|
2955 | frag = Element(CSML('ProfileSeriesDomain')) |
---|
2956 | ProfileSeriesDomain.toXML(self.domain,frag) |
---|
2957 | csmlFrag.append(frag) |
---|
2958 | return csmlFrag |
---|
2959 | |
---|
2960 | |
---|
2961 | class GridFeature(AbstractStaticCoverageFeature): |
---|
2962 | #CSML GridFeature class |
---|
2963 | # GridFeature(AbstractStaticCoverageFeature): |
---|
2964 | # +gridDomain[1]:gridDomain |
---|
2965 | |
---|
2966 | def __init__(self,domain=None,*args,**kwargs): |
---|
2967 | AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) |
---|
2968 | if domain: |
---|
2969 | self.domain=domain |
---|
2970 | def __str__(self): |
---|
2971 | return 'GridFeature' |
---|
2972 | def fromXML(self,csmlFrag): |
---|
2973 | AbstractStaticCoverageFeature.fromXML(self,csmlFrag) |
---|
2974 | for frag in csmlFrag.getchildren(): |
---|
2975 | if frag.tag == CSML('GridDomain'): |
---|
2976 | self.domain = GridDomain() |
---|
2977 | self.domain.fromXML(frag) |
---|
2978 | def toXML(self,csmlFrag): |
---|
2979 | AbstractStaticCoverageFeature.toXML(self,csmlFrag) |
---|
2980 | if hasattr(self,'domain'): |
---|
2981 | frag = Element(CSML('GridDomain')) |
---|
2982 | GridDomain.toXML(self.domain,frag) |
---|
2983 | csmlFrag.append(frag) |
---|
2984 | return csmlFrag |
---|
2985 | |
---|
2986 | |
---|
2987 | class GridSeriesFeature(AbstractStaticCoverageFeature): |
---|
2988 | def __init__(self,domain=None,*args,**kwargs): |
---|
2989 | AbstractStaticCoverageFeature.__init__(self,*args,**kwargs) |
---|
2990 | if domain: |
---|
2991 | self.domain=domain |
---|
2992 | def __str__(self): |
---|
2993 | return 'GridSeriesFeature' |
---|
2994 | def fromXML(self,csmlFrag): |
---|
2995 | AbstractStaticCoverageFeature.fromXML(self,csmlFrag) |
---|
2996 | for frag in csmlFrag.getchildren(): |
---|
2997 | if frag.tag == CSML('GridSeriesDomain'): |
---|
2998 | self.domain = GridSeriesDomain() |
---|
2999 | self.domain.fromXML(frag) |
---|
3000 | def toXML(self,csmlFrag): |
---|
3001 | AbstractStaticCoverageFeature.toXML(self,csmlFrag) |
---|
3002 | if hasattr(self,'domain'): |
---|
3003 | frag = Element(CSML('GridSeriesDomain')) |
---|
3004 | GridSeriesDomain.toXML(self.domain,frag) |
---|
3005 | csmlFrag.append(frag) |
---|
3006 | return csmlFrag |
---|
3007 | |
---|
3008 | |
---|
3009 | |
---|
3010 | class AbstractFeature(AbstractGML): |
---|
3011 | def __init__(self,boundedBy=None,*args,**kwargs): |
---|
3012 | AbstractGML.__init__(self,*args,**kwargs) |
---|
3013 | if boundedBy: |
---|
3014 | self.boundedBy=boundedBy |
---|
3015 | def fromXML(self,csmlFrag): |
---|
3016 | AbstractGML.fromXML(self,csmlFrag) |
---|
3017 | for frag in csmlFrag.getchildren(): |
---|
3018 | if frag.tag == GML('boundedBy'): |
---|
3019 | self.boundedBy = EnvelopeWithTimePeriod() |
---|
3020 | self.boundedBy.fromXML(frag) |
---|
3021 | def toXML(self,csmlFrag): |
---|
3022 | AbstractGML.toXML(self,csmlFrag) |
---|
3023 | if hasattr(self,'boundedBy'): |
---|
3024 | superfrag = Element(GML('boundedBy')) |
---|
3025 | frag = Element (GML('EnvelopeWithTimePeriod')) |
---|
3026 | EnvelopeWithTimePeriod.toXML(self.boundedBy,frag) |
---|
3027 | superfrag.append(frag) |
---|
3028 | csmlFrag.append(superfrag) |
---|
3029 | return csmlFrag |
---|
3030 | |
---|
3031 | class AbstractGeometryFeature(AbstractFeature): |
---|
3032 | def __init__(self,*args,**kwargs): |
---|
3033 | AbstractFeature.__init__(self,*args,**kwargs) |
---|
3034 | def fromXML(self,csmlFrag): |
---|
3035 | AbstractFeature.fromXML(self,csmlFrag) |
---|
3036 | def toXML(self, csmlFrag): |
---|
3037 | AbstractFeature.toXML(self,csmlFrag) |
---|
3038 | return csmlFrag |
---|
3039 | |
---|
3040 | |
---|
3041 | class TrajectoryFeature(AbstractGeometryFeature): |
---|
3042 | def __init__(self,track=None, *args, **kwargs): |
---|
3043 | AbstractGeometryFeature.__init__(self,*args,**kwargs) |
---|
3044 | if track: |
---|
3045 | self.track=track |
---|
3046 | def __str__(self): |
---|
3047 | return 'TrajectoryFeature' |
---|
3048 | def fromXML(self,csmlFrag): |
---|
3049 | AbstractGeometryFeature.fromXML(self,csmlFrag) |
---|
3050 | for frag in csmlFrag.getchildren(): |
---|
3051 | if frag.tag == CSML('track'): |
---|
3052 | self.track=Trajectory() |
---|
3053 | Trajectory.fromXML(self.track,frag) |
---|
3054 | def toXML(self,csmlFrag): |
---|
3055 | AbstractGeometryFeature.toXML(self,csmlFrag) |
---|
3056 | if hasattr(self, 'track'): |
---|
3057 | frag = Element(CSML('track')) |
---|
3058 | subFrag=Element(CSML('Trajectory')) |
---|
3059 | Trajectory.toXML(self.track,subFrag) |
---|
3060 | frag.append(subFrag) |
---|
3061 | csmlFrag.append(frag) |
---|
3062 | return csmlFrag |
---|
3063 | |
---|
3064 | class AbstractFeatureCollection(AbstractFeature): |
---|
3065 | """GML AbstractFeatureCollection class |
---|
3066 | |
---|
3067 | AbstractFeatureCollection(AbstractFeature): |
---|
3068 | +featureMember[0..*]: AbstractFeature |
---|
3069 | +featureMembers[0..1]: FeatureArray |
---|
3070 | """ |
---|
3071 | def __init__(self,members=[]): |
---|
3072 | if members: |
---|
3073 | self.members=members |
---|
3074 | def fromXML(self,csmlFrag): |
---|
3075 | AbstractFeature.fromXML(self,csmlFrag) |
---|
3076 | for frag in csmlFrag.getchildren(): |
---|
3077 | if frag.tag == GML('featureMember'): |
---|
3078 | checkArrayAttrib(self,'members') |
---|
3079 | featureFrag = frag.getchildren()[0] |
---|
3080 | if featureFrag.tag == CSML('PointFeature'): |
---|
3081 | self.members.append(PointFeature()) |
---|
3082 | self.members[-1].fromXML(featureFrag) |
---|
3083 | if featureFrag.tag == CSML('ProfileFeature'): |
---|
3084 | self.members.append(ProfileFeature()) |
---|
3085 | self.members[-1].fromXML(featureFrag) |
---|
3086 | if featureFrag.tag == CSML('GridFeature'): |
---|
3087 | self.members.append(GridFeature()) |
---|
3088 | self.members[-1].fromXML(featureFrag) |
---|
3089 | if featureFrag.tag == CSML('PointSeriesFeature'): |
---|
3090 | self.members.append(PointSeriesFeature()) |
---|
3091 | self.members[-1].fromXML(featureFrag) |
---|
3092 | if featureFrag.tag == CSML('ProfileSeriesFeature'): |
---|
3093 | self.members.append(ProfileSeriesFeature()) |
---|
3094 | self.members[-1].fromXML(featureFrag) |
---|
3095 | if featureFrag.tag == CSML('GridSeriesFeature'): |
---|
3096 | self.members.append(GridSeriesFeature()) |
---|
3097 | self.members[-1].fromXML(featureFrag) |
---|
3098 | if featureFrag.tag == CSML('TrajectoryFeature'): |
---|
3099 | self.members.append(TrajectoryFeature()) |
---|
3100 | self.members[-1].fromXML(featureFrag) |
---|
3101 | def toXML(self,csmlFrag): |
---|
3102 | AbstractFeature.toXML(self,csmlFrag) |
---|
3103 | for member in self.members: |
---|
3104 | if isinstance(member,PointFeature): |
---|
3105 | superFrag=Element(GML('featureMember')) |
---|
3106 | frag=Element(CSML('PointFeature')) |
---|
3107 | PointFeature.toXML(member,frag) |
---|
3108 | superFrag.append(frag) |
---|
3109 | csmlFrag.append(superFrag) |
---|
3110 | if isinstance(member,ProfileFeature): |
---|
3111 | superFrag=Element(GML('featureMember')) |
---|
3112 | frag=Element(CSML('ProfileFeature')) |
---|
3113 | ProfileFeature.toXML(member,frag) |
---|
3114 | superFrag.append(frag) |
---|
3115 | csmlFrag.append(superFrag) |
---|
3116 | if isinstance(member,GridFeature): |
---|
3117 | superFrag=Element(GML('featureMember')) |
---|
3118 | frag=Element(CSML('GridFeature')) |
---|
3119 | GridFeature.toXML(member,frag) |
---|
3120 | superFrag.append(frag) |
---|
3121 | csmlFrag.append(superFrag) |
---|
3122 | if isinstance(member,PointSeriesFeature): |
---|
3123 | superFrag=Element(GML('featureMember')) |
---|
3124 | frag=Element(CSML('PointSeriesFeature')) |
---|
3125 | PointSeriesFeature.toXML(member,frag) |
---|
3126 | superFrag.append(frag) |
---|
3127 | csmlFrag.append(superFrag) |
---|
3128 | if isinstance(member,ProfileSeriesFeature): |
---|
3129 | superFrag=Element(GML('featureMember')) |
---|
3130 | frag=Element(CSML('ProfileSeriesFeature')) |
---|
3131 | ProfileSeriesFeature.toXML(member,frag) |
---|
3132 | superFrag.append(frag) |
---|
3133 | csmlFrag.append(superFrag) |
---|
3134 | if isinstance(member,GridSeriesFeature): |
---|
3135 | superFrag=Element(GML('featureMember')) |
---|
3136 | frag=Element(CSML('GridSeriesFeature')) |
---|
3137 | GridSeriesFeature.toXML(member,frag) |
---|
3138 | superFrag.append(frag) |
---|
3139 | csmlFrag.append(superFrag) |
---|
3140 | if isinstance(member,TrajectoryFeature): |
---|
3141 | superFrag=Element(GML('featureMember')) |
---|
3142 | frag=Element(CSML('TrajectoryFeature')) |
---|
3143 | TrajectoryFeature.toXML(member,frag) |
---|
3144 | superFrag.append(frag) |
---|
3145 | csmlFrag.append(superFrag) |
---|
3146 | |
---|
3147 | return csmlFrag |
---|
3148 | |
---|
3149 | class FeatureCollection(AbstractFeatureCollection): |
---|
3150 | """GML FeatureCollection class |
---|
3151 | FeatureCollection() |
---|
3152 | +featureMembers[0..*] |
---|
3153 | """ |
---|
3154 | def __init__(self,*args,**kwargs): |
---|
3155 | AbstractFeatureCollection.__init__(self,*args,**kwargs) |
---|
3156 | def fromXML(self,csmlFrag): |
---|
3157 | AbstractFeatureCollection.fromXML(self,csmlFrag) |
---|
3158 | def toXML(self,csmlFrag): |
---|
3159 | AbstractFeatureCollection.toXML(self,csmlFrag) |
---|
3160 | return csmlFrag |
---|
3161 | |
---|
3162 | class Dataset(AbstractGML): |
---|
3163 | """CSML Dataset class |
---|
3164 | |
---|
3165 | Dataset(AbstractGML): |
---|
3166 | +unitDefinitions[0..*]: UnitDefinitions |
---|
3167 | +referenceSystemDefinitions[0..1]: ReferenceSystemDefinitions |
---|
3168 | +phenomenonDefinitions[0..1]: PhenomenonDefinitions |
---|
3169 | +arrayDescriptors[0..*]: AbstractArrayDescriptor |
---|
3170 | +featureCollection[0..1]: FeatureCollection |
---|
3171 | """ |
---|
3172 | def __init__(self,unitDefinitions=None,referenceSystemDefinitions=None, |
---|
3173 | phenomenonDefinitions=None,arrayDescriptors=[], |
---|
3174 | featureCollection=None,*args,**kwargs): |
---|
3175 | AbstractGML.__init__(self,*args,**kwargs) |
---|
3176 | if unitDefinitions: |
---|
3177 | self.unitDefinitions = unitDefinitions |
---|
3178 | if referenceSystemDefinitions: |
---|
3179 | self.referenceSystemDefinitions = referenceSystemDefinitions |
---|
3180 | if phenomenonDefinitions: |
---|
3181 | self.phenomenonDefinitions = phenomenonDefinitions |
---|
3182 | if arrayDescriptors: |
---|
3183 | self.arrayDescriptors = arrayDescriptors |
---|
3184 | if featureCollection: |
---|
3185 | self.featureCollection = featureCollection |
---|
3186 | def fromXML(self,csmlFrag): |
---|
3187 | if csmlFrag.tag != CSML('Dataset'): |
---|
3188 | print 'This does not appear to be a CSML file. Does not contain a root Dataset element.' |
---|
3189 | print ' ' |
---|
3190 | sys.exit() |
---|
3191 | AbstractGML.fromXML(self,csmlFrag) |
---|
3192 | for frag in csmlFrag.getchildren(): |
---|
3193 | if frag.tag == CSML('UnitDefinitions'): |
---|
3194 | self.unitDefinitions = UnitDefinitions() |
---|
3195 | self.unitDefinitions.fromXML(frag) |
---|
3196 | elif frag.tag == CSML('ReferenceSystemDefinitions'): |
---|
3197 | self.referenceSystemDefinitions = ReferenceSystemDefinitions() |
---|
3198 | self.referenceSystemDefinitions.fromXML(frag) |
---|
3199 | elif frag.tag == CSML('PhenomenonDefinitions'): |
---|
3200 | self.phenomenonDefinitions = PhenomenonDefinitions() |
---|
3201 | self.phenomenonDefinitions.fromXML(frag) |
---|
3202 | elif frag.tag == GML('FeatureCollection'): |
---|
3203 | self.featureCollection = FeatureCollection() |
---|
3204 | self.featureCollection.fromXML(frag) |
---|
3205 | elif frag.tag == CSML('AggregatedArray'): |
---|
3206 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3207 | self.arrayDescriptors.append(AggregatedArray()) |
---|
3208 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3209 | elif frag.tag == CSML('InlineArray'): |
---|
3210 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3211 | self.arrayDescriptors.append(InlineArray()) |
---|
3212 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3213 | elif frag.tag == CSML('ArrayGenerator'): |
---|
3214 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3215 | self.arrayDescriptors.append(ArrayGenerator()) |
---|
3216 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3217 | elif frag.tag == CSML('NASAAmesExtract'): |
---|
3218 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3219 | self.arrayDescriptors.append(NASAAmesExtract()) |
---|
3220 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3221 | elif frag.tag == CSML('NetCDFExtract'): |
---|
3222 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3223 | self.arrayDescriptors.append(NetCDFExtract()) |
---|
3224 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3225 | elif frag.tag == CSML('GRIBExtract'): |
---|
3226 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3227 | self.arrayDescriptors.append(GRIBExtract()) |
---|
3228 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3229 | elif frag.tag == CSML('PPExtract'): |
---|
3230 | checkArrayAttrib(self,'arrayDescriptors') |
---|
3231 | self.arrayDescriptors.append(PPExtract()) |
---|
3232 | self.arrayDescriptors[-1].fromXML(frag) |
---|
3233 | ## else: |
---|
3234 | ## raise Exception('Unexpected element: "'+frag.tag+'"') |
---|
3235 | def toXML(self,csmlFrag=None): |
---|
3236 | if csmlFrag is None: |
---|
3237 | csmlFrag = Element('Dataset') |
---|
3238 | csmlFrag = AbstractGML.toXML(self,csmlFrag) |
---|
3239 | if hasattr(self,'unitDefinitions'): |
---|
3240 | frag = Element(CSML('UnitDefinitions')) |
---|
3241 | frag = UnitDefinitions.toXML(self.unitDefinitions,frag) |
---|
3242 | csmlFrag.append(frag) |
---|
3243 | if hasattr(self,'referenceSystemDefinitions'): |
---|
3244 | frag = Element(CSML('ReferenceSystemDefinitions')) |
---|
3245 | frag = ReferenceSystemDefinitions.toXML(self.referenceSystemDefinitions,frag) |
---|
3246 | csmlFrag.append(frag) |
---|
3247 | if hasattr(self,'phenomenonDefinitions'): |
---|
3248 | frag = Element(CSML('PhenomenonDefinitions')) |
---|
3249 | frag = PhenomenonDefinitions.toXML(self.phenomenonDefinitions,frag) |
---|
3250 | csmlFrag.append(frag) |
---|
3251 | if hasattr(self,'arrayDescriptors'): |
---|
3252 | for arrayDesc in self.arrayDescriptors: |
---|
3253 | if isinstance(arrayDesc,AggregatedArray): |
---|
3254 | frag = Element(CSML('AggregatedArray')) |
---|
3255 | frag = AggregatedArray.toXML(arrayDesc,frag) |
---|
3256 | elif isinstance(arrayDesc,InlineArray): |
---|
3257 | frag = Element(CSML('InlineArray')) |
---|
3258 | frag = InlineArray.toXML(arrayDesc,frag) |
---|
3259 | elif isinstance(arrayDesc,ArrayGenerator): |
---|
3260 | frag = Element(CSML('ArrayGenerator')) |
---|
3261 | frag = ArrayGenerator.toXML(arrayDesc,frag) |
---|
3262 | elif isinstance(arrayDesc,NASAAmesExtract): |
---|
3263 | frag = Element(CSML('NASAAmesExtract')) |
---|
3264 | frag = NASAAmesExtract.toXML(arrayDesc,frag) |
---|
3265 | elif isinstance(arrayDesc,NetCDFExtract): |
---|
3266 | frag = Element(CSML('NetCDFExtract')) |
---|
3267 | frag = NetCDFExtract.toXML(arrayDesc,frag) |
---|
3268 | elif isinstance(arrayDesc,GRIBExtract): |
---|
3269 | frag = Element(CSML('GRIBExtract')) |
---|
3270 | frag = GRIBExtract.toXML(arrayDesc,frag) |
---|
3271 | elif isinstance(arrayDesc,PPExtract): |
---|
3272 | frag = Element(CSML('PPExtract')) |
---|
3273 | frag = PPExtract.toXML(arrayDesc,frag) |
---|
3274 | csmlFrag.append(frag) |
---|
3275 | if hasattr(self,'featureCollection'): |
---|
3276 | frag = Element(GML('FeatureCollection')) |
---|
3277 | frag = FeatureCollection.toXML(self.featureCollection,frag) |
---|
3278 | csmlFrag.append(frag) |
---|
3279 | #csmlFrag=fixNameSpaces(csmlFrag) |
---|
3280 | return csmlFrag |
---|