ruby-processing 1.0.11 → 2.4.1

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

@@ -0,0 +1,89 @@
+######################################
+# Yet another examples of reading and
+# writing to some form of markup,
+# appropriately yaml.
+# by Martin Prout after Dan Shiffman
+# ###################################
+load_library :bubble
+
+attr_reader :bubble_data
+
+def setup()
+  size(640, 360)
+  # load data from file
+  @bubble_data = BubbleData.new "bubbles"
+  bubble_data.load_data "data/data.yml"
+end
+
+def draw
+  background 255
+  bubble_data.display mouse_x, mouse_y
+end
+
+def mouse_pressed
+  # create a new bubble instance, where mouse was clicked
+  @bubble_data.create_new_bubble(mouse_x, mouse_y)
+end
+
+class BubbleData 
+  include Enumerable
+  
+  MAX_BUBBLE = 10
+  
+  attr_reader :key, :path, :bubbles
+  def initialize key
+    @key = key
+    @bubbles = []
+  end
+  
+  def each &block
+    bubbles.each &block
+  end  
+  
+  def create_new_bubble x, y
+    self.add Bubble.new(x, y, rand(40 .. 80), "new label")    
+    save_data 
+    load_data path
+  end
+  
+  def display x, y
+    self.each do |bubble|
+      bubble.display
+      bubble.rollover(x, y)
+    end
+  end
+  
+  # @param path to yaml file
+  
+  def load_data path
+    @path = path
+    yaml = Psych.load_file("data/data.yml")
+    data = yaml[key]
+    bubbles.clear
+    # iterate the bubble_data array, and create an array of bubbles
+    data.each do |point|
+      self.add Bubble.new(
+        point["position"]["x"],
+        point["position"]["y"],
+        point["diameter"],
+        point["label"])
+    end
+  end
+  
+  
+  def add bubble
+    bubbles << bubble
+    bubbles.shift if bubbles.size > MAX_BUBBLE
+  end 
+  
+  private   
+  
+  def save_data
+    hash = { key => self.map{ |point| point.to_hash } }
+    yaml = hash.to_yaml
+    # overwite existing 'data.yaml' 
+    open("data/data.yml", 'w:UTF-8') {|f| f.write(yaml) }
+  end
+  
+end
+

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

@@ -0,0 +1,47 @@
+#
+# Regular Expression example
+# by Martin Prout.  
+# 
+# This uses ruby scan
+#
+# Here we'll load the raw HTML from a URL and search for web-links
+#
+
+attr_reader :links, :url
+
+def setup
+  size(360, 480)
+  @url = "http://processing.org"
+  # Load the links
+  @links = load_links(url)
+  links.uniq! # get rid of the duplicates
+  text_font(create_font("Georgia", 16))
+end
+
+def draw
+  background(0)
+  # Display the bare links
+  fill(0, 255, 255)
+  links.each_with_index do |link, i|
+    text(link, 10, 20 + i * 20)
+  end
+end
+
+def load_links(s)
+  # Load the raw HTML
+  lines = load_strings(s)
+  # Put it in one big string
+  all_txt = lines.join('\n')
+  all_txt.scan(/
+        https?:\/\/
+        \w+
+        (?: [.-]\w+ )*
+        (?:
+            \/
+            [0-9]{1,5}
+            \?
+            [\w=]*
+        )?
+    /ix)
+end
+

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

@@ -0,0 +1,96 @@
+# 
+# Thread function example
+# by Martin Prout (after a Dan Schiffman vanilla processing version).  
+# 
+# This example demonstrates how to use Thread.new to spawn
+# a process that happens outside of the main animation thread.
+#
+# When Thread.new is called, the draw() loop will continue while
+# the code inside the block passed to the thread will operate
+# in the background.
+#
+# For more about threads, see: http://wiki.processing.org/w/Threading
+#
+
+# This sketch will load data from all of these URLs in a separate thread
+
+URLS = [
+"http://processing.org", 
+"http://www.processing.org/exhibition/", 
+"http://www.processing.org/reference/", 
+"http://www.processing.org/reference/libraries", 
+"http://www.processing.org/reference/tools",   
+"http://www.processing.org/reference/environment",   
+"http://www.processing.org/learning/", 
+"http://www.processing.org/learning/basics/", 
+"http://www.processing.org/learning/topics/", 
+"http://www.processing.org/learning/gettingstarted/",
+"http://www.processing.org/download/", 
+"http://www.processing.org/shop/", 
+"http://www.processing.org/about/"
+]
+
+
+attr_reader :finished, :percent
+
+def setup
+  size(640, 360)
+  # Spawn the thread!
+  # This will keep track of whether the thread is finished
+  load_data
+end
+
+def draw
+  background(0)
+  
+  # If we're not finished draw a "loading bar"
+  # This is so that we can see the progress of the thread
+  # This would not be necessary in a sketch where you wanted to load data in the background
+  # and hide this from the user, allowing the draw() loop to simply continue
+  if (!finished)
+    stroke(255)
+    no_fill()
+    rect(width/2-150, height/2, 300, 10)
+    fill(255)
+    # The size of the rectangle is mapped to the percentage completed
+    w = map(percent, 0, 1, 0, 300)
+    rect(width/2-150, height/2, w, 10)
+    text_size(16)
+    text_align(CENTER)
+    fill(255)
+    text("Loading", width/2, height/2+30)
+  else
+    # The thread is complete!
+    text_align(CENTER)
+    text_size(24)
+    fill(255)
+    text("Finished loading. Click the mouse to load again.", width/2, height/2)
+  end
+end
+
+def load_data
+  Thread.new { 
+    # The thread is not completed
+    @finished = false
+    @percent = 0
+    # Reset the data to empty
+    @all_data = ""
+    URLS.each_with_index do |url, i|
+      lines = load_strings(url)
+      all_txt = lines.join(' ')
+      words = all_txt.scan(/\w+/)
+      words.each do |word|
+        word.strip! 
+        word.downcase!
+      end
+      words.sort!
+      @all_data << words.join(' ')
+      @percent = i.to_f / URLS.length
+    end
+    @finished = true
+  }
+end
+
+def mouse_pressed   # guard against calling load_data when running
+  load_data unless !finished 
+end

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

@@ -0,0 +1,52 @@
+##################
+# From an original sketch on openprocessing by Chinchbug
+# http://www.openprocessing.org/sketch/29577
+##################
+FRAMES = 116
+
+attr_reader :ang, :curr, :frames, :done_loading
+
+def setup
+  size(305, 395)
+  background(0)
+  no_stroke
+  text_align(CENTER, CENTER)
+  @frames = []
+  @done_loading = false
+  @curr = 0
+  thread do    # supply a block in ruby-processing rather than use reflection
+    FRAMES.times do |i|
+      frames << load_image("a#{nf(i, 3)} copy.jpg")
+      @curr = i
+      delay(75) #just slows down this thread - the main draw cycle is unaffected...
+    end
+    @curr = 0
+    frame_rate(30)
+    @done_loading = true
+  end
+  @ang = 0.0
+end
+
+
+def draw
+  if (done_loading)
+    background(0)    
+    image(frames[curr], 0, 0)
+    @curr += 1
+    if (curr > 115)
+      @curr = 0
+    end
+  else
+    @ang += 0.1
+    x = cos(ang) * 8
+    y = sin(ang) * 8
+    fill(0, 8)
+    rect(50, 150, 100, 100)
+    fill(32, 32, 255)
+    ellipse(x + 100, y + 200, 8, 8)
+    fill(0)
+    rect(120, 150, 170, 100)
+    fill(128)
+    text("loading frames (#{curr} of 115)", 200, 200)
+  end
+end

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

@@ -0,0 +1,78 @@
+#
+# After a HashMap example
+# by Daniel Shiffman.  
+# 
+# This example demonstrates how to use a Hash to store 
+# a collection of objects referenced by a key. This is much like an array, 
+# only instead of accessing elements with a numeric index, we use a String.
+# If you are familiar with associative arrays from other languages,
+# this is the same idea.
+#
+# The Processing classes IntHash, FloatHash, and StringHash offer a simple
+# way of pairing Strings with numbers or other Strings. But are probably of 
+# less interest to rubyists.
+#
+# In this example, words that appear in one book (Dracula) are colored white 
+# whilst words in the other book (Frankenstein) are colored black.
+#
+load_library 'word'
+
+DRACULA = "dracula.txt"
+FRANKENSTEIN = "frankenstein.txt"
+
+attr_accessor :words
+
+def setup
+  size(640, 360)
+
+  # Create the HashMap
+  @words = {}
+  # Load two files
+  load_file(DRACULA)
+  load_file(FRANKENSTEIN)
+  # Create the font
+  text_font(create_font("Georgia", 24))
+end
+
+def draw
+  background(126)
+  # Show words
+  words.values.each do |w|
+    if w.qualify?
+      w.display
+      w.move
+    end
+  end
+end
+
+# Load a file
+def load_file(filename)
+  tokens = File.open(data_path(filename), "r"){|file| file.read.scan(/[\w'-]+/)}
+  tokens.each do |s|
+    s = s.downcase
+    # Is the word in the HashMap
+    if (words.has_key?(s))
+      # Get the word object and increase the count
+      # We access objects from a Hash via its key, the String
+      w = words[s]
+      # Which book am I loading?
+      if (filename == DRACULA)
+        w.increment_dracula
+      elsif (filename == FRANKENSTEIN)
+        w.increment_franken
+      end
+    else
+      # Otherwise make a new word
+      w = Word.new(s)
+      # And add entry to the Hash 
+      # The key for us is the String and the value is the Word object
+      words[s] = w
+      if (filename == DRACULA)
+        w.increment_dracula
+      elsif (filename == FRANKENSTEIN)
+        w.increment_franken
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+#
+# Loading XML Data
+# by Daniel Shiffman.  
+#
+# This example demonstrates how to use loadXML()
+# to retrieve data from an XML document via a URL
+#
+
+attr_reader :zip, :weather, :temperature
+
+def setup
+  size(600, 360)
+  @zip = 10003
+  font = create_font("Merriweather-Light.ttf", 28)
+  text_font(font)
+
+  # The URL for the XML document
+  url = "http://xml.weather.yahoo.com/forecastrss?p=#{zip}"
+  
+  # Load the XML document
+  xml = loadXML(url)
+
+  # Grab the element we want
+  forecast = xml.get_child("channel").get_child("item").get_child("yweather:forecast")
+  
+  # Get the attributes we want
+  @temperature = forecast.get_int("high")
+  @weather = forecast.get_string("text")
+end
+
+def draw
+  background(255)
+  fill(0)
+  # Display all the stuff we want to display
+  text("Zip code: #{zip}", width*0.15, height*0.33)
+  text("Today's high: #{temperature}", width*0.15, height*0.5)
+  text("Forecast: #{weather}", width*0.15, height*0.66)
+end

data/samples/processing_app/topics/animation/README.txt

@@ -0,0 +1 @@
+Sketches that load images seem to need --nojruby flag (weird).

data/samples/processing_app/topics/animation/animated_sprite.rb

@@ -0,0 +1,58 @@
+#
+# Animated Sprite (Shifty + Teddy)
+# by James Paterson, rubified by Martin Prout. 
+# 
+# Hold down the mouse button to change animations.
+# Demonstrates loading, displaying, and animating GIF images.
+# It would be easy to write a program to display 
+# animated GIFs, but would not allow as much control over 
+# the display sequence and rate of display. 
+#
+
+DRAG = 30.0
+attr_reader :xpos, :ypos, :animation1, :animation2
+
+def setup
+  size(640, 360)
+  background(255, 204, 0)
+  frameRate(24)
+  @animation1 = Animation.new("PT_Shifty_", 38)
+  @animation2 = Animation.new("PT_Teddy_", 60)
+  @ypos = height * 0.25
+  @xpos = 0
+end
+
+def draw 
+  dx = mouse_x - xpos
+  @xpos = xpos + dx/DRAG
+  # Display the sprite at the position xpos, ypos
+  if (mouse_pressed?)
+    background(153, 153, 0)
+    animation1.display(xpos-animation1.get_width/2, ypos)
+  else
+    background(255, 204, 0)
+    animation2.display(xpos-animation2.get_width/2, ypos)
+  end
+end
+
+class Animation < Array
+  attr_reader :images, :image_count, :frame
+  
+  def initialize(image_prefix, count)
+    @image_count = count
+    @frame = 0
+    image_count.times do |i|
+      # using ruby string format in preference to processing nf function
+      self << load_image("%s%04d%s" %  [image_prefix, i, ".gif"])
+    end
+  end
+
+  def display(xpos, ypos)
+    @frame = (frame + 1) % image_count
+    image(self[frame], xpos, ypos)
+  end
+  
+  def get_width
+    self[0].width
+  end
+end