Dataviz on Søren's Blog

Electricity Consumption

Tue, 05 Dec 2023 09:00:00 +0100

This fall, we moved into a new apartment. The building is labeled low-energy - „KfW55“ in German. Being a statistics nerd myself, I am curious how this effects our monthly energy consumption compared to the 70 year old building in which we lived before.

First things first: I am aware that I cannot compare the raw consumption rates 1:1. In the old building, heating and warm water were powered by oil and gas. In the new one, things are mainly powered by electricity. I expect the consumption to be higher - but, let’s see.

In the old flat, we used to have an average electricity consumption of ~2.000kWh. The statistics we received from our provider, bucket this just above the average of a single-person household.

In the new flat, the electricity meter currently shows 360kWh. Following a linear progression, we would end up at ~1.500kWh per year - even less than in the old flat and equal to the average consumption of a single person. However, heating period has started and within the first month we lived part-time in the old apartment.

Fingers crossed that we can keep consumption on a low level. Feels good to be on the green side.

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python an Telegram-Kanal senden

Sun, 27 Dec 2020 17:00:00 +0100

Dritter und letzter Teil der Reihe in der ich beschreibe wie ich Daten vom RKI mit Python abziehe, diese mit Plotly grafisch aufbereite und schließlich jeden Morgen in einen Telegram-Kanal sende.

In diesem Artikel schauen wir uns gemeinsam an, wie man einen Telegram-Bot erstellt, diesen einem Kanal hinzufügt und schließlich mit Python Nachrichten verschicken lässt.

Telegram Bot erstellen

Im Gegensatz zu anderen Messengern ist es bei Telegram überaus leicht, eigene Bots zu erstellen. Der BotFather kümmert sich um die technischen Details, ihr müsst ihm lediglich mitteilen wie eurer Bot heißen soll. Beginnt also zunächst einen Chat mit dem Account @BotFather - ihr findet ihn ganz einfach über die Suche.

Mit dem Befehl /newbot kündigt ihr dem BotFather an, dass ihr einen neuen Bot erstellen wollt. Er fragt euch daraufhin, wie euer Bot heißen soll - einmal sprechend, einmal technisch. Der technische Name muss auf bot enden. Wir könnten den Bot also beispielsweise “CoronaBotStuttgart” und “CoronaBotStuttgart_bot” nennen.

Der BotFather nennt euch daraufhin euren API access token. Dieser ist quasi Benutzername und Passwort für euren Bot in einem. Diese Information solltet ihr also unter keinen Umständen aus den Händen geben. Ihr braucht diesen Token gleich, um den Bot von Python aus zu steuern.

Telegram Bot einem Kanal hinzufügen

Jetzt solltet ihr einen neuen Kanal erstellen und euren Bot als Admin hinzufügen. Dazu geht ihr wie folgt vor:

In Telegram klickt auf “New Channel”
Gebt eurem Kanal einen Namen
Entscheidet ob der Kanal öffentlich oder privat sein soll und unter welcher URL er erreichbar sein soll
Fügt euren Bot dem Kanal hinzu (sucht nach dem “sprechenden Namen”)

Der Kanal ist nun erstellt.

Öffnet ihn und klickt oben auf den Namen und wählt “Aministrators” aus.
Befördert euren Bot zum Admin des Kanals. Er braucht lediglich das Recht Nachrichten senden zu können (“Post Messages”). Alle anderen Berechtigungen könnt ihr ihm (wenn ihr wollt) entziehen.

Anschließend könnt ihr eine “Hello World”-Nachricht in den Kanal schreiben.

ChatID herausfinden

Jetzt müssen wir die ChatID eures Kanals herausfinden. Diese benötigen wir (zusammen mit dem access token), um später Nachrichten im Namen eures Bots versenden zu können.

Die ChatID erhaltet ihr, wenn ihr folgende URL öffnet: https://api.telegram.org/bot<access_token>/getUpdates. Natürlich müsst ihr <access_token> mit eurem Token ersetzen. Wichtig ist, dass /bot vor dem Token in der URL erhalten bleibt. Die Ausgabe sollte ungefähr so aussehen:

{"ok":true,"result":[{"update_id":773467236,
"message":{"message_id":550,"from":{"id":343487567,"is_bot":false,"first_name":"Bat","last_name":"Man","username":"wayne123","language_code":"de-DE"}

Die ChatID verbirgt sich in der Nachricht unter "id". Im obigen Fall also "id":343487567. Speichert euch die ChatID ebenfalls sicher ab.

Nachrichten an Telegram-Kanal senden

Nun schreiben wir uns eine Funktion, die mit Hilfe des Access Tokens und der ChatID einen bestimmten Inhalt sendet. Wir übergeben der Funktion drei Parameter:

chatid: Wenn ihr mal was testen wollt schadet es nicht, wenn der Bot auch in einen anderen Chat posten kann.
message_type: Hiermit legen wir fest, ob eine Textnachricht oder ein Bild/Foto versendet werden soll. Je nachdem unterscheidet sich der API-Aufruf.
message_content: Übergibt den Inhalt der Nachricht (Bild oder Text) an die Funktion.
Den Access Token, den ihr vom BotFather erhalten habt, tragt ihr in der ersten Zeile ein.

 1def telegram_bot_send(chatid, message_type, message_content):
 2    # define access token (received from BotFather)
 3    bot_token = '<access_token>'
 4
 5    # translate message_type in API URL
 6    if mtype == 'text':
 7        bot_mtype = '/sendMessage'
 8    elif mtype == 'photo':
 9        bot_mtype = '/sendPhoto'
10
11    # concatenate API URL
12    bot_url = 'https://api.telegram.org/bot' + bot_token + bot_mtype + '?chat_id=' + chatid
13
14    # send message
15    if mtype == 'text':
16        response = requests.get(bot_url + '&parse_mode=Markdown&text=' + content)
17    elif mtype == 'photo':
18        response = requests.post(bot_url, files={'photo': open(content, 'rb')})
19    
20    return response.json()

Damit können wir nun Inhalte über unseren Bot in den entsprechenden Telegram-Kanal senden. Den zuvor erzeugten Plot sowie eine kleine Textnachricht können wir beispielsweise mit den folgenden Befehlen absenden. Der Text muss nicht statisch sein und kann bspw. auch dynamisch aus den Daten erzeugt werden.

 1# send messages to Telegram channel
 2telegram_bot_send(
 3    chatid = '343487567'
 4    message_type = 'photo'
 5    message_content = 'link/to/exported/plot.png'
 6)
 7telegram_bot_send(
 8    chatid = '343487567'
 9    message_type = 'text'
10    message_content = 'Die Indizenz in Stuttgart ist immer noch sehr hoch'
11)

Damit sind wir am Ende dieser kleinen Serie angekommen. Ich hoffe ihr könnt daraus was für eure Projekte ableiten. Schreibt mir gern, wenn es euch weitergeholfen hat oder Probleme auftreten.

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python visualisieren

Sun, 27 Dec 2020 15:00:00 +0100

Im letzten Post hatte ich bereits angekündigt, dass ich aktuell daran arbeite Daten vom RKI mit Python abzuziehen, diese mit Plotly grafisch aufzubereiten und schließlich jeden Morgen in einen Telegram-Kanal zu senden.

Heute werde ich euch zeigen, wie ich die heruntergeladenen Daten mit plotly in Python visualisiere.

Auch dafür bereiten wir zunächst das Skript vor, indem wir die notwendigen Abhängigkeiten laden. Falls euch etwas fehlt, könnt ihr es in der Regel mittels pip install <name> jederzeit installieren.

os und pandas benutzen wir erneut, um die zuvor exportierten Daten einzulesen und entsprechend aufzubereiten
mit plotly.graph_objects werden wir die Visualisierung erzeugen
und kaleido.scopes.plotly hilft uns die eigentlich interaktive Grafik von Plotly als statische Datei zu exportieren

1#imports
2import os
3import pandas as pd
4import plotly.graph_objects as go
5import requests
6
7from kaleido.scopes.plotly import PlotlyScope

Mit der Hilfe von os.path.abspath() defineren wir uns die Arbeitspfade. Gehen wir davon aus, dass sich in dem Verzeichnis, in dem unser Python-Skript liegt, auch die Unterordner data/ und img/ befinden. Aus ersterem wollen wir später die Datei rki.csv laden. In letzteres den fertigen Plot speichern.

Außerdem, sollten wir ein paar Farben festlegen.

1# define working paths
2app_dir = os.path.abspath(os.path.dirname(__file__))
3data_dir = app_dir + '/data/'
4img_dir = app_dir + '/img/'
5
6# define colors
7spaetzle_gelb_light = 'rgb(255,254,249)'
8spaetzle_gelb_dark = 'rgb(145,113,5)'
9light_grey = 'rgb(204, 204, 204)'

Laden wir die CSV-Datei und schränken sie auf den/die für uns relevanten Landkreis/e ein.

1# import as Pandas data frame and restrict to county "Stuttgart"
2rki = pd.read_csv(data_dir + "rki.csv", sep = ";")
3df_str = rki.loc[rki.GEN == "Stuttgart"]
4df_str.head()

Jeder plotly-Plot beginnt mit fig = go.Figure(). An fig werden dann weitere Elemente angefügt.

Beginnen wir damit ein Liniendiagramm hinzuzufügen (add_trace(go.Scatter()))
Dieses soll auf der x-Achse die Zeit zeigen (x = df_str.last_update)
Und auf der y-Achse die 7-Tage-Inzidenz pro 100.000 Einwohner (y = df_str.cases7_per_100k)
Die einzelnen Punkte sollen mit der (gerundeten) Inzidenz beschriftet werden (text = df_str.cases7_per_100k.round())
Angezeigt werden soll eine Linie, ein Marker und die Beschriftung (mode="lines+markers+text")
Außerdem wollen schwäbische Farben, also Spätzegelb verwenden

 1# create plot
 2fig = go.Figure()
 3fig.add_trace(go.Scatter(
 4    x = df_str.last_update,
 5    y = df_str.cases7_per_100k,
 6    text = df_str.cases7_per_100k.round(),
 7    mode="lines+markers+text",
 8    textposition="top center",
 9    textfont_color=spaetzle_gelb_dark,
10    line=dict(color = spaetzle_gelb_dark,
11))

Schon ganz nett, aber layout-technisch geht da noch was.

Geben wir dem Plot einen Titel (title = '7-Tage Inzidenz pro 100k Einwohner: Stuttgart') in der richtigen Farbe (title_font_color=spaetzle_gelb_dark)
Die x-Achse wollen wir dezent in grau zeigen (xaxis = dict())
Die y-Achse brauchen wir gar nicht (yaxis = dict())
Als Hintergrundfarbe wollen wir spätzle-gelb (plot_bgcolor, paper_bgcolor)
Und eine Legende brauchen wir auch nicht (showlegend = False)
Um Missverständnissen vorzubeugen wollen wir außerdem, dass die y-Achse nicht abgeschnitten wird (vor allem, da wir sie ausgeblendet haben). Mit update_yaxes(rangemode = 'tozero') sorgen wir dafür, dass die y-Achse immer bei null beginnt.

 1# make layout great again!
 2fig.update_layout(
 3    title = '7-Tage Inzidenz (100k EW): Stuttgart',
 4    title_font_color=spaetzle_gelb_dark,
 5    xaxis=dict(
 6        showline=True,
 7        showgrid=False,
 8        showticklabels=True,
 9        linecolor=light_grey,
10        color = light_grey,
11        linewidth=2,
12        ticks='outside', 
13    ),
14    yaxis=dict(
15        showgrid=False,
16        zeroline=False,
17        showline=False,
18        showticklabels=False,
19    ),
20    plot_bgcolor=spaetzle_gelb_light,
21    paper_bgcolor=spaetzle_gelb_light,
22    showlegend=False,
23)
24fig.update_yaxes(rangemode = 'tozero')

Diese Grafik sollten wir jetzt noch abspeichern, damit wir sie im nächsten Schritt in einen Telegram-Kanal senden können.

1# export plotly as png
2scope = PlotlyScope()
3with open(img_dir + "figure.png", "wb") as f:
4    f.write(scope.transform(fig, format="png"))

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Corona-Daten des RKI mit Python herunterladen

Sat, 26 Dec 2020 17:57:33 +0100

Auch Ende 2020 hält uns Corona fest im Griff. Vor allem vor den Feiertagen habe ich mir die Frage gestellt, wie sinnvoll es ist, wenn Personen aus unterschiedlichen Landesteilen zusammenkommen. Ich wollte also auf einen Blick für meine Familie sehen können, wie sich die Lage in den jeweiligen Landkreisen entwickelt. Idealerweise automatisiert jeden Morgen auf meinem Handy - ohne die völlig benutzerunfreundlichen Veröffentlichungen des RKI durchstöbern zu müssen.

Die Idee war geboren. Ein Python-Skript sollte mir jede Nacht die Daten vom RKI abziehen, in einer Grafik aufbereiten und via Telegram an meine Familie verteilen. Wenn die Muse anhält, werde ich in den nächsten Tagen also kurz beschreiben, wie ich Daten vom RKI mit Python abziehe, diese mit Plotly grafisch aufbereite und schließlich in einen Telegram-Kanal jeden Morgen poste.

Beginnen wir mit dem Abziehen der Daten aus dem NPGEO Corona Hub. Das RKI veröffentlicht die Daten - aus meiner Sicht sehr dürftig dokumentiert - über arcgis.com, das mittels API von Python aus angesprochen werden kann. Wir benötigen zunächst also die URL.

Da ich mich für Daten auf Landkreisebene interessiere, öffnen wir https://npgeo-corona-npgeo-de.hub.arcgis.com/search?collection=Dataset und wählen den Landkreis-Datensatz aus. Über den API-Explorer-Tab können wir Filter setzen, die relevanten Felder auswählen und die sich ergebende URL kopieren.

Dann bereiten wir unser Python-Skript vor, indem wir die notwendigen Bibliotheken laden.

mit json und requests laden wir die Daten
pandas vereinfacht die Aufräum-Arbeit in den heruntergeladenen Daten
os und datetime helfen uns die Daten in Unterordnern und mit Datumsstempeln zu speichern

1# imports
2import json
3import os
4import pandas as pd
5import requests
6
7from datetime import datetime
8from pandas.io.json import json_normalize

Im nächsten Schritt definieren wir ein paar Variablen.

api_url ist die API-Query-URL, die wir von arcgis.com kopiert haben.
app_dir und data_dir enthalten den Dateipfad zum Verzeichnis, in dem die Python-Datei liegt, sowie einem Unterordner data. In letzterem werden wir die heruntergeladenen Daten speichern.

1# define variables
2api_url = r'https://services7.arcgis.com/mOBPykOjAyBO2ZKk/arcgis/rest/services/RKI_Landkreisdaten/FeatureServer/0/query?where=1%3D1&outFields=*&outSR=4326&f=json'
3app_dir = os.path.abspath(os.path.dirname(__file__))
4data_dir = app_dir + '/data/'

Der eigentliche Download verfolgt über eine Kombination von json.loads() mit requests.get(). Mittels json_normalize() wandeln wir das heruntergeladen JSON-File in einen Pandas-Datensatz um.

1# download and normalize
2d = json.loads(requests.get(api_url).text)
3df = json_normalize(d, record_path=['features'])

Perfekt. Mittels df.head() können wir einen Blick auf die Daten werfen. Mir persönlich gefällt das attributes.-Präfix bei den Spaltennamen nicht. Lass es uns also entfernen. Dafür erzeugen wir ein leeres Array, schleifen über die Spaltennamen, ersetzen dabei jeweils “attributes.” mit "" und überschreiben schließlich die Spaltennamen mit dem Array. Es gibt dafür sicher einen besseren Weg.

1# remove "attributes." from field names
2colnames = []
3for i in range(len(df.columns)):
4    colnames.append(df.columns[i].replace('attributes.', ''))
5
6df.columns = colnames

Das RKI veröffentlicht über die API lediglich die neusten Daten. Sofern wir einen Zeitverlauf analysieren wollen, müssen wir die Daten also abspeichern. Der Einfachheit halber sichern wir den heruntergeladenen Datensatz als CSV mittels Pandas to_csv()-Funktion. Damit wir die Dateien den einzelnen Tagen zuordnen können, extrahieren wir aus der Spalte last_update das Datum und bauen das in den Namen der exportierten CSV-Datei ein.

 1# extract last update date (for filename)
 2file_date = datetime.strptime(df['last_update'][0], '%d.%m.%Y, %H:%M Uhr').strftime("%Y%m%d_%H%M")
 3
 4# epxort CSV to data directory, using last update date for filename
 5df.to_csv(
 6    path_or_buf = data_dir + "rki_" + file_date + ".csv",
 7    sep = ";",
 8    header = True,
 9    index = False,
10    encoding = 'utf-8'
11)

Und damit sind wir eigentlich auch schon fertig. Damit ich nicht für jede Anwendung die Daten neu einlesen und zusammenfügen muss, habe ich meinem Python-Skript noch einen letzten Absatz mitgegeben. Dieser erzeugt zunächst eine Liste aller unter data/ abgespeicherten Dateien (deren Dateiname mit rki_ beginnt), liest diese anschließend der Reihe nach ein, fügt sie zu einem Datensatz zusammen und speichert diesen als zusätzliches CSV-File ab.

 1# create list of all exported CSV files
 2filepaths = [f for f in os.listdir((data_dir)) if f.startswith('rki_')]
 3filepaths
 4
 5# append exported CSV files
 6rkitmp = []
 7for f in filepaths:
 8    dftmp = pd.read_csv(data_dir + f, sep = ";", decimal=",")
 9    rkitmp.append(dftmp)
10
11# concat to Pandas data frame
12rki = pd.concat(rkitmp, axis=0, ignore_index=True, sort = True)
13rki = rki.drop_duplicates()
14
15# export combined data
16rki.to_csv(
17    path_or_buf = data_dir + "rki.csv",
18    sep = ";",
19    header = True,
20    index = False,
21    encoding = 'utf-8'
22)

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.

Etwas coolere ggplots erstellen

Tue, 08 Oct 2019 00:00:00 +0000

Leider muss ich zugeben, dass meine bisherige Beteiligung am TidyTuesday weit hinter meinen Erwartungen zurück geblieben ist. Bisher habe ich lediglich einmal mitgemacht und das ist auch schon Monate her.

Natürlich überfliege ich trotzdem jede Woche unzählige Tweets und erfreue mich an tollen Grafiken zu verschiedenen Themen. So wie beispielsweise an dieser super-coole Visualisierung, die wirklich Lust darauf gemacht hat, mal wieder was mit Karten zu machen.

Und da ich mit ein bisschen Glück demnächst wieder Vollzeit-Baden-Württemberger werde, werden wir uns nicht Pizza-Restaurants in NYC sondern was aus dem lokaleren Datenbestand anschauen.

In diesem Blog-Post möchte ich zeigen, wie sich Visualisierungen in meinem Workflow entwickeln, wie ich von ggplot() + geom_point() zu etwas halbwegs ansehnlichem komme. Dass manche Schritte dabei ein Fall für @accidential aRt sind, versteht sich vermutlich von selbst 😅

Daten sammeln

Lange Rede - kurzer Sinn. Ich habe also auf die Webseite des Statistischen Landesamtes aufgerufen und mir einfach den erstbesten Datensatz runtergeladen, der Informationen auf Kreis-Ebene zur Verfügung stellt. Wir werden heute also etwas zur Bevölkerungsdichte in Baden-Württemberg lernen.

Damit wir die Daten auch hübsch visualisieren könne, habe ich mir darüber hinaus vom Landesamt für Geoinformation und Landentwicklung das entsprechende Shapefile heruntergeladen.

Da die Daten sauber vorbereitet sind, können wir sie mit wenigen Zeilen einlesen und in das gewünschte Format bringen.

 1# --------------------------------
 2# notwendige Packete laden
 3# --------------------------------
 4library(tidyverse)
 5library(sf)
 6
 7# --------------------------------
 8# Dateipfade definieren
 9# --------------------------------
10file_bevoelkerung <- "link/to/Bevoelk_I_Flaeche_j.csv"
11file_shapes <- "link/to/AX_Gebiet_Kreis.shp"
12
13# --------------------------------
14# Daten einlesen und aufbereiten
15# --------------------------------
16EINWOHNER.Kreise <- 
17  read_delim(
18    file = file_bevoelkerung, 
19    locale = locale(encoding = readr::guess_encoding(file_bevoelkerung) %>% select(encoding) %>% unlist()),
20    delim = ";", 
21    skip = 20,
22    col_names = c(
23      "ID.Regionaleinheit",
24      "AmtlicherGemeindeschluessel",
25      "PLZ",
26      "Regionalname",
27      "Stichtag",
28      "Bevoelkerung_insgesamt",
29      "Gemeindegebiet_ha",
30      "Bevoelkerungsdichte_EW_km2"
31    )
32  ) %>% 
33  filter(
34    Stichtag == "31.12.2018",
35    ID.Regionaleinheit == "KR"
36  ) %>% 
37  left_join(
38    y = read_sf(file_shapes),
39    by = c("AmtlicherGemeindeschluessel" = "Schlüssel")
40  )

Basis-Plot erstellen

Nachdem wir die Daten eingelesen und aufbereitet haben, sollten wir uns anschauen was ggplot() vorschlägt. Ein klarer Vorteil ist, dass selbst dieser erste Versuch schon relativ ansehnlich ist. Aber da geht natürlich noch mehr …

1# --------------------------------
2# Basisplot erstellen
3# --------------------------------
4p <- ggplot(data = EINWOHNER.Kreise) + 
5  geom_sf(aes(fill = Bevoelkerungsdichte_EW_km2))
6p

All hail the Spätzle!

Theoretisch könnten wir hier aufhören. Wir haben eine Karte auf der die Landkreise entsprechend ihrer Bevölkerungsdichte eingefärbt sind. Es wird auf einen Blick deutlich, dass in Stuttgart sehr viele Menschen auf wenig Raum wohnen, während es im Nord- und Südosten eher ruhig zugeht.

Nun wollten wir ja aber einen etwas cooleren Plot erstellen. Dazu ändern wir als erstes die Farben. Und weil die Landesfarbe halt spätzle-gelb ist, nehmen wir das als Basis. Von coolors.co lasse ich mir einen dazu passenden Rot-Ton erzeugen und definiere so die beiden Extremwerte meiner Farbskala.

 1# --------------------------------
 2# Farben definieren
 3# --------------------------------
 4colour_spaetzlegelb <- "#FFFEF9"
 5colour_rangemax <- "#AA4465"
 6
 7# --------------------------------
 8# Plot aktualisieren
 9# --------------------------------
10p <- p + 
11  scale_fill_gradient(low = colour_spaetzlegelb, high = colour_rangemax)
12p

Make the theme great again!

Das sieht schon besser (aber noch nicht gut) aus. Als nächstes passen wir das Theme an, entfernen die Legende, den grauen Hintergrund und die Achsen, deren Zahlenwerte aktuell eher verwirrend als hilfreich sind.

 1# --------------------------------
 2# Plot aktualisieren
 3# --------------------------------
 4p <- p + 
 5  theme(
 6    
 7    # Achsen entfernen -----------
 8    axis.line = element_blank(), 
 9    axis.title = element_blank(),
10    axis.ticks = element_blank(),
11    axis.text = element_blank(),
12
13    # Hintergrund anpassen -------
14    panel.background = element_rect(fill = colour_spaetzlegelb),
15    plot.background = element_rect(fill = colour_spaetzlegelb),
16    
17    # Legende entfernen ----------
18    legend.position = "none"
19  )
20p

Reden ist Silber, Annotierung ist Gold!

So langsam wird es doch. Es fehlt aber noch ein bisschen Kontext. Also fügen wir neben der eigentlich Grafik einen Titel und eine kurze Zusammenfassung der Ergebnisse ein. Das hilft die Hauptaussage der Visualisierung noch einmal (in prosa) hervorzuheben.

 1# --------------------------------
 2# Untertitel verfassen
 3# --------------------------------
 4plot_subtitle <- str_c(
 5  "Die Karte zeigt die Bevölkerungsdichte nach Kreisen in Baden-Württemberg.",
 6  "Am dünnsten besiedelt ist der Main-Tauber-Kreis. Hier wohnen 101 Personen pro km².",
 7  "Mehr als 30x mehr Personen pro Quadratkilomenter wohnen in der Landeshauptstadt.",
 8  sep = " "
 9)
10
11# --------------------------------
12# Quellen definieren
13# --------------------------------
14plot_caption <- str_c(
15  "Daten: Statistisches Landesamt Baden-Württemberg;",
16  "Karten: Landesamt für Geoinformation und Landentwicklung",
17  "Grafik: https://gluecko.se",
18  sep = " "
19)
20
21# --------------------------------
22# Notwendige Koordinaten speichern
23# --------------------------------
24coord_xmin <- sf::st_bbox(EINWOHNER.Kreise$geometry)$xmin
25coord_xmax <- sf::st_bbox(EINWOHNER.Kreise$geometry)$xmax
26coord_ymin <- sf::st_bbox(EINWOHNER.Kreise$geometry)$ymin
27coord_ymax <- sf::st_bbox(EINWOHNER.Kreise$geometry)$ymax
28
29# --------------------------------
30# Plot aktualisieren
31# --------------------------------
32p <- p + 
33  annotate("text", label = "Bevölkerungsdichte nach Kreisen", x = .7 * coord_xmin, y = 1.01 * coord_ymax, size = 6, hjust = 0) +
34  annotate("text", label = str_wrap(plot_subtitle, 40), x = .7 * coord_xmin, y = coord_ymax, size = 3, hjust = 0) +
35  annotate("text", label = str_wrap(plot_caption, 40), x = .7 * coord_xmin, y = coord_ymax, size = 3, hjust = 0, vjust = 2.5)
36p

Look here!

Na das sieht doch jetzt echt nach was aus! Wir sollten allerdings noch ein paar Kreise explizit hervorheben. Extremfälle bieten sich an - fügen wir also noch Hinweise auf die Kreise mit der höchsten bzw. niedrigsten Bevölkerungsdichte ein.

 1# --------------------------------
 2# Centroid berechnen
 3# --------------------------------
 4get_centroid <- function(name){
 5  coords <- 
 6    EINWOHNER.Kreise %>% 
 7    filter(Name %in% name) %>% 
 8    select(geometry) %>% 
 9    st_as_sf() %>% 
10    st_centroid() %>% 
11    unlist()
12  
13  if(length(coords)>2){
14    warning("More than one centroid found!")
15  }
16  
17  returnData <- 
18    tribble(
19      ~"Name", ~"x", ~"y",
20      name, coords[1], coords[2]
21    )
22  
23  return(returnData)
24}
25
26# --------------------------------
27# Notwendige Koordinaten speichern
28# --------------------------------
29coord_Stuttgart_xlabel <- 1.05 * coord_xmin
30coord_Stuttgart_ylabel <- 1.0045 * get_centroid("Stuttgart")$y
31coord_Mannheim_xlabel <- 1.1 * coord_xmin
32coord_Mannheim_ylabel <- 1.005 * get_centroid("Mannheim")$y
33coord_Karlsruhe_xlabel <- 1.1 * coord_xmin
34coord_Karlsruhe_ylabel <- 1.005 * get_centroid("Karlsruhe")$y
35coord_MainTauberKreis_xlabel <- 0.95 * coord_xmax
36coord_MainTauberKreis_ylabel <- 1.005 * get_centroid("Main-Tauber-Kreis")$y
37coord_Sigmaringen_xlabel <- 0.98 * coord_xmax
38coord_Sigmaringen_ylabel <- 1.005 * get_centroid("Sigmaringen")$y
39coord_NeckarOdenwaldKreis_xlabel <- 0.82 * coord_xmax
40coord_NeckarOdenwaldKreis_ylabel <- 1.0115 * get_centroid("Neckar-Odenwald-Kreis")$y
41
42# --------------------------------
43# Plot aktualisieren
44# --------------------------------
45p <- p + 
46  # Top 1: Stuttgart -------------  
47  annotate("segment", x = coord_Stuttgart_xlabel, y = coord_Stuttgart_ylabel, xend = get_centroid("Stuttgart")$x,  yend = get_centroid("Stuttgart")$y) + 
48  annotate("label", label = "Stuttgart\n3.062 EW/km²", x = coord_Stuttgart_xlabel, y = coord_Stuttgart_ylabel) + 
49  
50  # Top 2: Mannheim --------------
51  annotate("segment", x = coord_Mannheim_xlabel, y = coord_Mannheim_ylabel, xend = get_centroid("Mannheim")$x, yend = get_centroid("Mannheim")$y) + 
52  annotate("label", label = "Mannheim\n2.134 EW/km²", x = coord_Mannheim_xlabel, y = coord_Mannheim_ylabel) + 
53  
54  # Top 3: Karlsruhe -------------
55  annotate("segment", x = coord_Karlsruhe_xlabel, y = coord_Karlsruhe_ylabel, xend = get_centroid("Karlsruhe")$x, yend = get_centroid("Karlsruhe")$y) + 
56  annotate("label", label = "Karlsruhe\n1.805 EW/km²", x = coord_Karlsruhe_xlabel, y = coord_Karlsruhe_ylabel) + 
57
58  # Bottom 1: Main-Tauber-Kreis --
59  annotate("segment", x = coord_MainTauberKreis_xlabel, y = coord_MainTauberKreis_ylabel, xend = get_centroid("Main-Tauber-Kreis")$x, yend = get_centroid("Main-Tauber-Kreis")$y) +
60  annotate("label", label = "Main-Tauber-Kreis\n101 EW/km²", x = coord_MainTauberKreis_xlabel, y = coord_MainTauberKreis_ylabel) + 
61
62  # Bottom 2: Sigmaringen --------
63  annotate("segment", x = coord_Sigmaringen_xlabel, y = coord_Sigmaringen_ylabel, xend = get_centroid("Sigmaringen")$x, yend = get_centroid("Sigmaringen")$y) +
64  annotate("label", label = "Sigmaringen\n109 EW/km²", x = coord_Sigmaringen_xlabel, y = coord_Sigmaringen_ylabel) +
65
66  # bottom 3: Neckar-Odenwald-Kreis --
67  annotate("segment", x = coord_NeckarOdenwaldKreis_xlabel, y = coord_NeckarOdenwaldKreis_ylabel, xend = get_centroid("Neckar-Odenwald-Kreis")$x, yend = get_centroid("Neckar-Odenwald-Kreis")$y) +
68  annotate("label", label = "Neckar-Odenwald-Kreis\n127 EW/km²", x = coord_NeckarOdenwaldKreis_xlabel, y = coord_NeckarOdenwaldKreis_ylabel)
69p

Eine große Version der Grafik und den vollständigen Code am Stück gibt es - wie immer - bei GitHub.

Thank you for subscribing to this RSS feed. https://soeren.one/ is søren's personal blog. If you want to get in touch, please reply to this post via email.