ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/image_processing/linear_image.rb

@@ -0,0 +1,45 @@
+#
+# Linear Image. 
+# 
+# Click and drag mouse up and down to control the signal. 
+#
+# Note in ruby-processing to access booleans use
+#       mouse_pressed? and key_pressed?
+#
+# Press and hold any key to view the image scanning. 
+#
+
+attr_reader :signal, :img, :direction
+
+def setup
+  size(640, 360)
+  stroke(255)
+  @img = loadImage("sea.jpg")
+  @direction = 1
+  @signal = 0
+  img.load_pixels
+  load_pixels
+end
+
+def draw
+  if (signal > img.height - 1 || signal < 0)  
+    @direction = direction * -1
+  end
+  if mouse_pressed? 
+    @signal = abs(mouse_y % img.height)
+  else 
+    @signal += (0.3*direction)
+  end
+
+  if key_pressed? 
+    set(0, 0, img)
+    line(0, signal, img.width, signal)
+  else 
+    signal_offset = signal.to_i * img.width
+    (0 ... img.height).each do |y| 
+      java.lang.System::arraycopy(img.pixels.to_java, signal_offset, pixels, y*width, img.width)
+    end
+    update_pixels
+  end
+end
+

data/samples/processing_app/topics/image_processing/pixel_array.rb

@@ -0,0 +1,48 @@
+#
+# Pixel Array. 
+# 
+# Click and drag the mouse up and down to control the signal and 
+# press and hold any key to see the current pixel being read. 
+# This program sequentially reads the color of every pixel of an image
+# and displays this color to fill the window.  
+#
+
+ 
+
+attr_reader :signal, :img, :direction
+
+def setup
+  size(640, 360)
+  no_fill
+  stroke(255)
+  frame_rate(30)
+  @img = load_image("sea.jpg")
+  @direction = 1
+  @signal = 0
+end
+
+def draw
+  if (signal > img.width * img.height - 1 || signal < 0)
+    @direction = direction * -1 
+  end
+
+  if (mousePressed) 
+    mx = constrain(mouse_x, 0, img.width-1)
+    my = constrain(mouse_y, 0, img.height-1)
+    @signal = my * img.width + mx
+  else 
+    @signal += 0.33 * direction
+  end
+
+  sx = signal.to_i % img.width
+  sy = signal.to_i / img.width
+
+  if (keyPressed) 
+    set(0, 0, img)  # fast way to draw an image
+    point(sx, sy)
+    rect(sx - 5, sy - 5, 10, 10)
+  else 
+    c = img.get(sx, sy)
+    background(c)
+  end
+end

data/samples/processing_app/topics/image_processing/zoom.rb

@@ -0,0 +1,66 @@
+#
+# Zoom. 
+# 
+# Move the cursor over the image to alter its position. Click and press
+# the mouse to zoom. This program displays a series of lines with their 
+# heights corresponding to a color value read from an image. 
+#
+
+
+attr_reader :img, :img_pixels, :sval, :nmx, :nmy, :res
+
+def setup
+  size(640, 360, P3D)
+  noFill()
+  stroke(255)
+  @img = load_image("ystone08.jpg")
+  @img_pixels = []
+  @sval = 1.0
+  @res = 5
+  @nmx = 0
+  @nmy = 0
+  (0 ... img.height).each do |i|
+    inner = []
+    (0 ... img.width).each do |j|
+      inner << img.get(j, i)
+    end
+    img_pixels << inner
+  end  
+end
+
+def draw
+  background(0)
+
+  @nmx += (mouse_x - nmx) / 20 
+  @nmy += (mouse_y - nmy) / 20 
+
+  if(mouse_pressed?)  
+    @sval += 0.005 
+  else 
+    @sval -= 0.01 
+  end
+
+  @sval = constrain(sval, 1.0, 2.0)
+  translate(width/2 + nmx * sval-100, height/2 + nmy*sval - 100, -50)
+  scale(sval)
+  rotate_z(PI / 9 - sval + 1.0)
+  rotate_x(PI / sval / 8 - 0.125)
+  rotate_y(sval / 8 - 0.125)
+  translate(-width/2, -height/2, 0)
+  (0 ... img.height).step(res) do |i|
+    (0 ... img.width).step(res) do |j|
+      rr = red(img_pixels[j][i]) 
+      gg = green(img_pixels[j][i])
+      bb = blue(img_pixels[j][i])
+      tt = rr + gg + bb
+      stroke(rr, gg, gg)
+      line(i, j, tt / 10 - 20, i, j, tt / 10 )
+    end
+  end
+end
+
+
+
+
+
+

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

@@ -0,0 +1,72 @@
+########################################################
+# Chequer implemented using a grammar library
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
+
+
+load_libraries 'grammar'
+
+attr_reader :chequer
+
+def setup
+  size 600, 600
+  @chequer = Chequer.new width * 0.9, height/10
+  chequer.create_grammar 4  
+  no_loop
+end
+
+def draw
+  background 0
+  chequer.render
+end
+
+class Chequer
+  include Processing::Proxy
+  import 'grammar'
+  attr_accessor :axiom, :grammar, :production, :draw_length, :theta, :xpos, :ypos
+  DELTA = HALF_PI
+  
+  def initialize xpos, ypos
+    @xpos = xpos 
+    @ypos = ypos 
+    @axiom = "F-F-F-F"        # Axiom
+    @grammar = Grammar.new(
+      axiom,
+      {"F" => "FF-F-F-F-FF"}  # Rules
+   )
+    @draw_length = 500
+    stroke 0, 255, 0
+    stroke_weight 2  
+
+    @theta = 0
+  end
+  
+  def render
+    production.each do |element|
+      case element
+      when 'F'                     
+        x_temp = xpos
+        y_temp = ypos
+        @xpos -= draw_length * cos(theta) 
+        @ypos -= draw_length * sin(theta)
+        line(x_temp, y_temp, xpos, ypos)
+      when '+'
+        @theta += DELTA
+      when '-'
+        @theta -= DELTA
+      else
+        puts "Character '#{element}' is not in grammar"
+      end
+    end
+  end
+  
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+  
+  def create_grammar(gen)
+    @draw_length /=  3**gen
+    @production = @grammar.generate gen
+  end
+end

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

@@ -0,0 +1,100 @@
+########################################################
+# csplant.rb
+# A 3D Plant implemented using a Context Sensitive
+# Lindenmayer System in ruby-processing 
+# by Martin Prout (30 January 2013)
+########################################################
+
+attr_reader :csplant
+
+def setup
+  size 800, 800, P3D
+  @csplant = CSPlant.new(height)
+  csplant.create_grammar 5
+  no_stroke
+end
+
+def draw
+  background 0
+  lights
+  translate(width/2, height*0.8)
+  rotate_y QUARTER_PI
+  csplant.render
+end
+
+############
+# CSPlant 
+############
+
+load_libraries 'cs_grammar'
+
+class CSPlant
+  include Processing::Proxy
+  import 'cs_grammar'
+  IGNORE = "[]+-^&3"
+  attr_reader :grammar, :axiom, :production, :premis, :rule,
+  :theta, :scale_factor, :len, :phi, :len
+
+  def initialize(len)
+    @axiom = "F"
+    @grammar = Grammar.new(
+      axiom,
+      {
+        "F" => "F[-EF[3&A]]E[+F[3^A]]",        
+        "F<E" => "F[&F[3+A]][^F[3-A]]"      
+      },
+      IGNORE      
+    )
+    @production = axiom
+    @len = len
+    @theta = radians 25
+    @phi = radians 25
+    no_stroke()
+  end
+
+  def render()
+    fill(0, 75, 152)
+    light_specular(204, 204, 204)
+    specular(255, 255, 255)
+    shininess(1.0)
+    repeat = 1
+    production.each_char do |ch|
+      case(ch)
+      when "F"
+        translate(0, len/-2, 0)
+        box(len/9, len, len/9)
+        translate(0, len/-2, 0)
+      when "+"
+        rotateX(-theta * repeat)
+        repeat = 1
+      when "-"
+        rotateX(theta * repeat)
+        repeat = 1
+      when "&"
+        rotateZ(-phi * repeat)
+        repeat = 1
+      when "^"
+        rotateZ(phi * repeat)
+        repeat = 1
+      when "3"
+        repeat = 3
+      when "["
+        push_matrix
+      when "]"
+        pop_matrix
+      when "E", "A"
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+  end
+  ##############################
+  # create grammar from axiom and
+  # rules (adjust scale)
+  ##############################
+
+  def create_grammar(gen)
+    @len *= 0.6**gen
+    @production = grammar.generate gen
+  end
+end

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

@@ -0,0 +1,20 @@
+###########################
+# cstest.rb (use rp5 run ..
+# test of cs_grammar library
+###########################
+load_library 'cs_grammar'
+
+def setup
+  (0 .. 7).each do |i|
+    grammar = Grammar.new(
+      "baaaaaa",
+      {
+        "b<a" => "b",   # context sensitive rule replace a when preceded by b
+        "b"   =>"a"
+      }
+      )    
+    puts grammar.generate(i)
+  end
+end
+
+

data/samples/processing_app/topics/lsystems/data/java_args.txt

@@ -0,0 +1,3 @@
+-Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+ -XX:+OptimizeStringConcat 
+

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

@@ -0,0 +1,77 @@
+####################################################
+# The DavidTour fractal has been used to study the
+# Euclidean travelling salesman problem
+####################################################
+load_library :grammar
+
+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
+    @theta  = 0
+    @grammar = Grammar.new(
+      axiom,
+      {
+        "F" => "!F!-F-!F!",            # Rules
+        "X" => "!X"      
+      }
+      )
+    @draw_length = 15
+    @xpos = xpos
+    @ypos = ypos
+  end
+  
+  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))         
+      when '+'
+        @theta += DELTA      
+      when '-'
+        @theta += swap ? DELTA : -DELTA
+      when '!'
+        swap = !swap
+      when 'X'    
+      else
+        puts("character '#{ch}' not in grammar")
+      end
+    end
+    return points
+  end
+end
+
+
+
+########################################################
+# A David Tour fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
+
+attr_reader :points
+
+def setup
+  size(800, 900)
+  david = DavidTour.new(width * 0.6, height/4)
+  production = david.create_grammar(5)
+  @points = david.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/koch.rb

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