Tutorial: Wir basteln uns einen Funktionenplotter in Processing.py

Einen einfachen Funktionenplotter in Processing.py, dem Python-Mode von Processing, zu zeichnen, ist ziemlich einfach und in wenigen Zeilen Code erledigt. Zuerst habe ich – zur besseren Orientierung – den Hintergrund mit einem Ratser hinterlegt, wie ich es hier auch schon einmal angestellt hatte und mit translate(width/2, height/2) den Nullpunkt des Koordinatensystems in die Mitte des Fensters gelegt.

Jetzt ist eigentlich nur noch zu berücksichtigen, daß in einem kartesischen Koordinatensystem, wie wir es aus der Schule kennen, die positiven y-Werte von der Null-Linie aus nach oben gehen und nicht, wie in der Computergraphik (und damit auch in Processing) üblich, von der Null-Linie nach unten. Das habe ich damit behoben, daß ich den Skalierungsfaktor yscale mit -1 multipliziert und so die Richtung umgekehrt habe.

Der Rest ist Spielerei: Die eigentlichen Funktionen (in diesem Fall Sinus und Cosinus) habe ich in eine eigene Funktion (graphFunction()) ausgelagert, so daß man – wenn man andere Funktionen zeichnen will – Änderungen im Prinzip nur hier vornehmen muß. Wenn man die Fenstergröße ändert, muß man natürlich auch die Wertepaare [xmin, xmax] und [ymin, ymax] anpassen.

Hier der komplette Quellcode:

import math

# Range of x-values
xmin = -6
xmax = 6

# Range of y-values
ymin = -2
ymax = 2

# Calculate the range
rangex = xmax - xmin
rangey = ymax - ymin

def setup():
    global xscl, yscl
    size(600, 200)
    this.surface.setTitle("Sinus und Cosinus")
    xscl = width/rangex
    yscl = -height/rangey

def draw():
    global xscl, yscl
    background(255)
    translate(width/2, height/2)
    grid(xscl, yscl)
    graphFunction()

def graphFunction():
    x = xmin
    while x <= xmax:
        stroke(255, 0, 0)
        line(x*xscl, math.sin(x)*yscl, (x + 0.1)*xscl, math.sin(x + 0.1)*yscl)
        stroke(255, 0, 255)
        line(x*xscl, math.cos(x)*yscl, (x + 0.1)*xscl, math.cos(x + 0.1)*yscl)
        x += 0.1
        
def grid(xscl, yscl):
    strokeWeight(1)
    stroke(0, 255, 255)   # Cyan
    for i in range(xmin, xmax + 1):
        line(i*xscl, ymin*yscl, i*xscl, ymax*yscl)
    for i in range(ymin, ymax + 1):
        line(xmin*xscl, i*yscl, xmax*xscl, i*yscl)
    stroke(0)
    line(0, ymin*yscl, 0, ymax*yscl)
    line(xmin*xscl, 0, xmax*xscl, 0)

Das letztens hier im Blog Kritzelheft vorgestellte Buch »Math Adventures with Python« von Peter Farrell motiviert mich mehr und mehr. Ihr dürft also in der nächsten Zeit noch mehr darüber hier erwarten – sei es in Processing.py, sei es mit Pythons Turtlegraphik oder sei es mit der Matplotlib. Still reading and digging!

(Kommentieren)