Agnesi - Netter Programmierspaß (Projekte)

[thread]19097[/thread]

Agnesi - Netter Programmierspaß

Tags: perl5 Ähnliche Threads

Leser: 23

Articles: hide open all | hide show old branches

+5 replies

hlubenow

2014-05-18 01:58

User since
2009-02-22
875 Artikel
BenutzerIn
[default_avatar]

Hi,

gestern gab es ein interessantes Google-Doodle, gif-Animation hier.
Das wollte ich mal in Tk (Tkinter) nachmachen. Anleitung zur Mathematik hier.
Und ein Video hier.
Die Formel für die Kurve scheint zu sein: y = 8 / (4 + x ^ 2).

Mein Ansatz in Python (konnt's leider noch nicht nach Perl/Tk übertragen):

Code (python): (dl )

#!/usr/bin/python
# coding: iso-8859-1

import math
import Tkinter
from Tkconstants import *

# Screen resolution:
RESX = 800
RESY = 600

XFAC = 100
XSUM = 400
YFAC = 90
YSUM = 300

class AgnesiWindow:
    def __init__(self):
        self.mw = Tkinter.Tk()
        self.mw.option_add("*font", ("Arial", 12, "normal"))
        self.mw.title("Agnesi")
        self.mw.geometry("+90+45")
        self.cv = Tkinter.Canvas(self.mw,
                                 bg = "white",
                                 width = RESX,
                                 height = RESY)
        self.cv.pack()
        self.btn = Tkinter.Button(self.mw,
                                  text = "Ok",
                                  command = self.mw.destroy)
        self.btn.bind(sequence = "<Return>", func = self.bindFunc)
        self.btn.focus()
        self.btn.pack(side = RIGHT,
                      padx = 10,
                      pady = 10)
        self.w = 90
        self.points = {"up" : [math.cos(math.radians(270)),
                               math.sin(math.radians(270))],
                       "low" : [math.cos(math.radians(90)),
                                math.sin(math.radians(90))],
                       "circle" : [0, 0],
                       "line" : [-3.6, 0]}
        self.withdraw = []
        self.cv.create_line(0, self.points["up"][1] * YFAC + YSUM,
                            800, self.points["up"][1] * YFAC + YSUM) 
        self.cv.create_line(0, self.points["low"][1] * YFAC + YSUM,
                            800, self.points["low"][1] * YFAC + YSUM) 
        self.plotDot(self.points["low"], withdraw = False)
        self.mw.after(1000, self.draw)
        self.mw.mainloop()

    def bindFunc(self, a):
        self.mw.destroy()

    def plotPoint(self, point):
        a = [point[0] * XFAC + XSUM, point[1] * YFAC + YSUM]
        self.cv.create_line(a[0], a[1], a[0] + 1, a[1] + 1)

    def plotDot(self, point, withdraw = False):
        a = [point[0] * XFAC + XSUM, point[1] * YFAC + YSUM]
        if withdraw:
            self.withdraw.append(self.cv.create_oval(a[0] - 5, a[1] - 5,
                                                      a[0] + 5, a[1] + 5,
                                                      fill = 'black'))
        else:
            self.cv.create_oval(a[0] - 5, a[1] - 5,
                                a[0] + 5, a[1] + 5,
                                fill = 'black')

    def drawLine(self, from_, to_, withdraw = False):
        a = [from_[0] * XFAC + XSUM, from_[1] * YFAC + YSUM]
        b = [to_[0] * XFAC + XSUM, to_[1] * YFAC + YSUM]
        if withdraw:
            self.withdraw.append(self.cv.create_line(a[0], a[1],
                                                    b[0], b[1]))
        else:
            self.cv.create_line(a[0], a[1], b[0], b[1])

    def draw(self):
        if self.w <= 450:
            for i in self.withdraw:
                self.cv.delete(i)
            self.points["circle"] = [math.cos(math.radians(self.w)),
                                     math.sin(math.radians(self.w))]
            self.plotDot(self.points["circle"], withdraw = True)
            self.plotPoint(self.points["circle"])
            self.w += 1

            b = math.pow(self.points["line"][0], 2)
            self.points["line"][1] = 1 - (8. / (4. + b))
            self.plotPoint(self.points["line"])
            self.plotDot(self.points["line"], withdraw = True)

            self.plotDot([self.points["line"][0], self.points["up"][1]], withdraw = True)
            self.drawLine(self.points["low"], [self.points["line"][0], self.points["up"][1]], withdraw = True)

            self.plotDot([self.points["line"][0], self.points["low"][1]], withdraw = True)
            self.drawLine([self.points["line"][0], self.points["up"][1]],
                          [self.points["line"][0], self.points["low"][1]],
                          withdraw = True)

            self.points["line"][0] += 0.02
            self.mw.after(50, self.draw)
 
if __name__ == "__main__":
    app = AgnesiWindow()

Sieht schon ganz passabel aus, finde ich, aber da ist noch ein Fehler drin: Der Punkt auf dem Kreis müßte auf Höhe des Punktes auf der Kurve sein (und auf der Linie vom unteren Punkt aus). Das ist er leider nicht. :(
Na ja, wenn jemand Zeit und Lust dazu hat, kann er ja versuchen, den Fehler zu finden. Ich habe bisher aber auch mit Probieren "gearbeitet". :)

hlubenow

2014-05-18 17:34

User since
2009-02-22
875 Artikel
BenutzerIn
[default_avatar]

So, jetzt geht's doch (immer noch erstmal in Python).
Diesmal habe ich nicht die fertige Formel verwendet, sondern nur "gezeichnet", wie in dem pdf beschrieben.

Code (python): (dl )

#!/usr/bin/python

import math
import Tkinter as tk

# Screen resolution:
RESX = 800
RESY = 600

# Zoom-factor and Up/Down-correction:
XFAC = 70
XSUM = RESX // 2
YFAC = 60
YSUM = RESY // 2

class AgnesiWindow:
    def __init__(self):
        self.mw = tk.Tk()
        self.mw.option_add("*font", ("Arial", 12, "normal"))
        self.mw.title("Agnesi")
        self.mw.geometry("+90+45")
        self.cv = tk.Canvas(self.mw,
                            bg = "white",
                            width = RESX,
                            height = RESY)
        self.cv.pack()
        self.btn = tk.Button(self.mw,
                             text = "Ok",
                             command = self.mw.destroy)
        self.mw.bind(sequence = "<Key-space>", func = lambda k: self.pause())
        self.mw.bind(sequence = "<Return>", func = lambda k: self.mw.destroy())
        self.mw.bind(sequence = "<Control-q>", func = lambda k: self.mw.destroy())
        self.btn.pack(side = tk.RIGHT, padx = 10, pady = 10)
        self.angle = 130
        self.points = {"up"       : [math.cos(math.radians(270)),
                                     math.sin(math.radians(270))],
                       "down"     : [math.cos(math.radians(90)),
                                     math.sin(math.radians(90))],
                       "circle"   : [math.cos(math.radians(self.angle)),
                                     math.sin(math.radians(self.angle))],
                       "upline"   : [0, 0],
                       "downline" : [0, 0],
                       "curve"    : [0, 0]}
        self.withdraw = []
        self.drawStatic()
        self.calculatePoints()
        self.drawDynamic()
        self.running = -1
        self.mw.after(1000, self.run)
        self.mw.mainloop()

    def run(self):
        self.running = 1
        self.draw()

    def pause(self):
        self.running *= -1
        if self.running == 1:
            self.draw()
    
    def getZoom(self, point):
        return [point[0] * XFAC + XSUM, point[1] * YFAC + YSUM]
    
    def plotPoint(self, point):
        point = self.getZoom(point)
        self.cv.create_line(point[0], point[1], point[0] + 1, point[1] + 1)

    def plotDot(self, point, withdraw = False):
        point = self.getZoom(point)
        o = self.cv.create_oval(point[0] - 5, point[1] - 5,
                                point[0] + 5, point[1] + 5,
                                fill = 'black')
        if withdraw:
            self.withdraw.append(o)
            
    def drawLine(self, from_, to_, withdraw = False):
        from_ = self.getZoom(from_)
        to_ = self.getZoom(to_)
        self.withdraw.append(self.cv.create_line(from_[0], from_[1],
                                                 to_[0], to_[1]))
            
    def drawStatic(self):
        self.cv.create_line(0, self.points["up"][1] * YFAC + YSUM,
                            RESX, self.points["up"][1] * YFAC + YSUM) 
        self.cv.create_line(0, self.points["down"][1] * YFAC + YSUM,
                            RESX, self.points["down"][1] * YFAC + YSUM) 
        self.cv.create_oval((self.points["up"][0] - math.cos(math.radians(0))) * XFAC + XSUM,
                             self.points["up"][1] * YFAC + YSUM,
                             (self.points["up"][0] + math.cos(math.radians(0))) * XFAC + XSUM,
                             self.points["down"][1] * YFAC + YSUM)
        self.plotDot(self.points["down"], withdraw = False)

    def drawDynamic(self):
        self.drawLine(self.points["down"], self.points["upline"])
        self.drawLine(self.points["upline"], self.points["downline"])
        self.drawLine(self.points["curve"], self.points["circle"])
        self.plotDot(self.points["circle"], withdraw = True)
        self.plotDot(self.points["upline"], withdraw = True)
        self.plotDot(self.points["downline"], withdraw = True)
        self.plotDot(self.points["curve"], withdraw = True)
        self.plotPoint(self.points["curve"])

    def calculatePoints(self):
        self.points["circle"] = [math.cos(math.radians(self.angle)),
                                 math.sin(math.radians(self.angle))]
        # Strahlensatz:
        d = self.points["up"][1] - self.points["down"][1]
        a = self.points["circle"][1] - self.points["down"][1]
        b = self.points["down"][0] - self.points["circle"][0]
        self.points["upline"] = [self.points["down"][0] - d / a * b,
                                 self.points["up"][1]]
        self.points["downline"] = [self.points["upline"][0],
                                   self.points["down"][1]]
        self.points["curve"] = [self.points["upline"][0],
                                self.points["circle"][1]]
 
    def draw(self):
        if self.running == -1:
            return
        if self.angle <= 410:
            for i in self.withdraw:
                self.cv.delete(i)
            self.calculatePoints()
            self.drawDynamic()
            self.angle += 1
            self.mw.after(50, self.draw)
 
if __name__ == "__main__":
    app = AgnesiWindow()

Hat Spaß gemacht!

+2 replies
GwenDragon

2014-05-18 19:15

User since
2005-01-17
14746 Artikel
Admin1

Und wieso bitte ist das unter Anwendungen/Programme/Skripte in Perl · Allgemeines zu Perl?
Das ist doch kein Perl.

Oder sollen wird das jetzt umstricken? Rätselhaft.
Last edited: 2014-05-18 19:16:17 +0200 (CEST)
die Drachin Gwen

Meine Perl-Artikel · perldev – verschiedene Perl-Versionen unter Windows starten
- hlubenow
  
  2014-05-18 21:39
  
  User since
  2009-02-22
  875 Artikel
  BenutzerIn
  
  Keine Sorge, Perl kommt schon noch. ;)
  
  Ideen, was man mal so programmieren kann (vielleicht auch sowas wie "Projekt Euler") können doch ruhig nach "Allgemeines", finde ich.
  Umstricken braucht ihr nicht (wenn ihr nicht wollt), meist mach' ich das selbst, wenn die Zeit dafür da ist.
  Hier also noch eine Perl-Übersetzung meiner Version:
  more (44.4kb)
  Perl/Tk führt bei mir meist dazu, daß ich recht viele globale Variablen verwende, die dann in allen Funktionen bekannt sind. Wenn das Programm nicht wirklich groß ist, ist das vielleicht gar nicht so schlimm.
  Hier hab' ich auch die Daten (für die Punkte) in einer globalen Variable (HoA). Ist hier eigentlich ganz praktisch, obwohl globale Variablen allgemein ja eher verpönt sind ...
  
  modedit Editiert von pq: more-tag hinzugefügt
  Last edited: 2014-05-19 11:14:02 +0200 (CEST)
pq

2014-05-19 11:14

User since
2003-08-04
12208 Artikel
Admin1

Verschoben von Allgemeines zu Perl nach Projekte
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wie frage ich & perlintro brian's Leitfaden für jedes Perl-Problem

View all threads created 2014-05-18 01:58.