**def**

**setup**

size(

**300**,

**300**)

length =

**70**

stroke_weight

**3**

translate(width/

**2**, height -

**20**)

rotate(-

**PI**/

**2**)

line(

**0**,

**0**, length,

**0**)

translate(length,

**0**)

push_matrix

rotate(

**PI**/

**4**)

line(

**0**,

**0**, length,

**0**)

pop_matrix

push_matrix

rotate(-

**PI**/

**4**)

line(

**0**,

**0**, length,

**0**)

pop_matrix

line(

**0**,

**0**, length,

**0**)

translate(length,

**0**)

push_matrix

rotate(

**PI**/

**4**)

line(

**0**,

**0**, length,

**0**)

pop_matrix

push_matrix

rotate(-

**PI**/

**4**)

line(

**0**,

**0**, length,

**0**)

pop_matrix

line(

**0**,

**0**, length,

**0**)

**end**

Then I thought it would be a bit of fun to develop a kind of tree tutorial, so moving from this very procedural approach I thought the least I could do would be to extract a couple of functions. One to produce a trunk element and another to produce a branch element:-

**def**

**setup**

size(

**300**,

**300**)

length =

**70**

stroke_weight

**3**

translate(width/

**2**, height -

**20**)

rotate(-

**PI**/

**2**)

trunk length

branch

**PI**/

**4**, length

branch -

**PI**/

**4**, length

trunk length

length *=

**0.8**

**# reduce length**

branch

**PI**/

**4**, length

branch -

**PI**/

**4**, length

trunk length

**end**

**def**

**branch**angle, len

push_matrix

rotate angle

line

**0**,

**0**, len,

**0**

pop_matrix

**end**

**def**

**trunk**len

line

**0**,

**0**, len,

**0**

translate len,

**0**

**end**

Making the tree a bit more complicated, creating one new function gave the following:-

**def**

**setup**

size(

**300**,

**300**)

length =

**70**

stroke_weight

**3**

translate(width/

**2**, height -

**20**)

rotate(-

**PI**/

**2**)

trunk length

branch

**PI**/

**4**, length

branch -

**PI**/

**4**, length

length *=

**0.9**

**# reduce overall length**

branch

**0**, length

trunk length

branch

**0**, length

save_frame

**"**

**tree3.png**

**"**

**end**

**def**

**branch**angle, len

push_matrix

rotate angle

trunk len

angle =

**PI**/

**4**

**if**angle ==

**0**

**# then vertical branch element**

terminal_branch angle, len

terminal_branch -angle, len

trunk len

pop_matrix

**end**

**def**

**terminal_branch**angle, len

push_matrix

rotate angle

line

**0**,

**0**, len*

**0.8**,

**0**

**# reduce length of terminal branch**

pop_matrix

**end**

**def**

**trunk**len

line

**0**,

**0**, len,

**0**

translate len,

**0**

**end**

Now there has got to be easier way to do this and there are several. One way is to use LSystems to describe the tree, and another is to use recursion like in context free art.

Here are some context free rules (by curran) run with the c++ program cfdg with variation set to JIQ

**rule**

__tree__**20**{

**CIRCLE**{

**size**

**0.25**}

**scraggle**{

**y**

**0.1**}

}

**rule**

**{**

__scraggle__**tree**{

**rotate**

**5**}

}

**rule**

**{**

__scraggle__**tree**{

**rotate**

**-5**}

}

**rule**

__tree__**1**{

**branch**{

**size**

**0.7**}

}

**rule**

**{**

__branch__**tree**{

**rotate**

**-10**}

**tree**{

**rotate**

**10**}

}

Here are the cfdg rules above translated to run as ruby-processing context-free DSL script:-

**#################################################################**

**# A non deterministic sketch run it until you get a result you like**

**# uncomment "srand 5" to get a more deterministic result. It looked**

**# pretty good on my linux box (however I'm not sure how universal the**

**# random seeding is in jruby)**

**#################################################################**

load_library

**'**

**context_free**

**'**

**def**

**setup_the_tree**

**@tree**=

**ContextFree**.define

**do**

rule

**:trunk**,

**20**

**do**

**# rule has a probability weighting of 20**

circle

**:size**=>

**0.25**,

**:brightness**=>

**0**

**# giving an actual probability = 0.952381**

scraggle

**:y**=> -

**0.1**

**# the minus is require by the upside down coordinate system**

**end**

rule

**:trunk**,

**1**

**do**

**# rule has a probability weighting of 1**

branch

**:size**=>

**0.7**

**# giving an actual probability = 0.047619**

**end**

rule

**:branch**

**do**

split

**do**

**# split is like a branch, rewind returns original context**

trunk

**:rotation**=>

**10**

rewind

trunk

**:rotation**=> -

**10**

**end**

**end**

rule

**:scraggle**

**do**

**# without an explicit weighting**

trunk

**:rotation**=>

**5**

**# probability of each scraggle rule**

**end**

**# is 0.5**

rule

**:scraggle**

**do**

trunk

**:rotation**=> -

**5**

**end**

**end**

**end**

**def**

**setup**

size

**600**,

**600**

**# srand 5**

smooth

setup_the_tree

background

**255**

**# NB color mode here is "RGB 255", within context free definition**

draw_it

**# the color mode is "HSB 1.0", supports :hue, :saturation, :brightness**

**end**

**def**

**draw_it**

**@tree**.render

**:trunk**,

**:start_x**=> width/

**2**,

**:start_y**=> height *

**0.9**,

**:size**=> height/

**18**

**end**

Follow this link to see an LSystem tree implementation

Context free programs run with multiple definitions of a rule are non-deterministic, so it is quite usual to get different results each time the program is run.

## No comments:

## Post a Comment