393 lines
11 KiB
Python
393 lines
11 KiB
Python
from rowers.courseutils import coursetime_paths, coursetime_first, time_in_path
|
|
import pandas as pd
|
|
from rowers.models import (
|
|
Rower, Workout,
|
|
GeoPoint, GeoPolygon, GeoCourse,
|
|
course_length, course_coord_center, course_coord_maxmin,
|
|
polygon_coord_center, PlannedSession,
|
|
polygon_to_path, coordinate_in_path
|
|
)
|
|
from rowers.utils import geo_distance
|
|
import rowers.dataprep as dataprep
|
|
from timezonefinder import TimezoneFinder
|
|
import numpy as np
|
|
|
|
# All the Courses related methods
|
|
|
|
# Python
|
|
from django.utils import timezone
|
|
from datetime import datetime
|
|
from datetime import timedelta
|
|
import time
|
|
from django.db import IntegrityError
|
|
import uuid
|
|
from django.conf import settings
|
|
import math
|
|
|
|
import geocoder
|
|
|
|
# from matplotlib import path
|
|
import xml.etree.ElementTree as et
|
|
|
|
from xml.etree.ElementTree import Element, SubElement, Comment, tostring
|
|
from xml.dom import minidom
|
|
|
|
from rowers.models import VirtualRace
|
|
|
|
# distance of course from lat_lon in km
|
|
|
|
|
|
def howfaris(lat_lon, course):
|
|
coords = course.coord
|
|
distance = geo_distance(lat_lon[0], lat_lon[1], coords[0], coords[1])[0]
|
|
|
|
return distance
|
|
|
|
|
|
def getnearestraces(lat_lon, races, whatisnear=150):
|
|
newlist = []
|
|
counter = 0
|
|
for race in races:
|
|
if race.course is None: # pragma: no cover
|
|
newlist.append(race)
|
|
else:
|
|
c = race.course
|
|
distance = howfaris(lat_lon, c)
|
|
if distance < whatisnear:
|
|
newlist.append(race)
|
|
counter += 1
|
|
|
|
if counter > 0:
|
|
races = newlist
|
|
else:
|
|
courseraces = races.exclude(course__isnull=True)
|
|
orders = [(c.id, howfaris(lat_lon, c.course)) for c in courseraces]
|
|
orders = sorted(orders, key=lambda tup: tup[1])
|
|
ids = [id for id, distance in orders[0:4]]
|
|
for id, distance in orders[5:]: # pragma: no cover
|
|
if distance < whatisnear:
|
|
ids.append(id)
|
|
|
|
for id in ids:
|
|
newlist.append(VirtualRace.objects.get(id=id))
|
|
races = newlist
|
|
|
|
return races
|
|
|
|
|
|
def getnearestcourses(lat_lon, courses, whatisnear=150, strict=False):
|
|
|
|
newlist = []
|
|
counter = 0
|
|
for c in courses:
|
|
distance = howfaris(lat_lon, c)
|
|
|
|
if distance < whatisnear:
|
|
newlist.append(c)
|
|
counter += 1
|
|
|
|
if counter > 0:
|
|
courses = newlist
|
|
elif strict:
|
|
courses = newlist
|
|
else:
|
|
orders = [(c.id, howfaris(lat_lon, c)) for c in courses]
|
|
orders = sorted(orders, key=lambda tup: tup[1])
|
|
ids = [id for id, distance in orders[0:4]]
|
|
for id, distance in orders[5:]:
|
|
if distance < whatisnear: # pragma: no cover
|
|
ids.append(id)
|
|
|
|
for id in ids:
|
|
newlist.append(GeoCourse.objects.get(id=id))
|
|
courses = newlist
|
|
|
|
return courses
|
|
|
|
|
|
def prettify(elem):
|
|
"""Return a pretty-printed XML string for the Element.
|
|
"""
|
|
rough_string = tostring(elem, 'utf-8')
|
|
reparsed = minidom.parseString(rough_string)
|
|
return reparsed.toprettyxml(indent=" ")
|
|
|
|
|
|
ns = {'opengis': 'http://www.opengis.net/kml/2.2'}
|
|
|
|
xmlns_uris_dict = {'gx': 'http://www.google.com/kml/ext/2.2',
|
|
'kml': 'http://www.google.com/kml/ext/2.2',
|
|
'atom': "http://www.w3.org/2005/Atom",
|
|
'': "http://www.opengis.net/kml/2.2"}
|
|
|
|
|
|
def get_polar_angle(point, reference_point):
|
|
"""
|
|
Calculate the polar angle of a point with respect to a reference point.
|
|
"""
|
|
try:
|
|
delta_x = point.longitude - reference_point.longitude
|
|
delta_y = point.latitude - reference_point.latitude
|
|
except AttributeError:
|
|
delta_x = point['longitude'] - reference_point.longitude
|
|
delta_y = point['latitude'] - reference_point.latitude
|
|
|
|
|
|
return math.atan2(delta_y, delta_x)
|
|
|
|
class Coordinate:
|
|
def __init__(self, latitude, longitude):
|
|
self.latitude = latitude
|
|
self.longitude = longitude
|
|
|
|
def get_coordinates_centerpoint(coordinates):
|
|
try:
|
|
centroid_latitude = sum(coord.latitude for coord in coordinates) / len(coordinates)
|
|
centroid_longitude = sum(coord.longitude for coord in coordinates) / len(coordinates)
|
|
centroid = Coordinate(centroid_latitude, centroid_longitude)
|
|
except AttributeError:
|
|
centroid_latitude = sum(coord['latitude'] for coord in coordinates) / len(coordinates)
|
|
centroid_longitude = sum(coord['longitude'] for coord in coordinates) / len(coordinates)
|
|
centroid = Coordinate(centroid_latitude, centroid_longitude)
|
|
|
|
return centroid
|
|
|
|
def sort_coordinates_ccw(coordinates):
|
|
"""
|
|
Sort coordinates in counterclockwise order.
|
|
"""
|
|
# Find the reference point (centroid)
|
|
centroid = get_coordinates_centerpoint(coordinates)
|
|
|
|
# Sort coordinates based on polar angle with respect to the centroid
|
|
sorted_coords = sorted(coordinates, key=lambda coord: get_polar_angle(coord, centroid))
|
|
|
|
return sorted_coords
|
|
|
|
|
|
def crewnerdcourse(doc):
|
|
courses = []
|
|
for course in doc:
|
|
name = course.findall('.//opengis:name', ns)[0].text
|
|
try:
|
|
description = course.findall('.//opengis:description', ns)[0].text
|
|
except IndexError:
|
|
description = ''
|
|
|
|
polygonpms = course.findall(
|
|
'.//opengis:Placemark[opengis:Polygon]', ns)
|
|
polygons = get_polygons(polygonpms)
|
|
|
|
courses.append({
|
|
'name': name,
|
|
'description': description,
|
|
'polygons': polygons
|
|
})
|
|
|
|
return courses
|
|
|
|
|
|
def get_polygons(polygonpms):
|
|
polygons = []
|
|
for pm in polygonpms:
|
|
name = pm.findall('.//opengis:name', ns)[0].text
|
|
coordinates = pm.findall('.//opengis:coordinates', ns)
|
|
if coordinates:
|
|
cc = coordinates[0].text
|
|
else: # pragma: no cover
|
|
cc = ''
|
|
|
|
pointstring = cc.split()
|
|
|
|
points = []
|
|
for s in pointstring:
|
|
coordinates = s.split(',')
|
|
points.append({
|
|
'longitude': float(coordinates[0]),
|
|
'latitude': float(coordinates[1]),
|
|
})
|
|
|
|
points = sort_coordinates_ccw(points)
|
|
|
|
polygons.append({
|
|
'name': name,
|
|
'points': points
|
|
})
|
|
|
|
return polygons
|
|
|
|
|
|
def coursetokml(course):
|
|
top = Element('kml')
|
|
for prefix, uri in xmlns_uris_dict.items():
|
|
if prefix != '':
|
|
top.attrib['xmlns:' + prefix] = uri
|
|
else:
|
|
top.attrib['xmlns'] = uri
|
|
|
|
document = SubElement(top, 'Document')
|
|
name = SubElement(document, 'name')
|
|
name.text = 'Courses.kml'
|
|
folder = SubElement(document, 'Folder')
|
|
foldername = SubElement(folder, 'name')
|
|
foldername.text = 'Courses'
|
|
folder2 = SubElement(folder, 'Folder')
|
|
coursename = SubElement(folder2, 'name')
|
|
coursename.text = course.name
|
|
open = SubElement(folder2, 'open')
|
|
open.text = '1'
|
|
|
|
polygons = GeoPolygon.objects.filter(
|
|
course=course).order_by("order_in_course")
|
|
|
|
for polygon in polygons:
|
|
placemark = SubElement(folder2, 'Placemark')
|
|
polygonname = SubElement(placemark, 'name')
|
|
polygonname.text = polygon.name
|
|
p = SubElement(placemark, 'Polygon')
|
|
tessellate = SubElement(p, 'tessellate')
|
|
tessellate.text = '1'
|
|
boundary = SubElement(p, 'outerBoundaryIs')
|
|
ring = SubElement(boundary, 'LinearRing')
|
|
coordinates = SubElement(ring, 'coordinates')
|
|
coordinates.text = ''
|
|
points = GeoPoint.objects.filter(
|
|
polygon=polygon).order_by("order_in_poly")
|
|
points = sort_coordinates_ccw(points)
|
|
for point in points:
|
|
coordinates.text += '{lon},{lat},0 '.format(
|
|
lat=point.latitude,
|
|
lon=point.longitude,
|
|
)
|
|
coordinates.text += '{lon},{lat},0'.format(
|
|
lat=points[0].latitude,
|
|
lon=points[0].longitude,
|
|
)
|
|
|
|
return prettify(top)
|
|
|
|
|
|
def kmltocourse(f):
|
|
doc = et.parse(f)
|
|
courses = doc.findall('.//opengis:Folder[opengis:Placemark]', ns)
|
|
|
|
if not courses: # pragma: no cover
|
|
courses = doc.findall('.//opengis:Document[opengis:Placemark]', ns)
|
|
if not courses:
|
|
courses = doc.findall('.//opengis:Placemark', ns)
|
|
|
|
if courses:
|
|
return crewnerdcourse(courses)
|
|
|
|
polygonpms = doc.findall(
|
|
'.//opengis:Placemark[opengis:Polygon]', ns) # pragma: no cover
|
|
|
|
return get_polygons(polygonpms) # pragma: no cover
|
|
|
|
|
|
def createcourse(
|
|
manager, name, polygons, notes=''):
|
|
|
|
c = GeoCourse(manager=manager, name=name, notes=notes)
|
|
c.save()
|
|
|
|
i = 0
|
|
for p in polygons:
|
|
pp = GeoPolygon(course=c, order_in_course=i, name=p['name'])
|
|
pp.save()
|
|
j = 0
|
|
for point in p['points']:
|
|
if i == 0 and j == 0:
|
|
latitude = point['latitude']
|
|
longitude = point['longitude']
|
|
g = geocoder.osm([latitude, longitude], method='reverse')
|
|
if g.ok:
|
|
country = g.json['country']
|
|
else: # pragma: no cover
|
|
country = 'unknown'
|
|
|
|
c.country = country
|
|
c.save()
|
|
obj = GeoPoint(
|
|
latitude=point['latitude'],
|
|
longitude=point['longitude'],
|
|
polygon=pp,
|
|
order_in_poly=j
|
|
)
|
|
obj.save()
|
|
j += 1
|
|
i += 1
|
|
|
|
c.distance = int(course_length(c))
|
|
c.save()
|
|
|
|
return c
|
|
|
|
|
|
def get_time_course(ws, course): # pragma: no cover
|
|
coursetimeseconds = 0.0
|
|
coursecompleted = False
|
|
|
|
w = ws[0]
|
|
columns = ['time', ' latitude', ' longitude', 'cum_dist']
|
|
rowdata = dataprep.getsmallrowdata_db(
|
|
columns,
|
|
ids=[w.id],
|
|
doclean=False,
|
|
workstrokesonly=False
|
|
)
|
|
|
|
rowdata.rename(columns={
|
|
' latitude': 'latitude',
|
|
' longitude': 'longitude',
|
|
}, inplace=True)
|
|
|
|
rowdata['time'] = rowdata['time']/1000.
|
|
|
|
rowdata.fillna(method='backfill', inplace=True)
|
|
|
|
rowdata['time'] = rowdata['time']-rowdata.ix[0, 'time']
|
|
# we may want to expand the time (interpolate)
|
|
rowdata['dt'] = rowdata['time'].apply(
|
|
lambda x: timedelta(seconds=x)
|
|
)
|
|
rowdata = rowdata.resample('100ms', on='dt').mean()
|
|
rowdata = rowdata.interpolate()
|
|
|
|
# create path
|
|
polygons = GeoPolygon.objects.filter(
|
|
course=course).order_by("order_in_course")
|
|
paths = []
|
|
for polygon in polygons:
|
|
path = polygon_to_path(polygon)
|
|
paths.append(path)
|
|
|
|
(
|
|
coursetimeseconds,
|
|
coursemeters,
|
|
coursecompleted,
|
|
|
|
) = coursetime_paths(rowdata, paths)
|
|
(
|
|
coursetimefirst,
|
|
coursemetersfirst,
|
|
firstcompleted
|
|
) = coursetime_first(
|
|
rowdata, paths)
|
|
|
|
coursetimeseconds = coursetimeseconds-coursetimefirst
|
|
coursemeters = coursemeters-coursemetersfirst
|
|
|
|
return coursetimeseconds, coursemeters, coursecompleted
|
|
|
|
|
|
def replacecourse(course1, course2):
|
|
ps = PlannedSession.objects.filter(course=course1)
|
|
for p in ps:
|
|
p.course = course2
|
|
p.save()
|
|
|
|
course1.delete()
|
|
|
|
return 1
|