ruby-processing 1.0.1

data/samples/learning_processing/chapter_15/06_pixels_2d.rb

@@ -0,0 +1,29 @@
+require 'ruby-processing'
+
+class Pixels2dSketch < Processing::App
+
+  def setup
+    # load the pixels array
+    load_pixels
+    # Two loops allow us to visit every column (x) and every row (y).
+    # Loop through every pixel column
+    width.times do |x|
+      # Loop through every pixel row
+      height.times do |y|
+        # Use the formula to find the 1D location
+        # The location in the pixel array is calculated via our formula: 1D pixel location = x + y * width
+        loc = x + y * width
+        # We use the even-or-odd-ness of the column number (x) to determine whether the color should be black or white.
+        pixels[loc] = (x % 2 == 0) ? color(255) : color(0)
+      end
+    end
+    # update the pixels on screen
+    update_pixels
+  end
+
+
+end
+
+Pixels2dSketch.new :title => "Pixels 2d", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/07_image_pixels.rb

@@ -0,0 +1,40 @@
+require 'ruby-processing'
+
+class ImagePixelsSketch < Processing::App
+
+  def setup
+    @image = load_image 'sunflower.jpg'
+  end
+
+  def draw
+    # load the pixels array
+    load_pixels
+    # Two loops allow us to visit every column (x) and every row (y).
+    # Loop through every pixel column
+    width.times do |x|
+      # Loop through every pixel row
+      height.times do |y|
+        # Use the formula to find the 1D location
+        loc = x + y * width # The location in the pixel array is calculated via our formula: 1D pixel location = x + y * width
+
+        # The functions red, green, and blue pull out the three color components from a pixel.
+        r = red(@image.pixels[loc]) 
+        g = green(@image.pixels[loc])
+        b = blue(@image.pixels[loc])
+
+        # Image Processing would go here
+        # If we were to change the RGB values, we would do it here, before setting the pixel in the display window.
+
+        # Set the display pixel to the image pixel
+        pixels[loc] = color(r,g,b)
+      end
+    end
+    # update the pixels on screen
+    update_pixels
+  end
+
+end
+
+ImagePixelsSketch.new :title => "Image Pixels", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/08_image_brightness.rb

@@ -0,0 +1,29 @@
+require 'ruby-processing'
+
+class ImageBrightnessSketch < Processing::App
+
+  def setup
+    @image = load_image 'sunflower.jpg'
+    # Let's grab the red, green and blue component of each pixel of the image to start with.
+    @image_pixels = @image.pixels.map {|p| [red(p), green(p), blue(p)]}
+  end
+
+  def draw
+    # We calculate a multiplier ranging from 0.0 to 8.0 based on mouseX position. 
+    # That multiplier changes the RGB value of each pixel.      
+    adjustment = (mouse_x.to_f / width) * 8.0 
+    load_pixels # load the pixels array
+    
+    # And here's a modified Ruby way to do the Java equivalent
+    pixels.size.times do |i|
+      pixels[i] = color(*@image_pixels[i].map {|rgb| rgb * adjustment })
+    end
+    
+    update_pixels
+  end
+
+end
+
+ImageBrightnessSketch.new :title => "Image Brightness", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/09_flashlight_effect.rb

@@ -0,0 +1,42 @@
+require 'ruby-processing'
+
+class FlashlightEffectSketch < Processing::App
+
+  def setup
+    @image = load_image 'sunflower.jpg'
+    # Let's grab the red, green and blue component of each pixel of the image to start with.
+    @image_pixels = @image.pixels.map {|p| [red(p), green(p), blue(p)]}
+  end
+
+  def draw
+    load_pixels # Load the pixels array
+    # Two loops allow us to visit every column (x) and every row (y).
+    # Loop through every pixel column
+    width.times do |x|
+      # Loop through every pixel row
+      height.times do |y|
+        # Use the formula to find the 1D location
+        loc = x + y * width # The location in the pixel array is calculated via our formula: 1D pixel location = x + y * width
+
+        # Calculate an amount to change brightness
+        # based on proximity to the mouse
+        distance = dist(x, y, mouseX, mouseY)
+
+        # The closer the pixel is to the mouse, the lower the value of "distance" 
+        # We want closer pixels to be brighter, however, so we invert the value with the formula: adjustment = (50-distance)/50 
+        # Pixels with a distance of 50 (or greater) have a brightness of 0.0 (or negative which is equivalent to 0 here)
+        # Pixels with a distance of 0 have a brightness of 1.0.
+        adjustment = (50 - distance) / 50
+
+        # Set the display pixel to the image pixel
+        pixels[loc] = color(*@image_pixels[loc].map {|rgb| rgb * adjustment })
+      end
+    end
+    update_pixels
+  end
+
+end
+
+FlashlightEffectSketch.new :title => "Flashlight Effect", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/10_brightness_threshold.rb

@@ -0,0 +1,33 @@
+require 'ruby-processing'
+
+class BrightnessThresholdSketch < Processing::App
+
+  def setup
+    @source = load_image 'sunflower.jpg'
+    @destination = create_image @source.width, @source.height, RGB
+  end
+
+  def draw
+    threshold = 127
+    # We are going to look at both image's pixels
+    @source.load_pixels
+    @destination.load_pixels
+
+    @source.width.times do |x|
+      @source.height.times do |y|
+        loc = x + y*@source.width;
+        # Test the brightness against the threshold
+        @destination.pixels[loc] = (brightness(@source.pixels[loc]) > threshold) ? color(255) : color(0)
+      end
+    end
+
+    # We changed the pixels in @destination
+    @destination.update_pixels
+    # Display the @destination
+    image @destination, 0, 0
+  end
+
+end
+
+BrightnessThresholdSketch.new :title => "Brightness Threshold", :width => 200, :height => 200
+

data/samples/learning_processing/chapter_15/11_brightness_threshold_with_filter.rb

@@ -0,0 +1,20 @@
+require 'ruby-processing'
+
+class BrightnessThresholdWithFilterSketch < Processing::App
+
+  def setup
+    @img = load_image 'sunflower.jpg'
+  end
+
+  def draw
+    # Draw the image
+    image @img, 0, 0
+    # Filter the window with a threshold effect
+    # 0.5 means threshold is 50% brightness
+    filter THRESHOLD, 0.5
+  end
+
+end
+
+BrightnessThresholdWithFilterSketch.new :title => "Brightness Threshold With Filter", :width => 200, :height => 200
+

data/samples/learning_processing/chapter_15/12_pixel_neighbour_differences.rb

@@ -0,0 +1,43 @@
+require 'ruby-processing'
+
+class PixelNeighbourDifferencesSketch < Processing::App
+
+  def setup
+    @img = load_image 'sunflower.jpg'
+    @destination = create_image @img.width, @img.height, RGB
+  end
+
+  def draw
+    # We are going to look at both image's pixels
+    @img.load_pixels
+    @destination.load_pixels
+
+    # Since we are looking at left neighbors
+    # We skip the first column
+    (1...width).each do |x|
+      (0...height).each do |y|
+        # Pixel location and color
+        loc = x + y * @img.width
+        pix = @img.pixels[loc]
+
+        # Pixel to the left location and color
+        left_loc = (x - 1) + y * @img.width
+        left_pix = @img.pixels[left_loc]
+
+        # New color is difference between pixel and left neighbor
+        diff = (brightness(pix) - brightness(left_pix)).abs
+        @destination.pixels[loc] = color(diff) 
+      end
+    end
+
+    # We changed the pixels in @destination
+    @destination.update_pixels
+    # Display the @destination
+    image @destination, 0, 0
+  end
+
+end
+
+PixelNeighbourDifferencesSketch.new :title => "Pixel Neighbour Differences", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/14_pointillism.rb

@@ -0,0 +1,34 @@
+require 'ruby-processing'
+
+class PointillismSketch < Processing::App
+
+  def setup
+    @pointillize = 10
+    @img = load_image 'sunflower.jpg'
+    background 255
+    frame_rate 200 # Let's run this one as fast as we can.
+    no_stroke
+    smooth
+  end
+
+  def draw
+    # Pick a random point
+    x, y = rand(width), rand(height)
+    loc = x + y * width
+
+    # Look up the RGB color in the source image
+    load_pixels
+    pixel = @img.pixels[loc]
+    r, g, b = red(pixel), green(pixel), blue(pixel)
+    
+    # Draw an ellipse at that location with that color
+    fill r, g, b, 100
+    # Back to shapes! Instead of setting a pixel, we use the color from a pixel to draw a circle.
+    ellipse x, y, @pointillize, @pointillize
+  end
+
+end
+
+PointillismSketch.new :title => "Pointillism", :width => 200, :height => 200
+
+

data/samples/learning_processing/chapter_15/15_2d_image_mapped_to_3d.rb

@@ -0,0 +1,43 @@
+require 'ruby-processing'
+
+class TwoDMappedTo3dSketch < Processing::App
+
+  def setup
+    @cellsize = 2
+    @img = load_image 'sunflower.jpg' # Load the image
+    @img.load_pixels
+    @pixels = @img.pixels
+    @cols = width / @cellsize         # Calculate number of columns
+    @rows = height / @cellsize        # Calculate number of rows
+    render_mode P3D
+    no_stroke
+    rect_mode CENTER
+  end
+
+  def draw
+    background 255
+    @cols.times do |i|                      # Begin loop for columns
+      x = i * @cellsize + @cellsize / 2     # x position
+      @rows.times do |j|                    # Begin loop for rows
+        y = j * @cellsize + @cellsize / 2   # y position
+        loc = x + y * width                 # Pixel array location
+        c = @pixels[loc]                    # Grab the color
+
+        # Calculate a z position as a function of mouse_x and pixel brightness
+        z = (mouse_x/width.to_f) * brightness(@pixels[loc]) - 100.0
+
+        # Translate to the location, set fill and stroke, and draw the rect
+        push_matrix
+        translate x, y, z
+        fill c
+        rect 0, 0, @cellsize, @cellsize
+        pop_matrix
+      end
+    end
+  end
+
+end
+
+TwoDMappedTo3dSketch.new :title => "2d Mapped To 3d",  :width => 200,  :height => 200
+
+

data/samples/learning_processing/chapter_16/01_display_video.rb

@@ -0,0 +1,25 @@
+require 'ruby-processing'
+
+class CaptureVideoSketch < Processing::App
+
+  # Step 1. Import the video library
+  load_library "video"
+  # We need the video classes to be included here.
+  include_package "processing.video" 
+
+  def setup
+    # Step 2. Declare a Capture object
+    @video = Capture.new(self, width, height, 30)
+  end
+
+  def draw
+    # Step 3 and 4: Read from the camera if it's available.
+    @video.read if @video.available
+
+    # Step 5. Display the video image.
+    image @video, 0, 0
+  end
+
+end
+
+CaptureVideoSketch.new :title => "Capture Video", :width => 320, :height => 240

data/samples/learning_processing/chapter_16/02_manipulate_video_image.rb

@@ -0,0 +1,24 @@
+require 'ruby-processing'
+
+class ManipulateVideoImageSketch < Processing::App
+
+  load_library "video"
+  include_package "processing.video" 
+
+  def setup
+    @video = Capture.new(self, width, height, 30)
+  end
+
+  def draw
+    @video.read if @video.available
+
+    # Tinting using mouse location
+    tint mouse_x, mouse_y, 255
+
+    # A video image can also be tinted and resized just as with a PImage.
+    image @video, 0, 0, mouse_x, mouse_y
+  end
+
+end
+
+ManipulateVideoImageSketch.new :title => "Manipulate Video Image", :width => 320, :height => 240

data/samples/reflection.rb

@@ -0,0 +1,26 @@
+# Taken from the Processing Examples.
+
+require 'ruby-processing'
+
+class Reflection < Processing::App
+  
+  def setup
+    render_mode(P3D)
+    no_stroke
+    color_mode(RGB, 1)
+    fill 0.4
+  end
+  
+  def draw
+    background 0
+    translate( width/2, height/2 )
+    light_specular(1, 1, 1)
+    directional_light(0.8, 0.8, 0.8, 0, 0, -1)
+    s = mouse_x.to_f / width.to_f
+    specular s, s, s
+    sphere 50
+  end
+  
+end
+
+Reflection.new(:width => 200, :height => 200, :title => "Reflection")

data/samples/simple_buffer.rb

@@ -0,0 +1,49 @@
+require 'ruby-processing'
+
+class SimpleBuffer < Processing::App
+  def setup
+    
+    # With Processing, buffers allow you to draw off-screen to an image,
+    # and then use that image in your sketch. This can speed up rendering
+    # times quite a bit, as it's not only faster to draw off-screen, but
+    # it also allows you to redraw only portions of the screen.
+    
+    # Ruby-Processing provides a convenience method, "buffer", which
+    # sets up a buffer for you with the same width and height and 
+    # renderer as the current sketch, and yields it to you. It also
+    # takes care of calling begin_draw and end_draw at the start and 
+    # end of the block. Use it like so:
+    
+    @buffer = buffer do |b|
+      b.no_stroke
+      b.fill 255, 0, 0
+      b.rect 100, 200, 100, 100
+    end
+    
+    # Those lines are equivalent to the following lines:
+    
+    @buffer_2 = create_graphics(500, 500, P3D)
+    @buffer_2.begin_draw
+    @buffer_2.no_stroke
+    @buffer_2.fill(255, 0, 0)
+    @buffer_2.rect(100, 200, 100, 100)
+    @buffer_2.end_draw
+    
+    # If you'd like to set the size or renderer for the buffer block,
+    # just pass it in like normal:
+    
+    @buffer_3 = buffer(150, 150, P3D) do |b|
+      # b.whatever goes here.
+    end
+    
+    # And now we go ahead and grab the rendered image from the first buffer.
+    @img = @buffer.get(0, 0, @buffer.width, @buffer.height)
+  end
+  
+  def draw
+    background 0
+    image @img, frame_count, 0
+  end
+end
+
+SimpleBuffer.new :title => "Simple Buffer", :width => 500, :height => 500