ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/image_processing/blending.rb

@@ -0,0 +1,82 @@
+#
+# Blending 
+# by Andres Colubri. 
+# 
+# Images can be blended using one of the 10 blending modes 
+# (currently available only in P2D and P3).
+# Click to go to cycle through the modes.  
+#
+
+# NOTE: THIS EXAMPLE IS IN PROGRESS -- REAS
+
+attr_reader  :img1, :img2, :pic_alpha, :name, :sel_mode
+
+
+def setup
+  size(640, 360, P3D)
+  @img1 = loadImage("layer1.jpg")
+  @img2 = loadImage("layer2.jpg") 
+  @name = "REPLACE"
+  noStroke
+  @sel_mode = REPLACE
+end
+
+def draw
+  
+  @pic_alpha = (map(mouse_x, 0, width, 0, 255)).to_i
+  
+  background(0)
+  
+  tint(255, 255)
+  image(img1, 0, 0)
+  
+  blend_mode(sel_mode)  
+  tint(255, pic_alpha)
+  image(img2, 0, 0)
+  
+  blend_mode(REPLACE) 
+  fill(255)
+  rect(0, 0, 94, 22)
+  fill(0)
+  text(name, 10, 15)
+end
+
+def mouse_pressed
+  if (sel_mode == REPLACE) 
+    @sel_mode = BLEND
+    @name = "BLEND"
+  elsif (sel_mode == BLEND) 
+    @sel_mode = ADD
+    @name = "ADD"
+  elsif (sel_mode == ADD) 
+    @sel_mode = SUBTRACT
+    @name = "SUBTRACT"
+  elsif (sel_mode == SUBTRACT) 
+    @sel_mode = LIGHTEST
+    @name = "LIGHTEST"
+  elsif (sel_mode == LIGHTEST) 
+    @sel_mode = DARKEST
+    @name = "DARKEST"
+  elsif (sel_mode == DARKEST) 
+    @sel_mode = DIFFERENCE
+    @name = "DIFFERENCE"
+  elsif (sel_mode == DIFFERENCE) 
+    @sel_mode = EXCLUSION  
+    @name = "EXCLUSION"
+  elsif (sel_mode == EXCLUSION) 
+    @sel_mode = MULTIPLY  
+    @name = "MULTIPLY"
+  elsif (sel_mode == MULTIPLY) 
+    @sel_mode = SCREEN
+    @name = "SCREEN"
+  elsif (sel_mode == SCREEN) 
+    @sel_mode = REPLACE
+    @name = "REPLACE"
+  end
+end
+
+def mouse_dragged
+  if (height - 50 < mouse_y)
+    @pic_alpha = (map(mouse_x 0, width, 0, 255)).to_i
+  end
+end

data/samples/processing_app/topics/image_processing/blur.rb

@@ -0,0 +1,50 @@
+#
+# Blur. 
+# 
+# A low-pass filter blurs an image. This program analyzes every
+# pixel in an image and blends it with the neighboring pixels
+# to blur the image. 
+#
+
+
+KERNEL = Array.new(3, Array.new(3, 1.0/9.0))
+                 
+attr_reader :img
+
+def setup
+  size(640, 360)
+  @img = loadImage("moon.jpg") # Load the original image
+  noLoop
+end 
+
+def draw
+  image(img, 0, 0) # Displays the image from point (0,0) 
+  img.loadPixels
+
+  # Create an opaque image of the same size as the original
+  edgeImg = createImage(img.width, img.height, RGB)
+
+  # Loop through every pixel in the image
+  (1 ... img.height - 1).each do |y| 
+    (1 ... img.width - 1).each do |x| 
+      sum = 0 # Kernel sum for this pixel
+      (-1 .. 1).each do |ky| 
+        (-1 .. 1).each do |kx|
+          # Calculate the adjacent pixel for this kernel point
+          pos = (y + ky) * img.width + (x + kx)
+          # Image is grayscale, red/green/blue are identical
+          val = red(img.pixels[pos])
+          # Multiply adjacent pixels based on the kernel values
+          sum += KERNEL[ky + 1][kx + 1] * val
+        end
+      end
+      # For this pixel in the new image, set the gray value
+      # based on the sum from the kernel
+      edgeImg.pixels[y * img.width + x] = color(sum)
+    end
+  end
+  # State that there are changes to edgeImg.pixels[]
+  edgeImg.updatePixels
+  image(edgeImg, width/2, 0) # Draw the new image
+end
+

data/samples/processing_app/topics/image_processing/brightness.rb

@@ -0,0 +1,39 @@
+#
+# Brightness
+# by Daniel Shiffman. 
+# 
+# This program adjusts the brightness of a part of the image by
+# calculating the distance of each pixel to the mouse.
+#
+
+ 
+
+attr_reader :img
+
+def setup
+  size(640, 360)
+  frame_rate(30)
+  @img = load_image("moon-wide.jpg")
+  img.load_pixels
+  # Only need to load the pixels[] array once, because we're only
+  # manipulating pixels[] inside draw, not drawing shapes.
+  load_pixels
+end
+
+def draw
+  (0 ... img.width).each do |x|
+    (0 ... img.height).each do |y|
+      # Calculate the 1D location from a 2D grid
+      loc = x + y * img.width
+      r = red (img.pixels[loc])
+      # Calculate an amount to change brightness based on proximity to the mouse
+      maxdist = 50 # dist(0,0,width,height)
+      d = dist(x, y, mouseX, mouseY)
+      adjustbrightness = 255 * (maxdist-d) / maxdist
+      r += adjustbrightness
+      r = constrain(r, 0, 255)
+      pixels[y*width + x] = color(r)
+    end
+  end
+  update_pixels
+end

data/samples/processing_app/topics/image_processing/convolution.rb

@@ -0,0 +1,72 @@
+#*
+# Convolution
+# by Daniel Shiffman.  
+# 
+# Applies a convolution matrix to a portion of an image. Move mouse to 
+# apply filter to different parts of the image. 
+#
+
+attr_reader :img
+
+# It's possible to convolve the image with many different 
+# matrices to produce different effects. This is a high-pass 
+# filter it accentuates the edges.
+
+MATRIX = [ [ -1, -1, -1 ], [ -1,  9, -1 ], [ -1, -1, -1 ] ]
+W = 120
+
+def setup
+  size(640, 360)
+  @img = load_image("moon-wide.jpg") 
+end
+
+def draw
+  # We're only going to process a portion of the image
+  # so let's set the whole image as the background first
+  image(img, 0, 0)
+  
+  # Calculate the small rectangle we will process
+  xstart = constrain(mouse_x - W/2, 0, img.width)
+  ystart = constrain(mouse_y - W/2, 0, img.height)
+  xend = constrain(mouse_x + W/2, 0, img.width)
+  yend = constrain(mouse_y + W/2, 0, img.height)
+
+  load_pixels
+  # Begin our loop for every pixel in the smaller image
+  (xstart ... xend).each do |x| 
+    (ystart ... yend).each do |y| 
+      loc = x + y * img.width
+      pixels[loc] = convolution(x, y, MATRIX, MATRIX.length, img)
+    end
+  end
+  update_pixels
+end
+
+def convolution(x, y, matrix, matrixsize, img)
+
+  rtotal = 0.0
+  gtotal = 0.0
+  btotal = 0.0
+  offset = matrixsize / 2
+  (0 ... matrixsize).each do |i|
+     (0 ... matrixsize).each do |j|
+      # What pixel are we testing
+      xloc = x + i - offset
+      yloc = y + j - offset
+      loc = xloc + img.width * yloc
+      # Make sure we haven't walked off our image, we could do better here
+      loc = constrain(loc, 0, img.pixels.length - 1)
+      # Calculate the convolution
+      rtotal += (red(img.pixels[loc]) * matrix[i][j])
+      gtotal += (green(img.pixels[loc]) * matrix[i][j])
+      btotal += (blue(img.pixels[loc]) * matrix[i][j])
+    end
+  end
+  # Make sure RGB is within range
+  rtotal = constrain(rtotal, 0, 255)
+  gtotal = constrain(gtotal, 0, 255)
+  btotal = constrain(btotal, 0, 255)
+  # Return the resulting color
+  return color(rtotal, gtotal, btotal)
+end
+

data/samples/processing_app/topics/image_processing/data/java_args.txt

@@ -0,0 +1,3 @@
+-Djruby.ji.objectProxyCache=false -XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
+ 
+

data/samples/processing_app/topics/image_processing/edge_detection.rb

@@ -0,0 +1,47 @@
+#
+# Edge Detection. 
+# 
+# A high-pass filter sharpens an image. This program analyzes every
+# pixel in an image in relation to the neighboring pixels to sharpen 
+# the image. 
+#
+
+KERNEL = [ [ -1, -1, -1 ], [ -1,  9, -1 ], [ -1, -1, -1 ] ]
+                    
+attr_reader :img
+
+def setup 
+  size(640, 360)
+  @img = load_image("moon.jpg") # Load the original image
+  noLoop()
+end
+
+def draw
+  image(img, 0, 0) # Displays the image from point (0,0) 
+  img.load_pixels()
+  # Create an opaque image of the same size as the original
+  edge_img = create_image(img.width, img.height, RGB)
+  # Loop through every pixel in the image
+  (1 ... img.height - 1).each do |y| 
+    (1 ... img.width - 1).each do |x| 
+      sum = 0 # Kernel sum for this pixel
+      (-1 .. 1).each do |ky| 
+        (-1 .. 1).each do |kx|
+          # Calculate the adjacent pixel for this kernel point
+          pos = (y + ky)*img.width + (x + kx)
+          # Image is grayscale, red/green/blue are identical
+          val = red(img.pixels[pos])
+          # Multiply adjacent pixels based on the kernel values
+          sum += KERNEL[ky+1][kx+1] * val
+        end
+      end
+      # For this pixel in the new image, set the gray value
+      # based on the sum from the kernel
+      edge_img.pixels[y*img.width + x] = color(sum, sum, sum)
+    end
+  end
+  # State that there are changes to edge_img.pixels[]
+  edge_img.update_pixels()
+  image(edge_img, width/2, 0) # Draw the new image
+end
+

data/samples/processing_app/topics/image_processing/explode.rb

@@ -0,0 +1,35 @@
+# Explode 
+# by Daniel Shiffman. 
+# 
+# Mouse horizontal location controls breaking apart of image and 
+# Maps pixels from a 2D image into 3D space. Pixel brightness controls 
+# translation along z axis. 
+CELL_SIZE = 2
+
+def setup    
+  size 640, 360, P3D    
+  @img = load_image "eames.jpg"
+  @columns = @img.width / CELL_SIZE
+  @rows = @img.height / CELL_SIZE    
+end
+
+def draw    
+  background 0    
+  (0...@columns).each { |i|        
+    (0...@rows).each { |j|            
+      x = i * CELL_SIZE + CELL_SIZE / 2
+      y = j * CELL_SIZE + CELL_SIZE / 2            
+      loc = x + y * @img.width            
+      c = @img.pixels[loc]            
+      z = (mouse_x / width.to_f) * brightness( @img.pixels[loc] ) - 20            
+      push_matrix            
+      translate x + 200, y + 100, z            
+      fill c, 204
+      no_stroke
+      rect_mode CENTER            
+      rect 0, 0, CELL_SIZE, CELL_SIZE            
+      pop_matrix
+    }
+  }
+  
+end

data/samples/processing_app/topics/image_processing/extrusion.rb

@@ -0,0 +1,49 @@
+#
+# Extrusion. 
+# 
+# Converts a flat image into spatial data points and rotates the points
+# around the center.
+#
+
+attr_reader :a, :a_pixels, :values, :angle
+
+def setup
+  size(640, 360, P3D)
+  @angle = 0
+  @a_pixels = []
+  @values = []
+  no_fill
+  
+  # Load the image into a new array
+  # Extract the values and store in an array
+  @a = load_image("ystone08.jpg")
+  a.load_pixels
+  (0 ... a.height).each do |j|
+    a_inner = []
+    v_inner = []
+    (0 ... a.width).each do |i|
+      a_inner << a.pixels[i * a.width + j]
+      v_inner << blue(a_inner[i]).to_i
+    end
+    a_pixels << a_inner
+    values << v_inner
+  end
+end
+
+def draw
+  background(0)
+  translate(width/2, height/2, -height/2)
+  scale(2.0)
+  
+  # Update and constrain the angle
+  @angle += 0.005
+  rotate_y(angle)  
+  
+  # Display the image mass
+  (0 ... a.height).step(4) do |i|
+    (0 ... a.width).step(4) do |j|
+      stroke(values[j][i], 255)
+      line(j-a.width/2, i-a.height/2, -values[j][i], j-a.width/2, i-a.height/2, -values[j][i]-10)
+    end
+  end
+end

data/samples/processing_app/topics/image_processing/histogram.rb

@@ -0,0 +1,43 @@
+#
+# Histogram. 
+# 
+# Calculates the histogram of an image. 
+# A histogram is the frequency distribution 
+# of the gray levels with the number of pure black values
+# displayed on the left and number of pure white values on the right. 
+#
+
+attr_reader :hist
+
+def setup
+  size(640, 360)
+  
+  # Load an image from the data directory
+  # Load a different image by modifying the comments
+  img = loadImage("frontier.jpg")
+  image(img, 0, 0)
+  @hist = Array.new(256, 0)
+  
+  # Calculate the histogram
+  (0 ... img.width).each do |i|
+    (0 ... img.height).each do |j|
+      bright = (brightness(get(i, j))).to_i
+      hist[bright] += 1  
+    end
+  end
+  
+  # Find the largest value in the histogram using processings max function
+  # that's why we use to java cinversion
+  histMax = max(hist.to_java Java::int)
+  
+  stroke(255)
+  # Draw half of the histogram (skip every second value)
+  (0 ... img.width).step(2) do |i|
+    # Map i (from 0..img.width) to a location in the histogram (0..255)
+    which = (map(i, 0, img.width, 0, 255)).to_i
+    # Convert the histogram value to a location between 
+    # the bottom and the top of the picture
+    y = (map(hist[which], 0, histMax, img.height, 0)).to_i
+    line(i, img.height, i, y)
+  end
+end