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. chesstiger

Beiträge von chesstiger

  • Update Funktion

    • chesstiger
    • 31. Januar 2018 um 15:54

    Also... Falls es nicht um eine exorbitant hohe Nutzerzahl geht und wir nur von einem geschlossenen, internen Netzwerk reden... Pack doch einfach immer die aktuellste EXE in eine Netzwerkfreigabe und erstelle bei den Anwendern nur eine direkte Verknüpfung auf diese Datei. Wenn du dann die Datei auf dem Server aktualisierst, führen alle Nutzer automatisch diese neue Datei aus.

  • Trigger einbauen

    • chesstiger
    • 31. Januar 2018 um 15:22

    Alternativ kann man auch was ohne Dateien mit TCP und Singleton bauen.

  • Trigger einbauen

    • chesstiger
    • 31. Januar 2018 um 11:30

    Aufruf von was?

    Was genau hast du vor? Klingt nämlich wirklich etwas blöd, vielleicht kann man das ja noch schöner lösen.

  • Script zum beheben der "Script breaking changes"

    • chesstiger
    • 30. Januar 2018 um 23:12

    Also... Generell sind Magic Numbers erstmal schlecht. Per se lässt sich ein Skript mit sprechenden Konstanten wesentlich schöner lesen. Allerdings kann es u.U. einfach angenehmer sein, direkt die Zahl zu schreiben. Und mit einigen Jahren Programmiererfahrung (besser: AutoIt- und Win32-Erfahrung) _weiß_ man halt einfach etliche Konstanten auswendig. Die bereits genannte -3 für GUI_EVENT_CLOSE ist fast jedem bekannt und wenn nicht durch den Kontext trotzdem schnell zuordbar. Da ist das in Ordnung, finde ich.

    Und ehrlich gesagt gibt es auch einige Bereiche, die in AutoIt nicht durch Standard-Konstanten abgedeckt sind. Die meisten Errorcodes bspw. haben keine äquivalente Konstante. Oder -1 für das letzte Control bei GUI-Befehlen. Ist streng genommen auch eine Magic Number.

    Zusammengefasst finde ich, dass man in vernünftigen Mengen durchaus Literale statt Konstanten verwenden kann. Solange man nicht die Übersicht verliert.

  • SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

    • chesstiger
    • 6. Januar 2018 um 23:33

    Huhu!

    Irgendwie überfällt mich immer im Januar die Lust, etwas an diesem Stück Software zu machen. Daher ist jetzt das "schöne" Definieren von Strukturen dazugekommen. Mich nervt es immer ziemlich, Strukturen als Strings schreiben zu müssen. Das wird irgendwie schnell unübersichtlich, finde ich. Denkbar wäre noch ein GetAddress-Operator (also statt DllStructGetPtr($tMyStruct) ein ByRef $tMyStruct oder so)...

    Kurzes Beispiel (aus der README):

    Code
    BeginStruct point_t
        int x
        int y
    EndStruct
    
    
    Local Struct point_t $tPointA, $tPointB
    
    
    $tPointA.x = 1
    $tPointA.y = 2
    $tPointB.x = 6
    $tPointB.y = 3
    
    
    ConsoleWrite("Distance: " & getDist($tPointA, $tPointB) & @CRLF)
    
    
    Func getDist($tA, $tB)
        Return Sqrt(($tA.x - $tB.x)^2 + ($tA.y - $tB.y)^2)
    EndFunc
    Alles anzeigen


    Alles wie immer im Repo!

  • Viele Sub-Funktionen in einer main Funktion hinzufügen/entfernen

    • chesstiger
    • 6. Januar 2018 um 07:20

    alpines Du musst nach dem BitAnd auf Gleichheit mit $GUI_CHECKED prüfen. Sonst reicht ein gemeinsames Bit von aktuellem Status und $GUI_CHECKED für das Auslösen der Bedingung.

  • Alt tab in AutoIt nachbauen für ein Programm - Windows

    • chesstiger
    • 5. Januar 2018 um 01:56

    Das ist etwas tricky. Was ähnliches habe ich schon mal geschrieben. Das Problem dabei ist, von allen Fenstern ein Screenshot zu erstellen. Eigentlich kann man von minimierten Fenstern keinen Screenshot erstellen, dafür bedarf es eines kleinen Tricks und relativ viel WinAPI-Wissen. Dafür habe ich mir aber schon vor Jahren eine kleine UDF geschrieben.

    Genau wie für das Auflisten aller Fenster eines Prozesses, gefiltert nach Klassennamen. Ich hab daraus mal fix ein Beispiel für Mozilla Firefox gebastelt:

    C
    #include <GDIPlus.au3>
    #include <WindowsConstants.au3>
    #include <WinAPI.au3>
    #include <WinAPIProc.au3>
    #include <WinAPIDiag.au3>
    #include <GDIPlus.au3>
    #include <Math.au3>
    ;prevent autoit BUG
    DllCall("user32.dll", "bool", "SetProcessDPIAware")
    Opt("MustDeclareVars", True)
    _GDIPlus_Startup()
    Global $ahCaptures[4]
    Global $hMainWnd = GUICreate("Browser Screen Preview", 600, 400)
    Global $hGfx = _GDIPlus_GraphicsCreateFromHWND($hMainWnd)
    Global $hBmp = _GDIPlus_BitmapCreateFromGraphics(600, 400, $hGfx)
    Global $hBuf = _GDIPlus_ImageGetGraphicsContext($hBmp)
    ;register handlers
    OnAutoItExitRegister(exitProgram)
    AdlibRegister(updateWindowPreviews, 2000)
    updateWindowPreviews() ;initial call
    GUISetState()
    While True
    Switch GUIGetMsg()
    Case -3
    Exit
    EndSwitch
    _GDIPlus_GraphicsClear($hBuf, 0xffffffff) ;white background
    If $ahCaptures[0] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[0], 0, 0, 300, 200)
    If $ahCaptures[1] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[1], 300, 0, 300, 200)
    If $ahCaptures[2] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[2], 0, 200, 300, 200)
    If $ahCaptures[3] Then _GDIPlus_GraphicsDrawImageRect($hBuf, $ahCaptures[3], 300, 200, 300, 200)
    _GDIPlus_GraphicsDrawImage($hGfx, $hBmp, 0, 0)
    WEnd
    Func updateWindowPreviews()
    Local $aWndList, $iWinCount, $hWnd, $i
    $aWndList = getProcessWindows("firefox.exe", "^MozillaWindowClass$")
    $iWinCount = _Min(4, UBound($aWndList)) ;maximum of four windows
    For $i = 0 To 3
    $ahCaptures[$i] = Null
    Next
    For $i = 0 To $iWinCount - 1
    $hWnd = $aWndList[$i]
    $ahCaptures[$i] = captureWindow($hWnd)
    $ahCaptures[$i] = _GDIPlus_BitmapCreateFromHBITMAP($ahCaptures[$i]) ;gdiplus workaround
    Next
    EndFunc   ;==>updateWindowPreviews
    Func exitProgram()
    ;dispose gdi resources
    _GDIPlus_GraphicsDispose($hBuf)
    _GDIPlus_BitmapDispose($hBmp)
    _GDIPlus_GraphicsDispose($hGfx)
    _GDIPlus_Shutdown()
    ;make sure to re-enable window animations
    setMinAnimation(True)
    EndFunc   ;==>exitProgram
    ; - - - MULTI PURPOSE FUNCTIONS - - -
    Func getProcessWindows($sWantedProcess, $sClassFilter = ".*")
    ;by chesstiger
    Local $iPID, $oRet, $ahWindows, $i
    $oRet = ObjCreate("System.Collections.ArrayList")
    $ahWindows = _WinAPI_EnumWindows()
    For $i = 1 To $ahWindows[0][0]
    _WinAPI_GetWindowThreadProcessId($ahWindows[$i][0], $iPID) ;byref!
    If _WinAPI_GetProcessName($iPID) = $sWantedProcess Then
    If StringRegExp($ahWindows[$i][1], $sClassFilter) Then $oRet.add($ahWindows[$i][0])
    EndIf
    Next
    Return $oRet.toArray()
    EndFunc   ;==>getProcessWindows
    Func captureWindow($hWnd, $iWidth = -1, $iHeight = -1)
    ;by chesstiger
    ;with minimized window workaround
    Local $hDDC, $hCDC, $hBmp
    Local $tWindowPlacement, $bMinimized, $iOldLong
    $tWindowPlacement = _WinAPI_GetWindowPlacement($hWnd)
    $bMinimized = ($tWindowPlacement.showCmd = @SW_SHOWMINIMIZED)
    If $bMinimized Then
    setMinAnimation(False) ;disable animations
    $iOldLong = _WinAPI_GetWindowLong($hWnd, $GWL_EXSTYLE) ;make window invisible
    _WinAPI_SetWindowLong($hWnd, $GWL_EXSTYLE, BitOR($iOldLong, $WS_EX_LAYERED))
    _WinAPI_SetLayeredWindowAttributes($hWnd, 0, 0, $LWA_ALPHA)
    _WinAPI_ShowWindow($hWnd, @SW_RESTORE) ;restore window
    EndIf
    ;real screenshot
    If $iWidth = -1 Then $iWidth = _WinAPI_GetWindowWidth($hWnd)
    If $iHeight = -1 Then $iHeight = _WinAPI_GetWindowHeight($hWnd)
    $hDDC = _WinAPI_GetDC($hWnd)
    $hCDC = _WinAPI_CreateCompatibleDC($hDDC)
    $hBmp = _WinAPI_CreateCompatibleBitmap($hDDC, $iWidth, $iHeight)
    _WinAPI_SelectObject($hCDC, $hBmp)
    _WinAPI_PrintWindow($hWnd, $hCDC)
    _WinAPI_BitBlt($hCDC, 0, 0, 0, 0, $hDDC, 0, 0, 0x00330008)
    _WinAPI_ReleaseDC($hWnd, $hDDC)
    _WinAPI_DeleteDC($hCDC)
    If $bMinimized Then
    _WinAPI_ShowWindow($hWnd, @SW_MINIMIZE) ;minimize window
    _WinAPI_SetWindowLong($hWnd, $GWL_EXSTYLE, $iOldLong) ;make window visible again
    setMinAnimation(True) ;re-enable animations
    EndIf
    Return $hBmp
    EndFunc   ;==>captureWindow
    Func setMinAnimation($bState)
    ;by chesstiger
    Local Const $SPI_SETANIMATION = 0x0049
    Local Const $tagANIMATIONINFO = "uint cbSize;int iMinAnimate"
    Local $tAnimInfo
    $tAnimInfo = DllStructCreate($tagANIMATIONINFO)
    $tAnimInfo.iMinAnimate = $bState
    $tAnimInfo.cbSize = DllStructGetSize($tAnimInfo)
    _WinAPI_SystemParametersInfo($SPI_SETANIMATION, $tAnimInfo.cbSize, DllStructGetPtr($tAnimInfo))
    EndFunc   ;==>setMinAnimation
    Alles anzeigen


    Auf der Basis kannst du vermutlich recht leicht etwas basteln. ^^

  • AlignComment richtet Kommentare aus Update 13.08.2016

    • chesstiger
    • 4. Januar 2018 um 22:35

    fakeraol

    Nein, \" muss man nicht beachten. In AutoIt maskiert man das mit einer Doppelung. Und da man von vorne nach hinten durchgeht, kann man alles nach einem " bis zu einem einzelnen " ignorieren. Wenn dazwischen zwei doppelte Anführungszeichen hintereinander oder beliebig viele einzelne Anführungszeichen stehen, werden die korrekterweise übergangen.

  • AlignComment richtet Kommentare aus Update 13.08.2016

    • chesstiger
    • 4. Januar 2018 um 21:30

    Man muss das ja nicht mittels RegExp lösen.

    Ganz trivial: Gehe die Datei zeichenweise (!) durch. Wende dabei folgende Regeln an:

    1. Falls man auf die Sequenz #cs stößt, alles bis zur Sequenz #ce entfernen (ggf. auch die ausgeschriebene Variante beachten).
    2. Falls man auf das Zeichen ; stößt, alles bis zur Sequenz CRLF entfernen.
    3. Falls man auf das Zeichen " stößt, alles bis zum nächsten einzelnen " ignorieren.
    4. Falls man auf das Zeichen ' stößt, alles bis zum nächsten einzelnen ' ignorieren.

    Mir fällt so nichts ein, was das kaputt machen würde...

  • control über Text erkennen

    • chesstiger
    • 3. Januar 2018 um 22:38

    Ein paar Ansätze bzw. dafür nützliche Win32-Funktionen:

    EnumChildWindows

    GetWindowThreadProcessId

    EnumWindows

  • TCP Server / Mehrere Clients und TCP Send

    • chesstiger
    • 3. Januar 2018 um 21:19

    Randbemerkung: Im EN-Forum gibt es eine tolle, eventbasierte TCP-UDF (von Kip, meine ich), mit der man ziemlich gut Server und Client schreiben kann. Sehr zu empfehlen.

  • Control-Positionierung/Skalierung bei resizable GUIs

    • chesstiger
    • 3. Januar 2018 um 00:28

    Plattformunabhängigkeit schadet auf jeden Fall nicht.

    Dabei ist noch zu beachten, dass sich nicht für alle genannten Bibliotheken mit einfachen Mitteln AutoIt-Bindings erstellen lassen. Als Beispiel sei hier Qt genannt: Qt wurde in C++ geschrieben und baut sehr stark auf dessen Objektorientierung auf. Das ist in AutoIt nicht wirklich angenehm zu händeln und lässt sich auch schlecht abbilden. Im Idealfall nimmt man daher eine C-Bibliothek wie Gtk+, denke ich. Trotz GObject geht das definitiv besser.

    Wobei es eigentlich kein Problem darstellt, ein paar DLLs mitzuliefern. Erstens nehmen die nicht wirklich viel Speicherplatz ein und zweites stehen die meisten Toolkits unter Lizenzen wie der LGPL, was eine Weitergabe recht leicht macht.

  • Control-Positionierung/Skalierung bei resizable GUIs

    • chesstiger
    • 30. Dezember 2017 um 03:27

    Zunächst... Es gibt zig verschiedene GUI-Toolkits, mit denen du ein Fenster erzeugen und zeichnen kannst. Dabei ist das alles historisch gewachsen und dadurch auch etwas verworren. Die neueren arbeiten mit dynamischen Layouts, die älteren (wie bei AutoIt zu sehen) mit pixelgenauen Layouts. In der Unix/Linux-Welt sind da bekannte Vertreter Qt, wxWidgets oder GTK+. Auch Microsoft hat im Laufe der Zeit einige Toolkits entwickelt. DotNet verwendet bspw. WinForms. Dann gibt es noch WPF (Windows Presentation Foundation) für VC++. Und zu guter letzt existiert noch das wohl älteste Framework in diesem Bereich, nämlich Win32, auch einfach bekannt als WinAPI.

    Die WinAPI ist aber fest an Pixellayouts gebunden. Es besteht theoretisch die Möglichkeit, ein anderes Framework aus AutoIt aufzurufen. Allerdings ist mir keine UDF in dem Bereich bekannt.

  • String filtern

    • chesstiger
    • 26. Dezember 2017 um 14:09

    Na klar, das kann ja auch nicht funktionieren. Das Pattern besagt ausgeschrieben (und etwas vereinfacht).... Suche nach "<noscript" gefolgt von null oder mehr beliebigen Zeichen bis auf "%" gefolgt von "</noscript>". Es hakt an dem ausgeschlossenen Prozentzeichen, was ja ganz klar durch das URL-Encoding vorkommt (bspw. "/info/DE/1.Das1%2C1"). Wenn du [^%] (alles bis auf "%") durch . (beliebiges Zeichen) ersetzt, klappt das hier.

  • Meldetext mit automatischen Zeilenumbruch

    • chesstiger
    • 18. Dezember 2017 um 13:41

    Man könnte sich was mit GDI+ bauen. Die Funktion _GDIPlus_GraphicsMeasureString erlaubt es, einen Text ziemlich gut in der Größe anzupassen. Am einfachsten zu kalkulieren wäre das aber mit einer Monospace-Schriftart.

  • GetUniqueColors

    • chesstiger
    • 15. Dezember 2017 um 08:44

    Andy Die MT-Variante mit bits steht ja irgendwo. Ist aber leider auch langsamer.

    Davon ab... Ich habe jetzt auch etwas rumprobiert. Eigentlich sollte RadixSort hier das mit Abstand schnellste sein. Im Durchschnittsfall (ist hier gegeben) hat QuickSort die Komplexitätsklasse O(n*log(n)), wie alle besseren vergleichenden Sortieralgorithmen. RadixSort liegt aber in O(n), ist also linear. Der Zeitbedarf steigt also linear mit jedem neuen zu sortierenden Objekt.

    Wobei RadixSort nur effizient ist, wenn die maximale Schlüssellänge eher klein ist. Wenn man das klassischs RadixSort nimmt, wird nach Dezimalstellen sortiert, bei einem Int sind das dann maximal 10 Stellen. Das Problem ist wie gemacht für diesen Sortieralgorithmus. Spätestens bei großen Datenmengen sollte er gewinnen. Tut er aber nicht... Ich hab nur noch nicht raus, warum.

  • GetUniqueColors

    • chesstiger
    • 14. Dezember 2017 um 11:09

    Ich glaube, das kann man z.B. mit RadixSort noch schneller lösen. RadixSort hat (bei bekannter Schlüssellänge, bei uns 32 bit) eine lineare Laufzeit, also O(l*n), nicht O(n*log(n)) wie QuickSort. Ich bastel nachher mal was in C...

  • GetUniqueColors

    • chesstiger
    • 29. November 2017 um 20:57

    Für ein ARGB-Bild benötigt man aber nicht zwangsweise 4 GB Speicher! Man kann den Speicherbedarf erheblich reduzieren, man muss nur bisher ungenutzten Speicher effektiv nutzen.

    Im Endeffekt haben wir für jede mögliche Farbe (das sind 2^32 + 1, von #00000000 bis #FFFFFFFF) nur die Information, ob sie auftritt oder nicht. Zwei mögliche Zustände... Das schreit doch nach der Kodierung in einem Bit!

    Man kann zum Beispiel ein 2^28 + 1 Array of Short (2 Byte) verwenden. (2^28 + 1) * 2 Byte = 536.870.914 Byte = 512 MByte. Das ist zwar auch nicht wenig, aber annehmbarer als 4 GByte.

    Praktisch habe ich das so gelöst, dass die vordersten 4 Bit der Farbe (also die vordere Hälfte des Alpha-Wertes) mit dem jeweiligen Array-Element (indexiert durch die restlichen 28 Bit) verodert werden. Am Ende beim Summieren zähle ich dann einfach die Bits jedes Elementes. Funktioniert prima, und dauert bei Oscars Testbild inklusive LockBits... Ziemlich genau eine Sekunde, wobei davon auch nur knapp 400 ms für den DllCall draufgehen. Alles im Anhang!

    C
    #include "main.h"
    #include "32bit.h"
    
    
    unsigned short* colors32;
    unsigned int colorLen32 = 0x0fffffff + 1; //28 bit
    
    
    __inline int numberOfSetBits(unsigned int i) {
        /* here be dragons */
        i = i - ((i >> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
        return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
    }
    
    
    DWORD WINAPI colorThread32(void* data) {
        unsigned int i;
        pixelainfo_t* part = (pixelainfo_t*) data;
        for(i = 0; i < part->length; i++) {
            colors32[*(part->start + i) & 0x0fffffff] |= 1 << ((*(part->start + i) & 0xf0000000) >> 28);
        }
        return 0;
    }
    
    
    DWORD WINAPI additionThread32(void* data) {
        unsigned int i;
        countinfo_t* part = (countinfo_t*) data;
        part->ret = 0;
        for(i = 0; i < part->length; i++) {
            part->ret += numberOfSetBits(colors32[part->start + i]);
        }
        return 0;
    }
    
    
    long DLL_EXPORT getColorCount32(unsigned int* pixel, int len) {
        int i;
        long colorSum = 0;
        colors32 = (unsigned short*) calloc(colorLen32, sizeof(unsigned short));
        HANDLE threads[THREADS];
        pixelainfo_t* pixelparts[THREADS];
        countinfo_t* countparts[THREADS];
    
    
        for(i = 0; i < THREADS; i++) {
            /* partitioning pixel map and sum map, also start color count threads */
            pixelparts[i] = (pixelainfo_t*) malloc(sizeof(pixelainfo_t));
            pixelparts[i]->start = pixel + i * (len / THREADS);
            pixelparts[i]->length = len / THREADS;
            threads[i] = CreateThread(NULL, 0, colorThread32, pixelparts[i], 0, NULL);
            countparts[i] = (countinfo_t*) malloc(sizeof(countinfo_t));
            countparts[i]->start = i * (colorLen32 / THREADS);
            countparts[i]->length = colorLen32 / THREADS;
        }
        /* wait for color count threads (JOIN) */
        WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
        for(i = 0; i < THREADS; i++) {
            /* close color count threads, start addition threads */
            CloseHandle(threads[i]);
            free(pixelparts[i]);
            threads[i] = CreateThread(NULL, 0, additionThread32, countparts[i], 0, NULL);
        }
        /* wait for addition threads (JOIN) */
        WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
        for(i = 0; i < THREADS; i++) {
            /* close addition threads, calculate final sum from parts */
            CloseHandle(threads[i]);
            colorSum += countparts[i]->ret;
            free(countparts[i]);
        }
        free(colors32);
        return colorSum;
    }
    Alles anzeigen

    Dateien

    countcolors-32bitarray.zip 8,7 kB – 382 Downloads
  • GetUniqueColors

    • chesstiger
    • 29. November 2017 um 00:25

    UEZ

    Ah, das hab ich ganz übersehen. Bei mir kommt da raus...

    klein: 18.49 ms

    mittel: 33.51 ms

    groß: 195.28 ms

    riesig: 285.78 ms

    Ist also dennoch ein My schneller als der simple C-Code von oben!

    Selbst, wenn ich noch die Summation der Werte parallelisiere, ist da nicht mehr so viel zu holen.

    ( AspirinJunkie Da war echt noch was zu machen. Atomare Inkrements scheinen nicht ganz so performant zu sein... Aber auch hier macht sich MT nochmal bezahlt.)

    klein: 19.78 ms

    mittel: 32.83 ms

    groß: 182.60 ms

    riesig: 254.05 ms

    Code
    #define THREADS     4
    
    
    typedef struct pixelainfo { /* pixel array info */
        unsigned int* start;
        unsigned int length;
    } pixelainfo_t;
    
    
    typedef struct countinfo {
        unsigned int start;
        unsigned int length;
        unsigned int ret;
    } countinfo_t;
    
    
    unsigned char* colors;
    const int colorLen = 0xffffff + 1;
    
    
    DWORD WINAPI colorThread(void* data) {
        unsigned int i;
        pixelainfo_t* part = (pixelainfo_t*) data;
        for(i = 0; i < part->length; i++) {
            colors[*(part->start + i) & 0xffffff] = 1;
        }
        return 0;
    }
    
    
    DWORD WINAPI additionThread(void* data) {
        int i;
        countinfo_t* part = (countinfo_t*) data;
        part->ret = 0;
        for(i = 0; i < part->length; i++) {
            part->ret += colors[part->start + i];
        }
        return 0;
    }
    
    
    int DLL_EXPORT getColorCount(unsigned int* pixel, int len) {
        int i, colorSum = 0;
        colors = (unsigned char*) calloc(colorLen, sizeof(unsigned char));
        HANDLE threads[THREADS];
        pixelainfo_t* pixelparts[THREADS];
        countinfo_t* countparts[THREADS];
    
    
        for(i = 0; i < THREADS; i++) {
            /* partitioning pixel map and sum map, also start color count threads */
            pixelparts[i] = (pixelainfo_t*) malloc(sizeof(pixelainfo_t));
            pixelparts[i]->start = pixel + i * (len / THREADS);
            pixelparts[i]->length = len / THREADS;
            threads[i] = CreateThread(NULL, 0, colorThread, pixelparts[i], 0, NULL);
            countparts[i] = (countinfo_t*) malloc(sizeof(countinfo_t));
            countparts[i]->start = i * (colorLen / THREADS);
            countparts[i]->length = colorLen / THREADS;
        }
        /* wait for color count threads (JOIN) */
        WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
        for(i = 0; i < THREADS; i++) {
            /* close color count threads, start addition threads */
            CloseHandle(threads[i]);
            free(pixelparts[i]);
            threads[i] = CreateThread(NULL, 0, additionThread, countparts[i], 0, NULL);
        }
        /* wait for addition threads (JOIN) */
        WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
        for(i = 0; i < THREADS; i++) {
            /* close addition threads, calculate final sum from parts */
            CloseHandle(threads[i]);
            colorSum += countparts[i]->ret;
            free(countparts[i]);
        }
        free(colors);
        return colorSum;
    }
    Alles anzeigen

    Das ist noch etwas, aber nicht so viel, wie ich erwartet hätte. Wobei man fairerweise auch sagen muss, dass jetzt die Grenze des Machbaren erreicht ist. Der eigentliche DllCall dauert bei meiner neuen Multithreaded-Variante selbst für dein Riesen-Löwenzahnbild nur noch knappe 28 ms, also Pi mal Daumen 10% der Zeit. Der Rest geht für LockBits drauf..... Jetzt wäre der Moment gekommen, dort was zu optimieren.

    Edit:

    Ich habe mich jetzt mal etwas informiert. LockBits erstellt eine komplette Kopie der Bitmap. Das muss natürlich Ar...langsam sein. Man könnte evtl. GDIPlus durch was anderes ersetzen.

    Edit²:

    So, ich habe jetzt eine Implementation mit FreeImage gebastelt. Das Bild wird per FreeImage in AutoIt geladen und an meine DLL weitergegeben. Allerdings zeigt sich hier, dass die Werte für JPEGs etwas abweichen. Das Verhalten wurde ja schon zuvor beobachtet. Allerdings ist so nochmal ein MASSIVER Geschwindigkeitsvorteil zu erreichen. Beispiel am Löwenzahn-Bild: GDIPlus + DLL => ~250 ms, FreeImage + DLL => ~191.93 ms.

    Dateien

    CountColors_FullMT.zip 5,6 kB – 444 Downloads
  • GetUniqueColors

    • chesstiger
    • 28. November 2017 um 20:24

    Also!

    Das hier hat mir irgendwie keine Ruhe gelassen. Wir hatten jetzt Assembler, C, C++... Und C++ sogar multithreaded, allerdings durch die Sets relativ langsam. Ich hab also mal eine Implementation in purem Win32-C mit Threading geschrieben. So langsam muss ich aber auch kapitulieren. Hier mal die Statistiken, jeweils meine C-MT-Implementation gegen AspirinJunkies C++-Sets.

    Folgende Bildmaße wurden verwendet: klein (1024x768), mittel (1920x1280), groß (5590x3731).

    Code
    x       | AJ Single | AJ Multi | CT Multi
    klein   |    120.36 |    51.87 |    25.46
    mittel  |    375.95 |   151.47 |    36.89
    groß    |   2340.58 |   350.63 |   202.09

    Ich weiß zwar nicht, warum meine Implementation bei dem mittleren Bild so extrem heraussticht... Aber prinzipiell kann man so auf jeden Fall noch was rausholen! Ich teile das Bild einfach in mehrere gleiche Abschnitte auf und gehe diese dann in verschiedenen Threads durch. Am Ende, wenn alle Threads fertig sind, zähle ich die einzelnen Farben.

    Code
    typedef struct arrayinfo {
        unsigned int* start;
        unsigned int length;
    } arrayinfo_t;
    
    
    unsigned char* colors;
    const int colorLen = 0xffffff + 1;
    
    
    DWORD WINAPI colorThread(void* data) {
        unsigned int i;
        arrayinfo_t* part = (arrayinfo_t*) data;
        for(i = 0; i < part->length; i++) {
            colors[*(part->start + i) & 0xffffff] = 1;
        }
        return 0;
    }
    
    
    int DLL_EXPORT getColorCount(unsigned int* pixel, int len) {
        int i, colorSum = 0;
        colors = (unsigned char*) calloc(colorLen, sizeof(unsigned char));
        HANDLE threads[THREADS];
        arrayinfo_t* data[THREADS];
    
    
        for(i = 0; i < THREADS; i++) {
            data[i] = (arrayinfo_t*) malloc(sizeof(arrayinfo_t));
            data[i]->start = pixel + i * (len / THREADS);
            data[i]->length = len / THREADS;
            threads[i] = CreateThread(NULL, 0, colorThread, data[i], 0, NULL);
        }
        WaitForMultipleObjects(THREADS, threads, TRUE, INFINITE);
        for(i = 0; i < THREADS; i++) {
            CloseHandle(threads[i]);
            free(data[i]);
        }
        //calculate sum
        for(i = 0; i < colorLen; i++) colorSum += colors[i];
        free(colors);
        return colorSum;
    }
    Alles anzeigen


    DLL, vollständiger Source usw. alles im Anhang.

    Dateien

    CountColors_CMT.zip 5,26 kB – 391 Downloads

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™