Bildbearbeitung - Astronomie-Aufgabe

[hamptoncourt]

OK, soweit so gut ... vielen Dank schonmal dafür ...

aber wäre ja zu schön, wenn es jetzt funktionieren würde :roll:

Jetzt zeichnet er statt einen Kreis um das gesuchte Objekt in die obere linke Ecke ein seltsames Gebilde *lol*

Liegt das evtl an meiner Methode zum Finden der Punkte???

[Bummi]

Du hast xm und ym bei x und y vergessen....und das MoveTo sollte auf den ersten Punkt Deines Kreises stattfinden.

[hamptoncourt]

hmm ... nun tut sich gar nix mehr ...

Delphi-Quellcode:

type

  { TForm1 }
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Image2: TImage;
    Image3: TImage;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure roter_Kreis(xm, ym, r, anzahl : integer);

  private
    { private declarations }
  public
    { public declarations }


  end;

var
  Form1: TForm1;
  P1, P2, P3, P4: Integer;

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
   i, j, l, k, xm, ym : Integer;
begin
  for j:=0 to image3.Height-1 do begin
   for i:=1 to image3.width-1 do begin
    if(image3.Canvas.pixels[i,j]-image3.Canvas.pixels[i-1,j]>10) then break;
    P1:=i;
   end;
  end;

  for k:=image3.width-1 to 0 do begin
   for l:=image3.Height-2 to 0 do begin
    if(image3.Canvas.pixels[k,l]-image3.Canvas.pixels[k,l+1]>10) then break;
    P2 := l;
   end;
  end;

  for l:=image3.Height-1 to 0 do begin
   for k:=image3.width-2 to 0 do begin
    if(image3.Canvas.pixels[k,l]-image3.Canvas.pixels[k+1,l]>10) then break;
    P3 := k;
   end;
  end;


  for i:=0 to image3.width-1 do begin
   for j:=1 to image3.Height-1 do begin
   if(image3.Canvas.pixels[i,j]-image3.Canvas.pixels[i,j-1]>10) then break;
   P4 := j;
   end;
  end;

   xm := round((P3-P1)/2);
   ym := round((P4-P2)/2);


 Form1.roter_Kreis(xm, ym, 15, 40);

end;

procedure TForm1.roter_Kreis(xm, ym, r, anzahl : integer);
var
   gesamtwinkel , winkelschritt : real;
   i, x, y : Integer;

begin
   winkelschritt := 4*PI/80;
   gesamtwinkel := 0;


   Image1.Canvas.Pen.Color := clRed;
   Image1.Canvas.MoveTo((xm+15),ym);

   For i := 1 To anzahl do begin
     gesamtwinkel := gesamtwinkel+winkelschritt;
     x := (xm + round(cos(gesamtwinkel) * r));
     y := (ym + round(sin(gesamtwinkel) * r));
     Image1.Canvas.LineTo(x,y);
   end;

end;

[Bummi]

1.) Ein Break bei zwei FOR Schleifen verlässt nur die innere Schleife
2.) Du musst nach Punkten suchen nicht nach Integern
3.) Rückwärtsschleifen funktionieren nur mit DOWNTO
For i := 100 to 0 wird nie durchlaufen
4.) Image3 soll ja ein Differenzbild enthalten hier interessiert nur ob ein Punkt einen Wert >= 10 hat, der Nachbarpunkt interssiert nicht


Deine Suchroutine sollte eher so aussehen

Delphi-Quellcode:

var
  x,y:Integer;
  P1,P2:TPoint;
begin
  P1.X := -1;
  for y:=0 to image3.Height-1 do
    begin
    for x:=1 to image3.width-1 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255)  > 10) then
        begin
         P1.X := x;
         p1.Y := y;
         break;
        end;
      end;
    if P1.X > 0 then Break;
    end;

  P2.X := -1;
  for y := image3.Height-1 Downto 0 do
    begin
    for x:= image3.width-1 Downto 0 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255)  > 10) then
        begin
         P2.X := x;
         P2.Y := y;
         break;
        end;
      end;
    if P2.X > 0 then Break;
    end;
....
....
// und noch zwei Punkte ....

[hamptoncourt]

Das verstehe ich nicht ganz ...

Wird dann für P3 und P4 einfach dann das gleiche für Y gemacht? Also so:

Delphi-Quellcode:

begin
  P1.X := -1;
  for y:=0 to image3.Height-1 do
    begin
    for x:=1 to image3.width-1 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255) > 10) then
        begin
         P1.X := x;
         p1.Y := y;
         break;
        end;
      end;
    if P1.X > 0 then Break;
    end;

  P2.X := -1;
  for y := image3.Height-1 Downto 0 do
    begin
    for x:= image3.width-1 Downto 0 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255) > 10) then
        begin
         P2.X := x;
         P2.Y := y;
         break;
        end;
      end;
    if P2.X > 0 then Break;
    end;

  P3.Y := -1;
  for y:=0 to image3.Height-1 do
    begin
    for x:=1 to image3.width-1 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255) > 10) then
        begin
         P3.X := x;
         p3.Y := y;
         break;
        end;
      end;
    if P3.Y > 0 then Break;
    end;

  P4.Y := -1;
  for y := image3.Height-1 Downto 0 do
    begin
    for x:= image3.width-1 Downto 0 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255) > 10) then
        begin
         P4.X := x;
         P4.Y := y;
         break;
        end;
      end;
    if P4.Y > 0 then Break;
    end;


  xm := round(P1.X+((P2.X-P1.X)/2));
  ym := round(P3.Y+((P4.Y-P3.Y)/2));


 Form1.roter_Kreis(xm, ym, 15, 40);

end;

Er zeichnet zwar einen roten Kreis, setzt diesen jedoch genau in die Mitte des Imagefeldes.

[Bummi]

Du machst für P3 das gleiche wie für P1.
Du machst auch nichts für Y sondern Du läufts aus allen 4 Ecken in die Diagonale Ecke und vergleichst alle PUNKTE die Du findest mit dem Schwellenwert, wenn Du einen Punkt(x,y) findest verlässt Du per Break/Break die Doppelschleife.
Am Schluss hast Du 4 Punkte(x,y) deren Mittelpunkt berechnet werden muss. Wenn einer der Punkte in X1 einen negativen Wert hat(dann haben alle einen), gab es keine Änderung.
Ich würde Dir für eine korrekte und schnelle Berechnung nochmals das eingangs erwähnte Image.Picture.Bitmap.Scanline ans Herz legen.
Im Zweifelsfalle per Image.Picture.Bitmap.Pixelformat:=pf24Bit passend umstellen und die Differenz per

Delphi-Quellcode:

Function ByteDifference(b1,b2:Byte):Byte;
var
  i:Integer;
begin
  i := Abs(b1 - b2);
  Result := i;
end;

einen Fetzen Beispielcode, der für Dich zwar nicht passt aber das Prinzip der Scanlinezugriffe zeigt.

Delphi-Quellcode:

Procedure InvertBitMap24(bmp:TBitMap);
CONST
  PixelCountMax = MaxInt / 3;
TYPE
  pRGBTripleArray = ^TRGBTripleArray;
  TRGBTripleArray = ARRAY[0..$effffff] OF TRGBTriple;
var
  pscanLine : pRGBTripleArray;
  x,y:Integer;
begin
    for Y := 0 to bmp.Height -1 do
     begin
         pscanLine := bmp.Scanline[y];
         for x := 0 to bmp.Width -1 do
           begin
           pscanLine[x].rgbtBlue   := pscanLine[x].rgbtBlue XOR 255;
           pscanLine[x].rgbtGreen   := pscanLine[x].rgbtGreen XOR 255;
           pscanLine[x].rgbtRed   := pscanLine[x].rgbtRed XOR 255;
           end;
     end;
end;

[hamptoncourt]

Ach ... Diagonal ... :wall:

Jaja, so schaut es doch schon besser aus ...

Aber dann muss doch P3 anders sein, oder???

P1 läuft von oben link. P3 Muss doch dann von unten links laufen, also:

Delphi-Quellcode:

P3.X := -1;
  for y:=0 to image3.Height-1 do
    begin
    for x:= image3.width-1 Downto 0 do
      begin
      if (((image3.Canvas.pixels[x,y]) and 255) > 10) then
        begin
         P3.X := x;
         p3.Y := y;
         break;
        end;
      end;
    if P3.X > 0 then Break;
    end;

[hamptoncourt]

Nun funktioniert es tadellos ... ich danke euch allen für eure Hilfe und die vielen Tipps ...

Da ich persönlich die Berechnung des Mittelpunktes mit der 4-Punkte-Variante von Bummi etwas kompliziert finde, habe ich es dann auch nochmal mit dem von mir zuerst erdachten Lösungsweg versucht und nun klappt es dort auch ... Muss wohl an einer oder zwei Stellen mal mich vertippt haben :oops:

Für diejenigen, die Interesse daran haben (vielleicht wegen einer änlichen Problemstellung) stelle ich das hier mal rein:

Delphi-Quellcode:

type

  { TForm1 }
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Image1: TImage;
    Image2: TImage;
    Image3: TImage;
    Label1: TLabel;
    Label2: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure roter_Kreis(xm, ym, r, anzahl : integer);

  private
    { private declarations }
  public
    { public declarations }


  end;

var
  Form1: TForm1;


implementation

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
  Image1.Picture.Loadfromfile('N:\studium_pool\MBI\praktikum 5\1sw.bmp');         // Laden der ersten Aufnahme
  Image2.Picture.Loadfromfile('N:\studium_pool\MBI\praktikum 5\2sw.bmp');         // Laden der zweiten Aufnahme

  Image1.AutoSize := True;                                                        // Größe der ersten Aufnahme automatisch festlegen
  Image2.AutoSize := True;                                                        // Größe der zweiten Aufnahme automatisch festlegen

  Button1.Caption := 'Differenzbild erzeugen';                                    // Beschriftung der Buttons, Labels und des Forms
  Button2.Caption := 'Markieren der Änderung';
  Label1.Caption := '1. Aufnahme';
  Label2.Caption := '2. Aufnahme (zu einem späteren Zeitpunkt)';
  Form1.Caption := 'Zeitversetzte Aufnahmen vergleichen und Änderungen erkennen';
end;

// Differenzbild erzeugen
procedure TForm1.Button1Click(Sender: TObject);
var
   i,j :integer;                                                                                                   // Variablen initialisieren
begin
   Image3.Width:=Image1.Width;                                                                                     // Breite für Differenzbild entspricht Aufnahme 1
   Image3.Height := Image1.Height;                                                                                 // Höhe für Differenzbild entspricht Aufnahme 1

   for i:=0 to image1.width-1 do
    begin
      for j:=0 to image1.Height-1 do
       begin
          image3.Canvas.pixels[i,j]:=$00FFFFFF and (not (image1.Canvas.pixels[i,j]-image2.Canvas.pixels[i,j]));    // Erzeugen des Differenzbildes in Image3 (subtrahieren der Grauwerte)
       end;
    end;

end;

procedure TForm1.Button2Click(Sender: TObject);
var
   i, j, l, k, xm, ym, x1, x2, y1, y2 : Integer;                                                                   // Variablen initialisieren
begin
   x1:=-1;                                                                                                         // 1. FOR-Konstruktion tastet Differenzbild von oben nach unten und von links nach rechts ab, um Punkt x1 zu suchen
   for j:=0 to image3.Height-1 do
    begin
       for i:=1 to image3.width-1 do
        begin
           if(image3.Canvas.pixels[i,j]-image3.Canvas.pixels[i-1,j]>=10) then                                      // Abgleich der Grauwerte
            begin
               x1 := i;                                                                                            // Bestimmung x1
               break;
            end;
           if x1 >0 Then Break;                                                                                    // Sobald der Wert größer 0 ist, wird die FOR-Konstruktion verlassen
        end;
   end;


   x2:=-1;                                                                                                         // 2. FOR-Konstruktion tastet Differenzbild von unten nach oben und von rechts nach links ab, um Punkt x2 zu suchen
   for l:=image3.height-1 downto 0 do
    begin
       for k:=image3.width-2 downto 0 do
        begin
           if(image3.Canvas.pixels[k,l]-image3.Canvas.pixels[k+1,l]>=10) then                                      // Abgleich der Grauwerte
            begin
               x2 := k;                                                                                            // Bestimmung x2
               break;
            end;
           if x2 > 0 Then Break;                                                                                   // Sobald der Wert größer 0 ist, wird die FOR-Konstruktion verlassen
        end;
   end;

   y1:=-1;                                                                                                         // 3. FOR-Konstruktion tastet Differenzbild von links nach rechts und von oben nach unten ab, um Punkt y1 zu suchen
   for k:=0 to image3.width-1 do
    begin
       for l:=1 to image3.Height-2 do
        begin
           if(image3.Canvas.pixels[k,l]-image3.Canvas.pixels[k,l+1]>=10) then                                      // Abgleich der Grauwerte
            begin
               y1 := l;                                                                                            // Bestimmung y1
               break;
            end;
           if y1 > 0 Then Break;                                                                                   // Sobald der Wert größer 0 ist, wird die FOR-Konstruktion verlassen
        end;
    end;

   y2:=-1;                                                                                                         // 4. FOR-Konstruktion tastet Differenzbild von rechts nach links und von unten nach oben ab, um Punkt x1 zu suchen
   for i:=image3.Width-1 downto 0 do
    begin
       for j:=image3.Height-1 downto 1 do
        begin
           if(image3.Canvas.pixels[i,j]-image3.Canvas.pixels[i,j-1]>=10) then                                      // Abgleich der Grauwerte
            begin
               y2 := j;                                                                                            // Bestimmung y2
               break;
            end;
           if y2 > 0 Then Break;                                                                                   // Sobald der Wert größer 0 ist, wird die FOR-Konstruktion verlassen
        end;
    end;

   xm := round(x1+((x2-x1)/2));                                                                                    // Berechnung des X-Wertes für den Kreis-Mittelpunkt
   ym := round(y1+((y2-y1)/2));                                                                                    // Berechnung des Y-Wertes für den Kreis-Mittelpunk

   Form1.roter_Kreis(xm, ym, 15, 40);                                                                              // Aufrufen der Sub-Methode zum zeichnen der Kreise auf Image 1 und Image 2

end;


// Zeichnen der Kreis mit Radius 15 aus 40 Geradenlinien im Punkt P(mx,my)
procedure TForm1.roter_Kreis(xm, ym, r, anzahl : integer);
var
   gesamtwinkel , winkelschritt : real;                                                                            // Variablen initialisieren
   i, x, y : Integer;

begin
   winkelschritt := ((2*PI)/anzahl);                                                                               // Berechnung des Winkelschrittes
   gesamtwinkel := 0;                                                                                              // Gesamtwinkel zum Start auf 0 setzen

   // Kreis in der ersten Aufnahme zeichnen

   Image1.Canvas.Pen.Color := clRed;                                                                               // Farbe: Rot
   Image1.Canvas.MoveTo(xm+r,ym);                                                                                  // Startpunkt zum zeichnen festlegen

   For i := 1 To anzahl do
    begin                                                                                                          // Wiederholen, bis alle 40 Linien gezeichnet sind
      gesamtwinkel := gesamtwinkel+winkelschritt;                                                                  // Winkel weiter zählen
      x := xm +( round(cos(gesamtwinkel) * r));                                                                    // Berechnung des x-Wertes
      y := ym + ( round(sin(gesamtwinkel) * r));                                                                   // Berechnung des y-Wertes
      Image1.Canvas.LineTo(x,y);                                                                                   // Zeichnen der Linie
    end;

   // Kreis in der zweiten Aufnahme zeichnen

   Image2.Canvas.Pen.Color := clRed;                                                                               // Farbe: Rot
   Image2.Canvas.MoveTo(xm+r,ym);                                                                                  // Startpunkt zum zeichnen festlegen

   For i := 1 To anzahl do
    begin                                                                                                          // Wiederholen, bis alle 40 Linien gezeichnet sind
      gesamtwinkel := gesamtwinkel+winkelschritt;                                                                  // Winkel weiter zählen
      x := xm +( round(cos(gesamtwinkel) * r));                                                                    // Berechnung des x-Wertes
      y := ym + ( round(sin(gesamtwinkel) * r));                                                                   // Berechnung des y-Wertes
     Image2.Canvas.LineTo(x,y);                                                                                    // Zeichnen der Linie
    end;

end;

Danke euch allen nochmal ...

[Bummi]

Lass mich wissen wie es bewertet wurde, ich bin immer noch der Meinung daß Du mindestens 2 Logikfehler in Deiner Lösung hast, erstens hast Du nicht 4 Punkte

Zitat:

ergibt sich aus den 4 Koordinaten

und zweitens meine ich daß mit Differenz>=10 der tatsächliche Wert eines Differenzpunktes gemeint ist, nicht seine Differenz zu einem Nachbarpunkt, zumal die Differenzwertberechnung fehlerhaft implementiert ist z.B. 254 - 255.

[hamptoncourt]

Hey ... Habe die Aufgabe gestern abgegeben und meine Lösung wurde für gut befunden :-D Noten gibt es für die Testate bei und ja leider nicht *seufz*

Das ist richtig, ich habe keine vier Punkt a la P(x,y) ... Was ich aber habe, sind vier Koordinaten: x1, x2, y1 und y2. Diese reichen dann aus, um den Mittelpunkt zu berechnen.
Das tut das Programm auch ohne Probleme. Der Kreis sitzt an der richtigen Stelle. Und auch dem Test des Profs hat es stand gehalten :-D

An zwei Stellen musste ich aber doch noch etwas ändern. So, wie ich das Differenzbild erzeugt habe, wird es in schwarz-weiß ausgegeben. Der Hintergrund weiß, der Punkt schwarz. Es sollte jedoch so aussehen, dass der Hintergrund schwarz ist, und der Punkt "rot" ...

Zweite Sache ist, dass Delphi scheinbar dümmer ist als Lazarus. Denn als ich das Programm in Delphi schrieb und es ausführte, wurden die Kreise in den beiden Aufnahmen nicht in rot, sondern in grau gezeichnet. Das liegt daran, dass Delphi offenbar erkennt, dass es sich bei den Aufnahmen um scharz-weiß Images handelt. Er zeichnet dann also in Graustufen, nicht in Farbe. Um das zu lösen, müssen zwei weitere Imagefelder platziert werden (Image 4 und Image 5). Beim zeichnen, müssen zuerst die Bilder Pixel für Pixel in die zwei neuen Imagefelder kopiert werden. Erst dann können darauf die Kreise gezeichnet werden und erscheinen dann auch in rot.

Gruß
HC