pykf

lang65plus ... komplexe Funktionen

Liebe Besucher dieser Seite,

die nachfolgenden 6 Bilder zeigen die Darstellungen komplexer Funktionen mit der Farbkreismethode auf dem Raspi-Display;
sie erfolgen in zeitlicher Reihenfolge und 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 = 0.5 + self.satur * 0.5
        """
        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, fnr, faktor, faktorxy, x, y):
        self.werte = [1, 1, 1, 1]
        self.fnr = fnr
        self.faktor = faktor
        self.faktorxy = faktorxy
        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.faktorxy
        """ Imaginärteil der komplexen Zahl; y im Koordinatensystem nach oben gerichtet - im Canvas nach unten """
        self.i = -(self.y-self.y0) * self.faktorxy
        
        if self.fnr == 1:
            """ komplexe Funktion f(z) = sin(z) mit z = x + yi """
            self.kf = cmath.sin(complex(self.r, self.i))           
        elif self.fnr == 2:
            """ die komplexe Funtion f(z) = (z+a)/(z+b) mit z = x + yi, a = 1 + 1i, b = -2 - 3i  """
            self.alpha = 1
            self.beta = 1
            self.gamma = -2.00001
            self.delta = -3.00001
            self.z = complex(self.r , self.i)
            self.a = complex(self.alpha , self.beta)
            self.b = complex(self.gamma , self.delta)
            self.kf = (self.z + self.a)/(self.z + self.b)           
        elif self.fnr == 3:
            """ die komplexe Funtion f(z) = z = x + yi """
            self.kf = complex(self.r , self.i)
        elif self.fnr == 4:
            """ die komplexe Funtion f(z) = z^2 mit z = x + yi """
            self.kf = (complex(self.r , self.i))**2
        elif self.fnr == 5:
            """ die komplexe Funtion f(z) = (x^2) + (y^2)i mit z = x + yi """
            self.kf = complex(self.r**2 , self.i**2)
        elif self.fnr == 6:
            """ die komplexe Funtion f(z) = (z+a)/(z+b) + e^z/(z-c) mit z = x + yi und a, b, c … komplexe Zahlen
                x = [-2 ; 4] y = [-2,5 ; 3,5] alpha=1, beta=1, gamma=3, delta=1, epsilon=2, zeta=-1
            """
            self.r = self.r - 0.5
            self.i = self.i - 0.5 #* 2
            self.alpha = 1 #3 4 1 0.75 4 6 3 
            self.beta = 1 #1 3 0.25 2 1
            self.gamma = 3.000001 #2 0.5 2.5
            self.delta = 1.000001 #-1 -0.25 -1.5 -2
            self.epsilon = 2.000001 #1 0.25 1.5 2 3
            self.zeta = -1.000001 #1 -1 0.25 2 3 4
            self.a = complex(self.alpha , self.beta)
            self.b = complex(self.gamma , self.delta)
            self.c = complex(self.epsilon , self.zeta)
            self.z = complex(self.r , self.i)
            self.kf = (self.z + self.a)/(self.z + self.b) + cmath.exp(self.z)/(self.z-self.c)
           
        """ Funktionswerte für Darstellung anpassen """
        self.kf = self.kf * self.faktor
        """ Realteil des Funktionswertes der komplexen Funktion 
        self.kfr = self.kf.real
        """
        """ Imaginärteil des Funktionswertes der komplexen Funktion 
        self.kfi = self.kf.imag
        """
        """ Betrag des Funktionswertes der komplexen Funktion """
        self.betrag = abs(self.kf)
        """
        self.betrag = math.hypot(self.kfr, self.kfi)
        """
        """ 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 """
        self.x0 = self.fw/2
        self.y0 = self.fh/2
       
        """ Funktionsnummer 1...6 """
        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 Funktionen werden Text im Hinweis-Label und ein Faktor für die Funktionswerte
           (nach Geschmack) festgelegt; faktorxy ist Faktor zur Anpassung der Einheit der Koordinatenachsen
           an die Displaygröße für das gewünschte Funktionsbild
        """      
        if self.fnr == 1:
            self.faktorxy = 1/60
            self.faktor = 13
            self.hinweis["text"] = "die komplexe Funktion f(z) = sin(z) mit z = x + yj"
        elif self.fnr == 2:
            self.faktorxy = 1/40
            self.faktor = 30
            self.hinweis["text"] = "die komplexe Funktion f(z) = (z+a)/(z+b) mit z = x + yi, a = 1 + 1i, b = -2 - 3i"           
        elif self.fnr == 3:
            self.faktorxy = 1/20
            self.faktor = 25
            self.hinweis["text"] = "die komplexe Funktion f(z) = z = x + yi"
        elif self.fnr == 4:
            self.faktorxy = 1/60
            self.faktor = 5
            self.hinweis["text"] = "die komplexe Funktion f(z) = z^2 mit z = x + yi"
        elif self.fnr == 5:
            self.faktorxy = 1/80
            self.faktor = 10
            self.hinweis["text"] = "die komplexe Funktion f(z) = (x^2) + (y^2) i mit z = x + yi"
        elif self.fnr == 6:
            self.faktorxy = 1/133
            self.faktor =620
            self.hinweis["text"] = "die komplexe Funktion f(z) = (z+a)/(z+b) + e^z/(z-c) mit z = x + yi und a, b, c … komplexe Zahlen"

        """
           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.fnr, self.faktor, self.faktorxy, 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]
                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")
                        
        """ 6 veschiedene Funktionen, Funktionsnummer ändern """
        self.fnr += 1
        if self.fnr > 6:
            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("komplexe Funktion 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()
"""