Paul Koop Beispiel für ein L-System:

 

 

Modellieren mit L-Systemen

Systeme des Wiederbeschreibens

L-Systeme werden genutzt, um Transformations- und Wachstumsprozesse informatisch zu modellieren. Sie basieren auf der Idee von Chomsky-Grammatiken.. Ein gutes Beispiel hierzu ist das Kreieren einer "Schneeflocke" (bekannt als Koch-Kurve):

 

 

generative selbstähnliche Strukturen

Mit den oben beschriebenen Methoden können mit einer endlichen Anzahl an Regeln unendlich viele selbstähnliche generative Strukturen beschrieben werden.

Beispiel:

F

F ā F[+F]F[-F]F

Nach der 2. Ableitung:

F[+F]F[-F]F[+F[+F]F[-F]F]F[+F]F[-F]F[-F[+F]F[-F]F]F[+F]F[-F]F

Nach der 3. Ableitung:

F[+F]F[-F]F[+F[+F]F[-F]F]F[+F]F [-F]F[-F[+F]F[-F]F]F[+F]F[-F]F [+F[+F]F[-F]F[+F[+F]F[-F]F]F[+F]F[-F]F[-F[+F] F[-F]F]F[+F]F[-F]F]F[+F]F[-F]F[+F [+F]F[-F]F]F[+F]F[-F]F[-F[+F]F [-F]F]F[+F]F[-F]F[-F[+F]F[-F]F[+F[+F]F[-F]F]F[+F] F[-F]F[-F[+F]F[-F]F]F[+F]F[-F]F]F [+F]F[-F]F[+F[+F]F[-F]F]F[+F] F[-F]F[-F[+F]F[-F]F]F[+F]F[-F]F

Usw.

Die Zeichen der Zeichenkette sind ohne vordefinierte Bedeutung. Theoretisch relevant ist allein die Syntax ihrer Verknüpfung. Sie definiert die generative selbstähnliche Struktur. Die semantische Interpretation der Zeichen ist alleine eine Interpretationsleistung eines menschlichen Lesers. Im Prinzip ist auch eine visuelle Interpretation (die animiert werden kann) etwa zur automatischen Synthese von pflanzlichen Wachstumsstrukturen möglich.:

Quellcode für dieses Beispiel (c) Paul Koop 1993, 1994,1995,1996-2002

/*

* Paul Koop M.A.

* L-System

* Der Quellcode wurde ursprünglich entwickelt,

*um der frage nachzugehen, ob

*ein visuelle Interpretation auch für K-Systeme

*im Rahmen der

*Algorithmisch Rekursive Sequenzanalyse möglich ist.

*/

 

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

import java.util.*;

// Paul Koop M.A. Applet L-sytem

 

//classes

class stapel

{//BEGIN stapel

 double x;

 double y;

 double alpha;

 stapel nach;

 stapel vor;

}//END stapel

 

class turtle

{//BEGIN turtle

 // Variablen

 double xpos;

 double ypos;

 double alpha;

 boolean pen;

 //Methoden

 double bogenmass (double winkel)

 {//BEGIN bogenmass

  return (2*Math.PI*(winkel/360));

 }//END bogenmass

 double winkel (double bogenmass)

 {//BEGIN winkel

  return (360*(bogenmass/(2*Math.PI)));     

 }//END winkel

 void setx(double neux)

 {//BEGIN setx

  xpos=neux;

 }//END setx

 double getx()

 {//BEGIN getx

  return xpos;

 }//END getx

 void sety(double neuy)

 {//BEGIN sety

  ypos=neuy;     

 }//END sety

 double gety()

 {//BEGIN gety

  return ypos;

 }//END gety

 void setalpha(double neualpha)

 {//BEGIN setalpha

  alpha = neualpha;  

 }//END setalpha

 double getalpha()

 {//BEGIN alpha

  return alpha;     

 }//END alpha

 void penup()

 {pen = false;}

 void pendown()

 {pen = true;}

 //boolean getpen()

 void turn (double winkel)

 {//BEGIN turn

 alpha = alpha + winkel;

 if (alpha > 360) {alpha = alpha-360;}

 if (alpha <   0) {alpha = 360 + alpha;}

 }//END turn

 void move(int laenge, Graphics g)

  {//BEGIN move

  double neux;

  double neuy;

  double neualpha;

  neux = xpos+(laenge*Math.cos(bogenmass(alpha)));

  neuy = ypos+(laenge*Math.sin(bogenmass(alpha)));

  if (pen){g.drawLine((int)xpos,(int)ypos,(int)neux,(int)neuy);}

  setx(neux);

  sety(neuy);

 }//END move

}//END turtle

 

 

 

public class lsystem extends Applet

{//BEGIN lsystem

 //Deklarationen

 stapel kopf = new stapel();

 stapel last = kopf;

 

 StringBuffer zeichenkette = new StringBuffer("F");

 String regel = "FF+[+F-F-F]-[-F+F+F]";

 double win = 25;

 char ch;

 

 

 static private int hoehe;

 static private int breite;

 static private int laenge;

 static private final int a =5;

 turtle myTurtle = new turtle();

 

 

 

     

 public void befehl (char ch, Graphics g)

 {//BEGIN befehl

  switch (ch)

   {//BEGIN switch

      case 'F':

            myTurtle.pendown();

            myTurtle.move(laenge,g);

            break;

      case 'f':

            myTurtle.penup();

              myTurtle.move(laenge,g);

            break;

      case '+':

            myTurtle.turn(win);

            break;

      case '-':

            myTurtle.turn(-win);

            break;

      case '[':

            //push

            last.nach = new stapel();

            last.nach.vor = last;

            last = last.nach;

            last.x =myTurtle.getx();

            last.y =myTurtle.gety();

            last.alpha = myTurtle.getalpha();

            break;

      case ']':

            //pop

            myTurtle.setx(last.x);

            myTurtle.sety(last.y);

            myTurtle.setalpha(last.alpha);

            last = last.vor;

            last.nach = null;

            break;

      default:

            {}

    }//END switch

 }//END befehl

 

 public void paint(Graphics g)

    {//BEGIN paint     

    for (int z=0;z<zeichenkette.length();z++)

     {

           befehl(zeichenkette.charAt(z),g);

     }

    }//END paint

                 

 

 

 public  void init()

 {//BEGIN initmyTurtle = new turtle();

     //Initialisierungen

     Dimension size = getSize();

     hoehe   = size.height;

     breite  = size.width;

     laenge = 4;

     myTurtle.setx(10);

     myTurtle.sety(hoehe/2);

     myTurtle.setalpha(0);

     myTurtle.pendown();

     stapel kopf = new stapel();

     stapel last = kopf;

     kopf.vor = null;

     kopf.nach = null;

 

     //Vorbereitung der Zeichenkette

     for (int z=0;z<a;z++)

     {//BEGIN for 1 Anzahl der Durchlaeufe

      for (int i=0;i<zeichenkette.length();i++)

      {//BEGIN for 2 je Durchlauf Erzetzungsregel anwenden

       if (zeichenkette.charAt(i)=='F')

        {

         zeichenkette=zeichenkette.deleteCharAt(i);

         zeichenkette=zeichenkette.insert(i, regel);

         //System.out.println(zeichenkette);

         i = i+regel.length();

         continue;

        }//END if  

      }//END for 2

     }//END for 1

     

 }//END init

}//END lsystem