Weltkarte erstellen mit Python: Meeresspiegelanstieg

Grafik- und Contestforen Sonstige 2D/3D-Software
1

Hallo.

Ich wollte eine Animation erstellen, in der der Meeresspiegelanstieg simuliert wird und zwar auf einem Globus (Erdkugel) mit physikalischer Darstellung. „Blue Marble“ ginge auch, aber dann ohne Wolken. Ich habe früher einige Karten heruntergeladen, die diesen Anstieg zeigen, aber sie sind leider in der Mercator-Projektion und die Antarktis fehlt.

Nun habe ich mir gedacht: naja, das Internet wird ja wohl voll sein mit sowas, immerhin ist es ein brisantes Thema.
Pustekuchen - ich habe nichts gefunden.
Also habe ich aus „Verzweiflung“ mal ChatGPT gefragt und er/sie/es hat mir gleich hundert Vorschläge gemacht, darunter das besagte OpenSource-Projekt OSGeo4W. Und mir gleich ein Python-Script dafür hingesetzt, das aber nicht läuft (wie nicht anders zu erwarten…).
Dieses OSGeo4W hat nach dem Teststart sogar eine zum Teil deutsche Oberfläche (ohne dass ich gefragt wurde…), aber dennoch: ich habe von der Materie null Ahnung und dann kommen noch alle Erklärungen nur auf Englisch. Das Programm sieht immerhin sehr aufgeräumt aus.

Dort soll ich also die Reliefdaten (scheint sich um eine Graustufenkarte zu handeln?) mit einer physikalischen Karte kombinieren und mir somit meine Küstenverläufe nach Wunsch selbst generieren können.
Das sieht aber nach einer extrem steilen Lernkurve aus und wird vermutlich Wochen dauern, bis ich überhaupt begriffen habe, was ich da tue… Irgendwas mit ETOPO2022 - keine Ahnung, was das ist…
Die Alternative, in PS irgendwie anhand eines Pixel-Grauwerts die Meereshöhe anzugeben, war nicht von Erfolg gekrönt.

Wie würde man das angehen? Ich brauche also vielleicht 10 Lambert-Weltkarten der Meeresspiegel, die ich dann auf eine Kugel mappe und animiere (durch einfache Überblendung). Es ist also kein Cinema4d-Problem, sondern: wie komme ich an die Karten?

2

Ich habe mich jetzt den ganzen Tag mit ChatGPT „herumgeschlagen“. Immerhin, mit tatkräftiger Unterstützung funktioniert das Script, obwohl ich keine Ahnung habe, was ich da genau mache. Es ist nicht genau das, was ich als Kartenbild wollte, aber zu 90% nahe dran. Ich vermute, dass die Karte tatsächlich neu erstellt wird, so wie ich den Code verstehe, aber wie und womit, kann ich nicht sagen.

Ich hatte eigentlich eine fertige physikalische Rasterkarte als Vorlage (400 MB…), mit Wüsten und Vegetationszonen - aber eigentlich ist es gut so, weil diese Landschaften dann ja auch an die neuen Küsten angepasst werden müssten. Und einfach überfluten sieht auch doof aus. So ist es mehr generalisiert.

Das vorherige Kleinskalieren klappte nicht, so dass ich 70 MB-große Tiffs erhalte (beim Skalieren gingen offenbar die Geo-Daten verloren…) - aber die PNG lassen sich dann eben in PS runterskalieren.

flood_150m klein.jpg
flood_150m klein.jpg2000×1000 351 KB

Die Flachwasserzonen wollte ich nicht in Hellblau, aber ich weiß nicht, wie ich die Schattierung wegbekomme. Im Script kann man dort Zahlenwerte eingeben. Aber ich habe null Ahnung von Python und den beteiligten Bibliotheken, - das ist alles Blindflug. Naja, immerhin könnte ich jetzt theoretisch für jeden Meter eine Datei rendern lassen, und eigentlich wollte ich gar nicht mehr. :smiley:

Das Programm OSGeo4w habe ich jetzt nicht gebraucht, aber ich schaue trotzdem rein. Karten selbermachen mag ich!

#!/usr/bin/env python3"""
Erzeugt Weltkarten mit verändertem Meeresspiegel aus ETOPO 2022.


Benötigt:
    pip install rasterio numpy pillow


Datei:
    etopo.tif


Ausgabe:
    flood_10m.png
    flood_20m.png
    flood_50m.png
"""


import numpy as np
import rasterio
from rasterio.enums import Resampling
from PIL import Image


# ---------------------------------------------------
# Einstellungen
# ---------------------------------------------------


ETOPO = "etopo.tif"


OUTPUT_WIDTH = 16384
OUTPUT_HEIGHT = 8192


SEA_LEVELS = [2, 5, 10, 20, 50, 100, 150, 200, 300, 500, 1000]


# Farben
DEEP_WATER = np.array([25, 70, 170], dtype=np.uint8)
SHALLOW_WATER = np.array([90, 160, 255], dtype=np.uint8)


LOWLAND = np.array([170, 185, 120], dtype=np.uint8)
HIGHLAND = np.array([120, 105, 85], dtype=np.uint8)
MOUNTAIN = np.array([245, 245, 245], dtype=np.uint8)




# ---------------------------------------------------
# Hilfsfunktion
# ---------------------------------------------------


def blend(c1, c2, t):
    return (c1 * (1 - t) + c2 * t).astype(np.uint8)




# ---------------------------------------------------
# ETOPO laden
# ---------------------------------------------------


print("Lade ETOPO...")


with rasterio.open(ETOPO) as src:


    elev = src.read(
        1,
        out_shape=(OUTPUT_HEIGHT, OUTPUT_WIDTH),
        resampling=Resampling.bilinear,
    )


print("Größe:", elev.shape)


# ---------------------------------------------------
# Karten erzeugen
# ---------------------------------------------------


for sea in SEA_LEVELS:


    print(f"Erzeuge +{sea} m")


    rgb = np.zeros((OUTPUT_HEIGHT, OUTPUT_WIDTH, 3), dtype=np.uint8)


    water = elev <= sea
    land = ~water


    # ---------------------------
    # Wasser
    # ---------------------------


    depth = np.clip((sea - elev) / 6000.0, 0, 1)


    rgb[water] = blend(
        SHALLOW_WATER,
        DEEP_WATER,
        depth[water][:, None]
    )


    # ---------------------------
    # Land
    # ---------------------------


    h = np.clip((elev - sea) / 4000.0, 0, 1)


    low = h < 0.5
    high = ~low


    land_index = np.where(land)


    hh = h[land]


    colours = np.empty((hh.size, 3), dtype=np.uint8)


    a = hh < 0.5


    colours[a] = blend(
        LOWLAND,
        HIGHLAND,
        (hh[a] * 2)[:, None]
    )


    colours[~a] = blend(
        HIGHLAND,
        MOUNTAIN,
        ((hh[~a] - 0.5) * 2)[:, None]
    )


    rgb[land_index] = colours


    outfile = f"flood_{sea}m.png"


    Image.fromarray(rgb).save(outfile)


    print("Gespeichert:", outfile)


print("Fertig.")
3

Nimm das nächste mal Claude für so eine Aufgabe. Die Chance ist damit sehr hoch, dass Du schon beim ersten Versuch einen funktionierenden Prototypen bekommst.

1 „Gefällt mir“
4

Bei ChatGPT fiel mir auf, dass er mehrere Lösungen irgendwie gleichzeitig bearbeitet. Ich war mir nie sicher, welchen Lösungsweg der Bot verfolgt, weil immer Alternativen vorgeschlagen werden. Das Script war prinzipiell in Ordnung, aber er verhaspelte sich dabei, wie ich die Python-Bibliotheken zu installieren hätte. Ich habe also den Standard-Weg gewählt und sie über die Webseiten installiert, weil mir die “komfortablen” cmd-Befehle zu krude waren und nicht funzten.

Um die Reflektion/Spiegelung von Wasser hoch- und die von Land runterzusetzen, habe ich jetzt uraltklassisch in Photoshop die Wassermasken gemacht. Es gibt zwar Alphakanal für Spiegelung, aber nicht für Glanz, also müssen die gleichen Texturen in glänzend nochmal drauf.

Es gibt bestimmt einen schnelleren Weg per Script, aber nochmal wollte ich mir den Chat nicht antun. Die Karten existieren ja gerade durch den neuen Wasserspiegel, also kann man daraus sicher SW-Masken errechnen. K.A. wie.

Ist auch immer alles weg, so dass ich nur die Chatkopie als Vorlage habe. Sagen wir so: KI hilft durchaus, aber man muss jeden Schritt wenigstens mit Mindestlogik überprüfen. Also, ganz doof darf man nicht sein…

Claude habe ich noch nie probiert. Wenn man sich nicht anmelden muss und alles auf Deutsch geht, warum nicht? Mehr Unabhängigkeit von den Tech-Diktatoren…

5

warum ist es wichtig das es auf deutsch geht?
und alles was du da beschreibst ist wie fahrrad fahren mit einem bein, du kannst codex / claude via CLI in deiner codebase benutzen und musst nicht irgendwelche script bocken manuell kopieren.

6

ja versuchs mit claude cli..und aus meiner sicht hände weg von gpt codex..ist nur tokenfreser..unvollständig eingebunden und frisst ca 300% soviel tokens wie claude für selbe aufgabe..da müsen die etwickler erst mal noch unzählige bugs rausholen, auch wenn codex gute ergebnisse liefert.

> unabhängig ist claude cli wesentlich gewissenhafter und hat mer überblick..codex blendet mit geschwindigkeit, aber bei komplexen systemen hast du danach noch bugs ohne ende drin..dann lieber eine ki die sich mehr zeit nimmt und überlegt was sie wirkich tut und nicht wie ein schnellzug nach vorne prescht und unzählige wichtige sachen nicht berücksichtigt! dann hast du nur bugbekämpfung im nachhinein ohne ende..und das geht auf deine arbeitszeit, denn die bugs musst du finden und wieder erklären!!

7

Ist ja jetzt eigentlich wurscht, weil ich damit durch bin. Die Karten sind da (und ich könnte mit negativem Meeresspiegel auch eine Eiszeit simulieren. Dazu muss ich aber ETOPO verstehen und die Werte, die man da eingibt, auch ohne KI).
Naja, ich verstehe das Thema nicht mal auf Deutsch, wie soll ich mich da erst auf Englisch zurechtfinden? Ich würde tatsächlich alles vorher in DeepL übersetzen, was letztlich ja auch mit KI läuft…

Ich weiß z.B. nicht mal, was „in meiner Codebase benutzen“ heißen soll? Ich benutze Python normalerweise in cmd, ich weiß gar nicht, wie es anders geht - also sind Scripte schon ganz nett und ich kann sie im Editor manipulieren. Rumprobieren, rumprobieren.
Geht schneller als Handbücher lesen, weil ich die Texte gar nicht verstehe. Was für eine Matrix? Was sind „WGS84 geographic coordinates“? Oder was genau installiert „condainstall-cconda-forgelibgdal“?

Ihr habt es hier mit einem totalen Anfänger zu tun, was das betrifft. Ich kann Grafiken schön machen, aber diese Fachtermini dahinter sagen mir nichts.

Mein Englisch würde ich mit 4- einstufen. Es reicht, um versetzt zu werden…

PS: Ich benutze ChatGPT, weil ich mich dazu nicht registrieren lassen muss. Ganz simpel… Bei Claude muss ich das.

8

Zwei WIPS. Einmal mit stationärer Kamera, einmal mit Rotation (die natürlich unsinnig ist, weil es bestimmt einige hundert Jahre braucht - und so schnell kann man es nicht rotieren lassen…)

1 „Gefällt mir“
9
1 „Gefällt mir“
10

wow..die kugel dreht sich :slight_smile: erfolg, auf ganzer linie würd ich sagen..wie hast du da hinbekommen?

11

Du hast schon mitbekommen dass die kontinente verschwinden? :wink:

12

die stationäre darstellung finde ich von daher besser, dass man das verschwinden sehr viel besser verfolgen kann, bei der rotation hast du halt immer 180° der vollen drehung, bei der so gut wie keine kontinente zu sehen sind.

sind 1.000m realistisch? ich dachte das liegt bei 80m, wenn alles gletschereis und die pole schmelzen.

13

Glaub’ nicht, dass es realistisch ist. Um die 60 bis 70 Meter werden vermutet, wenn das ganze Eis schmilzt.
Aber bis auf wenige Stellen sieht man selbst 100 Meter Erhöhung nicht sofort auf einer Weltkarte. Dann sollte man tatsächlich die norddeutsche Küste oder Ozeanien als Detail herausnehmen. Also wäre es dann eher eine Kartenanimation. Oder man zoomt stärker ran. Ich habe die ~16000 Pixel jedoch auf 3000 Pixel reduziert, weil ich sonst Monsterdateien bekomme, die ich gar nicht brauche. Und für Nahaufnahmen ist es dann sowieso nicht optimal.

Ich wollte auch auf der Nachtseite die Lichter verlöschend anlegen, aber ich habe noch keine Idee, wie. Ich hätte gerne eine Art von rotierender Alphablende zwischen der Tag- und der Nachttextur. Habe das vor Jahren mal probiert, konnte es jedoch nicht anders lösen, als 12 Nachttexturen mit weitergerückter Alphaausblendung aufzulegen. Das wären hier für jedes Szenario 12 Nachtansichten, die fortlaufend gewechselt werden müssten, ein ziemlicher Haufen von Texturen… Leider sind die Shader-Positionen NICHT animierbar im Farbverlauf-Menü, das wäre perfekt gewesen.

Man kann auch Kameraanimationen machen, die sich einzelne Kontinente herauspicken. Dann hätte man sowohl stationär als auch bewegt. Wie gesagt: war ein WIP, um überhaupt mal zu ermessen, wie es wirkt.

1 „Gefällt mir“
14

Kirby: Im Grunde mit Texturüberblendung in der Key-Zeitleiste. Bei Texturen wird überblendet, während beim Text (Textspline mit Extrudenurb) das in Sprüngen erfolgt, wenn man den Text ändert.
Für die Reflektion habe ich die gleichen Texturen mit Glanzlicht und maskiertem Land noch mal gemappt. Spiegelung auch, aber nur wenig. Als Unterlage die Blue Marble-Textur, eine ETOPO-Karte und das Relief, die ich je nach Wunsch stärker hervorheben kann. Wolken waren nicht zielführend, also nein. Beim Eis war ich faul, das sind nur drei Texturen, was noch unschön und abgehackt wirkt - eine stetige Abnahme wäre besser.
Alles rotieren zu lassen, ist doch kein Problem, oder? :slight_smile:

15

Die Tag-Nacht-Animation. Ist von 2005 (!).
Ist so weit rechts, weil ich den Monddurchlauf kontrollieren wollte (ab 21s). Der Mondschatten ist kurz bei 8 Sekunden zu sehen. Da ich aber weiches Licht mit großer Streuung und weichem Schatten verwendet habe, ist es nicht sehr realistisch. Wirkt aber besser im Gesamtensemble.

Mond, Erde und Mondbahn und alle Zeitabläufe sind im echten Maßstab, also ist der Mond tatsächlich 300000 Kilometer entfernt (natürlich im Verhältnis zum Erddurchmesser) Die reale Entfernung zur Sonne und deren Größe wollte Cinema4d aber nicht umsetzen :smiley: :|.

https://vimeo.com/1216809133

Die Kamera hat 100 Millimeter Brennweite, dann sieht das Verhältnis Erde-Mond ok aus. Der Mond wirkt zwar größer bei stärkerem Tele, aber so kommt die Entfernung besser rüber.

Nokia 6300 Wip?!