ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/advanced_data/data/struct_data.yml

@@ -0,0 +1,22 @@
+---
+:bubbles:
+- !ruby/struct:BubbleStruct
+  x: 160
+  y: 103
+  diameter: 43.2
+  label: Happy
+- !ruby/struct:BubbleStruct
+  x: 372
+  y: 137
+  diameter: 52.4
+  label: Sad
+- !ruby/struct:BubbleStruct
+  x: 273
+  y: 235
+  diameter: 61.0
+  label: Joyous
+- !ruby/struct:BubbleStruct
+  x: 121
+  y: 179
+  diameter: 44.7
+  label: Melancholy

data/samples/processing_app/topics/advanced_data/library/bubble/bubble.rb

@@ -0,0 +1,45 @@
+# The bubble library, include BubbleStruct
+
+class Bubble
+  include Processing::Proxy
+  
+  attr_reader :x, :y, :diameter, :name, :over
+  
+  # Create  the Bubble
+  def initialize(x, y, diameter, name)
+    @x = x
+    @y = y
+    @diameter = diameter
+    @name = name
+    @over = false
+  end
+  
+  # Checking if mouse is over the Bubble
+  def rollover(px, py)
+    d = dist(px,py,x,y)
+    @over = (d < diameter/2)? true : false
+  end
+  
+  # Display the Bubble
+  def display
+    stroke(0)
+    stroke_weight(2)
+    noFill
+    ellipse(x,y,diameter,diameter)
+    if (over)
+      fill(0)
+      text_align(CENTER)
+      text(name, x, y + diameter/2 + 20)
+    end
+  end
+
+  def to_hash
+    {"position" => {"x" => x, "y" => y}, "diameter" => diameter, "label" => name}  
+  end
+
+  def to_struct
+    BubbleStruct.new(x, y, diameter, name)	  
+  end
+end
+
+BubbleStruct = Struct.new(:x, :y, :diameter, :label)

data/samples/processing_app/topics/advanced_data/library/word/word.rb

@@ -0,0 +1,64 @@
+#######
+# word.rb
+# the word class stores data about words (text, source, frequency)
+# thanks to processing mixin words are rendered according to
+# source and frequency
+########
+class Word
+  include Processing::Proxy
+  # Store a count for occurences in two different books
+  attr_reader :count_dracula, :count_franken, :total_count, :word, :position, :width, :height, :speed
+
+  def initialize(s)
+    @width, @height = $app.width, $app.height
+    @count_dracula, @count_franken, @total_count = 0, 0, 0
+    @position = [rand(width), rand(-height .. height*2)]
+    @word = s
+  end
+
+  # We will display a word if it appears at least 5 times
+  # and only in one of the books
+  def qualify?
+    return ((count_dracula == total_count || count_franken == total_count) && total_count > 5)
+  end
+
+  # Increment the count for Dracula
+  def increment_dracula
+    @count_dracula += 1
+    @total_count += 1
+  end
+
+
+  # Increment the count for Frankenstein
+  def increment_franken
+    @count_franken += 1
+    @total_count += 1
+  end
+
+  # The more often it appears, the faster it falls
+  def move
+    @speed = map(total_count, 5, 25, 0.1, 0.4).to_f
+    @speed = constrain(speed, 0, 10.0)
+    @position[Y] += speed
+
+    if (position[Y] > height*2)
+      @position[Y] = -height
+    end
+  end
+
+
+  # Depending on which book it gets a color
+  def display
+    if (count_dracula > 0)
+      fill(255)
+    elsif (count_franken > 0)
+      fill(0)
+    end
+    # Its size is also tied to number of occurences
+    fs = map(total_count,5,25,2,24.0).to_f
+    fs = constrain(fs, 2, 48)
+    text_size(fs)
+    text_align(CENTER)
+    text(word, position[X], position[Y])
+  end
+end

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

@@ -0,0 +1,114 @@
+#
+# Loading XML Data
+# by Daniel Shiffman.  
+# 
+# This example demonstrates how to use loadXML
+# to retrieve data from an XML file and make objects 
+# from that data.
+#
+# Here is what the XML looks like:
+#
+# <?xml version="1.0"?>
+# <bubbles>
+#  <bubble>
+#    <position x="160" y="103"/>
+#    <diameter>43.19838</diameter>
+#    <label>Happy</label>
+#  </bubble>
+#  <bubble>
+#    <position x="372" y="137"/>
+#    <diameter>52.42526</diameter>
+#    <label>Sad</label>
+#  </bubble>
+# </bubbles>
+#
+load_library "bubble"
+ 
+attr_reader :bubbles, :xml
+
+def setup
+  size(640, 360)
+  load_data
+end
+
+def draw
+  background(255)
+  # Display all bubbles
+  bubbles.each do |b|
+    b.display
+    b.rollover(mouseX, mouseY)
+  end
+
+  text_align(LEFT)
+  fill(0)
+  text("Click to add bubbles.", 10, height - 10)
+end
+
+def load_data
+  # Load XML file
+  @xml = loadXML("data.xml")
+  # Get all the child nodes named "bubble"
+  children = xml.get_children("bubble")
+
+  # The size of the array of Bubble objects is determined by the total XML elements named "bubble"
+  @bubbles = []
+
+  children.each do |element|    
+    # The position element has two attributes: x and y
+    position_element = element.get_child("position")
+    # Note how with attributes we can get an integer or directly
+    x, y = position_element.get_int("x"), position_element.get_int("y")
+    
+    # The diameter is the content of the child named "diamater"
+    diameter_element = element.get_child("diameter")
+    # Note how with the content of an XML node, we retrieve as a String and then convert
+    diameter = (diameter_element.get_content).to_f
+
+    # The label is the content of the child named "label"
+    label_element = element.get_child("label")
+    label = label_element.get_content
+
+    # Make a Bubble object out of the data read
+    bubbles << Bubble.new(x, y, diameter, label)
+  end 
+
+end
+
+# Still need to work on adding and deleting
+
+def mouse_pressed
+  
+  # Create a new XML bubble element
+  bubble = xml.add_child("bubble")
+  
+  # Set the poisition element
+  position = bubble.add_child("position")
+  # Here we can set attributes as integers directly
+  position.set_int("x",mouseX)
+  position.set_int("y",mouseY)
+  
+  # Set the diameter element
+  diameter = bubble.add_child("diameter")
+  # Here for a node's content, we have to convert to a String
+  diameter.set_content(rand(40.0 .. 80).to_s)
+  
+  # Set a label
+  label = bubble.add_child("label")
+  label.set_content("New label")
+  
+  
+  # Here we are removing the oldest bubble if there are more than 10
+  children = xml.get_children("bubble")
+    # If the XML file has more than 10 bubble elements
+  if (children.length > 10)
+    # Delete the first one
+    xml.remove_child(children[0])
+  end
+  
+  # Save a new XML file
+  saveXML(xml,"data/data.xml")
+  
+  # reload the new data 
+  load_data
+end
+

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

@@ -0,0 +1,93 @@
+# This example demonstrates how easily "sketch data" can be retrieved from a json file
+# in ruby-processing. Note this sketch re-uses the Bubble class from the bubble library. 
+# The BubbleData class, can load, store and create instances of Bubble (and request them
+# to display and/or show their label, when 'mouse over').
+# @author Martin Prout, after Daniel Shiffmans version for processing
+# 
+require "json"
+
+load_library :bubble
+
+attr_reader :bubble_data
+
+def setup()
+  size(640, 360)
+  # initialize bubble_data with 'key' and read data from 'file path'
+  @bubble_data = BubbleData.new "bubbles"
+  bubble_data.load_data "data/data.json"
+end
+
+def draw
+  background 255
+  # draw the bubbles and display a bubbles label whilst mouse over
+  bubble_data.display mouse_x, mouse_y
+end
+
+def mouse_pressed
+  # create a new instance of bubble, 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
+  
+  # @param key String for top level hash
+  
+  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 json file
+  
+  def load_data path
+    @path = path
+    source_string = open(path, "r"){ |file| file.read }
+    data = JSON.parse(source_string)[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 } }
+    json = JSON.pretty_generate(hash)      # generate pretty output
+    open(path, 'w') { |f| f.write(json) }
+  end
+  
+end
+

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

@@ -0,0 +1,85 @@
+######################################
+# Yet another examples of reading and
+# writing to some form of markup,
+# appropriately yaml using ruby structs 
+# by Martin Prout after Dan Shiffman
+####################################
+load_library :bubble
+
+attr_reader :bubble_data
+
+
+def setup()
+  size(640, 360)
+  @bubble_data = BubbleData.new :bubbles
+  bubble_data.load_data "data/struct_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 :path, :bubble_array
+  def initialize key
+    @bubble_array = []
+    @key = key
+  end
+  
+  def each &block
+    bubble_array.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 add bubble
+    bubble_array << bubble
+    bubble_array.shift if bubble_array.size > MAX_BUBBLE
+  end 
+ 
+   def load_data path
+     @path = path
+     yaml = Psych.load_file(path)
+     # we are storing the data as an array of RubyStruct, in a hash with
+     # a symbol as the key (the latter only to show we can, it makes no sense)
+     data = yaml[@key]      
+     bubble_array.clear
+     # iterate the bubble_data array, and populate the array of bubbles
+     data.each do |pt|
+       self.add Bubble.new(pt.x, pt.y, pt.diameter, pt.label)
+     end
+  end
+
+  def display x, y
+    self.each do |bubble|
+      bubble.display
+      bubble.rollover(x, y)
+    end
+  end  
+
+  private   
+  
+  def save_data
+    hash = { @key =>  self.map{ |point| point.to_struct } }
+    yaml = hash.to_yaml
+    # overwite existing 'struct_data.yaml' 
+    open(path, 'w:UTF-8') {|f| f.write(yaml) }
+  end
+
+end

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

@@ -0,0 +1,85 @@
+#
+# Loading Tabular Data
+# after Daniel Shiffman, by Martin Prout.  
+# 
+# This example demonstrates how to use CSV
+# to retrieve data from a CSV file and make objects 
+# from that data.
+#
+# Here is what the CSV looks like:
+#
+#   x,y,diameter,name
+#   160,103,43.19838,Happy
+#   372,137,52.42526,Sad
+#   273,235,61.14072,Joyous
+#   121,179,44.758068,Melancholy
+#
+require 'csv'
+
+load_library "bubble"
+
+attr_reader :bubbles, :data
+
+def setup
+  size(640, 360)
+  load_data
+end
+
+def draw
+  background(255)
+  # Display all bubbles
+  bubbles.each do |b|
+    b.display
+    b.rollover(mouse_x, mouse_y)
+  end
+  
+  text_align(LEFT)
+  fill(0)
+  text("Click to add bubbles.", 10, height - 10)
+end
+
+def load_data
+  # Load CSV file into an Array of Hash objects
+  # :headers option indicates the file has a header row
+  @data = CSV.read("data/data.csv", :headers => true).map{|row| row.to_hash}
+  
+  # The size of the array of Bubble objects is determined by the total number of "rows" in the CSV
+  @bubbles = [] 
+  
+  data.each do |row|
+    # You access the values via their column name (set by using headers option above)
+    x = row["x"].to_f
+    y = row["y"].to_f
+    d = row["diameter"].to_f
+    n = row["name"] 
+    # Make a Bubble object out of the data read
+    bubbles << Bubble.new(x, y, d, n)
+  end  
+  
+end
+
+def mouse_pressed
+  # Create a new "row" hash
+  row = {"x" => mouse_x.to_s, "y" => mouse_y.to_s, "diameter" => random(40, 80).to_s, "name" => "Blah"}
+  # add the row to the existing data array
+  data << row
+  
+  # If the table has more than 10 rows
+  if (data.size > 10)
+    # Delete the oldest row
+    data.shift 
+  end
+  # read column names from data, and generate csv "string" that can be written to file  
+  column_names = data.first.keys
+  s = CSV.generate do |csv|
+    csv << column_names
+    data.each do |row|
+      csv << row.values
+    end
+  end
+  # Writing the csv data back to the same file, (also specify UTF-8 format)
+  File.open("data/data.csv", 'w:UTF-8') { |file| file.write(s)}  
+  # And reloading it
+  load_data
+end
+