Was ist ein regionales Netz?

** Regionales Netz ** ist ein Netz, das basierend auf Breite und Länge fast die gleiche Form wie die Region hat. Ein Netz ist ungefähr quadratisch und in verschiedenen Größen definiert. Um die Dinge zusammenzufassen, die Sie häufig verwenden,

** Primärnetz **: Ca. 80 km auf einer Seite.
** Sekundärnetz **: Ca. 10 km auf einer Seite. Das Primärnetz ist vertikal und horizontal in 8 Teile unterteilt.
** Tertiärnetz **: Ca. 1 km an einer Seite. Das Sekundärnetz ist vertikal und horizontal in 10 Teile unterteilt.
** 4. Masche **: Ca. 500 m auf einer Seite. 3. Masche vertikal und horizontal in 2 Teile geteilt.
** 5. Masche **: Ca. 250 m auf einer Seite. 4. Masche vertikal und horizontal in 2 Teile geteilt.

Referenz: Statistikamt, Ministerium für innere Angelegenheiten und Kommunikation | Regionale Netzstatistik

Das Codesystem ist für das Netz festgelegt und es ist möglich, aus dem Breiten- und Längengrad zu berechnen (Referenz: Standardnetzsystem und Code). .. Die Definition jedes Netzcodes wird jedoch auch als Daten bereitgestellt (e-Stat | Statistik auf Karte (Statistisches GIS). -search? page = 1 & type = 2)). In diesem Artikel möchte ich verstehen, wie ich damit das regionale Netz visualisiere.

Softwarebibliothek

Python (Anaconda / Miniconda-Distribution) wird verwendet. Die erforderlichen Bibliotheken können mit dem folgenden Befehl installiert werden.

conda install -c conda-forge jupyter geopandas descartes shapely \
  matplotlib pip requests pillow chardet mplleaflet && \
  pip install tilemapbase

Die folgenden Bibliotheken sind für diesen Zweck charakteristisch.

Geopandas: Wird zur Verarbeitung von Geoinformationsdaten verwendet
mplleaflet: Zeichnen Sie auf einer interaktiven Karte
tilemapbase: Zeichnen Sie auf einer statischen Karte

Daten bekommen

Dieses Mal werden wir die Daten des primären Netzes 5339 verwenden. Die Datei kann direkt von diesem Link oder heruntergeladen werden Laden Sie die Formdatei "M5339" von der Seite e-Stat herunter. Ich werde. Da es sich um eine Zip-Datei handelt, erweitern Sie sie. Wenn sie die folgende Struktur aufweist, ist sie bereit.

└── QDDSWQ5339
    ├── MESH05339.dbf
    ├── MESH05339.prj
    ├── MESH05339.shp
    └── MESH05339.shx

Daten lesen

Das Laden von Formdateien ist mit der Geopandas-Bibliothek sehr einfach.

import geopandas as gpd

x = gpd.read_file("QDDSWQ5339/MESH05339.shp")
print(x.shape)
x.head()

(100800, 8)
     KEY_CODE MESH1_ID MESH2_ID MESH3_ID MESH4_ID MESH5_ID  OBJ_ID  \
0  5339000011     5339       00       00        1        1       1   
1  5339000012     5339       00       00        1        2       2   
2  5339000013     5339       00       00        1        3       3   
3  5339000014     5339       00       00        1        4       4   
4  5339000021     5339       00       00        2        1       5   

                                            geometry  
0  POLYGON ((139.00312 35.33333, 139.00000 35.333...  
1  POLYGON ((139.00625 35.33333, 139.00312 35.333...  
2  POLYGON ((139.00312 35.33542, 139.00000 35.335...  
3  POLYGON ((139.00625 35.33542, 139.00312 35.335...  
4  POLYGON ((139.00937 35.33333, 139.00625 35.333...

Die Daten enthalten alle Netze 5. Ordnung, beginnend mit 5339. --KEYCODE: Der gesamte Code des Netzes --MESHX_ID: Code des X. Netzteils. KEY_CODE ist eine Kombination davon vom 1. bis zum 5. Platz. --OBJ_ID: Zeilennummer hat keine besondere Bedeutung (glaube ich) --geometry: Geografische Informationen des Netzes. Als Polygon definiert.

Aggregation von Polygonen

Da die Daten diesmal beispielsweise die Daten des Netzes 5. Ordnung sind, ist das gesamte Netz "5339" 1. Ordnung selbst nirgendwo definiert. Für grobe Maschen kann es durch Aggregieren von Polygonen 5. Ordnung erhalten werden. Hierfür ist die Methode "Auflösen" von "Geopandas.GeoDataFrame" hilfreich.

Die folgende Funktion aggregiert die Daten des Netzes 5. Ordnung zu den Daten niedrigerer Ordnung.

def aggregate_mesh(x, level):
    tmp = x.copy()
    code_len = [4, 6, 8, 9, 10][level-1]
    tmp["key"] = tmp["KEY_CODE"].str.slice(0, code_len)
    tmp = tmp[["key", "geometry"]]
    tmp = tmp.dissolve(by="key")
    return tmp

--code_len: Codelänge mit angegebener Granularität

Geben Sie den in tmp [" key "] angegebenen Granularitätscode an
Polygone mit ".dissolve" zusammenfassen --. Dissolve nimmt eine Summe für geografische Informationen. Ich habe es diesmal nicht verwendet, aber wenn es andere Spalten gibt, werden gleichzeitig Berechnungen wie "groupby.aggregate" ausgeführt.

# aggregate to mesh level 1
mesh1 = aggregate_mesh(x, 1)
mesh1

      geometry
key                                                    
5339  POLYGON ((139.29062 35.33333, 139.28750 35.333...

Dies ist das Ergebnis der Aggregation in das primäre Netz. Dieses Mal wird nur das primäre Netz von "5339" verwendet, sodass es zu einer Zeile zusammengefasst wird.

Visualisierung von geografischen Netzinformationen (interaktive Karte)

Das Modul "geopandas.plotting" bietet nützliche Funktionen zur Visualisierung von geografischen Informationen. Insbesondere für Polygone ist plot_polygon_collection nützlich. Es ist buchstäblich eine Funktion, die mehrere Polygone visualisiert.

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
plot_polygon_collection(ax, mesh1.geometry, edgecolor="#121212", facecolor="#333333")

Geben Sie das Zeichnungsziel ("Achsen" von "matplotlib") mit dem ersten Argument von "plot_polygon_collection" an. Erstellen Sie also eine "Achse" aus der Funktion "pyplot.subplots".
Das zweite Argument ist "geopandas.GeoSeries"

Das Ergebnis ist ein Diagramm wie oben. Ich weiß nicht wo es ist. Verwenden Sie die Bibliothek "mplleaflet", um dies auf einer Karte zu zeichnen. Diese Bibliothek bietet die Möglichkeit, Matplotlib-Diagramme auf einer interaktiven Karte zu zeichnen.

import mplleaflet

mplleaflet.display(fig)  #Für Jupiter
# mplleaflet.show(fig)   #Andere

Bei Ausführung mit Jupyter wird die Karte wie oben gezeigt in der Ausgabe angezeigt. Es kann wie eine normale Karten-App vergrößert und verschoben werden. Wenn Sie ".show" verwenden, wird eine andere Seite des Browsers geöffnet und eine ähnliche Karte wird dort angezeigt.

Sie können sehen, dass das "5339" -Netz ein Netz ist, das einen Teil der südlichen Kanto-Region von Tokio aus umfasst. Der Grund, warum es nicht genau quadratisch ist, liegt wahrscheinlich darin, dass das Netz 5. Ordnung des Meeresteils nicht definiert ist.

In ähnlicher Weise zeigen wir das sekundäre Netz an.

mesh2 = aggregate_mesh(x, 2)

fig, ax = plt.subplots()
plot_polygon_collection(ax, mesh2.geometry, edgecolor="#121212", facecolor="#333333")
mplleaflet.display(fig)

Visualisierung von geografischen Netzinformationen (statische Karte)

Während "mplleaflet" eine sehr nützliche Funktion ist, hat es auch einige Schwächen.

―― Je mehr Sie planen, desto schwerer wird es.

Derzeit werden keine Zeichenzeichen unterstützt.

In Bezug auf das erste ist es beispielsweise schwierig zu zeichnen, wenn Sie Tausende bis 10.000 Streudiagramme angeben. Versuchen Sie alternativ, auf einer statischen Karte zu zeichnen. Es scheint einige Optionen zu geben, aber wir werden die Bibliothek TileMapBase verwenden. Dieses Paket nimmt eine OpenStreetMap-Karte als Bild und zeichnet sie im Hintergrund. Sie können die Funktionen von matplotlib frei verwenden, indem Sie die Zeichnung darüber legen. Die Schwäche ist, dass die Syntax nicht so einfach wie "mplleaflet" ist und die Koordinatenkonvertierung vom Benutzer durchgeführt werden muss.

Es wird etwas länger dauern, aber es ist eine Funktion, die ein Polygon auf der Karte und eine Zeichenfolge in der Mitte zeichnet.

import tilemapbase
tilemapbase.init(create=True)

from shapely import geometry

def plot_on_map_with_text(geoseries, texts):
    # find the graph range
    rect = geoseries.total_bounds
    edgex = rect[2] - rect[0]
    edgey = rect[3] - rect[1]
    extent = tilemapbase.Extent.from_lonlat(
        rect[0]-edgex*0.3, rect[2]+edgex*0.3,
        rect[1]-edgey*0.3, rect[3]+edgey*0.3)
    extent = extent.to_aspect(1.0)

    fig, ax = plt.subplots(figsize=(8, 8), dpi=100)
    ax.xaxis.set_visible(False)
    ax.yaxis.set_visible(False)
    
    t = tilemapbase.tiles.build_OSM()
    plotter = tilemapbase.Plotter(extent, t, width=600)
    plotter.plot(ax, t)

    polygons = []
    centers = []
    bounds = geoseries.bounds
    for i in range(len(bounds)):
        # convert to the plottable scale
        minx, miny = tilemapbase.project(bounds['minx'][i], bounds['miny'][i])
        maxx, maxy = tilemapbase.project(bounds['maxx'][i], bounds['maxy'][i])
        polygons.append(
            geometry.box(minx, miny, maxx, maxy))
        centers.append([(minx + maxx)/2.0, (miny + maxy)/2.0])

    polygons = gpd.GeoSeries(polygons)
    plot_polygon_collection(ax, polygons,
                            edgecolor='#121212', facecolor='#000000', alpha=0.4)
    for center, txt in zip(centers, texts):
        ax.text(center[0], center[1], txt, fontdict={'color':'lightblue'})
    return fig, ax

--tilemapbase.init muss vor der Verwendung einmal ausgeführt werden und erstellt einen Cache des erfassten Kartenbilds, um zu vermeiden, dass dieselben Informationen wiederholt abgerufen werden. Es scheint eine Überlegung zu sein, OpenStreetMap nicht durch wiederholten Zugriff zu stören. --shapely ist eine Bibliothek, die die Funktionen grundlegender Elemente geografischer Informationen wie Polygone bereitstellt, und geopandas hängt auch davon ab. Hier wird das Polygon neu definiert, dessen Koordinatensystem konvertiert wurde.

Zeichnen Sie das quadratische Netz mit den letzten beiden Ziffern des Codes.

plot_on_map_with_text(mesh2.geometry, mesh2.index.str.slice(4, 6))

Wenn Sie sich das ansehen, sehen Sie die Regeln des Netzcodes. Mit dem südwestlichen Ende als "(0, 0)" erhöht sich die erste Zahl, wenn Sie nach Norden gehen, und die zweite Zahl, wenn Sie nach Osten gehen. Das sekundäre Netz teilt das primäre Netz in acht, sodass Zahlen von 0 bis 7 angezeigt werden.

Sie können nach der 3. Bestellung auf die gleiche Weise zeichnen. Das Diagramm ist jedoch zu detailliert. Beschränken Sie es daher auf einen bestimmten Bereich.

mesh3 = aggregate_mesh(x[x.MESH2_ID == "45"], 3)
plot_on_map_with_text(mesh3.geometry, mesh3.index.str.slice(6, 8))

Die Regeln des Codes haben sich nicht geändert und diesmal ist er in 10 unterteilt.

mesh4 = aggregate_mesh(x[(x.MESH2_ID == "45") & (x.MESH3_ID == "09")], 4)
plot_on_map_with_text(mesh4.geometry, mesh4.index.str.slice(8, 9))

Das quaternäre Netz unterteilt das quaternäre Netz vertikal und horizontal in zwei Teile und weist dem Südwesten, Südosten, Nordwesten und Nordosten jeweils 1, 2, 3 und 4 Codes zu.

mesh5 = aggregate_mesh(x[(x.MESH2_ID == "45") & (x.MESH3_ID == "09")], 5)
plot_on_map_with_text(mesh5.geometry, mesh5.index.str.slice(8, 10))

Die vier quaternären Netze werden in fünf unterteilt und angezeigt. Die Codierungsregeln für das 5. Netz sind dieselben wie für das 4. Netz.

[PYTHON] Visualisieren und verstehen Sie Japans regionales Netz auf einer Karte