def test_constructor(self):
# Check that only Location instances are accepted
assert_raises(ValueError, Bounds, 3, 5)
sw = Location(latitude=49, longitude=6)
ne = Location(latitude=51, longitude=7)
b = Bounds(sw, ne)
eq_(b.southwest.latitude, 49)
eq_(b.southwest.longitude, 6)
eq_(b.northeast.latitude, 51)
eq_(b.northeast.longitude, 7)
def test_constructor():
# Check that only Location instances are accepted
with pytest.raises(ValueError):
Bounds(3, 5)
sw = Location(latitude=49, longitude=6)
ne = Location(latitude=51, longitude=7)
b = Bounds(sw, ne)
assert b.southwest.latitude == 49
assert b.southwest.longitude == 6
assert b.northeast.latitude == 51
assert b.northeast.longitude == 7
def _get_takeoff_locations(user):
locations = Location.get_clustered_locations(
Flight.takeoff_location_wkt,
filter=and_(Flight.pilot == user, Flight.is_rankable()),
)
return [loc.to_lonlat() for loc in locations]
def near(flight_id):
flight = get_requested_record(Flight,
flight_id,
joinedload=[Flight.igc_file])
current_user = User.get(request.user_id) if request.user_id else None
if not flight.is_viewable(current_user):
return jsonify(), 404
try:
latitude = float(request.args['lat'])
longitude = float(request.args['lon'])
time = float(request.args['time'])
except (KeyError, ValueError):
abort(400)
location = Location(latitude=latitude, longitude=longitude)
time = from_seconds_of_day(flight.takeoff_time, time)
flights = _get_near_flights(flight, location, time, 1000)
def add_flight_path(flight):
trace = _get_flight_path(flight, threshold=0.0001, max_points=10000)
trace['additional'] = dict(registration=flight.registration,
competition_id=flight.competition_id)
return trace
return jsonify(flights=map(add_flight_path, flights))
def _get_takeoff_locations(user):
locations = Location.get_clustered_locations(
Flight.takeoff_location_wkt,
filter=and_(Flight.pilot == user, Flight.is_rankable()),
)
return [loc.to_lonlat() for loc in locations]
def cumulative_distance(fixes, start_fix, end_fix):
if start_fix >= end_fix:
return 0
distance = 0
last_location = None
for fix in fixes[start_fix:end_fix + 1]:
location = Location(longitude=fix.location['longitude'], latitude=fix.location['latitude'])
if last_location:
distance += location.geographic_distance(last_location)
last_location = location
return distance
def parse_location(args):
try:
latitude = float(args["lat"])
longitude = float(args["lon"])
return Location(latitude=latitude, longitude=longitude)
except (KeyError, ValueError):
abort(400)
def parse_location():
try:
latitude = float(request.args['lat'])
longitude = float(request.args['lon'])
return Location(latitude=latitude, longitude=longitude)
except (KeyError, ValueError):
abort(400)
def cumulative_distance(fixes, start_fix, end_fix):
if start_fix >= end_fix:
return 0
distance = 0
last_location = None
for fix in fixes[start_fix:end_fix + 1]:
location = Location(longitude=fix.location['longitude'],
latitude=fix.location['latitude'])
if last_location:
distance += location.geographic_distance(last_location)
last_location = location
return distance
def _get_near_flights(flight, location, time, max_distance=1000):
# calculate max_distance in degrees at the earth's sphere (approximate,
# cutoff at +-85 deg)
max_distance_deg = (max_distance / METERS_PER_DEGREE) / \
math.cos(math.radians(min(abs(location.latitude), 85)))
# the distance filter is geometric only, so max_distance must be given in
# SRID units (which is degrees for WGS84). The filter will be more and more
# inaccurate further to the poles. But it's a lot faster than the geograpic
# filter...
result = Flight.query() \
.options(undefer_group('path')) \
.filter(Flight.id != flight.id) \
.filter(Flight.takeoff_time <= time) \
.filter(Flight.landing_time >= time) \
.filter(func.ST_DWithin(Flight.locations,
location.to_wkt_element(),
max_distance_deg))
result = _patch_query(result)
flights = []
for flight in result:
# find point closest to given time
closest = min(range(len(flight.timestamps)),
key=lambda x: abs((flight.timestamps[x] - time).total_seconds()))
trace = to_shape(flight.locations).coords
if closest == 0 or closest == len(trace) - 1:
point = trace[closest]
else:
# interpolate flight trace between two fixes
next_smaller = closest if flight.timestamps[closest] < time else closest - 1
next_larger = closest if flight.timestamps[closest] > time else closest + 1
dx = (time - flight.timestamps[next_smaller]).total_seconds() / \
(flight.timestamps[next_larger] - flight.timestamps[next_smaller]).total_seconds()
point_next = trace[closest]
point_prev = trace[closest]
point = [point_prev[0] + (point_next[0] - point_prev[0]) * dx,
point_prev[1] + (point_next[1] - point_prev[1]) * dx]
point_distance = location.geographic_distance(
Location(latitude=point[1], longitude=point[0]))
if point_distance > max_distance:
continue
flights.append(flight)
# limit to 5 flights
if len(flights) == 5:
break
return flights
def first(flight, **kwargs):
return ContestLeg(
flight=flight,
contest_type="olc_plus",
trace_type="classic",
distance=234833,
cruise_height=-6491,
cruise_distance=241148,
cruise_duration=timedelta(seconds=7104),
climb_height=6510,
climb_duration=timedelta(seconds=5252),
start_height=1234,
end_height=1253,
start_time=flight.takeoff_time + timedelta(minutes=5),
end_time=flight.takeoff_time + timedelta(minutes=53),
start_location=Location(51.4, 7.1),
end_location=Location(52.5, 7.8),
).apply_kwargs(kwargs)
def olc_classic(flight, **kwargs):
return Trace(
flight=flight,
contest_type="olc_plus",
trace_type="classic",
distance=725123,
duration=timedelta(hours=6.53),
times=[
datetime(2016, 8, 17, 9, 53, 22),
datetime(2016, 8, 17, 11, 32, 29),
datetime(2016, 8, 17, 14, 2, 54),
datetime(2016, 8, 17, 16, 43, 43),
],
locations=[
Location(51.3, 7.1),
Location(51.6, 9.3),
Location(50.2, 5.8),
Location(51.3, 7.1),
],
).apply_kwargs(kwargs)
def _get_flight_path(pilot, threshold=0.001, last_update=None):
fp = _get_flight_path2(pilot, last_update=last_update)
if not fp:
return None
num_levels = 4
zoom_factor = 4
zoom_levels = [0]
zoom_levels.extend([
round(-log(
32.0 / 45.0 *
(threshold * pow(zoom_factor, num_levels - i - 1)), 2))
for i in range(1, num_levels)
])
xcsoar_flight = xcsoar.Flight(fp)
xcsoar_flight.reduce(num_levels=num_levels,
zoom_factor=zoom_factor,
threshold=threshold)
encoded_flight = xcsoar_flight.encode()
points = encoded_flight["locations"]
barogram_t = encoded_flight["times"]
barogram_h = encoded_flight["altitude"]
enl = encoded_flight["enl"]
fp_reduced = map(lambda line: FlightPathFix(*line), xcsoar_flight.path())
elevations = xcsoar.encode(
[
fix.elevation if fix.elevation is not None else UNKNOWN_ELEVATION
for fix in fp_reduced
],
method="signed",
)
geoid_height = egm96_height(
Location(latitude=fp[0].location["latitude"],
longitude=fp[0].location["longitude"]))
return dict(
points=points,
barogram_t=barogram_t,
barogram_h=barogram_h,
enl=enl,
elevations=elevations,
geoid=geoid_height,
)
def read_location(node):
"""
Reads the latitude and longitude attributes of the node
and returns a Location instance if the node was parsed correctly.
"""
if node is None:
return None
if 'latitude' not in node or 'longitude' not in node:
return None
try:
latitude = float(node['latitude'])
longitude = float(node['longitude'])
return Location(latitude=latitude, longitude=longitude)
except ValueError:
return None
def near():
try:
latitude = float(request.args['lat'])
longitude = float(request.args['lon'])
time = float(request.args['time'])
except (KeyError, ValueError):
abort(400)
location = Location(latitude=latitude, longitude=longitude)
time = from_seconds_of_day(g.flight.takeoff_time, time)
flights = _get_near_flights(g.flight, location, time, 1000)
def add_flight_path(flight):
trace = _get_flight_path(flight, threshold=0.0001, max_points=10000)
trace['additional'] = dict(registration=flight.registration,
competition_id=flight.competition_id)
return trace
return jsonify(flights=map(add_flight_path, flights))
def _get_takeoff_locations():
return Location.get_clustered_locations(
Flight.takeoff_location_wkt,
filter=and_(Flight.pilot == g.user, Flight.is_rankable()))
def _get_takeoff_locations():
return Location.get_clustered_locations(Flight.takeoff_location_wkt,
filter=(Flight.pilot == g.user))
def _get_takeoff_locations():
return Location.get_clustered_locations(Flight.takeoff_location_wkt,
filter=and_(
Flight.pilot == g.user,
Flight.is_rankable()))
def test_by_location_returns_none_by_default():
assert TimeZone.by_location(Location(longitude=10, latitude=10)) is None
def test_by_location_returns_timezone():
tz = TimeZone.by_location(Location(longitude=20, latitude=30))
assert tz is not None
assert tz.zone == "Europe/Berlin"
