Język CFDG do generowania obrazów Context Free

CFDG: kontekstowo-wolna gramatyka do proceduralnej generacji obrazów

Context Free korzysta z języka CFDG (Context Free Design Grammar) do opisu proceduralnej generacji obrazów. To język zorientowany na dziedzinę z kontekstowo-wolną gramatyką, gdzie podstawowe prymitywy to CIRCLE i SQUARE. Renderowanie realizowane jest za pomocą biblioteki Anti-Grain Geometry. Reguły definiują rekurencyjne transformacje figur z parametrami: obrót (r), skalowanie (s), przesunięcie (x, y), kolor (hue, sat, b), przezroczystość (a) i inne.

Język umożliwia generowanie złożonych struktur fraktalnych z prostych opisów. Każdy przykład poniżej pokazuje rzeczywiste skrypty CFDG generujące kompozycje wizualne.

Podstawowy przykład: fraktalny wzór

Pierwszy skrypt tworzy symetryczny wzór na czarnym tle z powtarzającymi się okręgami i gradientami.

startshape T
// FLIGIZ
background{b -1}
tile {s 2.5}
rule T {3*{r 120 hue 30}S{x .3}}
rule S 3{CIRCLE{hue 30}4*{r 20 b.007 sat .1}S[s.3.7y.9]}
rule S {CIRCLE{hue 15}9*{r 20 b.05 hue -3}S[s.3.7y.9]}
rule S {S{flip 90}}

Tutaj reguła T inicjuje trzy gałęzie z obrotem 120°, każda transformuje S. Reguły S dodają okręgi z gradientem jasności (b) i nasycenia (sat), potem rekurencyjnie zmniejszają skalę (s 0.37) i przesuwają w górę (y 0.9).

Efekt tęczowy z cieniami

Skrypt generuje perlistą kulę z cieniami i błyskami za pomocą zagnieżdżonych reguł.

startshape START
rule START {
CIRCLE{}
RAINBOW_SPLIT{hue 0 sat 0 b 0}
RAINBOW_SPLIT{r 180 hue 120 sat 0}
}
rule RAINBOW_SPLIT{
RAINBOW{}
}
rule RAINBOW_SPLIT{
RAINBOW_MINI{alpha -.9 y -.4 s .2 flip 1 b -1}
RAINBOW{}
}
rule RAINBOW{
SHADOW{}
CIRCLE{}
HIGHLIGHT{
RAINBOW_SPLIT{hue 1.5 sat .1 s .99 b .001 x .09 r 2.8}
}
}
rule RAINBOW_MINI{
SHADOW{}
CIRCLE{}
HIGHLIGHT{}
RAINBOW_MINI{alpha .1 hue 2 s .98 x .3 r 2.8}
}
rule RAINBOW_MINI .04{
SHADOW{}
CIRCLE{}
HIGHLIGHT{}
RAINBOW_MINI{flip 1 alpha .1 hue 5 s .99 x .3 r 2.8}
}
rule SHADOW {
CIRCLE{hue 3 b -1 sat -.6 s 1.1 y .04 alpha -.7}
}
rule HIGHLIGHT {
CIRCLE{ hue 3 b .7 sat -.3 s .98 y .05}
CIRCLE{ hue 3 b 2 sat -.7 s .9 y .01}
}

Kluczowe transformacje: RAINBOW_SPLIT tworzy tęczowy gradient, SHADOW i HIGHLIGHT modelują oświetlenie. Rekursja w RAINBOW_MINI z prawdopodobieństwem 0.04 zatrzymuje rozgałęzianie.

Symulacja starożytnych tekstów

Ten skrypt imituje ręcznie pisany tekst za pomocą kresek i symboli.

background { hue 40 sat 0.2 b -0.2}
startshape LINES
rule LINES {
20 * {y -90} NEWLINE {hue 90 sat 0.7 b 0.2 a -0.5}
}
rule NEWLINE {
LINE {y 0}
}
rule NEWLINE {
LINE {y 20}
}
rule NEWLINE {
LINE {y 30}
}
rule LINE {
50 * {x 36} CHAR {}
}
rule CHAR 0.3 { }
rule CHAR {
2 * {x 20 flip 180} STROKE {r 90}
2 * {y 20 flip 180} STROKE {}
}
rule CHAR {
4 * {r 60} STROKE {}
}
rule CHAR {
STROKE {r 90}
3 * {y 10 flip 180} STROKE {}
}
rule STROKE {
B {}
}
rule STROKE {
B {flip 90}
}
rule B 30 {
MARK {}
B {x .6 r 10}
}
rule B 30 {
MARK {}
B {x .6 r 3}
}
rule B 250 {
MARK {}
B {x .9}
}
rule B 10 {
MARK {}
B {flip 90}
}
rule B 10 { }
rule MARK 3 {
CIRCLE {}
}
rule MARK {
CIRCLE {s 2}
}
rule MARK {
SQUARE {s 3}
}
rule MARK {
CIRCLE {s 4}
}
rule MARK 0.01 {
CIRCLE {s 7}
}

Struktura: LINES generuje linie NEWLINE, każda z 50 CHAR. CHAR łączy STROKE z obrotami i odbiciami (flip). B rekurencyjnie rysuje kreski MARK (CIRCLE/SQUARE).

Animowana scena z drzewami

Skrypt modeluje dynamiczną scenę z animacją czasu.

background{b -1} startshape init
rule init{time{z 0 r -90 sat .5 |h 220}}
rule time 40 {draw{} time{r 1 s .9991 b .1| a .1|}}
rule time    {slow{|b -1 |a 1 |sat 1}}
rule time    {slow{|b 1 |a -1 |sat 1}}
rule slow 20 {draw{} slow{ r 1 s .9991 b .03| a .03| h -1}}
rule slow    {time{|sat -1}}
rule draw{
SQUARE[z 0 x 1 s .27 .018 x -.5 a 1 h 1|]
stars{z 1 x .91}
cloud[z 2 x .83 s .17 x .5 h .7| a 1 sat .3|]
ground[z 3 x .73 s .1 x .5]
}
// ... (pozostałe reguły dla ground, stuff, block, bush, tree, stars, cloud skrócone dla przykładu)

Reguły time i slow sterują animacją: obrót, zanikanie (a), jasność (b). draw komponuje warstwy według kolejności Z.

Zaawansowany przykład: proceduralne drzewo

Najbardziej złożony skrypt generuje realistyczne drzewo z gałęziami i liśćmi, używając funkcji i pętli.

startshape MAIN
CF::Background = [hue 0 sat 0.84 b -0.9]
CF::MinimumSize = 1
// Globalne stałe i funkcje: GTreePartMove, MaxTrunkDepth() = randint(10,40), RandRange, itd.
shape MAIN {
rule 1 {
SKY [ z -2 s 100 ]
SUN [ z -1 s 400 ]
TREE [ x -0.1 y -0.75 ]
GRASS [ x -1 y -1 ]
}
}
// ... (pełny kod z TRUNK, LEAFBUNCH, LEAFSTEM itd. definiuje rekurencyjne rozgałęzianie z randint i rand)

Funkcje jak MaxTrunkDepth() i NewBranchRotation() dodają losowość. TRUNK rośnie rekurencyjnie do EndDepth, potem się rozgałęzia. LEAFBUNCH symuluje korony z twist.

Główne konstrukcje CFDG

• Reguły (rule): rule Shape { ... } z prawdopodobieństwami (np. rule S 3 {..}).
• Transformacje: s (skala), r (obrót), x/y (przesunięcie), flip, z (warstwy).
• Kolor i efekty: hue, sat, b (jasność), a (alfa).
• Funkcje: randint(min,max), rand(min,max), loop N.
• Warunkowe: if/else dla rekursji.
• Start: startshape NAZWA, background{}.

Co ważne

• CFDG to kontekstowo-wolna gramatyka, idealna do fraktali i L-systemów bez kontekstu.
• Rekursja z prawdopodobieństwami i losowością zapewnia różnorodność.
• Obsługa bufora Z dla scen 2.5D.
• Licencja GPL, wieloplatformowość (Win/Mac/Linux).
• Alternatywy: Structure Synth dla 3D.

— Editorial Team