def generationParcours(longitudeDepart, latitudeDepart, longitudeArrivee, latitudeArrivee, api_key, blnSavetoCSV): #Output panda dataframe: #1: lng | #2: lat | #3: distance | #4: duration | #5: vitesse moyenne # Liste de listes. Pour chaque liste, 1er élément = latitude, 2e = longitude, 3e = vitesse max # route = [[latitudeDepart, longitudeDepart, 90],[65.000,45.000,130],[latitudeArrivee, longitudeArrivee, 50]] routemode='driving'; routealternatives=False; routelanguage='Fr' googlemap = Client(api_key) parcours = googlemap.directions((latitudeDepart, longitudeDepart), (latitudeArrivee, longitudeArrivee), mode=routemode, alternatives=routealternatives, language=routelanguage) if len(parcours) > 0: #ErreurParcours = str(parcours[0]['summary']) etapes = parcours[0]['legs'][0]['steps'] ParcoursEtapes=[] for numetape in range(0, len(etapes)): ParcoursEtape= [] etape = etapes[numetape] #print numetape, etape['start_location']['lat'], etape['start_location']['lng'], etape['end_location']['lat'], etape['end_location']['lng'], etape['distance']['value'], etape['duration']['value'] if etape['duration']['value'] != 0: vitmoyms = float(etape['distance']['value'] / etape['duration']['value']) # metres par seconde vitmoykmh = float(3.6*vitmoyms) # kilomètre par heure #print numetape, vitmoyms, vitmoykmh ParcoursEtape.append(etape['start_location']['lat']) ParcoursEtape.append(etape['start_location']['lng']) ParcoursEtape.append(etape['distance']['value']) # eb mètres ParcoursEtape.append(etape['duration']['value']) # en secondes ParcoursEtape.append(vitmoykmh) ParcoursEtapes.append(ParcoursEtape) if(blnSavetoCSV == True): pd.DataFrame(ParcoursEtapes, columns=('lat', 'lng', 'distance', 'duration', 'vit.moy')).to_csv("generationParcours.csv", sep='\t', encoding='utf-8') return pd.DataFrame(ParcoursEtapes, columns=('lat', 'lng', 'distance', 'duration', 'vit.moy') ) else: return False
def directions_result(request): if 'origin' in request.POST: origin = request.POST['origin'] if 'destination' in request.POST: destination = request.POST['destination'] if 'waypoints' in request.POST: waypoints = request.POST['waypoints'] if 'alternatives' in request.POST: alternatives = request.POST['alternatives'] else: alternatives = False print 'alternatives -> ', alternatives if origin and destination: c = Client(api_key) dirs = c.directions( origin=origin, destination=destination, alternatives=alternatives, waypoints=waypoints) else: dirs = '' pprint(len(dirs)) return render(request, 'directions_result.html', { 'directions': dirs })
def getDirections(start = "Sinclair Secondary School, Whitby, Ontario, Canada", end = "University of Windsor, Windsor, Ontario, Canada"): gmaps = Client(key = 'AIzaSyDYYj3lEniXBaV0wQCO4tnkkXl_OnxrdE0') dirs = gmaps.directions(start, end, units = 'metric', mode = "driving") #print (dirs) directions = [] distance = [] for step in dirs: if type(step) is dict: for i in step: if type(step[i] is list): try: for stepNumber in step[i]: if (type(stepNumber) is dict): for key in stepNumber: if key == "steps": for stepInstruction in stepNumber["steps"]: directions.append(stepInstruction.get("html_instructions")) distance.append(stepInstruction.get("distance").get("text")) except: Exception for i in range(0, len(directions)): directions[i] = directions[i].replace("<b>", "") directions[i] = directions[i].replace("</b>", "") directions[i] = directions[i].replace('<div style=\"font-size:0.9em">', " [") directions[i] = directions[i].replace("</div>", "] ") return directions, distance
class Maps(): def __init__(self,key): self.key=key self.con = Client(key=self.key) def getDirections(self,origin,destination,mode='walking'): r,a=self.con.directions(origin,destination,mode=mode)[0]['legs'][0]['steps'],[] for i in r: a.append(i['html_instructions']) return a def textToLatLng(self,text): r=self.con.geocode(text,language='ES-MX')[0]['geometry']['location'] return '%s,%s'%(r['lat'],r['lng']) def getReferenceOnLocation(self,latLngAsString): lat,lng=latLngAsString.split(',') nearbyS='$MAPS_API?key=%s&location=%s&rankby=distance'%(self.key,latLngAsString) return json.loads(requests.get(nearbyS).text)['results'][0]['name'] def getKeyWords(self,string,start='<b>',end='</b>'): words=[] for i in (lambda x:(i for i in xrange(0,x.count(start))))(string): string=string[string.find(start)+3:] words.append(string[:string.find(end)]) return words def getRouteLine(self,line,route=None, stop=None): k = self.getKeyWords(line) if route and stop: return 'Continua hasta %s y abordas la ruta %s en la %s '%(k[0], route, stop) elif stop: return 'Desciende en la %s'%stop else: if len(k)>2: return 'Voltea hacia el %s, camina desde %s hacia %s '%(k[0],k[1],k[2]) else: return 'Dirigete hacia %s '%k[0]
def check_googleMap(self, location): gmaps = Client(key='AIzaSyDAALCs0fN4bo9GdYeplrjdkpg6Lc8LpiU') #lat,lan = gmaps.address_to_latlng(location) ginfo = gmaps.geocode(location) dic = ginfo[0] lat = dic.get('geometry').get('bounds').get('northeast').get('lat') lng = dic.get('geometry').get('bounds').get('northeast').get('lng') return [lat,lng]
def google_directions( self ): # initalize a googlemaps object googmap = Client(google_api_key) print '\n\n' # call the .directions() funciton on Client, save in a list # See if we should use waypoint optimixzing? list_of_maps = [ googmap.directions( pitstop[0], pitstop[1] ) for pitstop in self.trip ] print "\n\n\n******************************\n\n\n" # print directions['Directions']['Distance']["meters"] # for thing in list_of_maps: # print "\n\n\n\n" # print thing total_distance = 0 for count, gmap in enumerate(list_of_maps): # Iterate through the list if gmap[0]['legs'][0]['distance']['text'][-2:] == "ft": total_distance = 0.10 else: total_distance += round( float(gmap[0]['legs'][0]['distance']['text'].replace( ' mi', '')) , 2 ) steps = gmap[0]['legs'][0]['steps'] display = [] turn = 0 leg = 0 for step in steps: to_go = step['distance']['text'] # total_distance += int(to_go) turn = turn + 1 words = step['html_instructions'] words = words.replace( '<b>' , ' ') words = words.replace( '</b>' , ' ') words = words.replace( '<div style="font-size:0.9em">' , '') words = words.replace( '</div>' , ' ' ) display.append([turn, to_go, words]) # print display tabs = ["Turn", "Distance", "Instruction"] tab = tabulate(display, headers = tabs, tablefmt = "simple") print "LEG # " , count , "\n" print tab final = [] final.append(tab) # print tab # return directions print "\n\nDistance: ", total_distance print "\n\n\n******************************\nEnd of google_directions().\n\n" # return final return total_distance
def Directions(start, end): try: mapService = Client('AIzaSyDddi5KttOYGnCalNu8M54DUsc1kCKVCrA') directions = mapService.directions(start, end) x=[] for value in directions[0]['legs'][0]['steps']: x.append(strip_tags(value['html_instructions'])) return x except: return 'Error'
def get_directions(start,end): mapService= Client('AIzaSyDpo931DWDqeeHXeaNAvydQH4isieEHc9s') directions=mapService.directions(start,end) #print each step in directions to console #print json.dumps(directions,indent=4,sort_keys=True) for step in directions[0]['legs'][0]['steps']: print step['html_instructions'] print
def save(self, *args, **kwargs): # only update timestamp when the object is first created # when id is not set yet if not self.id: self.timestamp = timezone.now() self.updated = timezone.now() self.slug = slugify(self.title) gmaps = Client(key="AIzaSyDPPebmy_mg8ho15JXng1WD2ByUsYrT7bY") results = gmaps.geocode(address=self.address + ", " + self.city, region="CA") if results: self.lat = results[0]['geometry']['location']['lat'] self.lon = results[0]['geometry']['location']['lng'] return super(Post, self).save(*args, **kwargs)
def createRoutewithwaypoints(client, dangerpoint, waypoints, aclocations, sp, ep): #print("WE ARE CURRENTLY ENTERING CREATEROUTEWWAYP") k = 25 # in meters dirs = [] pathlist = [] waypoints_inner = [] waypointslist = [] dirs.append((1,1)) dirs.append((1,-1)) dirs.append((-1,1)) dirs.append((1,-1)) for dir in dirs: #print("This is the dangerpoint") #print(dangerpoint) adj_point = getdistfm(dangerpoint[0],dangerpoint[1],k,dir) waypoints_inner = waypoints + [adj_point] waypointslist.append(waypoints_inner); #print("This is the waypoints") #print(waypoints_inner) directionsObject = client.directions(origin=sp, destination=ep, mode='walking', waypoints=waypoints_inner, alternatives = True) if(len(directionsObject) >= 1): pathlist.append(decode(directionsObject[0]['overview_polyline']['points'])) #print("The pathlist is -----------------------------------------------------------------------------------------> \n") #print(pathlist) else: print("WE ARE GETTING 000000! ---------------------------------------------------------------------------------->\n") newpath, wp = choose_best_path(pathlist,dangerpoint,waypointslist) #print("This is NEW PATH -----------------------------------------------************************************************---------------->") #print(newpath) return createRoute(client, sp, ep, newpath, wp , aclocations)
def get_lat_lng(): """ For user input (eg. 'Constitution Ave NW & 10th St NW, Washington, DC', 'San Francisco, CA','Moscow, Russia')calculate geocode using Googlemaps API""" api_key = os.environ["GEOCODING_KEY"] gmaps = Client(api_key) address = request.args.get("address") for dictionary in gmaps.geocode(address): lat = dictionary["geometry"]["location"]["lat"] lng = dictionary["geometry"]["location"]["lng"] payload = {"lat": lat, "lon": lng} return payload
def update_gecode(ip, location): from googlemaps import Client # from django.conf import settings import json ip.latitude = location['latitude'] ip.longitude = location['longitude'] gmaps = Client(key=settings.GOOGLE_GEOCODE_KEY) result = gmaps.reverse_geocode( (location['latitude'], location['longitude'])) ip.geocode = json.dumps(result) print result ip.save()
def locate(area: str = None) -> str: """Returns current location. area: Looks for specific details of an address while locating. Default: None Find and returns current global position using reverse lookup via Google Maps API. Note: Function uses Google Maps for retreiving latitude and longitude using Google Maps API. Hence it is necessary to generate the API key first before running this function. You can generate it here: https://console.developers.google.com Caution: If you run the function without passing valid API key, it will raise an exception. """ import os from geocoder import osm from googlemaps import Client try: if check_internet(): # Passing Google maps API key. gmaps = Client(key=os.environ.get('CHARLOTTE_MAPS_KEY')) # Finding current latitude and longitude details. current_coords = gmaps.geolocate() location = osm(list(current_coords['location'].values()), method='reverse') if area is not None: try: # Returns particular address detail only. return location.json[area] except: return _NO_RESPONSE else: try: # Returns complete address. return location.json['address'] except: return _NO_RESPONSE else: # Returns None if no internet connection is available. return None except Exception as error: print('An error occured while performing this operation because of' f' {error} in function "{stack()[0][3]}" on line' f' {exc_info()[-1].tb_lineno}.')
def find_locales_inside(gmaps: googlemaps.Client, au_suburbs: pd.DataFrame, address: str): target = munchify(gmaps.geocode(address)[0]) bounds = target.geometry.bounds return au_suburbs.loc[(au_suburbs.lat >= bounds.southwest.lat) & (au_suburbs.lat <= bounds.northeast.lat) & (au_suburbs.lon >= bounds.southwest.lng) & (au_suburbs.lon <= bounds.northeast.lng)]
def _get_coords(location: Optional[Text] = None) -> Tuple: """Returns coords for the asked location. location: Location or the address to be converted to latitude and longitude. Default: None Find and returns current global position and the city using reverse lookup via Google Maps API. Note: Function uses Google Maps for retreiving latitude & longitude using it`s API. Hence it is necessary to generate the API key first before running this function. You can generate it here: https://console.developers.google.com Caution: If you run the function without passing valid API key, it will raise an exception. """ import os from geocoder import osm from googlemaps import Client try: # Passing Google maps API key. map = Client(key=os.environ.get('CHARLOTTE_MAPS_KEY')) # Finding current latitude and longitude coordinates. if location: curr = map.geocode(location) coords = (curr[0]['geometry']['location']['lat'], curr[0]['geometry']['location']['lng']) else: curr = map.geolocate() coords = (curr['location']['lat'], curr['location']['lng']) # Reverse mapping the coordinates to find out the city name. area = osm(coords, method='reverse') loc_list = ['city', 'town', 'suburb', 'state', 'region', 'country'] for idx in loc_list: if area.json.get(idx, None) is not None: loc = area.json[idx] break return coords, loc except Exception as error: print('An error occured while performing this operation because of ' f'{error} in function "{stack()[0][3]}" on line ' f'{exc_info()[-1].tb_lineno}.') return (None, None), None
async def offer_park(ctx, *locations): location = "" for place in locations: location = location + place gmaps = Client('AIzaSyA0QJJKbsee6MVN7DAiVSeTUOV2F-V0rRs') latitude = gmaps.geocode(location)[0]['geometry']['location']['lat'] longitude = gmaps.geocode(location)[0]['geometry']['location']['lng'] results = findPlaces(latitude, longitude, "museum") MAX_RESULTS = 5 curr_result = 0 for result in results: if curr_result == MAX_RESULTS: return message = str(curr_result + 1) + ". Name: " + result[ 'name'] + "\n\tLocation: " + result['vicinity'] await ctx.send(message) curr_result = curr_result + 1
def get_lat_lng(): """ For user input (eg. 'Constitution Ave NW & 10th St NW, Washington, DC', 'San Francisco, CA','Moscow, Russia')calculate geocode using Googlemaps API""" api_key = os.environ['GEOCODING_KEY'] gmaps = Client(api_key) address = request.args.get("address") for dictionary in gmaps.geocode(address): lat = dictionary['geometry']['location']['lat'] lng = dictionary['geometry']['location']['lng'] payload = {'lat': lat, 'lon': lng} return payload
def select(paras): a = time.time() gmaps = Client(key='AIzaSyAdtMHxfsESr0OuVdGuseM_VW_uiDtahJY') address = paras['street'] + ", " + paras['city'] + ", " + paras['state'] latitude, longtitude = geofind(address) print "Location convertion: " + str(latitude) + str(longtitude) time_start_mon = int(paras['s_mon']) time_start_day = int(paras['s_day']) time_start_hour = int(paras['s_hou']) time_end_mon = int(paras['e_mon']) time_end_day = int(paras['e_day']) time_end_hour = int(paras['e_hou']) radius = paras['r'] start_time = datetime.datetime(YEAR, time_start_mon, time_start_day, time_start_hour, 0) end_time = datetime.datetime(YEAR, time_end_mon, time_end_day, time_end_hour, 0) start_epoch_time = time.mktime(start_time.timetuple()) * 1000 print "start" + str(start_epoch_time) end_epoch_time = time.mktime(end_time.timetuple()) * 1000 distance = "3959*acos((sin({3}/57.29577951)*sin(latitude/57.29577951)+cos({3}/57.29577951)*cos(latitude/57.29577951)*cos(abs(longtitude-({2}))/57.29577951))) <{4}" querystr = ( "select user, uid, feature, longtitude, latitude, time, size from Meta_data where time >= {0} and time <= {1} and " + distance + " order by user;").format(start_epoch_time, end_epoch_time, longtitude, latitude, radius) if (paras['r'] == '0'): querystr = ( "select user, uid, feature, longtitude, latitude, time, size from Meta_data where time >= {0} and time <= {1} order by user;" ).format(start_epoch_time, end_epoch_time) print querystr con, cur = sql_execute(querystr) b = time.time() f = open('timestamp', 'w') f.write(str(b - a)) f.close() data = [] while True: dat = cur.fetchone() if dat == None: break data.append(dat) # print "paras['type']=" + paras['type'] # paras['type']=0 if (paras['type'] == '0'): return top_k_similar(data, paras['option1'], paras['option2'], paras['deadline']) if (paras['type'] == '1'): return mst.call_mst(data, paras['deadline']) if (paras['type'] == '2'): return kmeans_new.call_kmeans(data, paras['deadline'], int(paras['option1'])) if (paras['type'] == '3'): return represent.call_represent(data, paras['deadline'], int(paras['option1'])) else: return [], [] pass
def reverse_geocode_ipstore(self, queryset): """Reverse geocode the new ip to get more info from lat/longs Args: queryset (TYPE): Description Returns: TYPE: Description """ from apps.warehouse.models import IPStore from googlemaps import Client from django.conf import settings import json gmaps = Client(key=settings.GOOGLE_GEOCODE_KEY) import datetime _now = datetime.datetime.now() for ip in IPStore.objects.filter(geocode__isnull=True): print '---' print ip.ip print '---' qs = queryset.filter( meta__at_ip=ip.ip).order_by('-added_on') print qs print '---' if qs.count() > 0: obj = qs[0] else: obj = None if obj: location = obj.meta['ip2geo']['location'] ip.latitude = location['latitude'] ip.longitude = location['longitude'] result = gmaps.reverse_geocode((location['latitude'], location['longitude'])) ip.geocode = result ip.save() print '---' print ip.ip print '---' print location print '---' print ip.geocode print '---'
def generationParcours(longitudeDepart, latitudeDepart, longitudeArrivee, latitudeArrivee, api_key, blnSavetoCSV): #Output panda dataframe: #1: lng | #2: lat | #3: distance | #4: duration | #5: vitesse moyenne # Liste de listes. Pour chaque liste, 1er élément = latitude, 2e = longitude, 3e = vitesse max # route = [[latitudeDepart, longitudeDepart, 90],[65.000,45.000,130],[latitudeArrivee, longitudeArrivee, 50]] routemode = 'driving' routealternatives = False routelanguage = 'Fr' googlemap = Client(api_key) parcours = googlemap.directions((latitudeDepart, longitudeDepart), (latitudeArrivee, longitudeArrivee), mode=routemode, alternatives=routealternatives, language=routelanguage) if len(parcours) > 0: #ErreurParcours = str(parcours[0]['summary']) etapes = parcours[0]['legs'][0]['steps'] ParcoursEtapes = [] for numetape in range(0, len(etapes)): ParcoursEtape = [] etape = etapes[numetape] #print numetape, etape['start_location']['lat'], etape['start_location']['lng'], etape['end_location']['lat'], etape['end_location']['lng'], etape['distance']['value'], etape['duration']['value'] if etape['duration']['value'] != 0: vitmoyms = float( etape['distance']['value'] / etape['duration']['value']) # metres par seconde vitmoykmh = float(3.6 * vitmoyms) # kilomètre par heure #print numetape, vitmoyms, vitmoykmh ParcoursEtape.append(etape['start_location']['lat']) ParcoursEtape.append(etape['start_location']['lng']) ParcoursEtape.append(etape['distance']['value']) # eb mètres ParcoursEtape.append(etape['duration']['value']) # en secondes ParcoursEtape.append(vitmoykmh) ParcoursEtapes.append(ParcoursEtape) if (blnSavetoCSV == True): pd.DataFrame(ParcoursEtapes, columns=('lat', 'lng', 'distance', 'duration', 'vit.moy')).to_csv("generationParcours.csv", sep='\t', encoding='utf-8') return pd.DataFrame(ParcoursEtapes, columns=('lat', 'lng', 'distance', 'duration', 'vit.moy')) else: return False
def update_gecode(self, ip, location): from googlemaps import Client from googlemaps.exceptions import Timeout from django.conf import settings import json ip.latitude = location['latitude'] ip.longitude = location['longitude'] try: gmaps = Client(key=settings.GOOGLE_GEOCODE_KEY) result = gmaps.reverse_geocode( (location['latitude'], location['longitude'])) ip.geocode = result except Timeout: print 'unable to reverse geocode: %s' % (ip) ip.save()
def getRouteFromUserToBusinessByAppointmentId(aid): api_key = "AIzaSyCeHf-jcEx21QPuV7BZOUOukikZ-bQYxDA" google = GoogleMaps(api_key) route = AppointmentsHandler().getRouteFromUserToBusinessByAppointmentId( aid) originaddress = route[0] + ', ' + route[1] destaddress = route[2] + ', ' + route[3] geocode_origin_result = google.geocode(originaddress) geocode_dest_result = google.geocode(destaddress) originlatitude = geocode_origin_result[0]['geometry']['location']['lat'] originlongitude = geocode_origin_result[0]['geometry']['location']['lng'] destlatitude = geocode_dest_result[0]['geometry']['location']['lat'] destlongitude = geocode_dest_result[0]['geometry']['location']['lng'] return render_template('route.html', originlongitude=originlongitude, originlatitude=originlatitude, destlongitude=destlongitude, destlatitude=destlatitude)
def get_direction(api_key, from_address, to_address, travelling_mode): """Returns all the direction informations between two points Arguments: - api_key : (str) googlemaps API key - from_address : (str) departure location - to_address : (str) arrival location - travelling_mode : (str) conveyance Returns: - client.directions(...) : (list) information about the journey """ client = Client(api_key) return client.directions(from_address, to_address, mode=travelling_mode, departure_time=datetime.now())
def __init__(self, key=''): self.key = key self.lat = None self.lng = None self.country = '' self.is_us = False self.json = None if not self.key: raise AssertionError("There was no API keys specified.") self.client = GClient(key=self.key)
def __init__(self, connection_string=None): self.client = Client(get_api_key()) self.connection_string = connection_string self.engine = create_engine(connection_string) self.Session = sessionmaker(bind=self.engine) self.session = self.Session() self.from_addresses = [] self.to_addresses = [] self.results = [] Base.metadata.create_all(bind=self.engine)
def get_directions(): gmaps=Client(key='AIzaSyB7hXzGzrXUuQuPReZlERvxZO9YFakIzVw') now = datetime.now() direction_result = gmaps.directions("A-10,JIIT Noida, sector-62, Noida","9, Vaibhav Khand, Indirapuram, Ghaziabad, Uttar Pradesh 201014, India",mode="transit",departure_time=now) ##print direction_result distance=direction_result[0]['legs'][0]['distance'] end_address=direction_result[0]['legs'][0]['end_address'] travel_mode=direction_result[0]['legs'][0]['steps'][0]['travel_mode'] instructions=direction_result[0]['legs'][0]['steps'][0]['html_instructions'] duration=direction_result[0]['legs'][0]['steps'][0]['duration'] print distance['text'],duration['text'] ## Directions num_steps=len(direction_result[0]['legs'][0]['steps'][0]['steps']) str1='' for i in range(0,num_steps): str1+=str(direction_result[0]['legs'][0]['steps'][0]['steps'][i]['html_instructions'])+'\n' #print direction_result[0]['legs'][0]['steps'][0]['steps'][i]['distance'] #print direction_result[0]['legs'][0]['steps'][0]['steps'][i]['duration'] return str1
def is_valid_config_entry(opp, logger, api_key, origin, destination): """Return whether the config entry data is valid.""" origin = resolve_location(opp, logger, origin) destination = resolve_location(opp, logger, destination) client = Client(api_key, timeout=10) try: distance_matrix(client, origin, destination, mode="driving") except ApiError: return False return True
def is_valid_config_entry(hass, api_key, origin, destination): """Return whether the config entry data is valid.""" origin = find_coordinates(hass, origin) destination = find_coordinates(hass, destination) client = Client(api_key, timeout=10) try: distance_matrix(client, origin, destination, mode="driving") except ApiError: return False return True
def buscar(self): nombre_ubicacion = self.ui.txt_nombre_ubicacion.text().strip() if len(nombre_ubicacion): cliente = Client(key='AIzaSyDCugQUG_8vYlrXz2URJEUgYKuOF4miIcU') resultado = cliente.geocode(nombre_ubicacion)[0] self.ui.txt_ciudad.setText(nombre_ubicacion) self.ui.txt_nombre_completo_ubicacion.setText( resultado['formatted_address']) self.ui.txt_latitud.setText( str(resultado['geometry']['location']['lat'])) self.ui.txt_longitud.setText( str(resultado['geometry']['location']['lng'])) else: self.mensaje.setIcon(QMessageBox.Warning) self.mensaje.setText('El campo Nombre ubicación es obligatorio.') self.mensaje.exec_()
def getDirections(current_location, transportation_mode, shop_preference): """Return a list of directions that the user should take to get from their current location to the ClickTime office while stopping for donuts and coffee along the way.""" # Init API Clients google_places = GooglePlaces(GOOGLE_API_KEY) google_maps = Client(key=GOOGLE_API_KEY) # Get the coordinates of the nearest donut shop to the ClickTime office. query_result = google_places.nearby_search( lat_lng=CLICKTIME_LOCATION, name='donut', types='food', rankby=shop_preference) donut_shop_name = query_result.places[0].name donut_shop_location = query_result.places[0].geo_location # Get directions from current location to donut shop. # Had issues with waypoints so I broke the route into # two different pieces. directions_api_result = google_maps.directions( current_location, donut_shop_location, mode=transportation_mode) directions = [] for step in directions_api_result[0]['legs'][0]['steps']: directions.append(step['html_instructions']) directions.append('<font color="green">Arrived at ' + donut_shop_name + '!</font>') # Get directions from the donut shop to the ClickTime office. directions_api_result = google_maps.directions( donut_shop_location, CLICKTIME_LOCATION, mode=transportation_mode) for step in directions_api_result[0]['legs'][0]['steps']: directions.append(step['html_instructions']) directions.append('<font color="green">Arrived at ClickTime!</font>') return directions
def __query_INFO(search_parameter): gmaps = client(key = Extractor.__API_KEY) #Query google API by parameter_type query_DATA = [] query_results = client.find_place(gmaps, ('+1' + search_parameter) , 'phonenumber', ['name', 'types']) for item in query_results.items(): query_DATA.append(item[1][0]['name']) query_DATA.append(item[1][0]['types'][0]) return query_DATA
def google_maps_request(addr, key): gmaps = Client(key=key) # Geocoding an address geocode_result = gmaps.geocode(addr) print('geocode_result={}'.format(geocode_result)) # Look up an address with reverse geocoding reverse_geocode_result = gmaps.reverse_geocode((40.714224, -73.961452)) print('reverse_geocode_result={}'.format(reverse_geocode_result)) # Request directions via public transit now = datetime.now() directions_result = gmaps.directions( origin="Sydney Town Hall", destination="Parramatta, NSW", mode="transit", departure_time=now ) print('directions_result={}'.format(directions_result))
def get_directions(place, dest): gmaps = Client(key='AIzaSyB7hXzGzrXUuQuPReZlERvxZO9YFakIzVw') now = datetime.now() direction_result = gmaps.directions(place, dest, mode="transit", departure_time=now) ##print direction_result distance = direction_result[0]['legs'][0]['distance'] end_address = direction_result[0]['legs'][0]['end_address'] travel_mode = direction_result[0]['legs'][0]['steps'][0]['travel_mode'] instructions = direction_result[0]['legs'][0]['steps'][0][ 'html_instructions'] duration = direction_result[0]['legs'][0]['steps'][0]['duration'] str1 = '' num_steps = len(direction_result[0]['legs'][0]['steps'][0]['steps']) for i in range(0, num_steps): str1 += str(direction_result[0]['legs'][0]['steps'][0]['steps'][i] ['html_instructions']) + '\n' return distance['text'] + ' ' + duration['text'] + ' ' + str1
def __init__(self, lat, lng): # maps neighbor node to distance """ a node representing a location on the map using latitude and longitude :param lat: latitude of this node :param lng: longitude """ self.neighbors = dict() # dict of node -> distance self.latitude = lat self.longitude = lng self.elevation = elevation(Client(key='AIzaSyCtnZS7miejfbAh1FsKUBhxil1VXa0EicY'), (lat, lng))[0]['elevation']
def __init__(self, apiKey: str): """ コンストラクタ Parameters ---------- apiKey : str Google Mapsクライアントに接続するAPI key Notes ----- (32 + 31 + ... + 2 + 1)回Google Maps APIを実行して通信を行う """ # 各店舗間の経路情報の行列の初期化 self._directions = [] # Google Mapsクライエントの初期化 client = Client(key=apiKey) # Google Maps APIを用いて、各店舗間の経路情報の行列をセット for i in range(len(Sawayaka._ADDRESSES)): directions_tmp = [] for j in range(len(Sawayaka._ADDRESSES)): if i < j: # 上三角成分の場合は、Google Maps APIを実行して追加 result = client.directions( origin=Sawayaka._ADDRESSES[i], destination=Sawayaka._ADDRESSES[j], mode="driving", alternatives=False) directions_tmp.append(result[0]['legs'][0]) elif i > j: # 下三角成分の場合は、上三角成分をそのままコピー directions_tmp.append(self._directions[j][i]) else: # 対角成分の場合は、Noneを追加 directions_tmp.append(None) self._directions.append(directions_tmp)
def find_using_google(user_query, lat_long_coordinates, minimum_price=0, maximum_price=2, next_page_token=""): google_client = Client(app.config['GOOGLE_API_KEY']) radius = 500 result_type_filter = 'restaurant' result = places.places(google_client, query=user_query, location=lat_long_coordinates, radius=radius, min_price=minimum_price, max_price=maximum_price, type=result_type_filter, page_token=next_page_token) formatted_results = format_google_return_list(result['results']) if 'next_page_token' in result: return {'resultList': formatted_results, 'nextPageToken': result['next_page_token']} return {'resultList': formatted_results, 'nextPageToken': None}
class Gmaps: def __init__(self, APIKey): self.key = APIKey self.Gmaps = GoogleMaps(self.key) def get_Region(self, address): try: Location = self.Gmaps.geocode(address) region = Location[0]["address_components"][7]["short_name"] return region except: return ""
def say_hi(self): gmaps = Client('AIzaSyD0AJQRoThLlugn1lW_TgYhRBtRON34LDA') start = self.E1.get() finish = self.E2.get() url = 'http://maps.googleapis.com/maps/api/directions/json?%s' % urlencode( (('origin', start), ('destination', finish))) ur = urlopen(url) result = json.load(ur) for i in range(0, len(result['routes'][0]['legs'][0]['steps'])): j = result['routes'][0]['legs'][0]['steps'][i]['html_instructions'] self.list1.insert(0, j)
class location(metaclass=Singleton): def __init__(self, s=""): self.api_key = 'AIzaSyAhb_rBwht_tVUC0VEFMiQIqelRESZgL_c' if s != "": self.api_key = s self.gmaps = GoogleMaps(self.api_key) def find_location_for(self, adr): l = self.gmaps.geocode(adr) lat = l[0]["geometry"]["location"]["lat"] lon = l[0]["geometry"]["location"]["lng"] return lat, lon
def perform_create(self, serializer): gmaps = Client(key=os.environ['GOOGLE_MAPS_KEY']) origin_city = f"{serializer.validated_data['origin_city']}, {serializer.validated_data['origin_state']}" destination_city = f"{serializer.validated_data['destination_city']}, {serializer.validated_data['destination_state']}" origin_gmaps = gmaps.find_place( origin_city, 'textquery', fields=['geometry', 'formatted_address']) destination_gmaps = gmaps.find_place( destination_city, 'textquery', fields=['geometry', 'formatted_address']) serializer.save( owner=self.request.user, origin_lat=origin_gmaps['candidates'][0]['geometry']['location'] ['lat'], origin_lon=origin_gmaps['candidates'][0]['geometry']['location'] ['lng'], destination_lat=destination_gmaps['candidates'][0]['geometry'] ['location']['lat'], destination_lon=destination_gmaps['candidates'][0]['geometry'] ['location']['lng'], )
def find_traffic(hours, minutes): addresses = [] gmaps = Client('AIzaSyCaQlauoQ1njrABzhVCliY49DaByZNYkTY') cassie_work = '3237 S 16th St, Milwaukee, WI 53215' joey_work = '1550 Innovation Way, Hartford, WI 53027' with open('address.txt') as f: addresses = f.readlines() file = open('times.csv', 'a') day = datetime.datetime.today().weekday() for addr_newline in addresses: addr = addr_newline.rstrip() directions_cassie = None directions_joey = None if (hours < 8): directions_cassie = gmaps.directions(addr, cassie_work) directions_joey = gmaps.directions(addr, joey_work) else: directions_cassie = gmaps.directions(cassie_work, addr) directions_joey = gmaps.directions(joey_work, addr) file.write( str(addr) + ',' + format_time(hours, minutes) + ',Cassie,' + str(directions_cassie[0]['legs'][0]['duration']['value']) + ',Joey,' + str(directions_joey[0]['legs'][0]['duration']['value']) + ',' + str(day) + '\n') file.close()
def calcular_distancia(self): primera_ubicacion = self.ui.txt_primera_ubicacion.text().strip() if len(primera_ubicacion): segunda_ubicacion = self.ui.txt_segunda_ubicacion.text().strip() if len(segunda_ubicacion): cliente = Client(key='AIzaSyDCugQUG_8vYlrXz2URJEUgYKuOF4miIcU') resultado = cliente.distance_matrix(primera_ubicacion, segunda_ubicacion) distancia = resultado['rows'][0]['elements'][0]['distance']['text'] self.ui.txt_distancia.setText(distancia) else: self.mensaje.setIcon(QMessageBox.Warning) self.mensaje.setText('El campo Segunda ubicación es obligatorio.') self.mensaje.exec_() else: self.mensaje.setIcon(QMessageBox.Warning) self.mensaje.setText('El campo Primera ubicación es obligatorio.') self.mensaje.exec_()
def createRoute(startpoint, endpoint, aclocations): client = \ googlemaps.Client(key='AIzaSyDAszXFz4LjQQ6Itr4o7O90RUJhUhhnXXI') finalRoute = [] directionsObject = client.directions(origin=startpoint, destination=endpoint, mode='walking') mainPath = decode(directionsObject[0]['overview_polyline']['points']) i = 0 for point in mainPath: i = i+1 if checkIfSafe(point, aclocations) == True: finalRoute.append(point) #print finalRoute else: ''' print(aclocations) print("\n") print mainPath print("We have reached to point" + str(point)) print("The point before this is: " + str(mainPath[i-2])) print("The point after this is: " + str(mainPath[i])) ''' tup1 = [] tup1.append(mainPath[i-2][1]) tup1.append(mainPath[i-2][0]) tup2 = [] tup2.append(mainPath[i][1]) tup2.append(mainPath[i][0]) #print mainPath[i-1] #print mainPath[i+1] #finalRoute.append(createRoute(mainPath[point-1], mainPath[point+1], aclocations)) #print("The point in the mainpoints that has an issue is: " + str(point)) #finalRoute.append(createRoute(mainPath[i-2], mainPath[i], aclocations)) directionsObject2 = client.directions(origin = tup1, destination = tup2, mode = 'walking', alternatives = True) routeAgain = decode(directionsObject2[0]['overview_polyline']['points']) for point in routeAgain: finalRoute.append(point) return finalRoute
def main(): startAddress = sys.argv[1] endAddress = sys.argv[2] aclocations = [] aclocations = readInJSON() aclocations = aclocations + [[40.11351,-88.22807]] + [[40.11449,-88.2243]]; client = \ googlemaps.Client(key='AIzaSyDAszXFz4LjQQ6Itr4o7O90RUJhUhhnXXI') finalRoute = [] waypoints = [] directionsObject = client.directions(origin=startAddress, destination=endAddress, mode='walking', alternatives = True) mainPath = decode(directionsObject[0]['overview_polyline']['points']) theRoute = createRoute(client, startAddress, endAddress, mainPath, [], aclocations) print (theRoute)
def main(): sp = sys.argv[1] ep = sys.argv[2] totalCrimes = readInJSON() ac = [] vt = [] ac = totalCrimes[0] vt = totalCrimes[1] #aclocations = aclocations + [[40.11351,-88.22807]] + [[40.11449,-88.2243]]; # + [[40.1136,-88.22725]] #print(aclocations) #sp = '331 E Stoughton Stoughton Champaign IL' #ep = '208 N. Harvey Urbana IL 61801' #sp = '610 E Stoughton Champaign IL 61820' client = \ googlemaps.Client(key='AIzaSyDAszXFz4LjQQ6Itr4o7O90RUJhUhhnXXI') finalRoute = [] waypoints = [] directionsObject = client.directions(origin=sp, destination=ep, mode='walking', alternatives = True) mainPath = decode(directionsObject[0]['overview_polyline']['points']) theRoute = createRoute(client, sp, ep, mainPath, [], ac, vt) print(theRoute)
#!/usr/bin/env python # -*- coding: utf-8 -*- import sys from urllib import urlopen # <------------- import requests import json from googlemaps import Client from database import collection # maxPages = int(sys.argv[1]) # numero di pagine da prendere pageArray = [] gmaps = Client(key='AIzaSyDGGQRjUKv2HkqPzotZx9isbz-xXVDR0NQ') # def metaSparkfunParse(): # print 'get metadata sparkfun' # for i in range(maxPages): # for i in range(100, 105): # page = i # print(i) # try: # # pageArray.append(urllib.request.urlopen("https://data.sparkfun.com/streams/?page=" + str(page))) # pageArray.append(urlopen("https://data.sparkfun.com/streams/?page=" + str(page))) # except: # print (sys.exc_info()[0]) # continue pageArray.append(urlopen("https://data.sparkfun.com/streams/?page=105"))
from googlemaps import Client as GoogleMaps from googlemaps import geocoding from googlemaps import convert API_Key="AIzaSyDVYcV4L2bOFuiEvjgvtTWsVieX7nZfzeo" gmaps = GoogleMaps(API_Key) address = raw_input("Enter a location: ") coordinates = gmaps.geocode(address) print coordinates
from googlemaps import Client as GoogleMaps gmaps = GoogleMaps(api_key="YOUR KEY") address = 'Constitution Ave NW & 10th St NW, Washington, DC' lat, lng = gmaps.address_to_latlng(address) print lat, lng
#Python Get Directions Script #API_KEY value API_KEY="AIzaSyDVYcV4L2bOFuiEvjgvtTWsVieX7nZfzeo" #import statements from googlemaps import Client #create GoogleMaps object mapService = Client(API_KEY) #get directions from google directions = mapService.directions('texarkana', 'atlanta') for key in directions: print(key)
#0.3 os package used to change directory import os #0.4 Client package from google maps used to query distances from googlemaps import Client #0.5 Import numpy import numpy as np #----------------------------------------------------------------- #----------------------------------------------------------------- #1. Change directory os.chdir('/Users/rodrigoazuero/Documents/DATAIDB2015/Clusters/FinalFiles/Python/Cluster8') #----------------------------------------------------------------- #----------------------------------------------------------------- #2. Store the API key in the following variables gmaps=Client('INSTERT-KEY-HERE') gmaps=Client(key='INSTERT-KEY-HERE') #----------------------------------------------------------------- #----------------------------------------------------------------- #3. Matrix definitions for distances. We need to replace #the values with the corresponding rank for the matrices. drivedistance= np.empty((10000,10000), dtype=np.object) walkdistance= np.empty((10000,10000), dtype=np.object) #3.1 Define the threshold variable. I will compute the google maps query exclusively #for those schools within the value of threshold threshold=10 #-----------------------------------------------------------------
#helper function used in _encode_coords def _encode_value(value): # Step 2 & 4 value = ~(value << 1) if value < 0 else (value << 1) # Step 5 - 8 chunks = _split_into_chunks(value) # Step 9-10 return (chr(chunk + 63) for chunk in chunks) #actually calling the directions method on the origin and destinatino directions = client.directions(origin = '201 N. Goodwin Avenue Urbana IL 61801', destination = '208 N. Harvey Urbana IL 61801', mode = "walking", alternatives = True) #parsing the directions object (JSON) so we can return a list of lat/lon points point_str = (directions[0]['overview_polyline']['points']) points = [] #function that decodes the unicode string that Google Maps returns as the encoded lat/lon route def decode(point_str): '''Decodes a polyline that has been encoded using Google's algorithm http://code.google.com/apis/maps/documentation/polylinealgorithm.html This is a generic method that returns a list of (latitude, longitude) tuples. :param point_str: Encoded polyline string. :type point_str: string
def from_place_to_lati_longi(place): gmaps = Client(API_KEY) address = place lat_lng = gmaps.geocode(address)[0][u'geometry'][u'location'] return lat_lng
def __init__(self,key): self.key=key self.con = Client(key=self.key)
def get_lat_long(self): gmaps = Client(key=settings.GMAPS_API_KEY) results = gmaps.geocode(address=self.address + ", " + self.city, region="CA") if results: lat_lng = results[0]['geometry']['location'] return lat_lng
from datetime import timedelta from datetime import datetime from pytz import timezone import re from skiplagged import Skiplagged from pushbullet import Pushbullet from googlemaps import Client from utils.pokemon import is_unique if __name__ == '__main__': client = Skiplagged() pb = Pushbullet(os.getenv("PB_KEY")) gmaps = Client(os.getenv("GMAP_KEY")) #bounds = client.get_bounds_for_address('Isla Vista, CA') bounds = ( (34.408359, -119.869816), # Lower left lat, lng (34.420923, -119.840293) # Upper right lat, lng ) for channel in pb.channels: print channel if channel.channel_tag == '': my_channel = channel
def append_elevation(lat, lon, gmaps_api_key): request_google = Client(key=str(gmaps_api_key)) location = (lat, lon) response = request_google.elevation(locations=location) elev = response[0]['elevation'] return (lat, lon, elev)
def getGeocode(location): c = Client("AIzaSyAGfQB9o_UWdN6NNn9L0jv_6ppXgW4W-uo") return c.geocode(location)[0]["geometry"]["location"]
def getgeo(address): gmaps = Client('AIzaSyA3i4VXAqU2qmSXKQ3ve4htc_QNxLaJpW4') json_response = gmaps.geocode(address) dictionary= json_response[0]['geometry']['location'] return dictionary[u'lat'],dictionary[u'lng']
#0.3 os package used to change directory import os #0.4 Client package from google maps used to query distances from googlemaps import Client #0.5 Import numpy import numpy as np #----------------------------------------------------------------- #Block of parameter definition. #----------------------------------------------------------------- #1. Change directory os.chdir('/Users/rodrigoazuero/Dropbox/gmapsdistance/gmapsdistancePython') #----------------------------------------------------------------- #----------------------------------------------------------------- #2. Store the API key in the following variables gmaps=Client('AIzaSyB2GpMeRX8FHzz0aVZApbnF8_wlw88eBK0') gmaps=Client(key='AIzaSyB2GpMeRX8FHzz0aVZApbnF8_wlw88eBK0') #----------------------------------------------------------------- #----------------------------------------------------------------- #3. Matrix definitions for distances. We need to replace #the values with the corresponding rank for the matrices. DISTANCEFINAL= np.empty((10000,10000), dtype=np.object) #3.1 Define the threshold variable. I will compute the google maps query exclusively #for those schools within the value of threshold threshold=10
# -*- coding: utf8 -*- import pandas as pd import numpy as np from pandas import Series, DataFrame import re import googlemaps from googlemaps import Client API_KEY = 'AIzaSyAcXNyjXepUbFyAf5auZq_RAF_CJJofG_E' #create the Google maps client gmaps = Client(key=API_KEY) #mapp = 'https://maps.googleapis.com/maps/api/distancematrix/json?origins=Paris&destinations=Poitier&mode=bicycling&language=fr-FR&key=AIzaSyAcXNyjXepUbFyAf5auZq_RAF_CJJofG_E' # read the cities cities = pd.read_csv('villes.csv') origins = ["Perth, Australia", "Sydney, Australia", "Melbourne, Australia", "Adelaide, Australia", "Brisbane, Australia", "Darwin, Australia", "Hobart, Australia", "Canberra, Australia"] origins = list(cities['Ville'].values[0:10]) destinations = list(cities['Ville'].values[0:10]) matrix = gmaps.distance_matrix(origins, destinations) matrix_train = gmaps.distance_matrix(origins, destinations,mode='walking')