spielkarten erkennen

  • VB.NET

Es gibt 15 Antworten in diesem Thema. Der letzte Beitrag () ist von Mangafreak1995.

    spielkarten erkennen

    Hallo,

    ich bin dabei ein kartenspiel zu programmieren.

    Ich habe auf dem bildschirm spielkarten und möchte die erkennen (wert und farbe sind IMMER in dem selben bereich)

    jetzt brauch ich etwas, was mir sagt, welche karte sich in einem definiertem Bereich (gerne auch frei wählbaren) befindet.

    bis jetzt kann ich mit meiner funktion

    VB.NET-Quellcode

    1. pixel(200,500)

    die RGB farben eines pixels auslesen. als ergebnis bekomm ich dieses format: "Color [A=255, R=35, G=65, B=25]"

    jedoch weiß ich jetzt nicht wie ich das benutzen soll um buchstaben und zeichen auszulesen.

    Außerdem muss ich erst ein screenshot machen bevor ich das pixel auslesen kann. das dauert zwar etwas, aber schlimmstenfalls kann ich damit leben.

    gibt es vielleicht externe software die das kann? ich kann nämlich auch schon mit VB mausklicks simulieren, d.h. ich könnte dann mit VB die exterene software bedienen.

    bin offen für jede hilfe, stichpunkte und teillösungen

    Hallo,

    da würde dann das Thema OOP kommen ;) dafür würdest du doch einfach ein Objekt machen, welches eine Eigenschaft hat, an der die Karte erkannt werden soll...wenn du das nicht willst, dann solltest du dir mal die LockBits Funktion von Image/Bitmap angucken und System.Marshall.Copy...

    welche externe Software willst du denn steuern? Wenn du ein Kartenspiel programmierst, dann musst du dieses doch nicht von extern steuern?!

    Mfg jvbsl
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    ne ich mein sowas wie ein tool, wo du mit der maus ein kästchen ziehst und das sagt dann herz ass oder sowas.

    das mit OOP ist glaub schwer, weil die karten nicht von mir sind. Ich spiel online mau mau und will eine automatische routine programmieren, die drauf antwortet.

    von deinen tipps sagt mir jetzt alles nix, aber ich werd jetzt mal probieren googlen und dann feedbacken :)

    danke schonmal
    also was ich jetzt so über die LockBits gelesen habe scheint irgendwie nicht das richtige zu sein. angeblich kann man so zeichenfolgen sperren. lass mich aber gern eines besseren belehren.

    gibt es vielleicht eine möglichkeit bilder zu vergleichen? das ich sagen kann ich hab hier ein 50x50 pixel bild und ich möchte vergleichen ob im bereich 100x100 bis 150x150 dasselbe, oder ähnliche bild zu finden ist?

    so eine art OCR eben

    wie oben gesagt ich antworte auf ein bereits vorhandenes programm. mann kann ja zb über ICQ karten spielen und mein programm soll voll automatisch spielen, ohne menschliche bedienung. die endscheidungsroutine hab ich schon programiert, ich muss nur noch rauskriegen welche karte mein gegner gespielt hat.

    es gibt einen bestimmten Bereich wo die Karte des Gegners liegt
    die bestimmts du abhängig von dem Screen (oder Form)
    dann machst du einen Shot vom Screen (oder der Form)
    an der Stelle der Karte und wertest das Bild aus
    am besten mit einem Vergleich wie diesem

    VB.NET-Quellcode

    1. Public Function Ähnlichkeit(img1, iimg2 as Bitmap) as Double
    3. Dim col as list of Color
    4. Dim count as list of Integer
    5. For x as integer = 0 to img1.width - 1
    6. For y as integer = 0 to img1.Height -1
    7. If Not(col.Contains(img1.getpixel(x,y))) Then
    8. col.Add(img1.getpixel(x,y))
    9. Else
    10. count(col.IndexOf(img1.getpixel(x,y)) += 1
    11. End If
    12. NExt
    13. Next
    15. Dim col2 as list of Color
    16. Dim count2 as list of Integer
    17. For x as integer = 0 to img2.width - 1
    18. For y as integer = 0 to img2.Height -1
    19. If Not(col.Contains(img2.getpixel(x,y))) Then
    20. col2.Add(img2.getpixel(x,y))
    21. Else
    22. count2(col.IndexOf(img2.getpixel(x,y)) += 1
    23. End If
    24. NExt
    25. Next
    26. ' ...

    das ist nur schnell überlegt aber der Ansatz könnte helfen
    bei dem jetztigen Code werden deine Farben aufgelisten und dazu die Anzahl der Farbe
    wenn du jetzt dir etwas zusammenbastelst um rauszufinden wie anhand der Daten der beiden Bilder sie wie stark übereinstimmen
    hast du es
    den Wert würd ich dann als Prozentwert (Double) zurückgeben damit du eine Toleranz einbringen kannst

    Ein Screen direkt von der Form hat einen Vorteil [VB 2008] Screen von der FORM machen

    eine funktion die mir ein screenshot erstellt habe ich bereits geschrieben :)
    wie kann ich denn die funktion änhlichkeit aufrufen?

    was ist denn "list of integer" und "list of color" für ein typ? die werden bei mir auch gar nicht erkannt.

    VB.NET-Quellcode

    1. Public Function Ähnlichkeit(ByVal img1 As Bitmap, ByVal img2 As Bitmap) As Double
    3. Dim col1 as list of Color
    4. Dim count1 as list of Integer
    5. For x As Integer = 0 To img1.width - 1
    6. For y As Integer = 0 To img1.Height - 1
    7. If Not (col1.Contains(img1.GetPixel(x, y))) Then
    8. col1.Add(img1.GetPixel(x, y))
    9. Else
    10. count1(col1.IndexOf(img1.GetPixel(x, y)) = +1)
    11. End If
    12. Next
    13. Next
    15. Dim col2 as list of Color
    16. Dim count2 as list of Integer
    17. For x As Integer = 0 To img2.Width - 1
    18. For y As Integer = 0 To img2.Height - 1
    19. If Not (col.Contains(img2.GetPixel(x, y))) Then
    20. col2.Add(img2.GetPixel(x, y))
    21. Else
    22. count2(col.IndexOf(img2.GetPixel(x, y)) = +1)
    23. End If
    24. Next
    25. Next
    26. End Function


    und muss das unten in der schleife nicht beides mal col2 heißten?

    vielen dank für deine hilfe :)

    ist die funkton so richtig?
    ich kanns kompilieren, aber hab halt paar kleine warnungen:

    VB.NET-Quellcode

    1. Public Function Ähnlichkeit(ByVal img1 As Bitmap, ByVal img2 As Bitmap) As Double
    3. Dim col1 As List(Of Color)
    4. Dim count1 As List(Of Integer)
    5. For x As Integer = 0 To img1.width - 1
    6. For y As Integer = 0 To img1.Height - 1
    7. If Not (col1.Contains(img1.GetPixel(x, y))) Then
    8. col1.Add(img1.GetPixel(x, y))
    9. Else
    10. count1(col1.IndexOf(img1.GetPixel(x, y))) = +1
    11. End If
    12. Next
    13. Next
    15. Dim col2 As List(Of Color)
    16. Dim count2 As List(Of Integer)
    17. For x As Integer = 0 To img2.Width - 1
    18. For y As Integer = 0 To img2.Height - 1
    19. If Not (col2.Contains(img2.GetPixel(x, y))) Then
    20. col2.Add(img2.GetPixel(x, y))
    21. Else
    22. count2(col2.IndexOf(img2.GetPixel(x, y))) = +1
    23. End If
    24. Next
    25. Next
    26. End Function

    klar kann es sein dass ich mich verschrieben habe
    ich meinte auch List (of Type)

    die Function bis jetzt ist richtig
    nur gibt sie keinen Wert zurück

    ich hab schon mal ja einen Anfang gemacht
    jetzt denkst du dir was aus wie du mit den Daten
    Bild1:
    Anzahl der Farben
    Anzahl wie oft eine Farbe benutzt wurde

    Bild2:
    Anzahl der Farben
    Anzahl wie oft eine Farbe benutzt wurde

    dir eine prozentualen Wert zurückgeben lässt wie stark sie sich unterscheiden

    Hi
    Ich will ja jetzt nicht deine Enthusiasmusjuhurufe stören, aber das was du zu OOP (Objektorientierte Programmierung) gesagt hast, zeigt, wie gut du Bescheid weißt. Meine Empfehlung wäre, einfach bei was leichtem einzusteigen, weil Schrifterkennung Bilderkennung nicht unbedingt das leichteste ist.
    Mangafreak1995 hat zwar bereits einen Ansatz geliefert, dieser ist aber noch sehr ausbaufähig. Viel mehr solltest du eine gewisse Toleranzgrenze machen und bestimmte Bitarrays oder Bitmaps verwenden um die beiden Bilder zu vergleichen. Dabei ist es sinnvoll, hier ein Foto von der Karte zu posten.

    zur Erläuterung: Bei der Methode mit den Bit-Arrays denke ich an eine Realisierung, die ein Bild über Helligkeiten vergleicht. Liegt die Helligkeit(Color.GetBrightness) beispielsweise unter 0.75F, so ist es ein aktiver Punkt mit Schrift. Dann die einzelnen Pixel entweder mit der Marshal-Methode von jvbsl oder per GetPixel vergleichen. Die GetBrightness-Methode würde wegfallen, wenn du mehrere Bitmaps vergleichst.
    Auf jeden Fall solltest du dir schon mal viel Zeit einplanen, um ein wenig mehr VB zu lernen.

    Gruß
    ~blaze~

    vielen dank erstmal für eure hilfe.

    ich bin mittlerweile soweit gekommen, dass ich einen bereich im bildschirm definiert hab und von dort die ein pixelarray erstellt hab mit der rgb nummer für jedes pixel.

    dann hab ich fest definierte arrays erstellt die die karten ergaben und konnte dann schön sagen vergleiche das erstellte array mit den arrays aus den fest definierten arrays, und wenn eins gleich ist, dann hab ich die richtige karte gefunden.

    das hat bis jetzt meisten ganz gut geklappt.

    das blöde ist nur, es klappt nicht immer. es liegt nicht an ungenauigkeit der pixel oder so, sndern die kartenbilder sind nicht immer gleich. da gibts ein zwei pixel, die sich mal unterscheiden, und dann kommts mal vor das ich die karte nicht finde :(

    bin kurz davor aufzugeben....
    das einzige was ich noch im kopf habe, wäre eine mit einer OCR software den screenshot auslesen.
    kennt da jemand eins das das kann und auch kostenlos ist?

    oder hat jemand eine andere idee?

    Wie überprüfst du die Arrays? Sicher gibts hierbei auch die Möglichkeit den Grad der Abweichung zu ermitteln und wenn sich 2 Pixel unterscheiden kann man davon ausgehen das die Karte trotzdem stimmt, somit könnte man einen Wert festlegen wie z.B. die Abweichung muss unter 15 Pixel oder so sein.

    ich vergleiche in einer schleife jedes einzelne element.

    der bereich indem die karte ist geht vom punkt(700,210) bis punkt(709,240)
    ich hab immer jedes dritte pixel in das array geschrieben, damit das vergleichen nicht solang dauert, hab also arrays der dimension (2,9)

    VB.NET-Quellcode

    1. Private Function AVergleich(ByVal q As Array, ByVal b As Array)
    2. Dim m, n As Integer
    4. n = 0
    5. Do
    6. m = 0
    7. Do
    8. If q(m, n) <> b(m, n) Then
    9. Return "00" '"Kartenwert nicht gefunden"
    10. Exit Function
    11. End If
    12. m = m + 1
    13. Loop Until m = 3
    14. n = n + 1
    15. Loop Until n = 9
    17. Select Case ArNr
    18. Case 1
    19. ArNr = 0
    20. Return "ak"
    21. Case 2
    22. ArNr = 0
    23. Return "ap"
    24. Case 3
    25. ArNr = 0
    26. Return "as"
    27. Case 4
    28. ArNr = 0
    29. Return "ah"
    30. Case 5
    31. ArNr = 0
    32. Return "kk"
    33. Case 6
    34. ArNr = 0
    35. Return "kp"
    36. Case 7
    37. ArNr = 0
    38. Return "ks"
    39. Case 8
    40. ArNr = 0
    41. Return "kh"
    42. Case 9
    43. ArNr = 0
    44. Return "qk"
    45. Case 10
    46. ArNr = 0
    47. Return "qp"
    48. Case 11
    49. ArNr = 0
    50. Return "qs"
    51. Case 12
    52. ArNr = 0
    53. Return "qh"
    54. Case 13
    55. ArNr = 0
    56. Return "jk"
    57. Case 14
    58. ArNr = 0
    59. Return "jp"
    60. Case 15
    61. ArNr = 0
    62. Return "js"
    63. Case 16
    64. ArNr = 0
    65. Return "jh"
    66. Case 17
    67. ArNr = 0
    68. Return "tk"
    69. Case 18
    70. ArNr = 0
    71. Return "tp"
    72. Case 19
    73. ArNr = 0
    74. Return "ts"
    75. Case 20
    76. ArNr = 0
    77. Return "th"
    78. Case 21
    79. ArNr = 0
    80. Return "9k"
    81. Case 22
    82. ArNr = 0
    83. Return "9p"
    84. Case 23
    85. ArNr = 0
    86. Return "9s"
    87. Case 24
    88. ArNr = 0
    89. Return "9h"
    90. Case 25
    91. ArNr = 0
    92. Return "8k"
    93. Case 26
    94. ArNr = 0
    95. Return "8p"
    96. Case 27
    97. ArNr = 0
    98. Return "8s"
    99. Case 28
    100. ArNr = 0
    101. Return "8h"
    102. Case 29
    103. ArNr = 0
    104. Return "7k"
    105. Case 30
    106. ArNr = 0
    107. Return "7p"
    108. Case 31
    109. ArNr = 0
    110. Return "7s"
    111. Case 32
    112. ArNr = 0
    113. Return "7h"
    114. Case 33
    115. ArNr = 0
    116. Return "6k"
    117. Case 34
    118. ArNr = 0
    119. Return "6p"
    120. Case 35
    121. ArNr = 0
    122. Return "6s"
    123. Case 36
    124. ArNr = 0
    125. Return "6h"
    126. Case 37
    127. ArNr = 0
    128. Return "5k"
    129. Case 38
    130. ArNr = 0
    131. Return "5p"
    132. Case 39
    133. ArNr = 0
    134. Return "5s"
    135. Case 40
    136. ArNr = 0
    137. Return "5h"
    138. Case 41
    139. ArNr = 0
    140. Return "4k"
    141. Case 42
    142. ArNr = 0
    143. Return "4p"
    144. Case 43
    145. ArNr = 0
    146. Return "4s"
    147. Case 44
    148. ArNr = 0
    149. Return "4h"
    150. Case 45
    151. ArNr = 0
    152. Return "3k"
    153. Case 46
    154. ArNr = 0
    155. Return "3p"
    156. Case 47
    157. ArNr = 0
    158. Return "3s"
    159. Case 48
    160. ArNr = 0
    161. Return "3h"
    162. Case 49
    163. ArNr = 0
    164. Return "2k"
    165. Case 50
    166. ArNr = 0
    167. Return "2p"
    168. Case 51
    169. ArNr = 0
    170. Return "2s"
    171. Case 52
    172. ArNr = 0
    173. Return "2h"
    174. Case Else
    175. Return "01" '"Kartenname nicht gefunden"
    176. End Select
    179. End Function


    die funktion hab ArNr hochzählen lassen und dann zB bei ArNr = 1 hab ich die funktion mir as kreuz aufgerufenbei ArNr = 2 mit as piek usw...

    ArNr = 0 heißt die Karte ist gefunden und die Schleife wird beendet. Sobald ein Arrayelement nicht übereinstimmt wird der Vergleich mit der nächsten Karte gestartet. So hab ich in weniger als 5 sekunden eine karte gefunden. (getestet habe ich das mit screenshots, aber im richtigen spiel dann waren die karten mal um ein pixel anders und schon konnte man das nicht finden)

    hab erst gedacht das ich vielleicht die pixel runden kann, aber das ging auch nicht weil in meinem beispiel statt ein weißes pixel das eine diesmal schwarz war, und das sind ja ganz andere farben.

    wie würdest du das genau realisieren mit der abweichung?
    ich werd sobald ich wieder zeit hab mal schauen, wie viel pixel sich da ungefähr unterscheiden.

    vielen dank schonmal :)

    du nimmst noch einen counter der die Fehler zählt und erst wenn der über 15 ist dann wird erst abgebrochen
    das ist im Prinzip eine Art für die Toleranz

    Zudem würde man hier auf eine For Next Schleif zurückgreifen und eine Do Loop Schleife.

    VB.NET-Quellcode

    1. Dim Toleranz As Integer = 0
    3. For x As Integer = 0 To 2
    4. For y As Integer = 0 To 9
    5. If Not q(x,y) = b(x,y) Then Toleranz += 1
    6. Next y
    7. Next x
    9. If Toleranz < 15 Then MessageBox.Show("Das Array 'q' entspricht dem Array 'b' mit einer Abweichung von " & Toleranz & " Pixel")

    naja man muss nich die ganze Karte nehmen
    reicht ja das Zeichen oder das Bild

Facebook
Telefonspende