Programm zur Bestimmung von PI - Schleife auf Knopfdruck abbrechen, aber wie?

[mabstudent]

Vielen vielen Dank, hätte ich mich mal eher an euch gewandt, an meiner "WirrWarr Schleife" saß ich nämlich mehrere Stunden

Danke auch für den Tipp von sx2008


Deshalb stelle ich jetzt gleich mein nächstes Problem bei dem Programm vor, auch wenn ich beim Rumprobieren viel gelernt hab:

Um PI zu berechnen muss ich ja die Pixel im Viertelkreis zählen und die Pixel im Quadrat, also die Gesamtzahl der Pixel.
Wie kann ich das machen?
Kann ich in meiner Schleife welche den Pixelregen erzeugt folgendes machen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);

begin
  abbr:=false;
  VKhits:=0;   //Anzahl der Pixel im Viertelkreis, zu Anfang :=0
  NVKhits:=0;  //Anzahl der Pixel Nicht im Viertelkreis, zu Anfang:=0
  WHILE NOT abbr DO
  begin
  Application.ProcessMessages;
  x:=random(300);
  y:=random(300);
  IF (sqrt((x*x)+(y*y))<=300)
  THEN image1.canvas.pixels[x,y]:=clblue AND inc(VKhits)  //Pixel blau färben UND Anzahl aufsummieren
  ELSE image1.Canvas.Pixels[x,y]:=clred AND inc(NVKhits); //Pixel rot färben UND Anzahl aufsummieren
  end;

label1.Caption:=(4*VKhits/(NVKhits+VKhits));   //ausgabe PI




end;

Klar, das habe ich schon probiert und es funktioniert nicht, aber hier könnt ihr denk ich am besten sehen was ich vorhabe: Um PI zu berechnen muss ich irgendwie an die Anzahl der Pixel im Viertelkreis und an die außerhalb kommen. über die suche habe ich rausgefunden das inc() eine funktion zum zählen ist.

[jfheins]

Mehrere Anweisungen kannst du immer mit begin ... end; zusammenfassen.
Also:

Delphi-Quellcode:

if xyz then
begin
  //Anweisungen
  //noch mehr Anweisungen
end;

[mabstudent]

...dann bekomme ich den fehler:

'END' erwartet aber 'ELSE' gefunden

Delphi-Quellcode:

begin
  abbr:=false;
  VKhits:=0;
  NVKhits:=0;
  WHILE NOT abbr DO
  begin
  Application.ProcessMessages;
  x:=random(301);
  y:=random(301);
  IF (sqrt((x*x)+(y*y))<=300)
  THEN image1.canvas.pixels[x,y]:=clblue;  //Anweisung 1a
       VKhits:=VKhits+1                    //weitere Anweisung
  ELSE image1.Canvas.Pixels[x,y]:=clred;   //Anweisung 1b
       NVKhits:=NVKhits+1;                 //weitere Anweisung 

  end;
end;

[Bummi]

Delphi-Quellcode:

  THEN 
BEGIN
       image1.canvas.pixels[x,y]:=clblue; //Anweisung 1a
       VKhits:=VKhits+1 //weitere Anweisung
END
  ELSE 
BEGIN
       image1.Canvas.Pixels[x,y]:=clred; //Anweisung 1b
       NVKhits:=NVKhits+1; //weitere Anweisung
END

[Sir Rufo]

Hier haben wir doch ein perfektes Beispiel dafür, warum man Code und Ausgabe trennen sollte.

Die ermittelten Zufallspunkte werden in einem Bitmap gepseichert und nun drängt sich die Frage auf, wie man die Anzahl der Zufallspixel bekommt und die Anzahl der Pixel im Kreissegment.
Das Bitmap beinhaltet ja auch noch die Kreislinie.

Antwort: Geht gar nicht. Durch die Zufallsmethode können auf einem Pixelpunkt des Bitmaps n Zufallspunkte liegen. Wie soll das im Nachhinein gezählt werden? Pixel ist blauer als der andere Blaue?

Also trennen wir das Ganze mal, denn die Berechnung muss auch ohne grafische Ausgabe erfolgen und selbige dient ja nur der Visualisierung.

Zunächst brauchen wir ja einen Speicher für einen Zufallspunkt. Da bietet und Delphi ja passend TPoint an. Da können wir einen x und y Wert abspeichern (was wollen wir mehr).
Wir haben mehrere Punkte, gut wir brauchen eine Liste. Das ist jetzt Geschmackssache, ob man das mit einer verketteten Liste (Pointer) selber baut, ein variables Array benutzt oder das fertige TList oder auch TObjectList .

Jede Liste hat eine Eigenschaft Count und schon weiß man, wieviele Punkte man insgesamt erzeugt hat.

Jetzt fehlt und ein Algorithmus, der berechnen kann, ob ein Punkt innerhalb oder ausserhalb des Kreissegments liegt.

Die Ausgabe erfolgt jetzt anhand genau dieser Liste. Also jeden Pixel wie gewohnt auf das Bitmap klatschen.
Über den Algorithmus, weiß man, ob der Punkt blau oder rot gepinselt werden soll.

BTW das Ergebnis wird umso genauer, je größer man das Zielgebiet macht.
Ein Gebiet mit 10x10 Pixel ergibt ein ungenaues Ergebnis.
1000x1000 wäre schon besser

Bei einer Auflösung mit 10.000x10.000 habe ich aber Probleme mit der Darstellung. Darum hilft jetzt auch die Trennung zwischen Code und Ausgabe, denn die Pixel-Koordinaten werden für die Ausgabe einfach skaliert.

Code:

AusgabeX = Runden( WertX / WertBreite * AusgabeBreite )