lehrkraefte:blc:informatik:glf22:turtle [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Grundlagen mit Turtle ======

Grundidee: Ein Schildkröte (Turtle) befindet sich auf dem Bildschirm an einer bestimmten Position $(x,y)$ und schaut in eine bestimmte Richtung (festgelegt durch einen Winkel $\alpha$ wie im Einheitskreis).

Die Turtle kann sich vorwärts bewegen (''forward'') dabei zeichnen (oder nicht mit ''move'') und sich drehen mit ''left'' oder ''right''.

Damit können recht einfach spannende Grafiken gezeichnet werden.

===== Setup =====
Legen Sie einen neuen Ordner an (z.B. mit dem Namen 'turtle').

Speichern Sie darin folgende minimale Turtleklasse: {{lehrkraefte:blc:informatik:glf22:kroete.py}}

Speichern Sie im gleichen Ordner folgendes Test-Programm: {{lehrkraefte:blc:informatik:glf22:turtletest.py}}

Testen Sie das Test-Programm und versuchen Sie es zu verstehen.

===== Mathematik hinter der Turtle =====
Soll von einem Punkt $(x,y)$ weiter in die Richtung vom Winkel $\alpha$ gegangen werden, muss also in die Richtung vom Vektor
$\begin{pmatrix}\cos(\alpha)\\ \sin(\alpha) \end{pmatrix}$ gegangen werden. Dieser Vektor entspricht der Verschiebung des Nullpunkts zum Punk $P_{\alpha}$ auf dem Einheitskreis.

Wenn die Schrittlänge $r$ ist, reicht es, beide Einträge vom Vektor mit $r$ zu multiplizieren. Der neue Punkt hat also die Koordinaten
$$
\left(x + r \cdot \cos(\alpha),\,\, y+ r \cdot \sin(\alpha)\right)
$$

<WRAP todo>
Finden Sie den der obigen Formel ensprechenden Python-Code in der Datei ''kroete.py''.
</WRAP>

==== Aufgaben ====
<WRAP todo>
  * Ändern Sie den Code in ''turtletest.py'' so ab, dass anstatt des Dreiecks ein blaues Quadrat gezeichnet wird.
</WRAP>

===== For-Schlaufen =====
Mit For-Schlaufen werden Programmblöcke wiederholt. Dabei wird eine **Laufvariable** hochgezählt (bzw. läuft die Werte in einer Liste durch).
<code python>
for i in range(10):     # 10 Wiederholungen, i läuft von 0 bis und mit 9
  print(i)
  if i%2 == 0:          # i%2 ist der Rest der Division durch zwei, also 0 oder 1.
     print("gerade")
     
print("Das wird nicht wiederholt")
</code>
[[lehrkraefte:blc:informatik:glf22:python:intro#for-loop|Mehr Beispiele dazu]]

<WRAP todo>
Schreiben Sie je ein Programm mit For-Schleifen, das mit der Turtle folgende Dinge zeichnet:
  * Ein regelmässiges 12-Eck
  * Ein 5-Zack-Stern
  * Ein regelmässiges $n$-Eck, wobei $n$ als Variable am Anfang im Code festgelegt werden kann.
  * Ein $n$-Zack-Stern, wobei $n$ als Variable am Anfang im Code festgelegt werden kann.
  * Bonus-Aufgabe: Zentrieren Sie das $n$-Eck bzw. den $n$-Zack-Stern.
Für die Bonus-Aufgabe wird wohl der Radius vom $n$-Eck benötigt (oder umgekehrt die Seitenlänge aus dem Radius berechnet). Dazu werden die trigonometrischen Funktionen gebraucht:
<code python>
# Die Funktionen Cosinus und Sinus sowie die Konstante pi importieren
from math import cos,sin,pi

w=30
print(f"cos({w})={cos(w/180*pi)}, sin({w})={sin(w/180*pi)}")
</code>

<hidden Lösungsvorschläge>
<code python 12-eck.py>
from kroete import Kroete

t = Kroete()

for i in range(12):
    t.forward()
    t.left(30)

</code>
<code python 5zack.py>
from kroete import Kroete

t = Kroete()

for i in range(5):
    t.forward(200)
    t.left(144)
</code>
<code python n-eck.py>
from kroete import Kroete

n=7

t = Kroete()
for i in range(n):
    t.forward()
    t.left(360/n)

</code>
<code python n-zack.py>
from kroete import Kroete

n=11              # Anzahl Zacken
m=4   # Wie viele Zacken vorwärts (darf kein Teiler von n sein!)

t = Kroete()
for i in range(n):
    t.forward(200)
    t.left(m*360/n)
</code>
</hidden>
</WRAP>

===== Funktionen =====
Wie bereits gesehen, bieten sich Funktionen an, ein Programm in kleine Unterprogramme zu zerlegen.

Funktionen können (müssen aber nicht) mit ''return'' Werte zurückgeben. Ein ''return'' beendet die Funktion sofort.

Funktionen können beliebig viele Parameter (bzw. Argumente) entgegennehmen.

Beispiel:
<code python>
from kroete import Kroete

# Definition der Funktion quadrat, wird nicht direkt ausgeführt.
def quadrat(schildi, s):
    """Zeichnet ein Quadrat mit der Turtle schildi und Seitenlänge s"""
    for i in range(4):
        schildi.forward(s)
        schildi.left(90)

t = Kroete()
# Aufruf der Funktion. schildi wird dann zu t, s zu 200
quadrat(t, 200)
</code>

<WRAP todo>
Mit Hilfe der oben definierten Funktion ''quadrat'' erstellen Sie (in ungefähr) folgendes Bild (lässt sich in etwa 3 zusätzlichen Zeilen realisieren):


{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-091916.png?400}}

Oder mit einer zusätzlichen Zeile kann noch die Farbe berechnet werden, mit ''t.rgb(rot, gruen, blau)'', wobei ''rot'', ''gruen'' und ''blau'' ganze Zahlen zwischen 0 und 255 sind:

{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-093411.png?200}}
</WRAP>

==== Kreis ====
Folgende Funktion zeichnet Kreise wobei der Mittelpunkt der aktuellen Position der Turtle entspricht:
<code python>
def kreis(schildi, r):
    schildi.save()  # Zustand speichern
    n = int(r)  # Anzahl Segmente
    w = 2*pi/n  # Winkelschritt
    s = r*sqrt(sin(w)**2+(1-cos(w))**2)  # Segmentlänge
    schildi.move(r)
    schildi.left(90)
    for i in range(n):
        schildi.forward(s)
        schildi.left(360/n)
    schildi.restore()  # Zustand wieder herstellen

</code>

<WRAP todo>
  * Mathematisch gesprochen, was genau zeichnet die Funktion Kreis?
  * Was genau ist die Segmentlänge und woher kommt diese Formel? Begründen Sie mit einer guten Skizze (//Die Herleitung gäbe ein wunderbare Trigo-Prüfungsaufgabe//).
</WRAP>

===== Rekursion =====
Rekursion nennt man etwas, das mit sich selbst definiert wird (plus noch etwas, um zu beginnen). In der Informatik heisst das meist, dass sich eine Funktion selbst wieder aufruft. Dabei muss natürlich peinlichst darauf geachtet werden, dass sich die Funktion nicht unendlich oft selbst wieder aufruft.

==== Koch-Kurve ====
Die Koch-Kurve ist eine rekursiv definierte Kurve. 
  * Auf Stufe 0 ist die Kurve einfach eine Gerade
  * Auf Stufe 1 ist die Kurve aus 4 gleich langen Geradenstücken aufgebaut, mit entsprechenden Winkeln
  * Auf Stufe $n$ besteht die Kurve 4 Stücken der Stufe $n-1$, mit entsprechenden Winkeln dazwischen.

{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-102047.png}}

<WRAP todo>
  * Schreiben und testen Sie eine Funktion ''koch0'', die eine Koch-Kurve der Stufe 0 zeichnet, also einfach eine Gerade. Als Argumente nimmt die Funktion eine Turtle und die Gesamtlänge entgegen.
  * Schreiben und testen Sie eine Funktion ''koch1'', die eine Koch-Kurve der Stufe 1 zeichnet und dabei die Funktion ''koch0'' aufruft. Als Argument nimmt die Funktion eine Turtle und die die Gesamtlänge entgegen. Die Länge einer ''koch0''-«Kurve» muss dann aus der Gesamtlänge berechnet werden.
  * Schreiben Sie dann eine Funktion ''koch2'', die eine Koch-Kurve der Stufe 2 zeichnet (und die natürlich die Funktion ''koch1'' benutzt). Ebenfalls gleiche Argumente.
  * Wie unterscheiden sich die Funktionen ''koch2'' und ''koch1''?
  * Anstatt jetzt noch eine Funktion ''koch3'' zu schreiben, schreiben Sie eine Funktion ''koch'', die einen zusätzlichen Parameter ''stufe'' entgegen nimmt. Ist die ''stufe'' Null, wird ein einzelner Strich gezeichnet und dann die Funktion mit ''return'' beendet. Ansonsten wird 4 mal die Funktion ''koch'' mit ''stufe-1'' aufgerufen und dazwischen entsprechend gedreht.
  * Zusatzaufgabe: Zeichnen Sie 3 Koch-Kurven auf einem gleichseitigen Dreieck, dass damit die «Kochschneeflocke» entsteht.

{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-103525.png}}

</WRAP>


==== Pythagorasbaum ====

{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-105500.png}}

<WRAP todo>
Um diesen Baum zu zeichnen, erstellen Sie erst eine Funktion ''element'', die folgendes Bild zeichnet:

{{:lehrkraefte:blc:informatik:glf22:pasted:20230112-111635.png}}

Die Funktion nimmt folgende Parameter entgegen:
  * Eine Turtle ''t''. Diese legt die Richtung und die Länge vom Quadrat als ''t.r'' fest.
  * Einen Winkel ''w'', der dem «linken» Winkel des rechtwinkligen Dreiecks entspricht.
  * Die Turtle startet bei «Start» und muss am Ende bei «Ende» sein. Die Schrittlänge ''t.r'' soll am Schluss unverändert sein.
  * Sie können dazu auch die Turtle-Methoden ''save'' und ''restore'' verwenden, um sich die Position und Zustand der Turtle zu merken.

Hinweis: Sie können die Kathetenlängen mit trigonometrischen Funktionen aus ''w'' und ''t.r'' berechnen. 

</WRAP>

<WRAP todo>
Erweitern Sie Ihre Funktion so, dass ein zusätzlicher Parameter ''stufe'' entgegengenommen wird.
  * Ist die ''stufe'' Null, macht die Funktion immer noch das genau gleiche.
  * Sonst wird anstelle des Zeichnens der Katheten die Funktion selbst mit ''stufe-1'' aufgerufen, der Rest bleibt sich geich.
  * Probieren Sie verschiedene Winkel aus.
  * Anstatt die ''stufe'' als Abbruchkriterium zu verwenden, verwenden Sie ''t.r'', d.h. sobald die zu zeichnende Strecke z.B. kleiner als 3 ist, wird abgebrochen. So werden alle Äste bis zu einer sinnvollen Tiefe gezeichnet.
  * Man erhält einen interessanten Baum, wenn man statt einen konstanten Winkel ''w'' zu verwenden, zwischen ''w'' und ''90-w'' abwechselt, bzw. den je nach Stufe anpasst (z.B. als Schwingung ;-))
</WRAP>

<hidden Lösungsvorschlag>
<code python>
from kroete import Kroete
from math import cos,sin,pi



def baum(t, winkel, stufe):
    t.save()
    for i in range(4):
        t.forward()
        t.left(90)
    t.left(90)
    t.move()
    a = cos(winkel/180*pi)*t.r
    b = sin(winkel/180*pi)*t.r
    t.right(90-winkel)
    t.r = a
    if stufe==0 or (stufe<0 and t.r<3):
        t.forward()
    else:
        baum(t, winkel, stufe-1)
    t.right(90)
    t.r = b
    if stufe==0 or (stufe<0 and t.r<3):
        t.forward()
    else:
        baum(t, winkel, stufe-1)
    t.restore()
    t.move()



t = Kroete()
t.y = -200
t.x = 50
t.r = 110
baum(t, 30, -1)
</code>
</hidden>