Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
147 lines (121 sloc) 5.93 KB
"""Take huge detailed screenshots of Google Maps."""
from datetime import datetime
import os
import time
import tkinter
from PIL import Image
import pyscreenshot
from selenium import webdriver
def create_map(lat_start: float, long_start: float,
number_rows: int, number_cols: int,
scale: float=1, sleep_time: float=0,
offset_left: float=0, offset_top: float=0,
offset_right: float=0, offset_bottom: float=0,
outfile: str=None):
"""Create a big Google Map image from a grid of screenshots.
ARGS:
lat_start: Top-left coodinate to start taking screenshots.
long_start: Top-left coodinate to start taking screenshots.
number_rows: Number of screenshots to take for map.
number_cols: Number of screenshots to take for map.
scale: Percent to scale each image to reduce final resolution
and filesize. Should be a float value between 0 and 1.
Recommend to leave at 1 for production, and between 0.05
and 0.2 for testing.
sleep_time: Seconds to sleep between screenshots.
Needed because Gmaps has some AJAX queries that will make
the image better a few seconds after confirming page load.
Recommend 0 for testing, and 3-5 seconds for production.
offset_*: Percent of each side to crop from screenshots.
Each should be a float value between 0 and 1. Offsets should
account for all unwanted screen elements, including:
taskbars, windows, multiple displays, and Gmaps UI (minimap,
search box, compass/zoom buttons). Defaults are set for an
Ubuntu laptop with left-side taskbar, and will need to be
tuned to the specific machine and setup where it will be run.
outfile: If provided, the program will save the final image to
this filepath. Otherwise, it will be saved in the current
working directory with name 'testimg-<timestamp>.png'
"""
if outfile:
# Make sure the path doesn't exist, is writable, and is a .PNG
assert not os.path.exists(outfile)
assert os.access(os.path.dirname(os.path.abspath(outfile)), os.W_OK)
assert outfile.upper().endswith('.PNG')
driver = webdriver.Firefox()
driver.maximize_window()
# 2D grid of Images to be stitched together
images = [[None for _ in range(number_cols)]
for _ in range(number_rows)]
# Calculate amount to shift lat/long each screenshot
screen_width, screen_height = get_screen_resolution()
lat_shift = calc_latitude_shift(screen_height,
(offset_top + offset_bottom))
long_shift = calc_longitude_shift(screen_width,
(offset_left + offset_right))
for row in range(number_rows):
for col in range(number_cols):
latitude = lat_start + (lat_shift * row)
longitude = long_start + (long_shift * col)
# Show the map using the Firefox driver
url = (
'https://www.google.com/maps/@{lat},{long},18z'
).format(lat=latitude, long=longitude)
driver.get(url)
# Let the map load all assets before taking a screenshot
time.sleep(sleep_time)
image = screenshot(screen_width, screen_height,
offset_left, offset_top,
offset_right, offset_bottom)
# Scale image up or down if desired, then save in memory
images[row][col] = scale_image(image, scale)
driver.close()
driver.quit()
# Combine all the images into one, then save it to disk
final = combine_images(images)
if not outfile:
timestamp = datetime.now().strftime('%Y-%m-%dT%H-%M-%S')
outfile = 'testimg-{}.png'.format(timestamp)
final.save(outfile)
def get_screen_resolution() -> tuple:
"""Return tuple of (width, height) of screen resolution in pixels."""
root = tkinter.Tk()
root.withdraw()
return (root.winfo_screenwidth(), root.winfo_screenheight())
def calc_latitude_shift(screen_height: int, percent_hidden: float) -> float:
"""Return the amount to shift latitude per row of screenshots."""
return -0.000002051 * screen_height * (1 - percent_hidden)
def calc_longitude_shift(screen_width: int, percent_hidden: float) -> float:
"""Return the amount to shift longitude per column of screenshots."""
return 0.00000268 * screen_width * (1 - percent_hidden)
def screenshot(screen_width: int, screen_height: int,
offset_left: float, offset_top: float,
offset_right: float, offset_bottom: float) -> Image:
"""Return a screenshot of only the pure maps area."""
x1 = offset_left * screen_width
y1 = offset_top * screen_height
x2 = (offset_right * -screen_width) + screen_width
y2 = (offset_bottom * -screen_height) + screen_height
image = pyscreenshot.grab(bbox=(x1, y1, x2, y2))
return image
def scale_image(image: Image, scale: float) -> Image:
"""Scale an Image by a proportion, maintaining aspect ratio."""
width = round(image.width * scale)
height = round(image.height * scale)
image.thumbnail((width, height))
return image
def combine_images(images: list) -> Image:
"""Return combined image from a grid of identically-sized images.
images is a 2d list of Image objects. The images should
be already sorted/arranged when provided to this function.
"""
imgwidth = images[0][0].width
imgheight = images[0][0].height
newsize = (imgwidth * len(images[0]), imgheight * len(images))
newimage = Image.new('RGB', newsize)
# Add all the images from the grid to the new, blank image
for rowindex, row in enumerate(images):
for colindex, image in enumerate(row):
location = (colindex * imgwidth, rowindex * imgheight)
newimage.paste(image, location)
return newimage
You can’t perform that action at this time.