Lévy-C-Kurve

Die Lévy-C-Kurve ist, in der Mathematik, eine selbstähnliche fraktale Kurve, die erstmals 1906 von Ernesto Cesàro und 1910 von Georg Faber beschrieben und deren Differenzierbarkeitseigenschaften analysiert wurden, die jedoch heute den Namen des französischen Mathematikers Paul Lévy trägt. Lévy war der Erste, der die Selbstähnlichkeitseigenschaften der Kurve beschrieb und eine geometrische Konstruktion von ihr erstellen konnte, die sie als repräsentative Kurve innerhalb derselben Klasse wie die Koch-Kurve zeigte. Die Lévy-C-Kurve ist ein Sonderfall einer Periodenverdopplungskurve, bzw. einer De-Rham-Kurve.

Aufbau des L-Systems

Die ersten acht Schritte in der Konstruktion einer Lévy-C-Kurve

Eine Lévy-C-Kurve (aus einem L-System, nach den ersten 12 Schritten)

Falls man ein Lindenmayer-System (L-System) verwendet, beginnt die Konstruktion der Lévy-C-Kurve mit einer geraden Linie. Mit dieser Linie als Hypotenuse wird ein gleichschenkliges Dreieck mit Winkeln von 45 °, 90 ° und 45 ° erstellt. Die ursprüngliche Linie wird dann durch diese anderen zwei Seiten des Dreiecks ersetzt.

Im zweiten Schritt bilden die zwei neuen Linien jeweils die Basis für ein weiteres rechtwinkliges gleichschenkliges Dreieck und werden durch die beiden anderen Seiten ihres jeweiligen Dreiecks ersetzt. Also erscheint die Kurve nach zwei Schritten als drei Seiten eines Rechtecks mit der gleichen Länge wie die ursprüngliche Linie, aber nur halb so breit.

In jedem nachfolgenden Schritt wird jedes gerade Liniensegment in der Kurve durch die anderen zwei Seiten eines darauf aufgesetzten rechtwinkligen gleichschenkligen Dreiecks ersetzt. Nach n Schritten besteht die Kurve aus $2^{n}$ Liniensegmenten, von denen jedes um den Faktor $2^{\frac {n}{2}}$ kleiner ist als die ursprüngliche Linie.

Das L-System der Kurve kann wie folgt beschrieben werden:

Variable(n)

F

Konstant(e)

$+$

$-$

Start

F

Regel(n)

$F\mapsto +F--F+$

Die einzelnen Elemente des L-Systems kann man wie folgt definieren:

F

vorwärts ziehen

$+$

45 ° im Uhrzeigersinn drehen

$-$

45 ° gegen den Uhrzeigersinn drehen

Die Lévy-C-Kurve ist die Fraktalkurve die die Grenze dieses „unendlichen“ Prozesses ist. Der Name ist eine Anspielung auf die Ähnlichkeit der Kurve mit einer sehr verzierten Version des Buchstaben „C“. Die Kurve ähnelt ebenfalls den feineren Details eines Pythagoras-Baums.

Die Hausdorff-Dimension der C-Kurve gleicht 2 (sie beinhaltet offene Mengen), während der Rand eine Dimension von etwa 1,9340 hat.

Variationen

Die Standard C-Kurve wird aus 45 ° gleichschenkligen Dreiecken erstellt.

Variationen der C-Kurve können durch die Verwendung gleichschenkliger Dreiecke mit anderen Winkeln als 45 ° konstruiert werden. Solange der Winkel weniger als 60 ° beträgt, sind die in jedem Schritt eingeführten neuen Linien jeweils kürzer als die Linien, die sie ersetzen, sodass der Erstellungsprozess zu einer Grenzkurve tendiert. Winkel von weniger als 45 ° erzeugen einen Fraktal, der weniger fest „geringelt“ ist.

IFS Konstruktion

Lévy-C-Kurve (aus IFS, unendliche Stufen)

Wenn man ein iteriertes Funktionensystem (IFS, oder das Chaosspiel, bzw. die IFS-methode) verwendet, dann ist die Konstruktion der C-Kurve etwas einfacher. Eine Menge bestehend aus zwei „Regeln“ wird dazu benötigt, nämlich: Zwei Punkte auf einer Ebene mit einem Skalierfaktor von ${\frac {1}{\sqrt {2}}}$. Die erste Regel ist eine Drehung von 45 ° und die zweite −45 °. Diese Menge wird einen Punkt [x, y] iterieren, indem per Zufall eine der zwei Regeln ausgewählt wird und die Parameter, die mit der Regel verbunden sind, um den Punkt zu skalieren oder zu drehen mittels einer 2D-Transformationsfunktion.

In Formeln ausgedrückt:

$f_{1}(z)={\frac {(1-i)z}{2}}$

$f_{2}(z)=1+{\frac {(1+i)(z-1)}{2}}$

von der ursprünglichen Menge an Punkten $S_{0}=\{0,1\}$.

Animation der Lévy-C-Kurve in Java

import javax.swing.*;
import java.awt.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CKurve extends JPanel {
    private static final int INTERVALL = 500;
    private static final double DREHUNG = Math.PI / 4; // 45° im Bogenmaß
    private final int maximaleRekursionen;
    private final AtomicInteger tiefe = new AtomicInteger();

    public CKurve(int maximaleRekursionen) {
        this.maximaleRekursionen = maximaleRekursionen;
    }

    public void paint(Graphics g) {
        double width = getWidth(); // Breite des Fensters
        double height = getHeight(); // Höhe des Fensters

        g.setColor(Color.BLACK);
        g.fillRect(0, 0, getWidth(), getHeight());

        // Wähle length, x und y so, dass sich die Kurve in der Mitte befindet.
        // (Das Fraktal erweitert sich vom Anfang aus um 1/2 nach links, 3/2 nach rechts, 1/4 nach oben und 1 nach unten)
        double size = 0.75; // Skalierung der Kurve in Fenstergrößen
        double length = Math.min(width, height) * 4 / 5 * size; // Länge der ersten Linie
        double startX = width / 2 - length / 2;
        double startY = height / 2 - length * 3 / 8;

        cKurve(g, startX, startY, length, 0, 0, tiefe.get(), 0.5f);
    }

    /**
     * Stellt die Kurve auf {@code g} für die gegebene Rekursionstiefe dar.
     *
     * @param x         Anfang der aktuellen Linie (x-Position)
     * @param y         Anfang der aktuellen Linie (y-Position)
     * @param length    Länge der aktuellen Linie
     * @param alpha     Richtung in Radiant
     * @param iteration Aktuelle Iteration (0 - {@code tiefe})
     * @param tiefe     Iterationstiefe
     * @param farbe     Position der aktuellen Linie im Fraktal. (0 = Anfang, 1 = Ende)
     */
    public void cKurve(Graphics g, double x, double y, double length, double alpha, int iteration, int tiefe, float farbe) {
        if (iteration < tiefe) { // Das Ende der Iteration wurde noch nicht erreicht; zerteile weiter!
            iteration++;
            length = length / Math.sqrt(2);
            float farbverschiebung = (float) Math.pow(0.5, iteration + 1);
            double alpha1 = alpha + DREHUNG;
            double alpha2 = alpha - DREHUNG;
            cKurve(g, x, y, length, alpha1, iteration, tiefe, farbe - farbverschiebung); // Rekursiver Aufruf (Kathete 1)
            // Die zweite Kathete beginnt am Ende der ersten Kathete
            x += length * Math.cos(alpha1);
            y += length * Math.sin(alpha1);
            cKurve(g, x, y, length, alpha2, iteration, tiefe, farbe + farbverschiebung); // Rekursiver Aufruf (Kathete 2)
        } else { // Das Ende der Iteration wurde erreicht; male die Linie!
            g.setColor(new Color(farbe, 1 - farbe, 1, 1));
            // Berechne das Ende der aktuellen Linie
            double endeX = x + length * Math.cos(alpha);
            double endeY = y + length * Math.sin(alpha);
            g.drawLine((int) x, (int) y, (int) endeX, (int) endeY);
        }
    }

    /**
     * Stellt die Kurve für die nächste Rekursionstiefe dar.
     */
    public void next() {
        tiefe.updateAndGet(wert -> (wert + 1) % maximaleRekursionen);
        repaint();
    }

    public static void main(String[] args) {
        CKurve kurve = new CKurve(15);

        JFrame frame = new JFrame("Animation der Lévy-C-Kurve");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(kurve);
        frame.setSize(640, 480);
        frame.setExtendedState(Frame.MAXIMIZED_BOTH);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

        new Timer(INTERVALL, e -> kurve.next()).start();
    }
}

Siehe auch

• Pythagoras-Baum
• Drachenkurve

Literatur

• S. Bailey, T. Kim, R. S. Strichartz: Inside the Lévy dragon. In: American Mathematical Monthly. 109, Nr. 8, 2002, S. 689–703.
• E. Cesaro: Fonctions continues sans dérivée. In: Archiv der Math. und Phys. 10, 1906, S. 57–63.
• G. Faber: Über stetige Funktionen II. In: Math. Annalen. 69, 1910, S. 372–443.
• Paul Lévy: Plane or Space Curves and Surfaces Consisting of Parts Similar to the Whole. 1938, reproduziert in Gerald A. Edgar (Hrsg.): Classics on Fractals. 1993 Addison-Wesley Publishing, ISBN 0-201-58701-7.

Weblinks

Commons: Lévy C curve – Album mit Bildern, Videos und Audiodateien