ruby-processing 2.4.4 → 2.5.0

data/samples/processing_app/topics/lsystems/library/stochastic_grammar/stochastic_grammar.rb

@@ -8,9 +8,8 @@ class StochasticGrammar
   PROB = 1
   attr_accessor :axiom, :srules
 
-  def initialize axiom
+  def initialize(axiom)
     @axiom = axiom
-    @srules = {}   # rules dictionary (a hash of hashes)
   end
 
   ######################################################
@@ -18,8 +17,8 @@ class StochasticGrammar
   #####################################################
 
   def stochastic_rule(rules)
-    total = rules.inject(0) do |total, rule_and_weight|
-      total += rule_and_weight[PROB]
+    total = rules.inject(0) do |sum, rule_and_weight|
+      sum + rule_and_weight[PROB]
     end
     srand
     chance = rand * total
@@ -30,29 +29,28 @@ class StochasticGrammar
     return rule
   end
 
-  def has_rule?(pre)
-    @srules.has_key?(pre)
+  def rule?(pre)
+    @srules.key?(pre)
   end
 
-  def add_rule(pre, rule, weight = 1.0)  # default weighting 1 (can handle non-stochastic rules)
-    if (has_rule?(pre))                  # add to existing hash
+  def add_rule(pre, rule, weight = 1.0)    # default weighting 1 (can handle non-stochastic rules)
+    @srules ||= Hash.new { |h, k| h[k] = 1 }
+    if rule?(pre)                      # add to existing hash
       srules[pre][rule] = weight
     else
-      srules[pre] = {rule => weight}     # store new hash with pre key
+      srules[pre] = { rule => weight }     # store new hash with pre key
     end
   end
 
   def new_production(prod)  # note the use of gsub!, we are changing prod as we go
     prod.gsub!(/./) do |ch|
-      (has_rule?(ch)) ? stochastic_rule(srules[ch]) : ch
+      rule?(ch) ? stochastic_rule(srules[ch]) : ch
     end
   end
 
   def generate(repeat = 0)
     prod = axiom
-    repeat.times do
-      prod = new_production(prod)
-    end
+    repeat.times { prod = new_production(prod) }
     return prod
   end
 end

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

@@ -4,27 +4,26 @@
 ########################################################
 load_library 'grammar'
 ####################################################
-# The MPeano fractal has been used to study the 
+# The MPeano fractal has been used to study the
 # Euclidean travelling salesman problem
 ####################################################
 class MPeano
   include Processing::Proxy
-  import 'grammar'
-  
+
   SQRT2 = Math.sqrt(2.0)
   ISQRT2 = 1/SQRT2
-  
+
   attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar, :delta
-  
-  def initialize xpos, ypos
-    @axiom = "XFF--AFF--XFF--AFF"       # Axiom
+
+  def initialize(xpos, ypos)
+    @axiom = 'XFF--AFF--XFF--AFF'       # Axiom
     rules = {
-      "X" => "+!X!FF-BQFI-!X!FF+",      # LSystem Rules
-      "F" => "",                        # Example of a 'delete' replace
-      "Y" => "FFY",
-      "A" => "BQFI",
-      "B" => "AFF"
-    }    
+      'X' => '+!X!FF-BQFI-!X!FF+',      # LSystem Rules
+      'F' => '',                        # Example of a 'delete' replace
+      'Y' => 'FFY',
+      'A' => 'BQFI',
+      'B' => 'AFF'
+    }
     @grammar = Grammar.new(axiom, rules)
     @delta   = QUARTER_PI          # 45 degrees
     @theta   = HALF_PI
@@ -32,28 +31,28 @@ class MPeano
     @xpos = xpos
     @ypos = ypos
   end
-  
-  def generate gen
+
+  def generate(gen)
     grammar.generate gen
   end
-  
+
   def translate_rules(prod)
     points = []               # An empty array to store line vertices
     prod.each do |ch|
       case(ch)
-      when "F"        
-        points << xpos << ypos << (@xpos -= draw_length * cos(theta)) << (@ypos -= draw_length * sin(theta)) 
-      when "+"
-        @theta += delta    
-      when "-"
-        @theta -= delta   
-      when "!"
+      when 'F'
+        points << xpos << ypos << (@xpos -= draw_length * cos(theta)) << (@ypos -= draw_length * sin(theta))
+      when '+'
+        @theta += delta
+      when '-'
+        @theta -= delta
+      when '!'
         @delta = -delta
-      when "I"
-        @draw_length *= ISQRT2    
-      when "Q"
-        @draw_length *= SQRT2    
-      when "X", "A", "B"     
+      when 'I'
+        @draw_length *= ISQRT2
+      when 'Q'
+        @draw_length *= SQRT2
+      when 'X', 'A', 'B'
       else
         puts("character '#{ch}' not in grammar")
       end
@@ -66,7 +65,7 @@ attr_reader :points
 
 def setup
   size(600, 600)
-  mpeano = MPeano.new(width/2, height*0.95)
+  mpeano = MPeano.new(width / 2, height * 0.95)
   production = mpeano.generate 7                  # 7 generations looks OK
   @points = mpeano.translate_rules(production)
   no_loop
@@ -78,6 +77,4 @@ def draw
   points.each_slice(4) do |point|
     line(*point)
   end
-end
-
-
+end

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

@@ -2,57 +2,55 @@
 # A Peano fractal implemented using a
 # Lindenmayer System in ruby-processing by Martin Prout
 ########################################################
-load_library 'grammar'
+load_libraries :grammar, :fastmath, :vecmath
 
 class Peano
-  include Processing::Proxy
-  import 'grammar'
+  include Processing::Proxy 
   
-  
-  attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar
-  DELTA  = PI/3    # 60 degrees
-  def initialize xpos, ypos
-    @axiom = "XF"       # Axiom
+  attr_reader :draw_length, :vec, :theta, :axiom, :grammar
+  DELTA  = 60  # degrees
+  def initialize vec
+    @axiom = 'XF'       # Axiom
     rules = {
-      'X' => "X+YF++YF-FX--FXFX-YF+",      # LSystem Rules
-      "Y" => "-FX+YFYF++YF+FX--FX-Y"
+      'X' => 'X+YF++YF-FX--FXFX-YF+',      # LSystem Rules
+      'Y' => '-FX+YFYF++YF+FX--FX-Y'
     }    
     @grammar = Grammar.new(axiom, rules)
     @theta   = 0  
     @draw_length = 100
-    @xpos = xpos
-    @ypos = ypos
+    @vec = vec
   end
   
   def generate gen
-    @draw_length = draw_length * pow(0.6, gen)
+    @draw_length = draw_length * 0.6**gen
     grammar.generate gen
   end
   
   def translate_rules(prod)
-    points = []               # An empty array to store line vertices
+    points = []               # An empty array to store line vertices as Vec2D
     prod.each do |ch|
       case ch
       when 'F'
-        points << xpos << ypos << (@xpos += draw_length * cos(theta)) << (@ypos -= draw_length * sin(theta))
+        points << vec.copy << Vec2D.new(vec.x += draw_length * DegLut.cos(theta), vec.y -= draw_length * DegLut.sin(theta))
       when '+'
         @theta += DELTA        
       when '-'
         @theta -= DELTA        
       when 'X', 'Y'        
       else
-        puts("character  #{ch} not in grammar")        
+        puts("character #{ch} not in grammar")        
       end      
     end
     return points
   end
 end
 
-attr_reader :points
+attr_reader :points, :renderer
 
 def setup
   size(800, 800)
-  peano = Peano.new(width * 0.65, height * 0.9)
+  @renderer = AppRender.new(self)
+  peano = Peano.new(Vec2D.new(width * 0.65, height * 0.9))
   production = peano.generate 4                  # 4 generations looks OK
   @points = peano.translate_rules(production)  
   no_loop
@@ -68,9 +66,9 @@ def render points
   stroke 200.0
   stroke_weight 3
   begin_shape
-  points.each_slice(4) do |x0, y0, x1, y1|
-    vertex x0, y0
-    vertex x1, y1
+  points.each_slice(2) do |v0, v1|
+    v0.to_vertex(renderer) 
+    v1.to_vertex(renderer)
   end
   end_shape 
 end

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

@@ -2,7 +2,7 @@
 # penrose tiling in ruby processing using LSystems
 # in ruby-processing by Martin Prout
 ######################################################
-load_libraries "grammar"
+load_libraries :grammar, :fastmath
 
 attr_reader :penrose
 
@@ -10,9 +10,9 @@ def setup
   size 800, 800
   stroke_weight 2
   smooth
-  @penrose = PenroseColored.new(width/2, height/2)
+  @penrose = PenroseColored.new(width / 2, height / 2)
   penrose.create_grammar 5
-  no_loop  
+  no_loop
 end
 
 def draw
@@ -20,7 +20,7 @@ def draw
   penrose.render
 end
 
-
+Turtle = Struct.new(:x, :y, :angle, :color)
 
 #############################
 # penrose_colored.rb
@@ -28,30 +28,23 @@ end
 
 class PenroseColored
   include Processing::Proxy
-  import 'grammar'
   
-  attr_reader :axiom, :grammar, :start_length, :theta, :production, :draw_length,
-  :repeats, :xpos, :ypos
+  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
+  DELTA = 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    
+  def initialize(xpos, ypos)             # Note use of abbreviated grammar 
+    @axiom = '[X]2+[X]2+[X]2+[X]2+[X]'   # nos, 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",       
-      }
+      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
@@ -70,27 +63,29 @@ class PenroseColored
   
   def render
     repeats = 1
-    pen = [xpos, ypos, theta, :R]   # simple array for pen, symbol :R = red
+    ignored = %w(W X Y Z)
+    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|
       case element
       when 'F'
         pen = draw_line(pen, draw_length)
       when '+'
-        pen[ANGLE] += DELTA * repeats
+        pen.angle += DELTA * repeats
         repeats = 1
       when '-'
-        pen[ANGLE] -= DELTA * repeats
+        pen.angle -= DELTA * repeats
         repeats = 1
       when '['
-        stack.push(pen.dup)  # push a copy current pen to stack
+        stack << 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)
+        pen.color = element.to_sym  # set pen color as symbol
+      when *ignored
+      when *repeated
+        repeats = element.to_i
       else puts "Character '#{element}' not in grammar"
       end
     end
@@ -106,18 +101,17 @@ class PenroseColored
   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
+    stroke(pen.color == :R ? RED : BLUE)
+    new_xpos = pen.x - length * DegLut.cos(pen.angle)
+    new_ypos = pen.y - length * DegLut.sin(pen.angle)
+    line(pen.x, pen.y, new_xpos, new_ypos)    # draw line
+    Turtle.new(new_xpos, new_ypos, pen.angle, pen.color) # return pen @ new pos
   end
 end
-
-

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

@@ -1,18 +1,15 @@
-load_library 'grammar'
+load_libraries :grammar, :fastmath
 
 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
+  attr_accessor :axiom, :grammar, :start_length, :theta, :production,
+    :draw_length, :xpos, :ypos
+  DELTA = 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"}
-    )
+    @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
@@ -48,7 +45,7 @@ class PenroseSnowflake
 
   ##########################################
   # adjust draw length with number of repeats
-  # uses grammar to set production string 
+  # uses grammar to set production string
   # see 'grammar.rb'
   ##########################################
 
@@ -56,7 +53,7 @@ class PenroseSnowflake
     @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
@@ -65,7 +62,7 @@ class PenroseSnowflake
   def multiplier(repeats, type)
     value = draw_length * repeats
     # using equal? for identity comparison
-    (type.equal? :cos)?  value * cos(theta) : value *  sin(theta)
+    (type.equal? :cos)?  value * DegLut.cos(theta) : value *  DegLut.sin(theta)
   end
 end
 
@@ -82,12 +79,10 @@ def setup
   stroke 255
   @penrose = PenroseSnowflake.new width * 0.8, height * 0.95
   penrose.create_grammar 4
-  no_loop    
+  no_loop
 end
 
 def draw
   background 0
   penrose.render
 end
-
-

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

@@ -1,35 +1,32 @@
 ############################
 # pentagonal.rb here I roll one of my own
 ###########################
-load_library 'grammar'
+load_library :grammar, :fastmath
 
 class Pentagonal
   include Processing::Proxy
-  import 'grammar'
-  DELTA = (Math::PI/180) * 72.0    # convert degrees to radians
+  DELTA = 72    # degrees
   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"}
-      )
+  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 
-  
+  end
+
   def make_shape
     no_fill
     shape = create_shape
@@ -40,25 +37,25 @@ class Pentagonal
     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))   
+        shape.vertex(@xpos -= adjust(:cos), @ypos += adjust(:sin))
       when '+'
-        @theta += DELTA        
+        @theta += DELTA
       when '-'
-        @theta -= DELTA        
-      else puts "Grammar not recognized"
+        @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)
+    (type.equal? :cos)?  draw_length * DegLut.cos(theta) : draw_length * DegLut.sin(theta)
   end
 end
 
@@ -67,7 +64,7 @@ end
 # Lindenmayer System in ruby-processing by Martin Prout
 ###
 
-#  Empirically determined pstition addjustments
+#  Empirically determined pstition adjustments
 ADJUST = [[800, 50], [500, 500], [500, 500], [300, 280], [50, 600]]
 
 attr_reader :pentagonal, :pentive
@@ -82,7 +79,7 @@ def setup
 end
 
 def draw
-  background 0  
+  background 0
   shape(pentive)
 end
 
@@ -94,10 +91,10 @@ def key_pressed
     pentagonal.create_grammar gen
     @pentive = pentagonal.make_shape
     pentive.translate(ADJUST[gen - 1][0], ADJUST[gen - 1][1])
-  else    
+  else
     @pentagonal = Pentagonal.new
     pentagonal.create_grammar 2
     @pentive = pentagonal.make_shape
     pentive.translate(ADJUST[1][0], ADJUST[1][1])
   end
-end
+end