ruby-processing 2.6.3 → 2.6.4

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

@@ -1,45 +0,0 @@
-#
-# 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 = (mouse_y % img.height).abs
-  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

@@ -1,48 +0,0 @@
-#
-# 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

@@ -1,66 +0,0 @@
-#
-# 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/Rakefile

@@ -1,30 +0,0 @@
-# Simple demo Rakefile to autorun samples in current directory
-# adjust path to rp5 executable, and or opts as required
-
-SAMPLES_DIR = './'
-
-desc 'run demo'
-task default: [:demo]
-
-desc 'demo'
-task :demo do
-  samples_list.shuffle.each{ |sample| run_sample sample }
-end
-
-def samples_list
-  files = []
-  Dir.chdir(SAMPLES_DIR)
-  Dir.glob('*.rb').each do |file|
-    files << File.join(SAMPLES_DIR, file)
-  end
-  return files
-end
-
-def run_sample(sample_name)
-  puts "Running #{sample_name}...quit to run next sample"
-  open("|rp5 run #{sample_name}", 'r') do |io|
-    while l = io.gets
-      puts(l.chop)
-    end      
-  end
-end

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

@@ -1,66 +0,0 @@
-########################################################
-# Chequer implemented using a grammar library
-# Lindenmayer System in ruby-processing by Martin Prout
-########################################################
-
-load_library :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
-  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')
-    @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

@@ -1,100 +0,0 @@
-########################################################
-# csplant.rb
-# A 3D Plant implemented using a Context Sensitive
-# Lindenmayer System in ruby-processing 
-# by Martin Prout (30 January 2013)
-# Hold down 'y' key and drag mouse to rotate about y axis
-########################################################
-
-load_libraries :cs_grammar, :vecmath, :fastmath
-attr_reader :csplant
-
-def setup
-  size 800, 800, P3D
-  ArcBall.init(self)
-  @csplant = CSPlant.new(height)
-  csplant.create_grammar 5
-  no_stroke
-end
-
-def draw
-  background 0
-  lights
-  translate(0, height*0.3)
-  csplant.render
-end
-
-############
-# CSPlant 
-############
-
-class CSPlant
-  include Processing::Proxy
-
-  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 = 25.radians
-    @phi = 25.radians
-    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

@@ -1,25 +0,0 @@
-###########################
-# cstest.rb (use rp5 run ..
-# test of cs_grammar library
-###########################
-load_library 'cs_grammar'
-
-def setup
-  size 150, 250
-  background 0
-  fill(200, 200, 0)
-  f = create_font('Arial', 16, true)
-  text_font(f)
-  (0..7).each do |i|
-    grammar = Grammar.new(
-      'baaaaaa',
-      {
-        'b<a' => 'b',   # context sensitive rule replace a when preceded by b
-        'b'   =>'a'
-      }
-      )    
-    text grammar.generate(i), 30, i * 25
-  end
-end
-
-

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

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

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

@@ -1,75 +0,0 @@
-####################################################
-# 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