Sierpinski-Dreieck

aus Wikipedia, der freien Enzyklopädie

Du hast neue Nachrichten (Unterschied zur vorletzten Version).

Sierpinski-Dreieck mit Rekursionstiefe 7

Ein Sierpinski-Dreieck (nach Wacław Sierpiński) ist ein Fraktal, das durch fortgesetzte rekursive Aufteilung eines Vorgängerdreiecks $n - 1$ in vier weitere (zueinander kongruente) Dreiecke erhalten wird, die dem Ausgangsdreieck ähnlich im mathematischen Sinne sind. Geht $n$ gegen unendlich, spricht man von einer Sierpinski-Fläche. Die fraktale Dimension der Sierpinski-Fläche beträgt $D = l o g 3 / l o g 2 = 1,585...$

Inhaltsverzeichnis

1 Konstruktion
2 Mathematische Zusammenhänge
3 Darstellung mittels Hutchinson-Operator
4 Sierpinski-Schwamm
5 Chaos-Spiel
6 Zusammenhang mit dem Pascalschen Dreieck
7 Code
8 Weblinks

[Bearbeiten] 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.

[Bearbeiten] 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 $l o g (3) / l o g (2) = 1,585$ . Dies resultiert daraus, dass bei jedem Schritt $k$ genau $3 k$ neue Teildreiecke mit der Seitenlänge $(1 / 2) k$ erzeugt werden. Das Grenzobjekt entsteht, wenn $k$ 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.

[Bearbeiten] 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.

[Bearbeiten] 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

[Bearbeiten] 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.

[Bearbeiten] 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.

[Bearbeiten] Code

Programme um Sierpinski-Dreiecke zu zeichnen werden meist – wie auch die folgenden Beispiele in verschiedenen Programmiersprachen – rekursiv implementiert.

[Bearbeiten] Java-Programm

Das folgende Java Applet zeichnet ein Sierpinski-Dreieck: (siehe auch Java-Applet zum Zeichnen von Sierpinski-Dreiecken)

import java.awt.*;
import java.applet.*;

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öße 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
       }
   }
}

[Bearbeiten] 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);

[Bearbeiten] Logo-Programm

PR 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]]
ende

Beispielaufruf: sierpinski 6 300

[Bearbeiten] Visual Basic .NET Programm

Benötigt ein Windows-Forms-Projekt mit Paint-Ereignis. Getestet mit Net-Framework 2.0.

Sub Sierpinski(x1 As Integer, y1 As Integer, x2 As Integer, y2 As Integer, _
    x3 As Integer, y3 As Integer, t As Integer)
    Dim g As Graphics = Me.CreateGraphics
    Dim p As New Pen(Color.Black, 1)
    Dim P1, P2, P3 As Point
    Dim penblack As New Pen(Color.Black)
    P1 = New Point(x1,y1)
    P2 = New Point(x2,y2)
    P3 = New Point(x3,y3)
    Dim Points As Point() = {P1, P2, P3}
    If t > 0 Then
        g.DrawPolygon(penblack,Points)
        Sierpinski(x1, y1, x1 + (x3 - x1) / 4, ((y1 - y2) / 2) + y2, x2, y1, t - 1)
        Sierpinski(x1 + (x3 - x1) / 4, ((y1 - y2) / 2) + y2, x2, y2, x1 + (x3 - x1) / 4 * 3, _
            ((y1 - y2) / 2) + y2, t - 1)
        Sierpinski(x2, y1, x1 + (x3 - x1) / 4 * 3, ((y1 - y2) / 2) + y2, x3, y3, t - 1)
  End If
End Sub
        
Sub MainFormPaint(sender As Object, e As System.Windows.Forms.PaintEventArgs)
    Sierpinski(20, 350, 220, 50, 420, 350, 7)
End Sub

[Bearbeiten] 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
Struktur der Kurve noch erkennen kann. Pfeilspitzen-Fraktale
mit höherer Stufe gleichen einem Sierpinski-Dreieck viel stärker

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