Beiträge von alpines

Bitte beim nächsten Mal deinen Code in die entsprechenden Tags packen oder im Editor "Code"-anklicken, einfügen und als Highlighter AutoIt nehmen.

Guck doch mal in die _HexToString-Funktion rein, die arbeitet mit UTF-8 und deine Datei scheint ANSI-formatiert zu sein. Ein kleiner Test zeigt das ganze auch:

#include <FileConstants.au3>
#include <MsgBoxConstants.au3>
#include <String.au3>
#include <Array.au3>

;Assign the file path to a variable
Local $sFilePath = "test.txt"

$hFileOpen = FileOpen($sFilePath, 16)

$sBinary = FileRead($hFileOpen)
$sStringANSI = BinaryToString($sBinary, $SB_ANSI)
$sStringUTF8 = BinaryToString($sBinary, $SB_UTF8)

ConsoleWrite($sBinary & @CRLF)
ConsoleWrite($sStringANSI & @CRLF)
ConsoleWrite($sStringUTF8 & @CRLF)

ConsoleWrite(StringToBinary($sStringANSI, $SB_ANSI) & @CRLF)
ConsoleWrite(StringToBinary($sStringUTF8, $SB_UTF8) & @CRLF)

;Close the handle returned by FileOpen.
FileClose($hFileOpen)

Was genau hast du denn mit dem Code, den du gerade gepostet hast, versucht und was glaubst du macht er?

Für welches Spiel ist denn das?

Wenn du uns dein Script nicht komplett zeigst können wir dir auch nicht helfen.

Der Wert springt nur auf die 1 zurück wenn du auch irgendwo $i = 1 setzt, ich schätze mal du rufst die Global $i = 1 Zeile mehrmals auf.

Du fragst nur einmal die Farbe und die Position des Mauszeigers ab, obwohl du das andauernd machen müsstest.

Da sind auch noch andere Fehler im Script. Du brauchst nämlich kein Hex() auf Farbwerte anzuwenden, denn 16 ist nur eine andere Repräsentation von 0x10.

AutoIt sieht (sofern beides Zahlenvariablen sind) keinen Unterschied 16 = 0x10 = True.

Hier mal das Script (korrigiert, da haben Teile gefehlt) mit der Farbe des SciTE-Editors, die Formatierung habe ich nicht angepasst, das solltest du aber nochmal üben.

;Definierungen und Variablen
$scitegrau = 0xF0F4F9

Opt("TrayAutoPause",0)

HotKeySet("a", "_farben")

local $i = 0

Func _farben()
    $point = MouseGetPos()
    $color = PixelGetColor($point[0],$point[1])

    If $color = $scitegrau then
       MsgBox(0,"Farbe","Ist Gleich")
       ;$i = $i + 1
       sleep(1000)


    ElseIf $color <> $scitegrau then
      MsgBox(0,"Farbe","Ist Ungleich" & "-" & Hex($color,6))
       ;$i = $i + 1
       sleep(1000)
    EndIf
EndFunc

While 1
sleep(100)
WEnd

Nebenbei gefragt: Wofür brauchst du denn das ganze? Es gibt bestimmt eine bessere Möglichkeit das Problem anzugehen welches du mit Pixelwerten zu lösen versuchst.

Du musst die selben Abfragen wie bei dem Until verwenden. Momentan fragst du ab ob ein Array true ist, was absolut daneben ist.

Du fragst im Until die Koordinaten ab, frag doch einfach nach der Until nochmal ab und dann springst du in If-Blöcke wenn die Maus dort ist führe das Makro aus, wenn die Maus woanders ist führe das Makro aus.

Zitat von Xorianator

Danke, wieder was gelernt

Ich hab ein kleines Beispielprogramm geschrieben und das zeigt das ganze auch schön:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    const int TEST_SIZE = 5000;

    void* pSpaceMalloc = malloc(TEST_SIZE);
    void* pSpaceCalloc = calloc(TEST_SIZE, 1);

    int counterMalloc = 0;

    char* pMalloc = (char*)(pSpaceMalloc);

    for (int i = 0; i < TEST_SIZE; i++)
    {
        if (*pMalloc != 0) counterMalloc++;
        pMalloc += 1;
    }

    printf("Non-Zeroes Malloc: %d\n", counterMalloc);


    int counterCalloc = 0;

    char* pCalloc = (char*)(pSpaceCalloc);

    for (int i = 0; i < TEST_SIZE; i++)
    {
        if (*pCalloc != 0) counterCalloc++;
        pCalloc += 1;
    }

    printf("Non-Zeroes Calloc: %d", counterCalloc);
    getchar();

    return 0;
}

Non-Zeroes Malloc: 18
Non-Zeroes Calloc: 0

Zitat von Xorianator

Ist es denn 100% gewährleistet, dass der Speicher für das Bool auch wirklich 0 ist? Ich meine es gab da was, dass man nicht gewährleisten kann, was im Speicher drinnen steht. Würde das dann nicht im Extremfall zum Ausbleiben von gefundenen Pixeln führen?

Dafür gibt es ja calloc. malloc stellt dir nur den Speicher zur Verfügung, zur Sicherheit sollte man diesen mit Nullen überschreiben.

Wieso probierst du nicht mal mit einer älteren AutoIt-Version den Installer zu kompilieren?

Wenn euer eigentliches Script mit dem aktuellsten AutoIt ausgeliefert wird und der Installer z.B. mit 3.3.8.1 ist das ja eigentlich kein Problem.

Zitat von autoiter

EDIT: Nach etwas überlegen, weiß ich gar nicht, ob das wirklich bei so großen Paketen praktikabel ist. So groß waren meine integrierten Pakete noch nie.

Ich weiß nicht ob das überhaupt sinnvoll wäre, wenn AutoIt den String dann als ganzes liest, dann landen im Arbeitsspeicher 600 MB Dateien.

FileInstall schafft das ganze ohne den RAM zu überladen glaube ich.

Zitat von BugFix

da hast du null Möglichkeit zum Automatisieren.

Man möge mir auf die Finger hauen aber es gibt ja noch _ImageSearch.

Zitat von Xorianator

mit einem klitzekleinen Fehler

Da hast du natürlich recht, besser wäre wohl 0x1000000 oder zur besseren Veranschaulichung deine Version mit 0xFFFFFF + 1.

Den anderen "Fehler" hatte Oscar ja schon gewähnt: Lieber BitAND nutzen, ansonsten muss man erst prüfen, ob das Bild Transparenz besitzt.

Ich weiß allerdings nicht ob BitAnd() oder die einfache Subtraktion (mit kurzer Prüfung im voraus) schneller ist.

// Ein kleiner Test zeigt, dass beim Testbild die BitAnd Variante bei mir um etwa 100ms langsamer ist.

Zitat von autoiter

Wieso ist hier die Zuweisung in ein Array schneller, alpines?

Nun, ich könnte dir eine komplizierte Erklärung liefern mit Suchlaufzeiten (O(n) etc) und B+ Bäumen aber ich halt es mal kurz und knapp:

Der Arrayzugriff benötigt eine konstante Laufzeit,

da der Index direkt angesprochen ist und man mittels $pArrayBase + $iIndexOffset * sizeof($array_entry) den Eintrag direkt adressieren kann.

Dictionaries sind vermutlich als Bäume implementiert und um einen Eintrag zu finden musst du den Suchbaum durchgehen und immer deinen Eintrag suchen, das kann bei einer effizienten Implementierung auf etwa logarithmische Laufzeit heruntergebrochen werden.

Der Vorteil der Baumimplementation allerdings wird schnell ersichtlich: Es wird Unmengen an Speicherplatz gespart, da man für jede existierende Farbe Speicher benötigt und in einem Suchbaum nur die Farben gespeichert werden die bisher gefunden wurden.

Würde man das Array mit jeder gefundenen Farbe redimmen und den Index vergleichen wäre das DEUTLICH langsamer als die Dictionaryvariante.

//Edit: Dictionaries können aber auch als Hash implementiert sein, die Baumimplementation ist nur eine von vielen Möglichkeiten.

Ohne Hex-Funktion ist es bei mir rund 700ms langsamer als die Arrayvariante.

Mit Arrays (vorausgesetzt es existiert keine Transparenz, da das sonst die Arraygrößen sprengt) schaffe ich es in rund 1300ms.

Den Speicherverbrauch von 80 Megabyte ignorieren wir mal

$iW * $iH = 708197 px
Zeit: 1366 ms
Anzahl der Farben: 99394

#include <GDIPlus.au3>

Global $sImagefile = @ScriptDir & '\test.jpg'
Global $aColor[0xFFFFFF]

_GDIPlus_Startup()
Global $hImage = _GDIPlus_BitmapCreateFromFile($sImagefile)
$iTimer = TimerInit()
$iCount = _GetUniqueColors($hImage)
ConsoleWrite('Zeit: ' & Int(TimerDiff($iTimer)) & ' ms' & @CR)
ConsoleWrite('Anzahl der Farben: ' & $iCount & @CR)
_GDIPlus_BitmapDispose($hImage)
_GDIPlus_Shutdown()
Exit

Func _GetUniqueColors(ByRef $hImage)
    $iColorCounter = 0

    Local $iW, $iH, $tBitmapData, $pScan0, $tPixel, $iOffset, $iColor, $oUnique = ObjCreate('Scripting.Dictionary')
    $iW = _GDIPlus_ImageGetWidth($hImage)
    $iH = _GDIPlus_ImageGetHeight($hImage)
    $tBitmapData = _GDIPlus_BitmapLockBits($hImage, 0, 0, $iW, $iH, $GDIP_ILMREAD, $GDIP_PXF32ARGB)
    $pScan0 = DllStructGetData($tBitmapData, 'Scan0')
    $tPixel = DllStructCreate('uint[' & $iW * $iH & '];', $pScan0)
    ConsoleWrite('$iW * $iH = ' & $iW * $iH & ' px' & @CRLF)
    For $iY = 0 To $iH - 1
        $iOffset = $iY * $iW + 1
        For $iX = 0 To $iW - 1
            $iColor = DllStructGetData($tPixel, 1, $iOffset + $iX) - 0xFF000000
            $aColor[$iColor] += 1
            If $aColor[$iColor] = 1 Then $iColorCounter += 1
        Next
    Next
    _GDIPlus_BitmapUnlockBits($hImage, $tBitmapData)
    $tPixel = 0
    Return $iColorCounter
EndFunc

Wenn du mit dem Handle arbeitest, dann wird die DLL einmal geöffnet (mit DLLOpen) und später von dir einmal geschlossen (DLLClose).

Gibst du nur den Dateipfad der DLL an, so wird ausnahmslos bei jedem DLLCall, der mit der Pfadangabe arbeitet, die DLL geöffnet und geschlossen.

Das kann bei mehreren hundert/tausend DLL-Aufrufen ziemlich CPU/HDD belastend sein und die Performanz des Skriptes beeinflussen, da bei jedem Aufruf die DLL geöffet+geschlossen werden muss.

Eventuell kann es noch sein, dass beim DLLOpen das FileHandle gesperrt wird und man die Datei nicht löschen kann, bei DLLCall wäre das dann nur während des Calls.

Da man im Normalfall aber nicht mehrere tausend Male die Sekunde eine DLL aufruft (ein Fall wäre z.B. _IsPressed mit der user32.dll), kann man ruhig die Pfadangabe verwenden.

Einfach alles 1:1 abtippen und nur bisschen verändert und schon läuft das ganze

Hab es mit dem "3754 KC 75" String getestet und der Code der entsteht ist der selbe der im Testprogramm auf der Website angezeigt wird.

Ich hab das Script nicht verschönert. Variablennamen sind exakt die selben, damit du siehst welche Zeile ich wie übersetzt habe.

#cs
    $ String
    % Int32
    & Int64
    ! Single
    # Double
    @ Decimal

    &H Hex
    &O Oct
#ce

MsgBox(0,0,Code128("3754 KC 75"))

Func Code128($chaine)
    Local $i, $checksum, $mini, $dummy ;Integer
    Local $tableB = False              ;Boolean

    Local $Code128 = "" ;Return Wert

    If StringLen($chaine) > 0 Then
        For $i = 1 To StringLen($chaine)
            Switch Asc(StringMid($chaine, $i, 1))
                Case 32 To 126
                Case 203

                Case Else
                    $i = 0
                    ExitLoop ;Exit For
            EndSwitch
        Next

        $Code128 = ""
        $tableB = True

        If $i > 0 Then
            $i = 1

            While $i <= StringLen($chaine)
                If $tableB Then
                    $mini = ($i = 1 or $i + 3 = StringLen($chaine)) ? 4 : 6 ; IIF

                    testnum($chaine, $mini, $i)

                    If $mini < 0 Then
                        If $i = 1 Then
                            $Code128 = Chr(210)
                        Else
                            $Code128 = $Code128 & Chr(204)
                        EndIf

                        $tableB = False
                    Else
                        If $i = 1 Then $Code128 = Chr(209)
                    EndIf
                EndIf

                If Not $tableB Then
                    $mini = 2

                    testnum($chaine, $mini, $i)

                    If $mini < 0 Then
                        $dummy = Number(StringMid($chaine, $i, 2))
                        $dummy = ($dummy < 95) ? ($dummy + 32) : ($dummy + 105)
                        $Code128 = $Code128 & Chr($dummy)
                        $i = $i + 2
                    Else
                        $Code128 = $Code128 & Chr(205)
                        $tableB = True
                    EndIf
                EndIf

                If $tableB Then
                    $Code128 = $Code128 & StringMid($chaine, $i, 1)
                    $i = $i + 1
                EndIf
            WEnd

            For $i = 1 To StringLen($Code128)
                $dummy = Asc(StringMid($Code128, $i, 1))
                $dummy = ($dummy < 127) ? ($dummy - 32) : ($dummy - 105)
                If $i = 1 Then $checksum = $dummy
                $checksum = Mod($checksum + ($i - 1) * $dummy, 103)
            Next

            $checksum = ($checksum < 95) ? ($checksum + 32) : ($checksum + 105)
            $Code128 = $Code128 & Chr($checksum) & Chr(211)
        EndIf
    EndIf

    Return $Code128 ;Exit Function
EndFunc

Func testnum(ByRef $chaine, ByRef $mini, ByRef $i)
    $mini = $mini - 1
    If $i + $mini <= StringLen($chaine) Then
        While $mini >= 0
            If Asc(StringMid($chaine, $i + $mini, 1)) < 48 OR Asc(StringMid($chaine, $i + $mini, 1)) > 57 Then ExitLoop
            $mini = $mini - 1
        WEnd
    EndIf
EndFunc