def test_raise_over_query_limit(self): valid_query = ENDPOINT_DICT['directions'] responses.add(responses.POST, 'https://api.openrouteservice.org/v2/directions/{}/geojson'.format(valid_query['profile']), json=valid_query, status=429, content_type='application/json') with self.assertRaises(openrouteservice.exceptions._OverQueryLimit): client = openrouteservice.Client(key=self.key, retry_over_query_limit=False) client.directions(**valid_query) with self.assertRaises(openrouteservice.exceptions.Timeout): client = openrouteservice.Client(key=self.key, retry_over_query_limit=True, retry_timeout=3) client.directions(**valid_query)
def setUp(self): self.key = 'sample_key' self.client = openrouteservice.Client(self.key) self.search = {'text': 'Heidelberg', 'focus_point': (8.675786, 49.418431), 'rect_min_x': 8.573179, 'rect_min_y': 49.351764, 'rect_max_x': 8.79405, 'rect_max_y': 49.459693, 'circle_point': (8.675786, 49.418431), 'circle_radius': 50, 'sources': ['osm', 'wof', 'gn'], 'layers': ['locality', 'county', 'region'], 'country': 'de', 'size': 5, } self.structured = {'address': 'Berliner Straße 45', 'neighbourhood': 'Neuenheimer Feld', 'borough': 'Heidelberg', 'locality': 'Heidelberg', 'county': 'Rhein-Neckar-Kreis', 'region': 'Baden-Württemberg', 'postalcode': '69120', 'country': 'de', } self.reverse = {'point': (8.675786, 49.418431), 'circle_radius': 50, 'sources': ['osm', 'wof', 'gn'], 'layers': ['locality', 'county', 'region'], 'country': 'de', 'size': 5, }
def __init__(self, transportation_type, **kwargs): """This class filters objects from the ors service. It gives nice methods for calling ors functions. """ self.client = openrouteservice.Client(base_url=None) self.transportation_type = transportation_type super().__init__(**kwargs)
def start(): api_key = '' with open('route_visualization/api_key.txt', "r") as api_key_file: api_key = api_key_file.read() clnt = openrouteservice.Client(key=api_key) coords = read_coords_from_3_group_json() mapCenter = (38.945830, -92.328912) m = folium.Map(location=(mapCenter[0], mapCenter[1]), zoom_start=14) m = load_markers(m) global garage_matrix_g1 garage_matrix_g1 = get_matrices(0, clnt, coords) global garage_matrix_g2 garage_matrix_g2 = get_matrices(1, clnt, coords) global garage_matrix_g3 garage_matrix_g3 = get_matrices(2, clnt, coords) optCoordsG1 = get_path(garage_matrix_g1, coords[0], 1) optCoordsG2 = get_path(garage_matrix_g2, coords[1], 2) optCoordsG3 = get_path(garage_matrix_g3, coords[2], 3) get_path_mapped(optCoordsG1, m, clnt, 1) get_path_mapped(optCoordsG2, m, clnt, 2) get_path_mapped(optCoordsG3, m, clnt, 3) save_routes(1, optCoordsG1) save_routes(2, optCoordsG2) save_routes(3, optCoordsG3) m.save('route_visualization/three_route_enforcement.html')
def create_route(self, coordinates): ors_client = ors.Client( key='5b3ce3597851110001cf6248f3b059537e424e639a05afc159c35d77') route = ors_client.directions(coordinates=coordinates, profile='driving-car', format='geojson') print("[create_route] " + str(coordinates)) route_points = route['features'][0]['geometry']['coordinates'] plt.plot(route_points[0][0], route_points[0][1], 'ro', markersize=16) # Marca en punto de origen plt.plot(route_points[-1][0], route_points[-1][1], 'go', markersize=16) # Marca en punto de destino route_points.append( route_points[-1] ) # Para que no haya problemas al final del siguiente for for p in range( len(route_points) - 1): # Linea de union entre cada par de puntos consecutivos col = (1, 0, 0) # TODO cambiar el color para cada usuario trayectoria = mlines.Line2D( [route_points[p + 1][0], route_points[p][0]], [route_points[p + 1][1], route_points[p][1]], color=col, linewidth=4) plt.gca().add_line(trayectoria)
def map(request, fName, kOsa): mapUrl = 'https://nominatim.openstreetmap.org/?addressdetails=1&q=' + fName + '+' + kOsa + '&format=json&limit=1' response = requests.get(mapUrl) data = response.json() lat = [] lon = [] if data == []: print("Kenttaa ei loytynyt kartalta") return redirect('api') else: for field in data: lat = field['lat'] lon = field['lon'] # https://openrouteservice-py.readthedocs.io/en/latest/ myLocation = geocoder.ip('me').latlng coords = ((myLocation[1], myLocation[0]), (lon, lat)) client = openrouteservice.Client(key='') # Specify your personal API key routes = client.directions(coords) geometry = routes['routes'][0]['geometry'] #Geometriatiedot decoded = convert.decode_polyline( geometry) #Hakee 'coordinates': [[lon, lan][lon,lan] yms...] route = decoded['coordinates'] #Lista koordinaateista for point in route: point.reverse() # [lon, lat] -> [lat, lon] return render( request, 'sportFields/map.html', { 'lat': lat, 'lon': lon, 'fName': fName, 'route': route, 'myLocation': myLocation })
def start_ORS_client(): import openrouteservice api = get_api_keys() ORS_api_key = api['ORS_api_key'] ORS_client = openrouteservice.Client( key=ORS_api_key) # Specify your personal API key return ORS_client
def locate(destination): import openrouteservice #find user's current location startGeocoder = geocoder.ip('me') s_lat = startGeocoder.lat s_lng = startGeocoder.lng start_pos = (s_lng, s_lat) #find the coordinates of the desired location eg = geocoder.mapquest(destination, key=geo_key) e_lat = eg[0].lat e_lng = eg[0].lng end_pos = (e_lng, e_lat) coords = (start_pos, end_pos) print(coords) client = openrouteservice.Client(route_key) routes = client.directions(coords, units="mi", profile="driving-car") #format direction output output = "" for route in routes["routes"][0]["segments"][0]["steps"]: output += "In " + str( route["distance"]) + " miles, " + route["instruction"] + ".\n" return output
def __init__( self, origin: None, destination: None, api_key: str, travel_mode: str, route_mode: str, units: str, origin_reverse_geocode_enabled: bool, destination_reverse_geocode_enabled: bool, ) -> None: """Initialize openrouteservice.""" self.origin = origin self.destination = destination self.travel_mode = travel_mode self.route_mode = route_mode self.attribution = None self.duration = None self.distance = None self.route = None self.base_time = None self.origin_name = None self.destination_name = None self.units = units self.origin_reverse_geocode_enabled = origin_reverse_geocode_enabled self.destination_reverse_geocode_enabled = destination_reverse_geocode_enabled self._client = openrouteservice.Client(key=api_key)
def setUp(self): self.key = 'sample_key' self.client = openrouteservice.Client(self.key) self.coords_valid = [[9.970093,48.477473], [9.207916,49.153868], [37.573242,55.801281], [115.663757,38.106467]]
def get_distance_and_duration(destination_address): doc = frappe.get_doc('OpenRouteService_robins_erpnext_extensions') client = ors.Client(key=doc.api_openrouteservice) home_address = doc.address_line1 + ", " + doc.pincode + " " + doc.city + ", " + doc.country home_address_location = client.pelias_search(text=home_address) home_address_coordinates = home_address_location["features"][0][ "geometry"]["coordinates"] destination_address_location = client.pelias_search( text=destination_address) destination_address_coordinates = destination_address_location["features"][ 0]["geometry"]["coordinates"] coordinates = [home_address_coordinates, destination_address_coordinates] route = client.directions(coordinates=coordinates, profile='driving-car', geometry_simplify=True, instructions=False, geometry=False) distance_and_duration = route.get("routes")[0].get("summary") distance = distance_and_duration["distance"] duration = distance_and_duration["duration"] distance = distance / 1000 duration = duration / 60 return distance, duration
def route(self, arg1): self.log('I got a query:', arg1, pretty=True, lvl=debug) profile = 'driving-car' instructions = False simplify = True query = json.loads(unquote(arg1)) self.log(query, pretty=True) coords = query client = openrouteservice.Client(key=self.key) routes = openrouteservice.client.directions(client, coordinates=coords, profile=profile, format='geojson', instructions=instructions, geometry_simplify=simplify) self.response.headers['Content-Type'] = 'application/json' # self.response.headers['X-Content-Type-Options'] = 'nosniff' self.response.headers['Access-Control-Allow-Headers'] = '*' self.response.headers['Access-Control-Allow-Origin'] = '*' self.log(self.response.headers, pretty=True, lvl=critical) return json.dumps(routes)
def giveDistMatrix( coords, demands, key='5b3ce3597851110001cf62480bea960faed84e018b953afbd3510ae7', dry_run=False, verbose=True): client = nav.Client(key=key) distanceMatrix = nav.distance_matrix.distance_matrix( client, locations=coords, profile='driving-car', sources=None, destinations=None, metrics=['distance', 'duration'], resolve_locations=True, units='m', optimized=True, validate=True, dry_run=dry_run) if (verbose): print(distanceMatrix) temp = { 'distances': distanceMatrix['distances'], 'durations': distanceMatrix['durations'], 'coords': coords, 'demands': demands } return temp
def confirmSim(): print("Inside Confirm!") req = eval(request.data) coords = ((req["source_long"], req["source_lat"]), (req["dest_long"], req["dest_lat"])) client = openrouteservice.Client( key=api_key) # Specify your personal API key # decode_polyline needs the geometry only while (True): try: geometry = client.directions(coords)['routes'][0]['geometry'] break except Exception as e: print(e) pass global decoded decoded = convert.decode_polyline(geometry) decoded = decoded['coordinates'] for i in decoded: i[0], i[1] = i[1], i[0] closest_car = get_closest_distance(req['source_lat'], req['source_long'], 5) for i in closest_car[0]: i[0], i[1] = i[1], i[0] print(closest_car) global obj obj = car_state(closest_car[2], closest_car[0]) return "", 200
def main(file_path): df = FileLoader.load(file_path) FileLoader.display(df, 10) network = create_netwok(df) network.summary_in_file(f"{file_path}_net_summary") client = openrouteservice.Client(key=APIKEY) output = network.calc_network(client) network.tours[0].create_map() # #todo : faire un df qui fait un calcul sur le df et mettre en 2eme sheet output.to_excel("output.xlsx")
def setUp(self): self.key = 'sample_key' self.client = openrouteservice.Client(self.key) self.query = 'Heidelberg' self.location = (8.68353, 49.412623) self.structured = { "postalcode": "69120", "country": "Germany", "locality": "Heidelberg", }
def ors_client() -> ors.Client: """Implement an open route service client. Needs to have a valid path to an API token text file. Yields: An open route service client. """ key_path = "./ors.key" ors_api_key = "" with open(path.abspath(key_path)) as key_file: ors_api_key = key_file.readline().strip() yield ors.Client(ors_api_key)
def test_server_running(self): coords = ((34.482724, 31.492354), (34.492724, 31.452354)) print("") feat = DistanceTimeFeature(ROAD, OSM_LINE_TABLE) feat.extract_coordinates(coords) # key can be omitted for local host client = openrouteservice.Client( base_url='http://52.236.160.138:8080/ors') # Only works if you didn't change the ORS endpoints manually routes = client.directions(coords, instructions=False, geometry=False) self.assertIsNotNone(routes)
def test_overquerylimit_error(self): # Assume more queries_per_minute than allowed by API policy and # don't allow retries if API throws 'rate exceeded' error, which # should be caught. queries_per_minute = 110 query_range = range(queries_per_minute * 2) client = openrouteservice.Client(key='5b3ce3597851110001cf624870cf2f2a58d44c718542b3088221b684', queries_per_minute=queries_per_minute, retry_over_query_limit=False) with self.assertRaises(openrouteservice.exceptions._OverQueryLimit): for _ in query_range: client.directions(self.coords_valid)
def test_host_override_with_parameters(self): # Test if it's possible to override host for individual hosting. responses.add(responses.GET, "https://foo.com/bar", body='{"status":"OK","results":[]}', status=200, content_type="application/json") client = openrouteservice.Client(base_url="https://foo.com") client.request("/bar", {'bunny': 'pretty', 'fox': 'prettier'}) self.assertURLEqual("https://foo.com/bar?bunny=pretty&fox=prettier", responses.calls[0].request.url) self.assertEqual(1, len(responses.calls))
def reparse_walking_distances(): client = openrouteservice.Client(key=openrouteservice_api_key) stops_df: pd.DataFrame = pd.read_pickle(FloydDataPaths.stops_df.value) stops_df = stops_df[['stop_name', 'stop_lon', 'stop_lat']] walking_distances_pickle = load_pickle( FloydDataPaths.api_walking_distances.value) api_walking_distances = walking_distances_pickle['distances'] api_stop_list = stops_df['stop_name'].to_list() print(api_stop_list) def adjacent_stops_generator(): for id_1, name_1, lon_1, lat_1 in stops_df.itertuples(): for id_2, name_2, lon_2, lat_2 in stops_df.itertuples(): if id_1 < id_2 and get_walking_distance( lon_1, lat_1, lon_2, lat_2) < MAX_WALKING_DISTANCE: yield name_1, lon_1, lat_1, name_2, lon_2, lat_2 adjacent_stops = list(adjacent_stops_generator()) all_stops = len(adjacent_stops) current_stop_percent = 0 loop_counter = 0 for name_1, lon_1, lat_1, name_2, lon_2, lat_2 in adjacent_stops: loop_counter += 1 if 100 * loop_counter / all_stops >= current_stop_percent: print(f"{current_stop_percent}% done ") current_stop_percent += 1 if (name_1, name_2) in api_walking_distances.keys(): continue time.sleep(2) coords = ((lon_1, lat_1), (lon_2, lat_2)) if (lon_1, lat_1) == (lon_2, lat_2): api_walking_distances[(name_1, name_2)] = 0 api_walking_distances[(name_2, name_1)] = 0 else: try: routes = directions(client, coords, profile='foot-walking') api_walking_distances[( name_1, name_2)] = routes['routes'][0]['summary']['duration'] api_walking_distances[( name_2, name_1)] = routes['routes'][0]['summary']['duration'] except openrouteservice.exceptions.ApiError: break save_pickle( { 'distances': api_walking_distances, 'stop_list': list(api_stop_list) }, FloydDataPaths.api_walking_distances.value)
def test_dry_run(self): # Test that nothing is requested when dry_run is 'true' responses.add(responses.GET, 'https://api.openrouteservice.org/directions', body='{"status":"OK","results":[]}', status=200, content_type='application/json') client = openrouteservice.Client(key=self.key) req = client.request(params={'format_out': 'geojson'}, url='directions/', dry_run='true') self.assertEqual(0, len(responses.calls))
def test_format_out_deprecation(self): bad_query = copy(self.valid_query) bad_query['format_out'] = "json" bad_query['dry_run'] = True self.client = openrouteservice.Client(self.key) with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # Trigger a warning. _ = self.client.directions(**bad_query) assert len(w) == 1 assert issubclass(w[-1].category, DeprecationWarning) assert "deprecated" in str(w[-1].message)
def __init__(self, start: Point, start_bear: float, destination: Point, announcer_manager: AnnouncerManager): # logging self.__logger = logging.getLogger(__name__) self.__logger.info("OrsRouter.__init__() called with start=" + str(start) + " start_bear=" + str(start_bear) + " destination=" + str(destination)) # value initialization self.__start = start self.__start_bear = start_bear self.__destination = destination self.__announcer_manager = announcer_manager self.__client = openrouteservice.Client(key='key here', retry_timeout=3600) self.__calculate_routing_information()
def __init__(self, origin, destination, mode): # 設定起點終點進行路線規劃 print("open route service directions api") f = open("./APIKEY", "r") self.key = f.read() self.origin = origin self.destination = destination self.mode = mode self.client = openrouteservice.Client( key=self.key) # Specify your personal API key self.avoided_point_list = [] self.idw_grid = gpd.read_file( './data/taipei_grid_500m_20190610052502.geojson') # self.barriers_level_1 = self.__selectBarriers(1) # self.barriers_level_2 = self.__selectBarriers(2) # self.barriers_level_3 = self.__selectBarriers(3) self.barriers = []
def search(): req = eval(request.data) geolocator = Nominatim() while (True): try: source = geolocator.geocode(req['source']) dest = geolocator.geocode(req['destination']) break except: pass print(source.latitude, source.longitude) print(dest.latitude, dest.longitude) i = 0 num_cars = 0 print("HELLO") while (num_cars <= 5): i += 0.5 num_cars, cars = get_num_cars(source.latitude, source.longitude, i) print("The Number of cars is: ", num_cars) coords = ((source.longitude, source.latitude), (dest.longitude, dest.latitude)) client = openrouteservice.Client( key=api_key) # Specify your personal API key # decode_polyline needs the geometry only while (True): try: geometry = client.directions(coords)['routes'][0]['geometry'] break except: pass decoded = convert.decode_polyline(geometry) decoded = decoded['coordinates'] for i in decoded: i[0], i[1] = i[1], i[0] return { "source_lat": source.latitude, "source_long": source.longitude, "dest_lat": dest.latitude, "dest_long": dest.longitude, "graph": plot_cars(source, cars, decoded) }
def get_paths(df): path_list = [] for index, row in df.iterrows(): coords = [(row['plo'], row['pla']), (row['maplong'], row['maplat'])] print(coords) client = openrouteservice.Client( key='5b3ce3597851110001cf6248c196e442e9f148a9a1863fa5c168e7bc') geometry = client.directions(coords)['routes'][0]['geometry'] decoded = convert.decode_polyline(geometry) reverse = [(y, x) for x, y in decoded['coordinates']] path_list.append(reverse) print(index) return path_list
def test_raise_timeout_retriable_requests(self): # Mock query gives 503 as HTTP status, code should try a few times to # request the same and then fail on Timout() error. retry_timeout = 3 responses.add(responses.GET, 'https://api.openrouteservice.org/directions', body='{"status":"OK","results":[]}', status=503, content_type='application/json') client = openrouteservice.Client(key=self.key, retry_timeout=retry_timeout) start = time.time() with self.assertRaises(openrouteservice.exceptions.Timeout): client.directions(self.coords_valid) end = time.time() self.assertTrue(retry_timeout < end - start < 2 * retry_timeout)
def main(coordinates): API_KEY = "5b3ce3597851110001cf62486d267b042a754245aeb826068a8ea035" client = openrouteservice.Client(key=API_KEY) coords = (coordinates[0], coordinates[1]) df = pd.read_csv("points.csv") radiuses, points_list = extract_coordinates_radius(dataframe=df, rad_col="radio(m)", lng_col="Longitude", lat_col="Latitude") normal_route = get_normal_route(client, coords) buffer_route = get_buffer_route(normal_route) sites_polygon = obtain_polygons(buffer_route, points_list, radiuses) route_detour = get_detour_route(client, coords, buffer_route, sites_polygon) route_coordinates = get_detour_route_coordinates(route_detour) route_coordinates.insert(0, list(coords[0])) route_coordinates.append(list(coords[1])) return create_route_json(route_coordinates, dtype="list")
def geocode(self, place): place = unquote(place) self.log('I got a geocode query:', place, pretty=True, lvl=debug) client = openrouteservice.Client(key=self.key) address = openrouteservice.client.pelias_autocomplete(client, text=place) self.log(self.request.headers, pretty=True, lvl=verbose) self.response.headers['Content-Type'] = 'application/json' # self.response.headers['X-Content-Type-Options'] = 'nosniff' self.response.headers['Access-Control-Allow-Headers'] = '*' self.response.headers['Access-Control-Allow-Origin'] = '*' self.log(self.response, pretty=True, lvl=verbose) self.log(address, pretty=True, lvl=debug) return json.dumps(address)