ruby-processing 2.4.4 → 2.5.0

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

@@ -5,15 +5,20 @@
 load_library 'cs_grammar'
 
 def setup
+  size 150, 250
+  background 0
+  fill(200, 200, 0)
+  f = create_font('Arial', 16, true)
+  text_font(f)
   (0 .. 7).each do |i|
     grammar = Grammar.new(
-      "baaaaaa",
+      'baaaaaa',
       {
-        "b<a" => "b",   # context sensitive rule replace a when preceded by b
-        "b"   =>"a"
+        'b<a' => 'b',   # context sensitive rule replace a when preceded by b
+        'b'   =>'a'
       }
       )    
-    puts grammar.generate(i)
+    text grammar.generate(i), 30, i * 25
   end
 end
 

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

@@ -8,41 +8,39 @@ class DavidTour
   import 'grammar'
   attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar
   DELTA = Math::PI/3 # 60 degrees
-  
-  def initialize xpos, ypos
-    @axiom = "FX-XFX-XFX-XFX-XFX-XF"   # Axiom
+
+  def initialize(xpos, ypos)
+    @axiom = 'FX-XFX-XFX-XFX-XFX-XF'   # Axiom
     @theta  = 0
     @grammar = Grammar.new(
       axiom,
-      {
-        "F" => "!F!-F-!F!",            # Rules
-        "X" => "!X"      
-      }
+      'F' => '!F!-F-!F!',              # Rules
+      'X' => '!X'
       )
     @draw_length = 15
     @xpos = xpos
     @ypos = ypos
   end
-  
-  def create_grammar(gen)  
+
+  def create_grammar(gen)
     @draw_length *= draw_length * 0.5**gen
     grammar.generate(gen)
   end
-  
+
   def translate_rules(prod)
     swap = false
     points = [] # An empty array to store lines as a flat array of points
     prod.each do |ch|
       case(ch)
       when 'F'
-        points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))         
+        points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))
       when '+'
-        @theta += DELTA      
+        @theta += DELTA
       when '-'
         @theta += swap ? DELTA : -DELTA
       when '!'
         swap = !swap
-      when 'X'    
+      when 'X'
       else
         puts("character '#{ch}' not in grammar")
       end
@@ -65,13 +63,13 @@ def setup
   david = DavidTour.new(width * 0.6, height/4)
   production = david.create_grammar(5)
   @points = david.translate_rules(production)
-  no_loop()
+  no_loop
 end
 
-def draw()
+def draw
   background(0)
   stroke(255)
   points.each_slice(4) do |point|
     line(*point)
   end
-end
+end

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

@@ -1,29 +1,19 @@
-#
-# Koch Curve
-# by Daniel Shiffman.
-# 
-# Renders a simple fractal, the Koch snowflake. 
-# Each recursive level is drawn in sequence. 
-#
-
-load_libraries :koch, :vecmath
-
-attr_reader :k
+load_library :vecmath, :fastmath, :koch
 
 def setup
-  size(640, 360)
+  size(800, 250)
+  background(255)
   frame_rate(1)  # Animate slowly
   @k = KochFractal.new(width, height)
+  smooth 8
 end
 
 def draw
-  background(0)
+  background(255)
   # Draws the snowflake!
-  k.render
+  @k.render
   # Iterate
-  k.next_level
+  @k.next_level
   # Let's not do it more than 5 times. . .
-  if (k.get_count > 5) 
-    k.restart
-  end
+  @k.restart if @k.count > 5
 end

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

@@ -1,6 +1,6 @@
 ######################################
 # cs_grammar.rb a context sensitive
-# 1-L lsystem grammar for 
+# 1-L lsystem grammar for
 # ruby/ruby-processing
 # by Martin Prout (January 2013)
 ######################################
@@ -27,42 +27,40 @@ class Grammar
       add_rule pair[0], pair[1]
     end
   end
-  
+
   def add_rule(pre, rule)
     if pre.length == 3
       if pre[1] == '<'
         @context[pre[2]] = pre
       elsif pre[1] == '>'
-        @context[pre[0]] = pre 
+        @context[pre[0]] = pre
       end
       @no_context[pre] = rule # key length == 3
     elsif pre.length == 1
       @no_context[pre] = rule # key length == 1
-    else 
-      print "unrecognized grammar '#{pre}'"  
+    else
+      print 'unrecognized grammar '#{pre}''
     end
   end
-  
+
   def generate(repeat = 0) # repeat iteration grammar rules
     prod = axiom
-    repeat.times do
-      prod = new_production(prod)
-    end
+    repeat.times { prod = new_production(prod) }
     return prod
-  end 
-  
-  
+  end
+
+
   def new_production prod  # single iteration grammar rules
     @idx = -1
     prod.gsub!(/./) do |ch|
-      get_rule(prod, ch) 
+      get_rule(prod, ch)
     end
   end
-  
+
   def get_rule prod, ch
     rule = ch # default is return original character as rule (no change)
     @idx += 1 # increment the index of axiom/production as a side effect
-    if (context.has_key?(ch))
+    if context.key?(ch)
       if context[ch][1] == '<'
         cs_char = context[ch][0]
         rule = no_context[context[ch]] if cs_char == get_context(prod, idx, -1) # use context sensitive rule
@@ -71,18 +69,14 @@ class Grammar
         rule = no_context[context[ch]] if cs_char == get_context(prod, idx, 1) # use context sensitive rule
       end
     else
-      rule = no_context[ch] if no_context.has_key?(ch) # context free rule if it exists
+      rule = no_context[ch] if no_context.key?(ch) # context free rule if it exists
     end
     return rule
   end
-  
-  def get_context prod, idx, inc
+
+  def get_context(prod, idx, inc)
     index = idx + inc
-    while (ignore.include? prod[index])
-      index += inc
-    end
+    index += inc while ignore.include?(prod[index])
     return prod[index]
   end
-end
-
-
+end

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

@@ -2,7 +2,7 @@
 # Simple lsystem grammar
 ############################
 class Grammar
-  
+
   attr_reader :axiom, :rules
   def initialize(axiom, rules)
     @axiom = axiom
@@ -11,7 +11,7 @@ class Grammar
 
   def expand(production, iterations, &block)
     production.each_char do |token|
-      if rules.has_key?(token) && iterations > 0        
+      if rules.key?(token) && iterations > 0
         expand(rules[token], iterations - 1, &block)
       else
         yield token
@@ -19,15 +19,13 @@ class Grammar
     end
   end
 
-  def each gen
-    expand(axiom, gen) {|token| yield token }
+  def each(gen)
+    expand(axiom, gen) { |token| yield token }
   end
 
-  def generate gen
+  def generate(gen)
     output = []
-    each(gen){ |token| output << token }
+    each(gen) { |token| output << token }
     return output
   end
-
-end
-
+end

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

@@ -1,118 +1,99 @@
-# Koch Curve
-# A class to manage the list of line segments in the snowflake pattern
+class KochLine
+  include Processing::Proxy
+  attr_reader :start, :finish
+
+  def initialize(a, b)
+    @start = a.copy
+    @finish = b.copy
+  end
+
+  def display
+    stroke(120)
+    line(start.x, start.y, finish.x, finish.y)
+  end
 
+  # This is easy, just 1/3 of the way
+  def kochleft
+    v = finish - start
+    v /= 3
+    v + start
+  end
+
+  # More complicated, have to use a little trig to figure out where this vector is!
+  def kochmiddle
+    v = finish - start
+    v /= 3
+    p = start.copy
+    p += v
+    rotate_line(v, -60)
+    p + v
+  end
+
+  # Easy, just 2/3 of the way
+  def kochright
+    v = start - finish
+    v /= 3
+    v + finish
+  end
+
+  private
+  def rotate_line(v, theta)
+    xtemp = v.x
+    # Might need to check for rounding errors like with angleBetween function?
+    v.x = v.x * DegLut.cos(theta) - v.y * DegLut.sin(theta)
+    v.y = xtemp * DegLut.sin(theta) + v.y * DegLut.cos(theta)
+  end
+end
 
 class KochFractal
-  include Processing::Proxy
-  attr_reader :start, :endk, :lines, :count
-  
-  def initialize width, height
+  attr_reader :count, :start, :finish, :lines
+  def initialize(width, height)
     @start = Vec2D.new(0, height - 20)
-    @endk = Vec2D.new(width, height - 20)  
+    @finish = Vec2D.new(width, height - 20)
+    @lines = []
     restart
   end
 
-  def next_level  
+  def next_level
     # For every line that is in the arraylist
     # create 4 more lines in a new arraylist
     @lines = iterate(lines)
     @count += 1
   end
 
-  def restart 
+  def restart
     @count = 0      # Reset count
-    @lines = []     # Empty the array list
-    lines << KochLine.new(start, endk)  # Add the initial line (from one end Vector to the other)
+    lines.clear     # Empty the array list
+    lines << KochLine.new(start, finish)  # Add the initial line (from one end vector to the other)
   end
-  
-  def get_count
-    return count
-  end
-  
-  # This is easy, just draw all the lines
+
   def render
-    lines.each do |line|
-      line.display
-    end
+    lines.each{ |line| line.display }
   end
 
   # This is where the **MAGIC** happens
-  # Step 1: Create an empty array
-  # Step 2: For every line currently in the array
+  # Step 1: Create an empty arraylist
+  # Step 2: For every line currently in the arraylist
   #   - calculate 4 line segments based on Koch algorithm
-  #   - add all 4 line segments into the new array
-  # Step 3: Return the new array and it becomes the list of line segments for the structure
-  
-  # As we do this over and over again, each line gets broken into 4 lines, which gets broken into 4 lines, and so on. . . 
+  #   - add all 4 line segments into the new arraylist
+  # Step 3: Return the new arraylist and it becomes the list of line segments for the structure
+
+  # As we do this over and over again, each line gets broken into 4 lines, which gets broken into 4 lines, and so on. . .
   def iterate(before)
-    now = []    # Create empty list
-    before.each do |line|
-      # Calculate 5 koch Vectors (done for us by the line object)
-      a = line.start                 
-      b = line.kochleft
-      c = line.kochmiddle
-      d = line.kochright
-      e = line.endk
-      # Make line segments between all the Vectors and add them
-      # Note how we can chain '<<' in ruby, could all be in one line.
-      now << KochLine.new(a,b) << KochLine.new(b,c)
-      now << KochLine.new(c,d) << KochLine.new(d,e)
+    now = []    # Create emtpy list
+    before.each do |l|
+      # Calculate 5 koch vectors (done for us by the line object)
+      a = l.start
+      b = l.kochleft
+      c = l.kochmiddle
+      d = l.kochright
+      e = l.finish
+      # Make line segments between all the vectors and add them
+      now << KochLine.new(a, b)
+      now << KochLine.new(b, c)
+      now << KochLine.new(c, d)
+      now << KochLine.new(d, e)
     end
-    return now
+    now
   end
 end
-
-# The Nature of Code
-# Daniel Shiffman
-# http://natureofcode.com
-
-# Koch Curve
-# A class to describe one line segment in the fractal
-# Includes methods to calculate mid Vectors along the line according to the Koch algorithm
-
-class KochLine
-  include Processing::Proxy
-  # Two PVectors,
-  # a is the "left" Vector and 
-  # b is the "right Vector
-  attr_reader :start, :endk
-
-  def initialize(start, endk)
-    @start = start.dup
-    @endk = endk.dup
-  end
-
-  def display
-    stroke(255)
-    line(start.x, start.y, endk.x, endk.y)
-  end
-
-  # This is easy, just 1/3 of the way
-  def kochleft
-    v = endk - start
-    v /= 3.0
-    v += start
-    return v
-  end    
-
-  # More complicated, have to use a little trig to figure out where this Vector is!
-  def kochmiddle
-    v = endk - start
-    v /= 3.0    
-    p = start.dup
-    p += v  
-    rot = radians(-60)
-    r = Vec2D.new((v.x * cos(rot)) - v.y * sin(rot), (v.x * sin(rot)) + (v.y * cos(rot))) 
-    p += r  
-    return p
-  end    
-
-  # Easy, just 2/3 of the way
-  def kochright
-    v = start - endk
-    v /= 3.0
-    v += endk
-    return v
-  end
-end
-