Vergleichen zweier BitMaps

[fresh_hotboy]

hi hallo

das forum hier ist echt erste sahne. habe ein paar lösungen für mein erstes problem bekommen und diese gleich umgesetzt. EIN FETTER DANK AN DIE ORGANISATOREN DIESES FORUMS!!!
nu habe ich ein weiteres problem, möchte zwei bitmaps miteinander vergleichen. das ergebnis anschliessend in eine neue paintbox laden.
kann mir da irgendeiner weiter helfen.

danke!!!!

[Daniel]

Was soll dennn bei Deinem Vergleich herauskommen? Ganz allgemein kann so ein Vergleich ja nur "sind identisch" oder "sind nicht identisch" liefern. Für so ein Resultat brauchst Du aber keine Paintbox. :roll:
Was hast Du also im Speziellen vor ?


P.S.: Heißen Dank für's fett Lob. *g*

[choose]

Wenn ich Dich richtig verstehe, willst Du die "Differenz" zweier Bilder berechnen, oder?
Aus den Lösungen zu Deinem letzen Posting weißt Du schon, wie Du die einzelnen Pixel auslesen kannst. Um nun die Differenz der Bilder zu berechnen, brauchst Du nur folgendes zu machen (vorausgesetzt, die Bildgrößen sind passend):

Delphi-Quellcode:

für jeden Pixel do
begin
  Ergebnispixel:= Pixel aus Bild1 - Pixel aus Bild2
end;

Bei der Berechnung kann es zu Überläufen kommen, wenn ein Farbwert aus Bild2 größer ist als der korrespondierende aus Bild1.

Willst Du lediglich die Pixel weiß zeichnen, in denen sich zwei Bilder unterscheiden, und alle anderen schwarz, probiere folgendes:

Delphi-Quellcode:

für jeden Pixel do
begin
  if Pixel aus Bild1 <> Pixel aus Bild2 then
    Ergebnispixel:= Weiß
  else
    Ergebnispixel:= Schwarz

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]

[fresh_hotboy]

danke für eure antworten, sollte mich aber vielleicht doch besser ausdrücken!!
bin grad ein delphi anfänger und probiere so einiges aus. deshalb benötige ich wohl momentan eine etwas genauere anleitung zu den programmen. aber zurück zum thema:

habe zwei BitMaps in zwei Paintboxen geladen, diese anschliessend in graustufen umgewandelt. nun möchte ich diese bilder auf deren inhalt vergleichen (d.h. ob z.B. ein neuer gegenstand auf dem bild ist). das vergleichen geschiecht durch abziehen der farbwerte bild1-bild2. das Vergleichs bild soll anschliessend in eine dritte PaintBox gemalt werden.

so nu ist es hoffe ich einiegermassen klarer. :-D

PS.: der lob ist berechtigt !!!

[himitsu]

Versuch es mal hiermit:

Delphi-Quellcode:

Var X, Y: Integer;

Begin
  For X := 0 to PaintBox1.Width - 1 do
    For Y := 0 to PaintBox1.Width - 1 do
      PaintBox3.Canvas.Pixels[X, Y] := (PaintBox1.Canvas.Pixels[X, Y] xor PaintBox2.Canvas.Pixels[X, Y]) and $00FFFFFF;
End;

Hab das mal schnell im Kopf optimiert. Also nicht getestet.
Das berechnet pro Pixel für jede Grundfarbe (Rot/Grün/Blau) die Farbdifferenz.

Delphi-Quellcode:

Rot3 := ABS(Rot1 - Rot2);

Man könnte das Ganze noch auf ScanLine abändern, um die Berechnung zu beschleunigen.

[choose]

Zitat:

Zitat von himitsu

Delphi-Quellcode:

//gekürzt und geändert
Rot3 := (Rot1 xor Rot2) and $FF;

Hab das mal schnell im Kopf optimiert. Also nicht getestet.
Das berechnet pro Pixel für jede Grundfarbe (Rot/Grün/Blau) die Farbdifferenz.

Delphi-Quellcode:

Rot3 := ABS(Rot1 - Rot2);

Hi himitsu, bei mir ist aber obdA

Delphi-Quellcode:

($08 xor $01) <> abs($08 - $01) // $09 <> $07

Oder habe ich einen Denkfehler?

[fresh_hotboy]

hi hallo
VIELEN DANK !!
habe es bereits auf ein graustufenbild angewandt und es funktioniert :-D.
bin gerade es mit dem befehl scanline zu optimieren, komme aber grad nicht auf den grünen punkt, da ich damit noch nicht so wirklich viel zu tun hatte.

[himitsu]

Ne, ich glaub der Denkfehler liegt bei mir. Funktioniert aber dennoch.

Kannst ja auch so rechnen:

Delphi-Quellcode:

Var R1, G1, B1, R2, G2, B2, Re, Ge, Be: Byte;

{je Pixel}
R1 := Bild1.Canvas.Pixels[X, Y] and $0000FF;
G1 := (Bild1.Canvas.Pixels[X, Y] and $00FF00) shr 8;
B1 := (Bild1.Canvas.Pixels[X, Y] and $FF0000) shr 16;

R2 := Bild2.Canvas.Pixels[X, Y] and $0000FF;
G2 := (Bild2.Canvas.Pixels[X, Y] and $00FF00) shr 8;
B2 := (Bild2.Canvas.Pixels[X, Y] and $FF0000) shr 16;

Re := Ord(R1 - R2);
Ge := Ord(G1 - G2);
Be := Ord(B1 - B2);

Bild3.Canvas.Pixels[X, Y] := RGB(Re, Ge, Be);

Auch wenn es nicht ganz richtig ist, ist es doch etwas schneller:

Delphi-Quellcode:

Bild3.Canvas.Pixels[X, Y] := (Bild1.Canvas.Pixels[X, Y] xor Bild2.Canvas.Pixels[X, Y]) and $00FFFFFF;

[choose]

Zitat:

Zitat von himitsu

Delphi-Quellcode:

Re := Ord(R1 - R2);

Hi himitsu,

hier gibt es Überlaufprobleme, wenn R2>R1, Du meinstest aber sicher, abs statt ord, oder?

Ich verstehe trotzdem nicht Deine Variante, nach der Du mithilfe zweier binärer Operationen eine Arithmetische ersetzt...? Wenn Du zB 128 xor 127 rechnest, ist das doch 255 statt 128 - 127 mit dem gewünschten Ergebnis 1. Sicher ist es schneller, aber das Ergebnis stimmt nicht ganz ;)

[himitsu]

:oops: Stimmt, meinte natürlich ABS.
:gruebel: Das mit dem XOR, weis auch nicht was da in meinem Kopf fehlgeleitet wurde. (hatte mir auch ein paar Werte durchgerechnet, und da stimmte es fast)


:coder: Na dann optimieren wir mal in Richtung Graustufen.

Delphi-Quellcode:

Var R1, G1, B1, R2, G2, B2, Re, Ge, Be: Byte;

{je Pixel}
R1 := Bild1.Canvas.Pixels[X, Y] and $0000FF;
G1 := (Bild1.Canvas.Pixels[X, Y] and $00FF00) shr 8;
B1 := (Bild1.Canvas.Pixels[X, Y] and $FF0000) shr 16;

R2 := Bild2.Canvas.Pixels[X, Y] and $0000FF;
G2 := (Bild2.Canvas.Pixels[X, Y] and $00FF00) shr 8;
B2 := (Bild2.Canvas.Pixels[X, Y] and $FF0000) shr 16;

Re := ABS(R1 - R2);
Ge := ABS(G1 - G2);
Be := ABS(B1 - B2);

Bild3.Canvas.Pixels[X, Y] := RGB(Re, Ge, Be);

wird zu:

Delphi-Quellcode:

Var C: Byte;

{je Pixel}
C := ABS((Bild1.Canvas.Pixels[X, Y] and $0000FF) - (Bild2.Canvas.Pixels[X, Y] and $0000FF));
Bild3.Canvas.Pixels[X, Y] := RGB(C, C, C);

oder:

Delphi-Quellcode:

Var C: Byte;

{je Pixel}
C := ABS((Bild1.Canvas.Pixels[X, Y] and $0000FF) - (Bild2.Canvas.Pixels[X, Y] and $0000FF));
Bild3.Canvas.Pixels[X, Y] := (C shl 16) or (C shl 8) or C;