ruby-processing 2.6.3 → 2.6.4

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

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

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

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

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

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

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

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

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

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

@@ -1,43 +0,0 @@
-#
-# 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 = load_image('frontier.jpg')
-  image(img, 0, 0)
-  img.load_pixels
-  @hist = Array.new(256, 0)
-  
-  # Calculate the histogram
-  (0 ... img.width).each do |i|
-    (0 ... img.height).each do |j|
-      bright = (brightness(img.pixels[j * img.width + i]))
-      hist[bright] += 1  
-    end
-  end
-  
-  # Find the largest value in the histogram using ruby array max function
-  hist_max = hist.max
-  
-  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)
-    # Convert the histogram value to a location between 
-    # the bottom and the top of the picture
-    y = map(hist[which], 0, hist_max, img.height, 0)
-    line(i, img.height, i, y)
-  end
-end