ruby-processing 2.6.3 → 2.6.4

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

@@ -1,117 +0,0 @@
-#######################################################
-# penrose tiling in ruby processing using LSystems
-# in ruby-processing by Martin Prout
-######################################################
-load_libraries :grammar, :fastmath
-
-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
-
-Turtle = Struct.new(:x, :y, :angle, :color)
-
-#############################
-# penrose_colored.rb
-#############################
-
-class PenroseColored
-  include Processing::Proxy
-  
-  attr_reader :axiom, :grammar, :start_length, :theta, :production, 
-              :draw_length, :repeats, :xpos, :ypos
-  
-  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 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' 
-      )
-    @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
-    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
-        repeats = 1
-      when '-'
-        pen.angle -= DELTA * repeats
-        repeats = 1
-      when '['
-        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.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
-  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.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,88 +0,0 @@
-load_libraries :grammar, :fastmath
-
-class PenroseSnowflake
-  include Processing::Proxy
-
-  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')
-    @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 * DegLut.cos(theta) : value *  DegLut.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

@@ -1,100 +0,0 @@
-############################
-# pentagonal.rb here I roll one of my own
-###########################
-load_library :grammar, :fastmath
-
-class Pentagonal
-  include Processing::Proxy
-  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')
-    @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 * DegLut.cos(theta) : draw_length * DegLut.sin(theta)
-  end
-end
-
-##
-# A Pentagonal Fractal created using a
-# Lindenmayer System in ruby-processing by Martin Prout
-###
-
-#  Empirically determined pstition adjustments
-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

@@ -1,93 +0,0 @@
-#######################################################
-# Lindenmayer System in ruby-procesDegLut.sing by Martin Prout
-# snake_kolam.rb uDegLut.sing l-systems
-#######################################################
-
-load_library :grammar, :fastmath
-
-class SnakeKolam
-  include Processing::Proxy
-
-  attr_accessor :axiom, :start_length, :xpos, :ypos, :grammar, :production, :draw_length, :gen
-  XPOS = 0
-  YPOS = 1
-  ANGLE = 2
-  DELTA = 90 # degrees 
-  
-  def initialize xpos, ypos
-    setup_grammar
-    @start_length = 120.0
-    @theta = 90 # degrees 
-    @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 uDegLut.sing 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 uDegLut.sing current turtle and length parameters
-  # returns a turtle corresponding to the new position
-  ######################################################
-  
-  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)
-    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

@@ -1,96 +0,0 @@
-#######################################################
-# stochastic_test.rb
-#
-# Lindenmayer System in ruby-processing by Martin Prout
-# Exploring terminals with minimum logic
-########################################################
-
-
-load_library :stochastic_grammar, :fastmath
-
-Turtle = Struct.new(:x, :y, :angle)
-
-class StochasticPlant
-  include Processing::Proxy
-
-  attr_reader :grammar, :axiom, :draw_length, :turtle, :production
-
-  DELTA = 23
-
-  def initialize xpos, ypos
-    @draw_length = 350
-    # use Struct as turtle
-    @turtle = Turtle.new(xpos, ypos, 90)        # 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
-    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 << 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 new turtle corresponding to the next position
-  ######################################################
-
-  def draw_line(turtle, length)
-    new_xpos = turtle.x + length * DegLut.cos(turtle.angle)
-    new_ypos = turtle.y - length * DegLut.sin(turtle.angle)
-    line(turtle.x, turtle.y, new_xpos, new_ypos)
-    Turtle.new(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