Lösung (in Python Code):
Zuerst suchen wir die Koordinaten der 4 Ecken des Bildes und der Mitte.
Wir brauchen nacher eigentlich nur von jeder Seite 1 Koordinate aber so haben wir alle falls sie später gebraucht werden sollten für andere Berechnungen.
import math
def tile_corner_coordinates(X: int, Y: int, zoom: int) -> list:
"""
Gibt die Koordinaten (Längen-und Breitengrade) der 4 Ecken
zurück und die der Mitte des Bildes/Kachel.
:param X [int] -- Der X Wert der Kachel in der Mercator
Projektion (im Rasternetz)
:param Y [int] -- Der Y Wert der Kachel in der Mercator
Projektion (im Rasternetz)
:param zoom [int] -- Die zoom Stufe des Bildes/Kachel
:returns list[list[float, float]] -- [[lon1, lat1], [lon2,
lat2]]
"""
original_X, original_Y = X, Y # Wir merken uns die Originalwerte
# von X und Y da wir X und Y
# verändern je nachdem welche Ecke
# wir suchen.
out = []
n = 2 ** zoom
for i in range(5):
if i == 1: # oben rechts (i=0 wäre oben links)
X += 1
elif i == 2: # unten rechts
X += 1
Y += 1
elif i == 3: # unten links
Y += 1
elif i == 4: # mitte
X += 0.5
Y += 0.5
lon_deg = X / n * 360.0 - 180.0
lat_rad = math.atan(math.sinh(math.pi * (1 - 2 * Y / n)))
lat_deg = lat_rad * 180 / math.pi
out.append([lon_deg, lat_deg])
X, Y = original_X, original_Y
return out
In der 'for loop' kucken wir welchen Wert i hat denn wir wollen im Uhrzeigersinn die 4 Ecken ausfindig machen. Da die Formeln in den 3 Zeilen 'lon_deg = ...' , 'lat_rad = ...' und 'lat_deg = ...' uns immer nur die Koordinaten für die obere linke Ecke liefern, klappt dies eigentlich nur für die obere linke Ecke der Kachel. Danach müssen wir für die obere Rechte Ecke der Kachel einfach eine Kachel nach rechts gehen (X + 1) (da wir uns ja in einem Raster befinden) und die linke obere Ecke dieser Kachel ausrechnen welche im Prinzip die obere rechte Ecke unserer Kachel ist.
Für unten rechts gehen wir 1 nach rechts und 1 runter (x+1, y+1).
Für unten links gehen wir nur 1 runter (y+1)
Um die Mitte zu berechnen gehen wir eine halbe Kachel runter und nach rechts (x+0.5, y+0.5). Diese Kachel hätte jetzt als obere linke Ecke die Mitte unserer Kachel.
Nun der eigentliche Code zur Lösung der Frage:
def latlng_from_px(px: int, py: int, corner_coordinates: list,
tilesize: int):
"""
Gibt die Koordinaten eines Pixels auf einer Kachel zurück.
:param px [int] -- Die x position des Pixels auf der Kachel
:param py [int] -- Die y position des Pixels auf der Kachel
:param corner_coordinates [list] -- Die Liste der Koordinaten
der Ecken (siehe Funktion
oben)
:param tilesize [int] -- Die größe der Kachel in pixel
"""
# Basierend auf der folgenden Antwort:
# https://stackoverflow.com/a/13323592
mapWidth = tilesize
mapHeight = tilesize # wir nehmen an dass die Kachel so hoch
# wie breit ist (w = h)
mapLonLeft = corner_coordinates[3][0] # Längengrad unten links
mapLonDelta = corner_coordinates[2][0] - mapLonLeft
# distanz zwischen unten links und unten rechts = mapLonDelta
# Breitengrad unten links
mapLatBottomRadian = math.radians(corner_coordinates[3][1])
worldMapRadius = mapWidth / mapLonDelta * 360 / (2 * math.pi)
mapOffsetY = (worldMapRadius / 2 * math.log((1 +
math.sin(mapLatBottomRadian)) / (1 -
math.sin(mapLatBottomRadian))))
equatorY = mapHeight + mapOffsetY
a = (equatorY - py) / worldMapRadius
lat = 180 / math.pi * (2 * math.atan(math.exp(a)) -math.pi / 2)
long = mapLonLeft + px / mapWidth * mapLonDelta
return long, lat
