def test_haversine_distance(self):
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(2, 3)
self.assertEqual(
loc1.distance_2d(loc2),
mod_geo.distance(loc1.latitude, loc1.longitude, None,
loc2.latitude, loc2.longitude, None))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(3, 4)
self.assertEqual(
loc1.distance_2d(loc2),
mod_geo.distance(loc1.latitude, loc1.longitude, None,
loc2.latitude, loc2.longitude, None))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(3.1, 4)
self.assertEqual(
loc1.distance_2d(loc2),
mod_geo.haversine_distance(loc1.latitude, loc1.longitude,
loc2.latitude, loc2.longitude))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(2, 4.1)
self.assertEqual(
loc1.distance_2d(loc2),
mod_geo.haversine_distance(loc1.latitude, loc1.longitude,
loc2.latitude, loc2.longitude))
def convert_gpx_string_to_array(gpx_file_string):
gpx = gpxpy.parse(gpx_file_string)
tracks = []
for track in gpx.tracks:
segments = []
start_time, end_time = track.get_time_bounds()
for segment in track.segments:
points = []
for point in segment.points:
points.append([point.latitude, point.longitude])
segments.append(points)
new_segments = []
new_segment = []
last_point = None
for index_s, segment in enumerate(segments):
for index_p, point in enumerate(segment):
if (index_p == 0) and (last_point):
if haversine_distance(last_point[0], last_point[1], point[0], point[1]) >= settings.MERGE_SEGMENT_DISTANCE:
new_segments.append(new_segment)
new_segment = []
new_segment.append(point)
last_point = point
new_segments.append(new_segment)
distance = calculate_distance_from_segments(new_segments)
tracks.append((gpx.name, distance, start_time, end_time, new_segments))
return tracks
def __createDeltaDist(self):
lat1, lon1, lat2, lon2 = 0, 0, 0, 0
for i in range(len(self.coordList) - 1):
lat1, lon1 = self.coordList[i]
lat2, lon2 = self.coordList[i + 1]
delta = geo.haversine_distance(lat1, lon1, lat2, lon2)
self.deltaDist.append(delta / 1000)
def print_avg_error_distance(X, y_latlong, kf):
### Get the avg distance our guess was away from the actual spot ###
print(
"Running lat,long regression and calculating the average distance between our predictions and the ground truth"
)
y = y_latlong
counter = 0
all_avg_errors_in_distance = []
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
regression_model = LinearRegression()
regression_model.fit(X_train, y_train)
errors_in_distance = []
for X_row, y_true_row in zip(X_test, y_test):
y_pred_row = regression_model.predict(X_row.reshape(1, -1))[0]
distance = haversine_distance(y_pred_row[0], y_pred_row[1],
y_true_row[0],
y_true_row[1]) / 1000 #gives of km
errors_in_distance.append(distance)
avg_error_in_distance = np.average(errors_in_distance)
print("Fold " + str(counter) +
" had an average error in distance of %.3f km" %
avg_error_in_distance)
all_avg_errors_in_distance.append(avg_error_in_distance)
counter += 1
print("Average error across all folds was %.3f km\n" %
np.average(all_avg_errors_in_distance))
def calculate_distance_from_segments(segments):
distance = 0
last_point = None
for segment in segments:
first_segment_point = True
for point in segment:
if last_point and first_segment_point:
if haversine_distance(
last_point[0], last_point[1], point[0],
point[1]) >= settings.MERGE_SEGMENT_DISTANCE:
last_point = None
if last_point:
distance = distance + haversine_distance(
last_point[0], last_point[1], point[0], point[1])
last_point = point
first_segment_point = False
return round(distance)
def distance_gps(point1, point2):
"""
This method return the eucliedien distance between two points
:param point1:
:param point2:
:return:
"""
return haversine_distance(point1.get_latitude(), point1.get_longitude(),
point2.get_latitude(), point2.get_longitude())
def get_context(self, request):
context = super(ResourcePage, self).get_context(request)
if (request.META.get('HTTP_REFERER')
and request.session.get('results_page')):
context['back'] = request.session.pop('results_page')
if 'ldmw_session' in request.COOKIES:
cookie = request.COOKIES['ldmw_session']
try:
context['liked_value'] = Likes.objects\
.get(resource_id=self.id, user_hash=cookie)\
.like_value
except:
context['liked_value'] = 0
else:
cookie = ''
context['liked_value'] = 0
if 'ldmw_location_latlong' in request.COOKIES:
try:
location = request.COOKIES['ldmw_location_latlong']
[user_lat, user_long] = location.split(",")
context['is_near'] = any(
filter(
lambda e: haversine_distance(float(
user_lat), float(user_long), float(
e.latitude), float(e.longitude)) / 1.6 < 1000,
self.latlong.all()))
# less than 1 mile
except:
print("Failed to get location")
context['is_near'] = False
else:
context['is_near'] = False
Home = apps.get_model('resources', 'home')
combine_tags = create_tag_combiner(None)
landing_pages = Home.objects.filter(~Q(slug="home")).live()
context['landing_pages'] = landing_pages
context['tags'] = combine_tags(self).specific.tags
context['number_of_likes'] = Likes.objects\
.filter(resource_id=self.id, like_value=1)\
.count()
context['number_of_dislikes'] = Likes.objects\
.filter(resource_id=self.id, like_value=-1)\
.count()
context['badges'] = ResourcePageBadges.objects\
.filter(page_id=self.page_ptr_id)
context['buttons'] = ResourcePageButtons.objects\
.filter(page_id=self.page_ptr_id)
return base_context(context, self)
def get_distance(a, b):
a_lat = float(Terminals.loc[a, 'Latitude'])
a_long = float(Terminals.loc[a, 'Longtitude'])
b_lat = float(Terminals.loc[b, 'Latitude'])
b_long = float(Terminals.loc[b, 'Longtitude'])
# get distance in meters between two points
dist = geo.haversine_distance(a_lat, a_long, b_lat, b_long)
# convert to miles and return
return (dist * 0.000621371 * 1.26)
def get_grove_to_storage_distance(grove, storage):
grove_lat = float(Terminals.loc[grove, 'Latitude'])
grove_long = float(Terminals.loc[grove, 'Longtitude'])
storage_lat = float(Terminals.loc[storage, 'Latitude'])
storage_long = float(Terminals.loc[storage, 'Longtitude'])
# get distance in meters between two points
dist = geo.haversine_distance(grove_lat, grove_long, storage_lat, storage_long)
# convert to miles and return
return (dist*0.000621371*1.26)
def convert(file):
path = file
gpx_file = open(path, 'r')
print(gpx_file)
gpx = gpxpy.parse(gpx_file)
points = []
for track in gpx.tracks:
for segment in track.segments:
for point in segment.points:
points.append((point.latitude, point.longitude))
ret = []
for it in range(0, len(points) - 1):
v = (points[it][0], points[it][1], points[it + 1][0],
points[it + 1][1])
distance = geo.haversine_distance(v[0], v[1], v[2], v[3])
div = distance / 2
count = int(div)
if count == 0:
ret.append((v[0], v[1]))
else:
a = (v[2] - v[0]) / count
b = (v[3] - v[1]) / count
for i in range(0, count):
new = (v[0] + i * a, v[1] + i * b)
ret.append(new)
ret.append((v[2], v[3]))
gpx = """<?xml version="1.0"?>
<gpx version="1.1" creator="Xcode">
"""
for it in range(0, len(ret)):
gpx += '<wpt lat="' + str(ret[it][0]) + '" lon="' + str(
ret[it][1]) + '"></wpt>\n'
gpx += """
</gpx>"""
f = open(path + ".converted.gpx", "w")
f.write(gpx)
f.close()
def set_haversine_distance(data_frame):
data_frame['haversine_dist'] = [
gpx.haversine_distance(data_frame.latitude[i], data_frame.longitude[i],
data_frame.latitude[i + 1],
data_frame.longitude[i + 1]) if i !=
(len(data_frame.t_user_id) - 1) else 0
for i in range(len(data_frame.t_user_id))
]
data_frame['haversine_dist'] = [
(data_frame.haversine_dist[i] * data_frame.user_separator[i] *
data_frame.day_separator[i]) for i in range(len(data_frame.t_user_id))
]
def send_notification(request, format=None):
#lat1 = 22.5848556
#lon1 = 88.3580799
if request.method == 'POST':
try:
jsondata = json.loads(request.body)
lat = jsondata['lat']
lon = jsondata['lon']
post_id = jsondata['post_id']
email = jsondata['email']
except Exception as e:
raise ValidationError('json error')
send_users = []
users = NotificationArea.objects.exclude(email=email)
for user in users:
dist = geo.haversine_distance(lat, lon, user.cen_lat, user.cen_lon)
dist = dist / 1000
if (dist <= user.radius):
send_users.append(user.email)
fcm_device = GCMDevice.objects.filter(name__in=send_users)
fcm_device.send_message(
'New issue posted in your area',
extra={
"priority": 2,
"post": post_id,
"visibility": 1,
'icon': 'notif',
'sound': 'default',
'notId': post_id
},
use_fcm_notifications=False)
#notification code for ios devices
#apns_token = "22cfcc654ee2998fe911b71c2908a64295397875fa4308ce8ef616736a2616e0"
#apns_device = APNSDevice.objects.get(registration_id=apns_token)
apns_device = APNSDevice.objects.filter(name__in=send_users)
apns_device.send_message(
'New issue posted in your area',
extra={
"priority": 2,
"post": post_id,
"visibility": 1,
'icon': 'notif',
'sound': 'default'
})
res = {'response': 'ok'}
return JsonResponse(res)
def test_haversine_distance(self):
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(2, 3)
self.assertEqual(loc1.distance_2d(loc2),
mod_geo.distance(loc1.latitude, loc1.longitude, None, loc2.latitude, loc2.longitude, None))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(3, 4)
self.assertEqual(loc1.distance_2d(loc2),
mod_geo.distance(loc1.latitude, loc1.longitude, None, loc2.latitude, loc2.longitude, None))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(3.1, 4)
self.assertEqual(loc1.distance_2d(loc2),
mod_geo.haversine_distance(loc1.latitude, loc1.longitude, loc2.latitude, loc2.longitude))
loc1 = mod_geo.Location(1, 2)
loc2 = mod_geo.Location(2, 4.1)
self.assertEqual(loc1.distance_2d(loc2),
mod_geo.haversine_distance(loc1.latitude, loc1.longitude, loc2.latitude, loc2.longitude))
def get_distances_per_degree(gpx) -> Dict[float, float]:
distance_per_degree: Dict[float, float] = {}
for track in gpx.tracks:
for segment in track.segments:
for prev, cur in zip(segment.points, segment.points[1:]):
distance = geo.haversine_distance(
prev.latitude, prev.longitude, cur.latitude, cur.longitude
)
bearing_degree = geo.get_course(
prev.longitude, prev.latitude, cur.longitude, cur.latitude
)
distance_per_degree[bearing_degree] = (
distance_per_degree.get(bearing_degree, 0) + distance / 1000
)
return distance_per_degree
def grove_to_storage_distance(grove, storage):
locations = terminals['Location']
grove_row = terminals[locations==grove]
storage_row = terminals[locations==storage]
grove_lat = float(grove_row['Latitude'])
grove_long = float(grove_row['Longtitude'])
storage_lat = float(storage_row['Latitude'])
storage_long = float(storage_row['Longtitude'])
# get distance in meters between two points
dist = geo.haversine_distance(grove_lat, grove_long, storage_lat, storage_long)
# convert to miles and return
return (dist*0.000621371*1.26)
def validate_transaction(self, loc_elements, txn_details):
user = loc_elements[0]
loc_time = loc_elements[1]
latitude = loc_elements[2]
longitude = loc_elements[3]
distance = geo.haversine_distance(float(latitude), float(longitude),
float(txn_details['lat']),
float(txn_details['long']))
txn_time = txn_details['time']
threashold = distancer.distance_threshold(txn_time, loc_time)
if distance > threashold:
fraud_msg = user \
+ ',' + txn_details['vendor'] \
+ ',' + txn_details['lat'] + ';' + txn_details['long'] \
+ ',' + txn_details['time'] \
+ ',' + txn_details['amount'] \
+ ',' + str(distance)
self.fproducer.produce(fraud_msg)
def train_predict(X,
y,
kf,
accuracy_acceptance_range=0.1,
use_surface_distance=False):
accuracies = []
counter = 0
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
regression_model = LinearRegression()
regression_model.fit(X_train, y_train)
correct = 0
total = 0
for X_row, y_true_row in zip(X_test, y_test):
y_pred_row = regression_model.predict(X_row.reshape(1, -1))[0]
# IF we are using longitude and latitude together then we can predict using haversine distance
if use_surface_distance == True:
distance = haversine_distance(
y_pred_row[0], y_pred_row[1], y_true_row[0],
y_true_row[1]) / 1000 #gives of km
if distance < accuracy_acceptance_range:
correct += 1
# IF we are predicting a single value we can use this
elif abs(y_pred_row - y_true_row) < accuracy_acceptance_range:
correct += 1
total += 1
print("Fold " + str(counter) +
" had {0:.3f}% accuracy".format(correct / total * 100))
accuracies.append(correct / total)
counter += 1
return ("Average accuracy across all folds was {0:.3f}%".format(
sum(accuracies) / len(accuracies) * 100))
def compute_distance(df):
df['h_dt'] = [gp.haversine_distance(df.latitude[i], df.longitude[i], df.latitude[i+1], df.longitude[i +1]) if i != (len(df.t_user_id) - 1) else 0 for i in range(len(df.t_user_id))]
df['h_dt'] = [df.h_dt[i] * df.msk[i] * df.dymask[i] for i in range(len(df.t_user_id))]
#df['h_dt'] = [df.h_dt[i] * df.dymask[i] for i in range(len(df.t_user_id))]
#df['Haversine_distance'] = distance
return df
def get_gameobject_distance(obj1, obj2):
return geo.haversine_distance(obj1.latitude, obj1.longitude, obj2.latitude,
obj2.longitude)
def haversine_distance_meters(lat1: float, lon1: float, lat2: float,
lon2: float) -> Meters:
return geo.haversine_distance(lat1, lon1, lat2, lon2)
def within_mile(resource, user_lat, user_long):
dist = haversine_distance(float(user_lat), float(user_long),
float(resource.latitude),
float(resource.longitude))
return dist / 1.6 < 1000
def send_area_notification(request, format=None):
if request.method == 'POST':
jsondata = json.loads(request.body)
post_id = jsondata['post_id']
lat = jsondata['lat']
lon = jsondata['lon']
email = jsondata['email']
title = jsondata['title']
message = jsondata['message']
not_id = jsondata['not_id']
post = Post.objects.get(id=post_id)
images = Image.objects.filter(post_id_id=post_id)[:1]
image_row = None
for image in images.iterator():
image_row = getattr(image, 'image')
if (image_row != None):
image_file = 'https://citysavior.pythonanywhere.com' + image_row.url
html_message = '<html><body><h1 style="text-align:center;background-color:lightGrey;font-size:300%;"><i>City Savior</i></h1><h3 style="text-align:center">' + message + '</h3><br><div style="text-align:center"><h2><i>' + post.title + '</i></h2><img src="' + image_file + '" alt="" height="500" width="500" style="border:5px solid red"/></div><div style="text-align:center"><br><a href="https://play.google.com/store/apps/details?id=com.citySavior&hl=en"><img src="https://citysavior.pythonanywhere.com/static/android-button.png" alt=""></a> <a href="https://itunes.apple.com/us/app/city-savior/id1249164397"><img src="https://citysavior.pythonanywhere.com/static/apple-button.png" alt=""></a></div></body></html>'
else:
html_message = '<html><body><h1 style="text-align:center;background-color:lightGrey;font-size:300%;"><i>City Savior</i></h1><h3 style="text-align:center">' + message + '</h3><br><div style="text-align:center"><br><a href="https://play.google.com/store/apps/details?id=com.citySavior&hl=en"><img src="https://citysavior.pythonanywhere.com/static/android-button.png" alt=""></a> <a href="https://itunes.apple.com/us/app/city-savior/id1249164397"><img src="https://citysavior.pythonanywhere.com/static/apple-button.png" alt=""></a></div></body></html>'
send_users = []
users = NotificationArea.objects.exclude(email=email)
for user in users:
dist = geo.haversine_distance(lat, lon, user.cen_lat, user.cen_lon)
dist = dist / 1000
if (dist <= user.radius):
send_users.append(user.email)
send_mail(
title,
message,
'City Savior', [user.email],
fail_silently=True,
html_message=html_message)
fcm_device = GCMDevice.objects.filter(name__in=send_users)
response = fcm_device.send_message(
title,
extra={
"priority": 2,
"post": post_id,
"visibility": 1,
'icon': 'notif',
'sound': 'default',
'notId': not_id
},
use_fcm_notifications=False)
#notification code for ios devices
#apns_token = "22cfcc654ee2998fe911b71c2908a64295397875fa4308ce8ef616736a2616e0"
#apns_device = APNSDevice.objects.get(registration_id=apns_token)
apns_device = APNSDevice.objects.filter(name__in=send_users)
response = apns_device.send_message(
title,
extra={
"priority": 2,
"post": post_id,
"visibility": 1,
'icon': 'notif',
'sound': 'default'
})
res = {'response': response}
return JsonResponse(res)
from util import Vec2d
# https://www.movable-type.co.uk/scripts/latlong.html
def initial_bearing((lat1, lon1), (lat2, lon2)):
y = math.sin(lon2 - lon1) * math.cos(lat2)
x = math.cos(lat1) * math.sin(lat2) - \
math.sin(lat1) * math.cos(lat2) * math.cos(lon2 - lon1)
bearing = math.degrees(math.atan2(y, x))
return (bearing + 360) % 360
def dist_to_waypoint(loc, (wlat, wlon)):
"""returns the distance to a GPS waypoint (in meters)"""
return haversine_distance(loc['lat'], loc['lon'], wlat, wlon)
def calculate_gps_heading(loc, waypoint):
"""returns a vector, where the angle is the initial bearing and the magnitude
is the distance between two GPS coordinates"""
dist = dist_to_waypoint(loc, waypoint)
angle = initial_bearing(
(loc['lat'], loc['lon']), waypoint) - loc['gps_heading']
return Vec2d(angle, dist)
def current_angle(loc):
"""just returns the current angle from pixhawk"""
def get_gameobject_distance(obj1, obj2):
return geo.haversine_distance(obj1.latitude, obj1.longitude,
obj2.latitude, obj2.longitude)
