ruby-processing 1.0.2 → 1.0.3

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

@@ -0,0 +1,43 @@
+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
+    no_stroke
+    background 0
+    
+    c = load_image "cait.jpg"
+    
+    xoff, yoff = 0, 0
+    p = 2
+    pix = p * 3
+    
+    (c.width * c.height).times do |i|
+    	
+    	pixel = c.pixels[i]
+    	
+    	fill red( pixel ), 0, 0
+    	rect xoff, yoff, p, pix
+    	
+    	fill 0, green( pixel ), 0
+    	rect xoff+p, yoff, p, pix
+    	
+    	fill 0, 0, blue( pixel )
+    	rect xoff+p*2, yoff, p, pix
+    	
+    	xoff += pix
+    	if xoff >= (width-pix)
+    		xoff = 0
+    		yoff += pix
+    	end
+    end
+    
+  end
+  
+end
+
+Reading.new :title => "Reading", :width => 200, :height => 200

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

@@ -0,0 +1,38 @@
+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
+  
+end
+
+Relativity.new :title => "Relativity", :width => 200, :height => 200

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

@@ -0,0 +1,35 @@
+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
+  
+    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
+  
+end
+
+Saturation.new :title => "Saturation", :width => 200, :height => 200

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

@@ -0,0 +1,45 @@
+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
+  
+end
+
+WaveGradient.new :title => "Wave Gradient", :width => 200, :height => 200

data/samples/processing_app/basics/control/conditionals1.rb

@@ -0,0 +1,51 @@
+require 'ruby-processing'
+
+# Conditions are like questions. 
+# They allow a program to decide to take one action if 
+# the answer to a question is true or to do another action
+# if the answer to the question is false. 
+# The questions asked within a program are always logical
+# or relational statements. For example, if the variable 'i' is 
+# equal to zero then draw a line.
+
+class Conditionals1 < Processing::App
+
+  def setup
+  	background 0
+    
+    1.upto( width / 10 ) do |i|
+    	# If 'i' is even then draw the first line otherwise draw the second line
+  		i.even? ? draw_short(i) : draw_long(i)
+    end
+  end
+  
+  def draw_short(i)
+    stroke 153
+    line i*10, 40, i*10, height/2
+  end
+  	
+  def draw_long(i)
+    stroke 102
+    line i*10, 20, i*10, 180
+  end
+  
+end
+
+# Ruby allows us to extend base classes, such as numbers, with
+# methods of our choosing. In this case we'll add methods that tell
+# you whether a given integer is even or odd.
+
+class Fixnum
+  
+  def even?
+    self % 2 == 0
+  end
+  
+  def odd?
+    !even?
+  end
+  
+end
+  
+
+Conditionals1.new :title => "Conditionals1", :width => 200, :height => 200

data/samples/processing_app/basics/control/conditionals2.rb

@@ -0,0 +1,44 @@
+require 'ruby-processing'
+
+# We extend the language of conditionals by adding the 
+# keyword "elsif". This allows conditionals to ask 
+# two or more sequential questions, each with a different
+# action. 
+
+class Conditionals2 < Processing::App
+
+  def setup
+  
+  	background 0
+  	
+  	1.upto( width / 2 ) do |i|
+  	
+  		# If 'i' divides by 10 with no remainder 
+  		# draw the first line .. 
+  		# else if 'i' devides by 5 with no remainder 
+  		# draw second line else draw third
+  		
+  		if (i % 10) == 0
+  		
+  			stroke 255
+  			line i*2, 40, i*2, height/2
+  		
+  		elsif (i % 5) == 0
+  		
+  			stroke 153
+  			line i*2, 20, i*2, 180
+  			
+  		else
+  		
+  			stroke 102
+  			line i*2, height/2, i*2, height-40
+  			
+  		end
+  		
+  	end
+    
+  end
+  
+end
+
+Conditionals2.new :title => "Conditionals2", :width => 200, :height => 200

data/samples/processing_app/basics/control/embedded_iteration.rb

@@ -0,0 +1,42 @@
+require 'ruby-processing'
+
+# Embedding "for" structures allows repetition in two dimensions. 
+
+class EmbeddedIteration < Processing::App
+
+  def setup
+    
+    background 0
+    no_stroke
+    
+    box_size = 11.0
+    box_space = 12.0
+    margin = 7
+    
+    # Draw gray boxes 
+    
+    (margin...height-margin).step(box_space) do |i|
+    # or, if you feel more java-loopy:
+    # i = margin; while i < height-margin
+    	
+    	if box_size > 0
+ 
+    		(margin...width-margin).step(box_space) do |j|
+    		
+    			fill( 255 - box_size * 10 )
+    			rect j, i, box_size, box_size
+    		end
+    		
+    	end
+    	
+    	box_size -= 0.6
+    	
+    	# for java loops, don't forget to increment with while:
+    	# i += box_space
+    end
+    
+  end
+  
+end
+
+EmbeddedIteration.new :title => "Embedded Iteration", :width => 200, :height => 200

data/samples/processing_app/basics/control/iteration.rb

@@ -0,0 +1,61 @@
+require 'ruby-processing'
+
+# Iteration in Ruby differs from that in Processing / Java.
+# Where you'd mainly use for- and while constructs in the later
+# you'd be using iterators with blocks (do-end, {}) in Ruby.
+
+class Iteration < Processing::App
+
+  def setup
+  	background 102
+  	no_stroke
+    
+  	xpos1 = 100
+	  xpos2 = 118 
+	  count = 0
+	  timey = 0
+	  num = 12
+	  
+	  # Draw white bars
+	  
+	  fill 255
+	  k = 60
+	  
+	  (num/3).times do |i|  # Loop using the "times" iterator of a number
+	  	rect 25, k, 155, 5
+	  	k += 10
+	  end
+	  
+	  # Dark grey bars
+	  
+	  fill 51
+	  k = 40
+	  
+	  0.upto( num-1 ) do |i|  # Loop using "upto" of a number
+	  	rect 105, k, 30, 5
+	  	k += 10
+	  end
+	  
+	  k = 15
+	  
+	  arr = (0...num).to_a  # Create an array with increasing numbers from a Range to
+	  
+	  arr.each do |i|  	    # use with the "each" iterator of Array
+	  	rect 125, k, 30, 5
+	  	k += 10
+	  end
+	  
+	  # Thin lines
+	  
+	  fill 0
+	  k = 42
+	  
+	  (0...num-1).step(1) do |i|  # Loop using a Range with its "step" iterator
+	  	rect 36, k, 20, 1
+	  	k += 10
+	  end
+  end
+  
+end
+
+Iteration.new :title => "Iteration", :width => 200, :height => 200

data/samples/processing_app/basics/control/logical_operators.rb

@@ -0,0 +1,59 @@
+require 'ruby-processing'
+
+# The logical operators for AND (&&) and OR (||) are used to 
+# combine simple relational statements into more complex expressions.
+# The NOT (!) operator is used to negate a boolean statement. 
+
+class LogicalOperators < Processing::App
+
+  def setup
+    
+  	background 126
+  	
+  	op = false
+  	
+  	(5..195).step(5) do |i|
+  	
+  		stroke 0
+  		
+  		# Logical AND
+  		
+  		if (i > 35) && (i < 100)
+  			
+  			line 5, i, 95, i
+  			op = false
+  		end
+  		
+  		stroke 76
+  		
+  		# Logical OR
+  		
+  		if (i <= 35) || (i >= 100)
+  			line 105, i, 195, i
+  			op = true
+  		end
+  		
+  		
+		# Testing if a boolean value is "true"
+		# The expression "if op" is equivalent to "if (op == true)"
+  		
+  		if op
+  			stroke 0
+  			point width/2, i
+  		end
+  		
+		# Testing if a boolean value is "false"
+		# The expressions "unless op" or "if !op" are equivalent to "if (op == false)"
+  		
+  		unless op
+  			stroke 255
+  			point width/4, i
+  		end
+  		
+  	end
+    
+  end
+  
+end
+
+LogicalOperators.new :title => "Logical Operators", :width => 200, :height => 200

data/samples/processing_app/basics/data/characters_strings/characters_strings.rb

@@ -0,0 +1,87 @@
+require 'ruby-processing'
+
+#  * Click on the image to give it focus and then type letters to
+#  * shift the location of the image. 
+#  * Characters are typographic symbols such as A, d, and %.  
+#  * The character datatype, abbreviated as char, stores letters and 
+#  * symbols in the Unicode format, a coding system developed to support 
+#  * a variety of world languages. Characters are distinguished from other
+#  * symbols by putting them between single quotes ('P'). 
+#  * A string is a sequence of characters. A string is noted by surrounding 
+#  * a group of letters with double quotes ("Processing"). 
+#  * Chars and strings are most often used with the keyboard methods, 
+#  * to display text to the screen, and to load images or files. 
+
+class CharactersStrings < Processing::App
+
+  def setup
+    
+    render_mode P2D
+    
+    @xoffset = 0
+    @letter = ""
+    
+    @font = load_font "Eureka-90.vlw"
+    text_font @font
+    
+    # Draw text more accurately and efficiently.
+    
+    text_mode SCREEN
+    text_align CENTER
+    
+  	# A String is actually a class with its own methods, some of which are
+  	# featured below.
+  	
+  	name = "rathausFrog"
+  	extension = ".jpg"
+  	
+  	puts "The length of #{name} is #{name.length}." # "puts" is Ruby for "println"
+  	
+  	name = name + extension
+  	puts "The length of #{name} is #{name.length}."
+  	
+  	# The parameter for the loadImage() method must be a string
+  	# This line could also be written "frog = load_image "rathausFrog.jpg"
+
+  	@frog = load_image name
+  end
+  
+  def draw
+  	background 51 # Set background to dark gray
+  	
+  	# Same as "image @frog, @xoffset, 0", but more efficient 
+  	# because no transformations or "tint" or "smooth" are used.
+  	set @xoffset, 0, @frog
+  	
+  	# Draw an X
+  	line 0, 0, width, height 
+  	line 0, height, width, 0
+  	
+  	# Draw the letter to the center of the screen
+  	text @letter, width/2, height/2
+  end
+  
+  def key_pressed
+  	# The variable "key" always contains the value of the most recent key pressed.
+	  # If the key is an upper or lowercase letter between 'A' and 'z'
+	  # the image is shifted to the corresponding value of that key
+	  
+	  if (key >= "A"[0]) and (key <= "z"[0])  # should become "A".ord and "z".ord in Ruby 1.9
+		
+		  # Map the index of the key pressed from the range between 'A' and 'z',
+		  # into a position for the left edge of the image. The maximum xoffset
+		  # is the width of the drawing area minus the size of the image.
+		  
+		  @xoffset = map( key, "A"[0], "z"[0], 0, width - @frog.width ).to_i
+		  
+		  # Update the letter shown to the screen
+		  @letter = key.chr
+		  
+		  # Write the letter to the console
+		  puts key
+	  end
+  end
+  
+end
+
+CharactersStrings.new :title => "Characters Strings", :width => 200, :height => 200