Bilder-Vergleichen / Farbe erkennen

[patti]

Also zumindest bei dem Farb-Vergleich kann ich dir helfen.

Eine RGB-Farbe besteht aus den drei Farb-Komponenten (Kanälen) Rot, Grün und Blau, wobei jeder Wert ein (vorzeichenloses) Byte ist, also Werte von 0 bis 255 annehmen kann. Den Unterschied zwischen zwei Farben kannst du beispielsweise als die durchschnittliche Differenz ihrer Kanal-Werte interpretieren:

Delphi-Quellcode:

function FarbAbweichung(c1, c2 : TColor) : byte;
var abweichung_r, abweichung_g, abweichung_b : byte;
var mittlere_abweichung : byte;
begin
abweichung_r := abs(GetRValue(c1) - GetRValue(c2));
abweichung_g := abs(GetGValue(c1) - GetGValue(c2));
abweichung_b := abs(GetBValue(c1) - GetBValue(c2));
//
mittlere_abweichung := round((abweichung_r + abweichung_g + abweichung_b) / 3);
result := mittlere_abweichung;
end;

Leg dir intern zwei Bitmaps (TBitmap) an, die die selbe Größe haben. Auf das erste Bitmap stretchst du (am besten per StretchBlt, einfach suchen) dein erstes Bild, auf dein zweites Bitmap dein zweites Bild. Dann gehst du in einer zweidimensionalen Schleife jeden Pixel durch, überprüfst die beiden Farb-Werte aus den zwei Bitmaps auf Ähnlichkeit (natürlich mit einer gewissen Toleranz) und speicherst das Ergebnis in einem zweidimensionalen Array of boolean.

Delphi-Quellcode:

var ergebnis : array of array of boolean; // natürlich in der Größe deiner Bitmaps
//
for x := 0 to breite -1 do
begin
  for y := 0 to hoehe -1 do
    ergebnis[x,y] := FarbAbweichung(bitmap1.Canvas.Pixel[x,y],bitmap2.Canvas.Pixel[x,y]) < toleranz;
end;

(lässt sich sicherlich noch alles optimieren, nur so als Denkanstoß)

Ein Array-Wert von 1 steht dann für "ähnlich", ein Wert von 0 für "unähnlich".

Das war jetzt nur eine knappe Zusammenfassung, wie ich es angehen würde. Vielleicht hilft dir das ja schonmal einen Schritt weiter

[Phoenix]

Das TImage solltest Du ganz schnell vergessen. Das Problem ist hierbei, dass das TImage das Bild selber nicht skaliert sondern nur skaliert darstellt. Das heisst Du müsstest dann nochmal einen Screenshot von dem skalierten Bild machen und versaust Dir damit das Ergebnis.

Weiteres Problem wenn Du mit unterschiedlichen Bildergrößen und Skalierungen arbeitest und, wie Du meintest, nur jedes n-te Pixel vergleichst: Allein die leichteste Verschiebung des Inhaltes um ein Pixel wird Dir je nach Inhalt ein Changeset von annähernd 100% liefern.

Du solltest bei Bildern unterschiedlicher Größen hergehen, und beim höher aufgelösten (größeren) Bild, Pixelgruppen im größenverhältnis zum kleineren Bild zusammenfassen und über deren Mittelwert berechnen (also sozusagen das größere zum Vergleich in-memory runterskalieren). Das dürfte ein besseres Ergebnis geben.

Um Verschiebungen vorzubeugen wäre es auch besser, erstmal nur eine reine Kantenerkennung zu machen (da gibts noch relativ leichte Algorithmen), und wenn in beiden Bildern ähnliche Kantenvektoren erkannt wurden, entlang dieser Kanten entsprechend skaliert zu vergleichen (rechts bzw. links von der Kante). Anhand der Kantenvektoren kannst Du dann auch einige Punkte zwischen den Kanten ermitteln und hier weitere vergleiche machen um das Ergebnis zu verbessern.

Bei den Farbvergleichen: Du musst immer mit Toleranzen arbeiten. Welche Toleranzen allerdings die besten Ergebnisse ergeben ist leider von ungeheuer vielen Faktoren abhängig. Da ist erstmal viel Ausprobieren notwendig.

Alles in allem ist das eine durchaus lösbare Aufgabe, aber unterschätze den Aufwand nicht. Das ist viel Mathe, und es ist schon schwierig das überhaupt hinzubekommen. Das dann noch performant zu lösen, so dass sich der Rechner nicht totrechnet sondern in einer ordentlichen Zeit das Ergebnis ausspuckt ist dann nochmal eine Stufe drüber.

Wie gesagt würde ich erstmal mit Kantenerkennung anfangen um überhaupt zu entscheiden ob es sich lohnt mit Farbvergleichen loszulegen. Und dann die große Frage: Soll ein Farb- und ein Schwarzweissbild als dasselbe Motiv erkannt werden oder nicht?

[shmia]

Von turboPASCAL gibt es zum Vergleich von Bitmaps ein Demo/Tool mit Sourcecode:
http://www.delphipraxis.net/49986-%5...-scanline.html
Das könne man als Startpunkt verwenden und dann weiterentwickeln.
Man müsste den eigentlichen Vergleichsalgorithmus aus der Unit1 rausrupfen und als Klassenbibliothek bereitstellen...

[Lifthrasir]

Vielen Dank für eure Antworten, ich werde mir mal das mit der Kantenerkennung ansehen..

Farbbereiche zusammenzuführen und dann einen Mittelwert zu bilden erscheint mir im späterem Verlauf ebenso sinnig. Schade das nun Images nicht skalieren *lach


Freue mich aber auf noch mehr Denkanstöße und Tipps, da bin ich immer sehr Dankbar

[Lifthrasir]

Zwischenfrage:
patti und Phoenix - ihr habt beide von TBitmap bzw Bitmaps gesprochen.. Habe nun auch zwei angelegt in welche ein Probebild eingeladen wird. So weit so gut. Aber, verzeiht die blöde Frage, was passiert mit jpegs? Die kann man nicht wirklich in ein Bitmap laden, oder?

Danke für's Bemühen


PS:
Ich habe durch Suchfu herrausgefunden das sich jpgs ''Recht leicht'' in bmp umwandeln lassen, das wäre also der nötige vorschritt, oder?

[-187-]

Ich glaube du brauchst die uses JPEG um ein jpg in ein TBitmap zu laden.

[patti]

Ja, Unit JPEG einbinden und dann kann's los gehen
Du kannst dann beispielsweise per Bitmap.Canvas.Draw(0,0,jpeg); ein JPEG auf eine Bitmap-Canvas zeichnen. Schau dir dazu mal TJPEGImage an.