def test_tracks_with_fishpoints(self):
ofp = load_ofp(DATADIR + '/KJFK-LFPG 27Mar2015 05:45z OFP.txt')
tracks = list(ofp.tracks(fishfile=FISHFILE))
self.assertEqual(len(tracks), 9)
self.assertEqual(
tracks[0],
Route([
GeoPoint((55.000000, -15.000000), name="RESNO"),
GeoPoint((56.000000, -20.000000)),
GeoPoint((57.000000, -30.000000)),
GeoPoint((58.000000, -40.000000)),
GeoPoint((58.000000, -50.000000)),
GeoPoint((56.700000, -57.000000), name="CUDDY")
]))
self.assertEqual(
tracks[-1],
Route([
GeoPoint((42.000000, -40.000000)),
GeoPoint((38.000000, -50.000000)),
GeoPoint((33.000000, -60.000000)),
GeoPoint((32.670000, -61.190000), name="NUMBR")
]))
for p in tracks[0]:
self.assertTrue(p.name)
self.assertTrue(tracks[0].name.endswith('A'))
self.assertTrue(tracks[-1].name.endswith('J'))
def add_sigmets(kml, folder, jsondata):
from editolido.geopoint import GeoPoint
from editolido.route import Route
for d in jsondata['features']:
props = d['properties']
geom = d['geometry']
name = "{firName}: {qualifier} {hazard}".format(**props)
description = "{rawSigmet}".format(**props)
if geom['type'] == 'LineString':
geom['coordinates'] = [geom['coordinates']]
if geom['type'] in ('Polygon', 'LineString'):
for area in geom['coordinates']:
route = Route(
[GeoPoint((lat, lon)) for lon, lat in area],
name=name,
description=description
)
kml.add_line(folder, route)
kml.add_point(
folder,
GeoPoint.get_center(
route,
name=name, description=description),
)
elif geom['type'] == 'Point':
kml.add_point(
folder,
GeoPoint(
(geom['coordinates'][1], geom['coordinates'][0]),
name=name, description=description),
)
else:
print(d)
print('unknown geometry type: %s' % geom['type'])
raise ValueError
def test_repr(self):
self.assertEqual(
"%s" % GeoPoint((10, 20)),
'GeoPoint((10.000000, 20.000000))')
self.assertEqual(
"%s" % GeoPoint((10, 20), name="WPT"),
'GeoPoint(WPT(10.000000, 20.000000))')
def test_add_line(self):
kml = KMLGenerator(line_template="{name} {color}")
kml.add_folder('aFolder')
from editolido.route import Route
from editolido.geopoint import GeoPoint
route = Route([GeoPoint((0, 0)), GeoPoint((0, 90))], name="route")
kml.add_line('aFolder', route, color="blouge")
self.assertEqual(kml.folders['aFolder'][0], 'route blouge')
def test_add_point_no_pin_set_in_folder(self):
kml = KMLGenerator(point_template="{name} {color}")
kml.add_folder('aFolder')
from editolido.geopoint import GeoPoint
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"))
self.assertFalse(kml.folders['aFolder'])
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"),
color="blouge", style='#style')
self.assertEqual(kml.folders['aFolder'][0], 'P1 blouge')
def test_add_points(self):
kml = KMLGenerator(point_template="{name}{color}")
kml.add_folder('aFolder')
from editolido.route import Route
from editolido.geopoint import GeoPoint
route = Route([GeoPoint((0, 0)), GeoPoint((0, 90))], name="route")
kml.add_points('aFolder', route, color="blouge")
self.assertEqual(''.join(kml.folders['aFolder']),
'N0000.0W00000.0blougeN0000.0E09000.0blouge')
def test_wpt_coordinates_alternate(self):
ofp = load_ofp(DATADIR + '/KJFK-LFPG 27Mar2015 05:45z OFP.txt')
points = list(ofp.wpt_coordinates_alternate())
self.assertEqual(points[0],
GeoPoint('N4900.6E00232.9', normalizer=dm_normalizer))
self.assertEqual(points[1],
GeoPoint('N4825.8E00213.8', normalizer=dm_normalizer))
self.assertEqual(points[-1],
GeoPoint('N4843.4E00222.8', normalizer=dm_normalizer))
def tracks(self, fishfile=None):
"""
Yield a route for each track found
Note: track points only include arinc points (no entry or exit point)
Full track display requires an optional csv files containing fish points.
:return: generator
"""
try:
tracks = self.tracks_iterator()
except (LookupError, IndexError):
return
geo_wpt_regex = r'(\d{2,4}[NS]\d{3,5}[EW]|[NESW]\d{4}|\d[NESW]\d{3}[^EW])'
tracks = list(tracks)
fish_points = None
# optionally find entry/exit points
if fishfile:
unknown_wpts = []
for letter, description in tracks:
track_points = [p.strip() for p in description.split(' ') if p.strip()]
for label in track_points:
if label == 'LVLS':
break
m = re.match(geo_wpt_regex, label)
if not m:
unknown_wpts.append(label)
fish_points = get_missing_fishpoints(unknown_wpts, fishfile=fishfile)
for letter, description in tracks:
is_mine = self.is_my_track(letter)
if is_mine:
label_dict = {p.name: p for p in self.route if p.name}
else:
label_dict = fish_points
track_points = [p.strip() for p in description.split(' ') if p.strip()]
track_route = []
track_is_complete = True
for label in track_points:
if label == 'LVLS':
break
m = re.match(geo_wpt_regex, label)
if m:
track_route.append(GeoPoint(label, normalizer=arinc_normalizer, name=label))
elif label_dict and label in label_dict:
track_route.append(GeoPoint(label_dict[label], name=label))
else:
track_is_complete = False
yield Track(
track_route,
name="NAT %s" % letter,
description=description,
is_mine=self.is_my_track(letter),
is_complete=track_is_complete,
)
def test_get_nearest_points(self):
from editolido.geoindex import GeoGridIndex
c = GeoPoint((45, 10.5))
p = GeoPoint((45, 10)) # à 21,23NM
grid = GeoGridIndex()
grid.add_point(p)
nearby = grid.get_nearest_points(c, 20, converter=nm_to_rad)
self.assertEqual(list(nearby), [])
nearby = grid.get_nearest_points(c, 23, converter=nm_to_rad)
self.assertEqual(list(nearby),
[(p, c.distance_to(p, converter=rad_to_nm))])
def test_add_point_pin_set_in_folder(self):
kml = KMLGenerator(point_template="{name} {color} {style}")
kml.add_folder('aFolder', pin=PIN_ORANGE)
from editolido.geopoint import GeoPoint
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"), color="blouge")
self.assertEqual(kml.folders['aFolder'][0],
'P1 blouge #placemark-orange')
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"),
color="blouge", style=PIN_RED)
self.assertEqual(kml.folders['aFolder'][1],
'P1 blouge #placemark-red')
def test_add_segments(self):
kml = KMLGenerator(point_template="{name}{color}")
kml.add_folder('aFolder')
from editolido.route import Route
from editolido.geopoint import GeoPoint
route = Route([GeoPoint((0, 0), name='p1'),
GeoPoint((45, 90), name='p2'),
GeoPoint((0, 90), name='p3')], name="route")
kml.add_points('aFolder', route, color="blouge")
self.assertEqual(''.join(kml.folders['aFolder']),
'p1blougep2blougep3blouge')
def test_wpt_coordinates_alternate_af011_22Mar2016(self):
ofp = load_ofp(DATADIR +
'/AF011_KJFK-LFPG_22Mar2016_02:45z_OFP_8_0_1.txt')
points = list(ofp.wpt_coordinates_alternate())
self.assertEqual(points[0],
GeoPoint('N4900.6E00232.9', normalizer=dm_normalizer))
self.assertEqual(points[1],
GeoPoint('N4825.8E00213.8', normalizer=dm_normalizer))
self.assertEqual(points[-1],
GeoPoint('N4843.4E00222.8', normalizer=dm_normalizer))
def test_render_folders(self):
kml = KMLGenerator(folder_template="{name} {open} {content}",
point_template="{name} {color} {style}")
kml.add_folders('aFolder', ('another', PIN_RED))
from editolido.geopoint import GeoPoint
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"),
color="blouge", style='#mystyle')
kml.add_point('another', GeoPoint((0, 0), name="P2"), color="red")
self.assertEqual(kml.render_folders(),
'aFolder 1 P1 blouge #mystyle\n'
'another 1 P2 red #placemark-red')
def test_get_nearest_points_dirty(self):
c = GeoPoint((45, 10.5))
p = GeoPoint((45, 10)) # à 21,23NM
grid = GeoGridIndex(4)
print(grid.precision, rad_to_km(grid.grid_size))
grid.add_point([p.name, float(p.latitude), float(p.longitude)])
with self.assertRaises(ValueError):
grid.get_nearest_points_dirty(c, 30, converter=nm_to_rad)
grid = GeoGridIndex()
grid.add_point([p.name, float(p.latitude), float(p.longitude)])
nearby = grid.get_nearest_points_dirty(c, 20, converter=nm_to_rad)
self.assertEqual(list(nearby), [p])
def test_slice(self):
def generator(): # pragma no cover
return
# noinspection PyUnreachableCode
yield "dummy generator"
route = Route(generator())
self.assertFalse(route)
self.assertEqual([], route[1:])
self.assertEqual([], route[:])
route = Route([GeoPoint((0, 0)), GeoPoint((0, 90))])
self.assertEqual([GeoPoint((0, 90))], route[1:])
def test_segments(self):
a = GeoPoint((0, 0))
b = GeoPoint((0, 90))
c = GeoPoint((0, 180))
route = Route([a, b, c], )
self.assertEqual(list(route.segments), [(a, b), (b, c)])
route = Route([a, b], )
self.assertEqual(list(route.segments), [(a, b)])
route = Route()
self.assertEqual(list(route.segments), [])
route = Route([a, c])
self.assertEqual(list(route.segments), [(a, c)])
def test_distance(self):
from editolido.geolite import rad_to_nm
geopoint1 = GeoPoint((30, 13))
geopoint2 = GeoPoint((50, -77))
self.assertEqual(
GeoPoint.distance(geopoint1, geopoint2),
geopoint1.distance_to(geopoint2),
msg='unit radians'
)
self.assertEqual(
GeoPoint.distance(geopoint1, geopoint2, converter=rad_to_nm),
geopoint1.distance_to(geopoint2, converter=rad_to_nm)
)
def test_equality(self):
from editolido.geolite import LatLng
geopoint1 = GeoPoint((30, 13))
geopoint2 = GeoPoint((30, 13))
self.assertEqual(geopoint1, geopoint2)
self.assertTrue(geopoint1 == geopoint1)
self.assertEqual(geopoint1, LatLng(30., 13.))
geopoint3 = GeoPoint((50, -77))
self.assertFalse(geopoint1 == geopoint3)
self.assertNotEqual(geopoint1, geopoint3)
with self.assertRaises(ValueError):
geopoint1 == (30, 13)
self.assertEqual(GeoPoint((0, 46.6822)), GeoPoint((0, 46.6822001)))
def test_wpt_coordinates(self):
ofp = load_ofp(DATADIR + '/KJFK-LFPG 27Mar2015 05:45z OFP.txt')
points = list(ofp.wpt_coordinates())
self.assertEqual(len(points), 31)
self.assertEqual(points[0].name, 'KJFK')
self.assertEqual(points[-1].name, 'LFPG')
self.assertEqual(points[5].name, '')
self.assertEqual(points[0],
GeoPoint('N4038.4W07346.7', normalizer=dm_normalizer))
self.assertEqual(points[-1],
GeoPoint('N4900.6E00232.9', normalizer=dm_normalizer))
self.assertEqual(points[5],
GeoPoint('N5100.0W05000.0', normalizer=dm_normalizer))
def tests_tracks_rlat_new_format(self):
ofp = load_ofp(DATADIR +
'/AF009_KJFK-LFPG_18Mar2016_04:55z_OFP_12_0_1.txt')
tracks = list(ofp.tracks())
self.assertEqual(len(tracks), 7)
self.assertEqual(
tracks[0],
Route([
GeoPoint((50, -50)),
GeoPoint((51, -40)),
GeoPoint((52, -30)),
GeoPoint((53, -20))
]))
self.assertFalse(tracks[0].is_complete)
self.assertEqual(
tracks[2],
Route([
GeoPoint((48.5, -50)),
GeoPoint((49.5, -40)),
GeoPoint((50.5, -30)),
GeoPoint((51.5, -20))
]))
self.assertFalse(tracks[2].is_complete)
self.assertTrue(tracks[0].name.endswith('T'))
self.assertTrue(tracks[-1].name.endswith('Z'))
def test_distance(self):
route = Route()
self.assertAlmostEqual(route.distance(converter=None), 0)
a = GeoPoint((0, 0))
b = GeoPoint((0, 90))
c = GeoPoint((0, 180))
route = Route([a, b, c])
self.assertAlmostEqual(route.distance(converter=None), math.pi)
route = Route([c, b, a])
self.assertAlmostEqual(route.distance(converter=None), math.pi)
route = Route([a, c])
self.assertAlmostEqual(route.distance(converter=None), math.pi)
d = GeoPoint((-90, 0))
route = Route([a, d, c])
self.assertAlmostEqual(route.distance(converter=None), math.pi)
def test_as_kml_line(self):
kml = KMLGenerator(
line_template='{name}/{style}/{description}/{coordinates}',)
from editolido.geopoint import GeoPoint
from editolido.route import Route
start = GeoPoint((0, 0))
end = GeoPoint((0, 90))
route = Route(
[start, end], name="route_name", description="route_description")
kml.add_folder('aFolder')
kml.add_line('aFolder', route, style='route_style')
self.assertEqual(
''.join(kml.folders['aFolder']),
'route_name/route_style/route_description/'
'0.000000,0.000000 90.000000,0.000000'
)
def test_get_nearest_points(self):
center_point = GeoPoint([49, 2])
wmo_grid = GeoGridIndex()
wmo_grid.load()
nearest = list(wmo_grid.get_nearest_points(center_point, 27))
self.assertEqual(len(nearest), 1)
self.assertEqual(nearest[0][0].name, "07145")
def test_get_nearest_points(self):
c = GeoPoint((45, 10.5))
p = GeoPoint((45, 10)) # à 21,23NM
grid = GeoGridIndex()
grid.add_point([p.name, float(p.latitude), float(p.longitude)])
nearby = grid.get_nearest_points(c, 20, converter=nm_to_rad)
if six.PY2:
self.assertEqual(list(nearby), [])
else:
pass # TODO
nearby = grid.get_nearest_points(c, 23, converter=nm_to_rad)
if six.PY2:
self.assertEqual(list(nearby),
[(p, c.distance_to(p, converter=rad_to_nm))])
else:
pass # TODO
def add_sigmets(kml, folder, jsondata):
from editolido.geopoint import GeoPoint
from editolido.route import Route
for d in jsondata['features']:
props = d['properties']
geom = d['geometry']
name = "{firName}: {qualifier} {hazard}".format(**props)
description = "{rawSigmet}".format(**props)
if geom['type'] == 'LineString':
geom['coordinates'] = [geom['coordinates']]
if geom['type'] in ('Polygon', 'LineString'):
for area in geom['coordinates']:
route = Route(
[GeoPoint((lat, lon)) for lon, lat in area],
name=name,
description=description
)
kml.add_line(folder, route)
kml.add_point(
folder,
GeoPoint.get_center(
route,
name=name, description=description),
)
elif geom['type'] == 'Point':
kml.add_point(
folder,
GeoPoint(
(geom['coordinates'][1], geom['coordinates'][0]),
name=name, description=description),
)
else:
print(d)
print('unknown geometry type: %s' % geom['type'])
raise ValueError
def test_as_kml_points(self):
kml = KMLGenerator(
point_template='{name}/{style}/{description}/{coordinates}',)
from editolido.geopoint import GeoPoint
from editolido.route import Route
start = GeoPoint((0, 0), name="P1")
end = GeoPoint((0, 90), name="P2", description="D2")
route = Route(
[start, end], name="route_name", description="route_description")
kml.add_folder('aFolder')
kml.add_points('aFolder', route, style='point_style')
self.assertEqual(
'\n'.join(kml.folders['aFolder']),
'P1/point_style//0.000000,0.000000\n'
'P2/point_style/D2/90.000000,0.000000'
)
def get_nearest_points_dirty(self,
center_point,
radius,
converter=km_to_rad):
"""
return approx list of point from circle with given center and radius
it uses geohash and return with some error (see GEO_HASH_ERRORS)
:param center_point: center of search circle
:param radius: radius of search circle
:param converter: function to convert the radius unit in radians
:return: list of GeoPoints from given area
"""
if converter:
radius = converter(radius)
if radius > self.grid_size / 2.0:
# radius is too big for current grid, we cannot use 9 neighbors
# to cover all possible points
suggested_precision = 0
for precision, max_size in GEO_HASH_GRID_SIZE.items():
if radius > km_to_rad(max_size) / 2:
suggested_precision = precision - 1
break
raise ValueError(
'Too large radius, please rebuild GeoHashGrid with '
'precision={0}'.format(suggested_precision))
me_and_neighbors = geohash.expand(self.get_point_hash(center_point))
points = []
for key in me_and_neighbors:
for name, lat, lon in self.data.get(key, []):
points.append(GeoPoint([lat, lon], name=name))
return points
def wpt_coordinates_generator(text):
for m in re.finditer(r'(\S+|\s+)\s+([NS]\d{4}\.\d)([EW]\d{5}\.\d)',
text):
name = m.group(1).strip()
yield GeoPoint(
(m.group(2), m.group(3)),
name=name, normalizer=dm_normalizer
)
def test_get_nearest_points_dirty(self):
center_point = GeoPoint([49, 2])
wmo_grid = GeoGridIndex()
wmo_grid.load()
# with self.assertRaises(ValueError):
# wmo_grid.get_nearest_points_dirty(center_point, 100)
nearest = list(wmo_grid.get_nearest_points_dirty(center_point, 75))
self.assertEqual(len(nearest), 42)
def test_dumps(self):
p = GeoPoint((45, 10), name='P1', description='D2')
grid = GeoGridIndex()
self.assertEqual(grid.dumps(), '{}')
grid.add_point([p.name, float(p.latitude), float(p.longitude)])
grid.data['__test__'] = 'test' # test default encoder is called
jsondata = grid.dumps()
self.assertDictEqual(grid.data, json.loads(jsondata, encoding='utf-8'))
def test_render_folder(self):
kml = KMLGenerator(folder_template="{name} {open} {content}",
point_template="{name} {color} {style}")
kml.add_folder('aFolder')
from editolido.geopoint import GeoPoint
kml.add_point('aFolder', GeoPoint((0, 0), name="P1"),
color="blouge", style='#mystyle')
self.assertEqual(kml.render_folder('aFolder'),
'aFolder 1 P1 blouge #mystyle')
def test_tracks(self):
ofp = load_ofp(
DATADIR +
'/AF342_LFPG-CYUL_30Jul2019_14-00z_OFP7_0_1_pdfminer.txt')
tracks = list(ofp.tracks())
self.assertEqual(len(tracks), 6)
self.assertEqual(
tracks[0],
Route([
GeoPoint((62.000000, -20.000000)),
GeoPoint((63.000000, -30.000000)),
GeoPoint((64.000000, -40.000000)),
GeoPoint((63.000000, -50.000000))
]))
for p in tracks[0]:
self.assertTrue(p.name)
self.assertTrue(tracks[0].name.endswith('A'))
self.assertTrue(tracks[-1].name.endswith('F'))
def test_tracks(self):
ofp = load_ofp(
DATADIR +
'/AF 010_LFPG-KJFK_27Sep2019_1450z_OFP_6_nvp_pdfminer.txt')
tracks = list(ofp.tracks())
self.assertEqual(len(tracks), 5)
self.assertEqual(
tracks[0],
Route([
GeoPoint((59.000000, -20.000000)),
GeoPoint((59.000000, -30.000000)),
GeoPoint((58.000000, -40.000000)),
GeoPoint((56.000000, -50.000000))
]))
for p in tracks[0]:
self.assertTrue(p.name)
self.assertTrue(tracks[0].name.endswith('A'))
self.assertTrue(tracks[-1].name.endswith('E'))
def test_distance_to(self):
import math
from editolido.geolite import rad_to_nm, rad_to_km
geopoint1 = GeoPoint((0, 90))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint1),
0, msg="distance to self")
geopoint2 = GeoPoint((0, -90))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2),
math.pi, msg="points on equator")
geopoint2 = GeoPoint((90, -90))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2),
math.pi / 2, msg="pole to equator")
geopoint1 = GeoPoint((0, 179))
geopoint2 = GeoPoint((0, -179))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2),
2 * math.pi / 180, msg="date line boundary")
geopoint1 = GeoPoint((0, 1))
geopoint2 = GeoPoint((0, -1))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2),
2 * math.pi / 180, msg="greenwich boundary")
geopoint1 = GeoPoint((1, 0))
geopoint2 = GeoPoint((-1, 0))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2),
2 * math.pi / 180, msg="equator boundary")
geopoint1 = GeoPoint((30, 13))
geopoint2 = GeoPoint((50, -77))
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2, converter=rad_to_nm),
4051, places=0)
self.assertAlmostEqual(
geopoint1.distance_to(geopoint2, converter=rad_to_km),
7503, places=0)
def test_at_fraction(self):
geopoint1 = GeoPoint((30, 13))
geopoint2 = GeoPoint((50, -77))
expected = GeoPoint((49.5732910, -23.5838094))
self.assertEqual(geopoint1.at_fraction(geopoint2, 0.5), expected)
