ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/basics/color/creating.rb

@@ -1,37 +1,48 @@
-require 'ruby-processing'
-
 # Creating Colors (Homage to Albers). 
 # 
 # Creating variables for colors that may be referred to 
 # in the program by their name, rather than a number. 
 
-class Creating < Processing::App
 
-  def setup
-    
-    redder = color 204, 102, 0
-    yellower = color 204, 153, 0
-    orangish = color 153, 51, 0
-    
+def setup
+  size 640, 360
+  redder = color 204, 102, 0
+  yellower = color 204, 153, 0
+  orangish = color 153, 51, 0
+  
 	# These statements are equivalent to the statements above.
 	# Programmers may use the format they prefer.
 	
-	# redder = 0xFFCC6600
-	# yellower = 0xFFCC9900
-	# orangish = 0xFF993300
-    
-    no_stroke
+	# redder = color '#CC6600'
+	# yellower = color '#CC9900'
+	# orangish = color '#993300'
+	
+	# or alternatively
+	
+	# redder = color 0xFFCC6600
+	# yellower = color 0xFFCC9900
+	# orangish = color 0xFF993300
 	
-	  fill orangish
-	  rect 0, 0, 200, 200
-	  
-	  fill yellower
-	  rect 40, 60, 120, 120
-	  
-	  fill redder
-	  rect 60, 90, 80, 80
-  end
+	no_stroke
+	background 51, 0, 0
+	push_matrix
+  translate 80, 80
+  fill orangish
+  rect 0, 0, 200, 200
+  fill yellower
+  rect 40, 60, 120, 120
+  fill redder
+  rect 60, 90, 80, 80
+  pop_matrix
   
+  push_matrix
+  translate 360, 80
+  fill redder
+  rect 0, 0, 200, 200
+  fill orangish
+  rect 40, 60, 120, 120
+  fill yellower
+  rect 60, 90, 80, 80
+  pop_matrix
 end
 
-Creating.new :title => "Creating", :width => 200, :height => 200

data/samples/processing_app/basics/color/hue.rb

@@ -1,29 +1,23 @@
-require 'ruby-processing'
-
 # Hue is the color reflected from or transmitted through an object 
 # and is typically referred to as the name of the color (red, blue, yellow, etc.) 
 # Move the cursor vertically over each bar to alter its hue. 
 
-class Hue < Processing::App
 
-  def setup
-    @bar_width = 5
-    @hue = Array.new( (width/@bar_width), 0 )
-    
-    color_mode HSB, 360, height, height
-    no_stroke
-  end
-  
-  def draw
-  	(width/@bar_width).times do |i|
-  	  n = i * @bar_width
-  	  range = (n..n+@bar_width)
-  	  @hue[i] = mouse_y if range.include?(mouse_x)
-  		fill @hue[i], height/1.2, height/1.2
-  		rect n, 0, @bar_width, height
-		end
-  end
-  
+def setup
+  size 640, 360  
+  @bar_width = 20
+  @hue = Array.new( (width/@bar_width), 0 )    
+  color_mode HSB, height
+  no_stroke
+  background 0
 end
 
-Hue.new :title => "Hue", :width => 200, :height => 200
+def draw
+  (width/@bar_width).times do |i|
+    n = i * @bar_width
+    range = (n .. n + @bar_width)
+    @hue[i] = mouse_y if range.include?(mouse_x)
+    fill @hue[i], height/1.2, height/1.2
+    rect n, 0, @bar_width, height
+  end
+end

data/samples/processing_app/basics/color/linear_gradient.rb

@@ -1,47 +1,42 @@
-require 'ruby-processing'
-
 # Simple Linear Gradient 
-# by Ira Greenberg. 
 # 
-# Using the convenient red(), green() 
-# and blue() component functions,
-# generate some linear gradients.
+# The lerp_color function is useful for interpolating
+# between two colors.
+#
+ 
+Y_AXIS = 1
+X_AXIS = 2
 
-class LinearGradient < Processing::App
+def setup
+  size 640, 360  
+  # Define colors
+  b1 = color(255)
+  b2 = color(0)
+  c1 = color(204, 102, 0)
+  c2 = color(0, 102, 153)
 
-  def setup
-    b1 = color 190
-    b2 = color 20
-    set_gradient 0, 0, width.to_f, height.to_f, b1, b2, :y_axis
-    
-    c1 = color 255, 120, 0 
-  	c2 = color 10, 45, 255 
-  	c3 = color 10, 255, 15 
-  	c4 = color 125, 2, 140 
-  	c5 = color 255, 255, 0 
-  	c6 = color 25, 255, 200 
-  	set_gradient 25, 25, 75, 75, c1, c2, true
-  	set_gradient 100, 25, 75, 75, c3, c4, false
-  	set_gradient 25, 100, 75, 75, c2, c5, false
-  	set_gradient 100, 100, 75, 75, c4, c6, true
-  end
-  
-  def set_gradient( x, y, w, h, c1, c2, vertical )
-  	delta_r = red(c2) - red(c1)
-  	delta_g = green(c2) - green(c1)
-  	delta_b = blue(c2) - blue(c1)
-  	
-	  x.upto( x+w ) do |i|
-	  	y.upto( y+w ) do |j|
-	  		c = color(red(c1)+(j-y)*(delta_r/h),
-	  				      green(c1)+(j-y)*(delta_g/h),
-	  				      blue(c1)+(j-y)*(delta_b/h) )
-	  				      
-	  		vertical ? set(i, j, c) : set(j, i, c)
-	  	end
-	  end
+  # Background
+  set_gradient(0, 0, width/2, height, b1, b2, X_AXIS)
+  set_gradient(width/2, 0, width/2, height, b2, b1, X_AXIS)
+  # Foreground
+  set_gradient(50, 90, 540, 80, c1, c2, Y_AXIS)
+  set_gradient(50, 190, 540, 80, c2, c1, X_AXIS)
+end
+
+def set_gradient(x, y, w, h, c1, c2, axis )
+  no_fill
+  if (axis == Y_AXIS) # Top to bottom gradient
+    (y ... y + h).each do |i|
+      inter = map(i, y, y + h, 0, 1)      
+      stroke lerp_color(c1, c2, inter)
+      line(x, i, x + w, i)
+    end
+  elsif (axis == X_AXIS) # Left to right gradient
+    (x ... x + w).each do |i|
+      inter = map(i, x, x + w, 0, 1)
+      stroke lerp_color(c1, c2, inter)
+      line(i, y, i, y + h)
+    end
   end
-  
 end
 
-LinearGradient.new :title => "Linear Gradient", :width => 200, :height => 200

data/samples/processing_app/basics/color/radial_gradient.rb

@@ -1,52 +1,44 @@
-require 'ruby-processing'
-
 # Simple Radial Gradient 
 # by Ira Greenberg. 
 # 
 # Using the convenient red(), green() 
 # and blue() component functions,
 # generate an array of radial gradients.
+COLOR_SPACE = 16581375    # 255 * 255 * 255
 
-class RadialGradient < Processing::App
-
-  def setup
-    background 0
-    smooth
-    no_fill
-    stroke_width 1.8
-    
-    columns = 4
-    radius = (width / columns) / 2
-    diameter = radius * 2
-    
-    (width / diameter).times do |left|
-    	(height / diameter).times do |top|
-    		create_gradient( 
-    		  radius+left*diameter, radius+top*diameter, radius, random_color, random_color 
-    		)
-    	end
+def setup
+  size 640, 360 
+  background 0
+  smooth
+  no_fill
+  stroke_width 1.8    
+  columns = 4
+  radius = (width / columns) / 2
+  diameter = radius * 2    
+  (width / diameter).times do |left|
+    (height / diameter).times do |top|
+      create_gradient( 
+        radius+left*diameter, radius+top*diameter, radius, random_color, random_color 
+        )
+      end
     end
   end
   
   def random_color
-    color(rand(255), rand(255), rand(255))
+    color(rand(COLOR_SPACE))
   end
   
-  def create_gradient( x, y, radius, c1, c2 )
-  	
-  	delta_r = red(c2)   - red(c1)
-  	delta_g = green(c2) - green(c1)
-  	delta_b = blue(c2)  - blue(c1)
-  	  	
-  	radius.times do |r|
-  	  c = color(red(c1)   + r * (delta_r / radius),
-      				  green(c1) + r * (delta_g / radius),
-      				  blue(c1)  + r * (delta_b / radius))
+  def create_gradient( x, y, radius, c1, c2 )    
+    delta_r = red(c2)   - red(c1)
+    delta_g = green(c2) - green(c1)
+    delta_b = blue(c2)  - blue(c1)    
+    radius.times do |r|
+      c = color(red(c1)   + r * (delta_r / radius),
+        green(c1) + r * (delta_g / radius),
+        blue(c1)  + r * (delta_b / radius))
       stroke c
       ellipse x, y, r*2, r*2
-  	end
+    end
   end
   
-end
 
-RadialGradient.new :title => "Radial Gradient", :width => 200, :height => 200

data/samples/processing_app/basics/color/reading/reading.rb

@@ -1,12 +1,10 @@
-require 'ruby-processing'
-
 # An image is recreated from its individual component colors.
 # The many colors of the image are created through modulating the 
 # red, green, and blue values. This is an exageration of an LCD display. 
 
-class Reading < Processing::App
 
-  def setup
+def setup
+    size 200, 200  
     no_stroke
     background 0
     
@@ -36,8 +34,5 @@ class Reading < Processing::App
     	end
     end
     
-  end
-  
 end
 
-Reading.new :title => "Reading", :width => 200, :height => 200

data/samples/processing_app/basics/color/relativity.rb

@@ -1,38 +1,25 @@
-require 'ruby-processing'
-
 # Each color is perceived in relation to other colors. 
 # The top and bottom bars each contain the same component colors,
 # but a different display order causes individual colors to appear differently. 
 
-class Relativity < Processing::App
-
-  def setup
-    
-    a = color 165, 167, 20
-  	b = color 77,  86,  59
-  	c = color 42,  106, 105
-  	d = color 165, 89,  20
-  	e = color 146, 150, 127
-  	
-  	no_stroke
-  	
-  	draw_band [a, b, c, d, e], 0, 4
-  	draw_band [c, a, d, b, e], height/2, 4
-  end
-  
-  def draw_band( color_order, ypos, bar_width )
-  	
-  	num = color_order.length
-  	
-  	(0...width).step(bar_width * num) do |i|
-  		num.times do |j|
-  			fill color_order[j]
-  			rect i + j*bar_width, ypos, bar_width, height/2
-  		end
-  	end
-  	
-  end
-  
+def setup
+  size 640, 480
+  a = color 165, 167, 20
+  b = color 77,  86,  59
+  c = color 42,  106, 105
+  d = color 165, 89,  20
+  e = color 146, 150, 127  	
+  no_stroke  	
+  draw_band [a, b, c, d, e], 0, 4
+  draw_band [c, a, d, b, e], height/2, 4
 end
 
-Relativity.new :title => "Relativity", :width => 200, :height => 200
+def draw_band( color_order, ypos, bar_width )  	
+  num = color_order.length  	
+  (0...width).step(bar_width * num) do |i|
+    num.times do |j|
+      fill color_order[j]
+      rect i + j*bar_width, ypos, bar_width, height/2
+    end
+  end  	
+end

data/samples/processing_app/basics/color/saturation.rb

@@ -1,35 +1,24 @@
-require 'ruby-processing'
 
 # Saturation is the strength or purity of the color and represents the 
 # amount of gray in proportion to the hue. A "saturated" color is pure 
 # and an "unsaturated" color has a large percentage of gray. 
 # Move the cursor vertically over each bar to alter its saturation. 
 
-class Saturation < Processing::App
+def setup
+  size 640, 360
+  color_mode HSB, 360
+  no_stroke    
+  @bar_width = 20
+  @saturation = Array.new( width/@bar_width, 0 )    
+end
 
-  def setup
-  
-    color_mode HSB, 360, height, height
-    no_stroke
-    
-    @bar_width = 5
-    @saturation = Array.new( width/@bar_width, 0 )
-    
-  end
-  
-  def draw
-  	i = 0; j = 0; while i <= (width-@bar_width)
-    
-    	if (mouseX > i) && (mouseX < (i+@bar_width))
-    		@saturation[j] = mouseY
-    	end
-    	
-    	fill i, @saturation[j], height/1.5
-    	rect i, 0, @bar_width, height
-    
-  	j += 1; i += @bar_width; end
-  end
-  
+def draw
+  i = 0; j = 0; while i <= (width-@bar_width)    
+  if (mouseX > i) && (mouseX < (i+@bar_width))
+    @saturation[j] = mouseY
+  end    
+  fill i, @saturation[j], height/1.5
+  rect i, 0, @bar_width, height    
+  j += 1; i += @bar_width; end
 end
 
-Saturation.new :title => "Saturation", :width => 200, :height => 200

data/samples/processing_app/basics/color/wave_gradient.rb

@@ -1,45 +1,34 @@
-require 'ruby-processing'
+
 
 # Wave Gradient 
 # by Ira Greenberg.  
 # 
 # Generate a gradient along a sin() wave.
 
-class WaveGradient < Processing::App
 
-  def setup
-  
-  	background 200
-  	
-  	angle     = 0.0
-  	px, py    = 0.0, 0.0
-  	amplitude = 30.0
-  	frequency = 0.0
-  	fill_gap  = 2.5
-  	
-  	(height + 150).times do |i|
-  	  i -= 75
-  		angle = 0.0
-  		frequency += 0.006
-  		
-  		(width + 75).times do |j|
-  			py = i + sin( angle.radians ) * amplitude
-  			angle += frequency
-  			
-  			c = color((py-i).abs * 255/amplitude,
-  					      255 - (py-i).abs * 255/amplitude,
-  					      j * (255.0/(width+50)))
-  			
-  			fill_gap.ceil.times do |filler|
-  				set j-filler, py.to_i-filler, c
-  				set j, py.to_i, c
-  				set j+filler, py.to_i+filler, c
-  			end
-  		end
-  	end
-  	
-  end
+def setup
+  size 640, 360
+  background 200  	
+  angle     = 0.0
+  px, py    = 0.0, 0.0
+  amplitude = 30.0
+  frequency = 0.0
+  fill_gap  = 2.5
   
+  (-75 ... height + 75).each do |i|
+    angle = 0.0
+    frequency += 0.002  		
+    (width + 75).times do |j|
+      py = i + sin( angle.radians ) * amplitude
+      angle += frequency  			
+      c = color((py-i).abs * 255 / amplitude,
+        255 - (py-i).abs * 255 / amplitude,
+        j * (255.0 / (width+50)))  			
+      fill_gap.ceil.times do |filler|
+        set j-filler, py.to_i-filler, c
+        set j, py.to_i, c
+        set j+filler, py.to_i+filler, c
+      end
+    end
+  end  	
 end
-
-WaveGradient.new :title => "Wave Gradient", :width => 200, :height => 200