GPS-Koordinaten in 2D-Karte eintragen - oder Workaround.

Hui - wo fängt man da an?
Fangen wir mal so an: Was sind "GPS-Koordinaten"?
Hier muss man zwischen zwei Begriffen unterscheiden:

1. Bezugssystem: Die Grundlage für ein Koordinatensystem. Dies gibt (bei globalen Bezugssytemen) an, wie das System gegenüber der Erde gelagert ist, wie es sich mathematisch verhält usw. Unter anderem sind das die Parameter eines Rotationsellipsoiden (quasi als Modell der Erdform) sowie dessen Lage und Ausrichtung in Bezug zur Erde. Bekannt wären hier z.B. WGS84 (das von GPS) oder ETRS89 (das amtliche System in Deutschland).
2. Koordinatensystem: Mathematisches System, welches definiert wie der Bezug von Zahlendarstellungen auf eine Lage im Raum (oder Ebene,...) definiert ist. Klassisch wäre hier das ebene kartesische Koordinatensystem (x,y), das räumliche kartesische Koordinatensystem (x,y,z), geographische Koordinaten (Breitengrad, Längengrad), Polarkoordinaten (Winkel, Strecke) aber auch projektive Koordinaten wie z.B. die Gauß-Krüger-Koordinaten oder UTM-Koordinaten (Rechtswert, Hochwert).

Wenn du nun also sagst, dass du "GPS-Koordinaten" vorliegen hast, dann kann man sicherlich davon ausgehen, dass sie sich auf das Bezugssystem WGS84 beziehen. Die wirklich wichtige Frage ist jedoch: Welches Koordinatensystem? Koordinaten im WGS84 kann man im Grunde beliebig angeben. Sind es geographische Koordinaten? oder doch UTM? Bei der internen Berechnung selbst werden auch häufig räumliche kartesische Koordinaten verwendet. Das ist wichtig, weil wir ja den Brückenschlag zur Karte brauchen.

Gehen wir jetzt einfach mal davon aus, du hast geographische Koordinaten - also Längen und Breitenangaben. Diese Koordinatenangaben beziehen sich auf die Oberfläche eine Rotationsellipsoiden. Also eine nichtebene, gekrümmte Fläche. Deine Karte ist jedoch lediglich zweidimensional und flach. Und wenn man sie als Pixelansammlung betrachtet, dann ist deren Koordinatensystem ein ebenes kartesisches Koordinatensystem. Aber wie geschah die Zuordnung von der eigentlich gekrümmten Form auf der Erde hin zur zweidimensionalen Karte? Und hier sind wir im großen Gebiet der Projektion und Abbildungsgeometrien.

Wie dir sicherlich bewusst ist, gibt es nur eine Erde - aber zig unterschiedliche Darstellungsarten von ihr als Karte. Das hängt damit zusammen, dass man die gekrümmte Erdoberflächenform nicht verzerrungsfrei auf eine zweidimensionale Karte pressen kann. Daher gibt es zig verschiedene Projektionsarten die alle bestimmte Vor- und Nachteile haben und daher je nach Zweck unterschiedlich sind. Manche sind Winkeltreu, was die Navigation erleichtert, manche sind Streckentreu, was Messungen in der Karte erleichtert, manche sind Flächentreu, was Größenvergleiche ermöglicht usw. Wichtig: Keine Projektion erfüllt alle diese Anforderungen gleichzeitig!

Das heißt für dich: Damit du von deinen globalen Koordinaten in deine Kartenkoordinaten kommst, brauchst du die Information welche Projektion deiner Karte denn zugrunde lag.
Ohne diese Information kannst du keine rein geometrische Umrechnung durchführen.
Es gibt nur eine einzige Projektionsart bei der du nahezu 1:1 von geographischen Koordinaten in die Pixel übertragen kannst (da dort sowohl Längen- als auch Breitengrade linear abgebildet werden): Die Rektangularprojektion (auch "Plattkarte" genannt). Wenn du das vorliegen hast, dann wäre es sehr einfach machbar: Du brauchst nur Koordinatenursprung und den Maßstab (also wieviele Pixel sind ein Grad im Bild).

Wenn du diese Information nicht vorliegen hast aber dennoch eine Umrechnung haben willst, dann müsste man eine Transformation rechnen. Hierfür braucht es aber Koordinatenpaare. Sprich: Punkte deren Koordinaten in deinen "GPS-Koordinaten" bekannt sind, als auch deren Pixelposition im Zielbild.
Bei hinreichender Anzahl derartiger Koordinatenpaare berechnet man sich dann die Parameter für eine Transformation und kann sich dann mit dieser "Formel" die Koordinaten von einem ins andere System rüberrechnen. Je nach Verzerrung des Zielsystems kann das entweder rechenaufwendiger werden oder mit einem höheren Genauigkeitsverlust einhergehen.

Also zusammengefasst: Was genau hast du für Koordinaten? Kennst du die Projektionsart deiner Zielkarte? Hast du eventuell Bekannte Punkte deren GPS-Koordinaten du kennst und deren Pixelposition im Zielbild bekannt ist?

Zitat von UPIA

Bekomme ich das in python überhaubt ausreichend genau hin.

In Python bekommt man das noch gut hin.
Es gibt zig Bibliotheken für Python um z.B. Karten darzustellen, geographische Berechnungen durchzuführen usw.
Da ist im Grunde schon alles implementiert.
Man muss halt die richtige Bibliothek finden und diese entsprechend verwenden.
Hier habe ich allerdings keinen aktuellen Überblick mehr.
Ich hatte früher mal matplotlib dafür verwendet aber das ist nicht unbedingt hierauf spezialisiert.
Plotly, Folium und Cartopy habe ich noch im Kopf - aber wie gesagt: Da fehlt mir ein aktueller "Marktüberblick".
Für sowas würde ich persönlich schnell QGIS anschmeißen oder eine kleine Webseite in Leaflet erstellen.

Zitat von UPIA

*bei GPS ist ja der Breitengrad oben größer im gegensatz zum image

Ne - GPS betrifft ja nur die Koordinaten und deren mathematische Formatierung. Und Breitengrade haben nunmal immer den gleichen Abstand (nämlich Grad-Schritte).
Was du höchstwahrscheinlich meinst ist die Kartenprojektion des Bildes und wie du es beschreibst klingt es stark nach einer Mercatorprojektion.
Das wiederum hat rein gar nichts mit GPS zu tun.
Jedes Bezugssystem welches man über Mercator abbildet wird in der Darstellung "dickere" Breitenabstände hin zu den Polen haben.

Zitat von UPIA

ich benötige aber immer noch für die Zukunft eine Lösung mit GPS auf 2D (wenn mgl UTM)

Das ist im Grunde kein Problem.
Aber man muss sich hierbei ganz klar sein was man genau für Systeme meint.
Nochmal: Was ist mit "GPS" gemeint? WGS84 mit geographischen Koordinaten?
Was ist mit "UTM" gemeint? UTM ist erstmal nur eine Projektion die man auf beliebige Bezugssysteme packen kann.

Für eine Koordinatentransformation muss man daher wissen, welches Bezugssystem und dann welcher Streifen der UTM-Projektion das Zielsystem ist.
Beispiel: Das amtliche Bezugssystem in Deutschland ist ETRS89.
Amtliche Koordinatenreferenzsysteme gibt es jedoch primär zwei: Einmal ETRS89 UTM32 N (für den westlichen Teil Deutschlands) und ETRS89 UTM33 N (für den östlichen Teil Deutschlands).
Das muss man also genau wissen bevor man umrechnet. Nur "UTM" ist schlicht nichtssagend.

Wenn man das dann weiß, dann gibt es zig Tools zum Transformieren zwischen verschiedenen Koordinatenreferenzsystemen.
Wenn man Online-APIs wie die von MapTiler verwendet, dann bekommt man das auch gut in AutoIt integriert (hierfür brauchst du noch die JSON-UDF und einen API-Key von MapTiler) :

#include <Array.au3>
#include "JSON.au3"

; EPSG-Codes der verwendeten Koordinatenreferenzsysteme
; Datenbank der EPSG-Codes findet sich hier: https://epsg.io/
Global $dQuellsystem = 4326, _ ; geographische Koordinaten im WGS84
       $dZielsystem  = 25833   ; UTM 33N-Koordinaten im ETRS89-Bezugssystem (für den östlichen Teil Deutschlands das amtliche System)

; API-Key zum Zugriff auf die MapTiler-API (hier erhältlich: https://cloud.maptiler.com/account/keys/)
Global $sMapTilerAPIKey = 'xxxxxxxxxxxxxxxxx'

; Quellkoordinaten im Quellsystem, welche in das Zielsystem transformiert werden sollen
; Bei EPSG=4326 sind die Koordinaten in der Reihenfolge [Längengrad, Breitengrad]
Global $aCoords[][] = [   [13.37609, 52.51860], _ ; Reichstag
                          [13.01590, 52.40130], _ ; Schloss Sanssouci
                          [13.74159, 51.05195]  _ ; Frauenkirche Dresden  
                      ]

; Transformation durchführen
Global $aNewCoords = _geo_coordsTransform($sMapTilerAPIKey, $dQuellsystem, $dZielsystem, $aCoords)
If @error Then MsgBox(48, "Fehler", "@error: " & @error & @CRLF & "@extended: " & @extended & @CRLF & "Return: " & $aNewCoords)

; Transformierte Koordinaten anzeigen
_ArrayDisplay($aNewCoords, "Transformierte Koordinaten", "", 64)


; #FUNCTION# ======================================================================================
; Name ..........: _geo_coordsTransform
; Description ...: Transforms geographic coordinates between different coordinate reference systems 
;                  using the MapTiler API.
; Syntax ........: _geo_coordsTransform($sAPI_Key, $dSystemFrom, $dSystemTo, $aCoordinates [, $sProxy = Default])
; Parameters ....: $sAPI_Key      - API key for MapTiler service (String)
;                  $dSystemFrom   - Coordinate system from which coordinates will be transformed (String, EPSG code or name)
;                  $dSystemTo     - Coordinate system to which coordinates will be transformed (String, EPSG code or name)
;                  $aCoordinates  - Array of coordinates to transform, can be a single coordinate (2 or 3 elements) 
;                                    or multiple coordinate (up to 50) 
;                  [$sProxy]      - (Optional) Proxy server to use for the HTTP request (String, Default: no proxy)
; Return values .: Success - Returns a 2D array with transformed coordinates:
;                       @extended = number of coordinates transformed
;                  Failure - Returns an error code and sets @error:
;                       @error = 1 - Invalid input array dimensions
;                              = 2 - Invalid number of coordinate components (must be 2 or 3 elements)
;                              = 3 - Invalid number of coordinate components (must be 2 or 3 elements)
;                              = 4 - Too many points (over 50)
;                              = 5 - Failed to parse response as valid JSON
;                              = 6 - Response does not contain valid coordinate results
; Author ........: AspirinJunkie
; =================================================================================================
Func _geo_coordsTransform($sAPI_Key, $dSystemFrom, $dSystemTo, $aCoordinates, $sProxy = Default)
    Local $sCoordinates

    Switch UBound($aCoordinates, 0)
        Case 1
            ; check number of coordinate components (must be 2 or 3)
            If UBound($aCoordinates, 1) < 2 Or UBound($aCoordinates, 1) > 3 Then Return SetError(2, UBound($aCoordinates, 1), Null)
            
            $sCoordinates = _ArrayToString($aCoordinates, ",")

        Case 2
            ; check number of coordinate components (must be 2 or 3)
            If UBound($aCoordinates, 2) < 2 Or UBound($aCoordinates, 2) > 3 Then Return SetError(3, UBound($aCoordinates, 1), Null)

            ; MapTiler API-Limit = 50 Points per request
            If UBound($aCoordinates, 1) > 50 Then Return SetError(4, UBound($aCoordinates, 1), Null)

            $sCoordinates = _ArrayToString($aCoordinates, ",", -1, -1, ";")

        Case Else
            ; only 1D/2D Array as input coordinates
            Return SetError(1, UBound($aCoordinates, 0), Null)
    EndSwitch

    ; build Request-String
    Local $sOptExpVarStrings = Opt( "ExpandVarStrings", 1)
    Local $sRequest = 'https://api.maptiler.com/coordinates/transform/$sCoordinates$.json?s_srs=$dSystemFrom$&t_srs=$dSystemTo$&key=$sAPI_Key$'
    Opt( "ExpandVarStrings", $sOptExpVarStrings)

    ; send request
    Local $sResponse
    With ObjCreate("winhttp.winhttprequest.5.1")
        If IsKeyword($sProxy) <> 1 Then .SetProxy(2, $sProxy)
        .Open("Get", $sRequest, False)
        .Send()
        $sResponse = .ResponseText
    EndWith

    ; check if response is valid JSON
    Local $vResponse = _JSON_Parse($sResponse)
    If @error Then Return SetError(5, @error, $sResponse)

    ; check if response contains the result coordinates
    Local $aNewCoordsRaw = _JSON_Get($vResponse, ".results")
    If @error Then Return SetError(6, @error, $sResponse)

    ; convert result into 2D-Array
    Local $aNewCoordinates[UBound($aNewCoordsRaw, 1)][3], $mCoord, $iIdx = 0, $j, $sKey
    For $mCoord In $aNewCoordsRaw
        $j = 0
        For $sKey In MapKeys($mCoord)
            $aNewCoordinates[$iIdx][$j] = $mCoord[$sKey]
            $j += 1
        Next        
        $iIdx += 1
    Next

    Return SetExtended(UBound($aNewCoordinates), $aNewCoordinates)
EndFunc

Dann hast du zwischen zwei Koordinatenreferenzsystemen transformiert.
Aber eigentlich bist du da ja noch nicht am Ziel - oder?
So wie ich dich verstanden habe möchtest du auf dieser Basis Pixel in einer Karte ansprechen.
Es fehlt dir also immer noch eine Konvertierung von deinen transformierten Koordinaten in den Bildraum.
Je nach Genauigkeitsanforderung reicht hierfür evtl. schon aus die UTM-Koordinaten zu verschieben und zu skalieren.
Aber es muss halt noch getan werden.

Zitat von UPIA

mir fehlen 2 au3: JSON.au3, BinaryCall.au3

Du hast die falsche UDF gezogen.
Ich habe dir oben die richtige UDF verlinkt gehabt.
Hier nochmal ganz explizit auf die Datei direkt: JSON.au3.
Der zweite Hinweis da oben ist ebenso wichtig: Du musst dir erst noch einen API-Key dort besorgen.

Zitat von UPIA

woher hast du das script?

Das hab ich dir vorhin im Zug geschrieben.

Vielleicht hilft dieser Link weiter.

Individuelle Deutschlandkarte erstellen

dort kann man in einen "Kartenrohling" Orte seiner Wahl eintragen lassen...

Frohe Weihnachten

Peter