1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 9. März 2026 um 18:09
    Zitat von Andy

    den bekommt man nach dem $mCode = _JIT_Compile($sSourceCode)mit $mCode.BinaryString

    Das ist die "alte" Variante. Hier muss man sich aber selbst um die Offsets für die Funktionen kümmern.
    Da es hier nur eine Funktion gibt ist das aber nicht schädlich (und auf die Art sogar einfacher und kürzer).
    Aber allgemein rate ich nun dazu, stattdessen den String $mCode.ReusableString zu verwenden - dann liefert _JIT_LoadBinary() auch $mCode.Funcs.
    _JIT_LoadBinary() versteht beide Varianten.


    Ansonsten klappt bei mir Andys Version ebenso. Sieht wieder einmal äußerst schick aus :thumbup:

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 9. März 2026 um 15:36

    Ach Mensch. natürlich. war noch der alte Stand den ich im Kopf hatte. ja klar muss natürlich nun die andere variable sein. Sorry wegen der Verwirrung

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 9. März 2026 um 15:01

    Ich hatte die UDF vor nicht all zu langer Zeit aktualisiert. Schau also mal ob du die aktuelle Version hast.
    Hatte das so umgestellt, dass man direkt die Offsets der Funktionen mit als String erhält und die nicht extra erfassen muss.

    Zitat von UEZ

    $oHTTP.SetProxy(2, "localhost:3128")

    kann doch nicht funktionieren, da $oHTTP doch lokal in den Funktionen definiert wird, oder?

    Doch - ist ne globale. Genau so verwende ich es auch ab und an - daher bin ich mir äußerst sicher, dass das funktioniert (mit NTLM geht es aber glaube ich nicht).

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 9. März 2026 um 14:33

    Kompiliert ergibt das folgendes:

    AutoIt
    Global $sBinary = @AutoItX64 _
                      ? '{"b":"RYXAD46DAAAAQVRVV1aJ1lOF0n5wSInLRInHMclFMcBMY9pmZi4PH4QAAAAAAGaQRInARI0UiTHSTI0Mgw8fAInNjQRSMdVEMdBBiewPtsDB5QdBweQQgeUA/wAAQYHkAAD/AEQJ4AnoDQAAAP9BiQSRSIPCAUk503XFg8EBQQHwOc91q1teX11BXMPD","f":{"XorTexture":0}}' _
    				  : '{"b":"VVdWU4PsBItUJCCF0n5xi0QkHIXAfmmLRCQci3wkGDH2jRyFAAAAAIkcJC6NdCYAjSy2MdIujbQmAAAAAI12AInRjRxSMfEx64nID7bbweEHweAQgeEA/wAAJQAA/wAJ2AnIDQAAAP+JBJeDwgE5VCQcdcyDxgEDPCQ7dCQgdbCDxARbXl9dwgwA","f":{"XorTexture":0}}'
    Global $mCode = _JIT_LoadBinary($sBinary)

    Kompilieren klappt aber dann passiert nicht viel bei mir.

    Zitat von UEZ

    Vielleicht kann man ein Proxy mitgeben...

    Kann man:

    AutoIt
    #include "JIT.au3"
    $oHTTP.SetProxy(2, "localhost:3128")
  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 9. März 2026 um 13:28
    Zitat von Andy

    andere als C++-Compiler via _JIT_Compile() von der godbolt-Website einzusetzen

    Eigentlich gut möglich, jedoch müsste man sich dort das Thema der Relokationen nochmal genauer ansehen. Ich habe das ja durch eine manuelle Ersetzung realisiert. Ob die Bezeichnungen bei den anderen Compilern da gleich sind weiß ich nicht, da ich erstmal nur auf den GCC hin implementiert habe.

    Zitat von Andy

    Ich fände es besser, den C-Code direkt "inline" anzusprechen, wesentlich einfacher zu schreiben und zu debuggen.

    Dann bräuchte es aber eine Art Präprozessor der die au3-Datei entsprechend aufarbeitet.
    Das könnte man durchaus als ein Zusatzfeature mit einbauen.
    Ansonsten teile ich aber deine Grundproblem mit den Multi-Line-Strings in AutoIt: die sind einfach Mist.

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 6. März 2026 um 11:19

    Mal als Ergänzung: Ich hatte AutoIt allgemein längere Zeit liegen gelassen.
    Aber tatsächlich hat der Einsatz von KI da den Spaß wieder entflammt bei mir.
    Die Idee und technische Umsetzung bekomme ich bei den allermeisten Dingen hin.
    Aber was wirklich abfu**t ist der ganze Scheiß drumherum: Ordentlich formatieren, kommentieren, beschreiben, Codeverwaltung, Beispiele erstellen etc.
    Genau hier ist für mich KI bislang der absolute Game-Changer so dass ich mich jetzt wirklich nur auf den Teil konzentrieren kann der wirklich Spaß macht.

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 6. März 2026 um 10:38
    Zitat von Andy

    Wir waren damals ja an der "direkten" Übermittlung des assemblierten Codes an den Assembler hängengeblieben....

    Genau das!
    Ich konnte die Relokationen schlussendlich auflösen indem ich das ganze zweimal kompiliere (mit unterschiedlichen Parametern) und dort dann die Relocations entsprechend ersetzen kann.
    Das war der Durchbruch.

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    • AspirinJunkie
    • 6. März 2026 um 09:50

    JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Manchmal wünscht man sich, dass kritische Teile eines AutoIt-Skripts mit nativer Geschwindigkeit laufen könnten - Schleifen, numerische Algorithmen oder Bit-Operationen, für die AutoIt schlicht nicht gemacht ist. JIT.au3 ermöglicht es, C-Code als String zu schreiben, zur Laufzeit zu kompilieren und direkt aus AutoIt aufzurufen.

    Keine Compiler-Installation nötig. Alles was man braucht ist diese UDF und eine Internetverbindung.
    Die Kompilierung übernimmt die Compiler Explorer (Godbolt) API - der erzeugte Maschinencode wird in ausführbaren Speicher geladen und ist über DllCallAddress aufrufbar.

    GitHub: https://github.com/Sylvan86/autoit-jit-udf
    Download: Releases

    Schnellstart

    AutoIt
    #include "JIT.au3"
    
    ; C-Code schreiben - exportierte Funktionen mit CALLCONV kennzeichnen
    Global $sCode = _
        'CALLCONV double doubleIt(double x) {' & @LF & _
        '    return x * 2.0;                 ' & @LF & _
        '}'
    
    ; Über die Godbolt-API kompilieren
    Global $mCode = _JIT_Compile($sCode)
    
    ; Kompilierte Funktion aufrufen
    Global $aResult = DllCallAddress("double", $mCode.FuncPtr["doubleIt"], "DOUBLE", 21.0)
    ConsoleWrite("Ergebnis: " & $aResult[0] & @CRLF)  ; → 42.0
    
    ; Speicher freigeben
    _JIT_Free($mCode)
    Alles anzeigen

    Einmal kompilieren, immer wiederverwenden

    Zitat

    Bitte geht respektvoll mit der Godbolt-API um.
    Der Compiler Explorer ist ein freies Community-Projekt. Jeder Aufruf von _JIT_Compile sendet eine Anfrage an deren Server.

    Nach der ersten erfolgreichen Kompilierung kann der Binary-String gespeichert und wiederverwendet werden - keine weiteren API-Aufrufe nötig und deutlich schnellerer Start:

    AutoIt
    ; Erster Lauf: kompilieren und ReusableString notieren
    Global $mCode = _JIT_Compile($sCode)
    ConsoleWrite($mCode.ReusableString & @CRLF)  ; → diesen String speichern
    _JIT_Free($mCode)
    
    ; Alle weiteren Läufe: aus gespeichertem ReusableString laden (kein Internet nötig!)
    Global $mCode = _JIT_LoadBinary('{"b":"8g9YwMM","f":{"doubleIt":0}}')
    Global $aResult = DllCallAddress("double", $mCode.FuncPtr["doubleIt"], "DOUBLE", 21.0)

    Siehe examples/example_reuse.au3 im Repository für eine vollständige Anleitung.

    API-Übersicht

    FunktionBeschreibung
    _JIT_Compile($sCode)C-Code kompilieren und ausführbaren Speicher zurückgeben
    _JIT_LoadBinary($sBinary)Zuvor kompiliertes Binary laden (kein API-Aufruf)
    _JIT_Free($mCode)Ausführbaren Speicher freigeben
    _JIT_SetServer(...)Server, Compiler, Sprache und Proxy konfigurieren
    _JIT_GetCompilers()Verfügbare Compiler auflisten
    _JIT_GetLanguages()Verfügbare Sprachen auflisten
    _JIT_DescribeOpcode($sOp)Beschreibung eines Assembler-Opcodes abrufen

    Einschränkungen

    Diese UDF ist für kleine, eigenständige Code-Snippets gedacht - nicht für vollständige C-Projekte.

    • Keine #include-Unterstützung - die C-Standardbibliothek ist nicht verfügbar. Es gibt keinen Linker; der Code muss vollständig eigenständig sein.
    • Keine math.h-Funktionen - sin(), cos(), pow() usw. benötigen libm, das nicht gelinkt wird. Einige GCC-__builtin_*-Funktionen funktionieren als Inline-Alternativen (siehe examples/example_builtins.au3).
    • Internet für die Kompilierung erforderlich - mit _JIT_LoadBinary kann nach dem ersten Kompilieren offline gearbeitet werden.
    • Einzelne Übersetzungseinheit - der gesamte Code muss in einem String stehen, keine Mehrfach-Datei-Kompilierung.

    Beispiele

    Im Repository sind fünf Beispiele enthalten:

    • example_scalar.au3 - Grundprinzip: eine einfache Funktion kompilieren und aufrufen
    • example_array.au3 - Array an C übergeben: Kahan-Summation vs. naive Summation
    • example_string.au3 - String-Verarbeitung: Groß-/Kleinschreibung im Wechsel
    • example_builtins.au3 - GCC-__builtin_*-Funktionen: was funktioniert, was nicht
    • example_reuse.au3 - Kompilierte Binaries speichern und offline wiederverwenden

    Abhängigkeiten

    • JSON.au3 - JSON-UDF für die API-Kommunikation (im Release-Download enthalten)

    Danksagung

    Dieses Projekt wäre ohne den Compiler Explorer (Godbolt) von Matt Godbolt und Mitwirkenden nicht möglich. Es ist ein großartiges Open-Source-Werkzeug für die Programmier-Community. Bitte nutzt die API verantwortungsvoll.

  • Windows 11 Calculator - Prozess PID herausfinden

    • AspirinJunkie
    • 20. Februar 2026 um 13:16

    Achso du startest erst den Prozess und willst gleich die PID abfragen.
    Dann kann das natürlich sein, dass der Prozess noch nicht direkt danach in der Prozessliste auftaucht.

    Jetzt musst du aber mal das Endziel erläutern, damit klar ist was du eigentlich tatsächlich erreichen möchtest.
    Wenn es nur darum geht ein Programm zu starten und dessen Prozess-ID zu erhalten, dann reicht ein Run() alleine aus - der Rückgabe von Run ist ja eben diese Prozess-ID.

  • Windows 11 Calculator - Prozess PID herausfinden

    • AspirinJunkie
    • 19. Februar 2026 um 13:20

    Lässt sich bei mir nicht nachstellen (v3.3.18.0 x64).
    Ich erhalte die erwartete Ausgabe:

    Code
    CalculatorApp.exe
    PID: 21716
    PID: 21716
  • Dateipfad der im Windowsexplorer markierten Datei auslesen

    • AspirinJunkie
    • 2. Februar 2026 um 17:15
    Zitat von Lottich

    Kann man das umbauen, sodass nur der 1. Wert ($mExplWin["path"]) zurück kommt, ohne die Info´s der anderen Instanzen?

    $aExplorerWindows ist ein Array.
    Die Werte des Arrays sind einzelne Maps mit Infos zu den einzelnen Explorer-Fenstern.
    Momentan werden diese nach dem z-index sortiert.
    Daher ist das Fenster im Vordergrund bei dir das erste Element.
    Das erste Element eines AutoIt-Arrays liegt im Index [0].
    Sprich du musst $mExplWin = $aExplorerWindows[0] setzen, dann beinhaltet $mExplWin die Infos zum obersten Explorer-Fenster.

  • Dateipfad der im Windowsexplorer markierten Datei auslesen

    • AspirinJunkie
    • 2. Februar 2026 um 11:17

    Ich hatte mal eine ähnliche Funktion.
    Hab die mal schnell erweitert, so dass man die Rückgabe je nach gewünschtem Attribut sortiert zurückerhält:

    AutoIt
    #include <Array.au3>
    #include <WinAPIShPath.au3>
    #include <WinAPISysWin.au3>
    
    ; alle Explorerfenster abfragen und diese nach z-index sortieren so dass das vorderste Fenster im Index 0 steht
    Global $aExplorerWindows = _getSelectExplorerFiles(False, "z-index")
    
    For $mExplWin In $aExplorerWindows
    
    	ConsoleWrite("----------------------------"      & @CRLF & _ 
        "Path:           " & $mExplWin["path"]           & @CRLF & _ 
    	"Handle:         " & $mExplWin["handle"]         & @CRLF & _ 
    	"Z-Index:        " & $mExplWin["z-index"]        & @CRLF & _ 
    	"Creation-Index: " & $mExplWin["creation-index"] & @CRLF & _ 
        "----------------------------"                   & @CRLF & @CRLF)
    
    	_ArrayDisplay($mExplWin["selected"], $mExplWin["path"])
    Next
    
    
    ; #FUNCTION# ====================================================================================================================
    ; Name ..........: _getSelectExplorerFiles()
    ; Description ...: Returns an array of maps for currently opened explorer windows with path, handle, z-index and selected files
    ; Syntax ........: _getSelectExplorerFiles($bFullpath = True, $sSortBy = "z-index")
    ; Parameters ....: bFullpath - [Boolean]
    ;                            ↳ true: the full path of the selected files are returned
    ;                            ↳ false: only the names of the selected files are returned
    ;                  sSortBy   - [String] Key to sort by (ascending). Valid values:
    ;                            ↳ "z-index": window stacking order (0 = topmost)
    ;                            ↳ "creation-index": iteration order (creation order)
    ;                            ↳ "handle": window handle value
    ;                            ↳ "": no sorting (iteration order preserved)
    ; Return value ..: Success: [Array of Maps]: each map contains {path, handle, z-index, creation-index, selected}
    ;                  Failure: Null and set @error to:
    ;                           | 1: error during open Shell.Application
    ; Author ........: AspirinJunkie
    ; Modified.......: 2026-02-02
    ; Remarks .......: z-index: The smaller the z-index, the further the window is in the foreground.
    ;                  creation-index: iteration order of Shell.Windows (likely creation order, undocumented)
    ; Related .......: _WinAPI_PathCreateFromUrl(), _WinAPI_GetWindow()
    ; ===============================================================================================================================
    Func _getSelectExplorerFiles($bFullpath = True, $sSortBy = "z-index")
    	Local $oShell = ObjCreate("Shell.Application")
    	If Not IsObj($oShell) Then Return SetError(1, 0, Null)
    
    	Local $oWindows = $oShell.Windows, _
    	      $aReturn[$oWindows.Count], _
    	      $iCount = 0
    
    	For $oWin In $oWindows
    		Local $oSelectedFiles = $oWin.Document.SelectedItems()
    		If Not IsObj($oSelectedFiles) Then ContinueLoop
    
    		Local $aSelected[$oSelectedFiles.Count], $iC = 0
    		For $oFile In $oSelectedFiles
    			$aSelected[$iC] = $bFullpath ? $oFile.Path : $oFile.Name
    			$iC += 1
    		Next
    
    		Local $hWnd = HWnd($oWin.HWND)
    
    		; determine z-index
    		Local $iZIndex = -1, $hCurrent = $hWnd
    		Do
                $iZIndex += 1
    			$hCurrent = _WinAPI_GetWindow($hCurrent, $GW_HWNDPREV)
    		Until $hCurrent = 0
    
    		Local $mEntry[]
    		$mEntry["path"]           = _WinAPI_PathCreateFromUrl($oWin.LocationURL)
    		$mEntry["handle"]         = $hWnd
    		$mEntry["z-index"]        = $iZIndex
    		$mEntry["creation-index"] = $iCount
    		$mEntry["selected"]       = $aSelected
    
    		$aReturn[$iCount] = $mEntry
    		$iCount += 1
    	Next
    
    	; shrink to exact size
    	ReDim $aReturn[$iCount]
    
    	; Sort by specified key ascending
    	If $sSortBy <> "" Then
    		For $i = 1 To UBound($aReturn) - 1
    			Local $mTemp = $aReturn[$i]
    			Local $j = $i - 1
    			While $j >= 0 And ($aReturn[$j])[$sSortBy] > $mTemp[$sSortBy]
    				$aReturn[$j + 1] = $aReturn[$j]
    				$j -= 1
    			WEnd
    			$aReturn[$j + 1] = $mTemp
    		Next
    	EndIf
    
    	Return SetExtended(UBound($aReturn), $aReturn)
    EndFunc
    Alles anzeigen

    Damit kann man selbst festlegen ob man nach dem z-index sortiert haben möchte um die Fenster entsprechend ihrer Darstellungsreihenfolge anzuzeigen oder doch eher nach deren Erstellreihenfolge um die ältesten bzw. jüngsten Fenster zu verwenden.

  • AutoIt Community (GitHub Organization)

    • AspirinJunkie
    • 18. Januar 2026 um 19:18
    Zitat von water

    Frage: Verwendet Ihr eine grafische Oberfläche für Git? Falls ja, welche verwendet/empfehlt ihr?

    Meine persönliche Empfehlung hierzu wäre am Anfang erstmal rein auf Kommandozeilenebene mit git zu arbeiten.
    Irgendwann später - wenn soweit grundsätzlich klar ist was es da für Befehle gibt und was die genau machen, dann kann man auf grafische Tools umsteigen.
    Aber man hat dann den Vorteil, dass man das Konzept dahinter verinnerlicht hat und weiß was diese grafischen Tools im Hintergrund eigentlich genau tun.

    Übrigens: git for windows bringt bereits zwei GUI-Tools mit: git gui und gitk. Insbesondere gitk nutze ich gerne um schnell nen Überblick über ein Repository zu erhalten.

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

    • AspirinJunkie
    • 17. Dezember 2025 um 12:56
    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.

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

    • AspirinJunkie
    • 17. Dezember 2025 um 08:52
    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) :

    AutoIt
    #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
    Alles anzeigen


    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.

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

    • AspirinJunkie
    • 16. Dezember 2025 um 15:38
    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.

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

    • AspirinJunkie
    • 16. Dezember 2025 um 14:11

    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?

  • Anfängerfrage zum Ausführen einer Datei

    • AspirinJunkie
    • 12. Dezember 2025 um 09:05

    Das könnte durchaus am Programm selbst hängen.
    Es gibt mehrere Arten wie ein Programm Tastendrücke empfängt.
    Klassisch wären z.B. die Windows-Messages aber insbesondere Spiele nutzen auch andere Techniken wie z.B. Direct Input (gibts das noch?) oder gehen gleich auf den Raw-Input des Eingabegerätes.
    Send() nutzt intern die Windows-API-Funktion keybd_event und diese generiert eben diese Messages.

    Es kann also sein, dass der Flugsimulator diese Messages gar nicht auswertet, da er selbst anders auf Tastendrücke reagiert, bzw. eine Anti-Cheat-Engine derartige externe synthetische Messages verwirft.
    Man müsste also mal andere Methoden des Inputs probieren.
    Es gibt da z.B. noch die API-Funktion SendInput.
    Hier mal ein kleines Testskript, welches noch nicht sehr komfortabel ist aber F3 über SendInput triggern sollte:

    AutoIt
    ; Hotkey-Setup
    HotKeySet("{PAUSE}", _Stop)
    HotKeySet("{NUMPAD3}", _Send_F3)
    
    ; Endlosschleife um Skript am Leben zu halten
    Do
    	Sleep(20)
    Until 0
    
    
    Func _Send_F3()
    	; Sende F3 gedrückt:
        _SendInputKey(0x72, 0x3D, False)
    	If @error Then MsgBox("48", "Fehler bei down", "@error: " & @error & @CRLF & "@extended: " & @extended & @CRLF)
    	Sleep(10)
    
    	; Sende F3 losgelassen:
        _SendInputKey(0x72, 0x3D, True)
    	If @error Then MsgBox("48", "Fehler bei up", "@error: " & @error & @CRLF & "@extended: " & @extended & @CRLF)
    EndFunc
    
    Func _Stop()
    	Exit
    EndFunc
    
    
    Func _SendInputKey($iVK, $iScan, $bKeyUp)
        Local Static $tINPUT = @AutoItX64 _
    		? DllStructCreate("dword type; dword pad; ushort wVk; ushort wScan; dword dwFlags; dword time; uint64 dwExtraInfo; dword pad1; dword pad2") _
    		: DllStructCreate("dword type; ushort wVk; ushort wScan; dword dwFlags; dword time; dword dwExtraInfo; dword pad1; dword pad2"), _
    		$iStructSize = DllStructGetSize($tINPUT)
        
        DllStructSetData($tINPUT, "type", 1)     ; 1 = INPUT_KEYBOARD
        DllStructSetData($tINPUT, "wVk", $iVK)
        DllStructSetData($tINPUT, "wScan", $iScan)
        DllStructSetData($tINPUT, "dwFlags", $bKeyUp ? 2 : 0)
        DllStructSetData($tINPUT, "time", 0)
        DllStructSetData($tINPUT, "dwExtraInfo", 0x123)
        
        Local $aRet = DllCall("user32.dll", "uint", "SendInput", "uint", 1, "struct*", $tINPUT, "int", $iStructSize)
        
        If @error Then Return SetError(1, @error, False)
        If $aRet[0] = 0 Then Return SetError(2, 0, False)
        
        Return $aRet[0]
    EndFunc
    Alles anzeigen
  • _GDIPlus_ImageCalcDif

    • AspirinJunkie
    • 2. November 2025 um 19:33

    Grandios! "Script-Breaking" hinschreiben aber sich zum Inhalt komplett ausschweigen. "Internal optimisation" und fertig.

    Kein Mensch kann damit abschätzen in welchen Fällen es knallen wird. Sorry aber das ist wirklich wirklich unterirdisch unprofessionell.

    Edit: Ich rudere Mal ein Stück verbal zurück, da ich in dem Zusammenhang auch nichts von Script Breaking lese bislang.

  • PCIe 5 SSD

    • AspirinJunkie
    • 2. November 2025 um 08:31

    Ja das sind ja dann entsprechende Anwendungen.
    Diese habe ich persönlich nicht.
    Das habe ich vor einiger Zeit auch realisiert und daher hab ich da jetzt einen anderen Blick darauf.

    Aber dein Vergleich ging ja anscheinend allgemein SATA SSD --> M2. SSD.
    Ja das können tatsächlich heftige Unterschiede sein.
    Aber ob eine SSD 5.000 MBit/s schafft oder 15.000 Mbit/s wird (wenn man nicht, wie du, die entsprechenden Anwendungsfälle hat) man kaum bemerken (insb. beim angesprochenen USB3-Speicher-Kopieren ist man in beiden Fällen schon über dem Maximum).

    Zum Geraderücken: Das war nur für mein persönliches Anwendungsverhalten meine ganz eigenen Erkenntnisse zum Thema Performance.
    Wollte dir die SSD natürlich nicht madig reden (die ist offensichtlich ja wirklich gut). War nur ein allgemeiner Gedankengang zur Performancediskussion.

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™