ruby-processing 1.0.4 → 1.0.5

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-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.
-  import "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

@@ -1,24 +0,0 @@
-require 'ruby-processing'
-
-class ManipulateVideoImageSketch < Processing::App
-
-  load_library "video"
-  import "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/learning_processing/chapter_16/03_adjust_video_brightness.rb

@@ -1,49 +0,0 @@
-# Example 16-3: Adjust video brightness
-require 'ruby-processing'
-
-class AdjustVideoBrightness < Processing::App
-  load_library "video"
-  import "processing.video" 
-
-  def setup
-    size 240, 180, P3D
-
-    # Initialize Capture object via Constructor
-    # video is 320 x 240, @15 fps
-    @video = Capture.new self, 240, 180, 15
-    background 0
-  end
-
-  def draw
-    # Check to see if a new frame is available
-    # If so, read it.
-    @video.read if @video.available?
-
-    load_pixels
-    @video.load_pixels
-    pixs = @video.pixels
-    mx, my = mouse_x, mouse_y
-    max_dist  = 100
-    vid_width, vid_height = @video.width, @video.height
-
-    vid_width.times do |x|
-      vid_height.times do |y|
-        # Calculate the 1D location from a 2D grid
-        loc = x + y * vid_width
-        pix = pixs[loc]
-
-        # Calculate an amount to change brightness based on proximity to the mouse
-        d         = dist(x, y, mx, my)
-        fudge     = (max_dist - d) / max_dist
-        r, g, b   = red(pix) * fudge, green(pix) * fudge, blue(pix) * fudge
-
-        # Make a new color and set pixel in the window
-        pixels[loc] = color(r, g, b)
-      end
-    end
-    update_pixels
-  end
-
-end
-
-AdjustVideoBrightness.new :title => "Adjust Video Brightness"

data/samples/learning_processing/chapter_17/01_simple_displaying_text.rb

@@ -1,14 +0,0 @@
-def setup
-  size 200, 200
-  # Load Font
-  @font = loadFont "ArialMT-16.vlw"
-end
-
-def draw
-  background 255
-  text_font @font, 16   # Specify font to be used
-  fill 0                # Specify font color
-
-  # Display Text
-  text "Mmmmm ... Strings ..." , 10, 100
-end

data/samples/learning_processing/chapter_17/02_text_align.rb

@@ -1,21 +0,0 @@
-def setup
-  size 400, 200
-  @font = create_font "Arial", 16, true
-end
-
-def draw
-  background 255
-  stroke 175
-  line width/2, 0, width/2, height
-  text_font @font
-  fill 0
-
-  # text_align sets the alignment for displaying text. 
-  # It takes one argument: CENTER, LEFT, or RIGHT.
-  text_align CENTER
-  text "This text is centered.", width / 2, 60
-  text_align LEFT
-  text "This text is left aligned.", width/2, 100
-  text_align RIGHT
-  text "This text is right aligned.", width / 2, 140
-end

data/samples/learning_processing/chapter_17/03_scrolling_headlines.rb

@@ -1,35 +0,0 @@
-HEADLINES = "Processing downloads break downloading record.",
-            "New study shows computer programming lowers cholesterol."
-
-def setup
-  size 400, 200
-  @f     = create_font "Arial" ,16, true
-  @x     = width
-  @index = 0
-end
-
-def draw
-  background 255
-  fill 0
-
-  # Display headline at x location
-  text_font @f, 16
-  text_align LEFT
-
-  # A specific string from the array is displayed according to the value 
-  # of the "index" variable.
-  text HEADLINES[@index], @x, 180
-
-  # Decrement x
-  @x = @x - 3
-
-  # If x is less than the negative width, then it is off the screen
-  # text_width is used to calculate the width of the current string.
-  w = text_width(HEADLINES[@index])
-  if (@x < -w) 
-    @x = width
-    # @index is incremented when the current string has left
-    # the screen in order to display a new string.
-    @index = (@index + 1) % HEADLINES.length 
-  end
-end

data/samples/learning_processing/chapter_17/04_text_mirror.rb

@@ -1,68 +0,0 @@
-# This example demonstrates how to use the video library. You'll need a 
-# video camera hooked in to your computer.
-
-class TextMirror < Processing::App
-  load_library "video"
-  import "processing.video" 
-
-  # Size of each cell in the grid, ratio of window size to video size
-  VIDEOSCALE = 14
-
-  # The source text used in the mosaic pattern. 
-  # A longer String might produce more interesting results.
-  CHARS = "thetextmirror"
-
-  def setup
-    size 640, 480
-    smooth
-    # Set up columns and rows
-    @cols  = width / VIDEOSCALE  # Number of columns and...
-    @rows  = height / VIDEOSCALE # rows in our system
-    @video = Capture.new(self, @cols, @rows, 15)
-
-    # Load the font
-    # Using a fixed-width font. In most fonts, individual characters have different widths. 
-    # In a fixed-width font, all characters have the same width. 
-    # This is useful here since we intend to display the letters one at a time spaced out evenly. 
-    # See Section 17.7 for how to display text character by character with a nonfixed width font.
-    @f = load_font "Courier-Bold-20.vlw"
-  end
-
-  def draw
-    background 0
-
-    # Read image from the camera
-    @video.read if @video.available?
-    @video.load_pixels
-
-    # Use a variable to count through chars in String
-    charcount = 0
-    # Begin loop for rows
-    @rows.times do |j|
-      # Begin loop for columns
-      @cols.times do |i|
-
-        # Where are we, pixel-wise?
-        x = i * VIDEOSCALE
-        y = j * VIDEOSCALE
-
-        # Looking up the appropriate color in the pixel array
-        c = @video.pixels[i + j * @video.width]
-
-        # Displaying an individual character from the String instead of a rectangle
-        text_font @f
-        fill c
-
-        # One character from the source text is displayed colored accordingly to the pixel location. 
-        # A counter variableâ charcountâ is used to walk through the source String one character at a time.
-        text CHARS[charcount].chr, x, y
-
-        # Go on to the next character
-        charcount = (charcount + 1) % CHARS.length
-      end
-    end  
-  end
-
-end
-
-TextMirror.new :title => "Text Mirror"