49ccdff205f00eca95bd03f6e790c6c3ef205a29
[pyrungps.git] / pygpx.py
1 # coding: UTF-8
2 #------------------------
3 #  Работа с GPX-файлами
4 #------------------------
5 from lxml import etree
6 import os
7 import math
8 import datetime
9 from dateutil.parser import parse
10 from pprint import pprint
11
12 def deg2rad(deg):
13 # Преобразование из градусов в радианы.
14     return deg / (180 / math.pi)
15
16 tagprefix = { '1.0': '{http://www.topografix.com/GPX/1/0}', '1.1': '{http://www.topografix.com/GPX/1/1}'}
17
18 def StripPrefix(tag,version):
19   nstag=tagprefix[version]
20   return tag.replace(nstag,'')
21   
22 def formattime(dt):
23   return dt.strftime("%Y-%m-%dT%H:%M:%S")+"."+str(int(dt.microsecond/1000)).zfill(3)+"Z"
24
25 class Link:
26     # Ссылка. Может присутствовать в точке, треке, файле.
27     def __init__(self, node, version):
28         self.version = version
29         self.href = node.get("href")
30         self.text = None
31         self.type = None
32         if node is not None:
33           for child in node:
34             if child.tag == tagprefix[version] + "text":
35               self.text = child.text
36             elif child.tag == tagprefix[version] + "type":
37               self.type = child.text
38             else:
39               raise ValueError("Неизвестный тип узла: '%s' " % child.tag)  
40
41     def write(self,root):
42       linknode = etree.SubElement(root,"link");
43       linknode.set("href",self.href)
44       if self.text:
45         etree.SubElement(linknode,"text").text = self.text
46       if self.type:
47         etree.SubElement(linknode,"type").text = self.type
48
49 class GPXTrackPt:
50     # Точка с координатами. Может присутствовать в последовательности точек в треке, маршруте, а также в списке путевых точек.# 
51
52     def __init__(self, node, version):
53         # Извлекаем данные из GPX-тэгов.# 
54         self.version = version
55         # Сначала обязательные.# 
56         if node is not None:
57           self.lat = float(node.get("lat"))
58           self.lon = float(node.get("lon"))
59         self.elevation = None
60         self.time = None
61         self.speed = None
62         self.link = None
63         self.additional_info = {}
64         # Потом необязательные.# 
65         if node is not None:
66           for child in node:
67             if child.tag == tagprefix[version] + "time":
68                 self.time = parse(child.text)
69             elif child.tag == tagprefix[version] + "ele":
70                 self.elevation = float(child.text)
71             # Стандартом скорость не предусмотрена, но де-факто в Run.GPS используется.# 
72             elif child.tag == tagprefix[version] + "speed":
73                 self.speed = float(child.text)
74             elif child.tag == tagprefix[version] + "link":
75                 self.link = Link(child,version)
76             elif StripPrefix(child.tag,version) in ['magvar','geoidheight','name','cmt','desc',
77                 'src','sym','type','fix','sat','hdop','vdop','pdop','ageofdgpsdata','dgpsid']:
78                 self.additional_info[StripPrefix(child.tag,version)]=child.text
79             elif child.tag == tagprefix[version] + "extensions":
80                 pass
81             else:
82                 raise ValueError("Неизвестный тип узла: '%s'" % child.tag)
83   
84         for i in self.additional_info.keys():
85           val = self.additional_info[i];
86           if val:
87             if not val.strip(' \n\t'):
88               del self.additional_info[i]
89
90
91     def write(self,root,tag ="wpt"):
92       wptnode = etree.SubElement(root,tag)
93       wptnode.set("lat",repr(self.lat));
94       wptnode.set("lon",repr(self.lon));
95       if self.elevation:
96         etree.SubElement(wptnode,"ele").text = repr(self.elevation)
97       if self.time:
98         etree.SubElement(wptnode,"time").text = formattime(self.time)
99       if self.speed:
100         etree.SubElement(wptnode,"speed").text = repr(self.speed)
101       if self.link:
102         self.link.write(wptnode)
103       for i in self.additional_info.keys():
104         etree.SubElement(wptnode,i).text = self.additional_info[i]
105
106     def distance(self, other):
107         # Расстояние между двумя точками на глобусе.# 
108         try:
109             # http://www.platoscave.net/blog/2009/oct/5/calculate-distance-latitude-longitude-python/
110
111             radius = 6378700.0 # meters
112
113             lat1, lon1 = self.lat, self.lon
114             lat2, lon2 = other.lat, other.lon
115
116             dlat = math.radians(lat2-lat1)
117             dlon = math.radians(lon2-lon1)
118             a = math.sin(dlat/2) * math.sin(dlat/2) + math.cos(math.radians(lat1)) \
119                 * math.cos(math.radians(lat2)) * math.sin(dlon/2) * math.sin(dlon/2)
120             c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
121             d = radius * c
122
123         except ValueError, e:
124             raise ValueError(e)
125         return d
126
127     def duration(self, other):
128         # Время между двумя точками.# 
129         return other.time - self.time
130
131 class GPXRoute:
132         # Маршрут.# 
133
134     def __init__(self, node, version):
135         self.name = None
136         self.version = version
137         self.rtepts = []
138         self.additional_info = {}
139         self.link = None
140         if node is not None:
141           for child in node:
142             if child.tag == tagprefix[version] + "name":
143               self.name = child.text
144             elif child.tag == tagprefix[version] + "link":
145               self.link = Link(child,version)
146             elif StripPrefix(child.tag,version) in [ "cmt", "desc", "src", "number", "type" ]:
147               self.additional_info[StripPrefix(child.tag,version)]=child.text
148             elif child.tag == tagprefix[version] + "rtept":
149               self.rtepts.append(GPXTrackPt(child, version))
150             elif child.tag == tagprefix[version] + "extensions":
151               pass
152             else:
153               raise ValueError("Неизвестный тип узла <%s>" % child.tag)
154         for i in self.additional_info.keys():
155           val = self.additional_info[i];
156           if val:
157             if not val.strip(' \n\t'):
158               del self.additional_info[i]
159
160     def write(self,root):
161       rtenode = etree.SubElement(root,"rte")
162       if self.name:
163         etree.SubElement(rtenode,"name").text = self.name
164       if self.link:
165         self.link.write(rtenode)
166       for i in self.additional_info.keys():
167         print "storing %s " % ( i )
168         etree.SubElement(rtenode,i).text = self.additional_info[i]
169       for i in self.rtepts:
170         i.write(rtenode,"rtept") 
171         
172 class GPXTrackSeg:
173     # Один сегмент трека.# 
174
175     def __init__(self, node, version):
176         self.version = version
177         self.trkpts = []
178         self.elevation_gain = 0.0
179         self.elevation_loss = 0.0
180         if node is not None:
181           for child in node:
182             if child.tag == tagprefix[version] + "trkpt":
183               self.trkpts.append(GPXTrackPt(child, self.version))
184             else:
185               raise ValueError("Неизвестный тип узла <%s>" % node.nodeName)
186         self._get_elevation()
187
188     def write(self,root):
189       trksegnode = etree.SubElement(root,"trkseg")
190       for i in self.trkpts:
191         i.write(trksegnode,"trkpt")      
192
193     def _get_elevation(self):
194
195         elev_data = []
196         for pt in self.trkpts:
197           if pt.elevation:
198             elev_data.append(pt.elevation)
199
200         gain = 0.0
201         loss = 0.0
202         last_elevation = None
203
204         window_size = 5
205         i = 0
206         moving_averages = []
207
208         while i < len(elev_data) - window_size + 1:
209           this_window = elev_data[i : i + window_size]
210           window_average = sum(this_window) / window_size
211           moving_averages.append(window_average)
212           i += 1
213           
214         if len(moving_averages)>2:
215           elev_data = moving_averages
216
217         for pt in elev_data:    
218           if last_elevation is not None:
219             try:
220               if pt > last_elevation:
221                   gain += pt - last_elevation
222               else:
223                   loss += last_elevation - pt
224             except:
225               pass      
226           last_elevation=pt    
227
228         self.elevation_gain = gain
229         self.elevation_loss = loss
230
231     def distance(self):
232         # Расчет длины сегмента.# 
233         _length = 0.0
234         last_pt = None
235         for pt in self.trkpts:
236           if last_pt is not None:
237             _length += last_pt.distance(pt)
238           last_pt = pt
239         return _length
240
241     def filtered_distance(self,max_speed):
242         # Расчет длины сегмента с фильтрацией предположительно сбойных участков.# 
243         _length = 0.0
244         last_pt = None
245         for pt in self.trkpts:
246           if last_pt is not None:
247             _delta = last_pt.distance(pt)
248             _time_delta = pt.time - last_pt.time
249             _time_delta_s = _time_delta.days*86400 + _time_delta.seconds + _time_delta.microseconds/1000000
250             if _time_delta_s > 0:
251                 if _delta/_time_delta_s < max_speed:
252                     _length += _delta
253             else:
254                 _length += _delta
255           last_pt = pt      
256         return _length
257
258     def duration(self):
259         # Расчет продолжительности сегмента.# 
260         return self.trkpts[0].duration(self.trkpts[-1])
261
262     def bound_box(self):
263           # Обрамляющий прямоугольник для сегмента.# 
264       minlat =360
265       maxlat = -360
266       minlon = 360
267       maxlon = -360
268       for pt in self.trkpts:
269         if pt.lat<minlat:
270           minlat=pt.lat
271         if pt.lat>maxlat:
272           maxlat=pt.lat
273         if pt.lon<minlon:
274           minlon=pt.lon
275         if pt.lon>maxlon:
276           maxlon=pt.lon
277       return ((minlat,minlon),(maxlat,maxlon))      
278
279 class GPXTrack:
280     # Трек.# 
281
282     def __init__(self, node, version):
283         # Создаем трек из GPX-данных.# 
284
285         self.version = version
286         self.trksegs = []
287         self.sport= None
288         self.additional_info = {}
289         self.name = None
290         self.link = None
291   
292         if node is not None:
293           for child in node:
294             if child.tag == tagprefix[version] + "name":
295               self.name = child.text
296             elif child.tag == tagprefix[version] + "trkseg":
297               if len(child) > 0:
298                 self.trksegs.append(GPXTrackSeg(child, self.version))
299             elif child.tag == tagprefix[version] + "link":
300               self.link = Link(child,version)
301             elif StripPrefix(child.tag,version) in [ "number", "desc", "cmt", "src", "type" ]:
302               self.additional_info[StripPrefix(child.tag,version)] = child.text
303             elif child.tag == tagprefix[version] + "extensions":
304               for ext in child:
305                 # Из расширений извлекаем вид спорта - специфично для Run.GPS.# 
306                 if ext.tag == tagprefix[version] + "sport":
307                   self.sport = ext.text
308   
309         for i in self.additional_info.keys():
310           val = self.additional_info[i];
311           if val:
312             if not val.strip(' \n\t'):
313               del self.additional_info[i]
314
315     def write(self,root):
316       trknode = etree.SubElement(root,"trk")
317       if self.name:
318         etree.SubElement(trknode,"name").text = self.name
319       if self.sport:
320         etree.SubElement(etree.SubElement(trknode,"extensions"),"sport").text=self.sport  
321       if self.link:
322         self.link.write(trknode)
323       for i in self.additional_info.keys():
324         etree.SubElement(trknode,i).text = self.additional_info[i]
325       for i in self.trksegs:
326         i.write(trknode)      
327
328     def elevation_gain(self):
329                 # Набор высоты по треку.# 
330         return sum([trkseg.elevation_gain for trkseg in self.trksegs])
331
332     def elevation_loss(self):
333                 # Сброс высоты по треку.# 
334         return sum([trkseg.elevation_loss for trkseg in self.trksegs])
335
336     def distance(self):
337         # Длина трека.# 
338         try:
339             return sum([trkseg.distance() for trkseg in self.trksegs])
340         except IndexError:
341             print "Пустой сегмент трека, расчет длины невозможен."
342
343     def filtered_distance(self,max_speed=100):
344         # Длина трека с фильтрацией сбойных участков.# 
345         try:
346             return sum([trkseg.filtered_distance(max_speed=max_speed) for trkseg in self.trksegs])
347         except IndexError:
348             print "Пустой сегмент трека, расчет длины невозможен."
349
350     def duration(self):
351         # Продолжительность трека, не включая паузы между сегментами.# 
352         dur = datetime.timedelta(0)
353         for trkseg in self.trksegs:
354             try:
355               dur += trkseg.duration()
356             except:
357               pass  
358         return dur
359
360     def full_duration(self):
361         # Продолжительность трека, включая паузы между сегментами.# 
362         try:
363           return self.start().duration(self.end())
364         except:
365           return None
366
367     def start(self):
368         # Стартовая точка.# 
369         try:
370             return self.trksegs[0].trkpts[0]
371         except IndexError:
372             return None
373
374     def end(self):
375         # Финишная точка.# 
376         try:
377             return self.trksegs[-1].trkpts[-1]
378         except IndexError:
379             return None
380
381     def start_time(self):
382         # Время старта.# 
383         try:
384             return self.start().time
385         except:
386             return None
387
388     def end_time(self):
389         # Время финиша.# 
390         try:
391             return self.end().time
392         except:
393             return None    
394
395     def bound_box(self):
396       # Обрамляющий прямоугольник для всего трека.# 
397       minlat =360
398       maxlat = -360
399       minlon = 360
400       maxlon = -360
401       for trkseg in self.trksegs:
402         for pt in trkseg.trkpts:
403           if pt.lat<minlat:
404             minlat=pt.lat
405           if pt.lat>maxlat:
406             maxlat=pt.lat
407           if pt.lon<minlon:
408             minlon=pt.lon
409           if pt.lon>maxlon:
410             maxlon=pt.lon
411       return ((minlat,minlon),(maxlat,maxlon))      
412
413
414 class GPX:
415     # Работа с GPX-документами.# 
416
417     def __init__(self):
418                 # Создание пустого GPX-объекта# 
419         PATH = os.path.dirname(__file__)
420         self.creator = None
421         self.time = None
422         self.tracks = []
423         self.routes = []
424         self.waypoints = []
425         self.version = ""
426         self.author = None
427         self.name = None
428         self.link = None
429         self.copyright = None
430         self.meta = {}
431
432     def ReadTree(self,tree):
433                 # Загрузка из дерева etree.# 
434         root = tree
435
436         # Test if this is a GPX file or not and if it's version 1.1
437         if root.tag == "{http://www.topografix.com/GPX/1/1}gpx" and root.get("version") == "1.1":
438             self.version = "1.1"
439         elif root.tag == "{http://www.topografix.com/GPX/1/0}gpx" and root.get("version") == "1.0":
440             self.version = "1.0"
441         elif root.get("version") not in [ "1.1", "1.0"]:
442             raise ValueError("Версия формата %s не поддерживается. Используйте GPX 1.1." % root.get("version"))
443         else:
444             raise ValueError("Неизвестный формат дерева")
445         # attempt to validate the xml file against the schema
446
447         # initalize the GPX document for parsing.
448         self._init_version(root)
449         
450
451     def ReadFile(self, fd):
452         # Загрузка из файла.# 
453         gpx_doc = etree.parse(fd)
454         root = gpx_doc.getroot()
455
456         # Test if this is a GPX file or not and if it's version 1.1
457         if root.tag == "{http://www.topografix.com/GPX/1/1}gpx" and root.get("version") == "1.1":
458             self.version = "1.1"
459         elif root.tag == "{http://www.topografix.com/GPX/1/0}gpx" and root.get("version") == "1.0":
460             self.version = "1.0"
461         elif root.get("version") not in [ "1.1", "1.0"]:
462             raise ValueError("Версия формата %s не поддерживается. Используйте GPX 1.1." % root.get("version"))
463         else:
464             raise ValueError("Неизвестный формат файла")
465         # initalize the GPX document for parsing.
466         self._init_version(root)
467
468     def _init_version(self,root):
469         # Инициализация объекта.# 
470         self.creator = root.get("creator")
471         if root is not None:
472           for child in root:
473             if child.tag == tagprefix[self.version] + "author":
474               self.author = child.text
475             elif child.tag == tagprefix[self.version] + "trk":
476               self.tracks.append(GPXTrack(child, self.version))
477             elif child.tag == tagprefix[self.version] + "rte":
478               self.routes.append(GPXRoute(child, self.version))
479             elif child.tag == tagprefix[self.version] + "wpt":
480               self.waypoints.append(GPXTrackPt(child, self.version))
481             elif child.tag == tagprefix[self.version] + "metadata":
482                 for meta in child:
483                     if meta.tag == tagprefix[self.version] + "author":
484                       self.author = meta.text
485                     elif meta.tag == tagprefix[self.version] + "name":
486                       self.name = meta.text  
487                     elif meta.tag == tagprefix[self.version] + "bounds":
488                       # Границы пропускаем - их будем вычислять сами заново
489                       pass
490                     elif meta.tag == tagprefix[self.version] + "copyright":
491                       self.copyright = meta.text
492                     elif meta.tag == tagprefix[self.version] + "link":
493                       self.link = Link(meta,self.version) 
494                     else:
495                       self.meta[StripPrefix(meta.tag,self.version)]=meta.text
496                         
497         for i in self.meta.keys():
498           val = self.meta[i];
499           if val:
500             if not val.strip(' \n\t'):
501               del self.meta[i]
502
503     def elevation_gain(self):
504                 # Суммарный набор высоты.# 
505         return sum([track.elevation_gain() for track in self.tracks])
506
507     def elevation_loss(self):
508                 # Суммарная потеря высоты.# 
509         return sum([track.elevation_loss() for track in self.tracks])
510
511     def distance(self):
512         # Суммарная дистанция.# 
513         try:
514             return sum([track.distance() for track in self.tracks])
515         except IndexError:
516             print "Пустой файл!"
517
518     def filtered_distance(self):
519         # Суммарная дистанция с фильтрацией сбойных данных.# 
520         try:
521             return sum([track.filtered_distance() for track in self.tracks])
522         except IndexError:
523             print "Пустой файл!"
524
525     def duration(self):
526         # Суммарная продолжительность, не включая паузы.# 
527         dur = datetime.timedelta(0)
528         for track in self.tracks:
529             dur += track.duration()
530         return dur
531
532     def full_duration(self):
533         # Суммарная продолжительность, включая паузы# 
534         if hasattr(self.start(), 'duration'):
535             return self.start().duration(self.end())
536         else:
537             return None
538
539     def start(self):
540         # Точка старта.# 
541         return self.tracks[0].start()
542
543     def end(self):
544         # Точка финиша.# 
545         return self.tracks[-1].end()
546
547     def start_time(self):
548         # Время старта.# 
549         if self.start():
550             return self.start().time
551         else:
552             return None
553
554     def end_time(self):
555         # Время финиша.# 
556         return self.end().time
557
558     def bound_box(self):
559       # Обрамляющий прямоугольник для всех треков в файле.#  
560       minlat =360
561       maxlat = -360
562       minlon = 360
563       maxlon = -360
564       for track in self.tracks:
565         for trkseg in track.trksegs:
566           for pt in trkseg.trkpts:
567             if pt.lat<minlat:
568               minlat=pt.lat
569             if pt.lat>maxlat:
570               maxlat=pt.lat
571             if pt.lon<minlon:
572               minlon=pt.lon
573             if pt.lon>maxlon:
574               maxlon=pt.lon
575       return ((minlat,minlon),(maxlat,maxlon))      
576
577     def FixNames(self,linkname):
578       pprint(linkname)
579       pprint(type(linkname))
580       if type(linkname) is unicode:
581         goodname=linkname
582       else:  
583         goodname = linkname.decode('UTF-8')
584       badname = goodname.encode('ascii','replace')
585       if self.name and self.name.startswith(badname):
586         self.name=self.name.replace(badname,goodname)
587       for i in self.tracks:
588         if i.name and i.name.startswith(badname):
589           i.name = i.name.replace(badname,goodname)
590
591     def ProcessTrackSegs(self,seconds_gap=120):
592       for tr in self.tracks:
593         # Объединяем все точки трека в единую последовательность
594         all_trackpoints = []
595         for trseg in tr.trksegs:
596           all_trackpoints.extend(trseg.trkpts)
597         new_segs = []
598         current_seg = None
599         prev_pt = None
600         for pt in all_trackpoints:
601           if not current_seg:
602           # Начало нового сегмента
603             current_seg = GPXTrackSeg(None,self.version)
604             current_seg.trkpts.append(pt)
605           else: 
606             delta = pt.time - prev_pt.time
607             if delta.days > 0 or delta.seconds > seconds_gap:
608               # Нашли место разрыва
609               new_segs.append(current_seg)
610               current_seg = None  
611             else:
612               current_seg.trkpts.append(pt)  
613           prev_pt=pt   
614         # Если есть, что закинуть в хвост - пишем
615         if current_seg is not None:
616           new_segs.append(current_seg)  
617         # Обработали
618         for trs in new_segs:
619           trs._get_elevation()
620         tr.trksegs = new_segs
621         
622
623     def XMLTree(self):
624       root = etree.Element("gpx", attrib ={"creator": "pygpx",
625                                   "version": "1.1",
626                                   "xmlns": "http://www.topografix.com/GPX/1/1"}); 
627
628       # meta subtree
629
630       meta = etree.SubElement( root, "metadata" );
631       if self.name:
632         metarecord = etree.SubElement( meta, "name" )
633         metarecord.text = self.name
634       if self.author:
635         metarecord = etree.SubElement( meta, "author" )
636         metarecord.text = self.author
637       if self.copyright:
638         metarecord = etree.SubElement( meta, "copyright" )
639         metarecord.text = self.copyright
640       if self.link:  
641         self.link.write(meta)
642       for metatag in self.meta.iterkeys():
643         metarecord = etree.SubElement( meta, metatag )
644         metarecord.text = self.meta[metatag]
645
646       # wpts subtree
647
648       for i in self.waypoints:
649         i.write(root)      
650
651       # routes subtree
652       
653       for i in self.routes:
654         i.write(root)
655
656       # tracks subtree
657       
658       for i in self.tracks:
659         i.write(root)
660         
661       return root
662