pyuhr

lang65plus ... Schmetterlingsuhr

Liebe Besucher dieser Seite,

das Bild zeigt eine Momentaufnahme eines dynamischen Schmetterlings und einer Digitaluhr.
Nachfolgend das Pythonskript.

Volker Lang
                   
""" Modul tkinter (Tk interface; verwendet Tk-Toolkit) erlaubt, Tk-Anwendungen zu schreiben """
from tkinter import *
import math
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
    
""" 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="Schmetterlingskurve nach Temple Fay", 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.0
        self.y0 = self.fh/1.5
        self.i = 0

        """ Liste der Tagesnamen """
        self.wochentag = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Sonnabend", "Sonntag"]        

        """ Aufruf der Funktionen """
        self.punktemenge()
        self.zeichnen()   

    """ die Funktion zeichen wird ständig wiederholt, deshalb vorher alle Punkte berechnen """       
    def punktemenge(self):
        """ die Schleife winkel<75.39 erzeugt mit winkel+=0.2 diese Anzahl von Punkten """
        self.punkteanzahl = math.floor(75.39 * 50) + 1
        
        """ Liste xy der Punkte definieren """
        self.xy = [[ 0 for a in range(self.punkteanzahl)] for b in range(2)]
        
        self.winkel  = 0.0
        self.punktnummer = 0
        """ 12 * 2Pi = 75,39 """
        while self.winkel < 75.39:
              self.r = math.exp(math.cos(self.winkel)) - 2*math.cos(4*self.winkel) + (math.sin(self.winkel/12))**5
              self.x = self.r*math.cos(self.winkel - math.pi/2)
              self.y = self.r*math.sin(self.winkel - math.pi/2)
              """ auf Fenstergröße / für Koordinatenkreuz transformieren """
              self.xk = self.x *self.fw/10 
              self.yk = self.y *self.fh/10
              """ Punktkoordinaten """
              self.px = self.x0 + self.xk 
              self.py = self.y0 + self.yk
              """ Punkte-Feld """
              self.xy[0][self.punktnummer] = self.px
              self.xy[1][self.punktnummer] = self.py
              self.punktnummer += 1     
              self.winkel += 0.02

    def zeichnen(self):
                """ Abfrage aktuell Datum, Tag, Zeit """
                self.ortszeit = localtime(time())
                self.zeit = ("{:02}:{:02}".format(self.ortszeit.tm_hour, self.ortszeit.tm_min))
                self.wota = ("{}".format(self.wochentag[self.ortszeit.tm_wday]))
                self.datum = ("{:02}.{:02}.{:04}".format(self.ortszeit.tm_mday, self.ortszeit.tm_mon, self.ortszeit.tm_year))
                
                """ alte Ausgabe löschen """
                for item in self.fenster.find_all():
                     self.fenster.delete(item)
                     
                """ Bild einfügen """
                self.fenster.create_image(20, 300, image = self.bild, anchor = "nw")
                
                """ Text einfügen """
                self.fenster.create_text(400, 50, text=" Guten Tag, heute ist " + self.wota + " der " + self.datum + \
                            " und genau " + self.zeit + " Uhr", fill='black', font = ('Times', 24, 'italic'))
                
                """ Schmetterling einfügen """
                self.j = 0
                while self.j < self.punkteanzahl -1 :
                    self.rot = 255 - self.j % 64  
                    self.gruen = 102 + self.j % 64
                    self.blau = 51 + self.j % 64
                    
                    """ self.farbe erhält den Rückgabewert einer Instanz von RgbHex """
                    self.farbe = RgbHex.rgbhex(self, self.rot, self.gruen, self.blau)

                    self.fenster.create_line(self.xy[0][self.j], self.xy[1][self.j], self.xy[0][self.j+1], self.xy[1][self.j+1], width = 1.5, fill = self.farbe)
                    """ für gestrichelten Schmetterling ... j += 1 + i % 3 """
                    self.j += 1 + self.i % 3
                    
                """ self.i wird nur %3 ausgewertet """
                self.i += 1
                if self.i > 2:
                    self.i = 0
                    
                """ nach 1000ms Pause wird Funktion zeichnen erneut aufgerufen """    
                self.fenster.after(1000, self.zeichnen)
                
""" wurzelfenster ist eine Instanz der Klasse Tk """               
wurzelfenster = Tk()
wurzelfenster.title("Wochentag, Datum und Zeit")
""" Rahmen wird instanziert und erhält wurzelfenster, die Tk-Instanz, als Vater-Instanz"""
Rahmen(wurzelfenster).mainloop()

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

"""
Temple Fay: The Butterfly Curve, American Math. Monthly, 96(5); 442-443
Die Schmetterlingskurve ist eine transzendentale ebene Kurve, die Temple H. Fay kreierte.
http://www.kantel.de/schockwellenreiter/pythonmania/images/formel8.gif
oder anders
x = cos(u)*(e^[cos(u)] - 2 cos(4u) - sin(u/12)^5.0)
y = sin(u)*(e^[cos(u)] - 2 cos(4u) - sin(u/12)^5.0)
"""