Sierpinski-Dreieck
Ein Sierpinski-Dreieck (nach Wacław Sierpiński) ist ein Fraktal, das durch fortgesetzte rekursive Aufteilung eines Vorgängerdreiecks in vier weitere (zueinander kongruente) Dreiecke erhalten wird, die dem Ausgangsdreieck ähnlich im mathematischen Sinne sind. Geht gegen unendlich, spricht man von einer Sierpinski-Fläche. Die fraktale Dimension der Sierpinski-Fläche beträgt , also zwischen Gerade () und Fläche ().
Konstruktion
Zur Darstellung des Sierpinski-Dreiecks wird als Ausgangsdreieck meist ein gleichseitiges Dreieck gewählt; das ist nicht zwingend, jedes beliebige Dreieck kann in ein Sierpinski-Dreieck zerlegt werden.
Der "klassische" Algorithmus, der zur grafischen Demonstration des Fraktalbegriffs verwendet wird, ist folgender:
- Zeichne ein Dreieck ("Initiator")
- Verbinde die Mittelpunkte der Seiten ("Generator") (dadurch wird das ursprüngliche Dreieck in vier deckungsgleiche Teildreiecke zerlegt)
- Entferne das mittlere der vier Teildreiecke (die anderen drei Teildreiecke bleiben übrig)
- Wende Schritte 2 und 3 auf die drei übriggebliebenen Teildreiecke an. usw.
Dieser Algorithmus verdeutlicht den Zusammenhang. Es entstehen bei jedem Iterationsschritt an den Ecken drei (zum Initiator ähnliche) Dreiecke mit halber Seitenlänge und einem Viertel der Fläche, die gefärbt werden. Das vierte "innere" kleine Dreieck, welches dabei entsteht, kann man sich als aus der Dreiecksfläche des vorhergehenden Schritts "herausgeschnitten" vorstellen.
Das eigentliche Sierpinski-Dreieck im streng mathematischen Sinn ist das Grenzobjekt, das nach unendlich vielen Iterationsschritten übrigbleibt. Es besteht aus unendlich vielen "Eckpunkten". Zur Darstellung, die meist mit rekursiven Computerprogrammen realisiert und nach Bedarf auf einem Bildschirm angezeigt oder ausgedruckt wird, reicht meist schon eine Iterations- oder Rekursionstiefe von höchstens zehn. Bedingt durch die Auflösung des darstellenden Mediums (Monitor, Drucker etc...) und des menschlichen Auges sind diese Gebilde vom Grenzobjekt nicht mehr zu unterscheiden. In klassischer planimetrischer Flächenmessung geht die Fläche mit zunehmender Iterationstiefe gegen null.
Mathematische Zusammenhänge
Als klassisches Fraktal, insbesondere mit einem gleichseitigen Dreieck als Initiator, ist das Sierpinski-Dreieck ein Musterbeispiel für exakte Selbstähnlichkeit: Die in jedem Schritt erzeugten Teildreiecke sind verkleinerte exakte Kopien des Ausgangsdreiecks. Jede Skalierung eines beliebigen Teils des Grenzobjekts erscheint wie das Gesamtobjekt selbst. Es ist somit skaleninvariant.
Von den zugrundeliegenden mathematischen Gesetzmäßigkeiten her ist das Sierpinski-Dreieck eng verwandt mit der Cantor-Menge. Es hat die reziproke fraktale Dimension derselben, nämlich . Dies resultiert daraus, dass bei jedem Schritt genau neue Teildreiecke mit der Seitenlänge erzeugt werden. Das Grenzobjekt entsteht, wenn gegen unendlich geht, und es kann daher als "geometrisches Äquivalent" zu einem Grenzwert (Limes) aufgefasst werden. Aus der Bildungsvorschrift lässt sich auch berechnen, welche Punkte der ursprünglichen Fläche zum Grenzobjekt gehören.
Darstellung mittels Hutchinson-Operator
Ein Sierpinski-Dreieck lässt sich auch als Attraktor eines dynamischen Rückkopplungsprozesses, eines so genannten deterministisch iterierten Funktionensystems mit geeigneten Parametern aus nahezu jeder beliebigen geometrischen Figur darstellen. Dabei werden wiederholt Mehrfach-Transformationen des Ausgangsobjekt vorgenommen, diese Bilder mit einer Abbildungsvorschrift, dem Hutchinson-Operator, entsprechend angeordnet und diese Prozedur erneut auf das entstandene Gesamtbild angewandt usw. Mit zunehmender Iterationstiefe streben die entstehenden Bilder, falls geeignete Parameter gewählt wurden, einem Sierpinski-Dreieck zu, das in diesem Falle der Attraktor des Funktionensystems ist.
Sierpinski-Schwamm
Eine Darstellung des Sierpinksi-Dreiecks ist, analog zum Menger-Schwamm, auch in der dritten Dimension möglich: Der Initiator ist ein Tetraeder. Aus diesem wird als Iterationsschritt aus der Mitte ein Oktaeder mit halber Kantenlänge herausgeschnitten. Übrig bleiben vier Tetraeder, aus denen wieder je ein Oktaeder herausgeschnitten wird, usw. Die Dimension für dieses Gebilde ist D=log(4)/log(2)=2, obwohl es sich hierbei um eine Figur im dreidimensionalen Raum handelt. Mit einer zunehmenden Zahl von Iterationsschritten geht das Volumen der Figur gegen 0; die Oberfläche bleibt jedoch konstant.
|
|
|
|
|
|
|
| |
| Stufe | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
Chaos-Spiel
Abgesehen von der rekursiven Darstellung gibt es noch einen Zufallspunkt-Algorithmus zur näherungsweisen Konstruktion des Sierpinski-Dreiecks: Das Chaos-Spiel.
Dabei wird ein gleichseitiges Dreieck mit den Ecken A, B, C aufgezeichnet und ein zufälliger Punkt im Inneren des Dreiecks gewählt (er kann aber auch außerhalb liegen, ohne das Ergebnis wesentlich zu verändern). Nun wird pro Schritt eine Ecke zufällig ausgewählt (die Wahrscheinlichkeit für die Ecken sind gleich) und der Punkt gedanklich mit der gezogenen Ecke verbunden. Die Mitte dieser Strecke markiert nun den Punkt für die nächste Runde. Wiederholt man dies sehr oft, bilden die Punkte eine Näherung des Sierpinksi-Dreiecks. Wenn man die Punkte auch noch je nach ausgewählter Ecke unterschiedlich einfärbt, also z.B. A = grün, B = rot und C = blau, dann bekommt man drei unterschiedlich gefärbte Sierpinski-Dreiecke im Sierpinski-Dreieck.
Zusammenhang mit dem Pascalschen Dreieck
Mit dem Sierpinski-Dreieck verwandt ist auch das Pascalsche Dreieck. Um das zu verdeutlichen, stelle man sich die ungeraden Zahlen als schwarz markiert vor und die geraden als farblos. Die ungeraden Zahlen des Pascal-Dreiecks werden der Einfachheit halber als Doppelkreuze angegeben (und die geraden Zahlen weggelassen):
.
.
.
# # # # # # # . . . . . . . . . .
#
# #
# #
# # # #
# #
# # # #
# # # #
# # # # # # # #
Null-Meer # #
# # # #
# # # # # . . . . . .
# # # # # # # # #
# # # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # # # # # # # # #. . . . . . . . .
1
1 1
# #
1 3 3 1
# #
# # # #
# # # # Null-See
# # # # # # # #
# #
# # # #
# # # #
# # # # # # # #
# # # #
# # # # # # # #
# # # # # # # #
# # # # # # # # # # # # # # # #
# #
# # # #
. .
. .
. .
Aber egal, wie weit man das Gebilde erweitert, es wird nie ein Sierpinski-Dreieck daraus. Wenn man wissen will, wo sich das Pascal-Dreieck ungefähr im Sierpinski-Dreieck lokalisieren lassen könnte: es ist ein gedachter mathematischer Punkt auf der Mitte der Strecke der rechten, oder wahlweise linken Seite des (initialen) Dreiecks. Das bedeutet, wenn man von 1 aus in irgend eine Richtung laufen würde, käme man nie an irgend einen Eckpunkt. Ebenso wenig könnte ein Beobachter, der das ganze Sierpinski-Dreieck von oben betrachten würde, je das Sierpinski-Dreieck so vergrößern, dass er den Läufer jemals sehen würde.
Code
Programme um Sierpinski-Dreiecke zu zeichnen werden meist – wie auch die folgenden Beispiele in verschiedenen Programmiersprachen – rekursiv implementiert.
Java-Programm
Eine mögliche Realisierung des Problems mit Java — Java-Applet zum Zeichnen von Sierpinski-Dreiecken.
public class SierpinskiTriangle extends Applet {
private Graphics g;
private int dMin=4; // Grenze für Rekursion in Pixels
public void paint(Graphics g) {
this.g = g;
int d = 1024; // Basis (Grösse des Dreiecks)
int x0 = 50; // Abstand vom linken Rand
int y0 = 50; // Abstand vom oberen Rand
int h = (int)(d*Math.sqrt(3)/2); // Höhe
// so: passend für gleichseitiges Dreieck
int xA=x0, yA=y0+h; // (unten-links)
int xB=x0+d, yB=y0+h; // (unten-rechts)
// int xB=x0, yB=y0; // (oben-links)
// int xB=x0+d, yB=y0; // (oben-rechts)
int xC=x0+d/2, yC=y0; // gleichseitiges Dreieck (oben-Mitte)
// int xC=x0, yC=y0; // rechtwinkliges Dreieck, rechter Winkel bei A
// (oben-links)
// int xC=x0+d, yC=y0; // rechtwinkliges Dreieck, rechter Winkel bei B
// (oben-rechts)
int[] x = { xA, xB, xC };
int[] y = { yA, yB, yC };
drawSierpinskiTriangle( x, y, d/2 ); // Rekursion starten
}
private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) {
if (d<=dMin) g.fillPolygon ( x, y, 3 ); // Verankerung der Rekursion
else {
// Mittelpunkte der Seiten:
int xMc = (x[0]+x[1])/2, yMc = (y[0]+y[1])/2;
int xMb = (x[0]+x[2])/2, yMb = (y[0]+y[2])/2;
int xMa = (x[1]+x[2])/2, yMa = (y[1]+y[2])/2;
int[] xNeu1 = { x[0], xMc, xMb };
int[] yNeu1 = { y[0], yMc, yMb };
drawSierpinskiTriangle ( xNeu1, yNeu1, d/2 ); // Rekursion
int[] xNeu2 = { x[1], xMc, xMa };
int[] yNeu2 = { y[1], yMc, yMa };
drawSierpinskiTriangle ( xNeu2, yNeu2, d/2 ); // Rekursion
int[] xNeu3 = { x[2], xMb, xMa };
int[] yNeu3 = { y[2], yMb, yMa };
drawSierpinskiTriangle ( xNeu3, yNeu3, d/2 ); // Rekursion
}
}
}
Pascal-Programm
Beispiel-Code in Object Pascal (Delphi) zur grafischen Darstellung eines Sierpinski-Dreiecks:
procedure Sierpinski(Canvas: TCanvas; x1, y1, x2, y2, x3, y3: Extended; t: Integer);
begin
if t > 0 then
begin
Canvas.MoveTo(Round(x1), Round(y1));
Canvas.LineTo(Round(x2), Round(y2));
Canvas.LineTo(Round(x3), Round(y3));
Canvas.LineTo(Round(x1), Round(y1));
Sierpinski(Canvas, x1, y1, x1 + (x3 - x1) / 4, ((y1 - y2) / 2) + y2, x2, y1, t - 1);
Sierpinski(Canvas, x1 + (x3 - x1) / 4, ((y1 - y2) / 2) + y2, x2, y2, x1 + (x3 - x1) / 4 * 3,
((y1 - y2) / 2) + y2, t - 1);
Sierpinski(Canvas, x2, y1, x1 + (x3 - x1) / 4 * 3, ((y1 - y2) / 2) + y2, x3, y3, t - 1);
end;
end;
var
Image1: TImage; // muss initialisiert werden
--- Beispielaufruf
Sierpinski(Image1.Canvas, 20, 350, 220, 50, 420, 350, 6);
Logo-Programm
to sierpinski :stufe :laenge make "stufe :stufe - 1 make "laenge :laenge / 2 if :stufe > 0 [repeat 3 [sierpinski :stufe :laenge fd :laenge * 2 rt 120]] if :stufe = 0 [repeat 3 [repeat 3 [fd :laenge rt 120] fd :laenge * 2 rt 120]] end
Beispielaufruf: sierpinski 6 300
Logo-Programm mit „Pfeilspitzen“-Fraktal
Das Pfeilspitzen-Fraktal bietet eine sehr gute Näherung für ein Sierpinski-Dreieck:
|
Dieses Pfeilspitzen-Fraktal hat die Stufe 6, damit man die |
Das dem Pfeilspitzen-Fraktal zugehörige LOGO-Programm sieht so aus:
to pfeilspitze :stufe :laenge rpfeil :stufe :laenge end to rpfeil :stufe :laenge make "stufe :stufe - 1 make "laenge :laenge / 2 if :stufe > 0 [rt 60 lpfeil :stufe :laenge lt 60 rpfeil :stufe :laenge lt 60 lpfeil :stufe :laenge rt 60] if :stufe = 0 [rt 60 fd :laenge lt 60 fd :laenge lt 60 fd :laenge rt 60] end to lpfeil :stufe :laenge make "stufe :stufe - 1 make "laenge :laenge / 2 if :stufe > 0 [lt 60 rpfeil :stufe :laenge rt 60 lpfeil :stufe :laenge rt 60 rpfeil :stufe :laenge lt 60] if :stufe = 0 [lt 60 fd :laenge rt 60 fd :laenge rt 60 fd :laenge lt 60] end
Beispielaufruf: pfeilspitze 12 300
Siehe auch: Sierpiński-Kurve
Weblinks
- http://www.seefsen.de/sierp.html Java-Applet zur Demonstration des Dreiecks
- http://www.jgiesen.de/ChaosSpiel/Chaos.html - Erklärung und Java-Applet zum Chaos-Spiel
- http://www.beisenkamp.schulnetz.hamm.de/Logo/sierp.htm - Logo-Code für das Dreieck
