def find_destination(self, x1, y1, x2, y2):
gmaps = GoogleMaps("AIzaSyAChNKxjgh7MmGPQ6CJOGa_-tjM8giIZe4")
destination = gmaps.latlng_to_address(x2, y2)
adress = gmaps.latlng_to_address(x1, y1)
directions = gmaps.directions(address, destination)
print(directions['Directions']['Distance']['meters'])
def main(argv):
"""
Geocodes a location given on the command line.
Usage:
googlemaps.py "1600 amphitheatre mountain view ca" [YOUR_API_KEY]
googlemaps.py 37.4219720,-122.0841430 [YOUR_API_KEY]
When providing a latitude and longitude on the command line, ensure
they are separated by a comma and no space.
"""
if len(argv) < 2 or len(argv) > 4:
print main.__doc__
sys.exit(1)
query = argv[1]
if len(argv) == 3:
api_key = argv[2]
else:
api_key = raw_input("Google Maps API key: ")
gmap = GoogleMaps(api_key)
try:
result = gmap.geocode(query)
except GoogleMapsError, err:
sys.stderr.write('%s\n%s\nResponse:\n' % (err.url, err))
json.dump(err.response, sys.stderr, indent=4)
sys.exit(1)
def main():
keyfile = "MAP_KEY"
MAP_KEY = ''
# Get API key from a file
try:
with open(keyfile, 'r+') as fh:
MAP_KEY = fh.readline()
except FileNotFoundError:
print('API key file does not exist. Exit the program.')
exit()
# Create gmaps
try:
gmaps = GoogleMaps(MAP_KEY)
except ValueError:
print('Invalid API key provided. Exit the program.')
exit()
# Get src_addr and dst_addr. Currently hardcoded. Need to be changed.
src_addr = 'temple university'
dst_addr = 'temple university ambler campus Learning Center Parking Lot'
# Get distance and duration of src_addr and dst_addr
# return format examples: {'text': '25.3 km', 'value': 25318}, {'text': '25.3 km', 'value': 25318}
distance, duration = getLatLng(src_addr, dst_addr, gmaps)
print(distance)
print(duration)
"""
def getCoord(address):
""" Get coordinates for location using Google Maps Geolocation API.
Raises:
serializers.ValidationError: Google Maps API could not find pair of
coordinates suitable for address passed as input.
Returns:
dictionary: Geocoding information.
"""
start_time = time.time()
gmaps = GoogleMaps(os.getenv("GOOGLE_KEY"))
geocode_result = gmaps.geocode(address)
data = {'long': {}, 'short': {}, 'location': {}}
if geocode_result:
for geolist in geocode_result:
for item in geolist['address_components']:
for category in item['types']:
data['long'].update([(category, item['long_name'])])
data['short'].update([(category, item['short_name'])])
data['location'] = geolist['geometry']['location']
else:
e = serializers.ValidationError('GeoCoding Error: Could not parse coordinates')
capture_message(e)
raise e
print('--- Tiempo de ejecucion getCoord: {} segundos ---'.format((time.time() - start_time)))
return data
def create(self, request):
"""Add a new device location."""
attrs = self.flatten_dict(request.POST)
try:
device = Device.objects.get(user=request.user,
name=attrs['device_name'],
mobile_id=attrs['device_id'])
except Device.DoesNotExist:
return rc.NOT_FOUND
gmaps = GoogleMaps()
try:
address = gmaps.latlng_to_address(float(attrs['lat']),
float(attrs['lon']))
except GoogleMapsError:
address = None
device_location = DeviceLocation(device=device,
address=address,
lat=float(attrs['lat']),
lon=float(attrs['lon']),
created=datetime.datetime.now())
device_location.save()
return rc.CREATED
def return_result(qid, q_type):
global pending_photo, pending_task, active_queries
temp_pending_photo = copy.deepcopy(pending_photo)
for k,v in pending_photo[qid].iteritems():
if (os.path.exists('query/' + k)):
names = k.split('=')
pending_task[qid][names[0]].remove(names[1])
if (len(pending_task[qid][names[0]]) == 1):
del pending_task[qid][names[0]]
#if len(pending_task[qid]) > 0:
#kill_users(pending_task[qid])
ret_val = ''
if (len(pending_photo[qid]) == 0):
ret_val += "<h2>No relevent results.</h2>"
del pending_photo[qid]
del pending_task[qid]
del active_queries[qid]
return ret_val
#print "q_type = " + str(q_type) # q_type = 0U
if (q_type[0] == '0'):
ret_val += "Query Object: <br> </br><img src=\"data:image/jpg;base64,{0}\" width=205><br> </br>".format(open('QUERY_IMAGE/' + q_type[1:]).read().encode('base64').replace('\n', ''))
ret_val += 'Result Objects: <br> </br> <table border=1 bordercolor=#999999 width=600><tr>'
gmaps = GoogleMaps()
while (len(pending_photo[qid]) > 0):
(k, v) = max(pending_photo[qid].iteritems(), key=operator.itemgetter(1))
temp = k.split('=')
ret_val += "<td width=205>"
if (os.path.exists('query/' + k)):
ret_val += "<img src=\"data:image/jpg;base64,{0}\" width=205>".format(open('query/' + k).read().encode('base64').replace('\n', ''))
else:
ret_val += "<b>Warning:</b> Photo failed to be uploaded on time."
#temp = v.split(',')
#dd = datetime.datetime.fromtimestamp(long(temp[len(temp) - 2])/1000)
#tt = dd.isoformat(' ')
#destination = "a, b, c, d, e, f, g"
#destination = gmaps.latlng_to_address(float(temp[3]), float(temp[2]))
#dest = destination.split(', ')
#ret_val += "<p><b><pre>Location: </b>{0}</pre></p>".format(dest[0])
ret_val += "<p><b><pre>Credit: </b>{0}</pre></p>".format(str(pending_photo[qid][k]))
#del dest[0]
#dest[-2] += ', ' + dest[-1]
#del dest[-1]
#for dests in dest:
# ret_val += "<p><pre> {0}</pre></p>".format(dests)
ret_val += "<p><b><pre>Name: </b>{0}</pre></p>".format(k)
del pending_photo[qid][k]
ret_val += "</td>"
del pending_photo[qid]
del pending_task[qid]
del active_queries[qid]
print 'Finish response to ('+str(qid)+'). '
print ' Now query set (' + str(active_queries)+')'
print ' Pending photo ('+str(pending_photo)+')'
print ' Pending task ('+str(pending_task)+')'
return ret_val
def get_lat_long(self):
from googlemaps import GoogleMaps
gmaps = GoogleMaps(italian - 1489414695369)
Address = self.address
lat, lng = gmaps.address_to_latlng(address)
self.latitude = lat
self.longitude = lng
save()
def main():
gmaps = GoogleMaps()
cr = csv.reader(open("mark.csv", "rb"))
dic = dict()
i = 0
for row in cr:
if not row[0]:
break
if i == 0:
i += 1
continue
print row[2]
#address=row[2]
state = lookup(row[2])
text = row[14]
a = text.split('/')
if int(a[0]) > 6:
date = 'winter'
else:
date = 'summer'
if state not in dic:
dic[state] = dict()
if date not in dic[state]:
dic[state][date] = dict()
if row[5] not in dic[state][date]:
dic[state][date][row[5]] = list()
if row[6] not in dic[state][date][row[5]]:
dic[state][date][row[5]].append(row[6])
for state in dic:
print state,
for date in dic[state]:
print date
for order in dic[state][date]:
print dic[state][date][order]
for state in dic:
for date in dic[state]:
if not state:
state1 = 'statenotfoun'
else:
state1 = state
if not date:
date1 = 'datenotfound'
else:
date1 = date
if not os.path.exists('./ir'):
os.makedirs('./ir')
f = open('./ir/' + state1 + date1 + '.txt', 'a')
for order in dic[state][date]:
i = 0
while i < len(dic[state][date][order]):
f.write(dic[state][date][order][i])
f.write(' ')
i += 1
f.write('\n')
def test_point_from_latlng(self):
gmaps = GoogleMaps(settings.GOOGLEMAPS_API_KEY)
latlng = gmaps.address_to_latlng(u'Jose javier Diaz 440, cordoba, argentina', )
point=None
try:
point = MaapPoint(geom=Point(latlng).wkt)
point.save()
except Exception, e:
self.assertIsNotNone(point, msg=e)
def getPlaceID(self, address_line1, address_line2, area, city, state,
country, pincode):
gmaps = GoogleMaps('AIzaSyBoy1plslvW_UTSM3JTWNLijJL1KjsKf60')
address = str(address_line1) + ',' + str(address_line2) + ',' + str(
area) + ',' + str(city) + ',' + str(state) + ',' + str(
country) + ',' + str(pincode)
geocode_result = gmaps.geocode(address)
print(geocode_result[0]['formatted_address'])
place_id = geocode_result[0]['place_id']
return place_id
def getLocation(address_line1,address_line2,area,city,state,country,pincode):
gmaps = GoogleMaps('AIzaSyBoy1plslvW_UTSM3JTWNLijJL1KjsKf60')
address = str(address_line1)+ ',' + str(address_line2)+ ',' + str(area) + ',' + str(city) + ',' + str(state) + ',' + str(country) + ',' + str(pincode)
geocode_result = gmaps.geocode(address)
lat = geocode_result[0]['geometry']['location'] ['lat']
lon = geocode_result[0]['geometry']['location']['lng']
print(lat,lon)
location = "SRID=4326;POINT ("+str(lat) + " " + str(lon)+")"
print(location)
return location
def _geo_loc(self, cr, uid, ids, field_name, arg, context):
result = {}
gmaps = GoogleMaps(
"http://maps.googleapis.com/maps/api/js?key=AIzaSyBwNE-vFDyyOb62ODaRiqpiL2kz8wR0aTc"
)
for partner in self.browse(cr, uid, ids):
address = partner.street
lat, lng = gmaps.address_to_latlng(address)
latlng = str(lat) + "," + str(lng)
result[partner.id] = str(latlng)
return result
def compress(address):
try:
gmaps = GoogleMaps('AIzaSyAH-SEZ1C_8Kb1ACyPCZZpZAJKKDuWD3Ro')
geocode_result = gmaps.geocode(address)
return geocode_result[0]['geometry']['location'][
'lat'], geocode_result[0]['geometry']['location']['lng']
except IndexError:
print("Address was wrong...")
return "null", "null"
except Exception as e:
print("Unexpected error occurred.", e)
def main():
output = '/net/casfsb/vol/ssrchome/active_users/ceholden/img_names.txt'
f = codecs.open(output, 'w', encoding='utf-8')
# refimg = '/net/casrs1/volumes/cas/landsat25/reference_images/catalog'
# os.chdir(refimg)
# GoogleMaps API key
apik = 'AIzaSyA2w-3WNR5joUnHa4K7WDs2eyC-nzjr3fE'
gmaps = GoogleMaps(apik)
def select(paras):
gmaps = GoogleMaps()
address = paras['street'] + ", " + paras['city'] + ", " + paras['state']
latitude, longtitude = gmaps.address_to_latlng(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(2012, time_start_mon, time_start_day,
time_start_hour, 0)
end_time = datetime.datetime(2012, time_end_mon, time_end_day,
time_end_hour, 0)
start_epoch_time = time.mktime(start_time.timetuple()) * 1000
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)
data = []
while True:
dat = cur.fetchone()
if dat == None:
break
data.append(dat)
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 add_coordinate_info(df, api_key):
gmaps = GoogleMaps(api_key)
df['long'] = ""
df['lat'] = ""
long = []
lat = []
for location in progress_bar(df.location):
long_, lat_ = get_lat_long(location, gmaps)
long.append(long_)
lat.append(lat_)
df.long = long
df.lat = lat
return df.reset_index(drop=True)
def pegar_coordenadas_rotas(arquivo_rotas):
"""
Função que retorna uma lista contendo um dicionário com as informações
das rotas passada no arquivo, este dicionário contém as seguinte informações:
'rotas' -> Contem
'distancia' -> Distância em metros entre a origem e o destino
'tempo' -> Tempo em segundos entre a origem e o destino
'origem' -> Origem
'destino' -> Destino
'velocidade' -> Velocidade em metros por segundos
"""
maps = GoogleMaps()
rotas = []
try:
with open(arquivo_rotas, 'r') as f:
content = f.readlines()
for i in content:
try:
source = re.search('from:(.*?)to:(.*)', i).group(1)
dest = re.search('from:(.*?)to:(.*)', i).group(2)
except:
sys.stderr.write("Sintaxe do arquivo de rotas errada, verifique a documentação\n\n")
sys.exit(0)
try:
info = maps.directions(source, dest)
routes = info['Directions']['Routes'][0]['Steps']
Distancia = info['Directions']['Distance']['meters']
Tempo = info['Directions']['Duration']['seconds']
Origem = info['Placemark'][0]['address']
Destino = info['Placemark'][1]['address']
corigem = info['Placemark'][0]['Point']['coordinates']
cdestino = info['Placemark'][1]['Point']['coordinates']
Velocidade = Distancia/Tempo
rotas.append({'rotas':routes, 'distancia':Distancia, 'tempo':Tempo, 'origem':Origem, 'destino':Destino, 'velocidade':Velocidade, 'corigem': corigem, 'cdestino': cdestino})
except:
sys.stderr.write('Rota inexistente para: Origem: {} Destino: {}\n'.format(source, dest))
except IOError:
sys.stderr.write('Não foi possível abrir o arquivo de rotas\n')
return rotas
def get_coordinates(address: str, api_key: str) -> tuple:
"""
Takes in a string address and Google API key.
Returns a tuple with latitude and longitude.
"""
gmaps = GoogleMaps(api_key)
geocode_result = gmaps.geocode(address)
try:
lat = geocode_result[0]['geometry']['location']['lat']
long = geocode_result[0]['geometry']['location']['lng']
return lat, long
except IndexError:
print(f'Error: coordinates not found for location: {address}')
return 0, 0
def get_lat_lng(address, silent=False):
"""
address(unicode)からlat, lngを検索して返す
silent = Trueだとエラーを出さない
"""
addr_utf8 = smart_str(address)
try:
gmaps = GoogleMaps(GOOGLE_MAPS_API_KEY)
lat, lng = gmaps.address_to_latlng(addr_utf8)
except GoogleMapsError:
if silent:
return None, None
raise
return str(lat), str(lng)
def get_coord_dir(direction):
load_dotenv()
G_KEY = os.getenv("KEY_GOOGLE")
gmaps = GoogleMaps(G_KEY)
geocode_result = gmaps.geocode(direction)
try:
lat = geocode_result[0]["geometry"]["location"]["lat"]
lon = geocode_result[0]["geometry"]["location"]["lng"]
return lat, lon
except:
lat = None
lon = None
print('At least I tried')
def dist_from(destination, location):
gmaps = GoogleMaps(
'ABQIAAAAAPMmDP4HCUrLtqjxnhTeXRQV_yMSNSvbo2tmQzi3qOzMvFrzcRTFTor1bOkU8NE2pW1HDlgjEDlcIQ'
)
try:
origin = location
destination = '6224 Agricultural Road Vancouver, B.C. CA V6T 1Z1'
dirs = gmaps.directions(origin, destination, mode='walking')
time = dirs['Directions']['Duration']['html']
dist = dirs['Directions']['Distance']['meters']
route = dirs['Directions']['Routes'][0]
return dist
except GoogleMapsError:
return 10000
def getCoord(location):
start_time = time.time()
msj = ''
gmaps = GoogleMaps(os.getenv("GOOGLE_KEY"))
wk = []
for key in location.keys():
if 'name' not in key:
wk.append(key)
address = normalizeWord(re.sub(',', '', ', '.join(value for value in dict(zip(wk, [location[k] for k in wk])).values() if value), 1))
print(f"ADDRESS: {address}")
geocode_result = gmaps.geocode(address)
data = {'long': {}, 'short': {}, 'location': {}}
if geocode_result:
for geolist in geocode_result:
for item in geolist['address_components']:
for category in item['types']:
data['long'].update([(category, item['long_name'])])
data['short'].update([(category, item['short_name'])])
data['location'] = geolist['geometry']['location']
else:
msj = 'Coordinates not found. Please check Address sent'
try:
data['long']['administrative_area_level_1'] = getLocal('provincias', [dict(nombre=data.get('long').get('administrative_area_level_1'))]).get('nombre', None)
except IndexError:
raise serializers.ValidationError('Could not validate Locality')
# print('location country: {} - gmaps country: {}'.format(location['country'], data.get('long').get('country')))
# print('gmaps route: {}'.format(data.get('short').get('route')))
print(f"DATA: {data['long']['administrative_area_level_1']}")
if data.get('long').get('country') == location['country'] and normalizeWord(data.get('long').get('administrative_area_level_1')) == normalizeWord(location['province']):
if data.get('short').get('route'): location['street'] = data.get('short').get('route')
if data.get('short').get('locality'): location['city'] = data.get('short').get('locality')
location['province'] = data.get('long').get('administrative_area_level_1')
location['latitude'] = data.get('location').get('lat')
location['longitude'] = data.get('location').get('lng')
else:
msj = 'Address not Validated'
print(data['long']['administrative_area_level_1'])
print('--- Tiempo de ejecucion getCoord: {} segundos ---'.format((time.time() - start_time)))
return location, msj
return location, msj
def query_obs(location):
"""
Query information about a given location.
'CFHT Hawaii'
'Roque de los muchachos, Canary Islands'
'Siding Spring, Australia'
"""
print "Where the f**k is", location
gmaps = GoogleMaps()
result = gmaps.geocode(location)
pprint.pprint(result['Placemark'][0])
def storeloc(self, x):
try:
message = " "
api_key = 'YOUR-API-KEY'
gmaps = GoogleMaps(api_key)
geocode_result = gmaps.geocode(x)[0]
lat = geocode_result["geometry"]["location"]["lat"]
lng = geocode_result["geometry"]["location"]["lng"]
store = gmaps.places_nearby(location=(lat, lng), type='store', radius=500)
for i in range(0, 5):
message = message + str(store["results"][i]["name"] + "\n")
return message
except:
message = "You have Entered a invalid input please try again!"
return message
def getLocationByResourceId(r_id):
class Map:
def __init__(self, name, lat, lng):
self.name = name
self.lat = lat
self.lng = lng
api_key = "AIzaSyCeHf-jcEx21QPuV7BZOUOukikZ-bQYxDA"
google = GoogleMaps(api_key)
location = ResourcesHandler().getLocationByResourceId(r_id)
geocode_result = google.geocode(location + ', Puerto Rico')
lat = geocode_result[0]['geometry']['location']['lat']
lng = geocode_result[0]['geometry']['location']['lng']
map = Map(location, lat, lng)
return render_template('map.html', map=map)
def get_location(address):
"""def get_location(address)
Descripció: Cerca la latitud i longitud d'un adreça.
Entrada: String amb l'adreça.
Sortida: String amb la latitud i longitud o codi d'error
segons el resultat de la cerca.
"""
try:
gmaps = GoogleMaps(API_KEY)
geocode_result = gmaps.geocode(address)[0]
lat = geocode_result["geometry"]["location"]['lat']
lng = geocode_result["geometry"]["location"]['lng']
address_lat_lng = (str(lat) + ", " + str(lng))
return address_lat_lng
except IndexError:
return ADDRESS_NOT_FOUND_CODE
def directions(start, end, unsafe=False):
api_key = 'Your API Key'
mapService = GoogleMaps(api_key)
url = 'http://maps.googleapis.com/maps/api/directions/json?%s' % urlencode(
(('origin', start), ('destination', end)))
ur = urllib.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']
print strip_tags(j)
return
def hello_monkey():
def chooseSymbol(line):
if 'head' in line:
return "head"
elif 'roundabout' in line:
return 'roundabout'
elif 'right' in line:
return "right"
elif 'left' in line:
return "left"
elif 'merge' in line:
return "merge"
else:
return 'none'
body_message = str(request.values.get('Body', None))
latitude = body_message.split('_')[0]
longitude = body_message.split('_')[1]
destination = body_message.split('_')[2]
mapService = GoogleMaps()
directions = mapService.directions('RG7 5ND', 'RG7 5NN')
message = ""
#for step in directions['Directions']['Routes'][0]['Steps']:
# message = message + step['descriptionHtml']
mapsUrl = 'https://maps.googleapis.com/maps/api/directions/json?origin=' + str(
latitude) + ',' + str(longitude) + '&destination=' + str(
destination) + '&mode=walking'
response = urllib.urlopen(mapsUrl)
data = yaml.load(response.read())
leg = data.get('routes')[0].get('legs')[0]
general_data = leg.get('distance').get('text') + '_' + leg.get(
'duration').get('text')
stepMessage = ""
stepsArray = leg.get('steps')
for step in stepsArray:
line = step.get('html_instructions')
stepMessage = stepMessage + line + '_' + step.get('distance').get(
'text') + '_' + chooseSymbol(line) + '/n'
#message = str(directions)[0:100]
#message = "Latitude: " + str(latitude) + " Longitude: " + str(longitude) + " Destination: " + str(destination)
message = str(stepMessage)
resp = twilio.twiml.Response()
resp.message(message)
return str(resp)
def get_address_latlng(location):
"""
Requests the latitude and longitude for the given location's address.
Uses the Google Maps API, but could be extended to use a different API.
"""
address = u"%s, %s, %s %s" % (location.street_address, location.city,
location.state, location.postal_code)
try:
return GoogleMaps().address_to_latlng(address)
except GoogleMapsError:
raise LocationEncodingError(_("Google reported an error!"))
except URLError:
raise LocationEncodingError(_("Hmm, network error. Please try again."))
except Exception, e:
raise LocationEncodingError(_("Unknown error: %s, %s" %
(Exception, e)))
def main():
# connect to gmail server
print 'connecting to gmail server...'
username = raw_input("Gmail username: "******"google_maps_key.txt", "r").read()
GMAPS = GoogleMaps(GOOGLE_API_KEY)
rides = []
for receipt in receipts:
ride = receipt.to_ride().set_distance(GMAPS)
rides.append(ride)
print 'done.'
# put data in array, insert into database
print 'filling database...'
data = [(r.distance, r.price, r.bonus, r.time) for r in rides]
conn = build_db(data)
print 'done.'
# query for results
print 'running queries...'
results = run_queries(conn)
print 'done.'
# plot charts
print 'plotting charts...'
plt = plot_data(results)
plt.show()
print 'done.'
# dump coordinates data to json file
print 'exporting coordinates...'
export = export_coordinates(rides)
print 'done.'
