Turtle-Grafik mit Python 3.1 – Einführung Hardware und Software 1

Turtle-Grafik mit Python 3.1 – Einführung
Hardware und Software
Hardware:
Alle Computer bestehen aus folgenden Grundbausteinen:
Eingabegeräte (Tastatur, Maus, Scanner, Joystick, .....)
Zentraleinheit ( Rechenwerk, Steuerwerk, Arbeitsspeicher, ...)
Ausgabegeräte (Monitor, Drucker, Interface, ....)
Neben dem Hauptspeicher der Zentraleinheit (Arbeitsspeicher) benötigt man Speicher, mit deren Hilfe man Informationen (Daten) sichern kann:
USB-Stick mit USB-Port
Festplatte mit Festplattenlaufwerk
Diskette mit Diskettenlaufwerk
CDs mit CD-ROM-Laufwerk
und viele mehr
Man unterscheidet 2 Arten von Speichern:
Nur-Lese-Speicher : ROM (Read Only Memory)
z. B. für das Steuerprogramm des Computers, CDs.
Der Speicherinhalt lässt sich nicht verändern
Schreib-Lese-Speicher : RAM (Random Access Memory)
Hauptspeicher, Disketten, USB-Stick, Festplatte.
Daten können gelöscht und geändert werden.
Software:
Was bisher beschrieben wurde, sind die Geräte, die so genannte Hardware. Mit der Hardware
eines Computers alleine kann man nichts anfangen. Damit ein Computer arbeiten kann, benötigt man Software. Software ist das Programm, die Arbeitsmethode. Anwenderprogramme (z.
B. Textverarbeitungsprogramme) sind Programme, die der Benutzer für festgelegte Aufgaben
benutzen kann (Schreiben, Zeichnen, Spiele, ...). Wenn du den Computer für eigene Aufgaben
(Lernprogramme, Berechnungen, Spiele, ..) benutzen willst, brauchst du eine Programmiersprache, die diese Aufgaben dem Computer verständlich macht. Computer verstehen nur diese
eigens für sie geschaffenen Computersprachen.
Es gibt zahlreiche Programmiersprachen: Python, Delphi, Comal, Logo, BASIC, C, C++, Java,
PHP und viele mehr.
In diesem Kurs benutzt du die Programmiersprache Python 3.1.
Du kannst dir Python 3.1 kostenlos im Internet herunterladen, um auch zu Hause weiter zu programmieren:
http://www.python.org
Im Internet findest du auch zahlreiche Hilfen und Anleitungen.
Beim Programmieren erfährst du, dass der Computer ein „nimmermüdes Arbeitstier" ist und bekommst eine Vorstellung, wie Computerprogramme entstehen.
Dierk Schröder, 19.01.2011
1
Turtle-Grafik mit Python 3.1 – Einführung
Mit deinen Programmen kannst du Bilder erstellen, Berechnungen durchführen, Texte
bearbeiten lassen, Quizübungen durchführen, Spiele spielen u..v. m.
Zeichnen mit Turtle-Grafik
Die „Turtle“ ist eine programmierbare „Schildkröte“, die auf dem Boden hin- und herlaufen kann
und, falls der Zeichenstift abgesenkt ist, ihren zurückgelegten Weg aufzeichnet.
Starte Python, damit es losgehen kann.
IPI – Interaktiver Python Interpreter:
Du kannst sofort loslegen, wenn du in
der Eingabezeile deine Befehle eingibst.
Du gibst ein – Python gibt aus.
Damit du Turtle-Befehle benutzen kannst, musst du zuerst das Modul Turtle importieren.
>>> from turtle import *
>>> mode("logo")
# es werden alle Turtle-Methoden geladen
# 0° -> Nord, 90° -> Ost, rechtsdrehend
Es passiert zunächst scheinbar nichts. Ab jetzt kannst du im interaktiven Modus (IPI) die verfügbaren Turtle-Befehle ausprobieren und sofort das Ergebnis des Befehls beobachten.
Alle was hinter # steht, ist ein Kommentar und wird vom Programm nicht beachtet.
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
forward(200) #
right(90)
#
forward(100) #
right(90)
#
fd(200)
#
rt(90)
#
fd(100)
#
rt(90)
#
left(45)
#
back(50)
#
pu()
#
pd(-50,100)
#
down()
#
forward(200) #
circle(50)
#
pu()
#
fd(50)
#
down()
#
circle(50,90) #
lt(180)
#
circle(50,90) #
pd()
home()
#
pd()
setheading(90) #
gehe 200 Pixel vor
drehe dich um 90° nach rechts
gehe 100 Pixel vor
drehe dich um 90° nach rechts
gehe 200 Pixel vor
drehe dich um 90° nach rechts
gehe 100 Pixel vor
drehe dich um 90° nach rechts
drehe dich um 90° nach links
gehe 50 Pixel zurück
hebe den Stift an
gehe zum Punkt (-50,100)
senke den Stift ab
gehe 200 Pixel vor
zeichne einen Kreis mt dem Radius 50 Pixel
hebe den Stift an
gehe 50 Pixel vor
senke den Stift ab
zeichnet einen Bogen mit r=50 Pixel und Winkel=90°
drehe dich um 180° nach links
zeichnet einen Bogen mit r=50 Pixel und Winkel=90°
die Turtle springt in die Bildmitte (0|0)
die Turtle-Richtung wird auf 90° gesetzt.
IDLE – Befehle im Editor-Fenster eingeben:
Wähle File-New Window
Dierk Schröder, 19.01.2011
2
Turtle-Grafik mit Python 3.1 – Einführung
Jetzt kannst du die Befehle in einzelne Zeilen schreiben. Du erhältst dann eine Programmliste.
Diese Liste kannst du beliebig verändern, und damit das Ausgbebild nach deinen Wünschen
gestalten. Aber achte unbedingt auf die richtige Rechtschreibung (Syntax). Python verzeiht keine Schreibfehler. Die Fehlermeldungen kommen erst, wenn du das Programm startest.
Beginne dein erstes Programm mit folgenden Zeilen:
from turtle import *
mode('logo')
reset()
shape('turtle')
color('darkgreen')
width(2)
…..
…..
…..
#
#
#
#
#
Turtle zeigt bei 0° nach oben wie in Comal
Turtle wird in den Anfangszustand versetzt
statt des Dreiecks wird eine Turtle angezeigt
die Zeichenfarbe wird auf dunkelgrün gesetzt
die Linienbreite beträgt 2 Pixel
hier folgen jetzt die Befehle, die du schon oben ausprobiert hast. Du kannst die Befehlsliste beliebig verlängern und verändern, bis du mit deinem Bild zufrieden bist.
Achtung! Dies muss die letzte Zeile deines Programms sein:
mainloop()
Mit File-Save As kannst du dein Programm speichern.
Wähle für die Dateinamen immer die Dateiendung .py!
Mit File-Open kannst du gespeicherte Programme öffnen und später weiter bearbeiten.
Es gibt noch Methoden, mit denen du den Grafik-Bildschirm beeinflussen kannst:
clear()
reset()
bye()
# die Zeichnung der aktiven Turtle wird gelöscht
# die Turtle wird in den Anfangszustand versetzt
# das Turtlefenster wird geschlossen
Mit den bisherigen Befehlen kannst du schon sehr schöne Bilder erzeugen. Es fehlt aber noch
eine Methode, um Flächen auszufüllen:
color(red)
fillcolor('yellow')
begin_fill
fd(100)
rt(90)
fd(100)
rt(90)
fd(100)
rt(90)
fd(100)
rt(90)
end_fill
# setzt Zeichenfarbe auf rot
# setzt die Füllfarbe auf gelb
# hier beginnt das auszufüllende Viereck
# hier wird das geschlossene Viereck gefüllt
Wenn du dir die Zeichenschritte auf dem Grafikbildschirm in Ruhe ansehen willst, kannst du
das Zeichnen verlangsamen.
Dierk Schröder, 19.01.2011
3
Turtle-Grafik mit Python 3.1 – Einführung
speed(5)
delay(5)
tracer(1)
tracer(0)
#
#
#
#
0:am Schnellsten, 10: schnell, 1: langsam
Verzögerung in Millisekunden (0: schnell)
schaltet Animation ein
schaltet Animation aus
Relative Befehle:
Die Befehle
forward(x), backward(x), left(x), right(x), circle(r), circle(r,w)
bezeichnet man als relative Befehle, weil der Zeichenstift immer vom letzten Standort weiter
zeichnet.
Absolute Befehle:
Die Befehle
setheading(w) und goto(x,y)
bezeichnet man als absolute Befehle, weil der Zeichenstift unabhängig vom letzten Standort
bewegt wird.
Bitte beachte:
Dezimalbrüche (Kommazahlen) musst du immer mit Dezimalpunkt schreiben!
Beispiel: nicht 4,7 sondern 4.7
Wiederholungen
Du hast oben ein Quadrat programmiert und festgestellt, dass du viermal die folgenden Befehle
geschrieben hast:
fd(100)
rt(90)
Das gleiche Ergebnis erhältst du mit einer Schleife (Wiederholung).
for i in range(4):
# Beginn der Wiederholung. : nicht vergessen!
fd(100)
# wird viermal wiederholt
rt(90)
# wird viermal wiederholt
write('Die Wiederholung ist beendet')
Der Befehlsblock, der viermal wiederholt werden soll muss mit dem Tabulator gleichmäßig eingerückt werden.
range(4) ist eine Liste aus 4 Zahlen [0, 1, 2, 3]. Wenn die Liste durchlaufen wurde, ist
die Wiederholung beendet und der nächste Befehl wird ausgeführt.
i ist eine Variable, die den jeweiligen Listenwert von 0 bis 3 annimmt
for z in range(8):
fd(100)
rt(45)
print(z)
#
#
#
#
Beginn der Wiederholung. : nicht vergessen!
wird achtmal wiederholt
wird achtmal wiederholt
der Wert von z wird geschrieben
So geht’s auch:
Dierk Schröder, 19.01.2011
4
Turtle-Grafik mit Python 3.1 – Einführung
a = 1
# die Variable a erhält den Wert 1
while a<20:
# wiederhole solange wie a kleiner als 20 ist
fd(a*5)
# gehe 5*a Pixel vorwärts
rt(90)
a = a+1
# a wird um 1 vergrößert
write('Die letzte Zahl war: '+str(a))
Der Benutzer kann auch selber bestimmen, wie oft wiederholt werden soll.
ecken=textinput('Vieleck','Wie viele Ecken?')
# nur Ziffern eingeben
laenge=textinput('Eingabe','Seitenlänge?')
# nur Ziffern eingeben
anzahl=int(ecken)
# Umwandlung Text in ganze Zahl
s=int(laenge)
# Umwandlung Text in ganze Zahl (integer)
begin_fill()
for z in range(anzahl):
fd(s)
rt(360/anzahl)
write(z)
fillcolor('yellow')
end_fill()
name=textinput('Polygon','Wie heißt das Vieleck?')
rt(90)
pu()
fd(s)
write(name)
home()
pd()
Neue Befehle erfinden
Wenn du das Quadrat mit einem einzigen Befehl zeichnen möchtest kannst du die Methode
selber definieren. Python lernt einen neuen Befehl quadrat(), den du wie alle anderen Python-Befehle innerhalb des Programms benutzen kannst.
Denke unbedingt an die (leere) Klammer und die Doppelpunkte, sonst funktioniert es nicht.
def quadrat():
for i in range(4):
fd(100)
rt(90)
Mit dem folgenden Befehl wird diese Methode ausgeführt:
quadrat()
Noch besser geht es so:
def quadrat(a):
for i in range(4):
fd(a)
rt(90)
Mit dem Befehl
quadrat(50)
wird ein Quadrat mit 50 Pixel Seitenlänge gezeichnet.
Dierk Schröder, 19.01.2011
5
Turtle-Grafik mit Python 3.1 – Einführung
Hier siehst du, wie man den Befehl quadrat(s) einsetzen kann.
def muster():
for i in range(1, 10):
quadrat(i*10)
range(1,10) erzeugt die Liste [1, 2, 3, …, 9] mit 9 Zahlen.
Die Seitenlänge des Quadrats wird in jeder Runde verzehnfacht. (10, 20, 30, …;90)
Python kann auch würfeln
Wenn du Zufallszahlen erzeugen willst benötigst du die Befehlserweiterung random:
from random import *
# es werden alle Zufalls-Methoden geladen
for i in range(20):
x=randint(1,2)
y=randint(3,4)
print('x=',x,sep='',end=' ')
print('y=',y,sep='')
Ein gut strukturiertes Programm besteht im Wesentlichen aus einzelnen Methodendefinitionen
die bestimmte Teilaufgaben erledigen und überall im Programm zur Verfügung stehen.
Der Aufruf einer neuen Methode def …(): muss unterhalb der Methodendefinition stehen.
Turtle-Befehle
Bewegung und Zeichnen
forward(40), fd(40)
die Turtle zeichnet 40 Pixel vorwärts
back(30), bk(30)
die Turtle bewegt sich rückwärts und zeichnet
right(90), rt(90)
dreht die Turtle um 90° weiter nach rechts
left(60), lt(60)
dreht die Turtle um 60° weiter nach links
circle(30)
zeichnet einen Kreisbogen links mit dem Radius 30 Pixel
circle(20,90)
zeichnet einen Kreisbogen nach links mit einem Radius von 20
Pixel und einem Winkel von 90°
write('Hallo Welt',
font=('Arial', 16))
Schreibt Hallo Welt in Schriftart Arial und Schriftgröße 16 an der
aktuellen Position
dot(3,’red’)
zeichnet einen Punkt mit dem Durchmesser 3 Pixel und der Farbe rot an der aktuellen Position
goto(100,200),
setpos(100,200)
setzt die Turtle auf den Punkt (100|200) und zeichnet
setheading(270),
seth(270)
dreht die Turtle auf 270° (West), unabhängig von dem vorher
eingestellten Winkel.
pu(), up()
der Zeichenstift wird hochgenommen. (die Turtle bewegt sich
danach ohne zu zeichnen)
pd(), down()
der Zeichenstift wird heruntergesetzt. Die Turtle zeichnet wieder.
Dierk Schröder, 19.01.2011
6
Turtle-Grafik mit Python 3.1 – Einführung
hideturtle(), ht()
Turtle wird unsichtbar
showturtle(), st()
Turtle wird sichtbar
s1=stamp()
stempelt den Umriss der Turtle an der aktuellen Position. Stempelname ist s1
clearstamp(s1)
löscht Stempel s1
clearstams(n)
lösche alle, die ersten, die letzten von n Stempeln. Wenn die
Klammer leer ist, werden alle gelöscht. Wenn n > 0 werden die
ersten n Stempel, sonst die letzten n Stempel gelöscht
Position und Winkel bestimmen
position(), pos()
gibt die (x|y)-Koordinaten der Turtle zurück
towards(x,y)
gibt den Abstand bis zum Punkt (x|y) zurück
xcor()
gibt die x-Koordinate der Turtle zurück
ycor()
gibt die y-Koordinate der Turtle zurück
heading()
gibt den Winkel der Turtle zurück
distance(x,y)
gibt den Abstand der Turtle zum Punkt (x|y) zurück
Farben, Füllung, Aussehen
width(3), pensize(3)
setzt Linienbreite auf 3 Pixel
color('red','yellow')
die Zeichenfarbe ist rot, die Hintergrundfarbe ist gelb
fillcolor('blue')
die Hintergrundfarbe wird auf blau gesetzt.
begin_fill
färbt folgende geschlossene Fläche mit aktueller Hintergrundfarbe aus.
end_fill
färbt vorher geschlossene Fläche mit angegebener Farbe.
bgcolor('pink')
die Hintergrundfarbe wird auf pink gesetzt
bgpic('dateipfad')
es wird ein Bild als Hintergrund geladen
shape('turtle')
legt das Aussehen der Turtle fest ('arrow', 'turtle', 'circle', 'square', 'triangle', 'classic').
Grafikbilschirm
setworldcoordinates
(-10,-10,10,10)
legt das Koordinatensystem der Zeichenfläche auf die entsprechenden Koordinaten fest.
(Gibt u. a. Probleme mit circle(20,90))
title("Willkommen im
Turtlezirkus!")
Titelzeile im Grafikfenster
setup(width=200,
height=200, startx=0,
starty=0)
Das Grafikfenster wird auf die angegebenen Werte eingestellt.
bye()
schließt das Grafikfenster
clear()
löscht die Zeichnung der Turtle z. B. paula.clear()
clearscreen()
löscht den Grafikbildschirm
Dierk Schröder, 19.01.2011
7
Turtle-Grafik mit Python 3.1 – Einführung
Aktionen mit Maus und Tasten
listen()
setzt den Focus auf das Fenster, um auf Maus und Tastatur zu
reagieren.
onkey(funk,'T')
funk wird ausgeführt wenn Taste 'T' gedrückt wird
onkeyrelease(funk,'T') funk wird ausgeführt wenn Taste 'T' losgelassen wird
onkeypress(funk,['T']) funk wird ausgeführt solange (irgendeine) Taste gedrückt wird
onscreenclick(funk)
funk wird ausgeführt, wenn der Bildschirm angeklickt wird
onclick(test)
beim Klicken auf die Turtle wird test(x|y) mit den Mauskoordinaten (x|y) ausgeführt.
Die aufgerufene Prozedur muss so aussehen def test(x,y):
onrelease(test2)
test2(x|y) wird beim Loslassen mit den Mauskoordinaten (x|y)
ausgeführt. def test2(x|y):
ondrag(test3)
test3(x|y) wird beim Ziehen mit den Mauskoordinaten (x|y) ausgeführt. def test3(x|y):
auch: ondrag(goto)
Variable und Co.
a=2
weist der Variablen a den Wert 2 zu.
fd(3*a)
zeichnet eine Linie mit 6 Einheiten, wenn a gleich 2 ist
a+=3 oder a-=3
vergrößert (verkleinert) den Wert der Variablen a um 3.
Wenn a gleich 2 ist, dann wird a=5 bzw. a=-1)
x=a**3
weist der Variablen x den Wert a³ zu. Wenn a=2 dann ist x=8
z=randint(1,6)
vorher das Modul random importieren:
from random import *
z bekommt als Wert eine Zufallszahl zwischen 1 und 6 (würfeln)
y:=3x+2
es können beliebige Formeln als Zuweisung gewählt werden
zahl_str =
textinput('Gib eine
Zahl ein:')
Du kannst in einem Dialog einen beliebigen Text eingeben.
kommazahl =
float(zahl_str)
Wenn der Text aus Ziffern besteht, wird der Text in eine Kommazahl (float) umgewandelt.
zahl = int(zahl_str)
Wenn der Text aus Ziffern besteht, wird der Text in eine ganze
Zahl (integer) umgewandelt.
Du benötigst schnell alle Informationen zu einem Befehl? Gib an der Eingabeauforderung
help(Befehl) ein:
>>>
>>>
>>>
>>>
>>>
>>>
from turtle import *
help(shape)
help(bgcolor)
help (mode)
help(bgpic)
help(Turtle)
Fehlerbehandlung
Dierk Schröder, 19.01.2011
8
Turtle-Grafik mit Python 3.1 – Einführung
Trotz sorgfältiger Programmierung kann es zu so genannten Laufzeitfehlern kommen.
Wenn vom Benutzer z. B. eine ganze Zahl eingegeben werden soll und eine Kommazahl (float)
oder ein Text (string) eingegeben wird.
zahl = numinput('Eingabe','Gib eine ganze Zahl ein:',5,1,10)
try:
speed(zahl)
# wenn hier abgebrochen wird …
except:
speed(5)
# … geht's hier weiter
Lust auf ein Spiel?
Du kannst den Quelltext im Internet herunterladen:
http://igs-hassee.lernnetz.de/Silverstripe/Informatik (CatchMe.py)
# Catch me if you can! Paula fängt Horst, du fängst Paula.
from turtle import *
from random import *
mode('logo')
level = numinput("Fang' Paula!",'Wähle Level (1-10):',5,1,10)
try:
delay(10-int(level))
except:
delay(5)
pu()
goto(300,-250)
rt(45)
pd()
begin_fill()
fillcolor('pink')
circle(400,360,4)
end_fill()
color('black','green')
pu()
goto(-50,300)
pd()
write('Catch me if you can! Paula fängt Horst, du fängst Paula')
ht()
pd()
def main(x,y):
# x|y ist nötig, um Mauskoordinaten zu
paula = Turtle()
# übergeben
paula.shape('turtle')
paula.color('red','yellow')
paula.pu()
paula.goto(-250,290)
paula.pd()
horst = Turtle()
horst.shape("turtle")
horst.reset()
Dierk Schröder, 19.01.2011
9
Turtle-Grafik mit Python 3.1 – Einführung
horst.pu()
horst.goto(180,290)
horst.pd()
horst.color("black","darkgreen")
paula.seth(towards(horst))
horst.seth(randint(180,270))
horst.stamp()
paula.stamp()
count = 1
geschafft=False
def start(mx,my):
paula.clear()
main(1,2)
# mx|my für Mauskoordinaten
def gefangen(mx,my):
if not geschafft:
paula.write('Super, du hast Paula erwischt!')
else:
paula.write('Das zählt ja wohl nicht?!')
onclick(start)
# Mauskoordinaten werden
paula.onclick(gefangen)
# automatisch übergeben
while paula.distance(horst) > 4:
horst.fd(randint(3,7))
horst.lt(randint(-20,40)/10)
paula.setheading(paula.towards(horst))
paula.fd(randint(1,10))
if count % 20 == 0:
horst.stamp()
paula.stamp()
count += 1
if horst.ycor()<-260 or horst.xcor()>310:
horst.write('Puh, geschafft!')
paula.write('Mist, entwischt!')
geschafft=True
break
if not geschafft:
horst.write("Erwischt!",font=("Arial",14,"bold")")
pu()
goto(-200,-200)
shape('circle')
write(' Noch einmal? Hier klicken')
pd()
st()
#****** end_main *********
main(1,2)
# 1 und 2 sind "Dummyzahlen"
mainloop()
Dir fällt sicher noch eine Menge ein, um dieses Spiel zu erweitern.
Dierk Schröder, 19.01.2011
10
Turtle-Grafik mit Python 3.1 – Einführung
Programmbeispiele I
Deine Bildschirmausgabe kann von den Beispielbildern abweichen, weil dort andere Koordinaten eingestellt sind.
#Quadratmuster
from turtle import *
mode('logo')
x=-150
y=-150
for i in range(5):
pu()
goto(x,y)
pd()
for i in range(4):
fd(20)
rt(90)
x+=30
y+=30
mainloop()
# Methoden
from turtle import *
from random import *
mode('logo')
def
schild():
fd(80)
begin_fill
rt(90)
circle(20)
lt(90)
fillcolor('red')
end_fill
bk(80)
def schildmuehle():
n=randint(4,20)
for i in range(n):
schild
rt(360/n)
schildmuehle()
mainloop()
Dierk Schröder, 19.01.2011
11
Turtle-Grafik mit Python 3.1 – Einführung
Programme mit Wiederholungen
Schreibe Programme, die folgende Bilder zeichnen:
Dierk Schröder, 19.01.2011
12
Turtle-Grafik mit Python 3.1 – Einführung
Programmbeispiele II
Ändere die Befehlszeilen so um, dass die Prozeduren mit Python 3.1 funktionieren.
löschen
x:=0
y:=0
seite:=2
anzahl:=5
siedlung
ht
proc quadrat
repeat(4)
fd(Seite)
rt(90)
end
endproc
proc dreieck
repeat(3)
fd(seite)
rt(120)
end
endproc
proc baum
pw(seite*10)
pc(brown)
fd(seite)
pw(1)
pc(green)
lt(90)
bogenr(seite/3,360)
rt(90)
pu
fd(seite/3/2)
fill(green)
bk(seite/3/2)
bk(seite)
pd
pc(darkblue)
endproc
Dierk Schröder, 19.01.2011
proc haus
quadrat
pu
fd(seite)
pd
rt(30)
dreieck
lt(30)
pu
bk(seite)
pd
endproc
proc Straße
repeat(Anzahl)
mt(x,y)
haus
pu
lt(90)
fd(seite/4)
rt(90)
pd
baum
lt(90)
pu
bk(seite/4)
rt(90)
pd
x:=x+seite+seite/1.5
y:=y+seite+seite/2
end
endproc
proc Siedlung
repeat(10)
seite:=zufall(1,20)/10
anzahl:=1
straße
end
endproc
13
Turtle-Grafik mit Python 3.1 – Einführung
Schreibe Prozeduren für die folgenden Bilder:
Dierk Schröder, 19.01.2011
14
Turtle-Grafik mit Python 3.1 – Einführung
Schreibe Programme für folgende Bilder:
Dierk Schröder, 19.01.2011
15