[python] Python에서 사용할 GPS 라이브러리가 있습니까?

처음부터 무언가를 작성하는 대신 GPSD의 데이터 부분을 사용할 수 있습니다. 다음 코드는 GPSD 소스에서 가져온 것으로 GPS 데이터 스트림에서 경로를 만드는 모듈이 있습니다 (다음 경로 길이 및 기타 정보 가져 오기).

http://code.google.com/p/python-gpsd/source/browse/src/nmea/track.py

class Track(object):

    def __init__(self, recordDelay=10, maxSize=3600, ignoreDuplicates=True, duplicateRange=0.0001):
            """ Constructor
            
                    The default values allow for 10 hours worth of data recorded
                            at 10 second intervals.
                            
                                    recordDelay - Delay between recording data points
                                            maxSize - Maximum number of points to record
                                                    ignoreDuplicates - Ignore entries that are very similar (ie moved a minimal distance)
                                                            duplicateRange - Varience range within a duplicate is detected (adjust to account for
                                                                        subtle gps position drift)
                                                                                """
                                                                                        self.recordDelay = recordDelay
                                                                                                self.maxSize = maxSize
                                                                                                        self.ignoreDuplicates = ignoreDuplicates
                                                                                                                self.duplicateRange = duplicateRange
                                                                                                                        self.positions = []
                                                                                                                                self.latest = None
                                                                                                                                
                                                                                                                                    def append(self, position, heading, timeStamp=None):
                                                                                                                                            """ Append position and heading information """
                                                                                                                                                    if timeStamp is None: timeStamp = datetime.utcnow()
                                                                                                                                                    
                                                                                                                                                            self.latest = (timeStamp, position, heading)
                                                                                                                                                                    if len(self.positions):
                                                                                                                                                                                last = self.positions[0]
                                                                                                                                                                                        else:
                                                                                                                                                                                                    last = None
                                                                                                                                                                                                    
                                                                                                                                                                                                            # Make sure we re in range
                                                                                                                                                                                                                    if last is None or (timeStamp - last[0]).seconds >= self.recordDelay:
                                                                                                                                                                                                                                self.positions.insert(0, self.latest)
                                                                                                                                                                                                                                            self.latest = None
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                    # Clear extra data
                                                                                                                                                                                                                                                            if len(self.positions) > self.maxSize: pass
                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                def clear(self):
                                                                                                                                                                                                                                                                        """ Clear all items from track """
                                                                                                                                                                                                                                                                                self.positions = []
                                                                                                                                                                                                                                                                                        self.latest = None
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                            def __len__(self):
                                                                                                                                                                                                                                                                                                    """ Return the length of the track """
                                                                                                                                                                                                                                                                                                            if self.latest is None: return len(self.positions)
                                                                                                                                                                                                                                                                                                                    return len(self.positions) + 1
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                        def __getslice__(self, i, j):
                                                                                                                                                                                                                                                                                                                                return self.positions[i:j]
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                    def __getitem__(self, i):
                                                                                                                                                                                                                                                                                                                                            return self.positions[i]
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                def get_latest(self):
                                                                                                                                                                                                                                                                                                                                                        if self.latest is None and len(self.positions) > 0:
                                                                                                                                                                                                                                                                                                                                                                    return self.positions
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                        def get_by_time(self, timeRange, now=datetime.utcnow()):
                                                                                                                                                                                                                                                                                                                                                                                """ Returns the last n items within the time range """
                                                                                                                                                                                                                                                                                                                                                                                        result = []
                                                                                                                                                                                                                                                                                                                                                                                                if self.latest is not None: result.append(self.latest)
                                                                                                                                                                                                                                                                                                                                                                                                        for position in self.positions:
                                                                                                                                                                                                                                                                                                                                                                                                                    if (now - position[0]).seconds > timeRange: break
                                                                                                                                                                                                                                                                                                                                                                                                                                result.append(position)
                                                                                                                                                                                                                                                                                                                                                                                                                                        return result
                                                                                                                                                                                                                                                                                                                                                                                                                                        

-------------------

geopy 라는 흥미로운 라이브러리를 찾았 습니다 . 두 GPS 지점 사이의 거리를 계산할 수 있습니다 (대원 거리 및 Vincenty 거리 방법 사용). 또한 geopy 는 지오 코딩을 수행 할 수 있습니다 (주소에서 GPS 좌표를 가져올 수 있음).

다른 기능 (평균 속도, 최고점 등)은 혼자서 해킹 할 수 있습니다.

출처
https://stackoverflow.com/questions/7415001