ruby-processing 2.6.3 → 2.6.4

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

@@ -1,48 +0,0 @@
-# Creating Colors (Homage to Albers). 
-# 
-# Creating variables for colors that may be referred to 
-# in the program by their name, rather than a number. 
-
-
-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 = color '#CC6600'
-	# yellower = color '#CC9900'
-	# orangish = color '#993300'
-	
-	# or alternatively
-	
-	# redder = color 0xFFCC6600
-	# yellower = color 0xFFCC9900
-	# orangish = color 0xFF993300
-	
-	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
-

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

@@ -1,23 +0,0 @@
-# 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. 
-
-
-def setup
-  size 640, 360  
-  @bar_width = 20
-  @hue = Array.new( (width/@bar_width), 0 )    
-  color_mode HSB, height
-  no_stroke
-  background 0
-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

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

@@ -1,42 +0,0 @@
-# Simple Linear Gradient 
-# 
-# The lerp_color function is useful for interpolating
-# between two colors.
-#
- 
-Y_AXIS = 1
-X_AXIS = 2
-
-def setup
-  size 640, 360  
-  # Define colors
-  b1 = color(255)
-  b2 = color(0)
-  c1 = color(204, 102, 0)
-  c2 = color(0, 102, 153)
-
-  # 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
-

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

@@ -1,44 +0,0 @@
-# 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
-
-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(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))
-      stroke c
-      ellipse x, y, r*2, r*2
-    end
-  end
-  
-

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

@@ -1,29 +0,0 @@
-# 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. 
-
-
-def setup
-  size 200, 200  
-  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
-

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

@@ -1,25 +0,0 @@
-# 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. 
-
-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
-
-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,24 +0,0 @@
-
-# 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. 
-
-def setup
-  size 640, 360
-  color_mode HSB, 360
-  no_stroke    
-  @bar_width = 20
-  @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
-

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

@@ -1,34 +0,0 @@
-
-
-# Wave Gradient 
-# by Ira Greenberg.  
-# 
-# Generate a gradient along a sin() wave.
-
-
-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

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

@@ -1,27 +0,0 @@
-# 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
-# "even" then draw short line, else draw a long one.
-
-
-def setup
-  size 640, 360
-  background 0
-  stroke_weight 8
-  (5 ... width/2).step(5) do |i|
-    i.even? ? draw_short(i) : draw_long(i)
-  end
-end
-
-def draw_short(i)
-  stroke 255
-  line i * 2, 80, i * 2, height/2
-end
-
-def draw_long(i)
-  stroke 153
-  line i * 2, 20, i * 2, 180
-end

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

@@ -1,39 +0,0 @@
-
-
-# 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. 
-
-
-def setup
-  size 640, 360
-  background 0  	
-  (2 ... width - 2 ).step(2) do |i|
-    
-    # If 'i' divides by 20 with no remainder 
-    # draw the first line..
-    # else if 'i' divides by 10 with no remainder 
-    # draw second line, else draw third line
-    
-    if (i % 20) == 0
-      
-      stroke 255
-      line i, 80, i, height/2
-      
-    elsif (i % 10) == 0
-      
-      stroke 153
-      line i, 20, i, 180
-      
-    else
-      
-      stroke 102
-      line i, height/2, i, height-20
-      
-    end
-    
-  end
-  
-end
-

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

@@ -1,34 +0,0 @@
-# Embedding "for" structures allows repetition in two dimensions. 
-
-def setup
-  size 640, 360
-  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.3
-    
-    # for java loops, don't forget to increment with while:
-    # i += box_space
-  end
-  
-end

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

@@ -1,50 +0,0 @@
-# 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.
-
-def setup
-  size 640, 360  
-  background 102
-  no_stroke
-
-  num = 14
-  
-  # Draw white bars
-  
-  fill 255
-  k = 60
-  
-  (num/3).times do |i|  # Loop using the "times" iterator of a number
-    rect 40, k, 475, 10
-    k += 20
-	end
-	
-	# Dark grey bars
-	
-	fill 51
-	k = 40
-	
-	0.upto( num-1 ) do |i|  # Loop using "upto" of a number
-	  rect 405, k, 30, 10
-	  k += 20
-	end
-	
-	k = 50
-	
-	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 425, k, 30, 10
-	  k += 20
-	end
-	
-	# Thin lines
-	
-	fill 0
-	k = 45
-	
-	(0...num-1).step(1) do |i|  # Loop using a Range with its "step" iterator
-	  rect 120, k, 40, 1
-	  k += 20
-	end
-end

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

@@ -1,56 +0,0 @@
-# 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. 
-
-
-def setup
-  
-  size 640, 360  
-  background 156
-  
-  op = false
-  
-  (5...width).step(5) do |i|
-    
-    stroke 0
-    
-    # Logical AND
-    
-    if (i > 35) && (i < 100)
-      
-      line width / 4, i, width / 2, i
-      op = false
-    end
-    
-    stroke 76
-    
-    # Logical OR
-    
-    if (i <= 35) || (i >= 100)
-      line width / 2, i, width, i
-      op = true
-    end
-    
-    
-		# Testing if a boolean value is "true"
-		# The expression "if op" is equivalent to "if (op == true)"
-		
-		if op
-		  stroke_weight 2
-		  stroke 0
-		  point width / 3, 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_weight 3
-		  stroke 255
-		  point width/4, i
-		end
-		stroke_weight 1
-	end
-	
-end
-