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

  • Hex(2^0) = ?

    • AspirinJunkie
    • 25. November 2017 um 21:51

    Vielleicht wird so klarer was die Ursache ist:

    AutoIt
    ConsoleWrite(Hex(1) & @CRLF)
    ConsoleWrite(Hex(1.0) & @CRLF)
  • GetUniqueColors

    • AspirinJunkie
    • 25. November 2017 um 20:21

    Bei meiner Set-Variante ist die MT-Variante beilspielsweise bei 4 logischen Prozessoren bei mir um den Faktor 3,2 schneller.

    Also deutlich schneller als nur die 50% die du erwartest.

    Aber im Grunde stimmts schon - wenn's nicht notwendig warum dann noch einen zusätzlichen Aufwand betreiben und neue Unwägbarkeiten mit reinholen.

  • GetUniqueColors

    • AspirinJunkie
    • 25. November 2017 um 18:55
    Zitat von Mars

    byte[col] = 4 (nachdem alle Threads fertig sind)

    Nicht unbedingt.
    Inkrement funktioniert (falls es kein atomares inkrement ist) so:

    • aktuellen Wert aus Speicher auslesen
    • im Register addieren
    • Neuen Wert schreiben

    Gehen wir doch mal einen möglichen Fall das 4 Threads gleichzeitig die selbe Farbe haben durch:

    • Thread 1 liest aus -> 0
    • Thread 2 liest aus -> 0
    • Thread 1 addiert 1 im Register (Registerwert = 1)
    • Thread 3 liest aus -> 0
    • Thread 2 addiert 1 im Register (Registerwert = 1)
    • Thread 1 schreibt seinen Wert zurück in den Speicher -> 1
    • Thread 4 liest aus -> 1
    • Thread 2 schreibt seinen Wert zurück in den Speicher -> 1
    • Thread 3 addiert 1 im Register -> (Registerwert = 1)
    • Thread 3 schreibt seinen Wert zurück in Speicher -> 1
    • Thread 4 addiert 1 im Register -> (Registerwert = 2)
    • Thread 4 schreibt seinen Wert zurück in den Speicher -> 2

    Heißt: 4 Threads haben einen Anfangswert von 0 inkrementiert und nachdem alle fertig sind steht als Ergebnis eine 2 da.

    Die nächste Frage ist wie man das Überlaufproblem behandelt. Bei homogenen Bildern wo eine Farbe mehr als 256x vorkommt kommt es zu einem Überlauf und es geht wieder bei 0 los.

    Zitat von Mars

    farbcounter = 4 (nachdem alle Threads fertig sind)

    Die Tatsächliche Anzahl Farben ist also: farbcounter MINUS (Summe der Bytestruct MINUS 1 für jedes Element >0) = 4 - 3 = 1

    Wann bestimmst du den Moment dass gerade alle Threads fertig sind und an welcher Stelle soll die anschließende Rechnung stattfinden?

    Ich arbeite bei meiner MT-Variante mit einem atomaren Inkrement+Fetch. Heißt: Es ist garantiert dass auf die Speicherstelle für den gesamten Vorgang (auslesen, inkrementieren, neu schreiben) nur ein Thread zugreift.

    Anschließend wird der Farbcounter nur hochgezählt wenn das inkrement-Ergebnis 1 ist.

  • Bit aus 0xZahl abfragen

    • AspirinJunkie
    • 25. November 2017 um 11:38

    Dann musst du tatsächlich erst den entsprechenden Bereich per Binary-Funktionen herausschneiden, diesen als Integer behandeln und dort per BitAnd die entsprechenden Bits abfragen.

    Edit: Hier mal fix (also nicht ausgiebig getestet) umgesetzt:

    AutoIt
    $sVar = "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
    $b_Binary = Binary($sVar)
    
    ConsoleWrite(_GetBitOfBinary($b_Binary, 74) & @CRLF)
    
    Func _GetBitOfBinary($b_Binary, $d_BitNum)
        If Not IsBinary($b_Binary) Then Return SetError(1, 0, -1)
        If $d_BitNum < 1 Then Return SetError(2,0,-1)
        If BinaryLen($b_Binary) < $d_BitNum / 8 Then Return SetError(3, $d_BitNum, -1)
    
    
        Local $i_Byte = Floor(($d_BitNum-1) / 8)
        Local $i_SubBit = Mod($d_BitNum-1, 8)
        Local $d_Var = Int(BinaryMid($b_Binary, $i_Byte+ 1, 1))
    
        Return BitAND($d_Var, 2^$i_SubBit) = 0 ? 0 : 1
    EndFunc
    Alles anzeigen
  • Bit aus 0xZahl abfragen

    • AspirinJunkie
    • 25. November 2017 um 11:35

    Kanashius:

    Zu deiner Funktion _getBit():

    • Der Parameter $max wird nicht verwendet und kann daher weg
    • Das erste Bit ist in dieser Funktion $bitcount = 0 (wie du ja auch in der Funktionsbeschreibung schreibst). Eventuell wäre es intuitiver bei 1 zu beginnen.
  • GetUniqueColors

    • AspirinJunkie
    • 25. November 2017 um 11:25
    Zitat von Oscar

    Bezüglich der "nur 24Bit": Wenn man "_GDIPlus_BitmapLockBits" mit "$GDIP_PXF32PARGB", also PARGB aufruft, dann werden die Alphawerte doch vorher auf die RGB-Werte umgerechnet und somit müsste die Anzahl der Farben wieder stimmen, oder liege ich da falsch?

    Naja kommt halt darauf an was du genau zählen willst.
    Der Alpha-Channel ist kein Farbwert an sich - klar. Aber er beeinflusst dennoch die Darstellung des jeweiligen Pixels.

    Jetzt ist die Frage ob man diese Info dazuzählen möchte oder lediglich das Endergebnis auf einem homogenen Hintergrund wichtig ist.

    Wenn man den Alphachannel als eigenständigen Kanal betrachten will dann kann PARGB hingegen nicht die Lösung sein.
    Wir haben in diesem Fall eine surjektive Abbildung von 32Bit auf 24Bit -> also einen Informationsverlust.
    Unterschiedliche Ausgangswerte können also gleiche Ergebniswerte produzieren, was dazu führt, dass eigentlich unterschiedliche Farbwerte fälschlicherweise als gleichfarbig gezählt werden.

    Also wie gesagt: Was willst du genau zählen bzw. wozu brauchst du es?

  • Bit aus 0xZahl abfragen

    • AspirinJunkie
    • 25. November 2017 um 11:09

    Mit Binary wirst du nicht weiterkommen.

    Das richtige Tutorial hast du ja schon gefunden.
    Musst es im Grunde nur noch anwenden - dann könntest du auf z.B. sowas kommen:

    AutoIt
    $sVar = "FF0F"
    $dNumber = Dec($sVar)
    ConsoleWrite($dNumber & @CRLF)
    
    ; Schrittweise alle Bits abfragen:
    For $i = 0 To 31
        ConsoleWrite("Bit " & $i+1 & ": " & (BitAND($dNumber, 2^$i) <> 0) & @CRLF)
    Next

    Im Grunde musst du nur die Zahl aus der du ein bestimmtes Bit haben willst mit einer anderen Zahl bitweise Und-verknüpfen wo ausschließlich dieses gewünschte Bit gesetzt ist.

    Das Ergebnis ist nur dann 1 wenn in der Ausgangszahl dieses Bit auf 1 gesetzt ist.

  • GetUniqueColors

    • AspirinJunkie
    • 24. November 2017 um 21:33

    Oscar

    Multi-Threading wird bei dieser Lösung wohl fast keinen großen Sinn machen.

    Warum? Nun wir haben hier den klassischen Fall von Race-Conditions.

    Schauen wir uns mal den wichtigen Codeausschnitt an:

    C
    for(int i = 0; i < len; i++) {            
       if (colors[aPixel[i] & 0xffffff] == 0){
          colorSum++;
          colors[aPixel[i] & 0xffffff] = 1;
       }
    }

    Was passiert in einem besonders blöden Fall:

    • Thread 1 hat ein Pixel mit der Farbe 0 (schwarz also).
    • Thread 1 fragt an der entsprechenden Stelle im Array colors nach ( [0] ) und vergleicht dort auf 0 -> Ergebnis: Es ist noch 0
    • Also springt Thread 1 in den True-Case der If-Verzweigung
    • In der Zwischenzeit hat Thread 2 ebenfalls ein Pixel der Farbe 0 und testet gegen das Array colors -> und siehe da: Noch ist der Wert dort ebenfalls noch 0 da Thread 1 ja noch nicht geschrieben hat und springt ebenfalls in den True-Case
    • colorSum wird dann einmal von Thread 1 als auch nochmal von Thread 2 inkrementiert.
    • Die Farbe schwarz wurde also fälschlicherweise doppelt gezählt!
    • Unser Ergebnis wird also höher sein als das korrekte.

    Nun wie kann man das nun verhindern?
    Im Grunde durch Locks oder atomare Prozeduren.

    Der Lock müsste im Grunde aber auf die ganze If-Abfrage gesetzt werden. Da damit der gesamte Schleifeninhalt hierbei als nichtparallel definiert wird kann man sich diese Lösung ergo aber schenken wenn man das ganze parallelisieren möchte.

    Atomare Typen und Prozeduren als Alternative hierzu bringen hingegen soviel Overhead mit, dass der Geschwindigkeitsvorteil durch die Parallelisierung davon wieder mehr als aufgefressen wird.

    Kurz: Auf Anhieb hab ich keine Lösung wie man bei einer Parallelisierung korrekte Werte erhält und dennoch einen Performancezuwachs gegenüber der Single-Thread-Variante erwarten kann. Vielleicht finde ich noch ne Lösung - mal schauen.

    Die Multithread-Variante die zwar fix ist aber leicht falsche Ergebnisse produziert habe ich mal zum Nachvollziehen in der DLL belassen.

    Edit: So nun doch eine Variante gefunden welche zumindest bei großen Bildern bessere Performance liefern kann und dennoch korrekte Werte liefert (über die Windows-API-Funktion InterlockedIncrement16 umgesetzt).

    UEZ

    Oh super. Blöd nur dass wir bis jetzt nicht wissen warum die erste DLL bei dir nicht funktioniert hat.

    Zitat von UEZ

    Ich glaube nicht, dass MT hier noch was bringt bzw. MT sich richtig lohnt.

    Warum nicht?

    Dateien

    CountColors.zip 19,05 kB – 395 Downloads
  • GetUniqueColors

    • AspirinJunkie
    • 24. November 2017 um 18:35
    Zitat von Oscar

    Wie würde die Multi-Thread-Version wohl mit der Array-Methode aussehen?

    Zeig mir mal den Single-Thread Code und ich füg ihn noch als Threaded-Version der DLL hinzu.

  • GetUniqueColors

    • AspirinJunkie
    • 24. November 2017 um 18:06

    Habe der DLL mal noch eine Multithread-Version hinzugefügt.
    Hätte nicht gedacht dass es viel ausmacht aber gerade bei großen Bildern bringt es wirklich einen großen Unterschied.

    Siehe Anhang

    Dateien

    CountColors.zip 17,16 kB – 414 Downloads
  • GetUniqueColors

    • AspirinJunkie
    • 24. November 2017 um 06:37
    Zitat von BugFix

    Laut Bildbetrachter XnView sind es 103240 Farben - ein bischen Schwund ist immer

    [...]

    Anzahl Farben: 99394 (in XnView: 99375)


    XnView zählt mal mehr, mal weniger als diese Funktion. (Wer zählt von Hand nach? )

    Ist der selbe Grund wie hier schon vorher genannt. Liegt am JPEG-Decoder der unterschiedliche Ergebnisse produziert.

    Lass dir die Datei in XNView mal als PNG ausgeben dann sollten die Zahlen bei beiden übereinstimmen.

  • GetUniqueColors

    • AspirinJunkie
    • 23. November 2017 um 22:50

    Ok dann weiß ich es spontan auch nicht.
    Hab es hier auf Win10 x64 laufen und es läuft sowohl als x64 als auch als x86 dll.

    Eventuell hab ich gegen eine Win10-API gelinkt. Nutzt du Windows 10 oder vielleicht was anderes?
    Heute komm ich aber sicher nicht mehr dazu genauer nachzuschauen - wenn dann morgen Abend.

    Edit: Hab es gerade auf einem Win 8.1 x64 probiert: Nachdem ich die VS 2017 Redistributables installiert habe lief es auch dort.
    Kann es eventuell nochmal jemand anderes versuchen?

  • GetUniqueColors

    • AspirinJunkie
    • 23. November 2017 um 22:26

    Eventuell fehlen die Visual C++ 2017 Runtimes?

    Also von hier ganz unten: https://www.visualstudio.com/de/downloads/

  • GetUniqueColors

    • AspirinJunkie
    • 23. November 2017 um 21:58

    Ich bin mal ganz naiv rangegangen und dachte mir: Es gibt ne Set in C++ - warum nicht einfach die nutzen?

    So ist der Code brutal simpel:

    C
    #include <windows.h>
    #include <unordered_set>
    
    extern "C" __declspec(dllexport) int __stdcall count_colors(int len, int *aPixel ) {
        std::unordered_set<int> setOfColors(aPixel, &aPixel[len]);
    
        return static_cast<int>(setOfColors.size());
    }
    
    BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason, LPVOID reserved)
    {   switch (reason)
        {   case DLL_PROCESS_ATTACH: break;
            case DLL_PROCESS_DETACH: break;
            case DLL_THREAD_ATTACH:  break;
            case DLL_THREAD_DETACH:  break;}
        return TRUE;
    }
    Alles anzeigen

    Das Ergebnis in Form zweier DLL liegt im Anhang.

    Bei kleinen Bildern könnte der Code fix sein.
    Bei größeren Bildern womöglich langsamer als die vorgestellten Lösungen.

    Auch wenn es vielleicht nicht die Performance-Bestmarke knackt: Viel einfacher geht es im Grunde nicht mehr.

    Da ich bisschen neidisch auf die hier vorgestellten ASM-Lösungen schiele wollte ich dennoch noch was hier beitragen.

    Edit: Ach ja: 32 Bit-Bilder funktionieren hiermit ebenfalls.

    Dateien

    CountColors.zip 14,5 kB – 426 Downloads
  • BITMAP-Datei mit FileRead lesen.

    • AspirinJunkie
    • 22. November 2017 um 18:36
    Zitat von DOheim

    Gibt es eigentlich Assembler-Befehle bzw. -Routinen, mit denen man auf Basis von AssembleIt eine Datei einlesen und schreiben kann?

    Dir ist es zu mühselig das FileRead in deinem Programm entsprechend anzupassen aber mal einfach die File-Prozeduren durch Assemblercode zu ersetzen stellst du dir einfacher vor?

    Zum Thema Assemblerfilefunktionen: Möglich natürlich und sicher auch schon irgendwo vorhanden. Aber da man ja in ein bestimmtes FileSystem schreibt wird man die entsprechenden System-API-Funktionen hierfür ansprechen. Also genau das was auch die File-Funktionen von AutoIt machen - nur anders verpackt.

  • Berechnung von mehreren Einträgen

    • AspirinJunkie
    • 18. November 2017 um 21:14

    1. Du bist im Forum zu AutoIt und stellst eine Frage zu PHP. Wir haben jedoch extra für sowas ein Unterforum "Andere Programmiersprachen".

    2. Hast du mal einen Beispielaufbau der fraglichen Tabelle "Mitarbeiter", so dass man sehen kann was du wie berechnest?
    Hintergrund: Ich würde gern sehen warum es nötig sein sollte ist die Daten rauszuziehen, außerhalb zu bearbeiten und wieder in die Datenbank zu schreiben anstatt einfach direkt in der Datenbank die Daten entsprechend aufzubereiten.

    Weil ich denk da an sowas in der Art:

    SQL
    SELECT ID, SUM(CASE WHEN Schicht IN ("Tag", "Nacht") Then 12 ELSE 8 END) AS Summe
    FROM Mitarbeiter GROUP BY ID;
  • Kamera winkel ausrechnen im 3D Raum

    • AspirinJunkie
    • 12. November 2017 um 09:34
    Zitat von Tyzer

    aber bei Yaw bin ich mir nicht so sicher, wenn ich immer +90 hinzufüge wirds wohl nicht ganz stimmen, ihr habt doch bestimmt ne bessere Lösung als +90 oder?

    Naja +90 ist schon ok. Aber dann folgt noch eine Bereichsabfrage, damit man die daraus entstehenden Fälle über 180° korrekt behandelt.

    Da es aber 90°-Differenzen zum normalen Arkustangens sind, kann man alternativ auch durch entsprechendes umstellen der Parameter von atan2 eine Drehum um 90° erreichen.

    Entspricht dies dem was du erreichen möchtest?:

    AutoIt
    If Not IsDeclared("PI") Then Global Const $PI = ACos(-1)
    Global Const $rad2deg = 180.0 / $PI
    Global Const $deg2rad = $PI / 180.0
    
    ; Koordinaten
    Global $pt_A = [0, 0, 0] ; Kamerakoordinaten [X,Y,Z]
    Global $pt_B = [5, 5, 5] ; Punktkoordinaten [X,Y,Z]
    
    Global $f_Yaw = _calcYaw($pt_A, $pt_B)
    Global $f_Pitch = _calcPitch($pt_A, $pt_B)
    
    ConsoleWrite(StringFormat("% 10s: % 7.2f°\n% 10s: % 7.2f°\n", "Yaw", $f_Yaw * $rad2deg, "Pitch", $f_Pitch * $rad2deg))
    
    #Region Funktionen
    Func _calcYaw($pt_From, $pt_To)
        Return atan2($pt_To[0] - $pt_From[0], -($pt_To[1] - $pt_From[1]))
    EndFunc   ;==>_calcYaw
    
    Func _calcPitch($pt_From, $pt_To)
        Local $f_R2D = Sqrt(($pt_To[0] - $pt_From[0])^2 + ($pt_To[1] - $pt_From[1])^2) ; der Abstand auf der X-Y-Ebene
        Return -atan2($pt_To[2] - $pt_From[2], $f_R2D)
    EndFunc   ;==>_calcPitch
    
    Func atan2($y, $x)
        If $y = 0 And $x < 0 Then Return $PI
        Return (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y))))
    EndFunc   ;==>atan2
    #EndRegion Funktionen
    Alles anzeigen
  • Einbinden DLL für das Einlesen von Messwerten über die serielle Schnittstelle

    • AspirinJunkie
    • 11. November 2017 um 21:56
    Zitat von BugFix

    Das ist immer recht fraglich. Mal reicht tatsächlich die vordefinierte Variable, mal muss sie als Pointer übergeben werden. Das sind dann die Dinge, die mit Trial&Error erledigt werden.

    Hehe - exakt deswegen habe ich es so vorsichtig formuliert.
    Eh ich mir lange dazu den Kopf zerbrochen hätte, hätte ich es einfach mal getestet.
    Geht hier nur leider nicht.


    TheDude - lass dir mal testweise $aRet per _ArrayDisplay() ausgeben. So kannst du herausfinden ob dein gesuchter Wert dann in $aRet[3] steht.

    Zitat von BugFix

    Oops, hast natürlich recht - ich wollte eigentlich "BOOL" verwenden, also den 32 Bit Typ.

    Ach guck an - hatte ich auch nicht mehr auf dem Schirm dass es da einen ähnlich benannten Typ als 32 Bit-Variante gibt.

  • Einbinden DLL für das Einlesen von Messwerten über die serielle Schnittstelle

    • AspirinJunkie
    • 11. November 2017 um 21:38

    Laut der Beschreibung wird dort als boolean ein 32 Bit-Integer verwendet - oder?

    Dann würde ja der Rückgabewert und der 4. Parameter nicht passen da boolean in DLLCall ein 8 Bit-Wert darstellt.

    Ich denke daher dass man für den Rückgabewert und den 4. Parameter daher stattdessen INT verwenden sollte.

    Und zu dem 3. Parameter: Kann mich irren aber spontan hätte ich Double* statt Double verwendet.

  • Kamera winkel ausrechnen im 3D Raum

    • AspirinJunkie
    • 11. November 2017 um 19:44

    Um die Frage abschließend zu klären fehlen ein paar wichtige Infos.

    Vor allem wie denn deine eingezeichneten Winkelangaben im Koordinatensystem liegen.

    Sprich: In welche Richtung zeigt denn die X bzw. Y-Achse?

    Ansonsten sagst du dass du falsche Ergebnisse erhälst.

    Was ist konkret falsch daran?

    Was wären denn die richtigen Ergebnisse?

    Mit den bisherigen Angaben und ein paar notwendigen Annahmen meinerseits hätte ich so angefangen:

    AutoIt
    If Not IsDeclared("PI") Then Global Const $PI = ACos(-1)
    Global Const $rad2deg = 180.0 / $PI
    Global Const $deg2rad = $PI / 180.0
    
    ; Koordinaten
    Global $pt_A = [0, 0, 0] ; Kamerakoordinaten [X,Y,Z]
    Global $pt_B = [5, 5, 5] ; Punktkoordinaten [X,Y,Z]
    
    Global $f_Yaw = _calcYaw($pt_A, $pt_B)
    Global $f_Pitch = _calcPitch($pt_A, $pt_B)
    
    ConsoleWrite(StringFormat("Yaw: % 6.2f°\nPitch: % 6.2f°\n", $f_Yaw * $rad2deg, $f_Pitch * $rad2deg))
    
    
    #Region Funktionen
    Func _calcYaw($pt_From, $pt_To)
        Local $Yaw = atan2($pt_To[1] - $pt_From[1], $pt_To[0] - $pt_From[0])
        Return $Yaw
    EndFunc   ;==>_calcYaw
    
    Func _calcPitch($pt_From, $pt_To)
        Local $f_R2D = Sqrt(($pt_To[0] - $pt_From[0])^2 + ($pt_To[1] - $pt_From[1])^2) ; der Abstand auf der X-Y-Ebene
        Local $Yaw = atan2($pt_To[2] - $pt_From[2], $f_R2D)
        Return $Yaw
    EndFunc   ;==>_calcPitch
    
    Func atan2($y, $x)
        Return (2 * ATan($y / ($x + Sqrt($x * $x + $y * $y))))
    EndFunc   ;==>atan2
    #EndRegion Funktionen
    Alles anzeigen

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™