Imaginären/Realen Anteil berechnen

[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*

[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