Bildanalyse/-vergleich

[Slashmob]

Guten Tag zusammen,

ich möchte das untenstehende Projekt bearbeiten, das ich allerdings inhaltlich nicht ganz verstehe und mir somit die konkrete Umsetzung sehr schwer fällt.

Hier ist die Aufgabenstellung:

__________________________________________________ __________________________________________________ _____
Es sollen zwei Bilder des identischen Bereichs des Sternhimmels untersucht werden, die zu verschiedenen Zeiten aufgenommen wurden.
Es handelt sich um Grauwertbilder, von denen der Einfachheit halber nur der Rotanteil zur Auswertung benutzt wird (d.h. die Pixelfarben sind mit der Rotmaske zu maskieren).

Das Projekt enthält eine Funktion TForm1.floodfill_(x,y,fillColor,oldColor:integer), die eine mit einer Farbe umgrenzten Fläche ausfüllt.
Es handelt sich um eine rekursive Funktion.(Wie funktioniert die Funktion? Welche Farbkombination von RGB liefern graue Pixel?)

Für das Programm ist es notwendig ein ausgefülltes Quadrat der Fläche n*n an einer beliebigen Position (x,y=linke obere Ecke) in die vier Imagefelder zeichnen zu können.

Hierfür ist die Prozedur TForm1.quadratmalen(image,top_,left_,kantenlaenge, farbe:integer) zu erstellen, die mittels CASE das Zielimage (Image3) bedient.
Mit Hilfe der Parameter ist die Farbe einzustellen und dann vom linken oberen Eckpunkt aus mit vier Linien der Umriss des Quadrats zu zeichnen. Wird mit Farbe "rot" gezeichnet,
soll danach auf den rechten/unteren Punkt gesetzt werden, der noch nicht rot ist, sich also innerhalb des roten Kastens befindet. Dies ist der Startpunkt für die Floodfill-Funktion.
Dieser innere Punkt existiert erst ab der Kantenlänge 3.
Bei kleineren Kantenlängen wird nicht gezeichnet.

Die eigentliche Prozedur ist nun so zu programmieren, dass Pixel für Pixel das Ausgangsbild (Image1) mit dem Vergleichsbild (Image2) verglichen wird.
Man bildet dazu einfach den Absolutwert der Differenz der Pixel mit den gleichen Koordinaten.
Ist dieser Wert größer als der Schwellwert (Voreinstellung: Grauwert 10),
so ist an dieser Koordinate das rote Quadrat in Image3 zu zeichnen.

Gleichzeitig ist der Differenzwert zusammen mit der laufenden Nummer und Koordinate in ein Stringfeld einzutragen.
Jedes Mal, wenn sich die laufende Nummer der entdeckter Differenzen erhöht,
ist auch die Länge des Stringgrid-Feldes um eins zu erhöhen (Eigenschaft rowcount)

Sollte nun ein benachbarter Punkt innerhalb der Kantzenlänge des Quadrats liegen,
so ist er bei der Untersuchung zu ignorieren.
Zur Entscheidung dazu nutzt man die roten Pixel im Image3.
In das weiße Image4 werden die gefundenen Einzelpunkte in roter Farbe eingetragen.

Im Image4 sollten genauso viele Punkte sein, wie Quadrate in Image3 oder Zeilen im Stringgrid.
__________________________________________________ __________________________________________________ _______
Wie es fertig aussehen und funktionieren soll ist im Anhang als Bild dargestellt.


Als Hilfe haben wir schon einen Teil des Codes bekommen:

Delphi-Quellcode:

unit Unit1; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, Grids, Spin;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Image2: TImage;
    Image3: TImage;
    Image4: TImage;
    Label1: TLabel;
    Label2: TLabel;
    SpinEdit1: TSpinEdit;
    SpinEdit2: TSpinEdit;
    StringGrid1: TStringGrid;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure floodFill_(x,y,fillColor,oldColor: integer);
    procedure quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);
  private
    { private declarations }
  public
    { public declarations }
  end; 

var
  Form1: TForm1; 
  b,h:integer;
implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
     b:=image1.width; h:=image1.height;     // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     image3.width:=b; image3.height:=h;
     image4.width:=b; image4.height:=h;

     image1.canvas.brush.color:=clblack;   // Hintergrundfarben
     image2.canvas.brush.color:=clblack;
     image3.canvas.brush.color:=clblack;
     image4.canvas.brush.color:=clwhite;

     image1.canvas.fillrect(rect(0,0,b,h));  // Rechteck mit obigen Farben ausfüllen
     image2.canvas.fillrect(rect(0,0,b,h));
     image3.canvas.fillrect(rect(0,0,b,h));
     image4.canvas.fillrect(rect(0,0,b,h));

     image1.Picture.loadfromfile('1sw.bmp');  // Bilder hochladen
     image2.Picture.loadfromfile('pic2.bmp');

     form1.caption:= 'Bildanalyse-Suche nach Vergleichsschwankungen';
end;

procedure tform1.floodFill_(x,y,fillColor,oldColor: integer);
   begin
         // Wie arbeitet diese Füllfunktion?
   with image3.canvas do
   if (pixels[x,y]=oldColor) then
      begin
      Pixels[x,y]:= fillcolor;
      floodFill_(x+1,y, fillcolor, oldColor);
      floodFill_(x-1,y, fillcolor, oldColor);
      floodFill_(x,y+1, fillcolor, oldColor);
      floodFill_(x,y-1, fillcolor, oldColor);
   end;
end;

procedure tform1.quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);
   var km1:integer;

   begin
   km1:=kantenlaenge-1;

   // hier Programmierung des Quadrats in jedem Image 1-4
   // mittels zeichnen der Kanten aus 4 linien
   // und dann Füllen mit Füllfunktion
   // nur 3 wird benutzt
   case image of
      1:
         with form1.image1.canvas do
            begin
         end;
      2:
         with form1.image2.canvas do
            begin
            end;
      3: // der Fall wird im Programm benutzt
         with form1.image3.canvas do
            begin

         end;
      4:
         with form1.image4.canvas do
            begin
         end;
      end;
   end;

procedure TForm1.Button1Click(Sender: TObject);
Var i,              // Laufindex
    farbe1,         // Pixelfarbe im Image1
    farbe2,         // Pixelfarbe im Image2
    wert,           // Differenzwert
    schwellwert,    // Schwellwert zum Vergleich
    zeile,
    grid_zeilennr,  // Zeilennummer im Grid
    sz,             // Spaltenzahl
    zz,             // Zeilenzahl
    kantelange      // Kantenlänge des Quadrats
            :integer;

begin
     grid_zeilennr:=0;
     i:=0;
     schwellwert:=spinedit1.value;        // Voreinstellung 10
     kantelange:=spinedit2.value;         // minimal 3
     stringgrid1.cells[0,grid_zeilennr]:='Nr.';
     stringgrid1.cells[1,grid_zeilennr]:='Diff-Wert';
     stringgrid1.cells[2,grid_zeilennr]:='x';
     stringgrid1.cells[3,grid_zeilennr]:='y';
     // hier weiter programmieren
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  close;
end;

end.

Nun meine Fragen hierzu:
1) Was ist damit gemeint

Zitat:

Es handelt sich um Grauwertbilder, von denen der Einfachheit halber nur der Rotanteil zur Auswertung benutzt wird (d.h. die Pixelfarben sind mit der Rotmaske zu maskieren).

2)Wie genau funktioniert diese Funktion?

Zitat:

TForm1.floodfill_(x,y,fillColor,oldColor:integer)

Ich weiß, dass eine rekursive Funktion sich quasi "selbst aufrufen" kann.
Was bedeuten die Parameter fillColor und oldcolor? (vgl.obenstehenden code)
Auf die Frage

Zitat:

Welche Farbkombination von RGB liefern graue Pixel?)

würde ich ich sagen: $00ffffff.

3)Die Prozedur

Zitat:

TForm1.quadratmalen(image,top_,left_,kantenlaenge, farbe:integer)

versteh ich nicht ganz. Was bedeuten die beiden Parameter "top_" und "left_"?? Wie soll ich damit ein Quadrat malen?

4)

Zitat:

Die eigentliche Prozedur ist nun so zu programmieren, dass Pixel für Pixel das Ausgangsbild (Image1) mit dem Vergleichsbild (Image2) verglichen wird. Man bildet dazu einfach den Absolutwert der Differenz der Pixel mit den gleichen Koordinaten. Ist dieser Wert größer als der Schwellwert (Voreinstellung: Grauwert 10), so ist an dieser Koordinate das rote Quadrat in Image3 zu zeichnen.

Wie kann ich die beiden Bilder Pixelweise vergleichen?

Hab schon bisschen dran gearbeitet, aber wie gesagt komme hier nicht wirklich weiter, weil mich die obigen Fragen quälen. :?
Vielleicht werdet ihr schlauer aus der ganzen Sache als ich.
Wäre über jeden Tipp und Ansatz dankbar!

Gruß Slash

[freeway]

1) Ausmaskieren ? keine Ahnung aber getpixel oder scanline erfüllen den selben zweck

2) fillColor Farbe die ausgegeben werden soll
oldcolor Farbe die ersetzt werden soll

$00ffffff würde weiss entsprechen, $007F7F7F wäre dann ein Grauton

3)top_ left_ ist die Startposition und über die Kantenlänge wird bottom und right berechnet

4) dazu gibt es hier schon einige Beiträge z.B. --> http://www.delphipraxis.net/80639-bi...rgleichen.html

[Slashmob]

Zitat:

Zitat von freeway (Beitrag 1140358)

1) Ausmaskieren ? keine Ahnung aber getpixel oder scanline erfüllen den selben zweck

2) fillColor Farbe die ausgegeben werden soll
oldcolor Farbe die ersetzt werden soll

$00ffffff würde weiss entsprechen, $007F7F7F wäre dann ein Grauton

3)top_ left_ ist die Startposition und über die Kantenlänge wird bottom und right berechnet

4) dazu gibt es hier schon einige Beiträge z.B. --> http://www.delphipraxis.net/80639-bi...rgleichen.html

Wie geht das mit dem ausmaskieren? In der Aufgabe steht ja ich soll eine Rotmaske für die Pixel verwenden.

Zu 4)Wie sieht das als Code aus, wenn ich das erste Bild pixelweise, also in jeder Zeile und Spalte die Pixel auslese und mit dem zweiten Bild vergleiche und dann die Differenz der Pixel bei den gleichen Koordinaten bilde?

Dachte irgendwie an sowas...

Delphi-Quellcode:

For i:=1 to image1.width do       // Erstes Bild pixelweise auslesen
         Begin
              For j:=1 to image1.height do
                  Begin
                       farbe1:= image1.canvas.pixels[x,y];
                    end;
           end;

      For k:=1 to image2.width do        // Zweites Bild pixelweise auslesen
         Begin
              For l:=1 to image2.height do
                  Begin
                       farbe2:= image2.canvas.pixels[x,y];
                    end;
           end;                
      wert:= farbe1-farbe2;       // Differenzwert bilden

Jemand ne Ahnung wie man hier vorgeht??

[Bummi]

wenn Du

Delphi-Quellcode:

wert:= (farbe1 AND clRed) - (farbe2 AND clRed);

verwendest bist Du diesbezüglich näher an den Vorgaben.

[Slashmob]

Zitat:

Zitat von Bummi (Beitrag 1140636)

wenn Du

Delphi-Quellcode:

wert:= (farbe1 AND clRed) - (farbe2 AND clRed);

verwendest bist Du diesbezüglich näher an den Vorgaben.

Das heißt bei der Differenz hab ich dann automatisch die Rotmaske drinnen,richtig?

[Bummi]

Ja ...

[Slashmob]

Nun möchte ich den "wert" mit dem schwellwert vergleichen und ihn im stringgrid ausgeben, aber das klappt nicht. Dann kommt folgende Fehlermeldung:
Error: Incompatible type for arg no.3: Got "LongInt", expected "AnsiString"

Delphi-Quellcode:

For i:=1 to image1.width do             // Erstes Bild pixelweise auslesen
         Begin
              For j:=1 to image1.height do
                  Begin
                       farbe1:= image1.canvas.pixels[i,j];
                    end;
           end;

      For i:=1 to image2.width do       // Zweites Bild pixelweise auslesen
         Begin
              For j:=1 to image2.height do
                  Begin
                       farbe2:= image2.canvas.pixels[i,j];
                    end;
           end;

     wert:= (farbe1 and clred)-(farbe2 and clred);   // Differenzwert bilden

     If wert > schwellwert then
        Begin
             stringgrid1.cells[1,1]:=inttostr(wert);   // Edit
        end;

Und wie bekomm ich raus an welchen Stellen X und Y er die Unterschiede im Bild gefunden hat?

[DeddyH]

Wie wandelt man denn eine Ganzzahl in einen String um? Format oder IntToStr könnten da ganz hilfreich sein.

[Slashmob]

Zitat:

Zitat von DeddyH (Beitrag 1140646)

Wie wandelt man denn eine Ganzzahl in einen String um? Format oder IntToStr könnten da ganz hilfreich sein.

Ach logisch, stimmt! (Bin noch Anfänger :oops:)
Jetzt ist der Fehler weg, aber es wird kein Wert angezeigt, stattdessen ändert sich die zeilenanzahl :?
Kriegt er denn mit dem obigen code einen Wert? Bin mir nicht ganz sicher...

[DeddyH]

Irgendwie passen Deine Schleifen überhaupt nicht zusammen.

[edit] Da die Bilder ja gleich groß sind, müsste das auch so gehen:

Delphi-Quellcode:

For i:=1 to image1.width do
  Begin
    For j:=1 to image1.height do
      Begin
        farbe1 := image1.canvas.pixels[i,j];
        farbe2 := image2.canvas.pixels[i,j];
        wert:= (farbe1 and clred)-(farbe2 and clred);               
      end;
  end;

[/edit]

[Slashmob]

Zitat:

Zitat von DeddyH (Beitrag 1140648)

Irgendwie passen Deine Schleifen überhaupt nicht zusammen.

Hm, das versteh ich nicht.

Hab versucht mit der ersten Schleife das erste Bild pixelweise auszulesen und mit der zweiten Schleife das zweite Bild. Liegt das vlt. daran, dass ich bei beiden die gleichen Variablen genommen hab?

[DeddyH]

Ich habe meinen letzten Beitrag editiert, schau noch einmal.

[Bummi]

DeddyH war wieder mal schneller, da ich es schon habe poste ich es trotzdem mal ...


BTW.: wenn Du es es optimieren willst steig von Pixels auf Scanline um, Beiträge hierzu liefert die Forensuche bis zum Abwinken

Die bildest im Moment die Differenz nur für das letzte Pixel Deiner Schleifen, man könnte es so lösen

Delphi-Quellcode:

var
 i,j,z:Integer;
begin
 z := 0;
 For i:=0 to image1.width - 1 do // Erstes Bild pixelweise auslesen
         Begin
              For j:=0 to image1.height -1 do
                  Begin
                       farbe1:= image1.canvas.pixels[i,j];
                       farbe2:= image2.canvas.pixels[i,j];
                       wert:= (farbe1 and clred)-(farbe2 and clred); // Differenzwert bilden
                       inc(z);
                       AddFound(z , i, j, wert);
                    end;
           end;

Zahlen müssen in Strings umgewandelt werden wenn Du sie in einem Stringgrid darstellen willst

Delphi-Quellcode:

procedure TForm1.AddFound(nr, x, y, wert :Integer);
begin
  if StringGrid1.Rowcount < (nr + 1) then StringGrid1.Rowcount := (nr + 1);
  StringGrid1.Cells[0, nr ] := IntToStr(Nr);
  StringGrid1.Cells[1, nr ] := IntToStr(x);
  StringGrid1.Cells[2, nr ] := IntToStr(y);
  StringGrid1.Cells[3, nr ] := IntToStr(wert);
end;

[DeddyH]

Was mir gerade erst auffällt: ist Pixels nicht 0-indiziert?

[Bummi]

Doch ..... ich habe die Schleife ungeprüft kopiert und angepasst ...

[Slashmob]

Zitat:

Zitat von DeddyH (Beitrag 1140652)

Was mir gerade erst auffällt: ist Pixels nicht 0-indiziert?

Was bedeutet das? Muss ich ggf. was ändern?


@Bummi: versuche grade deine Idee anzupassen, doch irgendwie bleibt der Differenzwert immer Null.
Muss nochmal in den Code gucken...

[DeddyH]

Siehe Bummis geänderten Code: die Pixel nicht von 1 bis Width/Height vergleichen, sondern von 0 bis Width/Height - 1.

[Slashmob]

Ich habe jetzt versucht den Code etwas anzupassen.
Ich brauch ja nur die Stellen wo es einen Unterschied der beiden Bildern mit dem Schwellwert gibt. Das heißt, es werden nicht mehr alle Pixel aufgelistet, sondern nur die, wo der (Differenz-)Wert > Schwellenwert.
Das Problem ist, dass bei der Ausgabe auf dem Stringgrid der (Differenz-)Wert immer Null ist.
Wo könnte der Fehler sein?

@Bummi und DeddyH:
An dieser Stelle mal ein Danke für eure geleistete Hilfe, Bemühungen und Tipps! :thumb:

Delphi-Quellcode:

procedure TForm1.Addfound (nr,x,y,wert:Integer);
Begin

     If stringgrid1.rowcount < (nr+1) then
        stringgrid1.rowcount:= nr+1;
        
        stringgrid1.cells[0,nr]:=inttostr(Nr);
        stringgrid1.cells[1,nr]:=inttostr(X);
        stringgrid1.cells[2,nr]:=inttostr(Y);
        stringgrid1.cells[3,nr]:=inttostr(Wert);
        
        stringgrid1.cells[0,0]:='Nr.';
        stringgrid1.cells[1,0]:='X';
        stringgrid1.cells[2,0]:='Y';
        stringgrid1.cells[3,0]:='Diff-Wert';

end;

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
Var 
    farbe1,         // Pixelfarbe im Image1
    farbe2,         // Pixelfarbe im Image2
    wert,           // Differenzwert
    schwellwert,    // Schwellwert zum Vergleich
    x,              // Laufindex
    y,              // Laufindex
    z               // Zähler
            :integer;

begin
     b:=image1.width; h:=image1.height;     // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     
     schwellwert:=spinedit1.value;        // Voreinstellung 10

     z:=0;
     For x:=0 to b-1 do
      Begin
           For y:=0 to h-1 do
               Begin
                    farbe1 := image1.canvas.pixels[x,y];
                    farbe2 := image2.canvas.pixels[x,y];
                    wert:= (farbe1 and clred)-(farbe2 and clred);
                    If wert > schwellwert then
                    inc(z);
                    AddFound(z,x,y,wert);
               end;
      end;
end;

[Slashmob]

Ah jetzt steht dort keine Null mehr. *freu* :-D
Vor dem IF stand kein Begin und end?!

Delphi-Quellcode:

begin
     b:=image1.width; h:=image1.height; // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     
     schwellwert:=spinedit1.value; // Voreinstellung 10

     z:=0;
     For x:=0 to b-1 do
      Begin
           For y:=0 to h-1 do
               Begin
                    farbe1 := image1.canvas.pixels[x,y];
                    farbe2 := image2.canvas.pixels[x,y];
                    wert:= (farbe1 and clred)-(farbe2 and clred);
                    If wert > schwellwert then
                    Begin
                      inc(z);
                      AddFound(z,x,y,wert);
                    end;
               end;
      end;
end;

[Bummi]

sorry, lapsus:oops:

[Slashmob]

Nun steh ich wieder vor der Frage wie ich folgendes Problem lösen soll.
Ich muss nun um die gefundenen Punkte (X,Y), die im Stringgrid aufgelistet werden, ein Quadrat malen und dieses dann ausfüllen. (im Image3)
Hierfür hab ich zwei Prozeduren. Aber irgendwie verstehe ich nicht wie diese im Zusammenhang stehen.
Sowas hab ich leider noch nie gemacht. :oops:

Zum Beispiel weiß ich nicht was ich konkret für oldcolor einsetzen soll ( für fillcolor denk ich mal clred einsetzen) und wie ich diese Prozedur aufrufen kann.
Des Weiteren bin ich mir unsicher wie ich mit left_ und top_ umgehen soll. Ich vermute mal damit brauche ich nur die obere linke Ecke des Quadrats.

Ich sehe nur noch :?::?::?::?:

Delphi-Quellcode:

procedure tform1.floodFill_(x,y,fillColor,oldColor: integer);
   begin
   with image3.canvas do
   if (pixels[x,y]=oldColor) then
      begin
      Pixels[x,y]:= fillcolor;
      floodFill_(x+1,y, fillcolor, oldColor);
      floodFill_(x-1,y, fillcolor, oldColor);
      floodFill_(x,y+1, fillcolor, oldColor);
      floodFill_(x,y-1, fillcolor, oldColor);
   end;
end;

Delphi-Quellcode:

procedure tform1.quadratmalen(image,top_,left_,kantenlaenge,farbe:integer); 
   var
   x,
   y,
   kante      // Kantenlänge des Quadrats 
         :integer;

   begin
   kante:=spinedit2.value;      
   quadratmalen(image1,x-(kante/2),y-(kante/2),kante,clred);   // Quadratmalen mittels zeichnen der 4 Linien
   quadratmalen(image2,x-(kante/2),y-(kante/2),kante,clred);   // und dann Füllen mit Füllfunktion
   quadratmalen(image3,x-(kante/2),y-(kante/2),kante,clred);   // Ist dieser Zusammenhang richtig??
   quadratmalen(image4,x-(kante/2),y-(kante/2),kante,clred);
  
   case image of
      1:
         with form1.image1.canvas do
            begin
         end;
      2:
         with form1.image2.canvas do
            begin
            end;
      3:                                       // nur im Image3 werden die Quadrate gemalt!
         with form1.image3.canvas do  
            begin

         end;
      4:
         with form1.image4.canvas do
            begin
         end;
      end;
   end;

[Bummi]

kante:=spinedit2.value;
gehört nicht in die Prozedur, hier soll kantenlaenge verwendet werden, also im Aufruf spinedit2.value mitgeben.
Die Quadratemalfuntion ist nicht rekursiv (selbstaufrufend wie floodfill) zu implementieren.
Der Code der zu implementieren ist kommt nur in Case 3:
Quadrate kann man malen mit
MoveTo und 4 * LineTo
oder
Image3.Canvas.Brush.Style := bsClear;
Image3.Canvas.Rectangle(L,O,R,U);

nach dem Quadratemalen wird floodfill aufgerufen (kann auch innerhalb von quadratmalen aufgerufen werden)
fillcolor ist clRed, oldColor ist die Grundfarbe des Bildes also clBlack, diese Funktion ruft sich solange selbst wieder auf bis der gefundene Punkt nicht mehr oldColor entspricht, als wenn der Rahmen von Quadratemalen erreicht wurde.


Einen Teil in der Aufgabe hatten wir übersehen, weder im StringGrid noch in der Malroutine sollen Benachbarte Punkte nach Definition Kantenlänge erfasst werden. Dies bedeutet dass schon beim Scanvorgang Image3 miteinbezogen werden muss und nur wenn pixels[i,j] in Bild 3 schwarz ist dieser Punkt erfasst wird (gleiche Rangstufe wie der Schwellenwert), es muss dann wenn ein Punkt gefunden wurde auch direkt das Quadrat in Image3 gemalt und gefüllt werden, damit ein Beispielsweise direkt benachbarter Punkt bein nächsten Vergleich ausgeschlossen wird.

[Slashmob]

Ah super, danke schon mal für die Infos. Werde mich mal dransetzen und versuchen das umzusetzen. :thumb:

[Slashmob]

Zitat:

Zitat von Bummi (Beitrag 1140690)

kante:=spinedit2.value;
gehört nicht in die Prozedur, hier soll kantenlaenge verwendet werden, also im Aufruf spinedit2.value mitgeben.
Die Quadratemalfuntion ist nicht rekursiv (selbstaufrufend wie floodfill) zu implementieren.
Der Code der zu implementieren ist kommt nur in Case 3:
Quadrate kann man malen mit
MoveTo und 4 * LineTo
oder
Image3.Canvas.Brush.Style := bsClear;
Image3.Canvas.Rectangle(L,O,R,U);

nach dem Quadratemalen wird floodfill aufgerufen (kann auch innerhalb von quadratmalen aufgerufen werden)
fillcolor ist clRed, oldColor ist die Grundfarbe des Bildes also clBlack, diese Funktion ruft sich solange selbst wieder auf bis der gefundene Punkt nicht mehr oldColor entspricht, als wenn der Rahmen von Quadratemalen erreicht wurde.


Einen Teil in der Aufgabe hatten wir übersehen, weder im StringGrid noch in der Malroutine sollen Benachbarte Punkte nach Definition Kantenlänge erfasst werden. Dies bedeutet dass schon beim Scanvorgang Image3 miteinbezogen werden muss und nur wenn pixels[i,j] in Bild 3 schwarz ist dieser Punkt erfasst wird (gleiche Rangstufe wie der Schwellenwert), es muss dann wenn ein Punkt gefunden wurde auch direkt das Quadrat in Image3 gemalt und gefüllt werden, damit ein Beispielsweise direkt benachbarter Punkt bein nächsten Vergleich ausgeschlossen wird.

Was ich nicht verstehe... Wir haben doch die Quadratmal-Prozedur

Delphi-Quellcode:

procedure tform1.quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);

die uns mit Hilfe der Parameter das Quadrat malen soll. Wieso muss ich hier mit moveto/lineto bzw. rectangle arbeiten? Ich hatte mir das so vorgestellt, dass ich bei image3 das left_ und bottom_ bestimme, die kantenlänge aus dem spinedit2.value einlese und die farbe= rot setze und mir automatisch ein Quadrat gemalt wird. Ist das nicht so?
Also bin mit den beiden Prozeduren und deren Beziehung zu einander überfordert. Wie muss das als Code aussehen?

Ich stell nochmal den ganzen code rein:

Delphi-Quellcode:

unit Unit1; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, Grids, Spin;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Image2: TImage;
    Image3: TImage;
    Image4: TImage;
    Label1: TLabel;
    Label2: TLabel;
    SpinEdit1: TSpinEdit;
    SpinEdit2: TSpinEdit;
    StringGrid1: TStringGrid;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure floodFill_(x,y,fillColor,oldColor: integer);
    procedure quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);
    procedure AddFound(nr,x,y,wert:integer);
  private
    { private declarations }
  public
    { public declarations }
  end; 

var
  Form1: TForm1; 
  b,h:integer;
implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin

     b:=image1.width; h:=image1.height;     // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     image3.width:=b; image3.height:=h;
     image4.width:=b; image4.height:=h;

     image1.canvas.brush.color:=clblack;   // Hintergrundfarben
     image2.canvas.brush.color:=clblack;
     image3.canvas.brush.color:=clblack;
     image4.canvas.brush.color:=clwhite;

     image1.canvas.fillrect(rect(0,0,b,h));  // Rechteck mit obigen Farben ausfüllen
     image2.canvas.fillrect(rect(0,0,b,h));
     image3.canvas.fillrect(rect(0,0,b,h));
     image4.canvas.fillrect(rect(0,0,b,h));

     image1.Picture.loadfromfile('1sw.bmp');  // Bilder hochladen
     image2.Picture.loadfromfile('pic2.bmp');

      form1.caption:= 'Bildanalyse-Suche nach Vergleichsschwankungen';
end;

procedure tform1.floodFill_(x,y,fillColor,oldColor: integer);
   begin
   with image3.canvas do
   if (pixels[x,y]=oldColor) then
      begin
      Pixels[x,y]:= fillcolor;
      floodFill_(x+1,y, clred, oldColor);
      floodFill_(x-1,y, clred, oldColor);
      floodFill_(x,y+1, clred, oldColor);
      floodFill_(x,y-1, clred, oldColor);
   end;
end;

procedure tform1.quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);
   var
   x,   // Koordinaten
   y
        :integer;
  

   begin

   x:=stringgrid1.cells[1,nr];    // Koordinaten aus stringrid nehmen - klappt nicht!
   y:=stringgrid1.cells[2,nr]; 
 
    case image of
      1:
         with form1.image1.canvas do
            begin
         end;
      2:
         with form1.image2.canvas do
            begin
            end;
      3:
         with form1.image3.canvas do
            begin
            quadratmalen(3,round(x-(spinedit2.value/2)),round(y-(spinedit2.value/2)),spinedit1.value,clred); // Quadratmalen mittels zeichnen der 4 Linien - klappt nicht!

            pen.color:=clred;
            moveto(round(x-spinedit2.value/2),round (y-spinedit2.value/2));  // klappt nicht!
            lineto(round(x+spinedit2.value/2),round (y-spinedit2.value/2));
            lineto(round(x+spinedit2.value/2),round (y+spinedit2.value/2));
            lineto(round(x-spinedit2.value/2),round (y+spinedit2.value/2));
            lineto(round(x-spinedit2.value/2),round (y-spinedit2.value/2));
         end;
      4:
         with form1.image4.canvas do
            begin
         end;
      end;
   end;

procedure TForm1.Addfound (nr,x,y,wert:Integer);
Begin

     If stringgrid1.rowcount < (nr+1) then
        stringgrid1.rowcount:= nr+1;
        stringgrid1.cells[0,0]:='Nr.';
        stringgrid1.cells[1,0]:='X';
        stringgrid1.cells[2,0]:='Y';
        stringgrid1.cells[3,0]:='Diff-Wert';

        stringgrid1.cells[0,nr]:=inttostr(Nr);
        stringgrid1.cells[1,nr]:=inttostr(X);
        stringgrid1.cells[2,nr]:=inttostr(Y);
        stringgrid1.cells[3,nr]:=inttostr(Wert);
end;

procedure TForm1.Button1Click(Sender: TObject);
Var

    farbe1,         // Pixelfarbe im Image1
    farbe2,         // Pixelfarbe im Image2
    wert,           // Differenzwert
    schwellwert,    // Schwellwert zum Vergleich
    x,              // Laufindex
    y,              // Laufindex
    z,              // Zähler
    kante
            :integer;

begin
     schwellwert:=spinedit1.value;        // Voreinstellung 10
     kante:=spinedit2.value;

     z:=0;                // Zähler auf Null gesetzt
     For x:=0 to b-1 do        // Pixelweise Bilder auslesen
      Begin
           For y:=0 to h-1 do
               Begin
                    farbe1 := image1.canvas.pixels[x,y];           // Farbe merken
                    farbe2 := image2.canvas.pixels[x,y];
                    wert:= (farbe1 and clred)-(farbe2 and clred);   // Differenzwert
                    If wert > schwellwert then                  // mit Schwellwert vergleichen
                      begin
                       inc(z);                        // Zähler hochzählen
                       AddFound(z,x,y,wert);         // Daten in Stringgrid einfügen
                      end;
               end;

      end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  close;
end;

end.

[Bummi]

das gehört da nicht rein:

Delphi-Quellcode:

 x:=stringgrid1.cells[1,nr];
....

wenn es Sinn machen würde müsstest Du den String auch noch in einen Integer umwandeln (StrToInt)

Delphi-Quellcode:

      3:
         with form1.image3.canvas do
            begin
            // folgende Zeile hat hier nichts verloren .... 
            quadratmalen(3,round(x-(spinedit2.value/2)),round(y-(spinedit2.value/2)),spinedit1.value,clred); // Quadratmalen mittels zeichnen der 4 Linien - klappt nicht!
            //pen.color:=clred;
            pen.color:=farbe;

und statt spinedit2.value sollst Du nach Vorgabe _kantenlaenge verwenden


Die Prozedur gehört in die Ecke wo Du AddFound aufrufst, mit

Delphi-Quellcode:

quadratmalen(3,j,i,SpinEdit2.Value,clRed);

Ihr sollt ja den Sinn und die Funktion von Prozeduren verstehen lernen ....

[Slashmob]

Ja, aber wie ruf ich die Prozedur richtig auf?
Und wie sieht die richtige Zuweisung aus?
Bei diesem Teil hab ich Verständisprobleme.

Im moment weiß ich nur, dass ich mit de Prozedur "quadratmalen" ein Quaadrat, bestehend aus 4 Linien, zeichnen und diese innere Fläche mit der Prozedur "floodfill" ausfüllen soll.
Die Allgemeinform der Prozeduren steht ja in der Aufgabe, aber jetzt koknret für meinen Fall versteh ich das nicht so recht wie das als code aussehen soll.

:wall:

[Bummi]

Ich hatte Dir geschrieben wo und wie die Prozedur aufzurufen ist.
Ich hatte geschrieben was da nicht reingehört und was wie geändert werden muss.
Der MoveTo LineTo Part passt im Prinzip nur solltest Du top_ und left_ statt y und x verwenden, sowie wie beriets geschrieben kantenlaenge und farbe.

Vielleicht solltest Du mal da http://www.christian-stelzmann.de/artikel/crashkurs.htm vorbeischauen.
Wenn Du nicht verstehst wie was tickt solltest Du Dir ein kleineres Projekt selbst aufsetzen und mit den Canvasroutinen etwas herumspielen.

[bernhard_LA]

warum verwendet Ihr keine Algorithmen der Bildverabeitung ???

--> http://en.wikipedia.org/wiki/Feature...uter_vision%29

wenn es sich um Kreise handelt wäre Hough Tranmsformation der Bilder eine mögliche Lösung

-->> http://sourceforge.net/projects/houghtransforma/

(allerdings ist der Hough Accu hier nicht gut implementiert ... das Projekt wartet auf Freiwillige :-)

[Bummi]

@bernhard_LA

es handelt sich um eine Schulaufgabe mit fest vorgegebenem Rahmen

[Slashmob]

Hab den code jetzt korrigiert. Dennoch frag ich mich warum folgendes Problem auftritt.
Ich lass die Quadrate mit der Kantenlänge 3 zeichnen. Ok alles wunderbar,klappt!
Dann verändere ich z.B. auf die Kantenlänge 7. Das Quadrat mit Kantenlänge 3 bleibt bestehen und er zeichnet mir um dieses Quadrat nur einen Umriss des Quadrats mit Kantenlänge 7. Das heißt er füllt die Fläche nicht richtig aus.
Wenn man schrittweise die Kantenlänge um eins erhöht und jedesmal zeichnen lässt, dann sieht das so aus als würde die Fläche ganz ausgefüllt werden. Ist aber nicht Sinn der Sache.

Desweiteren hab ich noch die Frage wie ich das hier umsetzen soll.

Zitat:

Zitat von Bummi (Beitrag 1140690)

Einen Teil in der Aufgabe hatten wir übersehen, weder im StringGrid noch in der Malroutine sollen Benachbarte Punkte nach Definition Kantenlänge erfasst werden. Dies bedeutet dass schon beim Scanvorgang Image3 miteinbezogen werden muss und nur wenn pixels[i,j] in Bild 3 schwarz ist dieser Punkt erfasst wird (gleiche Rangstufe wie der Schwellenwert), es muss dann wenn ein Punkt gefunden wurde auch direkt das Quadrat in Image3 gemalt und gefüllt werden, damit ein Beispielsweise direkt benachbarter Punkt bein nächsten Vergleich ausgeschlossen wird.

Würde mich über Tipps freuen.

Hier der Code:

Delphi-Quellcode:

unit Unit1; 

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, Grids, Spin;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Image2: TImage;
    Image3: TImage;
    Image4: TImage;
    Label1: TLabel;
    Label2: TLabel;
    SpinEdit1: TSpinEdit;
    SpinEdit2: TSpinEdit;
    StringGrid1: TStringGrid;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure floodFill_(x,y,fillColor,oldColor: integer);
    procedure quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);
    procedure AddFound(nr,x,y,wert:integer);
  private
    { private declarations }
  public
    { public declarations }
  end; 

var
  Form1: TForm1; 
  b,h:integer;
implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin

     b:=image1.width; h:=image1.height;     // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     image3.width:=b; image3.height:=h;
     image4.width:=b; image4.height:=h;

     image1.canvas.brush.color:=clblack;   // Hintergrundfarben
     image2.canvas.brush.color:=clblack;
     image3.canvas.brush.color:=clblack;
     image4.canvas.brush.color:=clwhite;

     image1.canvas.fillrect(rect(0,0,b,h));  // Rechteck mit obigen Farben ausfüllen
     image2.canvas.fillrect(rect(0,0,b,h));
     image3.canvas.fillrect(rect(0,0,b,h));
     image4.canvas.fillrect(rect(0,0,b,h));

     image1.Picture.loadfromfile('1sw.bmp');  // Bilder hochladen
     image2.Picture.loadfromfile('pic2.bmp');

      form1.caption:= 'Bildanalyse-Suche nach Vergleichsschwankungen';
end;

procedure tform1.floodFill_(x,y,fillColor,oldColor: integer);
   begin
   with image3.canvas do
   if (pixels[x,y]=clblack) then
      begin
      Pixels[x,y]:= fillcolor;
      floodFill_(x+1,   y,   clred, clblack);
      floodFill_(x-1,   y,   clred, clblack);
      floodFill_(x,   y+1,   clred, clblack);
      floodFill_(x,   y-1,   clred, clblack);
   end;
end;

procedure tform1.quadratmalen(image,top_,left_,kantenlaenge,farbe:integer);

   begin

    case image of
      1:
         with form1.image1.canvas do            // Wird nicht benutzt
            begin
         end;
      2:
         with form1.image2.canvas do           // Wird nicht benutzt
            begin
            end;
      3:
         with form1.image3.canvas do
            begin
            pen.color:=clred;
            moveto(round(left_-kantenlaenge),round (top_-kantenlaenge));   // Startpunkt
            lineto(round(left_+kantenlaenge),round (top_-kantenlaenge));   // 4 Linien für das Quadrat zeichnen
            lineto(round(left_+kantenlaenge),round (top_+kantenlaenge));
            lineto(round(left_-kantenlaenge),round (top_+kantenlaenge));
            lineto(round(left_-kantenlaenge),round (top_-kantenlaenge));
         end;
      4:
         with form1.image4.canvas do           // Wird nicht benutzt
            begin
         end;
      end;
   end;

procedure TForm1.Addfound (nr,x,y,wert:Integer);
Begin

     If stringgrid1.rowcount < (nr+1) then
        begin                              // Zeile um eins erhöhen, wenn
           stringgrid1.rowcount:= nr+1;
        end;
        stringgrid1.cells[0,0]:='Nr.';           // Benennung der Spalten
        stringgrid1.cells[1,0]:='X';
        stringgrid1.cells[2,0]:='Y';
        stringgrid1.cells[3,0]:='Diff-Wert';

        stringgrid1.cells[0,nr]:=inttostr(Nr);    // Daten in entsprechende Spalten/Zeilen einfügen
        stringgrid1.cells[1,nr]:=inttostr(X);
        stringgrid1.cells[2,nr]:=inttostr(Y);
        stringgrid1.cells[3,nr]:=inttostr(Wert);
end;

procedure TForm1.Button1Click(Sender: TObject);
Var

    farbe1,         // Pixelfarbe im Image1
    farbe2,         // Pixelfarbe im Image2
    wert,           // Differenzwert
    schwellwert,    // Schwellwert zum Vergleich
    x,              // Laufindex in X-Richtung
    y,              // Laufindex in Y-Richtung
    z               // Zähler
        :integer;

begin
     schwellwert:=spinedit1.value;        // Schwellwert
     z:=0;                // Zähler auf Null gesetzt

     For x:=0 to b-1 do        // Pixelweise Bilder auslesen
      Begin
           For y:=0 to h-1 do
               Begin
                    farbe1 := image1.canvas.pixels[x,y];           // Farbe merken und zuweisen
                    farbe2 := image2.canvas.pixels[x,y];
                    wert:= (farbe1 and clred)-(farbe2 and clred);   // Differenzwert bilden (Rotmaske)
                    If wert > schwellwert then                  // Differenzwert mit Schwellwert vergleichen
                      begin
                       inc(z);                        // Zähler hochzählen
                       AddFound(z,x,y,wert);        // Daten in Stringgrid einfügen
                       quadratmalen(3,y,x,spinedit2.value,clred); // Quadrat malen
                       floodfill_(x,y,clred,clblack);             // Quadrat ausfüllen

                       image4.canvas.pixels[x,y]:=clred;
                       image4.canvas.pixels[x,y];    // Im Image4 die Punkte markieren
                      end;
               end;

      end;


end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  close;                                      // Schließen Knopf
end;

end.

[Bummi]

Wenn Du den Button mehrmals drücken willst musst Du Image 3 vorher wieder initialisieren wie das siehst Du im FormCreate.

Delphi-Quellcode:

 If (wert > schwellwert) and (Image3.Canvas.pixels[x,y] <> clRed) then

[Slashmob]

Zitat:

Zitat von Bummi (Beitrag 1140865)

Wenn Du den Button mehrmals drücken willst musst Du Image 3 vorher wieder initialisieren wie das siehst Du im FormCreate.

Delphi-Quellcode:

 If (wert > schwellwert) and (Image3.Canvas.pixels[x,y] <> clRed) then

Was genau soll ich im FormCreat sehen? Oder hab ich dich missverstanden?

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin

     b:=image1.width; h:=image1.height;     // Breite und Höhe der Imagefelder
     image2.width:=b; image2.height:=h;
     image3.width:=b; image3.height:=h;
     image4.width:=b; image4.height:=h;

     image1.canvas.brush.color:=clblack;   // Hintergrundfarben
     image2.canvas.brush.color:=clblack;
     image3.canvas.brush.color:=clblack;
     image4.canvas.brush.color:=clwhite;

     image1.canvas.fillrect(rect(0,0,b,h));  // Rechteck mit obigen Farben ausfüllen
     image2.canvas.fillrect(rect(0,0,b,h));
     image3.canvas.fillrect(rect(0,0,b,h));
     image4.canvas.fillrect(rect(0,0,b,h));

     image1.Picture.loadfromfile('1sw.bmp');  // Bilder hochladen
     image2.Picture.loadfromfile('pic2.bmp');

      form1.caption:= 'Bildanalyse-Suche nach Vergleichsschwankungen';
end;

Die If-Anweisung hab ich jetzt hier eingefügt, aber die roten Quadrate überlappen sich trotzdem noch:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
Var

    farbe1,         // Pixelfarbe im Image1
    farbe2,         // Pixelfarbe im Image2
    wert,           // Differenzwert
    schwellwert,    // Schwellwert zum Vergleich
    x,              // Laufindex in X-Richtung
    y,              // Laufindex in Y-Richtung
    z               // Zähler
        :integer;

begin
     schwellwert:=spinedit1.value;        // Schwellwert
     z:=0;                // Zähler auf Null gesetzt

     For x:=0 to b-1 do        // Pixelweise Bilder auslesen
      Begin
           For y:=0 to h-1 do
               Begin
                    farbe1 := image1.canvas.pixels[x,y];           // Farbe merken und zuweisen
                    farbe2 := image2.canvas.pixels[x,y];
                    wert:= (farbe1 and clred)-(farbe2 and clred);   // Differenzwert bilden (Rotmaske)

                    If (wert > schwellwert) and (Image3.Canvas.pixels[x,y] <> clRed) then                  // Differenzwert mit Schwellwert vergleichen
                      begin
                       inc(z);                        // Zähler hochzählen
                       AddFound(z,x,y,wert);        // Daten in Stringgrid einfügen
                       quadratmalen(3,y,x,spinedit2.value,clred); // Quadrat malen
                       floodfill_(x,y,clred,clblack);             // Quadrat ausfüllen

                       image4.canvas.pixels[x,y]:=clred;
                       image4.canvas.pixels[x,y];    // Im Image4 die Punkte markieren
                      end;
               end;

      end;


end;

Was hab ich falsch gemacht?

[Bummi]

überlappen sich bei mehrmaligem drücken und geändertem Spinedit?

Delphi-Quellcode:

image3.canvas.brush.color:=clblack;
image3.canvas.fillrect(rect(0,0,b,h));

wenn Du mehrmals malen willst musst Du das Bild vorher wieder schwarz füllen ...

[Slashmob]

Ja überlappen sich bei mehrmaligen Drücken des Buttons und Änderung des Schwellwerts(spinedit1.value).

[Bummi]

Wenn Du nirgendwo die roten Dreiecke entfernst .....
initialisier doch mal Bild 3 beim Drücken von Button1 ....

[Slashmob]

Mit initialisieren meinst du diesen Teil hier

Zitat:

Zitat von Bummi (Beitrag 1140883)

Delphi-Quellcode:

image3.canvas.brush.color:=clblack;
image3.canvas.fillrect(rect(0,0,b,h));

vor die FOR-Schleifen zu setzen oder? Wenn nicht dann versteh ich nicht was genau du mit initialisieren meinst :oops:

[Bummi]

genau
genau
und Du hast es schon verstanden ...
und wenn es bei b und h Probleme gibt einfach kurz nachdenken ...

[Slashmob]

Mhm, überlappen sich trotzdem.
Bei b und h gibts keine Probleme (denk ich), da global deklariert, weiß nicht ob du darauf hinaus wolltest.

[Bummi]

Das Überlappen durch mehrmaliges Drücken sollte nicht mehr auftreten, Du musst allenfalls noch das Problem in den Griff bekommen wenn Du bei angenommener Schrittweite von 8 z.B. einen Punkt bei 10/10 und einen bei 15/15 hast
Du malst dann 6/6 > 14/14 und wieder bei 11/11 > 19/19 ob die Überlappung bei 11/11 > 14/14 unerwünscht ist kann ich nicht sagen, so wie ich die Definition der Aufgabe verstehe sollen nur Punkte innerhalb eines gefundenen Rechtecks ignoriert werden.

[Slashmob]

Wie es im moment aussieht mit der Überlappung ist im Bild zu sehen (im Anhang).
Normalerweise dürfte er ja wegen der IF-Anweisung in keinem roten Bereich ein neues Quadrat zeichnen. Tut er aber..

Achja noch was und wie schafft man es genauso viele Punkte im Image4( Weißes Bild) wie Quadrate im Image3 zu zeichnen? Kann ich das am schnellsten mit einer IF-Anweisung machen? Was muss ich hier dann vergleichen?

Dachte vielleicht an sowas wie If "soundsoviele Quadrate im Image3" Then image4.canvas.pixels[x,y];