Mandelbrotmenge - Projektvorstellung

Als erstes erst einmal ein Bild. Der Sketch ist noch nicht ganz fertig !

2.4" TFT Color LCD,touch screen sheild: http://www.nuelectronics.com/estore/index.php?main_page=product_info&cPath=1&products_id=18&zenid=2332adca5eeb034568391d70882e0900

Geplante Funktionen sind: Selektion des zu zoomeden Bereiches über die Touchscreen Funktion mit einem Stylus. Verschiedene Farbkompositionen. Speichern der Bilder auf SD-Card. Slideshow. Evtl. auch noch die Berechnung der Juliamenge. etc ...

Das gefällt mir irgendwie. Es erinnert mich an Zeiten als irgendwie jeder ein "Apfelmännchen" programmiert hat.

Oliver

Das gefällt mir sehr gut. Wie lange dauert es denn mit dem Arduino dieses Grundbild zu berechnen ?

Hallo Realizer,

die Berechnung des Grundbildes dauert mit einem Arduino 2009 ca. 1 Minute.

Gezoomte Bilder mit einer entsprechend vergrösserten Iteration haben allerdings eine entsprechend steigende Rechenzeit, bisher bis ca. 5 Minuten. Bei Iterationen ab 200.

Mit der oben geposteten Funktion kann jetzt schon jedes existierende Mandelbrotbild berechnet werden. Dazu müssen nur die Werte für Breite, Breite2 (X-Werte), Hoehe und Hoehe2 (Y-Werte) geändert werden. Den Wert der maximalen Iteration findet man in der While-Bedingung, im Moment 50 !

RETURN TO FRACTALUS

void mandelbrot()
{
  uint8_t i,j,k;
  uint16_t color;
  tft.ClearScreen(WHITE);
  #define ORANGE _RGB565(255, 153, 0)
  #define GRAY2 _RGB565(200, 200, 200)
  byte Farbwahl;
  double a, b, r1, r2, calc1, calc2 = 0;
  int clrDepth;
  int col[256];
  int FarbNr;
  int j2 = 0;
  int BildHoehe = 240;
  int BildBreite = 320;
  float Breite = -2.3;
  float Hoehe  = -1.25;
  float Breite2 = 0.7;
  float Hoehe2 = 1.25;
  double StepX, StepY;
  Farbwahl = 4;
  // Farbverlauf 1
  if (Farbwahl == 1)
  {
    for (int Nr = 0; Nr <= 36; Nr += 1)
    {
      col[(Nr * 7) + 1] = RED;
      col[(Nr * 7) + 2] = ORANGE;
      col[(Nr * 7) + 3] = YELLOW;
      col[(Nr * 7) + 4] = GREEN;
      col[(Nr * 7) + 5] = CYAN;
      col[(Nr * 7) + 6] = BLUE;
      col[(Nr * 7) + 7] = MAGENTA;
    }
    col[253] = BLACK;
    clrDepth = 253;
  }
  // Farbverlauf 2
  else if (Farbwahl == 2)
  {
    for (int Nr = 0; Nr <= 42; Nr += 1)
    {
      col[(Nr * 6) + 1] = GRAY2;
      col[(Nr * 6) + 2] = GRAY;
      col[(Nr * 6) + 3] = SILVER;
      col[(Nr * 6) + 4] = GOLD;
      col[(Nr * 6) + 5] = YELLOW;
      col[(Nr * 6) + 6] = ORANGE;
    }
    col[253] = BLACK;
    clrDepth = 253;
  }
  // Farbverlauf 3
  else if (Farbwahl == 3)
  {
    for (int Nr = 1; Nr <= 126; Nr += 1)
    {
      if (Nr <= 21)
      {col[Nr] = _RGB565(129 + (Nr * 6), 0, 0);}
        else if (Nr <= 42)
        {col[Nr] = _RGB565(255, 129 + ((Nr - 21) * 6), 0);}   
          else if (Nr <= 63)      
          {col[Nr] = _RGB565(0, 129 + ((Nr - 42) * 6), 0);}       
            else if (Nr <= 84)
            {col[Nr] = _RGB565(0, 129 + ((Nr - 63) * 6), 171 + ((Nr - 63) * 4));}            
              else if (Nr <= 105)
              {col[Nr] = _RGB565(0, 0, 129 + ((Nr - 84) * 6));}
                else if (Nr <= 126)
                {col[Nr] = _RGB565(137 + ((Nr - 105) * 3), 0 + ((Nr - 105) * 8), 200 - ((Nr - 105) * 3));}           
    }              
    for (int Nr = 127; Nr <= 252; Nr += 1)
    {
      col[Nr] = col[Nr - 126];;
    }  
    col[253] = BLACK;
    clrDepth = 253;
  }
  // Farbverlauf 4
  else if (Farbwahl == 4)
  {
    FarbNr = 1;
    col[1] = _RGB565(255, 0, 0);
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(255, int(float((255 / 9) * Nr)), 0);
    }
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(255 - int(float((255 / 9) * Nr)), 255, 0);
    }
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(0, 255, int(float((255 / 9) * Nr)));
    } 
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(0, 255 - int(float((255 / 9) * Nr)), 255);
    }
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(int(float(255 / 9) * Nr), 0, 255);
    }    
    for (int Nr = 1; Nr <= 9; Nr += 1)
    {
      FarbNr = FarbNr + 1;
      col[FarbNr] = _RGB565(255, 0, 255 - int(float(255 / 9) * Nr));
    } 
    for (int Nr = 55; Nr <= 108; Nr += 1)
    {
      col[Nr] = col[Nr - 54];
      col[Nr + 54] = col[Nr - 54];
      col[Nr + 108] = col[Nr - 54];
    }
    col[217] = BLACK;
    clrDepth = 217;
  }
  // Berechnung
  StepX = (Breite2 - Breite) / BildBreite;
  StepY = (Hoehe2 - Hoehe) / BildHoehe;
  for (int n = 0; n <= BildHoehe; n += 1)
  {
    for (int k = 0; k <= BildBreite; k += 1)
    {
      a = Breite + k * StepX;
      b = Hoehe + n * StepY;
      j2 = 0;
      r1 = 0; 
      r2 = 0;
      do
      {
        calc1 = r1 * r1 - r2 * r2 + a;
        calc2 = 2 * r1 * r2 + b;
        r1 = calc1;
        r2 = calc2;
        j2 += 1;
      }
      while (((r1 * r1) + (r2 * r2) <= 50) and (j2 != clrDepth));
      tft.DrawPixel(k, n, col[j2]);
    }
  }
  wait_for_OK();
}

In dieser aktualisierten Version des Sourcecodes sind nun 4 Farbverläufe für die Bildberechnung enthalten !

Farbverlauf Nr 4:

Ich fühle mich in die alten Zeiten versetzt. Danke Megaionstorm für diese Zeitreise. Das Beste ist daß man mit dem Arduino und so einem (doch recht simplen Code) derartige Ergebnisse erzielen kann.

Die Farbverlaufsgeschichte gefällt mir sehr gut. Das Ergebnis kann sich sehen lassen !

Thanks ! :)

Die Farbverlaufsgeschichte gefällt mir sehr gut. Das Ergebnis kann sich sehen lassen !

Hi,
das waren noch Zeiten, kann mich dem nur anschließen. Wird der Farbverlauf noch animmiert? Ein durchrollen der Farben.
Das schaute als Effekt auch immer gut aus.

Die Farbverlaufsgeschichte gefällt mir sehr gut. Das Ergebnis kann sich sehen lassen !

Bei Farbverlauf 3 geht der Farbverlauf jeweils von dem Farbton mit der mittleren Helligkeit zum dem mit der höchsten Helligkeit. Also von Mittelhellrot bis Hellrot, von Mittelhellorange nach Hellorange etc ...

Bei Farbverlauf 4 geht der Farbverlauf von Rot nach Gelb nach Grün etc ... Der Farbverlauf geht also in die nächste Hauptfarbe über.

Wird der Farbverlauf noch animmiert?

Wenn der Arduino dazu nicht zu langsam ist, dann ja ! Nur zu gerne !

Der Code des Programmes wird in 3 Teilen veröffentlicht: 1) Die Routine zum Berechnen der Mandelbrotmenge. Zum einfachen Anpassen an andere Displays. 2) Die Routine zum Berechnen der Juliamenge. Zum einfachen Anpassen an andere Displays. 3) Das komplette Programm mit allen zusätzlichen Bilddateien für die SD-Card. Für die Menüdarstellung.

Nach der Fertigstellung der Arduino Applikation werde ich dann hier auch die Windows PC Version des Programmes als Download zur Verfügung stellen !

Hallo,

habe hier ein etwas neueres LCD Board von Watterott

MI0283QT-2 Display mit TouchPanel (2.8", 240x320 Pixel).

Der Farbverlauf 1 sieht so aus

Gruss Kalli

@Kalli

Ist doch schön zu sehen das Leute Interesse an der Mandelbrotmenge haben.

Wie sehen den Farbverlauf 3 und 4 auf deinem Display aus ?

Benutzt Du auch das Arduino mSD-Shield von Watterott in Verbindung mit deinem Display ? http://www.watterott.com/de/Arduino-mSD-Shield

Farbverlauf 3

Farbverlauf 4

Dauert aber schon einige Minuten. Der erste Computer, an dem ich sass, war auf der Fläche eines Kleingarten verteilt, hatte 40K Speicher und 100kHz Takt.

Gruss Kalli

Ja, benutze das mSD-Shield ohne was drauf...

wie schnell läuft eine art texteditor drauf ? schon mal text eingegeben ? ist evtl ein scrollen mit drin ohne grosse ruckartige zeitverzögerungen?

nur grafiken finde ich ein bisschen langweilig.

gruss

@funkheld

Ich werde versuchen die Frage demnächst zu beantworten !

Allerdings in einem neuen Threat !

Wenn Ihr euch, während ihr auf die Arduino Version wartet, schonmal die fast fertige PC-Version anschauen wollt.

Dann könnt Ihr dies hier tun: http://rapidshare.com/files/449243006/Return_To_Fractalus.rar

Ooohhhh, und der Delphi-Sourcecode ist ebenfalls enthalten ! How, how, how ... !

Also kompilierte EXE-Version + Sourcecode in Delphi !

Ich hatte kuerzlich auch einen Anfall von leichter Fraktolitis: http://www.flickr.com/photos/morezenart/5212199398. Das ist nicht auf dem Arduino gemacht, aber vielleicht inspiriert die Farbgebung.

Das gefällt mir alles sehr gut ! Ich freue mich von lauter Fraktalisten umgeben zu sein, da ich selber einer bin ! ;) Bilder kann ich derzeit keine präsentieren, da mein Fraktalprogramm direkt auf den Desktop zeichnet. (Sowetwas wie ein Hintergrunddesign - Fraktalprogramm)

Ich denke wir werden nicht offtopic, weil das alles miteinander verküpft werden kann.

Fraktale sind Plattformübergreifend !

In der Tat ist die Farbgebung ausschaggebend für das Ergebnis. Vielleicht zeige ich euch gerne bald mein Fraktalprogramm. Dieses hat ein Farbmischpult mit eingebaut. Die Farbgebung basiert auf 3 Sinussignalen welche in: Amplitude, Frequenz und Phasenlage justiert werden können.

Der Thread ist noch nicht fertig... Wir hören noch voneinander ! :)

Fraktalisten hoch 10.

Meine letzten Erzeugnisse:

http://www.youtube.com/watch?v=q06zJZR75Ew

Und wieder weg.