Loading Libraries

Like ruby-processing, there is a load_library utility, that can be used to load processing libraries or pure ruby libraries (or a mixture thereof when java libraries are called by the ruby library). Libraries need to have unique names and are called in this order:-

1. local ruby library library/grammar.rb called using load_library :grammar

2. local java library library/video/{jars} one or more jars including those in lib sub-folder called using load_library :video

3. processing installed java library {libraries}/library/video/{jars} one or more jars including those in lib sub-folder. This can be configured in `~/.jruby_art/config.yml to point to wherever vanilla processing libraries are stored.

# YAML configuration file for ruby-processing
# K9_HOME: "/home/ruby193 ... /ruby-processing" #windows users may need to set this
---
PROCESSING_ROOT: /home/tux/processing-3.0a10 
sketchbook_path: /home/tux/sketchbook/

Usage

Using video and video_event libraries, the video_event allows use of java reflection method captureEvent

load_libraries :video, :video_event

include_package 'processing.video'

attr_reader :cam

def setup
  sketch_title 'Test Capture'
  cameras = Capture.list
  fail 'There are no cameras available for capture.' if (cameras.length == 0)
  p 'Matching cameras available:'
  size_pattern = Regexp.new(format('%dx%d', width, height))
  select = cameras.grep size_pattern # filter available cameras
  select.uniq.map { |cam| p cam.strip }
  fail 'There are no matching cameras.' if (select.length == 0)
  start_capture(select[0])
end

def start_capture(cam_string)
  # The camera can be initialized directly using an
  # element from the array returned by list:
  @cam = Capture.new(self, cam_string)
  p format('Using camera %s', cam_string)
  cam.start
end

def draw
  image(cam, 0, 0)
  # The following does the same, and is faster when just drawing the image
  # without any additional resizing, transformations, or tint.
  # set(0, 0, cam)
end

def captureEvent(c)
  c.read
end

def settings
  size 960, 544, P2D
end

A custom ruby library 'library/grammar.rb' example

########################################################
# NB: To be edited refers old arch
########################################################
require 'jruby_art'

class ChequerSketch < Processing::App
  load_library :grammar

  attr_reader :chequer

  def setup
    size 600, 600
    @chequer = Chequer.new(self, width * 0.9, height/10)
    chequer.create_grammar 4  
    no_loop
  end

  def draw
    background 0
    chequer.render
  end
end

class Chequer
  attr_accessor :app, :axiom, :grammar, :production, :draw_length, :theta, :xpos, :ypos
  DELTA = Math::PI / 2.0
  
  def initialize(app, xpos, ypos)
    @app, @xpos, @ypos = app, xpos, ypos 
    @axiom = 'F-F-F-F'        # Axiom
    @grammar = Grammar.new(axiom, 'F' => 'FF-F-F-F-FF')
    @draw_length = 500
    app.stroke 0, 255, 0
    app.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 * Math.cos(theta) 
        @ypos -= draw_length * Math.sin(theta)
        app.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

ChequerSketch.new