ruby-processing 2.6.3 → 2.6.4

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

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

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

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

@@ -1,52 +0,0 @@
-##################
-# 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#{i.to_s.rjust(3, '0')} copy.jpg") # ruby syntax
-      @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

@@ -1,80 +0,0 @@
-#
-# 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'
-DRAC = /#{DRACULA}/
-FRANK = /#{FRANKENSTEIN}/
-
-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.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 DRAC =~ filename
-        w.increment_dracula
-      elsif FRANK =~ filename
-        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 DRAC =~ filename
-        w.increment_dracula
-      elsif FRANK =~ filename
-        w.increment_franken
-      end
-    end
-  end
-end
-

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

@@ -1,39 +0,0 @@
-#
-# 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('Times Roman', 28)
-  # 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

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

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

@@ -1,57 +0,0 @@
-#
-# 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)
-  frame_rate(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 
-  attr_reader :images, :image_count, :frame
-  
-  def initialize(image_prefix, count)
-    @image_count = count
-    @frame = 0
-    @images = (0 ... image_count).map { 
-    |i| load_image(format('%s%04d%s', image_prefix, i, '.gif')) 
-    }
-  end
-
-  def display(xpos, ypos)
-    @frame = (frame + 1) % image_count
-    image(images[frame], xpos, ypos)
-  end
-  
-  def get_width
-    images[0].width
-  end
-end