Un L-System (ou système de Lindenmayer) est une Grammaire formelle, permettant un procédé Algorithmique, inventé en 1968 par le Biologiste Hongrois Aristid Lindenmayer qui consiste à modéliser le processus de développement et de prolifération de plantes ou de bactéries.

Basée sur une forme récursive de grammaire générative, cette grammaire a été approfondie et mise en oeuvre graphiquement par Przemyslaw Prusinkiewicz dans les Années 1980.

Au départ, Lindenmayer avait pensé ce système comme un langage formel qui permettait de décrire le développement d'organismes multicellulaires simples. À cette époque il travaillait sur les levures, les champignons et des algues. Mais l'Informatique a permis d'exploiter ce système pour générer graphiquement des calculs de plantes très complexes.

Un L-System est un ensemble de règles et de symboles qui modélisent un processus de croissance d'êtres vivants comme des plantes ou des cellules. Le concept central des L-Systems est la notion de Réécriture. La réécriture est une technique pour construire des objets complexes en remplaçant des parties d'un objet initial simple en utilisant des règles de réécriture.

Pour ce faire, les cellules sont modélisées à l'aide de symboles. À chaque génération, les cellules se divisent, i.e. un symbole est remplacé par un ou plusieurs autres symboles formant un mot.

Grammaire formelle

Un L-System est une Grammaire formelle qui comprend :

1. Un alphabet V : l'ensemble des variables du L-System. V ^* est l'ensemble des "mots" que l'on peut construire avec les symboles de V, et V ⁺ l'ensemble des mots contenant au moins un symbole.
2. Un ensemble de valeur constantes S. Certains de ces symboles sont communs à tous les L-System (voir plus bas la Turtle interpretation).
3. Un axiome de départ ω choisi parmi V ⁺ , c'est à dire l'état initial.
4. Un ensemble de règles, noté P, de reproduction des symboles de V.

Un L-System est alors noté {V, S, ω, P } .

Exemples et notations de L-Systems simples

Exemple 1 : l'algue de Lindenmayer

Voici le premier L-System d'Aristid Lindenmayer qui servait à décrire le développement d'une algue :

• Alphabet : V = {A, B}
• Constantes : S = { ∅ }
• Axiome de départ : w = A
• Régles : (A → AB) ∧ (B → A)

Notation :

Algue<br> {<br> Axiom A<br> A=AB<br> B=A<br> }

Algue est le nom du L-System. En premier on a l'axiome ω, puis chaque règle de P est à la ligne l'une de l'autre. A=AB est à comprendre comme tout symbole A devient un « mot » AB à la génération suivante.

Voici le résultat sur six générations :

• n=0, A
• n=1, AB
• n=2, AB A
• n=3, AB A AB
• n=4, AB A AB AB A
• n=5, AB A AB AB A AB A AB
• n=6, AB A AB AB A AB A AB AB A AB AB A

Exemple 2 : la Suite de Fibonacci

• Alphabet : V = {A, B}
• Constantes : S = { ∅ }
• Axiome de départ : w = A
• Régles : (A → B) ∧ (B → AB)

Notation :

Algue<br> {<br> Axiom A<br> A=B<br> B=AB<br> }

Voici le résultat sur six générations :

• n=0, A
• n=1, B
• n=2, AB
• n=3, B AB
• n=4, AB B AB
• n=5, B AB AB B AB
• n=6, AB B AB B AB AB B AB

Si on compte le nombre de symboles à chaque génération, on obtient la Suite de Fibonacci :

• n=0, 1 symbole
• n=1, 1 symbole
• n=2, 2 symboles
• n=3, 3 symboles
• n=4, 5 symboles
• n=5, 8 symboles
• n=6, 13 symboles

Turtle interpretation

Cette chaîne de caractère est un mot insensé en soit, mais qui peut fort bien se prêter à une interprétation graphique, en deux ou trois dimensions. Pour illustrer la manière de construire une plante avec un L-System, imaginons que nous avons un crayon à la main et qu’elle se balade sur la feuille sous nos ordres : "monte d’un cran, puis tourne de 20° à gauche, déplace toi deux fois de un cran, mémorise ta position et avance encore d’un cran, lève-toi puis repose-toi sur la position mémorisée" et ainsi de suite... Il a donc fallu inventer des symboles variants ∈ V, ou constants ∈ S, pour permettre de guider cette main. Plusieurs d'entre eux ont été normalisés, ils font partie de ce qu'on appelle la "Turtle interpretation". Ce nom vient de la "tortue" du langage de programmation Logo qui fonctionne sur le même principe. En fait c'est cette tortue qui est votre main qui tient le crayon. Voici donc les signes couramment utilisés :

• F : Se déplacer d’un pas unitaire (∈ V)
• + : Tourner à gauche d’angle α (∈ S)
• - : Tourner à droite d’un angle α (∈ S)
• & : Pivoter vers le bas d’un angle α (∈ S)
• ^ : Pivoter vers le haut d’un angle α (∈ S)
• < : Roulez vers la gauche d’un angle α (∈ S) * > : Roulez vers la droite d’un angle α (∈ S)
• | : Tourner sur soi-même de 180° (∈ S)
• : Restaurer la dernière position sauvée (∈ S)

Pour être plus concret, les symboles appartenant à V sont des parties d'une plante, comme une branche ou une portion de branche tout simplement. Les symboles appartenant à S sont des ordres que l'on donne à notre main virtuelle qui dessine la plante, ils servent à déterminer une direction à prendre, tandis que les symboles de V dessinent dans cette direction.

Remarque : Les deux derniers symboles rappellent les fonctions pushMatrix() et popMatrix() d'OpenGl, ainsi on devine que c'est un environnement graphique qui se prêtera très bien au L-System. De plus la programmation orientée objet avec les pointeurs, tel que dans le langage C++, semble indiquée pour la modélisation d'une "chaîne cellulaire" qui évolue.

Exemple de la courbe de Koch

• Variable : v = {F}
• Constantes : S = {+, −}
• Axiome : w = F
• Règle : (F → F+F−F−F+F)

Courbe_de_Koch<br> {<br> angle 90<br> axiom F<br> F=+F−F−F+F<br> }

angle 90 détermine que l'on tourne de 90° avec les symboles + et -.

Voici le résultat sur trois générations :

• n=0:

F

• n=1:

F+F-F-F+F

• n=2:

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

• n=3:

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

Turtle en trois dimensions

Cette « turtle interpretation » peut être exploitée en trois dimensions grâce aux idées de Harold Abeson et Andrea diSessa dans leur ouvrage commun, « Turtle geometry : the computer as a medium for exploring mathematic ». L'orientation est représentée par trois vecteurs :

→ H

,

→ L

,

→ U

tels que

→ H

×

→ L

=

→ U

• → H

  pour turtle heading. Il s'agit du regard de la tortue.

• → U

  pour up. Il s'agit de la direction vers laquelle se dirige la tortue.

• → L

  pour left. Il s'agit de la gauche de cette tortue.

La rotation de la tortue se note alors :

=

R

Où R est une matrice 3×3. Les rotations d'un angle α autour des axes

→ U

,

→ L

ou

→ H

sont représentées par les matrices :

RU( α) = n

(   ┌      n cos( α)       sin( α)       0    ┐     )        n- sin( α)       cos( α)       0        └    n0       0       1 n     ┘

n

nRL( α) =

(   ┌      n cos( α)       0       - sin( α)    ┐     )        n0       1       0        └    n sin( α)       0       cos( α) n     ┘

nRH( α) =

(   ┌      n1       0       0    ┐     )        n0       cos( α)       - sin( α)        └    n0       sin( α)       cos( α) n     ┘

Les symboles prennent maintenant la signification suivante :

• + Tourner à gauche d'un angle α, en utilisant la matrice de rotation RU(α).
• − Tourner à droite d'un angle α, en utilisant la matrice de rotation RU(−α).
• & Pivoter vers le bas d'un angle α, en utilisant la matrice de rotation RL(α).
• ∧ Pivoter vers le haut d'un angle α, en utilisant la matrice de rotation RL(−α).
• \\ Rouler à droite d'un angle α, en utilisant la matrice de rotation RH(α).
• / Rouler à gauche d'un angle α, en utilisant la matrice de rotation RH(−α).
• | Tourner autour de lui-même de 180°, en utilisant la matrice de rotation RU(180◦).

DOL-System ou Determinist O-context System

Ce système est déterministe, i.e. qu'il n'offre qu'une seule évolution possible depuis l'axiome à la énième génération. Une cause engendre un effet, ce qui se traduit par : une variable ne peut subir qu'un seul type de transformation, toujours identique, donc une seule règle par variable. L'exemple ci-dessus était un DOL-System, il s'agit de la forme la plus simple de L-System.

Exemple de DOL-System

• Variable : V = {F, X}
• Constantes : S = {+, −, [, ]}
• Axiome : w = X
• Règles : (X → F[+X]F[−X]+X) ^ (F → FF)

Plante<br> {<br> angle 20<br> axiom X<br> X=F[+X]F[−X]+X<br> F=FF<br> }

angle 20 détermine de quel angle on tourne avec les symboles + et -.

Voici le résultat sur deux générations :

• n=0, X
• n=1, F[+X]F[−X]+X
• n=2, FF[+F[+X]F[−X]+X]FF[−F[+X]F[−X]+X]+F[+X]F[−X]+X

SOL-System ou Stochastic O-context System

Comme son nom l'indique, ce système fait appel aux probabilités, il est aussi appelé système non-déterministe. Contrairement au DOL-System, il est possible de déterminer plusieurs transformations pour un symbole. Chaque possibilité sera pondérée pour pouvoir donner priorité à certaines transformations par rapport à d'autres.

Exemple de SOL-System

On pourrait étoffer l'exemple du DOL-System, on s'en contentera pour rester sur quelque chose de simple, même si ça n'aurait que peu d'intérêt graphiquement :

• Variable : V = {F, X}
• Constantes : S = {+, −, [, ]}
• Axiome : w = X
• Règles : (X → F[+X]F[−X]+X) ^ (F → FF)

Plante_Stochastique<br> {<br> angle 20<br> axiom X<br> X=(0.2)F[++X]F[−X]+X<br> X=(0.8)F[+X]F[−X]+X<br> F=(1.0)FF<br> }

Voici un résultat possible sur deux générations :

• n=0, X
• n=1, F[++X]F[−X]+X
• n=2, FF[++F[+X]F[−X]+X]FF[−F[+X]F[−X]+X]+F[+X]F[−X]+X

Voici un autre résultat possible sur deux générations :

• n=0, X
• n=1, F[+X]F[−X]+X
• n=2, F[+F[++X]F[−X]+X]F[−F[++X]F[−X]+X]+F[++X]F[−X]+X

Il y a 2²=4 possibilités possibles sur deux générations.

(0.2), (0.8) et (1.0) représentent les poids de chaque transformation possible de X et de F.

Context-Sensitive

Les deux systèmes précédents (des OL-Systems) ne peuvent pas simuler l'interaction de parties d'une plante car ils sont context-free, i.e. chaque partie se développe indépendamment des autres parties. Un L-System context-sensitive résoud ce problème en prenant en compte ce qui précéde ou succède à une partie, c’est-à-dire un symbole. Un tel système est appelé IL-System ou encore (k,l)-System, le contexte de gauche est un "mot" de longueur k et celui de droite un "mot" de longueur l. Pour expliquer la manière dont se lisent les regles voici deux exemples :

Exemple 1 : signal acropète

Ce L-System simule la propagation d'un signal acropète dans une structure de branches qui ne se développe pas

• Variable : V = {A, B}
• Constantes : S = {+, −, [, ], <} * Axiome : w = B[+A]A[−A]A[+A]A * Règles : (B < A → B) A est une branche qui n'a pas encore reçu le signal, et B en est une qui l'a reçu. La règle se comprend ainsi : si un symbole A est précédé d'un symbole B, alors ce A devient un B à la génération suivante. Voici la propagation du signal sur trois générations, sachant que les signes + et - seront ignorés dans la prise en compte des règles : *n=0, B[+A]A[−A]A[+A]A *n=1, B[+B]B[−A]A[+A]A *n=2, B[+B]B[−B]B[+A]A *n=3, B[+B]B[−B]B[+B]B On constate que peu à peu, chaque branche est atteinte par le signal acropète qui permet au fleurs les plus hautes de s'ouvrir. Remarquez bien qu'à chaque génération, deux nouvelles branches reçoivent le signal, en effet, puisque l'on sauvegarde la position, que l'on dessine A puis qu'on restitue la position et on redessine un A, cela signifie que ces deux A ont la même base, donc la même branche précède les deux. === Exemple 2 : signal basipète === Ce L-System simule la propagation d'un signal basipète dans une structure de branches qui ne se développe pas. * Variable : V = {A, B} * Constantes : S = {+, −, [, ], <} * Axiome : w = A[+A]A[−A]A[+A]B * Règles : (A > B → B)

A est une branche qui n'a pas encore reçu le signal, et B en est une qui l'a reçu. La règle se comprend ainsi : si un symbole A est suivi d'un symbole B, alors ce A devient un B à la génération suivante.

Voici la propagation du signal sur trois générations, sachant que les signes + et - seront ignorés dans la prise en compte des règles :

• n=0, A[+A]A[−A]A[+A]B
• n=1, A[+A]A[−A]B[+B]B
• n=2, A[+A]B[−B]B[+B]B
• n=3, B[+B]B[−B]B[+B]B

On constate que peu à peu, chaque branche est atteinte par le signal basipète qui permet aux fleurs à l'Inflorescence en ombrelle ou en capitule de fleurir de manière centrifuge.

Remarque : il est bien sûr possible d'écrire une règle dans le genre (B < A < B → B), ce qui signifie que si une branche A est entourée par des branches B alors elle deviendra une branche B à la prochaine génération. Il est aussi possible d'écrire plusieurs règles, pour plusieurs situations. == Bibliographie == * « The Algorithmic beauty of plants » de Przemyslaw Prusinkiewicz et Aristid Lindenmayer, 1990 * « The book of L » de Przemyslaw Prusinkiewicz * « Lindenmayer Systems, Fractals, and Plants » de Przemyslaw Prusinkiewicz et James Hanan, 1992 == Liens externes == * Les publications du Biological Modeling and Visualization research group * (en) Catégorie Lindenmayer Systems de l’annuaire dmoz. * eXtended L-Systems (XL), Grammaires Relationnelles de Croissance, ainsi que la plateform libre GroIMP * Article de David J. Wright sur les L-systemes * Fractint L-System True Fractals * "An introduction to Lindenmayer systems", by Gabriela Ochoa. Brève description et application informatique. * "Branching: L-system Tree" par Ryoichi Mizuno * Fractint * L-Systemes en Architecture * Un générateur de L-Systems (Windows) * Lyndyhop: Un autre générateur de L-systèmes (Windows & Mac) * Autre générateur (anyos*) * L-systems gallery – a tribute to Fractint * "L-system Composition". * Figures générée par L-systemes * Un langage LOGO gratuit pour Windows avec des exemples de procédures L-systèmes.