Refactor LSystems

Author: monkstone

processing_app/topics/lsystems/chequer.rb

@@ -44,7 +44,7 @@ def initialize(xpos, ypos)
   end
 
   def render
-    production.each do |element|
+    production.scan(/./) do |element|
       case element
       when 'F'
         x_temp = xpos

processing_app/topics/lsystems/david_tour.rb

@@ -59,7 +59,7 @@ def create_grammar(gen)
   def translate_rules(prod)
     swap = false
     [].tap do |points| # An array to store lines as a flat array of points
-      prod.each do |ch|
+      prod.scan(/./) do |ch|
         case ch
         when 'F'
           points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))

processing_app/topics/lsystems/library/grammar/grammar.rb

@@ -8,28 +8,21 @@ def initialize(axiom, rules)
     @rules = rules
   end
 
-  def expand(production, iterations, &block)
-    production.each_char do |token|
-      if rules.key?(token) && iterations > 0
-        expand(rules[token], iterations - 1, &block)
-      else
-        yield token
-      end
-    end
-  end
-
-  def each(gen)
-    expand(axiom, gen) { |token| yield token }
+  def apply_rules(prod)
+    prod.gsub(/./) { |token| rules.fetch(token, token) }
   end
 
   def generate(gen)
-    [].tap do |output|
-      each(gen) { |token| output << token }
+    return axiom if gen.zero?
+
+    prod = axiom
+    gen.times do
+      prod = apply_rules(prod)
     end
+    prod
   end
 end
 
-
 Turtle = Struct.new(:x, :y, :angle, :color)
 
 #############################
@@ -75,7 +68,7 @@ def render
     repeated = %w(1 2 3 4)
     pen = Turtle.new(xpos, ypos, theta, :R)   # simple Struct for pen, symbol :R = red
     stack = []                      # simple array for stack
-    production.each do |element|
+    production.scan(/./) do |element|
       case element
       when 'F'
         pen = draw_line(pen, draw_length)

processing_app/topics/lsystems/library/koch/koch_fractal.rb

@@ -62,7 +62,7 @@ def generate(gen)
 
   def translate_rules(prod)
     [].tap do |points|      # An empty array to store line vertices
-      prod.each do |ch|
+      prod.scan(/./) do |ch|
         case ch
         when 'F'
           points << xpos << ypos << (@xpos -= draw_length * cos(theta)) << (@ypos -= draw_length * sin(theta))

processing_app/topics/lsystems/mpeano.rb

@@ -68,7 +68,7 @@ def translate_rules(prod)
     coss = ->(orig, alpha, len) { orig + len * DegLut.cos(alpha) }
     sinn = ->(orig, alpha, len) { orig - len * DegLut.sin(alpha) }
     [].tap do |pts| # An array to store line vertices as Vec2D
-      prod.each do |ch|
+      prod.scan(/./) do |ch|
         case ch
         when 'F'
           pts << vec.copy

processing_app/topics/lsystems/peano.rb

@@ -35,11 +35,11 @@ class PenroseSnowflake
 
   attr_accessor :axiom, :grammar, :start_length, :theta, :production,
   :draw_length, :xpos, :ypos
-  DELTA = 18 # degrees as radians
+  DELTA = 36 # degrees
 
   def initialize(xpos, ypos)
-    @axiom = 'F3-F3-F3-F3-F'
-    @grammar = Grammar.new(axiom, 'F' => 'F3-F3-F45-F++F3-F')
+    @axiom = 'F2-F2-F2-F2-F'
+    @grammar = Grammar.new(axiom, 'F' => 'F2-F2-F5-F+F2-F')
     @start_length = 450.0
     @theta = 0
     @xpos = xpos
@@ -54,7 +54,7 @@ def initialize(xpos, ypos)
 
   def render
     repeats = 1
-    production.each do |element|
+    production.scan(/./) do |element|
       case element
       when 'F'
         line(xpos, ypos, (@xpos -= multiplier(repeats, :cos)), (@ypos += multiplier(repeats, :sin)))
@@ -65,8 +65,8 @@ def render
       when '-'
         @theta -= DELTA * repeats
         repeats = 1
-      when '3', '4', '5'
-        repeats += element.to_i
+      when '2', '5'
+        repeats = element.to_i
       else
         puts "Character '#{element}' is not in grammar"
       end

processing_app/topics/lsystems/penrose_snowflake.rb

@@ -79,7 +79,7 @@ def make_shape
       shape.stroke 200
       shape.stroke_weight 3
       shape.vertex(xpos, ypos)
-      production.each do |element|
+      production.scan(/./) do |element|
         case element
         when 'F'
           shape.vertex(@xpos -= adjust(:cos), @ypos += adjust(:sin))

processing_app/topics/lsystems/pentagonal.rb

@@ -28,6 +28,8 @@ def settings
   end
 end
 
+SimpleTurtle = Struct.new(:x, :y, :angle)
+
 # class SnakeKolam
 class SnakeKolam
   include Propane::Proxy
@@ -55,15 +57,15 @@ def setup_grammar
   end
 
   def render # NB not using affine transforms here
-    turtle = [xpos, ypos, 0]
-    production.each do |element|
+    turtle = SimpleTurtle.new(xpos, ypos, 0)
+    production.scan(/./) do |element|
       case element
       when 'F'
         turtle = draw_line(turtle, draw_length)
       when '+'
-        turtle[ANGLE] += DELTA
+        turtle.angle += DELTA
       when '-'
-        turtle[ANGLE] -= DELTA
+        turtle.angle -= DELTA
       when 'X'
       else
         puts "Character '#{element}' is not in grammar"
@@ -90,10 +92,12 @@ def create_grammar(gen)
   ######################################################
 
   def draw_line(turtle, length)
-    new_xpos = turtle[XPOS] + length * DegLut.cos(turtle[ANGLE])
-    new_ypos = turtle[YPOS] + length * DegLut.sin(turtle[ANGLE])
-    line(turtle[XPOS], turtle[YPOS], new_xpos, new_ypos)
-    [new_xpos, new_ypos, turtle[ANGLE]]
+    x_temp = turtle.x
+    y_temp = turtle.y
+    turtle.x += draw_length * DegLut.cos(turtle.angle)
+    turtle.y += draw_length * DegLut.sin(turtle.angle)
+    line(x_temp, y_temp, turtle.x, turtle.y)
+    turtle
   end
 end