Versuchen Sie, Google Map und Geography Map mit Python anzuzeigen

Motivation

Ich habe meine eigene (absichtliche) Python-Anwendung, die ich erstellen möchte. Zu diesem Zweck ist es besser, eine Karte anzuzeigen. Es ist wie eine Studie dafür. Ich hoffe es hilft jemandem.

Referenzierte Methoden und Sites usw.

Es scheint eine Möglichkeit zu geben, Openstreetmap- und Basiskartenmodul, Folium, SHP-Datei und GIS-Software zu verwenden, aber ich schien es nicht schwierig oder für mich geeignet zu finden. Immerhin habe ich die Google Static Map API überprüft und mich für Google Map entschieden, da dies einfacher war als erwartet und das Luftbild meinem Zweck entspricht. Es scheint, dass die Karte des Geografischen Instituts auf die gleiche Weise behandelt werden kann, also ist es wie ...

In Bezug auf die Umrechnung zwischen Breiten- / Längengrad und Web-Mercator-Projektion TRAIL NOTE war die Erklärung des Autors leicht zu verstehen. Es gibt einige Dinge, die ich über die Koordinatenkonvertierung usw. nicht vollständig verstanden habe, aber dieser Punkt kann im Verlauf der Entwicklung offensichtlich werden.

Einfache Spezifikationen

• Ich habe den Betrieb mit Win10 / 32bit Anacondas Spyder und einer etwas früheren Version von Raspian Jessie überprüft.
• Betreibt und zeigt sowohl auf PC-Bildschirmen als auch auf Bildschirmen mit niedriger Auflösung für Himbeer-Pi an --Die online angezeigten Kacheln können als Datei gespeichert und offline angezeigt werden.
• Derzeit ist die Anzeige openCV. Dies hat gerade die Methode übernommen, die ich im Moment verstehe. Es verbindet, schneidet, zeigt, speichert und öffnet Kacheln wieder. Derzeit ist die Bildverarbeitung nichts Besonderes. Für die OpenCV-Installation
• Für Windows hier
• In raspberrypi habe ich versucht, opencv3 + python3.x zu verwenden, indem ich auf hier verwiesen habe, aber ich habe aufgegeben, weil die 8G-Festplatte nicht ausreichte. Es scheint, dass die Verwendung von urllib anders ist, daher wird ein Teil des Codes neu geschrieben und funktioniert mit opncv2 + python2
• Derzeit nur Tastaturbedienung ---: Schrumpfen, +: Vergrößern, a, s, d, f: Nach Westen, Norden, Süden bzw. Osten bewegen --Space, Backspace: Kartentyp wechseln (Google Hybrid → Google Luftbild → Google Road Map → Standardkarte des Geographical Institute →…) ――Es bedarf einiger Vorbereitungen, um es tatsächlich zu bedienen. Grabe ein Verzeichnis zum Speichern von Kacheln

import os
os.mkdir("maptiles")
for d in range(22):
    os.mkdir("maptiles/z%02d"%d)

Code

Wenn man es so betrachtet, kann es Akan sein, einen langen Slapstick darauf zu legen ... Ich werde in zukünftigen Beiträgen vorsichtig sein.

AMAP.py

# -*- coding: utf-8 -*-

import numpy as np
import cv2
import urllib
import os

#WIN_W=480
#WIN_H=260
WIN_W=1280
WIN_H=960

# gg*:googleMap,  other:cyberjapandata:Nationales Landforschungsinstitut
map_type_name = ["gghybrid","ggsatellite","ggroadmap", "std","ort_old10","gazo1","seamlessphoto"]
TILE_W = [640,640,640,256,256,256,256]
TILE_H = [640,640,640,256,256,256,256]
min_zoom=[ 0, 0, 0, 2,10,10, 2]
max_zoom=[21,21,21,18,17,17,18]
fmt=["png","png","png", "png", "png","jpg","jpg"]

#Sie können verschiedene Karten anzeigen, indem Sie die Tabellendefinition ändern
##ort:2007-, airphoto:2004-, gazo4:1988-1990, gazo3:1984-1986, gazo2:1979-1983, gazo1:1974-1978
##ort_old10:1961-1964, ort_USA10:1945-1950
#map_type_name = ["ort","airphoto","gazo4","gazo3","gazo2","gazo1","ort_old10","ort_USA10"]
#TILE_W = [256,256,256,256,256,256,256,256]
#TILE_H = [256,256,256,256,256,256,256,256]
#min_zoom=[14, 5,10,10,10,10,10,10]
#max_zoom=[18,18,17,17,17,17,17,17]
#fmt=["jpg","png","jpg","jpg","jpg","jpg","png","png"]

#Tokyo Station
HOME_LON=139.767052
HOME_LAT= 35.681167
HOME_ZOOM=18

TILES_DIR="maptiles/"

max_pixels= [256*2**zm for zm in range(22)]

#Ein Wörterbuch, in dem Verweise auf geöffnete Kacheln gespeichert sind. Eingeschrieben nach Kartentyp, Zoom, Index x, Index y
opened_tiles={}
white_tiles={}

#lon:Längengrad, lat:Breite
def ll2pix(lon, lat, zoom):
    pix_x=2**(zoom+7)*(lon/180+1)
    pix_y=2**(zoom+7)*(-np.arctanh(np.sin(np.pi/180*lat))/np.pi+1)
    return pix_x,pix_y

def pix2ll(x,y,zoom):
    lon=180*(x/(2**(zoom+7))-1)
    lat=180/np.pi*(np.arcsin(np.tanh(-np.pi/(2**(zoom+7))*y+np.pi)))
    return lon, lat

#Von Längen- / Breitengrad dx,dy Gibt den Längen- / Breitengrad zurück, wenn Pixel verschoben werden
def new_ll(lon_cur,lat_cur,zm, dx,dy):
    x,y=ll2pix(lon_cur,lat_cur,zm)
    return pix2ll(x+dx,y+dy,zm)

def dddmm2f(dddmm_mmmm):
    #12345.6789 ->123 Grad 45.6789 Minuten->123 Grad.(45.6789/60)
    ddd=int(dddmm_mmmm)//100
    mm_mmmm=dddmm_mmmm-ddd*100
    return ddd+mm_mmmm/60

#Verketten Sie Kacheln, um ein Bild zu erstellen, das größer als das Anzeigefenster ist, und schneiden Sie es schließlich auf die Fenstergröße zu und geben Sie es zurück
def load_win_img(mtype, lon,lat,zm):
    cx,cy=ll2pix(lon,lat,zm)
    
    win_left=int(cx-WIN_W/2)
    win_top=int(cy-WIN_H/2)
    
    x_nth=win_left//TILE_W[mtype]
    y_nth=win_top//TILE_H[mtype]
    
    left_offset = win_left%TILE_W[mtype]
    top_offset = win_top%TILE_H[mtype]
    
    vcon_list=[]
    tot_height=0
    tot_height += TILE_H[mtype]-top_offset
    j=0
    while True:
        hcon_list=[]
        tot_width=0
        tot_width += TILE_W[mtype]-left_offset
        i=0
        while True:
            img_tmp=open_tile_img(mtype, x_nth+i,y_nth+j,zm)
            hcon_list.append(img_tmp) #
            if tot_width >= WIN_W:
                break
            tot_width += TILE_W[mtype]
            i+=1
        hcon_img=cv2.hconcat(hcon_list)
        vcon_list.append(hcon_img)
        if tot_height >= WIN_H:
            break
        tot_height += TILE_H[mtype]
        j+=1
    convined_img=cv2.vconcat(vcon_list)

    return convined_img[top_offset:top_offset+WIN_H, left_offset:left_offset+WIN_W, :]

def tile_file_name(mtype, x_nth,y_nth,zm):
#    x_nth=x//TILE_W[mtype]
#    y_nth=y//TILE_H[mtype]
    return TILES_DIR+"z%02d/%s_z%02d_%dx%d_%07d_%07d"%(zm,map_type_name[mtype],zm,TILE_W[mtype],TILE_H[mtype],x_nth,y_nth)+"."+fmt[mtype]

#Kachel öffnen
#Ein Punkt, der nie geöffnet wurde->Versuchen Sie herunterzuladen / zu speichern. Wenn dies fehlschlägt, wird ein weiß getünchtes Bild zurückgegeben. Wenn dies erfolgreich ist, registrieren Sie den Punkt- / Zoom- / Kartentyp im Wörterbuch und markieren Sie ihn als danach geöffnet.
#In Datei gespeichert, aber nicht geöffnet->Normal öffnen. Registrieren Sie sich auch im Wörterbuch
#Bereits geöffnet->Gibt das im Wörterbuch registrierte Bild zurück
def open_tile_img(mtype, x_nth,y_nth,zm):
    if (mtype, zm,x_nth,y_nth) in opened_tiles:
        print("opened_tiles(%d,%d,%d,%d)"%(mtype, zm,x_nth,y_nth))
        return opened_tiles[(mtype, zm,x_nth,y_nth)]
    
    fname=tile_file_name(mtype, x_nth,y_nth,zm)
    if os.path.exists(fname):
        print("opening tile(%d,%d,%d,%d)"%(mtype,zm,x_nth,y_nth) +" -> "+fname)
    else:
        c_lon,c_lat=pix2ll((x_nth+0.5)*TILE_W[mtype],(y_nth+0.5)*TILE_H[mtype],zm)
        if map_type_name[mtype][0:2]=="gg":
            url="http://maps.google.com/maps/api/staticmap?"
            url+="&center=%.08f,%08f&zoom=%d&size=%dx%d&maptype=%s" % \
            (c_lat,c_lon,zm,TILE_W[mtype],TILE_H[mtype],map_type_name[mtype][2:])
        #maptype
        #Roadmap Normale Karte. Standardwert für den Parameter maptype
        #Satellitenluftaufnahme
        #Gelände Physisches Geländekartenbild, das Gelände und Vegetation zeigt
        #Hybrid-Luftbild + normale Karte. Überlagern von Hauptstraßen und Ortsnamen auf Luftbildern
        else:
            url="http://cyberjapandata.gsi.go.jp/xyz/%s/%d/%d/%d.%s"%(map_type_name[mtype],zm,x_nth,y_nth,fmt[mtype])
        print("Downloading... ")
        print(url)
        print(" -> "+fname)
        try:
            urllib.request.urlretrieve(url,fname) #python3
#            urllib.urlretrieve(url,fname) #python2
        except Exception as e:
            #Wenn die Kachel nicht erhalten werden kann, wird das in Weiß ausgefüllte Bild zurückgegeben.
            print(e)
            print("Download faild -> blank")
            if (TILE_W[mtype],TILE_H[mtype]) in white_tiles:
                return white_tiles[(TILE_W[mtype],TILE_H[mtype])]
            else:
                white=np.zeros([TILE_H[mtype],TILE_W[mtype],3],dtype=np.uint8)
                white[:,:,:]=255
                white_tiles[(TILE_W[mtype],TILE_H[mtype])]=white
                return white
    opened_tiles[(mtype, zm,x_nth,y_nth)]=cv2.imread(fname)
    return opened_tiles[(mtype, zm,x_nth,y_nth)]


if __name__ == '__main__':
    map_type=0
    c_lon=HOME_LON
    c_lat=HOME_LAT
    zoom=HOME_ZOOM
    cv2.namedWindow("Ackerman's Map", cv2.WINDOW_AUTOSIZE)

    map_type_bak = -1
    c_lon_bak = -1
    c_lat_bak = -1
    zoom_bak = -1
    
    #mainloop
    while (True):
        if map_type_bak != map_type or c_lon_bak != c_lon or c_lat_bak != c_lat or zoom_bak != zoom:
            win_img=load_win_img(map_type, c_lon,c_lat,zoom)
            cv2.imshow("Ackerman's Map", win_img)
        map_type_bak = map_type
        c_lon_bak = c_lon
        c_lat_bak = c_lat
        zoom_bak = zoom

        k=cv2.waitKey(0) & 0xff  #Wählen Sie beim Hinzufügen der GPS-Funktion ab, ohne die Wartezeit auf 0 zu setzen
        print("pressed:"+str(k))
        if k == ord('+'):
            if zoom<max_zoom[map_type]: 
                zoom += 1
        elif k == ord('-'):
            if zoom>min_zoom[map_type]: 
                zoom -= 1
        elif k == ord('a'):
            c_lon,c_lat=new_ll(c_lon,c_lat,zoom,-WIN_W/4,0)
        elif k == ord('s'):
            c_lon,c_lat=new_ll(c_lon,c_lat,zoom,0,-WIN_H/4)
        elif k == ord('d'):
            c_lon,c_lat=new_ll(c_lon,c_lat,zoom,0,+WIN_H/4)
        elif k == ord('f'):
            c_lon,c_lat=new_ll(c_lon,c_lat,zoom,+WIN_W/4,0)
        elif k == 32:
            #space key
            map_type = (map_type+1)%len(map_type_name)
            if zoom > max_zoom[map_type]:
                zoom=max_zoom[map_type]
            if zoom < min_zoom[map_type]:
                zoom=min_zoom[map_type]
        elif k == 8:
            #Backspace
            map_type = (map_type-1)%len(map_type_name)
            if zoom > max_zoom[map_type]:
                zoom=max_zoom[map_type]
            if zoom < min_zoom[map_type]:
                zoom=min_zoom[map_type]
        elif k == ord("q"):
            break
    cv2.destroyAllWindows()

Eindrücke von Herstellung und Nutzung und zukünftige Expansion

Für eine Weile habe ich das Beispiel des Einführungsbuchs von Himbeerpi nachgezeichnet und das Programm von Zeit zu Zeit geändert und beim Lesen des Einführungsbuchs von Python3 einen kurzen Code ausprobiert, aber ich frage mich, warum ich es zum ersten Mal von Grund auf neu geschrieben habe. Ich habe vor mehr als 15 Jahren hauptsächlich in C-Sprache programmiert, aber im Vergleich zu dieser Situation ist es eine Liste, ein Wörterbuch, eine inklusive Notation und der Himmel. Was ist der Nutzen von assoziativen Arrays (≒ Wörterbüchern) in anderen Sprachen? Ich habe nachgedacht, aber ich habe das Gefühl, dass ich es hier effektiv nutzen konnte.

Interessant ist auch die Karte des Geografischen Instituts, die als Randnotiz angezeigt wurde. „Hast du vor 50 Jahren hier gelebt?" „Wow, dieses mysteriöse Gebäude existiert seit mehr als 30 Jahren ?!" Im Code

#Tokyo Station
HOME_LON=139.767052
HOME_LAT= 35.681167

Es kann interessant sein, das Gebiet um das Gebiet auf den Breiten- und Längengrad Ihres Wohnsitzes zu ändern und einen Spaziergang zu machen, während Sie die Karte wechseln.

Schließen Sie den GNSS-Empfänger an und tun Sie etwas

Ich habe bereits über das Verbinden und Anzeigen meines aktuellen Standorts geschrieben und so etwas wie eine verschlechterte Version von FoxtrotGPS erstellt, die jedoch in einer Zeitschrift veröffentlicht wurde. Ich habe es vorerst nicht gepostet, da der Code ziemlich voll ist. Es ist wie das Entschlüsseln des NMEA-Formats, aber es war einfacher als ich erwartet hatte. Ich habe auch über eine Methode wie die Kommunikation mit gpsd nachgedacht, aber es scheint einfacher zu sein.