Imaginären/Realen Anteil berechnen

[Stillmatic]

Guten Tag!!

Ich habe die schwierige Aufgabe eine Apfelmännchen / Juliamenge Programm in Delphi zu schreiben!
Ich habe mir soweit ein Formular erstellt wo ich Werte für (RealMax,RealMin) und (ImgMax,ImgMin) eingeben kann.
Ausserdem kann man noch die Depth einstellen!

Nun soll ich aber 2 Funktionen schreiben in denen ich aus der Bildkoordinate(x) oder (y) den (realen) und den (imaginären)
Anteil berechne und die Werte in eine der 2 anderen Funktionen übergebe, wo ich die Farbe für einen ihr übergebenen Bildpunkt--Apfelmännchen rekursiv berechne oder halt die Farbe für einen ihr übergebenen Bildpunkt--Juliamenge rekursiv berechne!!

Doch leider weiß ich jetzt nicht mehr weiter......



*THX*
(Code könnte ich hochladen,wenn jemand mir helfen möchte)

[marabu]

Herzlich willkommen in der Delphi-PRAXiS, Stillmatic.

Vor dir haben sich schon andere mit der Visualisierung von Mandelbrotmengen herumgeschlagen. Suche mal hier nach [dp]Apfelm*[/dp] und du findest jede Menge Code als Anschauungsmaterial.

Freundliche Grüße vom marabu

[mkinzler]

Eine komplexe Zahl ist ja ein Vektor. Man könnte aber auch einen Typ dafür deklarieren und ab D10 Class Operatoren verwenden.

[Stillmatic]

Die meisten codes hab ich mir schon angeschaut doch es ist nirgens richtiger InlineCode enthalten sodass man nie weiß was der Programmierer dort macht.

Ich schreibe meine erstes Zeichen Programm in Delphi, dessahlb hab ich ein paar Probleme!

Kann mir den einer von euch sagen was genaus ich mit den Werten RealMin,RealMax,ImaginärMin,ImaginärMax und Depth anfange!!

Eine Rekursive Formel zur erstellung der Apfelmenge habe ich doch zuvor muss ich doch erstmal irgendetwas berechnen!

[marabu]

Du könntest dir mal die Prozedur iteration aus diesem Thread anschauen: progess bar soll laden waehrend sich ein timage aufbaut

[Stillmatic]

In wie fern soll mir diese Proceure weiter helfen??

Mein Problem ist es immer noch das ich die Aufgabe nicht wirklich verstehe!!!
Mir müsste einer mal erklären wie genau das Programm abläuft,also welche werte muss ich ermitteln um mit diesen Formeln arbeiten zu können.

(muss ich in rekursive Funktion packen)
Apfelmännchen:
Ren+1=Ren2-Imn2+Re0
Imn+1=2*Ren*Imn+Im0

Juliamenge:
Ren+1=Ren2-Imn2+JRe
Imn+1=2*Ren*Imn+JIm

Grenze:
Re*Re+Im*Im<=100

Vorgegeben sind diese Konstanten....

ReMin=-2,25
ReMax=0,75
ImMin=-1,5
ImMax=1,5
Depth=400

Konstanten nur für die Juliamengen
JRe=-0,743
JIm=0,18

Die Konstanten stehen in dem Formular als Anfangswerte für ReMin,ReMax,ImMin,ImMax,Depth!

Nun ist meine Frage (???????????)

In der Formle gibt es Werte wie Re oder Im......
Was genau sind das für Werte,wie ergeben sie sich??
Muss ich z.B. die Werte für Re mit ReMin und ReMax errechnen??

Anbei hab ich mal mein bissheriges Programm!!!
(es ist nicht viel code enthalten, nur zur veranschaulichung)

:wall:

[Eichhoernchen]

Re und Im bezeichnen den Realwert und den Imaginärwert (der Teil mit dem i) einer Komplexenzahl.

die Formel für die Mandelbrotmenge ist ja:
z = z² + c

wobei z und c Komplexezahlen sind.

z = a + b*i (die Definition einer Komplexenzahl)

z² = (a + b*i)² = a² + 2*a*b*i + (b*i)²

nach Definition ist i² = -1

somit:

z² = a² + 2abi - b²

Re(z²) = a² - b²
Im(z²) = 2*a*b*i

Nun addierst du zum z jeweils noch die entsprechenden c Teile und fertig.

Also der Teil mit dem i (Imaginäre Einheit) ist immer der Imaginärteil, der Realteil ist der Teil mit den Reellenzahlen.

Und um dann die Mandelbrotmenge zu berechnen, nimmst du dir Startwerte für die einzelnen Variablen und machst immer wieder z = z² +c, wobei das z², der Wert von dem z ist was du davor berechnen hast.Der Punkt gehört zur Bandelbrotmenge wenn der Betrag (Modul) der Zahl kleiner als 2 ist.
Man definiert das zwar recht häufig rekursiv jedoch lässt man das Programm in der Regel iterativ ablaufen, da es zum einen nicht so verwirrend ist für andere die den Code lesen (egal wie toll doch Rekursion ist) und ich glaube das Rekursion hier auch nicht angebracht ist, da man jenachdem wie genau man es haben will das ganze an die 1000 mal macht und dann gibt es nen Stackoverflow.
Ich hab mir das immer so Programmiert:

Delphi-Quellcode:

//Startwertesetzen(xalt, yalt, xc, yc, n)

while (xalt*xalt + yalt*yalt < 4) and (n < 400) do
begin
  inc(n);
  x := xalt*xalt - yalt*yalt + xc;
  y := 2 * xalt * yalt + yc;
  xalt := x;
  yalt := y;
end;
if n = 400 then
//  Punkt gehört dazu
else
//  Punkt gehört nicht dazu

[Stillmatic]

Ja das ist doch mal nen hilfreicher Beitrag, thx!!!

Jetzt weiß ich nur noch nicht wofür ich die vorgefertigten Functionen getRe,getIm,mandel und Julia brauche,aber das werde ich noch herausbekommen!!

Ganz verstanden hab ich das da oben noch nicht!
Kann einer mal ein Beispiel schreiben für eine rechnung(Apfelmännchen)....

ReMin=-2,25
ReMax=0,75
ImMin=-1,5
ImMax=1,5
Depth=400

Brauch man nicht dafür die Formulargröße(größe PaintBox) = 800 x 600 ( ist aber in Laufzeit skalierbar)??

Welche Werte setz ich jetzt in die Formel ein......

Ren+1=Ren2-Imn2+Re0
Imn+1=2*Ren*Imn+Im0

vielleicht wird es mit einem Beispiel deutlicher!!

[Stillmatic]

Kann mir denn keiner sagen, wie genau ich von z.B. ReMin und ReMax auf Re komme oder analog ImMin und Imax auf Im??

Ich verzweifel an dieser Aufgabe!!

[sirius]

So schwer ist das doch nicht :roll:
Wie bei einer "normalen" reellen Funktion. Da legts du dir ja auch einen Zeichenbereich fest (z.B. zeichnest du f(x)=sin(x) im Bereich von x von -pi bis pi) genauso hier. Nur das du bei komplexen Zahlen in der Gaußchen Zahlenebene bist. Und damit Re von Remin bis Remax und Im von Immin bis Immax laufen lassen musst.

Und zum Zeichnen musst du die Zahlen eben noch skalieren und dir eine angemessene Schrittweite überlegen.

[Stillmatic]

Ich weiß nicht warum aber ich versteh das nicht!
Kann mir denn einer von euch mal sagen nach welchen schritten ich vorgehen muss um das Apfelmännchen Zeichnne zu können??

Also:

Eingegeben werden (vom User)----->
RealMin,RealMax,ImaginärMin,ImaginärMax und Depth.

Mit diesen Werten muss ich nun arbeiten......
Doch ich verstehe immer noch nicht wie ich nun von den eingegebenen Werten zur Formel und somit zum entstehenden Bild gelange!!

Ich stehe etwas unter Zeitdruck,deswegen wäre ich über schnelle HILFE sehr Dankbar

*THX* :bounce1:

[Eichhoernchen]

Pass auf, du hast 800 Pixel in der Breite und, 600 Pixel in der Höhe.

Und du hast Für die X-Achse also die Realwerte Von ReMin (-2,25) bis ReMax (0,75), sprich entsprechen 800Pixel in der Breite 3 Einheiten in der Gauschenzahlenebene.

Sprich um ein Pixel in die Gauschezahlenebene umzurechnen rechnest du Pixel/3

Auf der Y-Achse werden die Imaginärenzahlen aufgetragen.

Von ImMin=-1,5 bis ImMax=1,5 sprich wieder 3.

Also auch Pixel/3.

nun lässt du ein Programm laufen:

Delphi-Quellcode:

//Wahrscheinlich muss die unit math eingebunden werden: uses ..., math;

procedure PaintMandelOnCanvas(ReMin, ReMax, ImMin, ImMax: Real; MaxIt: integer; Canv: TCanvas);
var
  xalt, x, xc, yalt, y, yc, RePlane, ImPlane: real;
  n, i, j: integer;
begin
  RePlane := abs(ReMin) + abs(ReMax);
  ImPlane := abs(ImMin) + abs(ImMax);
  for i := 0 to 800 do
    for j := 0 to 600 do
    begin
      xalt := 0;
      yalt := 0;
      n := 0;
      xc := (i / RePlane) + ReMin;  //Umrechnen in die Gauschezahlenebene
      yc := (j / ImPlane) - ImMin;  
      while (xalt*xalt + yalt*yalt < 4) and (n < MaxIt) do
      begin
        inc(n);
        x := xalt*xalt - yalt*yalt + xc;
        y := 2 * xalt * yalt + yc;
        xalt := x;
        yalt := y;
      end;
      if n = MaxIt then
        Canv.Pixel[i, j] := clblack
      else
        //Färb je nach erreichter Iteration, veränderbar
        Canv.Pixel[i, j] := RGB(n, n div 2, (n+100)/3);  
    end;
end;

So, ich hab das jetzt nicht getestet aber das sollte eine Schwarze Mandelbrotmenge geben mit gefärbtem Randbereich.

[Stillmatic]

Diese Funktion verschafft mir schoneinmal etwas Klarheit!!
Danke dafür!!

Nur ich muss das ganze ja wie gesagt rekursiv aufbauen also keine For Schleifen!!

Nun versteh ich nicht ganz wie ich aus den beiden geschachtelten For Schleifen zur Berechnung der Gauschenzahlenebene eine Rekursive Funktion bauen kann(???)

EDIT1:::::

Ich soll ja 2 Funktionen zur Berechnung erstellen...
Einmal getRe und get Im!

Reicht es dann nicht in getRe 800 und für getIm 600 zu übergeben??
Und die Funktion dann halt Rekursiv zu gestalten??
Aber wie?

[Eichhoernchen]

Soll getRe und getIm, einen Pixel in die Gauschezahlenebene umrechnen oder was?

Ich vermute ja dass nicht die For-Schleifen rekursiv sein sollen sondern die Berechnungsfunktion (in meinem Beispiel die whileschleife) der Mandelbrotmenge, so ürde das im Zusammenhang mit der Definition der Mandelbrotmenge Sinn machen.

Delphi-Quellcode:

const MaxIt = 400;

function getRe(pixel, ReMin, ReMax): real;
begin
  result := ( Pixel / (abs(ReMin) + abs(ReMax)) ) + ReMin;
end;

function getIm(Pixel, ImMin, ImMax): real;
begin
  result := ( Pixel / (abs(ImMin) + abs(ImMax)) ) - ImMin;
end;

function CalcMandel(xc, yc: real; xalt: real = 0; yalt: real = 0; recurs: integer = 0): integer;
var
  x, y: real;
begin
  x := xalt*xalt - yalt*yalt + xc;
  y := 2 * xalt * yalt + yc;
  if (xalt*xalt + yalt*yalt < 4) and (recurs < MaxIt) then
    result := CalcMandel(xc, yc, x, y, recurs+1)
  else
    result := recurs;
end;

procedure PaintMandelOnCanvas(ReMin, ReMax, ImMin, ImMax: Real; Canv: TCanvas);
var
  xc, yc: real;
  n, i, j: integer;
begin
  for i := 0 to 800 do
    for j := 0 to 600 do
    begin
      xc := getRe(i, ReMin, ReMax);
      yc := getIm(j, ImMin, ImMax); 
      n := calcmandel(xc, yc);
      if n = MaxIt then
        Canv.Pixel[i, j] := clblack
      else
        //Färb je nach erreichter Iteration, veränderbar
        Canv.Pixel[i, j] := RGB(n, n div 2, (n+100)/3); 
    end;
end;

Hab ich alles nicht getestet, hab ich einfach so aufgeschrieben, ich bin mir nicht sicher ob alles so klappt wie es gewollt ist.

[Stillmatic]

In der Aufgabe steht das ..........

getRe ( Diese Funktion berechnet aus der X-Bildkoordinate den realen Anteil im Koordinatensystem)
getIm ( Diese Funktion berechnet aus der Y-Bildkoordinate den imaginären Anteil im Koordinatensystem)
mandel ( Dies Funktion berechnet rekursiv die Farbe für einen ihr übergebenen Bildpunkt für das Apfelmännchen)

Also hab ich das doch in getRe(z.B) richtig gemacht????

Code:

function getRe(const x:integer;ReMin,ReMax:real;Breite:Integer):real;
var ReBe,ReKoordinate:real;
        i:integer;
Begin
for i:= 0 to Breite do
 Begin
  ReBe := abs(ReMin) + abs(ReMax);
  ReKoordinate := (i / ReBe) + ReMin;
  getRe:=ReKoordinate;
 end;
end;

Nur wofür brauch ich dann denn noch die const x??
Oder ist das so falsch, ich weiß nämlich nicht , wenn ich jetzt die Rechnung in Mandel programmieren sollte ob er dann auch jeden einzelnen Berechneten Wert aus getRe bekommt und somit nutzen kann??

[track]

x,y sind die pixel

du hast ein painxbox von 0 bis x (deine breite) und genauso von 0 bis y(höhe)
jtzt musst du den realen und imagineren anteil ausrechnen
zb. wieviele pixel= 1 re

[Eichhoernchen]

So, ich hab mit dem Threadersteller noch nen paar PMs getauscht und jetzt sollten alle Fehler beseitigt sein.

Delphi-Quellcode:

{##############################################################################}
{Diese Funktion berechnet aus der X-BildKoordinate den realen Anteil im Koordinatensystem}
function getRe(const x:integer;ReMin,ReMax,Breite:real):real;
Begin
 getRe := (x / (Breite /(abs(ReMax - ReMin))) + ReMin);
end;

{##############################################################################}
{Diese Funktion berechnet aus der Y-BildKoordinate den imaginären Anteil im Koordinatensystem}
function getIm(const y:integer;ImMin,ImMax,Hoehe:real):real;
Begin
 GetIm := -(y / (Hoehe /(abs(ImMax - ImMin))) - ImMax);
end;

{##############################################################################}
{Diese Funktion berechnet rekursiv die Farbe eines ihr übergebenen Bildpunktes --> Apfelmännchen}
function mandel(const re0,im0:real;depth:integer;re,im:real):TColor;
var
  x, y: real;
begin
  if (re0*re0 + im0*im0 <= 100) and (depth > 0) then
  begin
    x := re0*re0 - im0*im0 + re;
    y := 2 * re0 * im0 + im;
    mandel := mandel(x, y, depth-1, re, im)
  end
  else
    mandel := TColor(500*depth);
end;

{##############################################################################}
{Diese Funktion berechnet rekursiv die Farbe eines ihr übergebenen Bildpunktes --> Juliamenge}
function Julia(const re0, im0:real; depth: integer; jre, jim: real):TColor;
var
  x, y: real;
begin
  if (re0*re0 + im0*im0 <= 100) and (depth > 0) then
  begin
    x := re0*re0 - im0*im0 + jre;
    y := 2 * re0 * im0 + jim;
    julia := Julia(x, y, depth-1, jre, jim);
  end
  else
    julia := TColor(depth * 1500);
end;

Im Anhang ein kleines Beispielprogramm, was den Ablauf verdeutlicht