Capture intégré carte google image avec Python sans l'aide d'un navigateur

Plutôt que d'essayer d'utiliser le lien encastré, vous devriez aller directement à l'API de Google pour obtenir des images comme statique graphique. Voici le lien vers le Google Maps image statique de l'API - on dirait que vous pouvez juste passer en long/lat paramètres dans l'URL comme vous le faites pour la normale intégrable. Par exemple:

http://maps.googleapis.com/maps/api/staticmap?center=-30.027489,-51.229248&size=600x600&zoom=14&sensor=false

vous donne un 600x600 au niveau de la rue aperçu centrée sur les coordonnées que vous donnez ci-dessus, qui semble être de Porto Alegre, au Brésil. Maintenant, vous pouvez utiliser urlopen et PIL que Nie suggère:

from cStringIO import StringIO
import Image
import urllib
url = "http://maps.googleapis.com/maps/api/staticmap?center=-30.027489,-51.229248&size=800x800&zoom=14&sensor=false"
buffer = StringIO(urllib.urlopen(url).read())
image = Image.open(buffer)

OriginalL'auteur Daniel Roseman

Basé sur l'excellente réponse de heltonbiker avec des changements de BenElgar, voici un code mis à jour pour Python 3 et l'ajout de la clé de l'API d'accès, l'espérance de son utilité pour quelqu'un:

"""
Stitch together Google Maps images from lat, long coordinates
Based on work by heltonbiker and BenElgar
Changes: 
* updated for Python 3
* added Google Maps API key (compliance with T&C, although can set to None)
* handle http request exceptions
"""
import requests
from io import BytesIO
from math import log, exp, tan, atan, pi, ceil
from PIL import Image
import sys
EARTH_RADIUS = 6378137
EQUATOR_CIRCUMFERENCE = 2 * pi * EARTH_RADIUS
INITIAL_RESOLUTION = EQUATOR_CIRCUMFERENCE / 256.0
ORIGIN_SHIFT = EQUATOR_CIRCUMFERENCE / 2.0
GOOGLE_MAPS_API_KEY = None  # set to 'your_API_key'
def latlontopixels(lat, lon, zoom):
mx = (lon * ORIGIN_SHIFT) / 180.0
my = log(tan((90 + lat) * pi/360.0))/(pi/180.0)
my = (my * ORIGIN_SHIFT) /180.0
res = INITIAL_RESOLUTION / (2**zoom)
px = (mx + ORIGIN_SHIFT) / res
py = (my + ORIGIN_SHIFT) / res
return px, py
def pixelstolatlon(px, py, zoom):
res = INITIAL_RESOLUTION / (2**zoom)
mx = px * res - ORIGIN_SHIFT
my = py * res - ORIGIN_SHIFT
lat = (my / ORIGIN_SHIFT) * 180.0
lat = 180 / pi * (2*atan(exp(lat*pi/180.0)) - pi/2.0)
lon = (mx / ORIGIN_SHIFT) * 180.0
return lat, lon
def get_maps_image(NW_lat_long, SE_lat_long, zoom=18):
ullat, ullon = NW_lat_long
lrlat, lrlon = SE_lat_long
# Set some important parameters
scale = 1
maxsize = 640
# convert all these coordinates to pixels
ulx, uly = latlontopixels(ullat, ullon, zoom)
lrx, lry = latlontopixels(lrlat, lrlon, zoom)
# calculate total pixel dimensions of final image
dx, dy = lrx - ulx, uly - lry
# calculate rows and columns
cols, rows = int(ceil(dx/maxsize)), int(ceil(dy/maxsize))
# calculate pixel dimensions of each small image
bottom = 120
largura = int(ceil(dx/cols))
altura = int(ceil(dy/rows))
alturaplus = altura + bottom
# assemble the image from stitched
final = Image.new("RGB", (int(dx), int(dy)))
for x in range(cols):
for y in range(rows):
dxn = largura * (0.5 + x)
dyn = altura * (0.5 + y)
latn, lonn = pixelstolatlon(ulx + dxn, uly - dyn - bottom/2, zoom)
position = ','.join((str(latn), str(lonn)))
print(x, y, position)
urlparams = {'center': position,
'zoom': str(zoom),
'size': '%dx%d' % (largura, alturaplus),
'maptype': 'satellite',
'sensor': 'false',
'scale': scale}
if GOOGLE_MAPS_API_KEY is not None:
urlparams['key'] = GOOGLE_MAPS_API_KEY
url = 'http://maps.google.com/maps/api/staticmap'
try:                  
response = requests.get(url, params=urlparams)
response.raise_for_status()
except requests.exceptions.RequestException as e:
print(e)
sys.exit(1)
im = Image.open(BytesIO(response.content))                  
final.paste(im, (int(x*largura), int(y*altura)))
return final
############################################
if __name__ == '__main__':
# a neighbourhood in Lajeado, Brazil:
NW_lat_long =  (-29.44,-52.0)
SE_lat_long = (-29.45,-51.98)
zoom = 18   # be careful not to get too many images!
result = get_maps_image(NW_lat_long, SE_lat_long, zoom=18)
result.show()

OriginalL'auteur 4Oh4

@4Oh4 la réponse est juste, mais les maths sont plus compliquées qu'elles ne devraient l'être. Les Conversions entre les degrés et les radians passe plus souvent qu'ils en ont besoin. Du rayon de la Terre est appelé pour aucune raison du tout—il annule dans tous les calculs. Un décalage est ajouté au pixel de coordonnées pour aucune raison du tout. Le logo de coupure est plus grand qu'il ne devrait l'être. Et quelques autres bricoles qui ont été écrits dans les changements. Voici ma version:

#!/usr/bin/env python
"""
Stitch together Google Maps images from lat, long coordinates
Based on work by heltonbiker and BenElgar
Changes: 
* updated for Python 3
* added Google Maps API key (compliance with T&C, although can set to None)
* handle http request exceptions
With contributions from Eric Toombs.
Changes:
* Dramatically simplified the maths.
* Set a more reasonable default logo cutoff.
* Added global constants for logo cutoff and max image size.
* Translated a couple presumably Portuguese variable names to English.
"""
import requests
from io import BytesIO
from math import log, exp, tan, atan, ceil
from PIL import Image
import sys
# circumference/radius
tau = 6.283185307179586
# One degree in radians, i.e. in the units the machine uses to store angle,
# which is always radians. For converting to and from degrees. See code for
# usage demonstration.
DEGREE = tau/360
ZOOM_OFFSET = 8
GOOGLE_MAPS_API_KEY = None  # set to 'your_API_key'
# Max width or height of a single image grabbed from Google.
MAXSIZE = 640
# For cutting off the logos at the bottom of each of the grabbed images.  The
# logo height in pixels is assumed to be less than this amount.
LOGO_CUTOFF = 32
def latlon2pixels(lat, lon, zoom):
mx = lon
my = log(tan((lat + tau/4)/2))
res = 2**(zoom + ZOOM_OFFSET) / tau
px = mx*res
py = my*res
return px, py
def pixels2latlon(px, py, zoom):
res = 2**(zoom + ZOOM_OFFSET) / tau
mx = px/res
my = py/res
lon = mx
lat = 2*atan(exp(my)) - tau/4
return lat, lon
def get_maps_image(NW_lat_long, SE_lat_long, zoom=18):
ullat, ullon = NW_lat_long
lrlat, lrlon = SE_lat_long
# convert all these coordinates to pixels
ulx, uly = latlon2pixels(ullat, ullon, zoom)
lrx, lry = latlon2pixels(lrlat, lrlon, zoom)
# calculate total pixel dimensions of final image
dx, dy = lrx - ulx, uly - lry
# calculate rows and columns
cols, rows = ceil(dx/MAXSIZE), ceil(dy/MAXSIZE)
# calculate pixel dimensions of each small image
width = ceil(dx/cols)
height = ceil(dy/rows)
heightplus = height + LOGO_CUTOFF
# assemble the image from stitched
final = Image.new('RGB', (int(dx), int(dy)))
for x in range(cols):
for y in range(rows):
dxn = width * (0.5 + x)
dyn = height * (0.5 + y)
latn, lonn = pixels2latlon(
ulx + dxn, uly - dyn - LOGO_CUTOFF/2, zoom)
position = ','.join((str(latn/DEGREE), str(lonn/DEGREE)))
print(x, y, position)
urlparams = {
'center': position,
'zoom': str(zoom),
'size': '%dx%d' % (width, heightplus),
'maptype': 'satellite',
'sensor': 'false',
'scale': 1
}
if GOOGLE_MAPS_API_KEY is not None:
urlparams['key'] = GOOGLE_MAPS_API_KEY
url = 'http://maps.google.com/maps/api/staticmap'
try:                  
response = requests.get(url, params=urlparams)
response.raise_for_status()
except requests.exceptions.RequestException as e:
print(e)
sys.exit(1)
im = Image.open(BytesIO(response.content))                  
final.paste(im, (int(x*width), int(y*height)))
return final
############################################
if __name__ == '__main__':
# a neighbourhood in Lajeado, Brazil:
NW_lat_long =  (-29.44*DEGREE, -52.0*DEGREE)
SE_lat_long = (-29.45*DEGREE, -51.98*DEGREE)
zoom = 18   # be careful not to get too many images!
result = get_maps_image(NW_lat_long, SE_lat_long, zoom=18)
result.show()

OriginalL'auteur enigmaticPhysicist

urllib.urlopen va ouvrir une URL, le résultat aura un .read() méthode que vous pouvez utiliser pour obtenir l'image en octets. cStringIO a un fichier comme objet basé sur une chaîne de caractères en mémoire. PIL a un Image.open fonction qui ouvre un fichier de vous donner une image de l'objet. Les objets de l'Image peuvent être interrogés à propos de leurs valeurs de pixel.

OriginalL'auteur Ned Batchelder