def locate_on_quad(G, num_cols, num_rows, max_lat, min_lon, dist): bcn_matrix = [[[] for i in range(num_cols)] for i in range(num_rows)] for station in G.nodes: i = int(haversine((max_lat, min_lon), (station.lat, min_lon)) // dist) j = int(haversine((max_lat, min_lon), (max_lat, station.lon)) // dist) bcn_matrix[i][j].append(station) return bcn_matrix
def create_graph(dist): #First, we import all the bicing stations info, in panda format. url = 'https://api.bsmsa.eu/ext/api/bsm/gbfs/v2/en/station_information' bicing = pd.DataFrame.from_records(pd.read_json(url)['data']['stations'], index='station_id') dist /= 1000 #Convert distance (given in m) to km. G = nx.Graph() for station in bicing.itertuples(): G.add_node(station) max_lat, min_lat, max_lon, min_lon = bbox(G) #We determine the number of rows and columns, num_rows = int(haversine((max_lat, min_lon), (min_lat, min_lon)) // dist) + 1 num_cols = int(haversine((max_lat, min_lon), (max_lat, max_lon)) // dist) + 1 #Function that locates every station in its respective quadrant. bcn_matrix = locate_on_quad(G, num_cols, num_rows, max_lat, min_lon, dist) #In this loop, we check all the possible connections between stations. for i in range(num_rows): for j in range(num_cols): G = adjacent(G, bcn_matrix, i, j, i, j, dist) if i > 0: G = adjacent(G, bcn_matrix, i, j, i - 1, j, dist) if i > 0 and j + 1 < num_cols: G = adjacent(G, bcn_matrix, i, j, i - 1, j + 1, dist) if j + 1 < num_cols: G = adjacent(G, bcn_matrix, i, j, i, j + 1, dist) if i + 1 < num_rows and j + 1 < num_cols: G = adjacent(G, bcn_matrix, i, j, i + 1, j + 1, dist) return G
def route(G, name_file, addresses): coord_origin, coord_destination = addressesTOcoordinates(addresses) coord_origin = Pandas(lat=coord_origin[0], lon=coord_origin[1]) coord_destination = Pandas(lat=coord_destination[0], lon=coord_destination[1]) radius = haversine(coord_origin, coord_destination) G.add_nodes_from([coord_origin, coord_destination]) for node in G.nodes: dist_O = haversine(coord_origin, (node.lat, node.lon)) dist_D = haversine(coord_destination, (node.lat, node.lon)) if dist_O <= radius: G.add_edge(coord_origin, node, weight=dist_O/4) if dist_D <= radius: G.add_edge(coord_destination, node, weight=dist_D/4) fastest_path = nx.dijkstra_path(G, coord_origin, coord_destination) G.remove_nodes_from([coord_origin, coord_destination]) Route = nx.Graph() # When we modify the graph in order to be plotted, we also compute # the average time of the route. time = 0 for i in range(len(fastest_path)-1): a, b = ((fastest_path[i].lat, fastest_path[i].lon), (fastest_path[i+1].lat, fastest_path[i+1].lon)) if i == 0 or i == len(fastest_path)-1: time += haversine(a, b)/4 else: time += haversine(a, b)/10 Route.add_edge(fastest_path[i], fastest_path[i+1]) plotgraph(Route, name_file) return int(time*60)
def latlong(event): data = json.loads(event['body']) if event.get('body', 0) else event conn = get_db() curr = conn.cursor() curr.execute( "SELECT latitude,longitude, status from restaurant_restaurants ") row = curr.fetchall() if len(row) >= 2: restaurantsDataList = row customer = { 'latitude': data['latitude'], 'longitude': data['longitude'] } result = closest(restaurantsDataList, customer) response = result[:10] rs = [] for items in response: restaurants_lat_long = (items['latitude'], items['longitude'] ) # (lat, lon) customers_lat_logn = (data['latitude'], data['longitude']) distance_li = haversine(restaurants_lat_long, customers_lat_logn) if distance_li <= 5: # if items.get('status') == "Open": rs.append(items['latitude']) find_lat = tuple(rs) return find_lat else: return []
def distance(position1, position2): change = haversine((position1[0], position1[1]), (position2[0], position2[1]), miles=False) #change = great_circle((position1[0], position1[1]),(position2[0],position2[1])).miles change = change * 1000 return change
def findClosest(inLat, inLon, numTrucks, cache): #Get food truck data from cache if exists, else read the food truck data and set the cache json_data = cache.get("data") if (json_data == None): json_data = read_data(cache) #Iterate through food truck json file and calculate the distance from the input latitude and longitude. #Store the distance and the food trucks in an array. #For production, look into using array and numpy array for handling arrays, since they are quicker due to preallocation of memory. distList = [] for i in json_data['data']: #Use the haversine formula to compute the distance dist = haversine(inLat, inLon, i["Latitude"], i["Longitude"]) distList.append([ dist, i["Applicant"], i["LocationDescription"], i["Latitude"], i["Longitude"], i["locationid"] ]) #Set the distance as the key to sort on def sortDist(val): return val[0] #Store the distance in the array, so the closest is at the top distList.sort(key=sortDist) #Add the numTrucks closest food trucks to an array x = 0 closest = [] while (x < numTrucks): closest.append(distList[x]) x += 1 #Return the numTrucks closest food trucks in the json array return json.dumps(closest)
def adjacent(G, bcn_matrix, i, j, k, l, dist): for st_A in bcn_matrix[i][j]: for st_B in bcn_matrix[k][l]: d_AB = haversine([st_A.lat, st_A.lon], [st_B.lat, st_B.lon]) if d_AB <= dist and st_A != st_B: G.add_edge(st_A, st_B, weight=d_AB / 10) return G
def htmlemail(lat, lon, radius): recipients = user.objects.filter(last_lat__lt=lat + 5, last_lat__gt=lat - 5, last_lon__lt=lon + 5, last_lon__gt=lon - 5) recips = {} for recipient in recipients: recips[ recipient. fsq_id] = recipient.first_name, recipient.last_name, recipient.email the_records = record.objects.filter(time__lt=time(), time__gt=time() - 86400) the_set = {} for item in the_records: v = authenticator.userless_query("/venues/" + item.venue_id) vlat = v['venue']['location']['lat'] vlon = v['venue']['location']['lng'] venue_name = v['venue']['name'] try: venue_address = v['venue']['location']['address'] + ' ' + v[ 'venue']['location']['city'] + ', ' + v['venue']['location'][ 'state'] + ' ' + v['venue']['location']['postalCode'] except: pass if item.venue_id in the_set.keys(): the_set[item.venue_id][2] += item.target.quotient() the_set[item.venue_id][3] += 1 elif haversine(float(vlon), float(vlat), float(lon), float(lat)) <= int(radius): the_set[item.venue_id] = [ venue_name, venue_address, item.target.quotient(), 1 ] else: pass averages = {} for item in the_set.iteritems(): averages[item[0]] = [ item[1][2] / item[1][3], { 'female': [], 'male': [] } ] for item in the_records: try: u = user_lookup.objects.get(pic_id=item.target.pic_id) g = authenticator.query( "users/" + u.fsq_id, token="1A0ESOQC4W2RIGY442CJTKKFJEM04BYCEHSG0SNCVIWMKPII") averages[item.venue_id][1][g['user']['gender']].append( item.target.pic_id) except: pass for item in the_set: the_set[item].append(averages[item]) return the_set
def suggested_venues(fsq_id='', lat='', lon='', radius=''): newdict = {} if fsq_id: query = record.objects.filter(time__lt=time(), time__gt=time()-3600, user=user.objects.get(fsq_id=fsq_id)).order_by('venue_id') for venue in query: if venue.venue_id not in newdict: newdict[venue.venue_id]=[1,[venue.target.pic_id]] elif venue.target.pic_id not in newdict[venue.venue_id][1]: newdict[venue.venue_id][0]+=1 newdict[venue.venue_id][1].append(venue.target.pic_id) else: pass else: query = record.objects.filter(time__lt=time(), time__gt=time()-3600).order_by('venue_id') for venue in query: v=venue_ll.objects.get(venue_id=venue.venue_id) vlat=v.lat vlon=v.lon if venue.venue_id not in newdict and haversine(float(lat),float(lon),float(vlat),float(vlon)) <= int(radius)/1000: newdict[venue.venue_id]=[1,[venue.target.pic_id]] elif venue.venue_id in newdict: newdict[venue.venue_id][0]+=1 newdict[venue.venue_id][1].append(venue.target.pic_id) else: pass sorted_vals=sorted(newdict.iteritems(), key=operator.itemgetter(1)) sorted_vals.reverse() return sorted_vals[:5]
def suggested_venues(fsq_id='', lat='', lon='', radius=''): newdict = {} if fsq_id: query = record.objects.filter( time__lt=time(), time__gt=time() - 3600, user=user.objects.get(fsq_id=fsq_id)).order_by('venue_id') for venue in query: if venue.venue_id not in newdict: newdict[venue.venue_id] = [1, [venue.target.pic_id]] elif venue.target.pic_id not in newdict[venue.venue_id][1]: newdict[venue.venue_id][0] += 1 newdict[venue.venue_id][1].append(venue.target.pic_id) else: pass else: query = record.objects.filter(time__lt=time(), time__gt=time() - 3600).order_by('venue_id') for venue in query: v = venue_ll.objects.get(venue_id=venue.venue_id) vlat = v.lat vlon = v.lon if venue.venue_id not in newdict and haversine( float(lat), float(lon), float(vlat), float(vlon)) <= int(radius) / 1000: newdict[venue.venue_id] = [1, [venue.target.pic_id]] elif venue.venue_id in newdict: newdict[venue.venue_id][0] += 1 newdict[venue.venue_id][1].append(venue.target.pic_id) else: pass sorted_vals = sorted(newdict.iteritems(), key=operator.itemgetter(1)) sorted_vals.reverse() return sorted_vals[:5]
def getBairroFromLatLong(rddB, Lat, Long, sc): dLat = Decimal(Lat) dLong = Decimal(Long) tempRdd = rddB.map(lambda l: (l["Bairro"], haversine(dLong, dLat, Decimal(l["Longitude"]), Decimal(l["Latitude"])))) return tempRdd.min()[0]
def findRadius(gps, placelist): distance = 0 if len(placelist) == 0: return 50000.0 for place in placelist: km = haversine(gps, (place.getLng(), place.getLng())) if km > distance: distance = km return distance
def distance(self, other, type): from utils import euclidean import haversine if type == 'euclidean': return euclidean(self.center[0], self.center[1], other.center[0], other.center[1]) if type == 'haversine': pa = (self.center[0], self.center[1]) pb = (other.center[0], other.center[1]) return haversine(pa, pb)
def create_G_Coord(G, coord_origin, coord_destination): G_coord = nx.Graph() #In this new graph, the weight of the edges is the time needed to go from one node to another. for e in G.edges(): coord1, coord2, dist = (e[0].lat, e[0].lon), (e[1].lat, e[1].lon), G.edges[e[0], e[1]]['weight'] G_coord.add_edge(coord1, coord2, weight=dist / 10) #In this loop, all the added edges are done by foot. for node in G.nodes( ): #adds edges between origin, destination and the stations n_coord = (node.lat, node.lon) dist_to_og, dist_to_dest = haversine(coord_origin, n_coord), haversine( coord_destination, n_coord) G_coord.add_weighted_edges_from([ (coord_origin, n_coord, dist_to_og / 4), (coord_destination, n_coord, dist_to_dest / 4) ]) G_coord.add_edge(coord_origin, coord_destination, weight=(haversine(coord_origin, coord_destination) / 4)) return G_coord
def find_nearest_drone(drone_list, anomaly): """Find the drone closest to the anomaly.""" min_dist = 10000000000000 closest_drone = None for drone in drone_list: if drone["DroneState"]["Status"] != "Confirming": if drone["DroneState"]["DroneID"] != anomaly["DroneID"]: drone_location = tuple([float(x) for x in drone["DroneState"]["Position"].spit(',')]) anomaly_location = tuple([float(x) for x in anomaly["Position"].spit(',')]) dist = haversine(drone_location, anomaly_location) if dist < min_dist: min_dist = dist closest_drone = drone return closest_drone
def getBairroFromLatLongDict(dictB, Lat, Long): dLat = Decimal(Lat) dLong = Decimal(Long) minValue = Decimal('inf') minBairro = "None" for key, value in dictB.iteritems(): dist = haversine(dLong, dLat, Decimal(key[1]), Decimal(key[0])) if dist < minValue: minValue = dist minBairro = value return minBairro
def port_visit(row): lat = row['lat'] lon = row['lon'] port_list = br_ports.value visitors_list = [] for i in port_list: distance = haversine((lat,lon), (i[1], i[0]), miles=False) if (distance < 0.5): visitors_list.append(row['sourcemmsi']) break return visitors_list
def get_new_state(anomaly, drone): """Create the new drone state based on the anomaly.""" drone_position = tuple( [float(x) for x in drone["DroneState"]["Position"].split(',')]) anomaly_position = tuple( [float(x) for x in anomaly["Location"].split(',')]) if haversine(drone_position, anomaly_position) < 10: drone["DroneState"]["State"] = "Active" return drone, "ReadData" direction = get_direction(source=drone_position, destination=anomaly_position) drone["DroneState"]["Direction"] = direction return drone, None
def parse_location(Location): coordinates_list_km = [] location = [Location['lat'], Location['lng']] coordinates_list = Coordinates.objects.values_list('adress_id_id', 'lat', 'lng') for item in coordinates_list: if item[1] is not None and item[2] is not None: item_data = [item[1], item[2]] distances = haversine(tuple(location), tuple(item_data)) tuple_data = [item[0], distances] coordinates_list_km.append(tuple(tuple_data)) bubbleSort(coordinates_list_km) nearest_coordinates = coordinates_list_km[:NEAREST_LOCATION] return nearest_coordinates
def get_haversine_dist(start_point, end_point): """get haversine distance betweent 2 points Keyword arguments: start_point -- start point end_point -- end point """ dist = haversine(start_point, end_point, unit='mi') if math.isnan(dist): rv_value = 100000000 else: rv_value = dist return rv_value
def check_stores_by_geo(filter_brands, myLatLong, all_locs, within_km): stores_to_check = [] stores_to_check_filtered_by_brand = [] for loc in all_locs["locations"]: locLatLong = (loc["geoPoint"]["latitude"], loc["geoPoint"]["longitude"]) distance = haversine(myLatLong, locLatLong) if distance <= within_km: # Add a distance key:value pair to the location object so that # locations can be sorted by distance after the list is created loc_distance = {"distance": distance} loc.update(loc_distance) stores_to_check.append(loc) if filter_brands: if stores_to_check: for store in stores_to_check: storeBannerId = store["storeBannerId"] if storeBannerId in filter_brands: stores_to_check_filtered_by_brand.append(store) return stores_to_check_filtered_by_brand else: return stores_to_check
def whichTypesToRequestGoogle(dynamodb, lat, lng, types): requests = dynamodb.Table('requests') geohashes = adjacentHashes(geoHash(lat, lng, length=17)) result = [] for hash in geohashes: response = requests.query( KeyConditionExpression=Key('geohash').eq(hash.to01())) items = response['Items'] result += items resultTypes = types.copy() if len(result) != 0: for request in result: requestlat = request['lat'] requestlng = request['lng'] type = request['type'] radius = request['radius'] if type in resultTypes: distance = haversine((lat, lng), (requestlat, requestlng)) if (distance / float(radius)) <= .8: resultTypes.remove(type) return resultTypes
def htmlemail(lat,lon, radius): recipients=user.objects.filter(last_lat__lt=lat+5, last_lat__gt=lat-5, last_lon__lt=lon+5, last_lon__gt=lon-5) recips={} for recipient in recipients: recips[recipient.fsq_id]=recipient.first_name, recipient.last_name, recipient.email the_records = record.objects.filter(time__lt=time(),time__gt=time()-86400) the_set={} for item in the_records: v=authenticator.userless_query("/venues/"+item.venue_id) vlat=v['venue']['location']['lat'] vlon=v['venue']['location']['lng'] venue_name=v['venue']['name'] try: venue_address=v['venue']['location']['address']+' '+v['venue']['location']['city']+', '+v['venue']['location']['state']+' '+v['venue']['location']['postalCode'] except: pass if item.venue_id in the_set.keys(): the_set[item.venue_id][2]+=item.target.quotient() the_set[item.venue_id][3]+=1 elif haversine(float(vlon),float(vlat),float(lon),float(lat))<=int(radius): the_set[item.venue_id]=[venue_name,venue_address,item.target.quotient(),1] else: pass averages={} for item in the_set.iteritems(): averages[item[0]]=[item[1][2]/item[1][3],{'female':[],'male':[]}] for item in the_records: try: u=user_lookup.objects.get(pic_id=item.target.pic_id) g=authenticator.query("users/"+u.fsq_id, token="1A0ESOQC4W2RIGY442CJTKKFJEM04BYCEHSG0SNCVIWMKPII") averages[item.venue_id][1][g['user']['gender']].append(item.target.pic_id) except: pass for item in the_set: the_set[item].append(averages[item]) return the_set
import requests import json send_url = 'http://freegeoip.net/json' r = requests.get(send_url) j = json.loads(r.text) lat = j['latitude'] lon = j['longitude'] from haversine import * current = (lat, lon) disaster_brian_head = (-115, 38) dist_brian_head = haversine(current, disaster_brian_head) dist_brian_head = str(round(dist_brian_head)) print("You are " + dist_brian_head + " miles from the Brian Head, UT wildfire.") disaster_esmeralda = (-80, 0) dist_esmeralda = haversine(current, disaster_esmeralda) dist_esmeralda = str(round(dist_esmeralda)) print("You are " + dist_esmeralda + " miles from the Esmeralda, Ecuador earthquake.") disaster_teramo = (14, 43) dist_teramo = haversine(current, disaster_teramo) dist_teramo = str(round(dist_teramo)) print("You are " + dist_teramo + " miles from the Teramo, Italy earthquake.") disaster_bodrum = (27, 39) dist_bodrum = haversine(current, disaster_bodrum)
def gethaversine(src,dest): return haversine(src,dest,miles=True)
# Storing usable filtered coordinates lat_ff.append(lat_f) lon_ff.append(lon_f) alt_ff.append(alt_f) distances_pp = [] distances_pp_f = [] for j in range(len(lon_rz) - 1): # Defining cordinates of two points to messure distance coordinates0 = (lat_rz[j], lon_rz[j]) coordinates1 = (lat_rz[j + 1], lon_rz[j + 1]) # Calculating haversine distance between two points in nautical miles distance_pp = float(haversine(coordinates0, coordinates1, unit='nmi')) # Storing calculated point to point distances into a vector distances_pp.append(distance_pp) # Sum of point to point distances to obtain total distance of a flight distances = sum(distances_pp) # Next step perform a filter taking out first 6 nm of the flight distances2 = np.asarray(distances) GCD_CDGLHR = great_circle(coor_CDG, coor_LHR).nm altitude = alt_rz[j] Heff = ((distances - GCD_CDGLHR) / distances) * 100 print(distances)
from vision import cono from socket import * from bbbgps import * from navegacion import * from haversine import * import thread import time import sys #arriba = [11.020289, -74.848016] #abajo = [11.020035, -74.848057] #izquierda=[11.020194, -74.848468] #derecha = [11.020127, -74.847667] dest = [11.01796,-74.85141] inicio= [11.01807,-74.85141] punto2= [11.01826,-74.85138] #triang(dest,newpos,pos) a= int(triang(dest,inicio,[11.01807,-74.85142])) a= a*1600/360 print a print haversine(inicio,[11.01807,-74.85142])*1000
class mgo: def __init__(self): self.Users = {} self.table = {} self.token = "21234589jkjidjfoai" self.messages = {} self.msgid = 0 def user_exists(self,user,password): """Change logic to get info from db or firebase""" if user in self.Users: return True ## Raise Exception else: return False def update_user(self,username,password): """Update username and password to db<Update this to communicate with firebase>""" self.Users[username] = password return token def add_user(self,username,password): """Add new usser to db""" if user_exists(username) pass # later pass message user exists else: token = update_user(username,password) return token def login(self,username,password): """Logs user in the system <Needs to get data from firebase>""" if username in self.Users[username]: ##Update logic if password == self.Users[username]: return self.token if res is None: return None # login failed def add_message(self,username,message,location): """Add a new message to the messages dictionary""" #### USE pandas or sql lite db to or get from firebase id = self.msgid + 1 self.messages[id] = {"username":username,"message" : message ,"loc":location} self.push_to_users(id,location) def get_messages(location): """Returns all messages in given latitude and longitude range""" get_valid_msg_ids = get_msg_ids(location) res = [self.messages[id] for id in get_valid_msg_ids] return res def get_msg_ids(location): """Get all messges in the location range""" ###### Not needed ids = [] for id in self.messages: if is_range(location,self.messages[id][location],radius): ids.append(ids) return ids def is_range(location1,location2),radius): """Checks if corodinates are in is_range Formula for Haversine Distance Algorithm between two places R = earth’s radius (mean radius = 6,371km) Δlat = lat2− lat1 Δlong = long2− long1 a = sin²(Δlat/2) + cos(lat1).cos(lat2).sin²(Δlong/2) c = 2.atan2(√a, √(1−a)) d = R.c """ distance = haversine(coord1, coord2) * 1000 if distance <= radius: return True else: return False
def solve(grid, start, goal, solver=0, ntype=4, trace=False, currentsGrid_u=None, currentsGrid_v=None, geotransform=None, targetSpeed_mps=1, timeOffset=0, pixelsize_m=1, distMeas="haversine"): solvers = ["dijkstra", "astar"] if solver >= len(solvers): print("Invalid solver ID {}".format(solver_id)) exit(-1) rows, cols = grid.shape frontier = PriorityQueue() frontier.put(start, 0) came_from = {} cost_so_far = {} time_so_far = {} came_from[start] = None cost_so_far[start] = 0 time_so_far[start] = timeOffset tgrid = None if trace: tgrid = grid.copy() if distMeas == "haversine": # Lat, lon of goal g_latlon = grid2world(goal[0], goal[1], geotransform, rows) # Explore while not frontier.empty(): current = frontier.get() if distMeas == "haversine": c_latlon = grid2world(current[0], current[1], geotransform, rows) if trace: tgrid[current] = 0.25 # Check if goal if current == goal: break # Add suitable neighbors neighbors = getNeighbors(current, rows, cols, grid, ntype) for next in neighbors: if next[0] < 0 or next[1] < 0 or next[0] >= rows or next[1] >= cols: continue if grid[next] != 0: continue if distMeas == "haversine": n_latlon = grid2world(next[0], next[1], geotransform, rows) dist = haversine.haversine(c_latlon, n_latlon) * 1000 elif distMeas == "euclidean-scaled": dist = pow((pow(current[0] - next[0], 2) + pow(current[1] - next[1], 2)), 0.5) * pixelsize_m elif distMeas == "euclidean": dist = pow((pow(current[0] - next[0], 2) + pow(current[1] - next[1], 2)), 0.5) # Cost if currentsGrid_u is None: et = time_so_far[current] + (dist / targetSpeed_mps) # Distance cost new_cost = cost_so_far[current] + dist else: # Energy cost work, et = calcWork(current, next, currentsGrid_u, currentsGrid_v, targetSpeed_mps, geotransform=geotransform, timeIn=time_so_far[current], pixelsize_m=pixelsize_m, distMeas=distMeas) new_cost = cost_so_far[current] + work update = False if next not in cost_so_far: update = True else: if new_cost < cost_so_far[next]: update = True if update: cost_so_far[next] = new_cost if solver == 1: # A* if distMeas == "haversine": priority = new_cost + (haversine(n_latlon, g_latlon) * 1000) elif distMeas == "euclidean-scaled": priority = new_cost + pow( (pow(next[0] - goal[0], 2) + pow(next[1] - goal[1], 2)), 0.5) * pixelsize_m elif distMeas == "euclidean": priority = new_cost + pow( (pow(next[0] - goal[0], 2) + pow(next[1] - goal[1], 2)), 0.5) else: # Default: dijkstra priority = new_cost frontier.put(next, priority) came_from[next] = current time_so_far[next] = et # Reconstruct path current = goal path = [] while current != start: if trace: tgrid[current] = 1.5 path.append(current) current = came_from[current] if trace: tgrid[start] = 0.5 path.append(start) path.reverse() return path, tgrid, cost_so_far[goal], time_so_far[goal]
def geojson_haversine(geojson_tuple_a, geojson_tuple_b, haversine, **kwargs): flipped_a = geojson_tuple_a[1], geojson_tuple_a[0] flipped_b = geojson_tuple_b[1], geojson_tuple_b[0] return haversine(flipped_a, flipped_b, **kwargs)
alt = flights['alt'] xalt = np.arange(alt.size) new_xalt = np.linspace(xalt.min(), xalt.max(), CHUNK_SIZE) alt_rz = sp.interpolate.interp1d(xalt, alt, kind='slinear')(new_xalt) x,y = m(lon_rz,lat_rz) m.plot(*(x, y), color = 'b', linewidth=0.1) for j in range(len(lon_rz)-1): # Defining cordinates of two points to messure distance coordinates0 = (lat_rz[j],lon_rz[j]) # Calculating haversine distance between two points in nautical miles distance_to_AIRP1 = float(haversine(coor_AIRP1,coordinates0,unit='nmi')) distance_to_AIRP2 = float(haversine(coor_AIRP2,coordinates0,unit='nmi')) if distance_to_AIRP1 > 60 and distance_to_AIRP2 > 60: lon_f = [lon_rz[j]] lat_f = [lat_rz[j]] alt_f = [alt_rz[j]] # lat_teste_f = [lat_teste[j]] # lon_teste_f = [lon_teste[j]] lat_ff.append(lat_f) lon_ff.append(lon_f) alt_ff.append(alt_f)
coords = geo_json[0]["geometry"]["coordinates"] myLat = coords[1] myLong = coords[0] myLatLong = (myLat, myLong) if mode == "report": print(f'export MYLAT="{myLat}" ; export MYLONG="{myLong}"') stores_to_check = [] with open("locations.json") as inf: all_locs = json.load(inf) for loc in all_locs["locations"]: locLatLong = (loc["geoPoint"]["latitude"], loc["geoPoint"]["longitude"]) distance = haversine(myLatLong, locLatLong) if distance <= within_km: # Add a distance key:value pair to the location object so that # locations can be sorted by distance after the list is created loc_distance = {"distance": distance} loc.update(loc_distance) stores_to_check.append(loc) if stores_to_check: # Sort the list of locations by distance stores_to_check = sorted(stores_to_check, key=lambda s: s["distance"]) store_urls = { "bloor": "https://www.bloorstreetmarket.ca", "box": "https://www.boxfoodstores.ca", "independent": "https://www.yourindependentgrocer.ca",
lon = flights['lon'] xlon = np.arange(lon.size) new_xlon = np.linspace(xlon.min(), xlon.max(), CHUNK_SIZE) lon_rz = sp.interpolate.interp1d(xlon, lon, kind='slinear')(new_xlon) alt = flights['alt'] xalt = np.arange(alt.size) new_xalt = np.linspace(xalt.min(), xalt.max(), CHUNK_SIZE) alt_rz = sp.interpolate.interp1d(xalt, alt, kind='slinear')(new_xalt) for j in range(len(lon_rz) - 1): # Defining cordinates of two points to messure distance coordinates0 = (lat_rz[j], lon_rz[j]) # Calculating haversine distance between two points in nautical miles distance_to_FRA = float(haversine(coor_FRA, coordinates0, unit='nmi')) distance_to_ITA = float(haversine(coor_ITA, coordinates0, unit='nmi')) if distance_to_FRA > 60 and distance_to_ITA > 60: lon_f = [lon_rz[j]] lat_f = [lat_rz[j]] alt_f = [alt_rz[j]] lat_ff.append(lat_f) lon_ff.append(lon_f) alt_ff.append(alt_f) print(len(lat_ff)) mms = preprocessing.MinMaxScaler(feature_range=(0, 1))
alt = flights['alt'] xalt = np.arange(alt.size) new_xalt = np.linspace(xalt.min(), xalt.max(), CHUNK_SIZE) alt_rz = sp.interpolate.interp1d(xalt, alt, kind='slinear')(new_xalt) x, y = m(lon_rz, lat_rz) m.plot(*(x, y), color='b', linewidth=0.1) for j in range(len(lon_rz) - 1): # Defining cordinates of two points to messure distance coordinates0 = (lat_rz[j], lon_rz[j]) # Calculating haversine distance between two points in nautical miles distance_to_AIRP1 = float( haversine(coor_AIRP1, coordinates0, unit='nmi')) distance_to_AIRP2 = float( haversine(coor_AIRP2, coordinates0, unit='nmi')) if distance_to_AIRP1 > 60 and distance_to_AIRP2 > 60: lon_f = [lon_rz[j]] lat_f = [lat_rz[j]] alt_f = [alt_rz[j]] # lat_teste_f = [lat_teste[j]] # lon_teste_f = [lon_teste[j]] lat_ff.append(lat_f) lon_ff.append(lon_f) alt_ff.append(alt_f)