2 # SPDX-FileCopyrightText: 2010 `Maximilian Hoegner <hp.maxi@hoegners.de>`
4 # SPDX-License-Identifier: GPL-3.0-or-later
6 # geo.py is a python module with no dependencies on extra packages,
7 # providing some convenience functions for working with geographic
10 ### Part one - Functions for dealing with points on a sphere ###
12 ### Part two - A tolerant parser for position strings ###
17 """ A parser class using regular expressions. """
21 self
.raw_patterns
= {}
24 def add(self
, name
, pattern
, virtual
=False):
25 """ Adds a new named pattern (regular expression) that can reference previously added patterns by %(pattern_name)s.
26 Virtual patterns can be used to make expressions more compact but don't show up in the parse tree. """
27 self
.raw_patterns
[name
] = "(?:" + pattern
+ ")"
28 self
.virtual
[name
] = virtual
31 self
.patterns
[name
] = ("(?:" + pattern
+ ")") % self
.patterns
33 raise (Exception, "Unknown pattern name: %s" % str(e
))
35 def parse(self
, pattern_name
, text
):
36 """ Parses 'text' with pattern 'pattern_name' and returns parse tree """
38 # build pattern with subgroups
41 for s
in re
.finditer(r
"%\(.*?\)s", self
.raw_patterns
[pattern_name
]):
42 subpattern_name
= s
.group()[2:-2]
43 if not self
.virtual
[subpattern_name
]:
44 sub_dict
[subpattern_name
] = "(" + self
.patterns
[
45 subpattern_name
] + ")"
46 subpattern_names
.append(subpattern_name
)
48 sub_dict
[subpattern_name
] = self
.patterns
[subpattern_name
]
50 pattern
= "^" + (self
.raw_patterns
[pattern_name
] % sub_dict
) + "$"
53 m
= re
.match(pattern
, text
)
58 # build tree recursively by parsing subgroups
61 for i
in range(len(subpattern_names
)):
62 text_part
= m
.group(i
+ 1)
63 if text_part
is not None:
64 subpattern
= subpattern_names
[i
]
65 tree
[subpattern
] = self
.parse(subpattern
, text_part
)
70 position_parser
= Parser()
71 position_parser
.add("direction_ns", r
"[NSns]")
72 position_parser
.add("direction_ew", r
"[EOWeow]")
73 position_parser
.add("decimal_separator", r
"[\.,]", True)
74 position_parser
.add("sign", r
"[+-]")
76 position_parser
.add("nmea_style_degrees", r
"[0-9]{2,}")
77 position_parser
.add("nmea_style_minutes",
78 r
"[0-9]{2}(?:%(decimal_separator)s[0-9]*)?")
80 "nmea_style", r
"%(sign)s?\s*%(nmea_style_degrees)s%(nmea_style_minutes)s")
84 r
"[0-9]+(?:%(decimal_separator)s[0-9]*)?|%(decimal_separator)s[0-9]+")
86 position_parser
.add("plain_degrees", r
"(?:%(sign)s\s*)?%(number)s")
88 position_parser
.add("degree_symbol", r
"°", True)
89 position_parser
.add("minutes_symbol", r
"'|′|`|´", True)
90 position_parser
.add("seconds_symbol",
91 r
"%(minutes_symbol)s%(minutes_symbol)s|″|\"",
93 position_parser.add("degrees
", r"%(number)s\s
*%(degree_symbol)s")
94 position_parser.add("minutes
", r"%(number)s\s
*%(minutes_symbol)s")
95 position_parser.add("seconds
", r"%(number)s\s
*%(seconds_symbol)s")
98 r"(?
:%(sign)s\s
*)?
%(degrees)s(?
:[+\s
]*%(minutes)s)?
(?
:[+\s
]*%(seconds)s)?|
(?
:%(sign)s\s
*)%(minutes)s(?
:[+\s
]*%(seconds)s)?|
(?
:%(sign)s\s
*)%(seconds)s"
103 r"%(nmea_style)s|
%(plain_degrees)s|
%(degree_coordinates)s")
106 r"%(nmea_style)s|
%(plain_degrees)s|
%(degree_coordinates)s")
110 r"\s
*%(direction_ns)s\s
*%(coordinates_ns)s[,;\s
]*%(direction_ew)s\s
*%(coordinates_ew)s\s
*|
"
111 r"\s
*%(direction_ew)s\s
*%(coordinates_ew)s[,;\s
]*%(direction_ns)s\s
*%(coordinates_ns)s\s
*|
"
112 r"\s
*%(coordinates_ns)s\s
*%(direction_ns)s[,;\s
]*%(coordinates_ew)s\s
*%(direction_ew)s\s
*|
"
113 r"\s
*%(coordinates_ew)s\s
*%(direction_ew)s[,;\s
]*%(coordinates_ns)s\s
*%(direction_ns)s\s
*|
"
114 r"\s
*%(coordinates_ns)s[,;\s
]+%(coordinates_ew)s\s
*"
119 """ Takes appropriate branch of parse tree and returns float. """
120 s = b["TEXT
"].replace(",", ".")
124 def get_coordinate(b):
125 """ Takes appropriate branch of the parse tree and returns degrees as a float. """
129 if b.get("nmea_style
"):
130 if b["nmea_style
"].get("nmea_style_degrees
"):
131 r += get_number(b["nmea_style
"]["nmea_style_degrees
"])
132 if b["nmea_style
"].get("nmea_style_minutes
"):
133 r += get_number(b["nmea_style
"]["nmea_style_minutes
"]) / 60.
134 if b["nmea_style
"].get(
135 "sign
") and b["nmea_style
"]["sign
"]["TEXT
"] == "-":
137 elif b.get("plain_degrees
"):
138 r += get_number(b["plain_degrees
"]["number
"])
139 if b["plain_degrees
"].get(
140 "sign
") and b["plain_degrees
"]["sign
"]["TEXT
"] == "-":
142 elif b.get("degree_coordinates
"):
143 if b["degree_coordinates
"].get("degrees
"):
144 r += get_number(b["degree_coordinates
"]["degrees
"]["number
"])
145 if b["degree_coordinates
"].get("minutes
"):
146 r += get_number(b["degree_coordinates
"]["minutes
"]["number
"]) / 60.
147 if b["degree_coordinates
"].get("seconds
"):
149 b["degree_coordinates
"]["seconds
"]["number
"]) / 3600.
150 if b["degree_coordinates
"].get(
151 "sign
") and b["degree_coordinates
"]["sign
"]["TEXT
"] == "-":
157 def parse_position(s):
158 """ Takes a (utf8-encoded) string describing a position and returns a tuple of floats for latitude and longitude in degrees.
159 Tries to be as tolerant as possible with input. Returns None if parsing doesn't succeed. """
161 parse_tree = position_parser.parse("position
", s)
162 if parse_tree is None:
167 "direction_ns
") and parse_tree["direction_ns
"]["TEXT
"] in ("S
",
173 "direction_ew
") and parse_tree["direction_ew
"]["TEXT
"] in ("W
",
177 lat = lat_sign * get_coordinate(parse_tree["coordinates_ns
"])
178 lon = lon_sign * get_coordinate(parse_tree["coordinates_ew
"])