ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/lsystems/penrose.rb

@@ -0,0 +1,123 @@
+#######################################################
+# penrose tiling in ruby processing using LSystems
+# in ruby-processing by Martin Prout
+######################################################
+load_libraries "grammar"
+
+attr_reader :penrose
+
+def setup
+  size 800, 800
+  stroke_weight 2
+  smooth
+  @penrose = PenroseColored.new(width/2, height/2)
+  penrose.create_grammar 5
+  no_loop  
+end
+
+def draw
+  background 0
+  penrose.render
+end
+
+
+
+#############################
+# penrose_colored.rb
+#############################
+
+class PenroseColored
+  include Processing::Proxy
+  import 'grammar'
+  
+  attr_reader :axiom, :grammar, :start_length, :theta, :production, :draw_length,
+  :repeats, :xpos, :ypos
+  
+  XPOS = 0     # placeholders for pen array
+  YPOS = 1
+  ANGLE = 2
+  COL = 3
+  DELTA = PI/5 # radians or 36 degrees
+  RED = 70<<24|200<<16|0<<8|0   # using bit operations to set color int
+  BLUE = 70<<24|0<<16|0<<8|200
+  
+  def initialize xpos, ypos                  # Note using abbreviated lsystem grammar 
+    @axiom = "[X]2+[X]2+[X]2+[X]2+[X]"       # where numbers, are used to indicate repeats    
+    @grammar = Grammar.new(
+      axiom,                                 
+      {
+        "F" => "",                           # a so called deletion rule
+        "W" => "YBF2+ZRF4-XBF[-YBF4-WRF]2+", # regular substitution rules ....
+        "X" => "+YBF2-ZRF[3-WRF2-XBF]+",
+        "Y" => "-WRF2+XBF[3+YBF2+ZRF]-",
+        "Z" => "2-YBF4+WRF[+ZRF4+XBF]2-XBF",       
+      }
+      )
+    @start_length = 1000.0
+    @theta = 0
+    @xpos = xpos
+    @ypos = ypos
+    @production = axiom
+    @draw_length = start_length
+  end
+  
+  ##############################################################################
+  # Not strictly in the spirit of either processing in my render
+  # function I have ignored the processing translate/rotate functions in favour
+  # of the direct calculation of the new x and y positions, thus avoiding such
+  # affine transformations.
+  ##############################################################################
+  
+  def render
+    repeats = 1
+    pen = [xpos, ypos, theta, :R]   # simple array for pen, symbol :R = red
+    stack = []                      # simple array for stack
+    production.each do |element|
+      case element
+      when 'F'
+        pen = draw_line(pen, draw_length)
+      when '+'
+        pen[ANGLE] += DELTA * repeats
+        repeats = 1
+      when '-'
+        pen[ANGLE] -= DELTA * repeats
+        repeats = 1
+      when '['
+        stack.push(pen.dup)  # push a copy current pen to stack
+      when ']'
+        pen = stack.pop      # assign current pen to instance off the stack
+      when 'R', 'B'        
+        pen[COL] = element.to_sym  # set pen color as symbol
+      when 'W', 'X', 'Y', 'Z'  
+      when '1', '2', '3', '4'
+        repeats = Integer(element)
+      else puts "Character '#{element}' not in grammar"
+      end
+    end
+  end
+  
+  #####################################################
+  # create grammar from axiom and # rules (adjust scale)
+  #####################################################
+  
+  def create_grammar(gen)
+    @draw_length *= 0.5**gen
+    @production = grammar.generate gen
+  end
+  
+  private
+  ####################################################################
+  # draws line using current pen position, color and length parameters
+  # returns a pen corresponding to the new position
+  ###################################################################
+  
+  def draw_line(pen, length)
+    stroke (pen[COL] == :R)? RED : BLUE
+    new_xpos = pen[XPOS] - length * cos(pen[ANGLE])
+    new_ypos = pen[YPOS] - length * sin(pen[ANGLE])
+    line(pen[XPOS], pen[YPOS], new_xpos, new_ypos)    # draw line
+    return [new_xpos, new_ypos, pen[ANGLE], pen[COL]] # return pen @ new pos
+  end
+end
+
+

data/samples/processing_app/topics/lsystems/penrose_snowflake.rb

@@ -0,0 +1,93 @@
+load_library 'grammar'
+
+class PenroseSnowflake
+  include Processing::Proxy
+  import 'grammar'
+
+  attr_accessor :axiom, :grammar, :start_length, :theta, :production, :draw_length,
+    :repeats, :xpos, :ypos
+  DELTA = Math::PI / 10 # 18 degrees as radians
+
+  def initialize xpos, ypos
+    @axiom = "F3-F3-F3-F3-F"
+    @grammar = Grammar.new( axiom,
+    {"F" => "F3-F3-F45-F++F3-F"}
+    )
+    @start_length = 450.0
+    @theta = 0
+    @xpos = xpos
+    @ypos = ypos
+    @draw_length = start_length
+  end
+
+  ##############################################################################
+  # Parses the production string, and draws a line when 'F' is found, uses
+  # trignometry to calculate dx and dy rather than processing transforms
+  ##############################################################################
+
+  def render
+    repeats = 1
+    production.each do |element|
+      case element
+      when 'F'
+        line(xpos, ypos, (@xpos -= multiplier(repeats, :cos)), (@ypos += multiplier(repeats, :sin)))
+        repeats = 1
+      when '+'
+        @theta += DELTA * repeats
+        repeats = 1
+      when '-'
+        @theta -= DELTA * repeats
+        repeats = 1
+      when '3', '4', '5'
+        repeats += element.to_i
+      else
+        puts "Character '#{element}' is not in grammar"
+      end
+    end
+  end
+
+  ##########################################
+  # adjust draw length with number of repeats
+  # uses grammar to set production string 
+  # see 'grammar.rb'
+  ##########################################
+
+  def create_grammar(gen)
+    @draw_length *= 0.4**gen
+    @production = grammar.generate gen
+  end
+  
+  ###########################################
+  # a helper method that returns dx or dy with type & repeat
+  # multiplier after Dan Mayer
+  ###########################################
+
+  def multiplier(repeats, type)
+    value = draw_length * repeats
+    # using equal? for identity comparison
+    (type.equal? :cos)?  value * cos(theta) : value *  sin(theta)
+  end
+end
+
+##
+# Lindenmayer System in ruby-processing by Martin Prout
+# Very loosely based on a processing Penrose L-System
+# by Geraldine Sarmiento
+###
+
+attr_reader :penrose
+
+def setup
+  size 1000, 900
+  stroke 255
+  @penrose = PenroseSnowflake.new width * 0.8, height * 0.95
+  penrose.create_grammar 4
+  no_loop    
+end
+
+def draw
+  background 0
+  penrose.render
+end
+
+

data/samples/processing_app/topics/lsystems/pentagonal.rb

@@ -0,0 +1,103 @@
+############################
+# pentagonal.rb here I roll one of my own
+###########################
+load_library 'grammar'
+
+class Pentagonal
+  include Processing::Proxy
+  import 'grammar'
+  DELTA = (Math::PI/180) * 72.0    # convert degrees to radians
+  attr_accessor :draw_length
+  attr_reader :axiom, :grammar, :theta, :production, :xpos, :ypos
+  def initialize 
+    @axiom = "F-F-F-F-F"
+    @grammar = Grammar.new( axiom,
+      {"F" => "F+F+F-F-F-F+F+F"}
+      )
+    @draw_length = 400
+    @theta = 0.0
+    @xpos = 0.0
+    @ypos = 0.0
+  end
+  
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+  
+  def create_grammar(gen)
+    @draw_length *= 0.25**gen
+    @production = grammar.generate gen
+  end 
+  
+  def make_shape
+    no_fill
+    shape = create_shape
+    shape.begin_shape
+    shape.stroke 200
+    shape.stroke_weight 3
+    shape.vertex(xpos, ypos)
+    production.each do |element|
+      case element
+      when 'F'    # you could use processing transforms here, I prefer to do the Math
+        shape.vertex(@xpos -= adjust(:cos), @ypos += adjust(:sin))   
+      when '+'
+        @theta += DELTA        
+      when '-'
+        @theta -= DELTA        
+      else puts "Grammar not recognized"
+      end
+    end
+    shape.end_shape
+    return shape
+  end
+  
+  ###########################################
+  # a helper method that returns dx or dy with type
+  ###########################################
+  
+  def adjust(type)
+    # using equal? for identity comparison
+    (type.equal? :cos)?  draw_length * cos(theta) : draw_length *  sin(theta)
+  end
+end
+
+##
+# A Pentagonal Fractal created using a
+# Lindenmayer System in ruby-processing by Martin Prout
+###
+
+#  Empirically determined pstition addjustments
+ADJUST = [[800, 50], [500, 500], [500, 500], [300, 280], [50, 600]]
+
+attr_reader :pentagonal, :pentive
+
+
+def setup
+  size 800, 800, P2D
+  @pentagonal = Pentagonal.new
+  pentagonal.create_grammar 2
+  @pentive = pentagonal.make_shape
+  pentive.translate(ADJUST[1][0], ADJUST[1][1])
+end
+
+def draw
+  background 0  
+  shape(pentive)
+end
+
+def key_pressed
+  case key
+  when '1', '2', '3', '4', '5'  # key corresponds to generation
+    gen = key.to_i
+    @pentagonal = Pentagonal.new
+    pentagonal.create_grammar gen
+    @pentive = pentagonal.make_shape
+    pentive.translate(ADJUST[gen - 1][0], ADJUST[gen - 1][1])
+  else    
+    @pentagonal = Pentagonal.new
+    pentagonal.create_grammar 2
+    @pentive = pentagonal.make_shape
+    pentive.translate(ADJUST[1][0], ADJUST[1][1])
+  end
+end

data/samples/processing_app/topics/lsystems/snake_kolam.rb

@@ -0,0 +1,93 @@
+#######################################################
+# Lindenmayer System in ruby-processing by Martin Prout
+# snake_kolam.rb using l-systems
+#######################################################
+
+load_library 'grammar'
+
+class SnakeKolam
+  include Processing::Proxy
+  import 'grammar'
+  attr_accessor :axiom, :start_length, :xpos, :ypos, :grammar, :production, :draw_length, :gen
+  XPOS = 0
+  YPOS = 1
+  ANGLE = 2
+  DELTA = (PI/180) * 90.0 # convert degrees to radians
+  
+  def initialize xpos, ypos
+    setup_grammar
+    @start_length = 120.0
+    @theta = (PI/180) * 90.0 # convert degrees to radians
+    @draw_length = start_length
+    @xpos = xpos 
+    @ypos = ypos 
+  end
+  
+  def setup_grammar
+    @axiom = "FX+F+FX+F"
+    @grammar = Grammar.new(
+      axiom,
+      {"X" => "X-F-F+FX+F+FX-F-F+FX"}
+      )
+  end
+    
+  def render                     # NB not using affine transforms here
+    turtle = [xpos, ypos, 0.0]
+    production.each do |element|
+      case element
+      when 'F'                     
+        turtle = draw_line(turtle, draw_length)
+      when '+'
+        turtle[ANGLE] += DELTA   # rotate by + theta if going the affine transform route
+      when '-'
+        turtle[ANGLE] -= DELTA   # rotate by - theta if going the affine transform route
+      when 'X'                   # do nothing except recognize 'X' as a word in the L-system grammar
+      else 
+        puts "Character '#{element}' is not in grammar" 
+      end
+    end
+  end
+  
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+  
+  def create_grammar(gen)
+    @gen = gen
+    @draw_length *= 0.6**gen
+    @production = @grammar.generate gen
+  end    
+  
+  private
+  ######################################################
+  # draws line using current turtle and length parameters
+  # returns a turtle corresponding to the new position
+  ######################################################
+  
+  def draw_line(turtle, length)
+    new_xpos = turtle[XPOS] + length * Math.cos(turtle[ANGLE])
+    new_ypos = turtle[YPOS] + length * Math.sin(turtle[ANGLE])
+    line(turtle[XPOS], turtle[YPOS], new_xpos, new_ypos)
+    turtle = [new_xpos, new_ypos, turtle[ANGLE]]
+  end
+end  
+  
+  
+attr_reader :kolam
+
+def setup
+  size 500, 500
+  @kolam = SnakeKolam.new width/8, height*0.8
+  kolam.create_grammar 3          # create grammar from rules
+  no_loop
+end
+
+def draw
+  background 0
+  stroke_weight 3
+  stroke 200
+  kolam.render 
+end
+  
+

data/samples/processing_app/topics/lsystems/stochastic_test.rb

@@ -0,0 +1,99 @@
+#######################################################
+# stochastic_test.rb
+#
+# Lindenmayer System in ruby-processing by Martin Prout
+# Exploring terminals with minimum logic 
+########################################################
+
+load_library 'stochastic_grammar'
+
+class StochasticPlant
+  include Processing::Proxy
+
+  attr_reader :grammar, :axiom, :draw_length, :theta, :xpos, :ypos, :production
+
+  XPOS = 0     # placeholders for turtle array
+  YPOS = 1
+  ANGLE = 2
+
+  DELTA = PI/8
+
+  def initialize xpos_, ypos_   
+    @draw_length = 350
+    @xpos = xpos_
+    @ypos = ypos_
+    @theta = HALF_PI                  # this way is up?
+    setup_grammar
+  end
+
+  def setup_grammar
+    @axiom = "F"
+    @grammar = StochasticGrammar.new(axiom)           
+    grammar.add_rule("F", "F[+F]F[-F]F", 0.1)     
+    grammar.add_rule("F", "F[+F]F", 0.45)           
+    grammar.add_rule("F", "F[-F]F", 0.45)
+    @production = axiom
+  end
+
+  def render
+    stack = []                     # ruby array as the turtle stack
+    turtle = [xpos, ypos, theta]   # ruby array as a turtle
+    production.each_char do |element|
+      case element
+      when 'F'                     # NB NOT using affine transforms
+        turtle = draw_line(turtle, draw_length)
+      when '+'
+        turtle[ANGLE] += DELTA
+      when '-'
+        turtle[ANGLE] -= DELTA   
+      when '['
+        stack.push(turtle.dup)    # push a copy of the current turtle to stack 
+      when ']'
+        turtle = stack.pop        # assign current turtle to an instance popped from the stack
+      else
+        puts "Character '#{element}' is not in grammar"
+      end
+    end
+  end
+
+  def create_grammar gen
+    @draw_length *= 0.5**gen
+    @production = grammar.generate gen
+  end
+
+  private
+  ######################################################
+  # draws a line using current turtle and length parameters
+  # returns a turtle corresponding to the new position
+  ######################################################
+
+  def draw_line(turtle, length)
+    new_xpos = turtle[XPOS] + length * cos(turtle[ANGLE])
+    new_ypos = turtle[YPOS] - length * sin(turtle[ANGLE])
+    line(turtle[XPOS], turtle[YPOS], new_xpos, new_ypos) 
+    turtle = [new_xpos, new_ypos, turtle[ANGLE]]
+  end
+end
+
+
+attr_reader :stochastic, :stochastic1, :stochastic2
+
+def setup
+  size 1000, 800
+  @stochastic = StochasticPlant.new 200, 700
+  @stochastic1 = StochasticPlant.new 500, 700
+  @stochastic2 = StochasticPlant.new 700, 700
+  stochastic.create_grammar 5
+  stochastic1.create_grammar 4 # simpler plant
+  stochastic2.create_grammar 5
+  no_loop
+end
+
+def draw
+  background 0
+  stroke(0, 255, 0)
+  stroke_width(3)
+  stochastic.render
+  stochastic1.render
+  stochastic2.render
+end