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"""