Ruby Processing

GLGraphics in ruby-processing post processing (GLSL Fish Eye shader)

2011-12-01T19:34:00.008Z

# This example applies a post-processing texture filter to the offscreen canvas
# in order to generate an angular fish-eye effect.
# Based on the following discussion thread in the Processing forum:
# http:#forum.processing.org/topic/angular-fisheye
# Some other resources about fish-eye projections:
# 1) Excellent article from Paul Bourke on the math behind the angular fish-eye mapping  
# http:#paulbourke.net/miscellaneous/domefisheye/fisheye/
# 2) Fish-eye effect implemented as a GLSL vertex shader:
# http:#pixelsorcery.wordpress.com/2010/07/13/fisheye-vertex-shader/
# 3) Another fish-eye GLSL shader (didn't test it though):
# http:#pages.cpsc.ucalgary.ca/~brosz/wiki/pmwiki.php/CSharp/08022008

load_libraries 'opengl', 'GLGraphics'
include_package "codeanticode.glgraphics"


attr_reader :canvas, :fisheye, :tex

def setup()
  size(300, 300, GLConstants.GLGRAPHICS)
  # If your video card isn't up to it use following (no antialias)
  #@canvas = GLGraphicsOffScreen.new(self, width, height)    
  @canvas = GLGraphicsOffScreen.new(self, width, height, true, 4)

  # Destination texture to store the fisheye image.
  @tex = GLTexture.new(self)

  @fisheye = GLTextureFilter.new(self, "FishEye.xml")
  # The aperture angle is specified in degrees. Values
  # greater than 180 can be specified, but the result won't
  # be consistent since the mapping is not one-to-one in
  # that case.
  fisheye.set_parameter_value("aperture", 180.0)
end

def draw()
  # Generating offscreen rendering:
  canvas.begin_draw
  canvas.background(0)
  canvas.lights
  canvas.stroke(255, 0, 0)
  (0...height).step(10) {|i| canvas.line(i, 0, i, height)}
  (0...width).step(10) {|j| canvas.line(0, j, width, j)}
  canvas.no_stroke
  canvas.translate(mouse_x, mouse_y, 100)
  canvas.rotate_x(frame_count * 0.01)
  canvas.rotate_y(frame_count * 0.01)
  canvas.box(50)
  canvas.end_draw
  fisheye.apply(canvas.get_texture(), tex)
  image(tex, 0, 0, width, height)
end

This is is an example included with vanilla processing GLGraphics library be sure to copy the shader files from the GLGraphics/Examples/Output/FishEye/data into a data folder (where fish_eye.rb is saved). See also faux fish eye here.

Further Prototyping of my Povwriter Library in ruby-processing

2011-11-26T14:45:00.011Z

Update 22 December I have gone on to modify my java povwriter library, incorporating some of ideas developed here. This sketch is incompatible with that new library, however old library is still available here.

It really is much easier to prototype in ruby/ruby processing vs java/vanilla processing. Recently I had the idea of splitting up the povray files as follows:-

pov.ini to hold size (resolution) and quality (ray-trace parameter
pov.pov to hold template (camera/background etc)
pov.inc to hold mesh data etc from the processing sketch

In this iteration of prototyping I get to do 1 and 2, as 3 will involve a rewrite of my povwriter library, which I'm putting off until is clear whether beginRaw/endRaw will work in processing 2.0 (scheduled for release in Spring 2012?). I have decided less is definetly more for my gui, there are now only 3 quality options and the raytrace button now also initiates the recording of the PovRAY files as well as starting PovRAY. Further I've split the ini writer/povray runner into a new class as follows:-

# Demonstrates how you can use my povwriter libary
# in Ruby-Processing, to export to PovRAY

load_libraries 'povwriter', 'control_panel'
import 'povexport'
require 'ini_writer'

DATA = [-1, 0, 1]
attr_reader :exporter, :precord, :pquality, :type, :pview, :povfile

def setup
  size 1000, 1000, P3D
  @povfile = "balls.pov"
  @precord = false
  @pview = false
  @exporter = PovExporter.new self
  control_panel do |c|
    c.title = "Render as PovRAY"
    c.menu(:quality, ['instant', 'medium', 'high'], 'instant') {|m| load_quality_choice(m) }
    c.button :choose_template
    c.button :raytrace
    c.button :exit!
  end
  # uncomment next enter the path to povray executable on mac/windows/linux (or possibly jedit linux)  
  exporter.set_povray_path('/usr/local/bin/povray') # choice is saved in '.povwriter/povwriter.properties'
  # uncomment following line to adjust degenerate triangle cut off (area squared)
  # export.set_epsilon("0.001")
  exporter.store_settings    # uncomment this line to save settings   
  no_stroke
  sphere_detail(18)
end

def draw
  lights          # this needs to be outside the record loop
  if (precord)
    no_lights     # let PovRAY do the lighting
    no_loop       # don't loop while recording sketch
    begin_raw("povexport.RawPovray", data_path(povfile))
  end
  if pview
    pov_image = load_image(data_path(povfile.gsub("pov", "png")))
    update_pixels
    background(255) # clear the screen   
    image(pov_image, 0, 0)
  else
    render
  end
  if (precord)
    end_raw
    @precord = false
    puts "done recording"
    trace = IniWriter.new(data_path(povfile), width, height, pquality)
    trace.raytrace exporter.get_povray_path
    @pview = true
  end
end

def exit!
  exit
end

def render()
  background(0)
  translate(width*0.7, height/2, -width)
  DATA.each do |y|
    DATA.each do |x|
      DATA.each do |z|
        push_matrix
        translate(120*x, 120*y, 120*z)
        fill(rand * 255, rand * 255, rand * 255) # a nice test for my colorFactory class
        exporter.sphere(60) # use a better sphere primitive for ray tracing
        pop_matrix
      end
    end
  end
end



################################### Independent of sketch ############################

def raytrace
  @precord = true
end

def choose_template
  exporter.choose_template
end

def load_quality_choice(item)
  @pquality = item
end

Here is the ini writer class..................

require 'pathname'

INI = {'instant' => 'quick.ini', 'medium' => 'medium.ini', 'high' => 'quality.ini'}
QUALITY = {'instant' => 4, 'medium' => 6, 'high' => 11}

class IniWriter

  attr_reader :name, :width, :height, :qual, :base, :ini
 def initialize name, width, height, qual
   @name, @width, @height, @qual = name, width, height, qual
   init
 end

 def init
   @base = File.dirname(name)
   if (QUALITY[qual] < 6 && width > 300)
     @height *= 300.0/width
     @width = 300
   end
 end

 def write
   @ini = File.join(base, INI[qual])
   file = open(ini, 'w')
   file.puts("; #{ini}")
   file.puts("Input_File_Name='#{name}'")
   file.puts("width=#{width}")
   file.puts("height=#{height}")
   file.puts("quality=#{QUALITY[qual]}")
   file.puts("Antialias=true") unless QUALITY[qual] < 10
   file.puts("Output_File_Type=N8")
   file.puts("Output_File_Name='#{name.gsub('pov', 'png')}'")
   file.close
 end

 def raytrace povray_path
   write
   system([povray_path, ini].join(" "))
 end
end

Exporting Sketches from Ruby-Processing to PovRAY, features control panel

2011-11-16T14:41:00.028Z

It has taken a lot longer that it should have done, but finally I got round to exploring my vanilla processing povwriter library in ruby processing. Thanks to the latest version of ruby-processing, we can use the vanilla processing library from the sketchbook folder. This works fine and dandy at present, but I can foresee potential conflicts with libraries that have been modified to run with processing-2.0, but then lots of libraries are probably going to get screwed along the way to the new version (my povwriter library for one does not work with processing-2.0). Here's one of my povwriter example files translated to ruby:-

# Demonstrates how you can use my povwriter libary
# in Ruby-Processing, to export to PovRAY

load_libraries 'povwriter', 'control_panel'
import 'povexport'

DATA = [-1, 0, 1]
attr_reader :exporter, :precord, :pquality, :type, :pview, :memory, :povfile

def setup
  size 300, 300, P3D
  @povfile = "balls.pov"
  @precord = false
  @exporter = PovExporter.new self
  control_panel do |c|
    c.title = "Render as PovRAY"
    c.menu(:quality, ['low', 'medium', 'high', 'highest'], 'high') {|m| load_quality_choice(m) }
    c.menu(:image_type, ['png', 'jpeg', 'tga'], 'png') {|m| load_image_type(m) }
    c.menu(:memory, ['low', 'default', 'high', 'none'], 'default') {|m| load_memory_choice(m) }
    c.checkbox :antialias
    c.button :choose_template
    c.button :record
    c.button :raytrace
    c.button :view
    c.button :exit!
  end
  # uncomment next enter the path to povray executable on mac/windows/linux (or possibly jedit linux)  
  exporter.set_povray_path('/usr/local/bin/povray') # choice is saved in '.povwriter/povwriter.properties'
  # uncomment following line to adjust degenerate triangle cut off (area squared)
  # export.set_epsilon("0.001")
  exporter.store_settings    # uncomment this line to save settings   
  no_stroke
  sphere_detail(18)
end

def draw
  lights          # this needs to be outside the record loop
  if (precord)
    no_lights   # let PovRAY do the lighting
    no_loop       # don't loop while recording sketch
    begin_raw("povexport.RawPovray", data_path(povfile))
  end
  if pview
    background(0) # clear the screen
    image(load_image(data_path("balls.png")), 0, 0)
    no_loop
  else
    render
  end
  if (precord)
    end_raw
    @precord = false
    puts "done recording"
    loop
  end
end

def exit!
  exit
end

def render()
  background(0)
  translate(width*0.7, height/2, -width)
  DATA.each do |y|
    DATA.each do |x|
      DATA.each do |z|
        push_matrix
        translate(120*x, 120*y, 120*z)
        fill(rand * 255, rand * 255, rand * 255) # a nice test for my colorFactory class
        exporter.sphere(60) # use a better sphere primitive for ray tracing
        pop_matrix
      end
    end
  end
end

################################### Independent of sketch ############################
def record
  @precord = true
end

def raytrace
  Kernel.system([exporter.get_povray_path, povray_options, povray_scene].join(" "))
end

def choose_template
  exporter.choose_template
end

def view
  @pview = true
end

def povray_scene
  return "+I#{data_path(povfile)}"
end

def povray_options
  aa = @antialias ? "+A" : ""
  return "+IM#{memory} +W#{width} +H#{height} +Q#{pquality} #{aa} +F#{type}"
end


def load_quality_choice(item)
  map = {'low' => 0, 'medium' => 5, 'high' => 9, 'highest' => 11}
  @pquality = map[item]
end

def load_memory_choice(item)
  map = {'low' => 56, 'default' => 128, 'high' => 1024, 'none' => 0}
  @memory = map[item]
end

def load_image_type(item)
  map = {'png' => 'N', 'jpeg' => 'J', 'tga' => 'C'}
  @type = map[item]
end

Sketch now modified to use the excellent control panel of ruby-processing. Here I am using a custom sphere for raytracing, ideally I would just call the PovRAY sphere primitive, but that is a bit more complicated than it appears at first sight (see my vanilla processing blog). Presently everything is exported as a simple triangle mesh (ideally this would be a PovRAY mesh2 object). Make life easy for yourself and wrap drawing logic in a function such as render. Click on images below to see full size....

Live Display of PovRAY rendering

Viewing Rendered image in processing sketch

Rod Hilbert in Ruby-Processing (using homebaked libraries)

2011-07-12T19:28:00.005+01:00

Here is sketch where I have created two small libraries, one in java that I have archived as jar, and one in ruby that is library just because I put in the library folder. The java library provides fast lookup tables for sin and cos, and the ruby library provides some code that is re-used a lot when I create lystems in ruby-processing. Se the vanilla processing animation on my other blog. For your convenience I have provided these libaries here as a gist (NB: raw view of gist is required google has done something to the formatted code), as well as the sketch code:-

Faux Fish Eye Lens in ruby-processing, features control panel

2011-06-16T15:23:00.010+01:00

Sketches below show an unadulterated grid, a partial grid with fish eye 'filter' and some text with fish eye 'filter'. Unfortunately the mouse was doing two things (adjusting view and selecting image for 'the gimp') so actual captured image was a bit hit and miss. View the vanilla processing version at openprocessing.

############################
# fish_eye.rb 
# [Pseudo fisheye simulation]
# by Jonsku, September 2010
# From the article by Paul Bourke : http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/domefisheye/fisheye/
#
# translated to ruby-processing by Martin Prout (June 2011) 
# Toggle fisheye, select view, adjust aperture using 'Control Panel'
# Move mouse to change camera position.
############################

require 'beauty'

class Fish_Eye < Processing::App
  load_library :control_panel
  attr_reader :b_pass, :fish_eye_filter, :aperture, :options, :some_text, :img

  def setup()
    size(300, 300)
    setup_control
    text_font(load_font("Ubuntu-Regular-48.vlw"))
    @some_text = "Whatever it is,\n it was inside the Sphere.\n Now it's out, free to act. "
    @img = load_image("pattern.png")
    @fish_eye_filter = false
    @b_pass = BeautyPass.new
    smooth
  end

  def draw()
    background(0)
    case options
    when 'grid'
      draw_grid(20)
    when 'text'
      draw_text
    when 'image'
      display_image
    when 'noise'
      draw_noise
    else
      draw_grid(20)
    end
    if fish_eye_filter
      fisheye
    end
  end

  def setup_control
    control_panel do |c|
      c.title = "Control Panel"
      c.button :t_fisheye
      c.menu(:options, ['grid', 'text', 'image', 'noise' ], 'grid')
      c.slider :aperture, 0.5..Math::PI, 3.142
    end
  end

  def t_fisheye
    @fish_eye_filter = !fish_eye_filter
  end

  def draw_grid(row)
    stroke(255)
    stroke_weight(2)
    for i in 0...row
      line(0, i * height / row, width, i * height / row)
      line(i * height / row, 0, i * height / row, height)
    end
  end

  def draw_text
    fill(0, 255, 0)
    text(some_text,sin(frame_count * 0.1)*(width - text_width(some_text)), 180+Math.sin(Math::PI/2 + frame_count*0.01)*(height-170))
  end

  def display_image
    image(img, 0, 0, width, height)
  end

  def draw_noise
    push_style
    color_mode(RGB,1.0)
    load_pixels
    (0...width).each do |i|
      (0...height).each do |j|
        pixels[i+j*width] = color(noise((frame_count+i)*0.1,j*0.1),noise((frame_count+i)*0.1,j*0.1,0.3),noise((frame_count+i)*0.05,j*0.05,0.6))
      end
    end
    update_pixels
    pop_style
  end

  def fisheye
    half_aperture = aperture / 2
    # define camera positioning normalized coordinates
    cam_x = (2.0 * mouse_x) / (width - 1)
    cam_y = (2.0 * mouse_y) / (width - 1)

    load_pixels
    (0...width).each do |i|
      #transform pixel coordinates to normalised coordinates, range -1 to 1
      x = (2.0 * i) / (width - 1)
      (0...height).each do |j|
        y = (2.0 * j) / (height - 1)
        #radius r to camera
        r = dist(cam_x, cam_y, x, y)
        #at this stage any pixels where r > 1 are ignored
        if (r.abs > 1)
          next
        end
        #angle phi to x axis
        phi = Math.atan2(y - cam_y, x - cam_x)
        #r is mapped onto theta and phi is used directly as the polar coordinates of the direction vector 
        # from the camera into the scene
        theta = half_aperture * r
        #transform normalised coordinates to pixel coordinates
        dx = map(Math.sin(theta) * Math.cos(phi), -1.0, 1, 0, width)
        dy = map(Math.sin(theta) * Math.sin(phi), -1.0, 1, 0, height)

        ##############
        # Because the pixel array uses integer coordinates, black empty pixels will appear in the resulting image.
        # To attempt to fix this, the destination pixel is calculated with 3x3 combinations of roundings (round-round, 
        # the final value will be the average colors. See BeautyPass, it will become clearer.
        # round.floor, round.ceil, floor.floor, floor-round, etc.). Thus one pixel might have several colors but that 
        # is taken into account and NOTE: This works ok for aperture up to 180 but above that it is not enough.
        ###############
        fx = dx.round
        fy = dy.round
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.round
        fy = dy.floor
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.round
        fy = dy.ceil
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.floor
        fy = dy.floor
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.floor
        fy = dy.round
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.floor
        fy = dy.ceil
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.ceil
        fy = dy.ceil
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.ceil
        fy = dy.round
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
        fx = dx.ceil
        fy = dy.floor
        @b_pass.add_color(fx + fy * width, pixels[(i + j * width)])
      end
    end
    @b_pass.render
    @b_pass.reset
  end

end

############################
# beauty.rb (helper class), part of
# --=[Angular fisheye simulation]=--
# by Jonsku, September 2010
# From the article by Paul Bourke : http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/domefisheye/fisheye/
#
# translated to ruby-processing by Martin Prout
#
# Move mouse to change camera position.
############################
class BeautyPass
  include Processing::Proxy

  attr_reader :counts, :rSums, :gSums, :bSums

  def initialize()
    reset()
  end

  def reset()
    @counts = Array.new(width * height, 0)
    @rSums = Array.new(width * height, 0)
    @gSums = Array.new(width * height, 0)
    @bSums = Array.new(width * height, 0)
  end

  def add_color(i, c)
    if (i>0 && i< width * height)
      @rSums[i] += c >> 16 & 0xFF
      @gSums[i] += c >> 8 & 0xFF
      @bSums[i] += c & 0xFF
      @counts[i] +=  1
    end
  end

  def render()
    load_pixels()
    (0...width * height).each do |i|
      if (counts[i]>0)
        pixels[i] = color(rSums[i] / counts[i], gSums[i] / counts[i], bSums[i] / counts[i])
      else
        pixels[i] = color(0) #background color
      end
    end
    update_pixels()
  end
end

Exploring modelX in ruby processing

2011-05-05T20:32:00.000+01:00

############################
# processing modelX
# examples in ruby processing
###########################

def setup
  size 500, 500, P3D
  no_fill
end

def draw
  background 0

  push_matrix
  # start at the middle of the screen
  translate(width/2, height/2, -200)
  # some pseudo random rotation to make things interesting
  rotate_y 1.0 # yrot
  rotate_z 2.0 # zrot
  # rotate in X a little more each frame
  rotate_x(frame_count / 100.0)
  # offset from center
  translate(0, 150, 0)

  # draw a white box outline at (0, 0, 0)
  stroke 255
  box 80

  # the box was drawn at (0, 0, 0), store that location
  x = model_x(0, 0, 0)
  y = model_y(0, 0, 0)
  z = model_z(0, 0, 0)
  # clear out all the transformations
  pop_matrix

  # draw another box at the same (x, y, z) coordinate as the other
  push_matrix
  translate(x, y, z)
  stroke(255, 0, 0)
  box 80
  pop_matrix
end

Exploring screenX in ruby processing

2011-05-05T20:10:00.000+01:00

I think there is a mistake in the version at the processing wiki (which I have flagged) because the 2D lines mentioned in the comments have six parameters (in my book that is 3D line even if Z is zero). You still get to see the parallax in my amended version, try it.

###################
# processing screenX example
# in ruby processing
###################

def setup
  size 100, 100, P3D
end

def draw
  background 204

  x = mouse_x
  y = mouse_y
  z = -100

  # Draw "X" at z = -100
  stroke 255
  line(x - 10, y - 10, z, x + 10, y + 10, z)
  line(x + 10, y - 10, z, x - 10, y + 10, z)

  # Draw line in 2D at same x value
  # Notice the parallax
  stroke 102
  line(x, 0, x, height)

  # Draw 2D line to match the x value
  # element drawn at z = -100
  stroke(0)
  the_x = screen_x(x, y, z)
  line(the_x, 0, the_x, height)
end

Winged Edge Mesh and Physics from Toxiclibs

2011-05-03T07:42:00.005+01:00

Here is the toxiclibs InflateMesh verlet physics example demonstrating winged mesh class functionality. Although this was a P3D sketch in the example it looks best using OPENGL. Because there is still an issue with linux and ruby-processing OPENGL at less than full_screen, I have scaled some of the variables in the sketch (mainly annotated I think), anyway you should probably look at the original (included in the library download toxiclibs-complete version 0020).

# This example uses the attraction behavior to inflate a 3D mesh.
# The mesh vertices are re-created as physics particles and connected
# using springs. Upon mouse press the inflation force is applied,
# counteracting the forces created by the springs, causing the mesh to
# expand and deform.
#
# Usage: Click and hold mouse button to inflate mesh
#

############
# Copyright (c) 2010 Karsten Schmidt translated to ruby processing by Martin Prout (Spring 2011)
#
# This demo & library is free software you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation either
# version 2.1 of the License, or (at your option) any later version.
#
# http:#creativecommons.org/licenses/LGPL/2.1/
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
class InflateMesh < Processing::App
 load_libraries 'toxiclibs_p5', 'toxiclibscore', 'verletphysics', 'opengl'
 include_package 'processing.opengl'
 include_package 'toxi.geom'
 include_package 'toxi.geom.mesh.subdiv'
 include_package 'toxi.geom.mesh'
 include_package 'toxi.physics'
 include_package 'toxi.physics.behaviors'
 include_package 'toxi.physics.constraints'
 include_package 'toxi.processing'

 attr_reader :physics, :inflate, :box, :gfx
 full_screen

 def setup
 setup_opengl
 @gfx = ToxiclibsSupport.new(self)
 init_physics
 end

 def draw
 @physics.update()
 for vert in box.vertices.values
 vert.set(physics.particles.get(vert.id))
 end
 box.center(nil) # nil means centre at 0, 0, 0
 for vert in box.vertices.values
 @physics.particles.get(vert.id).set(vert)
 end
 box.compute_face_normals
 box.face_outwards
 box.compute_vertex_normals
 background(51)
 translate(width / 2, height / 2, 0)
 rotate_x((height / 2 - mouse_y) * 0.01)
 rotate_y((width / 2 - mouse_x) * 0.01)
 no_fill
 lights
 directional_light(255, 255, 255, -200, 1000, 500)
 specular(255)
 shininess(16)
 @gfx.origin(Vec3D.new, 300) # scaled up axes display from 50
 fill(192)
 no_stroke
 @gfx.mesh(box, true, 10) # scaled up normals display from 5
 end

 def init_physics
 @box = WETriangleMesh.new
 # create a simple start mesh
 #box.add_mesh(Cone.new(Vec3D.new(0, 0, 0), Vec3D.new(0, 1, 0), 10, 50, 100).to_mesh(4))
 @box.add_mesh(AABB.new(Vec3D.new, 150).to_mesh) # scaled up from 50
 # then subdivide a few times...
 @box.subdivide
 @box.subdivide
 @box.subdivide
 @box.subdivide
 @physics = VerletPhysics.new
 @physics.set_world_bounds(AABB.new(Vec3D.new, 540)) # scaled up from 180
 # turn mesh vertices into physics particles
 for vert in box.vertices.values
 @physics.add_particle(VerletParticle.new(vert))
 end
 # turn mesh edges into springs
 for w_edge in box.edges.values
 vp_a = physics.particles.get(w_edge.a.id)
 vp_b = physics.particles.get(w_edge.b.id)
 @physics.add_spring(VerletSpring.new(vp_a, vp_b, vp_a.distance_to(vp_b), 0.05))
 end
 end

 def key_pressed # using a switch anticipating more key actions
 case key
 when 'i'
 init_physics
 when 's'
 save_frame "inflate.png"
 end
 end

 def mouse_pressed
 @inflate=AttractionBehavior.new(Vec3D.new, 400, -0.3, 0.001)
 @physics.add_behavior(inflate)
 end

 def mouse_released
 @physics.remove_behavior(inflate)
 end

 def setup_opengl
 render_mode OPENGL
 hint ENABLE_OPENGL_4X_SMOOTH # optional
 hint DISABLE_OPENGL_ERROR_REPORT # optional
 end
end

Using Hemesh Library in ruby-processing

2011-05-02T17:07:00.002+01:00

It has been positively ages since I last posted any ruby-processing sketches here is one processing library that you might like to experiment with it is the Hemesh library by Frederik Vanhoutte aka W:Blut. Over on my other blog I have been describing the development of my latest processing library "povwriter" a tool for exporting processing sketches to the povray format and this is one of the sketches I have used. Next I will attempt to get my "povwriter" library working in ruby processing.

# RandomCage.rb is a processing sketch that shows
# how you can use the Hemesh library in Ruby-Processing.

class RandomCage < Processing::App
 load_libraries 'hemesh', 'opengl'
 include_package 'wblut.hemesh'
 include_package 'wblut.hemesh.creators'
 include_package 'wblut.hemesh.iterators'
 include_package 'wblut.hemesh.modifiers'
 include_package 'wblut.hemesh.subdividors'

 import "processing.opengl"

 full_screen
 TWO_PI = Math::PI * 2
 attr_reader :cage

 def setup
 configure_opengl
 @cage = HE_Mesh.new(HEC_Box.new(self).set_depth(height/2).set_height(height/2).set_width(height/2))
 @cage.modify(HEM_ChamferCorners.new.set_distance(height*0.1))
 #HES_Planar() subdivision can include a measure of randomness
 @cage.subdivide(HES_Planar.new.set_random(true).set_range(0.4),2)

 #A save choice after introducing any kind of randomness is to triangulate possible concave faces.
 #Concave faces do not invalidate the mesh but can give unexpected results.
 @cage.triangulate_concave_faces()

 @cage.modify(HEM_Lattice.new.set_depth(0.016*height).set_width(0.016*height).set_fuse(true))
 sel = HE_Selection.new
 for f in cage.f_itr # using ruby syntax here
 sel.add f
 end
 cage.subdivide_selected(HES_CatmullClark.new(),sel,2)
 end

 def draw
 background(120)
 lights
 translate(width/2, height/2)
 rotate_y(mouse_x * 1.0 / width * TWO_PI - Math::PI)
 rotate_x(mouse_y * 1.0 / height * TWO_PI - Math::PI)
 fill(255)
 no_stroke
 cage.draw_faces
 stroke(0)
 cage.draw_edges
 end

 def configure_opengl
 render_mode OPENGL
 hint ENABLE_OPENGL_4X_SMOOTH # optional
 hint DISABLE_OPENGL_ERROR_REPORT # optional
 end

end

The 'growing' of a context-sensitive L-system plant (ruby-processing)

2011-03-03T10:56:00.017Z

LSystem rules from a paper by Tong Lin at UMBC Maryland. The following code could be simplified if you could rely on string index being a char (ruby 1.9) rather than ascii value (ruby 1.8), tripped me up at first, ruby-processing is still at 1.8 (it depends on JRuby which will start supporting ruby 1.9 from JRuby version 1.6?)

Update 10 March 2011 just tried jruby-complete-1.6-RC3 still get old behaviour ie ascii value rather than char when indexing a string, nor is ord method supported still requires Jeremys shim to string.

########################################################
# cs_test.rb
# A 3D Plant implemented using a Context Sensitive
# Lindenmayer System in ruby-processing
# by Martin Prout (3 March 2011)
########################################################

class CS_Test < Processing::App
 full_screen # NB: All distances are relative to screen height
 load_libraries 'csplant', 'PeasyCam', 'opengl'
 import 'peasy'
 import "processing.opengl" if library_loaded? "opengl"
 attr_reader :csplant, :cam

 def setup
 library_loaded?(:opengl) ? configure_opengl : render_mode(P3D)
 configure_peasycam
 @csplant = CSPlant.new(height)
 csplant.create_grammar 5
 no_stroke
 end

 def configure_peasycam
 cam = PeasyCam.new self, height / 6.5
 cam.set_minimum_distance height / 10
 cam.set_maximum_distance height
 end

 def configure_opengl
 render_mode OPENGL
 hint ENABLE_OPENGL_4X_SMOOTH # optional
 hint DISABLE_OPENGL_ERROR_REPORT # optional
 end

 def draw
 background 0
 lights
 csplant.render
 end

end

The PeasyCam and csplant libraries need to be nested in the usual way in a library folder. This code is much more complicated than my previous post. This is mainly due to the need to ignore certain symbols when determining context, and hence need to navigate along the production string.

######################################
# csplant.rb
# A library used to implement
# a context sensitive
# 1-L lsystem grammar in
# ruby-processing
# by Martin Prout (4 March 2011)
######################################

################################################
# A helper class stores cs prefix idx, and cchar
# uses idx and char to determine context and
# pre to access context sensitive rule from rules
###############################################
class CSRule

 attr_accessor :pre

 def initialize pre
 @pre = pre
 end

 def idx
 x = 0
 if (pre[1] == 60) # NB comparing ascii values until ruby 1.9 support
 x -= 1
 end
 if (pre[1] == 62) # ">"[0] = 62, "<"[0] = 60
 x += 1
 end
 return x
 end

 def cchar
 return pre[0]
 end

end

##################################
# The grammar class stores lsystem rules
# in rules Hash, and context Hash if applicable
# In production context is checked (and applied)
# using get_rule method
##################################

class CSGrammar
 IGNORE = "[]+-^&3" # characters to ignore for context as a constant string
 attr_reader :axiom, :context, :rules, :count
 def initialize(axiom)
 @axiom = axiom
 @rules = Hash.new
 @context = Hash.new
 end

 def add_rule(pre, rule)
 if pre.length == 3
 context.store(pre[2], CSRule.new(pre))
 end
 rules.store pre, rule
 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
 @count = 0 # initialise count on axiom or new prod
 prod.gsub!(/./) do |ch|
 get_rule(prod, ch)
 end
 end

 def get_rule prod, ch
 rule = ch # default is to return original character as rule (ie no change)
 idx = count # idx is a local index, used to navigate the production string
 if (context.has_key?(ch[0]))
 while IGNORE.include?(prod[context[ch[0]].idx + idx].chr)
 idx += context[ch[0]].idx
 end
 if prod[context[ch[0]].idx + idx] == context[ch[0]].cchar
 rule = rules[context[ch[0]].pre]
 else
 rule = rules[ch] if rules.has_key?(ch) # context free rule if it exists
 end
 else
 rule = rules[ch] if rules.has_key?(ch) # context free rule if it exists
 end
 @count += 1 # increment the index of axiom/production as a side effect
 return rule
 end
end

############
# CSPlant
############
class CSPlant
 include Processing::Proxy

 attr_reader :grammar, :axiom, :production, :premis, :rule,
 :theta, :scale_factor, :distance, :phi, :len

 def initialize(len)
 @axiom = "F"
 @grammar = CSGrammar.new(axiom)
 @production = axiom
 @len = len
 @distance = len/4 # distance value relative to screen height
 @theta = Math::PI/180 * 25
 @phi = Math::PI/180 * 25
 grammar.add_rule("F", "F[-EF[3&A]]E[+F[3^A]]")
 grammar.add_rule("F<E", "F[&F[3+A]][^F[3-A]]") # context sensitive rule
 no_stroke()
 end

 def render()
 fill(0, 75, 152)
 light_specular(204, 204, 204)
 specular(255, 255, 255)
 shininess(1.0)
 repeat = 1
 production.scan(/./) do |ch|
 case(ch)
 when "F"
 translate(0, distance/-2, 0)
 box(distance/9, distance, distance/9)
 translate(0, distance/-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)
 @distance *= 0.5**gen
 @production = grammar.generate gen
 end
end

Exploring Context Sensitive LSystem rules in ruby / ruby-processing

2011-03-01T20:09:00.002Z

Warning the following code depends on ruby 1.9, where string index returns a char rather than an ascii value (ruby 1.8) see following post for how this tripped me up at first when exploring a proper ruby-processing example. (Update 5 March 2011)

######################################
# cs_grammar.rb a context sensitive
# 1-L lsystem grammar for
# ruby/ruby-processing
# by Martin Prout (1 March 2011)
######################################

#######################
# A helper class stores
# cs rules idx, and cchar
# methods extract cs data
#######################
class CSRule

 attr_accessor :pre, :crule

 def initialize pre, crule
 @pre, @crule = pre, crule
 end

 def idx
 x = 0
 if (pre[1] == "<")
 x -= 2
 end
 return x
 end

 def cchar
 return pre[0]
 end

end

##################################
# 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 CSGrammar

 attr_reader :axiom, :context, :no_context, :idx
 def initialize(axiom)
 @axiom = axiom
 @no_context = Hash.new
 @context = Hash.new
 end

 def add_rule(pre, rule)
 case pre.length
 when 3
 @context.store(pre[2], CSRule.new(pre, rule)) # index, context, rule
 when 1
 @no_context.store pre, rule
 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 = 0
 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)) && (prod[context[ch].idx + idx] == context[ch].cchar)
 rule = context[ch].crule # use context sensitive rule
 else
 rule = no_context[ch] if no_context.has_key?(ch) # context free rule if it exists
 end
 return rule
 end
end

# Test data taken from ABOP

7.times do |i|
 grammar = CSGrammar.new("baaaaaa")
 grammar.add_rule("b<a", "b") # context sensitive rule replace a when preceded by b
 grammar.add_rule("b", "a")
 result = grammar.generate(i)
 print result << "\n"
end

Test Output:

baaaaaa
abaaaaa
aabaaaa
aaabaaa
aaaabaa
aaaaaba
aaaaaab

Note the way b 'travels' from left to right through the production string in the test output.

Reference:

The Algorithmic Beauty of Plants

Przemyslaw Prusinkiewicz
Aristid Lindenmayer

Accelerating java2d sketches in ruby processing

2011-01-21T06:57:00.005Z

Graphics acceleration of java2d is apparently turned off by default. To enable it add the following to java_args.txt in the data folder (of the sketch you wish to accelerate).

-Dsun.java2d.opengl=true  (use True instead for verbose output informs you that the graphics pipeline is open)

Which sketches will benefit from such acceleration could be determined empirically, although this article gives some guidance. I was alerted to this information by one of phi.lho responses (on the processing discussion board) to a query about relative speed of some sketches on Windows and Ubuntu (which were different Ubuntu slower, until the use of this java option).

This article is only of interest if you've got a decent graphics card and are not using software emulated graphics acceleration (eg mesa on linux). Doesn't seem to play well with control panel sketches such as jwishy.

Another Snake Kolam in ruby-processing demonstrates the use of PGraphicsPDF

2010-11-30T15:03:00.000Z

Revised Perlin Noise Sketch (to use pixel array)

2010-10-30T14:01:00.002+01:00

A somewhat optimized sketch, makes use of processing pixel array functionality, takes a little time to "warm-up". Original used P3D mode, probably should have been P2D (apparently better than default for pixel array type sketches)....

##################################################
# amp_zoom_in.rb
# adapted from a sketch at http://www.biothing.org
##################################################
attr_reader :col, :a, :b, :c, :k, :amp, :time

def setup()
  size(640, 480, P2D)
  color_mode(RGB, 1.0)
  frame_rate(4)
  load_pixels()
  reset
end

def draw()
  @time += 0.1   #step ahead in time with each frame
  #now go through each pixel in the window:

  (0...width).each do |x|
    (0...height).each do |y|
      #create values with trig functions, noise, etc acting on x,y and time.
      #experiment with how these values are modulating over time.

      @a = dist(x, y, width/2, height/2)
      @b= (cos(x/360.0 + time)).abs         # frequency larger means less
      @c = noise(y/180.0*cos(time/20.0))    # inteference, larger means less
      @amp = k                              # amplitude

      @col = color((cos(a/120.0 + b + c * 10.0).abs)) * amp
      #combine values into a color somehow.  again the possibilities are limitless
      begin
        pixels[y * width + x] = col
      rescue
        reset
      end
    end
  end
  update_pixels()
  @k += 1
end

def reset
  @k = 0
  @time = 0
end

Revisiting My Voronoi Application

2010-10-30T11:45:00.005+01:00

I had the idea for sometime to optimize this application. As before the application uses Lee Byrons library which in turn depends on John Lloyds QuickHull3D library (both can be accessed at the Lee Byron link). One day I might re-write the application to use a 3D mesh library directly. The major optimization here is to use processings built in pixels array functionality. The app will work best if the aspect ratio of the image is the same as the frame size (1:1 is probably optimal?). I have introduced an auto-scale feature that seems to work...

Use the view raw feature (below) if you want to copy the code.

Creating simple animations using the SunflowAPIAPI library and jruby

2010-10-14T14:13:00.004+01:00

Here I explore the animation possibilities of the SunflowAPIAPI library (nothing on the scale of the one by amnon.owed).
It is very simple to use ruby syntax to create different views of a scene by changing the camera position, and use sunflow to render each image. Rather than modify each frame, I had the idea of using 20 incremental views, and crudely converting them to 200 frames by copying each view 10 times. I then used mencoder to stitch the frames together to produce a short movie. Here is the result:-

Changing the camera Sunflow Hair from monkstone on Vimeo.

# hair.rb NB: run this script directly with jruby

require 'library/sunflow_api/library/sunflow_api.jar'
require 'library/sunflow/library/sunflow.jar'
require 'library/sunflow/library/janino.jar'
require 'library/sunflow/library/commons-compiler.jar'

class BasicHair

  API = Java::Com::briansteen::SunflowAPIAPI
  SMath = Java::Org::sunflow::math
  JColor = java.awt.Color

  attr_reader :width, :height, :n_particles, :sunflow

  def initialize width = 640, height = 480, cam_x = 0
    @width = width
    @height = height
    @n_particles = 20
    # create a new API instance
    @sunflow = API.new
    # set width and height

    @sunflow.set_width(width)
    @sunflow.set_height(height)
    # set background color
    @sunflow.set_background(1, 1, 1)
    # set camera
    @sunflow.set_camera_position(cam_x, 7, 5)
    @sunflow.set_camera_target(2, 0.5, 0)
    @sunflow.set_thinlens_camera("thinLensCamera", 50, width/height)
    # set basic light
    @sunflow.set_point_light("myPointLight", SMath::Point3.new(0, 5, 5),
    JColor.new(255, 255, 255))
    @sunflow.set_directional_light("myDirectionalLight", SMath::Point3.new(-2, 3, 0),
    SMath::Vector3.new(0, 0, 0), 3, JColor.new(1, 1, 1))
    # @sunflow.setSphereLight("mySphereLight", SMath::Point3.new(0, 30, -5),
    # JColor.new(0, 0, 255), 32, 10)
    # draw a ground plane
    @sunflow.draw_plane("ground", SMath::Point3.new(0, 0, 0), SMath::Vector3.new(0, 1, 0))
    # coordinates array

    @sunflow.draw_box("boxname", 0, 0, 0, 1)
  end

  def create_scene
    hair_widths = [0.025]
    # create particle coordinates
    350.times do |j|
      # particle start position
      particle_x = Math.cos(j * 0.5) * j * 0.0015
      particle_y = 0
      particle_z = Math.sin(j * 0.5) * j * 0.0015

      hair_coordinates = Array.new(n_particles * 3)

      array_index = -1

      n_particles.times do |i|
        particle_x += 0.1 + Math.cos(i * 0.15 + j * 0.05) * 0.13
        particle_y -= Math.sin(particle_z * 0.01 + j * 0.05) * 0.125 +
        Math.cos(i * 0.5 + particle_y) * 0.125
        particle_z += Math.sin(i) * 0.25 + particle_y * 0.01
        hair_coordinates[array_index += 1] = particle_x
        hair_coordinates[array_index += 1] = particle_y
        hair_coordinates[array_index += 1] = particle_z
      end

      # set ambient occlusion shader
      @sunflow.setAmbientOcclusionShader("myAmbientOcclusionShader#{j}", JColor.new(55, 55, 55),
      JColor.new(0, 0, 0), 16, 1)
      # set glass shader
      # @sunflow.setGlassShader("myGlassShader", JColor.new(1, 1, 1), 2.5, 3, JColor.new(1, 1, 1))
      # set shiny-diffuse shader
      # @sunflow.setShinyDiffuseShader("myShinyShader", JColor.new(55, 55, 55), 0.8)

      # draw object
      @sunflow.draw_hair("hair#{j}", n_particles - 2, hair_coordinates.to_java(:float),
        hair_widths.to_java(:float))
    end
  end

  def render_scene filename = nil
    sunflow.setIrradianceCacheGIEngine(32, 0.4, 1, 15, nil)
    # render
    sunflow.render() unless filename
    if filename
      begin # test for dodgy filename/path
        file = File.new(filename, "w")
        file.close
        sunflow.render(filename) # save as png image
      rescue
        puts "Warning #{filename} is not writable"
      end
    end
  end

end

20.times do |i|
  hair = BasicHair.new 640, 480, i                   # preferred render size for vimeo
  hair.create_scene
  hair.render_scene "/home/tux/ruby_sunflow/frame-#{i}.png" # default is to render in sunflow frame ie not to file
end

Performance tune-ups (or not) for jruby sunflow raytracing

2010-10-03T14:33:00.007+01:00

When I realised that sunflow is multi-threaded I thought there may be some performance tune-ups possible.

These are the steps I tried:-

I've updated my sunflow to use the latest janino compiler, only a small amount of re-factoring was required essentially deprecating two types of error and revising one because it has been re-factored to the commons-compiler.
I'm using the --server option
I'm using the --fast option
I've increased the heap space -J-Xmx1024m
I've enabled thread pooling -J-Djruby.thread.pooling=true

I'm not sure what effect if any updating the janino compiler has but to my mind it makes the application a bit more future-proof (there is the option to upgrade from java 1.4 syntax see janino web site). The windows 0.073 version of sunflow is claimed to be faster on the basis of a native compiler, I doubt it.

Using the server option is a good thing, regular java uses it by default, I'm not sure about jruby. Because --server is a proxy for -J-server, suggest to me that you may need this option since it has been made easier to use?

Using the --fast option ensures pre-compilation (amongst other speed-ups) which must be good thing here?

Allocating increased memory is the only thing the sunflow.sh script does. Running the sunflow.jar directly (java -jar sunflow.jar) requests > 800 mb heap space to run.

The thread pooling is used to prevent wasteful ruby green threads being spawned. Both cores on my dual core linux box were kept running flat out according to my conky readout.

Now the difference between none of these measures, and running with the speed-ups seemed to be noticeable, so I thought I would measure it?

Conclusion

Now I've done a bit of measurement I'm not so sure perhaps it was the janino compiler change after all?

The --server command certainly makes no difference for me, default is --server.

Well it turns out it is all in the imagination when I measured the different compilers with or without any "performance" options performance was much the same...

However I was very impressed with the new StructureSynth built in ray tracing facility, which has apparently been been built with efficiency in mind, the default setting is for 4 processors (2 real, 2 virtual). Apparently povray lags behind in that regard?

SunflowAPIAPI test example using jruby

2010-10-01T10:58:00.002+01:00

See previous post for how to setup java libraries. If you are mad like me, and have updated sunflow to use the latest janino compiler you should require the commons-compiler.jar as well.

# sunflow_test.rb NB: run this script directly with jruby

require 'library/sunflow_api/library/sunflow_api.jar'
require 'library/sunflow/library/sunflow.jar'
require 'library/sunflow/library/janino.jar'

class SunflowTest
  API = Java::Com::briansteen::SunflowAPIAPI
  SMath = Java::Org::sunflow::math

  attr_reader :sunflow

  def initialize width = 500, height = 500
    @sunflow = API.new
    sunflow.set_width(width)
    sunflow.set_height(height)
    sunflow.set_camera_position(0, 2.5, -5)
    sunflow.set_camera_target(0, 0, 0)
    sunflow.set_thinlens_camera("thinLensCamera", 50, width/height)
  end

  def create_scene
    sunflow.draw_plane("ground", SMath::Point3.new(0,-3.5,0), SMath::Vector3.new(0, 1, 0))
    sunflow.draw_sphere_flake("mySphereFlake", 20, SMath::Vector3.new(0, 1, 0), 1)
  end

  def render_scene filename = nil
    sunflow.setPathTracingGIEngine 6
    # render
    sunflow.render unless filename
    if filename
      begin # test for dodgy filename/path
        file = File.new(filename, "w")
        file.close
        sunflow.render(filename) # save as png image
      rescue
        puts "Warning #{filename} is not writable"
      end
    end
  end

end

test = SunflowTest.new
test.create_scene
test.render_scene

Basic Hair Example SunflowAPIAPI just using jruby

2010-09-30T21:51:00.008+01:00

It occurred to me that all I was getting from using ruby-processing in my previous post was the ruby processing interface to the libraries. So here is the straightforward jruby version....
Screen output very much as before (smaller) hence not included there. For your convenience I present an embedded gist (click on view raw to copy).
See previous post for how to setup java libraries.
Example translated from java version (by Christopher Warnow?) included in the subversion checkout of the sunflowAPIAPI.

Basic Hair Example SunflowAPIAPI in ruby processing

2010-09-30T16:58:00.006+01:00

See previous post for how to setup java libraries.

# basic_hair.rb run with 'rp5 run script.rb'

class BasicHair < Processing::App
 load_libraries :sunflow_api, :sunflow
 include_package 'com.briansteen'
 include_package 'org.sunflow.math'
 include_package 'java.awt'

 API = Java::Com::briansteen::SunflowAPIAPI
 SMath = Java::Org::sunflow::math
 JColor = java.awt.Color
 WIDTH = 640
 HEIGHT = 480
 P_AMOUNT = 20

 def setup
 # create a new API instance
 @sunflow = API.new
 # set width and height

 @sunflow.set_width(WIDTH)
 @sunflow.set_height(HEIGHT)
 # set background color
 @sunflow.set_background(1, 1, 1)
 # set camera
 @sunflow.set_camera_position(0, 7, 5)
 @sunflow.set_camera_target(2, 0.5, 0)
 @sunflow.set_thinlens_camera("thinLensCamera", 50, WIDTH/HEIGHT)
 # set basic light
 @sunflow.set_point_light("myPointLight", SMath::Point3.new(0, 5, 5),
 JColor.new(255, 255, 255))
 @sunflow.set_directional_light("myDirectionalLight", SMath::Point3.new(-2, 3, 0),
 SMath::Vector3.new(0, 0, 0), 3, JColor.new(1, 1, 1))
 # @sunflow.setSphereLight("mySphereLight", SMath::Point3.new(0, 30, -5),
 # JColor.new(0, 0, 255), 32, 10)
 # draw a ground plane
 @sunflow.draw_plane("ground", SMath::Point3.new(0, 0, 0), SMath::Vector3.new(0, 1, 0))
 # coordinates array
 hair_widths = [0.025]
 @sunflow.draw_box("boxname", 0, 0, 0, 1)
 # create particle coordinates
 350.times do |j|
 # particle start position
 particle_x = Math.cos(j*0.5)*j*0.0015
 particle_y = 0
 particle_z = Math.sin(j*0.5)*j*0.0015
 hair_coordinates = Array.new(P_AMOUNT*3)
 array_index = -1
 P_AMOUNT.times do |i|
 particle_x += 0.1 + Math.cos(i * 0.15 + j*0.05) * 0.13
 particle_y -= Math.sin(particle_z*0.01 + j*0.05)*0.125 +
 Math.cos(i*0.5 + particle_y)*0.125
 particle_z += Math.sin(i)*0.25 + particle_y*0.01
 hair_coordinates[array_index += 1] = particle_x
 hair_coordinates[array_index += 1] = particle_y
 hair_coordinates[array_index += 1] = particle_z
 end

 # set ambient occlusion shader
 @sunflow.setAmbientOcclusionShader("myAmbientOcclusionShader#{j}", JColor.new(55,55,55),
 JColor.new(0,0,0), 16, 1)
 # set glass shader
 # @sunflow.setGlassShader("myGlassShader", JColor.new(1,1,1), 2.5, 3, JColor.new(1,1,1))
 # set shiny-diffuse shader
 # @sunflow.setShinyDiffuseShader("myShinyShader", JColor.new(55,55,55), 0.8)

 # draw object
 @sunflow.drawHair("hair#{j}", P_AMOUNT - 2, hair_coordinates.to_java(:float),
 hair_widths.to_java(:float))
 end

 @sunflow.setIrradianceCacheGIEngine(32, 0.4, 1, 15, nil)
 # render
 @sunflow.render() # display in sunflow window
 # @sunflow.render("BasicHair.png") # save as png image
 end

 def draw
 exit
 end

end

SunflowAPIAPI in ruby processing

2010-09-30T12:17:00.013+01:00

# sunflow_test.rb

class SunflowTest < Processing::App
 load_libraries :sunflow_api, :sunflow
 include_package 'com.briansteen'
 include_package "org.sunflow.math"
 API = Java::Com::briansteen::SunflowAPIAPI
 SMath = Java::Org::sunflow::math
 WIDTH = 500
 HEIGHT = 500

 def setup
 @sunflow = API.new
 @sunflow.set_width(WIDTH)
 @sunflow.set_height(HEIGHT)
 @sunflow.set_camera_position(0, 2.5, -5)
 @sunflow.set_camera_target(0, 0, 0)
 @sunflow.set_thinlens_camera("thinLensCamera", 50, WIDTH/HEIGHT)
 @sunflow.draw_plane("ground", SMath::Point3.new(0,-3.5,0), SMath::Vector3.new(0, 1, 0))
 @sunflow.draw_sphere_flake("mySphereFlake", 20, SMath::Vector3.new(0, 1, 0), 1)
 @sunflow.setPathTracingGIEngine 6
 @sunflow.render "SunflowTestRender.png"
 end

 def draw
 exit
 end

end

SunflowTest.new :title => "Sunflow Test"

This example was copied from amnon, following his recent posting on the processing discussion boards.

Checkout the sunflowapapi source (created by Christopher Warnow?) as follows:-
svn checkout http://sunflowapiapi.googlecode.com/svn/trunk/ sunflowapiapi-read-only

Get the sunflow libraries here, NB must be version 0.07.3:-

http://sunflow.sourceforge.net

Or possible here for Windows users:-

http://www.polyquark.com/opensource

The usual library setup required compile and jar the sunflowapiapi code into sunflow_api.jar nest that as follows in a folder library, in a folder sunflow_api in the library folder (in the directory where the sketch you want to run is stored). Do similar for the sunflow.jar put the janino.jar in the same folder. The janino.jar provides a fast java compiler, version is 2.~ is supplied with the sunflow download, however with a few minor modifications sunflow can be updated to use the latest version 2.6.1 (basically include the commons-compiler.jar, and remove a couple of deprecated exception types from the code and update the CompileException to the commons compiler version org.codehaus.commons.compiler.CompileException, do this in an ide unless you are crazy).

A Staffordshire Knot Using Ruby Processing and A Context Free Library

2010-09-26T06:41:00.005+01:00

A Staffordshire Knot, ruby-processing 3D context-free DSL from monkstone on Vimeo.

Using a slight variation of the previous post we get something similar to the Staffordshire Knot.

segment :rz => i, :ry => Math.sin(i*Math::PI/180)*0.2, :x => Math.sin(i*Math::PI/180)*1.5

Is the main change, although to produce the video, I was saving frames and set the size to 640*480 to match vimeo preferences. Was very jumpy when I saved frames as #####.png ...

I have since uploaded an improved version, this time using the default save_frame (hence tif format). Mencoder doesn't like this format so I batch converted the tif files to png as so:-

mogrify -format png -transparent blue *.tif

See my processing blog for the video recording details.

An Infinity Loop? With My 3D Context Free Library

2010-09-25T21:40:00.000+01:00

# infinity.rb
# An 'infinity loop?'

load_libraries :test_free

full_screen

attr_reader :xrot, :yrot, :zrot, :wheel, :col

def setup_the_spiral
  @spiral = ContextFree.define do

    rule :infinity do
      360.times do |i|
      split do
        segment :rz => i, :ry => Math.sin(i*Math::PI/180)*0.2, :x => Math.cos(i*Math::PI/180)*3
      rewind
      end
      end
    end

    rule :segment do
      cube :alpha => 0.8
    end

    rule :segment do
      cube :brightness => 1.0, :saturation => 1.0
    end

  end
end

def setup
  render_mode P3D
  @wheel = JWheelListener.new(-50, -20)      # initialize listener with start_z and maximum values
  self.add_mouse_wheel_listener(wheel)       # register the mouse listener
  smooth
  @xrot = 0.01
  @yrot = 0
  @zrot = 0
  @col = 0
  setup_the_spiral
end

def draw
  background 0
  setup_lights col
  specular col, 1, 1
  emissive 0.05
  shininess 10
  smooth_rotation(3, 3.2)
  smooth_color(6.0)
  @spiral.render :infinity, :start_x => 0, :start_y => 0, :start_z => wheel.zoom, :size => height/350,
  :stop_size => 0.2, :color => [0, 0.7, 0.7, 0.5], :rx => xrot, :ry => yrot, :rz => zrot
end

##
# Generate a gradient value that changes smoothly over time in the range [ 0, 1 ].
# The Math.sin() function is used to map the current time in milliseconds somewhere
# in the range [ 0, 1 ]. A 'speed' factor is specified by the parameters s1.
#
def smooth_gradient(s1)
  mills = millis * 0.00003
  gradient = 0.5 * Math.sin(mills * s1) + 0.5
end

##
# Rotate the current coordinate system.
# Uses smooth_gradient() to smoothly animate the rotation.
#
def smooth_rotation(s1, s2)
  @yrot = 2.0 * Math::PI * smooth_gradient(s1)
  @zrot = 2.0 * Math::PI * smooth_gradient(s2)
end

##
# Generate a 'hue' value which smoothly changes over time.
# The speed of change is controlled by the parameter s1.
#
def smooth_color(s1)
  @col = smooth_gradient(s1)
end

def setup_lights(col)
  directional_light(col, 0.8, 0.8, -0.5, 0.5, -1)
  point_light(col, 0.8, 0.8, -0.5, 0.5, -1)
  ambient_light(col, 0.8, 0.8, 1, 1, 1)
end

Revised 3D Context Free DSL Sketch, with Mouse Wheel Zoom Utility

2010-09-13T16:35:00.010+01:00

I demonstrate the new feature of mouse wheel zoom in this sketch. The logic for the smooth of color and rotation I copied from lazydogs classy rotating ball. PS: if you can't see the embedded code below chances are you are not using either Firefox or Google Chrome browser (doesn't always work for me with Opera, which I also find is awkward to use when copying code).

default.rb from monkstone on Vimeo.

A Mouse Wheel Listener in Ruby Processing

2010-09-12T15:12:00.001+01:00

For my 3D context free application/library, I would like to be able to zoom using the mouse wheel, I had vaguely thought about using peasycam or proscene to provide that, and other functionality. In the first instance I wanted to create it myself. After a bit of research, this the sort of implementation I would do using the java classes/interfaces in ruby:-

# mouse_listener.rb

class JWheelListener
 include java.awt.event.MouseWheelListener

 attr_reader :zoom

 def initialize(zoom)
 @zoom = zoom
 end

 def mouse_wheel_moved(e)
 @zoom += e.get_wheel_rotation * 10
 end

end

class Mouse < Processing::App

 attr_reader :wheel

 def setup
 size(1000, 1000)
 @wheel = JWheelListener.new(10)
 self.add_mouse_wheel_listener(@wheel)
 end

 def draw
 background 0
 fill 255, 0, 0
 ellipse(width/2, height/2, wheel.zoom, wheel.zoom)

 end

end

Mouse.new :title => "Mouse Wheel Listener"

3D Context Free DSL Screen Saver?

2010-09-11T08:18:00.006+01:00

Here is an animated version of the default.es from StructureSynth in ruby-processing. Mac or windows users might want to experiment with OPENGL rendering, as this sketch exposes errors in processing P3D, I see odd missing pixels from time to time. If you don't like the holes remove the smooth, personally I prefer the holes to the glitchty non-smooth (it is a known issue with current versions of processing with both P2D and P3D renderers, something to do with tessellation algorithms). The test_free library is as in previous post.
Nest the library as follows:-
library/test_free/test_free.rb in the folder containing the sketch
For instructions for installing ruby-processing follow the first link in the blog header.

# full_screen.rb
# An animation of default.es
# the StructureSynth default script

load_libraries :test_free
full_screen
attr_reader :xrot, :yrot, :zrot

def setup_the_spiral
  @spiral = ContextFree.define do

    rule :default do
      split do
      R1 :brightness => 1
      rewind
      R2 :brightness => 1
    end
    end

    rule :R1 do
      sphere :brightness => 1
      R1 :size => 0.99, :x => 0.25, :rz => 6, :ry => 6
    end

    rule :R2 do
      sphere :brightness => 1
      R2 :size => 0.99, :x => -0.25, :rz => 6, :ry => 6
    end

  end
end

def setup
  render_mode P3D
  smooth
  @xrot = 0.01
  @yrot = 0
  @zrot = 0
  setup_the_spiral
end

def draw
  background 0
  lights
  smooth_rotation(6.7, 7.3)
  @spiral.render :default, :start_x => 0, :start_y => 0, :start_z => -50, :size => height/350,
  :stop_size => 0.2, :color => [0, 0.8, 0.8], :rx => xrot, :ry => yrot, :rz => zrot
end

##
# Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
# Each component uses a Math.sin() function to map the current time in milliseconds somewhere
# in the range [ 0, 1 ].A 'speed' factor is specified for each component.
#
def smooth_vector(s1, s2)
  mills = millis * 0.00003
  y = 0.5 * Math.sin(mills * s1) + 0.5
  z = 0.5 * Math.sin(mills * s2) + 0.5
  vec = [y, z]
end

##
# Rotate the current coordinate system.
# Uses smooth_vector() to smoothly animate the rotation.
#
def smooth_rotation(s1, s2)
  r1 = smooth_vector(s1, s2)
  @yrot = (2.0 * Math::PI * r1[0])
  @zrot = (2.0 * Math::PI * r1[1])
end

Translating the default.es to ruby processing DSL

2010-09-09T16:40:00.011+01:00

It was very constructive to see if I could translate the EisenScript to my ruby processing DSL, I immediately learnt something about the EisenScript (recursion seems to be implicit, something I had not understood before). What I learnt about my library, was I was losing some context by directly altering the attitude (the image expected from the EisenScript appeared briefly but quickly degraded). I have now re-factored the sketch to only adjust the initial angle, the x rotation seems to affect the amplitude of deformation from the plane of the spirals. The y and z rotation give control of the attitude, and need to be used in combination to fully explore the 3 dimensional shape, which is now somewhat like that produced by StrucureSynth.

Here is my revised 3d context free DSL (test_free.rb):-

# A Context-Free library for Ruby-Processing, inspired by
# contextfreeart.org and StructureSynth
# Built on Jeremy Ashkenas context free DSL script

module Processing

 class ContextFree

 include Processing::Proxy

 attr_accessor :rules, :app, :xr, :yr, :zr

 AVAILABLE_OPTIONS = [:x, :y, :z, :rx, :ry, :rz, :size, :color, :hue, :saturation, :brightness, :alpha]
 HSB_ORDER = {:hue => 0, :saturation => 1, :brightness => 2, :alpha => 3}

 # Define a context-free system. Use this method to create a ContextFree
 # object. Call render() on it to make it draw.
 def self.define(&block)
 cf = ContextFree.new
 cf.instance_eval &block
 cf
 end

 # Initialize a bare ContextFree object with empty recursion stacks.
 def initialize
 @app = $app
 @graphics = $app.g
 @finished = false
 @rules = {}
 @rewind_stack = []
 @matrix_stack = []
 @xr = 0
 @yr = 0
 @zr = 0
 end

 # Create an accessor for the current value of every option. We use a values
 # object so that all the state can be saved and restored as a unit.
 AVAILABLE_OPTIONS.each do |option_name|
 define_method option_name do
 @values[option_name]
 end
 end

 # Here's the first serious method: A Rule has an
 # identifying name, a probability, and is associated with
 # a block of code. These code blocks are saved, and indexed
 # by name in a hash, to be run later, when needed.
 # The method then dynamically defines a method of the same
 # name here, in order to determine which rule to run.
 def rule(rule_name, prob=1, &proc)
 @rules[rule_name] ||= {:procs => [], :total => 0}
 total = @rules[rule_name][:total]
 @rules[rule_name][:procs] << [(total...(prob+total)), proc]
 @rules[rule_name][:total] += prob
 unless ContextFree.method_defined? rule_name
 self.class.class_eval do
 eval <<-METH
 def #{rule_name}(options)
 merge_options(@values, options)
 pick = determine_rule(#{rule_name.inspect})
 @finished = true if @values[:size] < @values[:stop_size]
 unless @finished
 get_ready_to_draw
 pick[1].call(options)
 end
 end
 METH
 end
 end
 end

 # Rule choice is random, based on the assigned probabilities.
 def determine_rule(rule_name)
 rule = @rules[rule_name]
 chance = rand * rule[:total]
 pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
 return pick.flatten
 end

 # At each step of the way, any of the options may change, slightly.
 # Many of them have different strategies for being merged.
 def merge_options(old_ops, new_ops)
 return unless new_ops
 # Do size first
 old_ops[:size] *= new_ops[:size] if new_ops[:size]
 new_ops.each do |key, value|
 case key
 when :size
 when :x, :y, :z
 old_ops[key] = value * old_ops[:size]
 when :rz, :ry, :rx
 old_ops[key] = value * (Math::PI / 180.0)
 when :hue, :saturation, :brightness, :alpha
 adjusted = old_ops[:color].dup
 adjusted[HSB_ORDER[key]] *= value
 old_ops[:color] = adjusted
 when :width, :height
 old_ops[key] *= value
 when :color
 old_ops[key] = value
 else # Used a key that we don't know about or trying to set
 merge_unknown_key(key, value, old_ops)
 end
 end
 end

 # Using an unknown key let's you set arbitrary values,
 # to keep track of for your own ends.
 def merge_unknown_key(key, value, old_ops)
 key_s = key.to_s
 if key_s.match(/^set/)
 key_sym = key_s.sub('set_', '').to_sym
 if key_s.match(/(brightness|hue|saturation|alpha)/)
 adjusted = old_ops[:color].dup
 adjusted[HSB_ORDER[key_sym]] = value
 old_ops[:color] = adjusted
 else
 old_ops[key_sym] = value
 end
 end
 end

 # Doing a 'split' saves the context, and proceeds from there,
 # allowing you to rewind to where you split from at any moment.
 def split(options=nil, &block)
 save_context
 merge_options(@values, options) if options
 yield
 restore_context
 end

 # Saving the context means the values plus the coordinate matrix.
 def save_context
 @rewind_stack.push @values.dup
 @matrix_stack << @graphics.get_matrix
 end

 # Restore the values and the coordinate matrix as the recursion unwinds.
 def restore_context
 @values = @rewind_stack.pop
 @graphics.set_matrix @matrix_stack.pop
 end

 # Rewinding goes back one step.
 def rewind
 @finished = false
 restore_context
 save_context
 end

 # Render the is method that kicks it all off, initializing the options
 # and calling the first rule.
 def render(rule_name, starting_values={})
 @values = {:x => 0, :y => 0, :z => 0,
 :rz => 0, :ry => 0, :rx => 0,
 :size => 1, :width => 1, :height => 1,
 :start_x => width/2, :start_y => height/2, :start_z => 0,
 :color => [0.5, 0.5, 0.5, 1],
 :stop_size => 1.5}
 @values.merge!(starting_values)
 @finished = false
 @app.reset_matrix
 @app.no_stroke
 @app.color_mode HSB, 1.0
 @app.translate @values[:start_x], @values[:start_y], @values[:start_z]
 self.send(rule_name, {})
 end

 def rotate_x rt
 @xr = rt
 end
 def rotate_y rt
 @yr = rt
 end
 def rotate_z rt
 @zr = rt
 end

 # Before actually drawing the next step, we need to move to the appropriate
 # location.
 def get_ready_to_draw
 @app.translate(@values[:x], @values[:y], @values[:z])
 @app.rotate_x(@values[:rx] + xr)
 @app.rotate_y(@values[:ry] + yr)
 @app.rotate_z(@values[:rz] + zr)
 end

 # Compute the rendering parameters for drawing a shape.
 def get_shape_values(some_options)
 old_ops = @values.dup
 merge_options(old_ops, some_options) if some_options
 @app.fill *old_ops[:color]
 return old_ops[:size], old_ops
 end

 # Sphere, cube are the primitive drawing
 def cube(some_options=nil)
 size, options = *get_shape_values(some_options)
 rotz = options[:rz]
 roty = options[:ry]
 rotx = options[:rx]
 @app.rotate_x rotx unless rotx.nil?
 @app.rotate_y roty unless roty.nil?
 @app.rotate_z rotz unless rotz.nil?
 @app.translate(options[:x] * size, options[:y] * size , options[:z] * size)
 @app.box(size)
 @app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an oredered way
 @app.rotate_y(-1 * roty) unless roty.nil?
 @app.rotate_x(-1 * rotx) unless rotx.nil?

 end

 def sphere(some_options=nil)
 size, options = *get_shape_values(some_options)
 rotz = options[:rz]
 roty = options[:ry]
 rotx = options[:rx]
 @app.rotate_x rotx unless rotx.nil?
 @app.rotate_y roty unless roty.nil?
 @app.rotate_z rotz unless rotz.nil?
 @app.sphere_detail 10
 @app.sphere(size)
 @app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an oredered way
 @app.rotate_y(-1 * roty) unless roty.nil?
 @app.rotate_x(-1 * rotx) unless rotx.nil?
 end
 end
end

My Translation of default.es to ruby processing

# default.rb
# virtually a direct translation of default.es
# the StructureSynth default script

load_libraries :test_free, :control_panel

attr_reader :amplitude, :yrot, :zrot

def setup_the_spiral
 @spiral = ContextFree.define do

 rule :default do
 split do
 R1 :brightness => 1
 rewind
 R2 :brightness => 1
 end
 end

 rule :R1 do
 sphere :brightness => 1
 R1 :size => 0.99, :x => 0.25, :rz => 6, :ry => 6
 end

 rule :R2 do
 sphere :brightness => 1
 R2 :size => 0.99, :x => -0.25, :rz => 6, :ry => 6
 end

 end
end

def configure_control # setup control panel gui
 control_panel do |c|
 c.title = "Amplitude+Attitude"
 c.slider :amplitude, -0.025..0.015, 0.0
 c.slider :yrot, -6.3..6.3, 0.005
 c.slider :zrot, -6.3..6.3, 0.005
 end
end

def setup
 size 800, 800, P3D
 configure_control
 smooth
 setup_the_spiral
end

def draw
 background 0
 lights
@spiral.render :default, :start_x => 0, :start_y => 0, :start_z => -40, :size => height/400,
 :stop_size => 0.2, :color => [0, 0.8, 0.8], :rx => amplitude, :ry => yrot, :rz => zrot
end

Testing the cube primitive in my context free DSL

2010-09-09T15:22:00.004+01:00

Another context free DSL example, better annotated, control panel and library as previous post (not shown):-

# cube.rb

load_libraries :test_free, :control_panel

attr_reader :xrot, :yrot, :zrot

def setup_the_spiral
 @spiral = ContextFree.define do # define the cf rules

 rule :cubeform do
 5.times do |i|
 split do # record the context
 cuby :ry => 72 * i
 rewind # restore the context
 end
 end
 end

 rule :beam do
 6.times do |i|
 split do # record the context
 cube :y => 0.2 * i
 rewind # restore the context
 end
 end
 end

 rule :cuby do
 beam :brightness => 1
 cuby :size => 0.98, :y => -0.24 # recursive call ends when size < 1
 end

 end
end

def setup # static setup
 size 800, 800, P3D # I can only use P3D (unless full_screen) on linux opengl might work on mac/windows
 configure_control
 smooth
 setup_the_spiral
end

def configure_control # setup control panel gui
 control_panel do |c|
 c.title = "Attitude Control"
 c.slider :xrot, -3.1..3.1, 0.5
 c.slider :yrot, -3.1..3.1, 0.5
 c.slider :zrot, -3.1..3.1, 1.0
 end
end

def draw # animation loop
 background 0.8
 lights
 @spiral.render :cubeform, :start_x => 0, :start_y => 10, :start_z => -30, :size => height/300, :stop_size => 1, :color => [0, 0.8, 0.8]
 @spiral.rotate_x xrot
 @spiral.rotate_y yrot
 @spiral.rotate_z zrot
end

Within the sketch :hue, :saturation and :brightness can be individually set. If you want to use :alpha, initialize :color with a 4 dimension array. Note, the color mode in the ruleset is hsb with range 0 .. 1.0. Increment and decrement is linear cf size where it is multiplicative.

Experimental 3D Context Free DSL in ruby-processing, a bit of a monster?

2010-09-08T22:39:00.018+01:00

This is at fairly experimental stage, I need to decide how to order rotations/translations. At the moment order is fixed by the library script, so it doesn't matter what order they are entered you get the default order!!!

This library cannot compete with StructureSynth which is a much more refined and complete program. However if you are used to ruby it may be easier to write your rules in ruby, rather than in the EisenScript syntax. The funky extra thing is, because it is based on processing you have the animation possibilities of the 'draw' loop. My monster in some directions could be seen as a beating heart.

To use the library, create a folder for you work say "work", create a sub-folder "library" and sub-sub-folder "test_free" (or whatever better name you can think of for the library). Put the library "test_free.rb" in the sub-sub-folder. Write you sketches in the "work" directory, and run them with "rp5 run my_sketch.rb". If you want to do it the really neat way use JEdit as your editor and my macro and commando tools, then you can run the sketch from the editor. The link to the tools describes live editing, which I haven't tried with this library so I would recommend just using the run mode for now.

If you are not a ruby meddler just get StructureSynth, and learn the EisenScript language. Otherwise you will need to get ruby-processing see link in my blog header to see how. My blog header also has link to the original Jeremy Ashkenas context-free.rb on github.

The test_free.rb library

# A Context-Free library for Ruby-Processing, inspired by
# contextfreeart.org and StructureSynth
# Built on Jeremy Ashkenas context free DSL script

module Processing

 class ContextFree

 include Processing::Proxy

 attr_accessor :rules, :app, :xr, :yr, :zr

 AVAILABLE_OPTIONS = [:x, :y, :z, :rx, :ry, :rz, :size, :color, :hue, :saturation, :brightness, :alpha]
 HSB_ORDER = {:hue => 0, :saturation => 1, :brightness => 2, :alpha => 3}

 # Define a context-free system. Use this method to create a ContextFree
 # object. Call render() on it to make it draw.
 def self.define(&block)
 cf = ContextFree.new
 cf.instance_eval &block
 cf
 end

 # Initialize a bare ContextFree object with empty recursion stacks.
 def initialize
 @app = $app
 @graphics = $app.g
 @finished = false
 @rules = {}
 @rewind_stack = []
 @matrix_stack = []
 @xr = 0
 @yr = 0
 @zr = 0
 end

 # Create an accessor for the current value of every option. We use a values
 # object so that all the state can be saved and restored as a unit.
 AVAILABLE_OPTIONS.each do |option_name|
 define_method option_name do
 @values[option_name]
 end
 end

 # Here's the first serious method: A Rule has an
 # identifying name, a probability, and is associated with
 # a block of code. These code blocks are saved, and indexed
 # by name in a hash, to be run later, when needed.
 # The method then dynamically defines a method of the same
 # name here, in order to determine which rule to run.
 def rule(rule_name, prob=1, &proc)
 @rules[rule_name] ||= {:procs => [], :total => 0}
 total = @rules[rule_name][:total]
 @rules[rule_name][:procs] << [(total...(prob+total)), proc]
 @rules[rule_name][:total] += prob
 unless ContextFree.method_defined? rule_name
 self.class.class_eval do
 eval <<-METH
 def #{rule_name}(options)
 merge_options(@values, options)
 pick = determine_rule(#{rule_name.inspect})
 @finished = true if @values[:size] < @values[:stop_size]
 unless @finished
 get_ready_to_draw
 pick[1].call(options)
 end
 end
 METH
 end
 end
 end

 # Rule choice is random, based on the assigned probabilities.
 def determine_rule(rule_name)
 rule = @rules[rule_name]
 chance = rand * rule[:total]
 pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
 return pick.flatten
 end

 # At each step of the way, any of the options may change, slightly.
 # Many of them have different strategies for being merged.
 def merge_options(old_ops, new_ops)
 return unless new_ops
 # Do size first
 old_ops[:size] *= new_ops[:size] if new_ops[:size]
 new_ops.each do |key, value|
 case key
 when :size
 when :x, :y, :z
 old_ops[key] = value * old_ops[:size]
 when :rz, :ry, :rx
 old_ops[key] = value * (Math::PI / 180.0)
 when :hue, :saturation, :brightness, :alpha
 adjusted = old_ops[:color].dup
 adjusted[HSB_ORDER[key]] *= value
 old_ops[:color] = adjusted
 when :width, :height
 old_ops[key] *= value
 when :color
 old_ops[key] = value
 else # Used a key that we don't know about or trying to set
 merge_unknown_key(key, value, old_ops)
 end
 end
 end

 # Using an unknown key let's you set arbitrary values,
 # to keep track of for your own ends.
 def merge_unknown_key(key, value, old_ops)
 key_s = key.to_s
 if key_s.match(/^set/)
 key_sym = key_s.sub('set_', '').to_sym
 if key_s.match(/(brightness|hue|saturation|alpha)/)
 adjusted = old_ops[:color].dup
 adjusted[HSB_ORDER[key_sym]] = value
 old_ops[:color] = adjusted
 else
 old_ops[key_sym] = value
 end
 end
 end

 # Doing a 'split' saves the context, and proceeds from there,
 # allowing you to rewind to where you split from at any moment.
 def split(options=nil, &block)
 save_context
 merge_options(@values, options) if options
 yield
 restore_context
 end

 # Saving the context means the values plus the coordinate matrix.
 def save_context
 @rewind_stack.push @values.dup
 @matrix_stack << @graphics.get_matrix
 end

 # Restore the values and the coordinate matrix as the recursion unwinds.
 def restore_context
 @values = @rewind_stack.pop
 @graphics.set_matrix @matrix_stack.pop
 end

 # Rewinding goes back one step.
 def rewind
 @finished = false
 restore_context
 save_context
 end

 # Render the is method that kicks it all off, initializing the options
 # and calling the first rule.
 def render(rule_name, starting_values={})
 @values = {:x => 0, :y => 0, :z => 0,
 :rz => 0, :ry => 0, :rx => 0,
 :size => 1, :width => 1, :height => 1,
 :start_x => width/2, :start_y => height/2, :start_z => 0,
 :color => [0.5, 0.5, 0.5, 1],
 :stop_size => 1.5}
 @values.merge!(starting_values)
 @finished = false
 @app.reset_matrix
 @app.rect_mode CENTER
 @app.ellipse_mode CENTER
 @app.no_stroke
 @app.color_mode HSB, 1.0
 @app.translate @values[:start_x], @values[:start_y], @values[:start_z]
 self.send(rule_name, {})
 end

 def rotate_x rt
 @xr = rt
 end
 def rotate_y rt
 @yr = rt
 end
 def rotate_z rt
 @zr = rt
 end

 # Before actually drawing the next step, we need to move to the appropriate
 # location.
 def get_ready_to_draw
 @app.translate(@values[:x], @values[:y], @values[:z])
 @app.rotate_x(@values[:rx] + xr)
 @app.rotate_y(@values[:ry] + yr)
 @app.rotate_z(@values[:rz] + zr)
 end

 # Compute the rendering parameters for drawing a shape.
 def get_shape_values(some_options)
 old_ops = @values.dup
 merge_options(old_ops, some_options) if some_options
 @app.fill *old_ops[:color]
 return old_ops[:size], old_ops
 end

 # The shape primitives are sphere and cube
 def cube(some_options=nil)
 size, options = *get_shape_values(some_options)
 rotz = options[:rz]
 roty = options[:ry]
 rotx = options[:rx]
 @app.rotate_x rotx unless rotx.nil?
 @app.rotate_y roty unless roty.nil?
 @app.rotate_z rotz unless rotz.nil?
 @app.translate(options[:x] * size, options[:y] * size , options[:z] * size)
 @app.box(size)
 @app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an ordered way
 @app.rotate_y(-1 * roty) unless roty.nil?
 @app.rotate_x(-1 * rotx) unless rotx.nil?

 end

 def sphere(some_options=nil)
 size, options = *get_shape_values(some_options)
 rotz = options[:rz]
 roty = options[:ry]
 rotx = options[:rx]
 @app.rotate_x rotx unless rotx.nil?
 @app.rotate_y roty unless roty.nil?
 @app.rotate_z rotz unless rotz.nil?
 @app.translate(options[:x] * size, options[:y] * size , options[:z] * size)
 @app.sphere_detail 10
 @app.sphere(size)
 @app.rotate_z(-1 * rotz) unless rotz.nil? # unwind rotations in an ordered way
 @app.rotate_y(-1 * roty) unless roty.nil?
 @app.rotate_x(-1 * rotx) unless rotx.nil?
 end
 end
end

My Test Script monster.rb

load_libraries :test_free, :control_panel

attr_reader :xrot, :yrot, :zrot

def setup_the_spiral
 @spiral = ContextFree.define do
 rule :monster do
 5.times do |i|
 split do
 cone :ry => 72 * i
 rewind
 end
 end
 end

 rule :cone do # two equally weighted cone rules creates the beat
 sphere :brightness => 1
 cone :size => 0.96, :y => -0.24
 end

 rule :cone do
 sphere :brightness => 1
 cone :size => 0.97, :y => -0.28
 end

 end
end

def setup
 size 800, 800, P3D
 configure_control
 smooth
 setup_the_spiral
end

def configure_control
 control_panel do |c|
 c.title = "Attitude Control"
 c.slider :xrot, -3.1..3.1, 0.5
 c.slider :yrot, -3.1..3.1, 0.5
 c.slider :zrot, -3.1..3.1, 1.0
 end
end
def draw
 background 0.8
 lights
 @spiral.render :monster, :start_x => 0, :start_y => 10, :start_z => -30, :size => height/200, :stop_size => 1, :color => [0, 0.8, 0.8]
 @spiral.rotate_x xrot
 @spiral.rotate_y yrot
 @spiral.rotate_z zrot
end

Using the control panel and Toxi Processing Libraries in ruby processing

2010-09-04T09:53:00.001+01:00

Here is a sketch that shows how easy it is to add controls to your sketch in ruby-processing.

#
# GrayScottControl uses the seedImage() method to use a bitmap as simulation seed.
# In this demo the image is re-applied every frame and the user can adjust the
# F coefficient of the reaction diffusion to produce different patterns emerging
# from the boundary of the bitmapped seed. Unlike some other GS demos provided,
# this one also uses a wrapped simulation space, creating tiled patterns.
#
# usage:
# <ul>
# <li>click + drag mouse to locally disturb the simulation</li>
# <li>Use slider to adjust the F parameter of the simulation</li>
# <li>press reset! to do what?</li>
# <li>press save_graycsott to do save</li>
# </ul>
#

#
# Copyright (c) 2010 Karsten Schmidt (rubified by Martin Prout)
#
# This demo & library is free software you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation either
# version 2.1 of the License, or (at your option) any later version.
#
# http:#creativecommons.org/licenses/LGPL/2.1/
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#

class GrayScottControl < Processing::App
 load_libraries 'simutils','toxiclibscore','colorutils','control_panel'
 include_package "toxi.sim.grayscott"
 include_package "toxi.math"
 include_package "toxi.color"

 attr_reader :gs, :tone_map, :img, :set_f

 def setup
 size 256, 256
 setup_control
 @gs = GrayScott.new width, height, true
 @img = load_image "two_prong.png"
 # create a duo-tone gradient map with 256 steps
 # NB: use '::' in place of '.' here
 @tone_map = ToneMap.new(0, 0.33, NamedColor::CRIMSON, NamedColor::WHITE, 256)
 end

 def draw
 @gs.seed_image(img.pixels, img.width, img.height)
 @gs.set_rect(mouse_x, mouse_y, 20, 20) if mouse_pressed?
 load_pixels
 10.times { @gs.update(1) }
 # read out the V result array
 # and use tone map to render colours
 gs.v.length.times do |i|
 pixels[i]=tone_map.getARGBToneFor(gs.v[i]) # NB: don't camel case convert here
 end
 @gs.setF(0.02 + set_f * 0.001)
 update_pixels
 end

 def setup_control
 control_panel do |c|
 c.title = "Control Panel"
 c.slider :set_f, 0..9, 8
 c.button :save_graycsott
 c.button :reset!
 end
 end

 def save_graycsott
 no_loop
 save_frame "toxi.png"
 loop
 end

 def reset!
 @gs.reset
 end

end