ruby-processing 1.0.2 → 1.0.3

data/samples/processing_app/basics/data/datatype_conversion.rb

@@ -0,0 +1,45 @@
+require 'ruby-processing'
+
+# Processings datatype conversion functions make no sense for Ruby as it does
+# not have primitive datatypes. Try these instead:
+# "to_s" (to String)
+# "to_i" (to Integer, thats a Fixnum or Bignum)
+# "to_f" (to Float, which would be "double" in Processing, not "float")
+# "to_a" (to Array, i.e. from a Range or Hash)
+
+class DatatypeConversion < Processing::App
+
+  def setup
+  	
+  	# Ruby has no primitive datatypes, everything is an object!
+  	# See:
+  	[1, 2.0, 'a', "B", nil, false].each do |element|
+  		puts
+  		puts "#{element.inspect} ... is a #{element.class.name} object"
+  	end
+  	
+  	c = 'A' # String (!) as there is no char datatype in Ruby.
+  			    # Single quotes are parsed without substitutions (i.e. "It is #{Time.now}.")
+  	
+  	f = c[0].to_f # Sets f = 65.0
+  	              # will become "c.ord.to_f" in Ruby 1.9+
+  	
+  	i = (f * 1.4).to_i # Sets i to 91
+  	
+  	b = (c[0] / 2) # Integer or FixNum as there is no byte in Ruby
+  	
+  	background 51
+  	no_stroke
+  	
+  	rect f, 0, 40, 66
+  	
+  	fill 204
+  	rect i, 67, 40, 66
+  	
+  	fill 255
+  	rect b, 134, 40, 66
+  end
+  
+end
+
+DatatypeConversion.new :title => "Datatype Conversion", :width => 200, :height => 200

data/samples/processing_app/basics/data/integers_floats.rb

@@ -0,0 +1,34 @@
+require 'ruby-processing'
+
+# Integers and floats are two different kinds of numerical data. 
+# An integer (more commonly called an int) is a number without 
+# a decimal point. A float is a floating-point number, which means 
+# it is a number that has a decimal place. Floats are used when
+# more precision is needed. 
+
+class IntegersFloats < Processing::App
+
+  def setup
+    stroke 255
+    frame_rate 30
+    
+    @a = 0		# Create an instance variable "a" of class Integer
+    @b = 0.0	# Create an instance variable "b" of class Float (because of "0.0")
+  end
+  
+  def draw
+  	background 51
+  	
+  	@a += 1
+  	@b += 0.2
+  	
+  	line @a, 0,        @a, height/2
+  	line @b, height/2, @b, height
+  	
+  	@a = 0 if @a > width
+  	@b = 0 if @b > width
+  end
+  
+end
+
+IntegersFloats.new :title => "Integers Floats", :width => 200, :height => 200

data/samples/processing_app/basics/data/true_false.rb

@@ -0,0 +1,37 @@
+require 'ruby-processing'
+
+# Boolean data is one bit of information. True or false. 
+# It is common to use Booleans with control statements to 
+# determine the flow of a program. In this example, when the
+# boolean value "x" is true, vertical black lines are drawn and when
+# the boolean value "x" is false, horizontal gray lines are drawn.
+
+# In Ruby, false and nil are "falsy" ... they are the only things
+# that will fail an "if" test. Absolutely everything else passes "if".
+
+class TrueFalse < Processing::App
+
+  def setup
+  	  background 0
+  	  stroke 0
+  	  
+  	  (1..width).step(2) do |i|
+  	    
+  	    x = i < (width/2) # Evaluates to true or false, depending on i
+  	    
+  	    if x
+  	    	stroke 255
+  	    	line i, 1, i, height-1
+  	    end
+  	    
+  	    if !x
+  	    	stroke 126
+  	    	line width/2, i, width-2, i
+  	    end
+  	      
+  	  end
+  end
+  
+end
+
+TrueFalse.new :title => "True False", :width => 200, :height => 200

data/samples/processing_app/basics/data/variable_scope.rb

@@ -0,0 +1,80 @@
+require 'ruby-processing'
+
+# Variables may either have a global or local "scope". 
+# For example, variables declared within either the
+# setup or draw functions may be only used in these
+# functions. Global variables, variables declared outside
+# of setup and draw, may be used anywhere within the program.
+# If a local variable is declared with the same name as a
+# global variable, the program will use the local variable to make 
+# its calculations within the current scope. Variables may be localized
+# within classes, functions, and iterative statements.
+
+# Please note that there are some changes on variable scope inside blocks
+# between Ruby versions 1.8 and 1.9.
+
+class VariableScope < Processing::App
+
+  def setup
+  		background 51
+  		stroke 255
+  		no_loop
+  		
+  		@a = 20 # Use "@" before the name to create an instance variable ("@a"), 
+  				    # which will be available anywhere inside this instance of "VariableScope".
+  end
+  
+  def draw
+  		# Draw a line using the instance variable "a", 
+  		# as returned by its getter function below
+  		line a, 0, a, height
+  		
+  		# Create a new variable "a" local to the block (do-end)
+  		(50..80).step(2) do |a|
+  			line a, 0, a, height
+  		end
+  		
+  		# Create a new variable "a" local to the draw method
+  		a = 100
+  		line a, 0, a, height
+  		
+  		# Make a call to the custom function draw_another_line
+  		draw_another_line
+  		
+  		# Make a call to the custom function draw_yet_another_line
+  		draw_yet_another_line
+  end
+  
+  def draw_another_line
+  		# Create a new variable "a" local to this method
+  		a = 185
+  		
+  		# Draw a line using the local variable "a"
+  		line a, 0, a, height
+  end
+  
+  def draw_yet_another_line
+  		# Because no new local variable "a" is set, this line draws using the 
+  		# instance variable "a" (returned by its getter function) which was 
+  		# set to the value 20 in setup.
+  		line a+2, 0, a+2, height
+  end
+  
+  # This is a "getter" function, it returns the value of the instance variable "a"
+  def a
+  	@a
+  end
+  
+  # Ruby can add that getter function for you automatically:
+  # attr_reader :a
+  
+  # And this would create a setter which will allow you to set "a" to a value ( "a = 123" )
+  # without using that "@" sign all the time:
+  # attr_writer :a
+  
+  # Or you could just have Ruby add both at once with:
+  # attr_accessor :a
+  
+end
+
+VariableScope.new :title => "Variable Scope", :width => 200, :height => 200

data/samples/processing_app/basics/data/variables.rb

@@ -0,0 +1,40 @@
+require 'ruby-processing'
+
+# Variables are used for storing values. In this example, changing 
+# the values of variables @one and @two significantly changes the composition. 
+
+class Variables < Processing::App
+  
+  load_library :control_panel
+  
+  def setup
+    stroke 153
+    
+    @one = 20 # Change these with the sliders
+    @two = 50
+    
+    control_panel do |c|
+      c.slider :one, -20..100
+      c.slider :two, -20..100
+    end
+  end
+
+
+  def draw
+    background 0
+    
+    c = @one * 8
+    d = @one * 9
+    e = @two - @one
+    f = @two * 2
+    g = f  + e
+    
+    line @one, f, @two,  g
+    line @two, e, @two,  g
+    line @two, e, d,     c
+    line @one, e, d-e,   c
+  end
+  
+end
+
+Variables.new :title => "Variables", :width => 200, :height => 200

data/samples/processing_app/basics/form/bezier.rb

@@ -0,0 +1,23 @@
+require 'ruby-processing'
+
+# The first two parameters for the bezier function specify the 
+# first point in the curve and the last two parameters specify 
+# the last point. The middle parameters set the control points
+# that define the shape of the curve. 
+
+class Bezier < Processing::App
+
+  def setup
+    background 0
+    stroke 255
+    no_fill
+    smooth
+    
+    (0..100).step(20) do |i|
+    	bezier 90-(i/2.0), 20+i, 210, 10, 220, 150, 120-(i/8.0), 150+(i/4.0)
+    end
+  end
+  
+end
+
+Bezier.new :title => "Bezier", :width => 200, :height => 200

data/samples/processing_app/basics/form/bezier_ellipse.rb

@@ -0,0 +1,110 @@
+require 'ruby-processing'
+
+# Bezier Ellipse  
+# By Ira Greenberg 
+# 
+# Generates an ellipse using bezier and
+# trig functions. Approximately every 1/2 
+# second a new ellipse is plotted using 
+# random values for control/anchor points.
+
+class BezierEllipse < Processing::App
+
+  # have Ruby add getter/setter functions for these,
+	# so we don't have to write "@var" all the time
+	attr_accessor :px, :py, :cx, :cy, :cx2, :cy2 
+
+  def setup
+  	@color_controls = 0xFF222222
+  	@color_anchors  = 0xFFBBBBBB
+  	
+  	smooth
+  	rect_mode CENTER
+    set_ellipse 4, 65, 65
+    frame_rate 1
+  end
+  
+  def draw
+  	background 145
+  	draw_ellipse
+  	set_ellipse random(3, 12).to_i, random(-100, 150), random(-100, 150)
+  end
+  
+  def draw_ellipse
+  
+  	number_of_points = px.length # all our arrays have same length
+  
+  	# draw shape
+  
+  	stroke_weight 1.125
+  	stroke 255
+  	no_fill
+  	
+  	number_of_points.times do |i|
+  		i2 = (i+1) % number_of_points  # wrap around to make a loop
+		  bezier px[i], py[i], 
+			       cx[i], cy[i], 
+			       cx2[i], cy2[i], 
+			       px[i2], py[i2]
+  	end
+  	  	
+  	# draw lines and handles
+  	
+  	stroke_weight 0.75
+  	stroke 0
+  	
+  	number_of_points.times do |i|
+  		i2 = (i+1) % number_of_points
+  		line px[i], py[i], cx[i], cy[i]      # anchor to control 1
+  		line cx2[i], cy2[i], px[i2], py[i2]  # control 2 to next anchor
+  	end
+  	
+  	number_of_points.times do |i|
+  		fill @color_controls
+  		no_stroke
+  		
+  		ellipse cx[i], cy[i], 4, 4
+  		ellipse cx2[i], cy2[i], 4, 4
+  		
+  		fill @color_anchors
+  		stroke 0
+  		
+  		rect px[i], py[i], 5, 5
+  	end
+  end
+  
+  def set_ellipse( points, radius, control_radius )
+  
+	# first time we come here the instance variables are created
+	# therefore we need to use "@" or "self.". the former will access the variable
+	# directly the later will use the setter function created by "attr_accessor".
+  	@px , self.py , @cx , @cy , @cx2 , @cy2 = [], [], [], [], [], [] 
+
+  	angle = 360.0/points
+  	control_angle_1 = angle/3.0
+  	control_angle_2 = control_angle_1*2.0
+  	points.times do |i|
+  		px[i] = width/2+cos(angle.radians)*radius
+  		
+    	py[i] = height/2+sin(angle.radians)*radius
+    	
+    	cx[i] = width/2+cos((angle+control_angle_1).radians)* 
+      			control_radius/cos((control_angle_1).radians)
+      			
+    	cy[i] = height/2+sin((angle+control_angle_1).radians)* 
+      			control_radius/cos((control_angle_1).radians)
+      			
+    	cx2[i] = width/2+cos((angle+control_angle_2).radians)* 
+      			control_radius/cos((control_angle_1).radians)
+      			
+    	cy2[i] = height/2+sin((angle+control_angle_2).radians)* 
+      			control_radius/cos((control_angle_1).radians)
+
+    	#increment angle so trig functions keep chugging along
+    	angle += 360.0/points
+  	end
+  end
+  
+end
+
+BezierEllipse.new :title => "Bezier Ellipse", :width => 200, :height => 200

data/samples/processing_app/basics/form/pie_chart.rb

@@ -0,0 +1,31 @@
+require 'ruby-processing'
+
+# Pie Chart  
+# By Ira Greenberg 
+# 
+# Uses the arc() function to generate a pie chart from the data
+# stored in an array.
+
+class PieChart < Processing::App
+
+  def setup
+    background 100
+    smooth
+    no_stroke
+    
+    diameter = 150
+    angles = [30, 10, 45, 35 ,60, 38, 75, 67]
+    last_angle = 0.0
+    
+    angles.each do |angle|
+    	fill angle * 3.0
+    	arc width/2, height/2, 	 						    # center x, y
+    		diameter, diameter,  						      # width, height
+    		last_angle, last_angle + radians(angle)	# angles from, to
+    	last_angle += radians(angle)
+    end
+  end
+  
+end
+
+PieChart.new :title => "Pie Chart", :width => 200, :height => 200

data/samples/processing_app/basics/form/points_lines.rb

@@ -0,0 +1,37 @@
+require 'ruby-processing'
+
+# Constructing a simple dimensional form with lines and rectangles.
+# Changing the value of the variable 'd' scales the image.
+# The four variables set the positions based on the value of 'd'. 
+ 
+class PointsLines < Processing::App
+
+  def setup
+	d = 40
+	p1 = d
+	p2 = p1+d
+	p3 = p2+d
+	p4 = p3+d
+
+	background 0
+
+	# Draw gray box
+	stroke 153 
+	line p3, p3, p2, p3 
+	line p2, p3, p2, p2 
+	line p2, p2, p3, p2 
+	line p3, p2, p3, p3 
+
+	# Draw white points
+	stroke 255 
+	point p1, p1 
+	point p1, p3  
+	point p2, p4 
+	point p3, p1  
+	point p4, p2 
+	point p4, p4
+  end
+  
+end
+
+PointsLines.new :title => "Points Lines", :width => 200, :height => 200