def distance(source, destination, distance_in=None): """ This function use to get distance between two address. Args: source (string/list): Source address string/ lat, lng as list. destination (string/list): Destination address string/ lat, lng as list. distance_in(string): Type of distance. Example: meter, kelometer, miles. Returns: Float: Distance The return value. """ # Initialize return value. return_value = 0 try: origin = (source['longitude'], source['latitude']) destination = (destination['longitude'], destination['latitude']) # Call mapbox client to get direction services. response = Directions(MAPBOX_TOKEN["mapbox_token"]).directions( [origin, destination]) driving_routes = response.geojson() distances = driving_routes['features'][0]['properties']["distance"] if not distance_in: return_value = distances * 0.00062137 elif distance_in == "kelometer": return_value = round(distances / 1000, 2) except BaseException: return_value = 0 return return_value
def mapbox_route(origin, destination, profile): """ origin (float, float): coordinates longitude, latitude, eg: (-122.7282, 45.5801) destination (float, float): coordinates profile (str): "car", "bike", or "foot" return RouteSummary """ mbprofile = { "car": "mapbox/driving-traffic", "bike": "mapbox/cycling", "foot": "mapbox/walking" }[profile] service = Directions() response = service.directions([origin, destination], mbprofile) # TODO: check it went fine r = response.json() logging.debug(response.json()) # TODO: r = response.json() # Get the most recommended route route = r["routes"][0] # To get the whole geometry: # driving_routes = response.geojson() if profile == "car": dist_km = route["distance"] / 1000 price = PRICE_PER_KM_CAR * dist_km co2 = CO2_PER_KM_CAR * dist_km else: price = 0 co2 = 0 return RouteSummary(profile, route["distance"], route["duration"], price, co2)
def directionRoute(): if request.method == 'POST' or request.method == 'GET': data = request.get_json() src = data['start'] dest = data['end'] pro = data['profile'] '''src=request.form['src'] dest=request.form['dest'] pro=request.form['pro']''' Profile = 'mapbox/' + pro PRofile = 'mapbox.' + pro MAPBOX_ACCESS_TOKEN = 'pk.eyJ1IjoidmluaXRoYS1zaHJlZSIsImEiOiJjamJ0ZW1yc24xMzB2Mnp1ZnVhazB6MnVzIn0.ynemM-bZ9mc4C9PuasnVow' geocoder = Geocoder(access_token=MAPBOX_ACCESS_TOKEN) #geocoder.session.params['access_token'] == 'sk.eyJ1IjoidmluaXRoYS1zaHJlZSIsImEiOiJjamNjMjkzZ3MwbTc0MndvMndtM2Ewb3lxIn0.cm3yhsou3E8UD0pm1GPKlA' geocode1 = geocoder.forward(src) src_geocode = geocode1.json() src1_geocode = json.dumps(src_geocode) geocode2 = geocoder.forward(dest) dest_geocode = geocode2.json() src_latlng = src_geocode["features"][0]['geometry']['coordinates'] dest_latlng = dest_geocode['features'][0]['geometry']['coordinates'] print(src_latlng) print(dest_latlng) origin = { 'type': 'Feature', 'properties': { 'name': 'dummy' }, 'geometry': { 'type': 'Point', 'coordinates': [0, 0] } } origin['properties']['name'] = src origin['geometry']['coordinates'] = src_latlng destination = { 'type': 'Feature', 'properties': { 'name': 'dummy' }, 'geometry': { 'type': 'Point', 'coordinates': [0, 0] } } destination['properties']['name'] = dest destination['geometry']['coordinates'] = dest_latlng print(origin) print(destination) services = Directions(access_token=MAPBOX_ACCESS_TOKEN) responses = services.directions([origin, destination], PRofile) directions_status = responses.status_code print(directions_status) directions_type = responses.headers['Content-Type'] print(directions_type) directionResponse_json = responses.json() #print(directionResponse_json) return json.dumps(directionResponse_json) return "works bad"
def output(): #get the lat/long of origin and destination geocoder = Geocoder() geocoder.session.params['access_token'] = 'pk.eyJ1IjoiYWNiYXR0bGVzIiwiYSI6ImNrNXptdWtnajA4ZGYzamxscmR5ZmV4ZGEifQ.e99budVtY2MsprEhvTNEtQ' directions = Directions() directions.session.params['access_token'] = 'pk.eyJ1IjoiYWNiYXR0bGVzIiwiYSI6ImNrNXptdWtnajA4ZGYzamxscmR5ZmV4ZGEifQ.e99budVtY2MsprEhvTNEtQ' starting_location = request.args.get('starting_location') ending_location = request.args.get('ending_location') #Auto input, if fields left blank if starting_location == '': start_geo = geocoder.forward('200 E Colfax Ave, Denver, CO 80203') else: start_geo = geocoder.forward(starting_location) if ending_location == '': end_geo = geocoder.forward('7711 E Academy Blvd, 80230') else: end_geo = geocoder.forward(ending_location) origin = start_geo.geojson()['features'][0] destination = end_geo.geojson()['features'][0] route = directions.directions([origin,destination], 'mapbox/driving', alternatives=True, exclude = 'motorway') route1 = route.geojson()['features'][0] route2 = route.geojson()['features'][1] #makes a list of the start/end coordinates on each line segment of the route coord_points_alt1 = route1['geometry']['coordinates'] coord_points_alt2 = route2['geometry']['coordinates'] #get the coordinates for TURNS (at this point) intersections_df1 = geodb_query(coord_points_alt1) intersections_df2 = geodb_query(coord_points_alt2) #get the relative risk at each turn. total_risk1 = intersections_df1['Pred_Prob'].sum() total_risk2 = intersections_df2['Pred_Prob'].sum() if total_risk1 < total_risk2: best_route = route1 next_route = route2 risk_out_low = round(total_risk1,1) risk_out_high = round(total_risk2,1) else: best_route = route2 next_route = route1 risk_out_low = round(total_risk2,1) risk_out_high = round(total_risk1,1) risk_proportion = round(((1-(risk_out_low/risk_out_high))*100),1) return render_template("output.html", routeA = best_route, routeB = next_route, origin = origin, destination = destination, risk1 = risk_out_low, risk2 = risk_out_high, risk_proportion = risk_proportion)
def snap_to_road(received_point): service = Directions() coords = [received_point.lng, received_point.lat] origin = destination = { "type": "Feature", "geometry": { "type": "LineString", "coordinates": [coords, coords] } } response = service.directions([origin, destination], profile='mapbox.driving') try: coordinates = response.geojson()['features'][0]['geometry']['coordinates'][0] except IndexError: return received_point received_point.lat = coordinates[1] received_point.lng = coordinates[0] received_point.save() return received_point
def get_Directions_Mapbox(from_location, to_location, api_key): service = Directions(access_token=api_key) origin = Feature(geometry=Point((from_location.longitude, from_location.latitude))) destination = Feature(geometry=Point((to_location.longitude, to_location.latitude))) #my_profile = 'mapbox/driving' my_profile = 'mapbox/driving-traffic' response = service.directions([origin, destination], profile=my_profile, geometries=None, annotations=['duration', 'distance']) driving_routes = response.geojson() #print("JSON Object: ", driving_routes, file=sys.stderr) #new_json = driving_routes['features'][0]['properties'] #pprint.pprint(new_json) if response.status_code == 200: return driving_routes['features'][0]['properties'] else: return response.status_code
def geoMessage(self, bot, update): bot.send_message(chat_id=update.message.chat_id, text="What is your origin?") origin = update.message.text # time = time.time(20) bot.send_message(chat_id=update.message.chat_id, text="What is your destination?") destination = update.message.text geocoder = mapbox.Geocoder( access_token= 'sk.eyJ1IjoiZGlhbmthbG9sNCIsImEiOiJjazhzdjE4c3QwMnlwM2Rud2EwZzg1b29iIn0.OqtyNqmiJI5q6UbWQC6oCQ' ) response = geocoder.forward('Paris, France') with open('text.json', 'w', encoding='UTF-8') as f: json.dump(response.json(), f) from mapbox import Directions resp = Directions('mapbox.driving').directions([origin, destination]) driving_routes = resp.geojson() first_route = driving_routes['features'][0] bot.send_message(chat_id=update.message.chat_id, pic=resp)
def computeDistance(stationN1, stationN2): def getDirectionObjects(stationN1, stationN2): data = getStationsData() dest = {"type": "Feature", "geometry": {"type": "Point", "coordinates": [None, None]}} orig = {"type": "Feature", "geometry": {"type": "Point", "coordinates": [None, None]}} for station in data: if station["number"] == stationN1: orig["geometry"]["coordinates"][1] = station["position"]["lng"] orig["geometry"]["coordinates"][0] = station["position"]["lat"] elif station["number"] == stationN2: dest["geometry"]["coordinates"][1] = station["position"]["lng"] dest["geometry"]["coordinates"][0] = station["position"]["lat"] if orig["geometry"]["coordinates"][0] != None and \ dest["geometry"]["coordinates"][0] != None: break return [orig, dest] service = Directions(MAPBOX_TOKEN) response = service.directions(getDirectionObjects(stationN1, stationN2), PROFILE) try: response.raise_for_status() except: print("Error %d occured while retreiving answer from server" %response.status_code, file=stderr) exit(EXIT_FAILURE) try: response = loads(response.text) except TypeError or ValueError: print("Incorrect data formating collected from:\n %s" %URL_DATA, file=stderr) exit(EXIT_FAILURE) return response["routes"][0]["distance"]
def gps_point_to_routes(points_from_file: str, dump_to='routes.geojson'): get_direct = Directions(access_token=TOKEN) with open(points_from_file, 'r') as cat: data = geojson.load(cat).copy() end_points = data['features'] if len(end_points) <= 25: resp = get_direct.directions(walkway_bias=1, profile='mapbox/walking', features=end_points, geometries='geojson') print(resp.status_code) print(resp.url) new_data = resp.json() geom = new_data['routes'][-1]['geometry'] line = LineString(geom['coordinates']) route_df = gpd.GeoDataFrame(geometry=[line]) route_df.to_file(dump_to, driver='GeoJSON', encoding="utf-8") else: print('many points in data')
import json from flask import request, jsonify from clean_fit.models import Users, Route, PlaceInfo, CleanCityIndex, History from clean_fit import app, db from flask_cors import CORS, cross_origin from mapbox import Directions import os import math import random import datetime from copy import deepcopy import datetime # from clean_fit.data_parser import parse_geo_info, parse_measures service = Directions( access_token= 'pk.eyJ1IjoicHJhbmF5a290aGFyaSIsImEiOiJja21kdTllMGoyY2VjMnBzOXA2eXBqZjJoIn0.v69swMJIzyBvXgbMHvOgGQ' ) # frontend routes @app.route('/', methods=["GET", "POST"]) def catch(): return app.send_static_file('index.html') @app.route('/go', methods=["GET", "POST"]) def catch_go(): return app.send_static_file('index.html')
from typing import List from mapbox import Directions from api.routes.models import RouteSegment service = Directions(access_token="pk.eyJ1IjoidG5hYmVyIiwiYSI6ImNqbmN5Zm" "V0ODBsdXAzcW1yanVkY2xoazMifQ.r9yIImJoKcOSVhhew00aBg") def get_polylines_from_array(arrays: List[List[float]]): return list(dict.fromkeys(get_lines_array(arrays))) def get_polylines(route_points): return list(dict.fromkeys(get_lines(route_points))) def get_lines_array(floats: List[List[float]]): coordinates = [] coords = [] if len(floats) >= 2: for i in floats: origin = { 'type': 'Feature', 'geometry': { 'type': 'Point', 'coordinates': i } } coords.append(origin)
response = service.directions([origin, destination],'mapbox/driving') print(response.status_code) driving_routes = response.geojson() #print(driving_routes['features'][0]['geometry']['type']) print(driving_routes['features'][0]['geometry']['coodinates']) routes = driving_routes['features'][0]['geometry']['coodinates']; print(routes.type)''' from mapbox import Directions import pandas as pd import plotly.express as px import plotly.io as pio import plotly.offline as pyo import plotly.graph_objects as go service = Directions(access_token="") origin = { 'type': 'Feature', 'properties': { 'name': 'Portland, OR' }, 'geometry': { 'type': 'Point', 'coordinates': [-122.7282, 45.5801] } } destination = { 'type': 'Feature', 'properties': { 'name': 'Bend, OR'
from mapbox import Geocoder, Directions import json from socketio import AsyncNamespace import requests from config import MAPBOX_ACCESS_TOKEN import asyncio geocoder = Geocoder(access_token=MAPBOX_ACCESS_TOKEN) service = Directions() async def full_route(params): response = service.directions([origin, destination], profile='mapbox/walking', geometries='geojson', overview=False, language=params['language'], steps=True) return response.json() async def check_courier_position(profile, current_loc_coordinates, token): base_url = "https://api.mapbox.com" req = "{}/isochrone/v1/{}/{},{}?contours_minutes=1&access_token={}".format( base_url, profile, current_loc_coordinates[0], current_loc_coordinates[1], token) responce = requests.get(req) return responce.json()['features'][0] loop = asyncio.get_event_loop()
import json import time from dbm import DBManager import sqlite3 as db from mapbox import Directions import mapbox_token DBM = DBManager('demo.db') service = Directions( access_token=mapbox_token.MAPBOX_ACCESS_TOKEN) #Mapbox API result = DBM.read_locs() #Get Location List to generate routes b/w them #Builds list of possible destinations and origins in memory. pairs = [] for loc_one in result: for loc_two in result: if (loc_one != loc_two): #Reformat raw db data into Mapbox Points point_one = { 'type': 'Feature', 'properties': { 'name': loc_one[0] }, 'geometry': { 'type': 'Point', 'coordinates': [loc_one[1], loc_one[2]] } } point_two = {
import mapbox import json geocoder = mapbox.Geocoder( access_token= 'sk.eyJ1IjoiZGlhbmthbG9sNCIsImEiOiJjazhzdjE4c3QwMnlwM2Rud2EwZzg1b29iIn0.OqtyNqmiJI5q6UbWQC6oCQ' ) response = geocoder.forward('Paris, France') with open('text.json', 'w', encoding='UTF-8') as f: json.dump(response.json(), f) from mapbox import Directions resp = Directions('mapbox.driving').directions([origin, destination]) driving_routes = resp.geojson() first_route = driving_routes['features'][0]
import os from collections import namedtuple from pprint import pprint from mapbox import Geocoder, Distance, Directions from model import db, connect_to_db, Popos, Posm MB_ACCESS_TOKEN = os.environ['MAPBOX_ACCESS_TOKEN'] geocoder = Geocoder(access_token=MB_ACCESS_TOKEN) service = Distance(access_token=MB_ACCESS_TOKEN) service1 = Directions(access_token=MB_ACCESS_TOKEN) def geocode_location(location): """Geocodes origin and returns lng/lat in named tuple.""" # Forward geocoding with proximity so results are biased toward given lng/lat response = geocoder.forward(location, lon=-122.431, lat=37.773) if response.status_code == 200: first = response.geojson()['features'][0] origin_lng = first['geometry']['coordinates'][0] origin_lat = first['geometry']['coordinates'][1] Latlng = namedtuple('Latlng', 'latitude longitude') origin = Latlng(origin_lat, origin_lng) return origin # Latlng(latitude=37.792458, longitude=-122.395709)
# - [email protected] # - http://www.ucs.louisiana.edu/~jev9637 # # Modified: # * # # TODO: # * ############################################################################### import numpy as np from mapbox import Directions, Static import folium direction_service = Directions(access_token='pk.eyJ1IjoiZG9jdmF1Z2hhbiIsImEiOiI1NXdlS184In0.xkx1iJIxebVhEXFS8cadrg') static_service = Static(access_token='pk.eyJ1IjoiZG9jdmF1Z2hhbiIsImEiOiI1NXdlS184In0.xkx1iJIxebVhEXFS8cadrg') origin = {'type': 'Feature', 'properties': {'name': 'Rougeou Hall'}, 'geometry': { 'type': 'Point', 'coordinates': [-92.0224611, 30.2096914]}} destination = {'type': 'Feature', 'properties': {'name': 'Martin Hall'}, 'geometry': { 'type': 'Point', 'coordinates': [-92.0189939, 30.215553]}} response = direction_service.directions([origin, destination], 'mapbox.walking')
from mapbox import Directions service = Directions(access_token='pk.eyJ1IjoibXRjb2x2YXJkIiwiYSI6ImNrMDgzYndkZjBoanUzb21jaTkzajZjNWEifQ.ocEzAm8Y7a6im_FVc92HjQ') class DirectionsCalculations: def returnRouteGeometry(self, waypoints_list): response = service.directions(waypoints_list, profile='mapbox/walking', walkway_bias=1, alley_bias=1, continue_straight=True) data = response.geojson() # print('DirectionsCalulations', data['features']) print('DirectionsCalulations', data) return data['features'][0]
from configmodule import ProductionConfig, DevelopmentConfig, TestingConfig from mapbox import Directions import os import math import random import datetime from copy import deepcopy # instantiate the app app = Flask(__name__) app.config.from_object(ProductionConfig()) service = Directions(access_token=DevelopmentConfig().MAPBOX_APIKEY) db = SQLAlchemy(app) import models # enable CORS CORS(app, resources={r'/plog*': {'origins': '*'}}) def coord_list_to_linestring(coordinates): linestring = "LINESTRING(" len_coords = len(coordinates) counter = 0 for coord in coordinates: if counter == len_coords - 1: linestring += f'{coord[0]} {coord[1]}'
def output(): # get origin and destination geolocations key = config.mapbox['key'] geocoder = Geocoder() geocoder.session.params['access_token'] = key directions = Directions() directions.session.params['access_token'] = key startname = request.args.get('origin') endname = request.args.get('destination') if startname == '' or endname == '': startname = 'Punxsutawney, PA' endname = 'State College, PA' startresponse = geocoder.forward(startname) endresponse = geocoder.forward(endname) origin = startresponse.geojson()['features'][0] destination = endresponse.geojson()['features'][0] response = directions.directions([origin, destination], 'mapbox/driving') coords = response.geojson()['features'][0]['geometry']['coordinates'] shapely_line = LineString(coords) midpoint = shapely_line.interpolate(0.5, normalized=True).coords[:][0] line = '[' + ','.join(["[{},{}]".format(lat, lon) for lat, lon in coords]) + ']' # Splitting shapely_line line_list = split_line(shapely_line) # Get features from overpass feature_df = overpass_query(line_list) #feature_df = feature_df.reindex(sorted(feature_df.columns), axis=1) feature_df.to_csv('debugging.csv') # Make prediction predictions = loaded_model.predict(feature_df) #predictions = [.2, .7, .8, .2] print(predictions) # Make pretty colors #colorstring = process_line_colors(predictions) colors_segments = process_line_colors(predictions) print(colors_segments) #print('COLORSTRING\n{}'.format(colors_segments)) #pull 'date' from input field and store it drive_date = request.args.get('date') drive_date = pd.to_datetime(drive_date) hour, minute = request.args.get('time').split(":") minute = float(minute) / 60 hour = float(hour) + minute #drive_time = int(request.args.get('time'))/100 idx = test.index.get_loc(drive_date, method='nearest') date_prob = test.iloc[idx].values[0] time_prob = deer_time(hour) time_multiplier = (date_prob * time_prob * 1) if time_multiplier > 0.5: color = "red" else: color = "blue" #print(color) return render_template("output.html", line=line, lat=midpoint[0], lon=midpoint[1], colors_segments=colors_segments)