ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/library/minim/frequency_modulation.rb

@@ -0,0 +1,64 @@
+
+# frequencyModulation
+# <p>
+# A simple example for doing FM (frequency modulation) using two Oscils. 
+# Use the mouse to control the speed and range of the frequency modulation.
+# <p>  
+# Author: Damien Di Fede 
+
+load_library 'minim'
+include_package 'ddf.minim'
+include_package 'ddf.minim.ugens'
+
+attr_reader :minim, :out, :fm, :wave
+
+def setup
+  size(512, 200, P3D)  
+  @minim = Minim.new(self)
+  
+  # use the getLineOut method of the Minim object to get an AudioOutput object
+  @out = minim.get_line_out()
+  # make the Oscil we will hear.
+  # arguments are frequency, amplitude, and waveform
+  @wave = Oscil.new( 200, 0.8, Waves::TRIANGLE )
+  
+  # make the Oscil we will use to modulate the frequency of wave.
+  # the frequency of this Oscil will determine how quickly the
+  # frequency of wave changes and the amplitude determines how much.
+  # since we are using the output of fm directly to set the frequency 
+  # of wave, you can think of the amplitude as being expressed in Hz.
+  @fm = Oscil.new( 10, 2, Waves::SINE )
+  
+  # set the offset of fm so that it generates values centered around 200 Hz
+  fm.offset.set_last_value( 200 )
+  # patch it to the frequency of wave so it controls it
+  fm.patch( wave.frequency )
+  # and patch wave to the output
+  wave.patch( out )
+  # patch the Oscil to the output
+  wave.patch(out)
+end
+
+def draw
+  background(0)
+  stroke(255)  
+  # draw the waveforms
+  (0 ... out.buffer_size - 1).step do |i|
+    # find the x position of each buffer value  
+    x1  =  map( i, 0, out.buffer_size(), 0, width )
+    x2  =  map( i+1, 0, out.buffer_size(), 0, width )
+    # draw a line from one buffer position to the next for both channels
+    line( x1, 50 + out.left.get(i)*50, x2, 50 + out.left.get(i+1)*50)
+    line( x1, 150 + out.right.get(i)*50, x2, 150 + out.right.get(i+1)*50)
+  end
+end
+
+
+# we can change the parameters of the frequency modulation Oscil
+# in real-time using the mouse.
+def mouse_moved
+  modulate_amount = map( mouse_y, 0, height, 220, 1 )
+  modulate_frequency = map( mouse_x, 0, width, 0.1, 100 )  
+  fm.frequency.set_last_value( modulate_frequency )
+  fm.amplitude.set_last_value( modulate_amount )
+end

data/samples/processing_app/library/minim/sequence_sound.rb

@@ -0,0 +1,59 @@
+# This sketch demonstrates how to create synthesized sound with Minim using an <code>AudioOutput</code> and the
+# default instrument built into an <code>AudioOutput</code>. By using the <code>play_note</code> method you can 
+# schedule notes to played at some point in the future, essentially allowing to you create musical scores with 
+# code. Because they are constructed with code, they can be either deterministic or different every time. This
+# sketch creates a deterministic score, meaning it is the same every time you run the sketch. It also demonstrates 
+# a couple different versions of the <code>play_note</code> method.
+# <p>
+# For more complex examples of using <code>play_note</code> check out algorithmicCompExample and compositionExample
+# in the Synthesis folder.
+#
+load_library 'minim'
+include_package 'ddf.minim'
+include_package 'ddf.minim.ugens'
+
+attr_reader :minim, :out
+
+def setup
+  size(512, 200, P3D)  
+  @minim = Minim.new(self)
+  
+  # use the getLineOut method of the Minim object to get an AudioOutput object
+  @out = minim.get_line_out()
+  
+  # given start time, duration, and frequency
+  out.play_note( 0.0, 0.9, 97.99 )
+  out.play_note( 1.0, 0.9, 123.47 )
+  
+  # given start time, duration, and note name  
+  out.play_note( 2.0, 2.9, "C3" )
+  out.play_note( 3.0, 1.9, "E3" )
+  out.play_note( 4.0, 0.9, "G3" )
+    
+  # given start time and note name or frequency
+  # (duration defaults to 1.0)
+  out.play_note( 5.0, "" )
+  out.play_note( 6.0, 329.63)
+  out.play_note( 7.0, "G4" )
+  
+  # the note offset is simply added into the start time of 
+  # every subsequenct call to play_note. It's expressed in beats, 
+  # but since the default tempo of an AudioOuput is 60 beats per minute,
+  # this particular call translates to 8.1 seconds, as you might expect.
+  out.setNoteOffset( 8.1 )
+  
+  # because only given a note name or frequency
+  # starttime defaults to 0.0 and duration defaults to 1.0
+  out.play_note( "G5" )
+  out.play_note( 987.77 )
+end
+
+def draw
+  background(0)
+  stroke(255)  
+  # draw the waveforms
+  (0 ... out.buffer_size - 1).step do |i|
+    line( i, 50 + out.left.get(i)*50, i+1, 50 + out.left.get(i+1)*50 )
+    line( i, 150 + out.right.get(i)*50, i+1, 150 + out.right.get(i+1)*50 )
+  end
+end

data/samples/processing_app/library/minim/synthesize_sound.rb

@@ -0,0 +1,35 @@
+# This sketch demonstrates how to create synthesized sound with Minim 
+# using an AudioOutput and an Oscil. An Oscil is a UGen object, 
+# one of many different types included with Minim. For many more examples 
+# of UGens included with Minim, have a look in the Synthesis 
+# folder of the Minim examples.
+#
+
+load_library 'minim'
+include_package 'ddf.minim'
+include_package 'ddf.minim.ugens'
+
+attr_reader :minim, :out, :wave
+
+def setup
+  size(512, 200, P3D)  
+  @minim = Minim.new(self)
+  
+  # use the getLineOut method of the Minim object to get an AudioOutput object
+  @out = minim.get_line_out()
+  
+  # create a sine wave Oscil, set to 440 Hz, at 0.5 amplitude
+  @wave = Oscil.new( 440, 0.5, Waves::SINE )
+  # patch the Oscil to the output
+  wave.patch(out)
+end
+
+def draw
+  background(0)
+  stroke(255)  
+  # draw the waveforms
+  (0 ... out.buffer_size - 1).step do |i|
+    line( i, 50 + out.left.get(i)*50, i+1, 50 + out.left.get(i+1)*50 )
+    line( i, 150 + out.right.get(i)*50, i+1, 150 + out.right.get(i+1)*50 )
+  end
+end

data/samples/processing_app/library/movie/README

@@ -0,0 +1 @@
+Sketches in this folder may need to be run with the "--nojruby" flag.

data/samples/processing_app/library/movie/loop.rb

@@ -0,0 +1,24 @@
+# Loop. 
+# 
+# Shows how to load and play a QuickTime movie file.  
+#
+#
+
+load_library 'video'
+
+include_package 'processing.video'
+
+attr_reader :movie
+
+def setup
+  size(640, 360)
+  background(0)
+  # Load and play the video in a loop
+  @movie = Movie.new(self, "transit.mov")
+  movie.loop
+end
+
+def draw
+  movie.read if movie.available? 
+  image(movie, 0, 0, width, height)
+end

data/samples/processing_app/library/movie/pixelate.rb

@@ -0,0 +1,50 @@
+#
+# Pixelate  
+# by Hernando Barragan.  
+# 
+# Load a QuickTime file and display the video signal 
+# using rectangles as pixels by reading the values stored 
+# in the current video frame pixels array. 
+#
+
+load_library :video
+include_package 'processing.video'
+
+BLOCK_SIZE = 10
+
+attr_reader :mov, :movie_color, :num_pixels_wide, :num_pixels_high
+
+def setup
+  size(640, 360)
+  no_stroke  
+  @mov = Movie.new(self, "transit.mov")  
+  @num_pixels_wide = width / BLOCK_SIZE
+  @num_pixels_high = height / BLOCK_SIZE
+  @movie_color = [] 
+  puts num_pixels_wide
+  mov.loop
+end
+
+# Display values from movie
+def draw
+  begin 
+    movie_color.clear
+    mov.read
+    mov.load_pixels
+    num_pixels_high.times do |j|
+      num_pixels_wide.times do |i|
+        movie_color << mov.get(i*BLOCK_SIZE, j*BLOCK_SIZE)
+      end
+    end
+  end unless !mov.available? 
+
+  num_pixels_high.times do |j|
+    num_pixels_wide.times do |i|
+      fill(movie_color[j*num_pixels_wide + i])
+      rect(i*BLOCK_SIZE, j*BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE)
+    end
+  end  
+end
+
+
+

data/samples/processing_app/library/movie/reverse.rb

@@ -0,0 +1,47 @@
+#
+# Reverse playback example.
+#
+# The Movie.speed method allows to change the playback speed. 
+# Use negative values for backwards playback. Note that not all 
+# video formats support backwards playback. This depends on the 
+# underlying gstreamer plugins used by gsvideo. For example, the 
+# theora codec does support backward playback, but not so the H264 
+# codec, at least in its current version.
+# 
+#
+load_library :video
+include_package 'processing.video'
+
+attr_reader :mov, :speed_set, :once
+
+def setup
+  size(640, 360)
+  background(0)
+  @speed_set = false
+  @once = true
+  @mov = Movie.new(self, "transit.mkv")
+  mov.play
+end
+
+def draw  
+  begin   # avoids reflection shit
+    mov.read  
+    if (speed_set == true)
+      @speed_set = false
+    end
+  end unless !mov.available?
+  if (speed_set == false && once == true)
+    # Setting the speed should be done only once,
+    # this is the reason for the if statement.
+    @speed_set = true
+    @once = false
+    mov.jump(mov.duration)
+    # -1 means backward playback at normal speed.
+    mov.speed(-1.0)
+    # Setting to play again, since the movie stop
+    # playback once it reached the end.
+    mov.play
+  end
+  image(mov, 0, 0, width, height)
+end   
+

data/samples/processing_app/library/movie/scratch.rb

@@ -0,0 +1,36 @@
+#
+# Scratch 
+# by Andres Colubri. 
+# 
+# Move the cursor horizontally across the screen to set  
+# the position in the movie file.
+#
+load_library :video
+include_package 'processing.video'
+
+attr_reader :mov
+
+def setup
+  size(640, 360)
+  background(0)  
+  @mov = Movie.new(self, "transit.mov")  
+  # Pausing the video at the first frame. 
+  mov.play
+  mov.jump 0
+  mov.pause
+end
+
+def draw
+  begin
+    mov.read
+    # A new time position is calculated using the current mouse location:
+    t = mov.duration * map(mouse_x, 0, width, 0, 1.0)
+    mov.play
+    mov.jump(t)
+    mov.pause 
+  end unless !mov.available?
+  image(mov, 0, 0)
+end
+
+
+

data/samples/processing_app/library/movie/speed.rb

@@ -0,0 +1,33 @@
+#
+# Speed. 
+#
+# Use the Movie.speed method to change
+# the playback speed.
+# 
+#
+
+load_library :video
+include_package 'processing.video'
+
+attr_reader :mov
+
+def setup
+  size(640, 360)
+  background(0)
+  @mov = Movie.new(self, "transit.mov")
+  mov.loop
+end
+
+def draw     
+  image(mov, 0, 0)
+  begin
+    mov.read
+  end unless !mov.available?
+  
+  new_speed = map(mouse_x, 0, width, 0.1, 2)
+  mov.speed(new_speed)
+  
+  fill(255)
+  text("%.2f" % new_speed << "X", 10, 30) 
+end  
+

data/samples/processing_app/library/net/HTTPClient.rb

@@ -0,0 +1,31 @@
+# HTTP Client. 
+# 
+# Starts a network client that connects to a server on port 80,
+# sends an HTTP 1.0 GET request, and prints the results. 
+# Note that this code is not necessary for simple HTTP GET request:
+# Simply calling loadStrings("http://www.processing.org") would do
+# the same thing as (and more efficiently than) this example.
+# This example is for people who might want to do something more 
+# complicated later.
+
+load_library 'net'
+include_package 'processing.net'
+
+attr_reader :client, :data
+
+def setup
+  size(200, 200)
+  background(50)
+  fill(200)
+  @client = Client.new(self, "www.processing.org", 80) # Connect to server on port 80
+  client.write("GET / HTTP/1.0\r\n") # Use the HTTP "GET" command to ask for a Web page
+  client.write("\r\n")
+end
+
+def draw
+  if (client.available() > 0)   # If there's incoming data from the client...
+    data = client.read_string()  # ...then grab it and print it
+    println(data)
+  end
+end
+

data/samples/processing_app/library/pdf/.gitignore

@@ -0,0 +1 @@
+*.pdf

data/samples/processing_app/library/pdf/complex_3D.rb

@@ -0,0 +1,160 @@
+# 
+#  Geometry 
+#  by Marius Watz. 
+#  
+load_library 'pdf'
+include_package 'processing.pdf'
+
+attr_reader :num, :pt, :style, :dosave
+
+def setup
+  size(1024, 768, P3D)  
+  background(255)
+  @dosave = false
+  @num = 150
+  @pt = []
+  @style = []
+  
+  # Set up arc shapes
+  index = 0
+  (0 ... num).each do |i|
+    pt.push(rand(TWO_PI)) # Random X axis rotation
+    pt.push(rand(TWO_PI)) # Random Y axis rotation
+    
+    pt.push(rand(60 .. 80)) # Short to quarter-circle arcs
+    if (rand(100)>90)
+      pt[pt.length - 1] = rand(8 .. 27) * 10
+    end     
+    pt.push(rand(2 .. 50) * 5) # Radius. Space them out nicely
+    
+    pt.push(rand(4 .. 32)) # Width of band
+    if (rand(100) > 90)
+      pt[pt.length - 1] = rand(40 .. 60) # Width of band
+    end
+    
+    pt.push(rand(0.005 .. 0.0334))# Speed of rotation
+    
+    # get colors
+    prob = rand(100)
+    if (prob < 30)
+      style[i*2] = color_blended(rand, 255,0,100, 255,0,0, 210)
+    elsif(prob < 70) 
+      style[i*2] = color_blended(rand, 0,153,255, 170,225,255, 210)
+    elsif(prob<90) 
+      style[i*2] = color_blended(rand, 200,255,0, 150,255,0, 210)
+    else 
+      style[i*2] = color(255,255,255, 220)
+    end
+    
+    if (prob < 50)
+      style[i*2] = color_blended(rand, 200,255,0, 50,120,0, 210)
+    elsif(prob < 90)
+      style[i*2] = color_blended(rand, 255,100,0, 255,255,0, 210)
+    else
+      style[i*2] = color(255, 255, 255, 220)
+      style[i*2+1] = rand(100) % 3
+    end
+  end
+end
+
+def draw 
+  if(dosave) 
+    # set up PGraphicsPDF for use with beginRaw
+    pdf = begin_raw(PDF, "pdf_complex_out.pdf")
+    # set default Illustrator stroke styles and paint background rect.
+    pdf.stroke_join(MITER)
+    pdf.stroke_cap(SQUARE)
+    pdf.fill(0)
+    pdf.no_stroke
+    pdf.rect(0,0, width,height)
+  end
+  background(0)    
+  index = 0
+  translate(width/2, height/2, 0)
+  rotate_x(PI/6)
+  rotate_y(PI/6)    
+  (0 ... num).each do |i|
+    push_matrix        
+    rotate_x(pt[index])
+    rotate_y(pt[index + 1])
+    index += 2
+    if (style[i*2+1] == 0)
+      stroke(style[i*2])
+      no_fill
+      stroke_weight(1)
+      arc_line(0,0, pt[index],pt[index + 1],pt[index + 2])
+      index += 3
+    elsif (style[i*2+1] == 1)
+      fill(style[i*2])
+      no_stroke
+      arc_line_bars(0,0, pt[index],pt[index + 1],pt[index + 2])
+      index += 3
+    else
+      fill(style[i*2])
+      no_stroke      
+      arc(0,0, pt[index],pt[index + 1],pt[index + 2])
+      index += 3
+    end
+    # increase rotation
+    pt[index-5] += pt[index] / 10
+    pt[index-4] += pt[index] / 20
+    index += 1
+    pop_matrix
+  end
+  if (dosave)
+    end_raw
+    @dosave=false
+  end
+end
+
+
+# Get blend of two colors
+def color_blended(fract, r, g, b, r2, g2, b2, a) 
+  r2 = (r2 - r)
+  g2 = (g2 - g)
+  b2 = (b2 - b)
+  return color(r + r2 * fract, g + g2 * fract, b + b2 * fract, a)
+end
+
+
+# Draw arc line
+def arc_line(x, y, deg, rad, w) 
+  a=(deg < 360)? deg : 0
+  numlines = w/2    
+  (0 ... numlines).each do 
+    begin_shape
+    (0 ... a).each do |i|                 
+      vertex(cos(i.radians)*rad+x,sin(i.radians)*rad+y)
+    end
+    end_shape 
+    rad += 2        
+  end
+end
+
+# Draw arc line with bars
+def arc_line_bars(x, y, deg, rad, w) 
+  a=(deg < 360)? deg / 16 : 0   
+  begin_shape(QUADS)
+  (0 ... a).step(4) do |i|
+    vertex(cos(i.radians)*(rad)+x,sin(i.radians)*(rad)+y)
+    vertex(cos(i.radians)*(rad+w)+x,sin(i.radians)*(rad+w)+y)
+    vertex(cos((i + 2).radians)*(rad+w)+x,sin((i + 2).radians)*(rad+w)+y)
+    vertex(cos((i + 2).radians)*(rad)+x,sin((i + 2).radians)*(rad)+y)
+  end
+  end_shape
+end
+  
+# Draw solid arc
+def arc(x,y,deg,rad,w) 
+  a = (deg < 360)? deg : 0
+  begin_shape(QUAD_STRIP)
+  (0 ... a).each do |i|
+    vertex(cos(i.radians)*(rad)+x,sin(i.radians)*(rad)+y)
+    vertex(cos(i.radians)*(rad+w)+x,sin(i.radians)*(rad+w)+y)
+  end
+  end_shape
+end
+
+def mouse_pressed
+  @dosave = true
+end