Introduction
You probably use Google Maps a lot in your daily life, such as locate a popular restaurant, check the distance between one place to another, or find the nearest driving route and shortest travelling time etc. If you have been thrown with a big set of location data where you need check and validate them from a map, and then find the optimal routes, you probably would think how this can be done programmatically in Python. In this article, we will be exploring how all these can be achieved with Python Google Maps APIs.
Prerequisites
To be able to use Google Maps APIs, you will need to create a Google Cloud Service account and set up a billing method. If you are a new signed up user, you would get $300 credit for you to try out all the various Google APIs. You can follow the official docs to set up a new project, and from where you would get an API key for using its services.
You will also need to install the GoogleMaps package in your working environment, below is the pip command to install the package:
pip install -U googlemaps
Now let’s import the package at the beginning of our code, and initialize the service with your API Key:
import googlemaps gmaps = googlemaps.Client(key='YOUR API KEY')
If you did not get any error up to this step, you are all set to go. Let’s start to explore the various function calls you can do with this package.
Get Geolocation of the Addresses
Often you need to check a location by address, postal code or even the name of the store/company, this can be done via the geocode function which is similar to search a place in Google Maps from your browser. The function returns a list of possible locations with the detailed address info such as the formatted address, country, region, street, lat/lng etc.
Below are a few possible address info you can pass to this API call:
#short form of address, such as country + postal code geocode_result = gmaps.geocode('singapore 018956') #full address geocode_result = gmaps.geocode("10 Bayfront Ave, Singapore 018956") #a place name geocode_result = gmaps.geocode("zhongshan park") #Chinese characters geocode_result = gmaps.geocode('滨海湾花园') #place name/restaurant name geocode_result = gmaps.geocode('jumbo seafood east coast') print(geocode_result[0]["formatted_address"]) print(geocode_result[0]["geometry"]["location"]["lat"]) print(geocode_result[0]["geometry"]["location"]["lng"])
Depends how complete the information you have supplied to the function call, you may get some sample output as per below:
1206 ECP, #01-07/08 East Coast Seafood Centre, Singapore 449883 1.3051669, 103.930673
Reverse Geocoding
You can also use the latitude and longitude to check the address information, this is called reverse geocoding. For instance, the below will give you the human readable addresses for the given lat/lng:
reverse_geocode_result = gmaps.reverse_geocode((1.3550021,103.7084641)) print(reverse_geocode_result[0]["formatted_address"]) #'87 Farrer Dr, Singapore 259287'
You may get multiple address info with the same lat/lng as Google just return the list of addresses closest to this lat/lng.
Check the Distance Between Locations
To check the distance between multiple locations, you can use the Google distance matrix API, where you can supply multiple locations, and Google will return the travelling distance between each location as well as the travelling time. E.g.:
from datetime import datetime, timedelta gmaps.distance_matrix(origins=geocode_result[0]['formatted_address'], destinations=reverse_geocode_result[0]["formatted_address"], departure_time=datetime.now() + timedelta(minutes=10))
In above example, we have provided the departure time as 10 minutes later from current time for Google to calculate the travelling time. The departure time cannot be any time in the past.
The return JSON object would include the travelling distance and time based on the current traffic condition (default transport mode is driving):
{'destination_addresses': ['87 Farrer Dr, Singapore 259287'], 'origin_addresses': ['1206 ECP, #01-07/08 East Coast Seafood Centre, Singapore 449883'], 'rows': [{'elements': [{'distance': {'text': '22.2 km', 'value': 22219}, 'duration': {'text': '24 mins', 'value': 1442}, 'duration_in_traffic': {'text': '22 mins', 'value': 1328}, 'status': 'OK'}]}], 'status': 'OK'}
Get Directions Between Locations
One of the most frequent usage of Google Maps is to check the direction from one place to another. You can use directions API to get the route info as per below:
directions_result = gmaps.directions(geocode_result[0]['formatted_address'], reverse_geocode_result[0]["formatted_address"], mode="transit", arrival_time=datetime.now() + timedelta(minutes=0.5))
For this directions API, it returns you the detailed routing information based on what type of travelling mode you’ve chosen.
In the above example, we have specified the mode as “transit”, so Google Maps will suggest a route that you can take the public transport whenever possible to reach your final destination. It may not meet your arrival time if it is really infeasible anyway.
Below is the sample return with detailed routing directions:
[{'bounds': {'northeast': {'lat': 1.3229677, 'lng': 103.9314612}, 'southwest': {'lat': 1.2925606, 'lng': 103.8056495}}, 'copyrights': 'Map data ©2021 Google', 'legs': [{'arrival_time': {'text': '9:16pm', 'time_zone': 'Asia/Singapore', 'value': 1611321373}, 'departure_time': {'text': '7:59pm', 'time_zone': 'Asia/Singapore', 'value': 1611316750}, 'distance': {'text': '18.0 km', 'value': 17992}, 'duration': {'text': '1 hour 17 mins', 'value': 4623}, 'end_address': '87 Farrer Dr, Singapore 259287', 'end_location': {'lat': 1.3132547, 'lng': 103.8070619}, 'start_address': '1206 ECP, #01-07/08 East Coast Seafood Centre, Singapore 449883', ... {'distance': {'text': '0.1 km', 'value': 106}, 'duration': {'text': '1 min', 'value': 76}, 'end_location': {'lat': 1.305934, 'lng': 103.9306822}, 'html_instructions': 'Turn <b>left</b>', 'maneuver': 'turn-left', 'polyline': {'points': 'q{}Fk_jyRM?KAIAE@a@DQBGDEBGDIF_@LQD'}, 'start_location': {'lat': 1.3050507, 'lng': 103.9309369}, 'travel_mode': 'WALKING'}, ... }]
You can also supply the waypoints parameter in order to route multiple locations between your origin and destination. For instance, if you want to go for a one day tour in Singapore, you can provide a list of the attractions and let Google to optimize the route for you with the optimize_waypoints = True parameter. The sample code as per below:
waypoints = ["Chinatown Buddha Tooth Relic Temple", "Sentosa Island, Singapore", "National Gallery Singapore", "Botanic Garden, Singapore", "Boat Quay @ Bonham Street, Singapore 049782"] results = gmaps.directions(origin = "Fort Canning Park, Singapore", destination = "Raffles Hotel, Singapore", waypoints = waypoints, optimize_waypoints = True, departure_time=datetime.now() + timedelta(hours=1) for i, leg in enumerate(results[0]["legs"]): print("Stop:" + str(i), leg["start_address"], "==> ", leg["end_address"], "distance: ", leg["distance"]["value"], "traveling Time: ", leg["duration"]["value"] )
To get a good result, you will need to make sure all the locations you’ve provided can be geocoded by Google. Below is the output:
Plot Route on Google Maps
To visualize your route or location on a map, you can make use of the Maps Static API. It allows you to plot your locations as markers on the map and draw the path between each location.
To get started, we shall define the markers for our locations. We can specify the color, size and label attributes for each location in a “|” separated string. As the label only allows a single character from {A-Z, 0-9}, we will just use A-Z to indicate the sequence of each location. E.g.:
locations = ["Fort Canning Park, Singapore", "Chinatown Buddha Tooth Relic Temple", "Sentosa Island, Singapore", "National Gallery Singapore", "Boat Quay @ Bonham Street, Singapore 049782", "Botanic Garden, Singapore", "Raffles Hotel, Singapore"] markers = ["color:blue|size:mid|label:" + chr(65+i) + "|" + r for i, r in enumerate(locations)]
In the static_map function, you can specify the scale, size and zoom to define how many pixels of your output and whether you want to show the details up to the city or individual building on your map.
The format and maptype parameters are used to specify the output image format and what type of maps you want to use.
Lastly, we can specify the path parameter to connect the different locations together. Similar to how we define the markers, we can specify the attributes in a “|” separated string. Below is the sample code:
result_map = gmaps.static_map( center=locations[0], scale=2, zoom=12, size=[640, 640], format="jpg", maptype="roadmap", markers=markers, path="color:0x0000ff|weight:2|" + "|".join(locations))
And if you save the return result into a .jpg file as per below:
with open(“driving_route_map.jpg”, “wb”) as img: for chunk in result_map: img.write(chunk)
You shall see something similar to the below:
The routing sequence is based on the list of locations you’ve supplied, so you can probably use directions function to return a optimal route and then plot them with static_map.
A few things to be noted are that the static map only support small size of image (up to 1280×1280), and you will have to plot in more points if you want to draw a nicer driver routes. For our above code, we only take 7 location points, so the lines are not making any sense for driving. If we use the location points suggested by Google from directions function, the result would look much better. E.g.:
marker_points = [] waypoints = [] #extract the location points from the previous directions function for leg in results[0]["legs"]: leg_start_loc = leg["start_location"] marker_points.append(f'{leg_start_loc["lat"]},{leg_start_loc["lng"]}') for step in leg["steps"]: end_loc = step["end_location"] waypoints.append(f'{end_loc["lat"]},{end_loc["lng"]}') last_stop = results[0]["legs"][-1]["end_location"] marker_points.append(f'{last_stop["lat"]},{last_stop["lng"]}') markers = [ "color:blue|size:mid|label:" + chr(65+i) + "|" + r for i, r in enumerate(marker_points)] result_map = gmaps.static_map( center = waypoints[0], scale=2, zoom=13, size=[640, 640], format="jpg", maptype="roadmap", markers=markers, path="color:0x0000ff|weight:2|" + "|".join(waypoints))
We are extracting all the location points from the directions function and pass them to the path parameter to draw the connection lines. The output would be similar to below which makes more sense for driving:
Conclusion
In this article, we have reviewed through a few Google Maps APIs which hopefully will help you for any feasibility study or even in your real projects. For example, to cleanse the dirty address for a large set of data, or to calculate the distance/travelling time or get the optimal routes between multiple locations. If your objective is to generate a dynamic map, you probably have to go for the Maps JavaScript API where you can display a map on web page and make it interactive, but still you may find these Python APIs would be more efficient in processing your raw data rather than doing it in JavaScript code.
(last updated on 8-May-2021)