ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/library/vecmath/smoke_particle_system.rb

@@ -0,0 +1,138 @@
+# Ported from http://processing.org/learning/topics/smokeparticlesystem.html
+# For some reason this sketch needs to be run with the --nojruby flag
+#
+# A ParticleSystem (Array) object manages a variable size list of
+# particles.
+
+load_library :vecmath
+
+attr_reader :ps, :img, :wind
+
+def setup
+  size(640,360)
+  @img = load_image("texture.png")
+  @ps = ParticleSystem.new(0, Vec2D.new(width/2, height - 60), img)
+end
+
+def draw
+  background(0)  
+  # Calculate a "wind" force based on mouse horizontal position
+  dx = map(mouse_x, 0, width, -0.2, 0.2)
+  @wind = Vec2D.new(dx, 0)
+  ps.apply_force(wind)
+  ps.run
+  2.times do
+    ps.add_particle
+  end
+  
+  # Draw a horizontal arrow representing the wind force
+  draw_vector(wind, Vec2D.new(width / 2, 50, 0), 500)
+  
+end
+
+# Renders a vector object 'v' as an arrow and a location 'loc'
+def draw_vector(v, loc, scayl)
+  push_matrix
+  # Translate to location to render vector
+  translate(loc.x, loc.y)  
+  rotate(v.heading)
+  # Calculate length of vector & scale as necessary
+  len = v.mag * scayl
+  # Draw three lines to make an arrow 
+  arrowsize = 4
+  stroke(255)
+  stroke_weight 2
+  line(0, 0, len, 0)
+  stroke_weight 1
+  line(len, 0, len - arrowsize, +arrowsize/2)
+  line(len, 0, len - arrowsize, -arrowsize/2)
+  pop_matrix
+end
+
+module Runnable
+  def run
+    self.reject! { |item| item.lifespan <= 0 }
+    self.each    { |item| item.run }
+  end
+end
+
+
+class ParticleSystem 
+  extend Enumerable
+  include Runnable
+  
+  attr_reader :particles, :origin, :image, :generator
+  
+  def initialize(num, location, image)
+    @particles = []
+    @origin = location # no need for location.clone in ruby
+    @image = image    
+    (0 ... num).each do
+      particles << Particle.new(origin, image)
+    end
+  end
+  
+  def each &block
+    particles.each &block    
+  end
+
+  def reject! &block
+    particles.reject! &block
+  end
+  
+  def add_particle(p = Particle.new(origin, image))
+    particles << p
+  end
+  
+  # Method to add a force vector to all particles currently in the system
+  def apply_force(dir) 
+    self.each do |p|
+      p.apply_force(dir)
+    end  
+  end 
+end
+
+# A simple Particle class
+
+class Particle 
+  include Processing::Proxy 
+  
+  attr_reader :loc, :acc, :vel, :lifespan, :img, :generator
+  
+  def initialize(l, img_) 
+    @acc = Vec2D.new
+    vx = random_gaussian * 0.3
+    vy = random_gaussian * 0.3 - 1.0
+    @vel = Vec2D.new(vx, vy)
+    @loc = l # no need for l.clone in ruby
+    @lifespan = 100.0
+    @img = img_
+  end
+  
+  def run
+    update
+    render
+  end
+  
+  # Method to update location
+  def update
+    @vel += acc
+    @loc += vel
+    @lifespan -= 1.0
+  end
+  
+  # Method to display
+  def render 
+    image_mode(CENTER)
+    tint(255,lifespan)
+    image(img, loc.x, loc.y)
+  end
+  
+  # Method to add a force vector to all particles currently in the system
+  def apply_force(f) 
+    @acc += f
+  end
+  
+end
+
+

data/samples/processing_app/library/vecmath/vector_math.rb

@@ -0,0 +1,39 @@
+#
+# Vector 
+# by Daniel Shiffman.  
+# PVector was used in the original (instead of Vec2D)
+# Demonstration some basic vector math: subtraction, normalization, scaling
+# Normalizing a vector sets its length to 1.
+#
+load_library :vecmath
+
+def setup
+  size(640,360)
+  smooth
+end
+
+def draw
+  background(0)
+  
+  # A vector that points to the mouse location
+  mouse = Vec2D.new(mouse_x, mouse_y)
+  # A vector that points to the center of the window
+  center = Vec2D.new(width/2, height/2)
+  # Subtract center from mouse which results in a vector that points from center to mouse
+  mouse -= center
+  
+  # Normalize the vector
+  mouse.normalize!
+  
+  # Multiply its length by 150 (Scaling its length)
+  mouse *= 150
+
+  translate(width/2,height/2)
+  # Draw the resulting vector
+  stroke(255)
+  stroke_weight(4)
+  line(0, 0, mouse.x, mouse.y)
+  
+end
+
+

data/samples/processing_app/library/vecmath/wiggle_pshape.rb

@@ -0,0 +1,22 @@
+#
+# WigglePShape. 
+# 
+# How to move the individual vertices of a PShape
+#
+load_library :vecmath # NB: load vecmath library here
+load_library :wiggler
+
+attr_reader :wiggler
+
+def setup
+  size(640, 360, P2D)
+  @wiggler = Wiggler.new width, height
+end
+
+def draw
+  background(255)
+  wiggler.display
+  wiggler.wiggle
+end
+
+

data/samples/processing_app/topics/advanced_data/README

@@ -0,0 +1 @@
+Some sketches in this folder may need to be run with the "--nojruby" flag. eg threads_two.rb, and word_frequency.rb the load_json.rb relies json or json-ruby gem.

data/samples/processing_app/topics/advanced_data/counting_words.rb

@@ -0,0 +1,79 @@
+class Word
+  # A helper to keep track of word frequency.
+  attr_accessor :word
+  attr_reader :count
+  def initialize word
+    @word = word
+    @count = 1
+  end
+
+  def increment
+    @count += 1
+  end
+end
+
+################################
+# This sketch is translated from a vanilla processing sketch by Daniel Schiffman
+# that was designed to demonstrate the use IntHash class in vanilla processing.
+# Similar results can easily be obtained using more idiomatic ruby. Here IntHash 
+# has been replaced by a String => Word hash (as used in a Schiffman prototype). 
+# Read about concordance here:-
+# http://en.wikipedia.org/wiki/Concordance_(publishing)
+################################
+
+attr_reader :concordance, :lines, :tokens, :counter
+
+def setup
+  size 640, 360
+  @counter = 0
+  @concordance = {}
+  # Open a file, read its contents, and 'scan' for words using a regex.
+  # Include words with apostrophe eg Harker's 
+  @tokens = File.read(data_path("dracula.txt")).scan(/[\w'-]+/)
+  text_font(create_font("Georgia", 24))
+end
+
+def draw
+  background 51
+  fill 255
+  s = (tokens[counter] == "I")? tokens[counter] : tokens[counter].downcase
+  @counter = (counter + 1) % tokens.length
+  if (concordance.has_key?(s))
+    # Get the word object and increase the count
+    # We access objects from a Hash via its key, the String
+    w = concordance[s]
+    w.increment    # increment word count
+  else
+    # Otherwise make a new Word instance and add it to 
+    # the Hash using the word String as the key
+    concordance[s] = Word.new(s)
+  end
+
+  # x and y will be used to locate each word
+  x = 0
+  y = height - 10
+
+  # Look at each word
+  concordance.values.each do |w|
+    # Only display words that appear 3 times
+    if (w.count > 3)  # access word count
+      # The size is the count
+      fsize = constrain(w.count, 0, 100)
+      text_size(fsize)
+      text(w.word, x, y)
+      # Move along the x-axis
+      x += text_width(w.word) + 1
+    end
+
+    # If x gets to the end, move y
+    # If y == 0 we are done
+    if (y == 0)
+      no_loop
+    else
+      if (x > width)
+        x = 0
+        y = (y < 0)? 0 : y - 100
+      end
+    end
+  end
+end