Zahlen in Bild erkennen mit Pixelsearch - Genauigkeitsprob.

[MaToBe]

okay jetzt gibts schon wieder ein neues Problem.

Meine Idee ist es, jeder Ziffer eine Art Code zu geben durch die sie identifizierbar ist. Der Code einer Ziffer wird generiert durch deren Schwarz-Weiß Bild. In diese werden dann die Wechsel zwischen schwarzen und weißen Pixeln verarbeitet.

Der Code für die Ziffer 1 sieht dann so aus:

Delphi-Quellcode:

Ziffer_1 : array[0..9] of integer = (251, 1, 26, 1, 26, 1, 24, 13, 14, 13);

Auf menschlich: 251 weiße Pixel, auf diese folgt 1 schwarzes Pixel, dann kommen 26 weiße Pixel, dann 1 schwarzes usw.

Alle Zifferncodes:

Delphi-Quellcode:

Ziffer_1 : array[0..9] of integer = (251, 1, 26, 1, 26, 1, 24, 13, 14, 13);
  Ziffer_2 : array[0..37] of integer = (250, 3, 6, 3, 14, 4, 5, 4, 14, 2, 6, 5, 14, 2, 6, 2, 1, 2, 14, 1, 6,
                                        2, 2, 2, 14, 2, 4, 2, 3, 2, 14, 7, 4, 2, 15, 6, 4, 2);
  Ziffer_3 : array[0..35] of integer = (250, 2, 7, 2, 15, 3, 7, 3, 14, 2, 10, 1, 14, 1, 5, 1, 5, 2, 13, 1, 5,
                                        1, 5, 2, 13, 2, 3, 3, 3, 2, 14, 13, 16, 3, 2, 5);
  Ziffer_4 : array[0..27] of integer = (230, 2, 23, 4, 22, 2, 2, 1, 20, 2, 4, 1, 18, 3, 5, 1, 17, 2, 7, 1, 17,
                                        13, 14, 13, 22, 2, 26, 1);
  Ziffer_5 : array[0..41] of integer = (232, 1, 16, 7, 3, 3, 14, 7, 3, 3, 14, 2, 3, 1, 6, 2, 13, 2, 3, 1, 6, 2,
                                        13, 2, 3, 2, 5, 2, 13, 2, 3, 2, 4, 2, 14, 2, 3, 8, 14, 2, 4, 6);
  Ziffer_6 : array[0..41] of integer = (226, 6, 18, 11, 16, 3, 2, 2, 2, 3, 14, 2, 3, 2, 5, 1, 14, 2, 3, 1, 6, 2,
                                        13, 1, 4, 2, 5, 2, 13, 2, 3, 2, 4, 2, 14, 3, 2, 8, 15, 2, 3, 6);
  Ziffer_7 : array[0..27] of integer = (222, 2, 25, 2, 25, 2, 9, 2, 14, 2, 6, 5, 14, 2, 4, 7, 14, 2, 2, 4, 19, 2,
                                        1, 3, 21, 4, 23, 3);
  Ziffer_8 : array[0..37] of integer = (250, 4, 2, 5, 15, 13, 14, 2, 3, 3, 4, 1, 14, 1, 4, 2, 5, 2, 13, 1, 4, 2, 5,
                                        2, 13, 2, 3, 2, 5, 2, 13, 13, 15, 4, 2, 5, 24, 1);
  Ziffer_9 : array[0..39] of integer = (225, 3, 22, 7, 3, 2, 14, 3, 2, 3, 3, 2, 14, 2, 5, 1, 4, 2, 13, 1, 6, 1, 4,
                                        2, 13, 1, 6, 1, 4, 2, 13, 2, 4, 2, 3, 2, 15, 11, 17, 9);

Meine Idee ist es jetzt, dass wenn eins der Bilder mit einer Ziffer eingelesen wird, für dieses Bild solch ein Code erstellt wird. Dann wird der Code auf die größtmögliche Gemeinsamkeit mit den 9 definierten Codes überprüft. Die größte Gemeinsamkeit soll dann als Treffer angenommen werden.

Und hier ist jetzt mein Problem. Wie vergleiche ich den neu generierten Code mit den 9 vodefinierten auf die größte Ähnlichkeit?

Meine Folgende Lösung war leider von der Idee her gut, aber viel zu ungenau:

Delphi-Quellcode:

.....
 for i := 0 to 34 do
   begin
      aktErgebnis := aktErgebnis + (strtoint(aktZiffer[i]) - Ziffer_3[i]);     //Die Differenz jeder Stelle des Codes aufaddieren 
   end;
   
   if abs(aktErgebnis) < abs(bestErgebnis) then                                //Die kleinste Differenz ist die gesuchte Zahl
   begin
      bestErgebnis := abs(aktErgebnis);
      totalErgebnis := 3;
   end
....

€: Ich suche diesmal keine Hilfe für das eigentliche Programmieren, sonder vielmehr logische, mathematische Ideen wie man die Codes am besten vergleicht!

[Medium]

Zunächst mal die Frage nach einer Info, die ganz von Anfang an schon sehr wichtig gewesen wäre eigentlich: Woher stammen die Buchstaben? Screenshots? Scans? Von gedrucktem oder Handschrift? Fotos? Mikrofilm? Danach richtet sich ganz stark wie tolerant das Verfahren sein darf/muss, und auch wie komplex.

Eine grundsätzlich ähnliche, aber andere Idee:
Lege für jedes Zeichen ein Musterbild an (wie jetzt deine Mustercodes quasi), und bilde die Differenz des aktuellen Kandidaten und aller Muster (ggf. durch Größen schon eingrenzbar). Dort wo nachher am meisten schwarze Pixel im Differenzbild sind, hast du eine ganz gute potentielle Übereinstimmung. Das kann man aber eben auch nur tun, wenn man sicher ist, alle Zeichen immer gleich eingrenzen zu können, und dass alle gleichen Zeichen im zu erkennenden Text sehr ähnlich sind. Aber das musst du bei deinem Verfahren oben ja genau so - daher nehme ich das mal als gegeben an.

Das wäre mit der simpelste Ansatz, der bei Screenshots immerhin perfekt arbeitet, und bei gescannten Drucksachen meist auch noch recht zuverlässig ist. Bei Handschrift wird man um ein NN nicht mehr herum kommen, und Fotos haben fast immer zu viele perspektivische Verzerrungen um sie unkorrigiert so nutzen zu können.

[MaToBe]

ich erstelle einen Screenshot auf dem gleichgroße gelbe Quadrate zu sehen sind, in die eine schwarze Ziffer geschrieben ist. Dies kann man auhc in meinem Anhang sehn, wie diese einzelnen Quadrate aussehn.

Da jedes Quadrat gleich groß ist, habe ich also die gleichen Ausgangsbedingugnen. Allerdings funktioniert mein Ansatz trotzdem leider nicht.

Zitat:

Lege für jedes Zeichen ein Musterbild an (wie jetzt deine Mustercodes quasi), und bilde die Differenz des aktuellen Kandidaten und aller Muster (ggf. durch Größen schon eingrenzbar). Dort wo nachher am meisten schwarze Pixel im Differenzbild sind, hast du eine ganz gute potentielle Übereinstimmung. Das kann man aber eben auch nur tun, wenn man sicher ist, alle Zeichen immer gleich eingrenzen zu können, und dass alle gleichen Zeichen im zu erkennenden Text sehr ähnlich sind. Aber das musst du bei deinem Verfahren oben ja genau so - daher nehme ich das mal als gegeben an.

Ich versteh nicht ganz den Unterschied? Ich benutzte doch auch ein Musterbild (in Zahlenform, die Codes) die dann mit jedem Quadrat abgeglichen werden.

[dacoder]

Ich denke, dass man es nicht all zu sehr von den Pixeln etc. abhängig machen sollte. Die Idee mit der Kohonen-Map erschien mir sehr plausibel.

Tools wie JDownloader erkennen Captchas, weiß zwar nicht, ob es dazu irgendwo eine Doku gibt, aber das wäre sicherlich mal, falls man dazu was im Internet findet, einen Schnupper wert.

[Medium]

Wenn es Screenshots klar lesbarer und nicht absichtlich unkenntlich gemachter Zeichen sind, ist ein NN oder Kohonen-Map völlig überdimensioniert.

Zitat:

Zitat von MaToBe

Ich versteh nicht ganz den Unterschied? Ich benutzte doch auch ein Musterbild (in Zahlenform, die Codes) die dann mit jedem Quadrat abgeglichen werden.

Ich sag ja, der Ansatz ist nicht unähnlich. Das Problem an den Codes ist allerdings, dass bei diesen die Positionsinformation mit der Farbinformation quasi vermischt wird, und eine einziger Pixel Unterschied in der Lage ist mehr Unterschied im "Fingerprint" zu erzeugen als sinnvoll. Ich finde gerade auch nicht wirklich gute Worte das brauchbar zu beschreiben :?.
Evtl. so: Ein einzelner isolierter Pixel Unterschied allein kann schon bedeuten, dass ein Fingerprint 2 Einträge mehr erhält, und somit fast nicht mehr mit dem eigentlich passenden zu identifizieren ist. Das wäre eine Schwachstelle.

So am Rande: Wenn die Screenshots zwischendurch nicht verlustbehaftet komprimiert wurden, sollten gleiche Zeichen doch spätestens nach Umwandlung in s/w wirklich 100%ig identisch sein. Brauchst du überhaupt ein intelligentes/tolerantes Verfahren!?

[MaToBe]

Zitat:

Zitat von Medium

Wenn es Screenshots klar lesbarer und nicht absichtlich unkenntlich gemachter Zeichen sind, ist ein NN oder Kohonen-Map völlig überdimensioniert.

Sie sind klar lesbar, also total überdimensionert, weshalb ich diese Varianten nicht verwende.

Zitat:

Zitat von Medium

Evtl. so: Ein einzelner isolierter Pixel Unterschied allein kann schon bedeuten, dass ein Fingerprint 2 Einträge mehr erhält, und somit fast nicht mehr mit dem eigentlich passenden zu identifizieren ist. Das wäre eine Schwachstelle.

Okay so hab ich jetzt mein Problem verstanden, super danke!

Zitat:

Zitat von Medium

So am Rande: Wenn die Screenshots zwischendurch nicht verlustbehaftet komprimiert wurden, sollten gleiche Zeichen doch spätestens nach Umwandlung in s/w wirklich 100%ig identisch sein. Brauchst du überhaupt ein intelligentes/tolerantes Verfahren!?

Komischerweise ist mir aufgegfallen, dass die einzelnen Ziffer-Bilder einer gleichen Ziffer durchaus geringfügig unterschiedlich sein können. Sie sind zwar immer gleich groß (gleiche Gesamtpixelanzahl) allerdings gibt es Unterschiede in den Farbnuancen. So hat zB eine 8 einmal nach der schwarz-weiß Umwandlung 81 schwarze Pixel und ein anderes mal nur 79. Dies kann man auch nicht durch das Angleichen des Toleranzwertes ausgleichen, hab ich schon probiert. Deshalb war das bloße Zählen der schwarzen Pixel auch zu Ungenau!

Zitat:

Zitat von Medium

Wenn die Screenshots zwischendurch nicht verlustbehaftet komprimiert wurden...

Ich lade den Screenshot in ein TImage. Ist das verlustbehaftet?

MFG und danke für euer Engagement

[Medium]

Zitat:

Komischerweise ist mir aufgegfallen, dass die einzelnen Ziffer-Bilder einer gleichen Ziffer durchaus geringfügig unterschiedlich sein können. [...]

Ah, ich seh's gerade. Dafür kannst du dich sehr wahrscheinlich bei ClearType bedanken :?. Ich fürchte nur die wirklich ganz schwarzen Pixel als schwarz anzuerkennen (also quasi Grenzwert 0) hilft auch nichts, oder? Aber bei dieser Art von Differenzen sollte mein Vorschlag sehr verlässliche Ergebnisse liefern.

Zitat:

Ich lade den Screenshot in ein TImage. Ist das verlustbehaftet?

Der wichtige Schritt ist: Speicherst du davor auf einen Datenträger, und wenn ja, in welchem Format? Die Anzeige ist völlig unerheblich. JPEG wäre z.B. verlustbehaftet, GIF nur was die Farbanzahl angeht, und da eh s/w ansteht wäre das relativ egal, BMP/PNG/TIF/TGA/DIB sind verlustfrei - um mal so die wichtigsten zu nennen. Wenn du den Screenshot direkt aus dem Clipboard holst, ist er in aller Regel auch verlustfrei übertragen.

[MaToBe]

Zitat:

Lege für jedes Zeichen ein Musterbild an (wie jetzt deine Mustercodes quasi), und bilde die Differenz des aktuellen Kandidaten und aller Muster (ggf. durch Größen schon eingrenzbar). Dort wo nachher am meisten schwarze Pixel im Differenzbild sind, hast du eine ganz gute potentielle Übereinstimmung.

Ich bin mir nicht sicher ob ich das ganz richtig verstanden habe. Ich soll quais das aktuelle Bild auf meinem Vergleichsbild abbilden und schauen ob es sich deckt?

Falls ja würde ich das so umsetzten:

Delphi-Quellcode:

// ~Pseudocode~
for x := 0 to Image.Width -1 do
begin
  for y := 0 to Image.Heiht -1 do
  begin
     if aktImage.Canvas.Pixel[x,y] = Image_8.Canvas.Pixel[x,y] then  //Wenn im aktuellen Bild und im Differenzbild ein Pixel die gleiche Farbe hat 
        inc(Anzahl_8);                                               //wird der Zähler für Ziffer 8 erhöht.
  end;
end;

//Die Zahl die den höchste Zähler hat ist die gesuchte Zahl.

Ist das deine grob deine Idee?

[Medium]

Das wäre eine Variante, jup. Mir fiel gerade noch ein, dass man das evtl. noch toleranter gegenüber des Antialiasings von ClearType gestalten könnte:

Die Bilder nicht in s/w, sondern Graustufen umwandeln. Dann

Delphi-Quellcode:

// ~Pseudocode~ 
Abweichung_8 := 0; // ist ein float
for x := 0 to Image.Width -1 do 
begin 
  for y := 0 to Image.Heiht -1 do 
  begin 
     Abweichung_8 := Abweichung_8 + Abs(GetRValue(aktImage.Canvas.Pixel[x,y]) - GetRValue(Image_8.Canvas.Pixel[x,y]));
  end; 
end; 
Abweichung_8 := Abweichung_8 / (255*Image.Width*Image.Height);

// Abweichung_* = 0 -> identisches Bild
// Abweichung_* = 1 -> maximaler Unterschied

Dadurch haut man sich evtl. weniger Fehler durch knappe Grenzwertentscheidungen beim s/w Konvertieren rein.

[MaToBe]

Ich hab es jetzt vollständig hinbekommen, bisher bei über 200 Zahlen kein Fehler.

Bei der Umwandlung in Graustufen traten wieder leichte Ungenauigkeiten auf, da manche Zahlen so eine Art "Glanzeffekt" haben. Deshalb habe ich dann doch wieder den Schwarz-Weiß Filter genommen (10% Toleranz), wodurch dieser Effekt ausgeklammert werden konnte.

Mit Hilfe von Mediums Ansatz des Abweichungsvergleichs läuft nun alles perfekt, weshalb ich mich mal wieder bei der DP aber besonders auch bei Medium bedanken möchte. Danke!