ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,88 @@
+######################################
+# cs_grammar.rb a context sensitive
+# 1-L lsystem grammar for 
+# ruby/ruby-processing
+# by Martin Prout (January 2013)
+######################################
+
+
+
+##################################
+# The grammar class stores rules
+# in two Hashes, one for cs rules,
+# one for context free rules. Rules
+# are filtered on input, and context
+# is checked using get_rule in production
+##################################
+
+class Grammar
+
+  attr_reader :axiom, :context, :no_context, :idx, :ignore
+  def initialize(axiom, rules, ignore = '')
+    @axiom = axiom
+    @no_context = {}
+    @context = {}
+    @ignore = ignore
+    rules.each_pair do |pair|
+      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 
+      end
+      @no_context[pre] = rule # key length == 3
+    elsif pre.length == 1
+      @no_context[pre] = rule # key length == 1
+    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
+    return prod
+  end 
+  
+  
+  def new_production prod  # single iteration grammar rules
+    @idx = -1
+    prod.gsub!(/./) do |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[ch][1] == '<'
+        cs_char = context[ch][0]
+        rule = no_context[context[ch]] if cs_char == get_context(prod, idx, -1) # use context sensitive rule
+      elsif context[ch][1] == '>'
+        cs_char = context[ch][2]
+        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
+    end
+    return rule
+  end
+  
+  def get_context prod, idx, inc
+    index = idx + inc
+    while (ignore.include? prod[index])
+      index += inc
+    end
+    return prod[index]
+  end
+end
+
+

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

@@ -0,0 +1,33 @@
+############################
+# Simple lsystem grammar
+############################
+class Grammar
+  
+  attr_reader :axiom, :rules
+  def initialize(axiom, rules)
+    @axiom = axiom
+    @rules = rules
+  end
+
+  def expand(production, iterations, &block)
+    production.each_char do |token|
+      if rules.has_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 }
+  end
+
+  def generate gen
+    output = []
+    each(gen){ |token| output << token }
+    return output
+  end
+
+end
+

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

@@ -0,0 +1,117 @@
+# Koch Curve
+# A class to manage the list of line segments in the snowflake pattern
+
+
+class KochFractal
+  include Processing::Proxy
+  attr_reader :start, :endk, :lines, :count
+  
+  def initialize width, height
+    @start = PVector.new(0, height - 20)
+    @endk = PVector.new(width, height - 20)  
+    restart
+  end
+
+  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 
+    @count = 0      # Reset count
+    @lines = []     # Empty the array list
+    lines << KochLine.new(start, endk)  # Add the initial line (from one end PVector 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
+  end
+
+  # This is where the **MAGIC** happens
+  # Step 1: Create an empty array
+  # Step 2: For every line currently in the array
+  #   - 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. . . 
+  def iterate(before)
+    now = []    # Create empty list
+    before.each do |line|
+      # Calculate 5 koch PVectors (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 PVectors 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)
+    end
+    return 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 PVectors along the line according to the Koch algorithm
+
+class KochLine
+  include Processing::Proxy
+  # Two PVectors,
+  # a is the "left" PVector and 
+  # b is the "right PVector
+  attr_reader :start, :endk
+
+  def initialize(start, endk)
+    @start = start.get
+    @endk = endk.get
+  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 = PVector.sub(endk, start)
+    v.div(3)
+    v.add(start)
+    return v
+  end    
+
+  # More complicated, have to use a little trig to figure out where this PVector is!
+  def kochmiddle
+    v = PVector.sub(endk, start)
+    v.div(3)    
+    p = start.get
+    p.add(v)    
+    v.rotate(-radians(60))
+    p.add(v)    
+    return p
+  end    
+
+  # Easy, just 2/3 of the way
+  def kochright
+    v = PVector.sub(start, endk)
+    v.div(3)
+    v.add(endk)
+    return v
+  end
+end
+

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

@@ -0,0 +1,58 @@
+########################
+# stochastic_grammar.rb
+# unweighted rules accepted
+# with default weight = 1
+# complex stochastic rule
+########################
+class StochasticGrammar
+  PROB = 1
+  attr_accessor :axiom, :srules
+
+  def initialize axiom
+    @axiom = axiom
+    @srules = {}   # rules dictionary (a hash of hashes)
+  end
+
+  ######################################################
+  # randomly selects a rule (with a weighted probability)
+  #####################################################
+
+  def stochastic_rule(rules)
+    total = rules.inject(0) do |total, rule_and_weight|
+      total += rule_and_weight[PROB]
+    end
+    srand
+    chance = rand * total
+    rules.each do |item, weight|
+      return item unless chance > weight
+      chance -= weight
+    end
+    return rule
+  end
+
+  def has_rule?(pre)
+    @srules.has_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
+      srules[pre][rule] = weight
+    else
+      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
+    end
+  end
+
+  def generate(repeat = 0)
+    prod = axiom
+    repeat.times do
+      prod = new_production(prod)
+    end
+    return prod
+  end
+end

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

@@ -0,0 +1,83 @@
+########################################################
+# A MPeano fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
+load_library 'grammar'
+####################################################
+# 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
+    rules = {
+      "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
+    @draw_length = 8
+    @xpos = xpos
+    @ypos = ypos
+  end
+  
+  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 "!"
+        @delta = -delta
+      when "I"
+        @draw_length *= ISQRT2    
+      when "Q"
+        @draw_length *= SQRT2    
+      when "X", "A", "B"     
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+    return points
+  end
+end
+
+attr_reader :points
+
+def setup
+  size(600, 600)
+  mpeano = MPeano.new(width/2, height*0.95)
+  production = mpeano.generate 7                  # 7 generations looks OK
+  @points = mpeano.translate_rules(production)
+  no_loop
+end
+
+def draw
+  background(0)
+  stroke(255)
+  points.each_slice(4) do |point|
+    line(*point)
+  end
+end
+
+

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

@@ -0,0 +1,78 @@
+########################################################
+# A Peano fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
+load_library 'grammar'
+
+class Peano
+  include Processing::Proxy
+  import 'grammar'
+  
+  
+  attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar
+  DELTA  = PI/3    # 60 degrees
+  def initialize xpos, ypos
+    @axiom = "XF"       # Axiom
+    rules = {
+      '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
+  end
+  
+  def generate gen
+    @draw_length = draw_length * pow(0.6, 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 'X', 'Y'        
+      else
+        puts("character  #{ch} not in grammar")        
+      end      
+    end
+    return points
+  end
+end
+
+attr_reader :points
+
+def setup
+  size(800, 800)
+  peano = Peano.new(width * 0.65, height * 0.9)
+  production = peano.generate 4                  # 4 generations looks OK
+  @points = peano.translate_rules(production)  
+  no_loop
+end
+
+def draw
+  background(0)
+  render points
+end
+
+def render points
+  no_fill
+  stroke 200.0
+  stroke_weight 3
+  begin_shape
+  points.each_slice(4) do |x0, y0, x1, y1|
+    vertex x0, y0
+    vertex x1, y1
+  end
+  end_shape 
+end
+
+