pymandelbrot

lang65plus ... Mandelbrotmenge

Liebe Besucher dieser Seite,

die nachfolgenden 4 Bilder zeigen Darstellungen einer Mandelbrotmenge mit der Farbkreismethode auf dem Raspi-Display;
sie erfolgen in zeitlicher Reihenfolge und der Aufbau einer Grafik dauert der umfangreichen Rechnungen wegen ca. 3 bis 4 Minuten
... also bitte etwas Geduld mit dem Raspi. Bitte beachten Sie die verschiedenen Darstellungsintervalle (Lupenstärke) dieser einen
Mandelbrotmenge. Unter den Bildern steht das zugehörige Pythonskript.
Das Skript ist mit zahlreichen Kommentaren versehen. Ich empfehle deshalb, dieses mit z.B. IDLE zu öffnen.
Entwicklungsumgebungen stellen Kommentare häufig andersfarbig als Anweisungen dar.

Volker Lang
                   	
"""
    Die Funktionswerte komplexer Funktionen sind komplexe Zahlen, diese lassen sich als 'z = x + yi'
    darstellen oder mittels Betrag von z und dem Winkel zwischen z und x;
    ordnet man den Winkel-'hue' und den Betrag-'satur' des HSV-Farbraumes zu, lässt sich der Funktionswert
    der komplexen Funktion als Farbe darstellen
"""

""" Modul tkinter (Tk interface; verwendet Tk-Toolkit) erlaubt, Tk-Anwendungen zu schreiben """
from tkinter import *
import math, cmath
from time import *

""" Klasse RgbHex hat eine Methode, rgb zu hex zu wandeln, diese gibt die 'hexfarbe' zurück """
class RgbHex():
    def __init__(self):
        self.rot = 0
        self.gruen = 0
        self.blau = 0

    def rgbhex(self, rot, gruen, blau):
        self.hex = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]       
        self.rot = rot
        self.gruen = gruen
        self.blau = blau
        self.rhex1 = self.hex[self.rot // 16]
        self.rhex2 = self.hex[self.rot % 16]
        self.ghex1 = self.hex[self.gruen // 16]
        self.ghex2 = self.hex[self.gruen % 16]
        self.bhex1 = self.hex[self.blau // 16]
        self.bhex2 = self.hex[self.blau % 16]
        self.hexfarbe = "#"+ self.rhex1 + self.rhex2 + self.ghex1 + self.ghex2 + self.bhex1 + self.bhex2
        return self.hexfarbe

""" Klasse HsvRgb hat eine Methode, hsv zu rgb zu wandeln, diese gibt die 'rgbfarbe' zurück """
class HsvRgb():
    def __init__(self):
        self.hue = 0
        self.satur = 0

    def hsvrgb(self, hue, satur):
        self.rgbfarbe = [255, 255, 255]
        """  Umrechnen vom HSV-Farbraum in den RGB-Farbraum nach Wikipedia  
	    hi = [H/60] ... größte ganze Zahl kleiner oder gleich (H/60) ... [ ] Gaußklammer
		also 0, 1, 2, 3, 4, 6
	    H ... hue Farbe	[0,360°]
	    S ... satur Sättigung [0,1]
	    V ... l Helligkeit [0,1]
	    f=(hue/60 - hi) sind also alles 0,.. Werte
	    p = V * ( 1 - S )
	    q = V * (1 - S*f)
	    t = V * (1 - S*( 1 - f ))
	    hi = 0 oder hi = 6 ... (V,t,p)
	    hi = 1 ... (q,V,p)
	    hi = 2 ... (p,V,t)
	    hi = 3 ... (p,q,V)
	    hi = 4 ... (t,p,V)
	    hi = 5 ... (V,p,q)
        """
        self.hi = self.hue  // 60
        self.v = self.satur
        """
        self.v = self.satur ... bei der Heligkeit kann man experimentieren
        """
        self.f = self.hue/60 - self.hi
        self.p = self.v * (1 - self.satur)
        self.q = self.v * (1 - self.satur * self.f)
        self.t = self.v * (1 - self.satur * (1 - self.f))
        if ((self.hi == 0 ) or (self.hi == 6)):
            self.rot = int(self.v * 255)
            self.gruen = int(self.t * 255)
            self.blau = int(self.p * 255)
        elif self.hi == 1:
            self.rot = int(self.q * 255)
            self.gruen = int(self.v * 255)
            self.blau = int(self.p * 255)
        elif self.hi == 2:
            self.rot = int(self.p * 255)
            self.gruen = int(self.v * 255)
            self.blau = int(self.t * 255)
        elif self.hi == 3:
            self.rot = int(self.p * 255)
            self.gruen = int(self.q * 255)
            self.blau = int(self.v * 255)
        elif self.hi == 4:
            self.rot = int(self.t * 255)
            self.gruen = int(self.p * 255)
            self.blau = int(self.v * 255)
        elif self.hi == 5:
            self.rot = int(self.v * 255)
            self.gruen = int(self.p * 255)
            self.blau = int(self.q * 255)
        self.rgbfarbe[0] = self.rot
        self.rgbfarbe[1] = self.gruen
        self.rgbfarbe[2] = self.blau
        return self.rgbfarbe

""" Klasse HsvWert hat eine Methode, die dem Funktionswert einen HSV-Farbwert zuordnent, diese gibt die 'hsvfarbe' zurück """
class HsvWert():
    def __init__(self):
        self.kfr = 0
        self.kfi = 0
        self.betrag = 0
        self.phig = 0
        
    def hsvwert(self, kfr, kfi, betrag, phig):
        self.hsvfarbe = [360, 1]
        """ hue ... Winkel(Farbe) im Farbkreis 0..360° ; 4 Quadranten """
        if ((self.kfr >= 0) and (self.kfi >= 0)):
            self.hue = self.phig
        elif ((self.kfr <= 0) and (self.kfi >= 0)):
            self.hue = 180 - self.phig
        elif ((self.kfr <= 0) and (self.kfi <= 0)):
            self.hue = 180 + self.phig
        elif ((self.kfr >= 0) and (self.kfi <= 0)):
            self.hue = 360 - self.phig
        """ satur ... Sättigung der Farbe
            ich bilde 'betrag' Modulo auf Intervalle I=[e^n , e^(n+1)] für satur ab """
        if ((self.betrag >= 0) and (self.betrag <= math.exp(0))):
            self.satur = abs(self.betrag/math.exp(0))
        elif ((self.betrag >= math.exp(0)) and (self.betrag <= math.exp(1))):
            self.satur = abs(self.betrag/math.exp(1))
        elif ((self.betrag >= math.exp(1)) and (self.betrag <= math.exp(2))):
            self.satur = abs(self.betrag/math.exp(2))
        elif ((self.betrag >= math.exp(2)) and (self.betrag <= math.exp(3))):
            self.satur = abs(self.betrag/math.exp(3))
        elif ((self.betrag >= math.exp(3)) and (self.betrag <= math.exp(4))):
            self.satur = abs(self.betrag/math.exp(4))
        elif ((self.betrag >= math.exp(4)) and (self.betrag <= math.exp(5))):
            self.satur = abs(self.betrag/math.exp(5))
        elif ((self.betrag >= math.exp(5)) and (self.betrag <= math.exp(6))):
            self.satur = abs(self.betrag/math.exp(6))                            
        elif ((self.betrag >= math.exp(6)) and (self.betrag <= math.exp(7))):
            self.satur = abs(self.betrag/math.exp(7))
        self.hsvfarbe[0] = self.hue
        self.hsvfarbe[1] = self.satur
        return self.hsvfarbe        

""" Klasse Funktionswert hat eine Methode, Elemente des Funktionswertes zu berechnen, diese gibt die 'werte' zurück """
class Funktionswert():
    def __init__(self):
        self.x = 0
        self.y = 0
        self.fnr = 1

    def elemente(self, faktor, faktorx, faktory, x, y):
        self.werte = [1, 1, 1, 1]
        self.faktor = faktor
        self.faktorx = faktorx
        self.faktory = faktory
        self.x = x
        self.y = y

        """ der Zeiger der komplexen Zahl führt vom Ursprung des Koordinatensystems x0,y0 zum Punkt P(x,y) """
        """ Realteil der komplexen Zahl """
        self.r = (self.x-self.x0) * self.faktorx
        """ Imaginärteil der komplexen Zahl; y im Koordinatensystem nach oben gerichtet - im Canvas nach unten """
        self.i = (self.y0-self.y) * self.faktory
        
        """ Maximalwert des Betrages für Schleifenabbruch """
        self.bmax = 6
        """ Maximalwert der Wiederholungen für Schleifenabbruch """
        self.wmax = 30
        """ Startwerte für Betrag und Wiederholung """
        self.b = 0
        self.w = 0
        """ c ... Punkt P(self.r,self.i), für den die Farbe bestimmt werden soll """
        self.c = complex(self.r, self.i)
        """ Startwert der Folge, a0 ist der Ursprung """
        self.kzn1 = complex(0, 0)
        while ((self.b < self.bmax) and (self.w < self.wmax)):
            """ komplexe Zahl n """
            self.kzn = self.kzn1
            self.kzn1 = self.kzn**2 + self.c
            self.b = abs(self.kzn1)                
            self.w += 1
           
        """ Funktionswerte für Darstellung anpassen """
        self.kf = self.kzn1 * self.faktor
        """ Betrag des Funktionswertes der komplexen Funktion """
        self.betrag = abs(self.kf)
        """ Winkel zwischen der komplexen Zahl z und der x-Achse im Bogenmaß, mit z = x + yi """
        if self.betrag > 0:
            self.phib = abs(math.asin(self.kf.imag/self.betrag))
        else: self.phib = 0

        """ Winkel im Gradmaß """
        self.phig = math.degrees(self.phib)
        self.werte[0] = self.kf.real
        self.werte[1] = self.kf.imag
        self.werte[2] = self.betrag
        self.werte[3] = self.phig
        return self.werte
    
       
""" Frame-Widget ist Container für andere Steuerelemente ( Widgets ); Rahmen ist eine Basisklasse von Frame """
class Rahmen(Frame):
    """ ___init___ gibt der Klasse einen Konstuktor; wird ein Widget erzeugt, muss ihm ein Master zugeordnet werden """
    def __init__(self, master):
        """ mit super() ruft der Konstrukor von Rahmen den von Frame auf und Frame ist das Master-Widget """
        super().__init__(master)
        self.pack()
        """ Fensterhöhe = fh, Fensterweite = fw ... für das Raspi-Display bestimmt """
        self.fw = 800
        self.fh = 350
        """ Widget Canvas namens fenster wird erzeugt """
        self.fenster = Canvas(self, width = self.fw, height = self.fh, background = "white")
        self.fenster.grid(row = 0, column = 0)       
        self.fenster.pack()

        """ Fußzeile mit Hinweis """
        self.hinweis = Label(self, text="Text wird bei 'zeichne' eingesetzt", bg="#FF6633", fg="white")
        self.hinweis.grid(row = 1, column = 0)
        self.hinweis.pack(fill=X)

        """ Bild definieren """
        self.bild = PhotoImage(file = "pythonicon.gif")
      
        """ Koordinatenusprung in Display-Mitte """
        self.x0mitte = self.fw/2
        self.y0mitte = self.fh/2
       
        """ Fraktal im jeweiligen Intervall Nummer 1...4 """
        self.fnr = 1

        """ Aufruf der Funktion """
        self.bestimmepunktfarbe()

    def bestimmepunktfarbe(self):
        """ Liste der Punke """
        self.xy = [[ "#FF6633" for a in range(self.fh)] for b in range(self.fw)]

        """
           für die einzelnen Folgen werden Text im Hinweis-Label und ein Faktor für die Funktionswerte
           (nach Geschmack) festgelegt; faktorx/y ist Faktor zur Anpassung der Einheit der Koordinatenachsen
           an die Displaygröße für das gewünschte Funktionsbild;
           x0,y0 +/- Wert = Verschiebung des Koordinatenursprungs für gewünschtes Darstellungsintervall
        """      
        if self.fnr == 1:
            self.x0 = self.x0mitte + 200
            self.y0 = self.y0mitte
            self.faktorx = 1/270 
            self.faktory = 1/130 
            self.faktor = 45
            self.hinweis["text"] = "Mandelbrotmenge z -> z^2 + c mit x=[-2.22;0.74] y=[-1.35;1.35]"
        elif self.fnr == 2:
            self.x0 = self.x0mitte - 1180 
            self.y0 = self.y0mitte
            self.faktorx = 1/3200 
            self.faktory = 1/1400 
            self.faktor = 100 
            self.hinweis["text"] = "Mandelbrotmenge z -> z^2 + c mit x=[0.25; 0.5] y=[-0.125;0.125]"           
        elif self.fnr == 3:
            self.x0 = self.x0mitte - 2600 
            self.y0 = self.y0mitte + 150 
            self.faktorx = 1/8000 
            self.faktory = 1/3500 
            self.faktor = 110 
            self.hinweis["text"] = "Mandelbrotmenge z -> z^2 + c mit x=[0.275;0.375] y=[0.0072;0.0928]"
        elif self.fnr == 4:
            self.x0 = self.x0mitte - 3800 
            self.y0 = self.y0mitte + 250 
            self.faktorx = 1/11200 
            self.faktory = 1/4900 
            self.faktor = 80 
            self.hinweis["text"] = "Mandelbrotmenge z -> z^2 + c mit x=[0.304;0.375] y=[0.0153;0.0867]"            

        """
           die einzelnen Schritte der Rechnung sind:
           1. eine Instanz der Klasse 'Funktionswert' berechnet Elemente des Funktionswertes
           2. eine Instanz der Klasse 'HsvWert' berechnet den zugehörigen HSV-Farbwert
           3. eine Instanz der Klasse 'HsvRgb' wandelt die HSV-Farbwerte in RGB-Farbwerte
           4. eine Instanz der Klasse 'RgbHex' wandelt die RGB-Werte in HEX-Werte
           5. Python verlangt HEX-Farbwerte und die Funktion 'zeichne' kann aufgerufen werden
        """    
        for x in range(self.fw):
            for y in range(self.fh):
                self.x = x
                self.y = y
                """ self.fwerte enthält den Rückgabewerte einer Instant von 'Funktionswert' """
                self.fwerte = Funktionswert.elemente(self, self.faktor, self.faktorx, self.faktory, self.x, self.y)
                self.kfr = self.fwerte[0]
                self.kfi = self.fwerte[1]
                self.betrag = self.fwerte[2]
                self.phig = self.fwerte[3]
                """ self.hsvfarbe enthält den Rückgabewert einer Instanz von 'HsvWert' """                
                self.hsvfarbe = HsvWert.hsvwert(self, self.kfr, self.kfi, self.betrag, self.phig)
                self.hue = self.hsvfarbe[0]
                #print(self.hue)
                self.satur = self.hsvfarbe[1]
                """ self.rgbfarbe enthält den Rückgabewert einer Instanz von 'HsvRgb' """
                self.rgbfarbe = HsvRgb.hsvrgb(self, self.hue, self.satur)
                self.rot = self.rgbfarbe[0]
                self.gruen = self.rgbfarbe[1]
                self.blau = self.rgbfarbe[2]
                """ self.farbe erhält den Rückgabewert einer Instanz von 'RgbHex'  """ 
                self.farbe = RgbHex.rgbhex(self, self.rot, self.gruen, self.blau)
                """ Farbe den einzelnen Punkten zuordnen """
                self.xy[self.x][self.y] = self.farbe

        self.zeichne()
                
    def zeichne(self):
        """ alte Ausgabe löschen """
        for item in self.fenster.find_all():
                self.fenster.delete(item)        
        """ Grafik einfügen """
        for x in range(self.fw):
            for y in range(self.fh):
                self.x = x
                self.y = y
                self.farbe = self.xy[self.x][self.y]
                """ zeichnet kurze Linie zum Nachbarpunkt """
                self.fenster.create_line(self.x, self.y, self.x+1, self.y, width = 1.5, fill = self.farbe)                
        """ Bild einfügen """
        self.fenster.create_image(20, 300, image = self.bild, anchor = "nw")
                        
        """ 4 veschiedene Darstellungsintervalle, Nummer ändern """ 
        self.fnr += 1
        if self.fnr > 4:
            self.fnr = 1
                  

        """ nach jweils 1000ms wird die Darstellung einer weiteren Funktion aufgerufen """
        self.fenster.after(1000, self.bestimmepunktfarbe)            
        
        
""" wurzelfenster ist eine Instanz der Klasse Tk """               
wurzelfenster = Tk()
wurzelfenster.title("Fraktal mit der Farbkreismethode dargestellt")
""" Rahmen wird instanziert und erhält wurzelfenster, die Tk-Instanz, als Vater-Instanz"""
Rahmen(wurzelfenster).mainloop()

"""
#oder auch:
#zeichnung ist eine Instanz der Klasse Rahmen und hat wurzelfenster als Vater-Instanz
zeichnung = Rahmen(wurzelfenster)
zeichnung.mainloop()
"""