Context Free Art - Simple Schönheit

Wer sich seine Zeit gerne mit Programmieren und Computergrafik vertreibt, wird mit Context Free Art sicher seine Freude haben. Chris Coyne hat mit dieser Anwendung eine einfache, kontext-freie Programmiersprache zur Beschreibung von Design-Grammatiken namens CFDG erschaffen und liefert eine leistungsfähige Rendering-Engine gleich mit.

Das Programm ist kostenlos für Mac, Windows und Unix unter www.contextfreeart.org erhältlich. Auch der Sourcecode steht unter der GPL offen.

Die Bilder werden aus einer Kette nicht deterministischer Regeln aufgebaut. Jede Regel definiert ein Symbol, das beliebig in weitere Sequenzen aufgelöst werden kann, und zwar unabhängig voneinander - daher auch der Name "context free". Es gibt dabei nur wenige fix definierte Grundformen als Endpunkte der Befehlskette, so z.B. CIRCLE und SQUARE, den Kreis und das Quadrat.

CFDG ist prädestiniert für rekursive Sequenzen und auch zufällige Abläufe - alles Dinge, die beispielsweise die Darstellung von natürlichen oder auch fraktalen Formen sehr einfach machen.

Als Anregung zum weiteren Herumspielen und Experimentieren soll hier ein kurzes Beispiel anhand eines farnartigen Gewächses erklärt werden. Nähere Angaben und Erklärungen zu CFDG gibt's auf der Website www.contextfreeart.org.

Nach Installation des Programms steht der linke Eingabebereich zur Erfassung der darzustellenden Bildbeschreibung zur Verfügung. Context Free Art erwartet zu Beginn die Angabe der Regel, mit der es die Bildberechnung starten soll. Der dazugehörige Befehl lautet "startshape".

Wir legen nun fest, dass unser Einstiegspunkt die Regel mit dem Namen "farn" sein soll:

startshape farn

Diese müssen wir nun natürlich auch definieren, was wir mit der aus vielen anderen Programmiersprachen vertrauten Block-Notation mit geschwungenen Klammern machen:

rule farn {
}

So ein Farn besteht nun aus vielen verzweigten Wedeln, also ergänzen wir:

rule farn {
    wedel { hue 200 }
}

Damit definieren wir, dass die Rendering-Engine bei Aufruf von "farn" die Regel namens "wedel" mit dem Farbton "hue 200" (blau) anwendet.

Nun definieren wir unseren Wedel. Dazu verwenden wir eine der wenigen möglichen Grundformen - den Kreis, den wir hier als etwas verzerrte Ellipse anwenden. Diese soll mit einer relativen Größe (s = size) von 0.5 Einheiten Breite und 1.2 Einheiten Höhe angezeigt werden. Also notieren wir:

rule wedel {
    CIRCLE { s 0.5 1.2 }
}

Das Ergebnis nach einem Klick auf den "Render"- Button ist vorerst einmal eine dunkle Ellipse:



Hier bauen wir nun die erste Rekursion ein. Die Regel "wedel" soll sich immer wieder selbst aufrufen und dabei sukzessive kleiner und heller werden und sich leicht nach oben bewegen. Wir ergänzen:

rule wedel {
    CIRCLE { s 0.5 1.2 }
    wedel { s 0.97 y 0.3 sat 0.04 b 0.02}
}

Bei jedem rekursiven Aufruf wird die Größe nun auf 0.97 Einheiten der vorhergehenden Form verkleinert (s = size), die y-Koordinate um 0.3 Einheiten nach oben verschoben (y) und werden die Farbwerte für Sättigung (sat = saturation) und Helligkeit (b = brightness) um die angegebenen Werte verändert.

Es ergibt sich folgendes Bild:



Wir drehen unsere Ellipse nun bei jedem Durchlauf zusätzlich um einen kleinen Ruck (r = rotation):

rule wedel {
   CIRCLE { s 0.5 1.2 }
   wedel { s 0.97 y 0.3 r 1 sat 0.04 b 0.02}
}

Folgende gebeugte Form ergibt sich nun beim Rendern:



Nun kommt der Zufall ins Spiel. Wir können unsere "wedel"-Regel einfach ein zweites Mal definieren und es dem Programm überlassen, welche Definition es zufällig aus den beiden auswählt, wenn der Wedel an der Reihe ist.

rule wedel {
   wedel { flip 80 }
}

Wenn nun diese Regel zum Zug kommt, dann spiegeln wir unsere Form einfach um eine 80-Grad-Achse. Heraus kommt nun eine zittrige Ausgabe unserer ursprünglichen Form, wobei jeder Klick auf den "Render"-Button nun ein anderes Ergebnis bringt, da ab sofort der Zufall die endgültige Ausgabe bestimmt.



Das genügt uns aber noch nicht. Wir wollen mehr Verzweigungen und eine noch viel zufälligere Aufteilung unserer Formen. Wir ergänzen daher eine weitere Definition für unseren Wedel, die die Rendering-Engine alternativ zu den beiden bestehenden zufällig ausählen kann.

rule wedel {
   wedel { r 10 }
   wedel { r -30 s 0.5 }
}

Diese ruft sich selbst - oder eben zufallsbedingt die beiden anderen möglichen "wedel"-Definitionen - zwei mal auf, und zwar mit zwei verschiedenen Rotationswerten (r) und im zweiten Fall mit einer Größenreduktion.

Das Ergebnis sieht nun schon sehr verästelt aus:



Durch Angaben zur Aufruf-Wahrscheinlichkeit können wir dem reinen Zufall nun noch ein Schnippchen schlagen und eine Gewichtung der Regeln festlegen:

rule wedel {
   CIRCLE { s 0.5 1.2 }
   wedel { s 0.97 y 0.3 r 1 sat 0.04 b 0.02}
}

rule wedel 0.5 {
   wedel { flip 80 }
}

rule wedel 0.4 {
   wedel { r 10 }
   wedel { r -30 s 0.5 }
}

Dies macht unseren Farn gleich merkbar feiner, womit wir uns für unser Testprojekt vorerst einmal zufrieden geben.



Context Free Art kann noch mehr: Neben der Darstellung sehr komplexer Definitionen kann es die Ausgabe in riesengroßen Formaten bereitstellen und aus dem Grafikaufbau auch einen Kurzfilm machen.

Das schöne daran: Man kann eigentlich kaum etwas falsch machen. Darum: Einfach drauf los programmieren und Spaß haben. :-)