ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/create_shapes/polygon_shape.rb

@@ -0,0 +1,42 @@
+
+#
+# PrimitivePShape. 
+# 
+# Using a PShape to display a custom polygon. 
+#
+
+# The PShape object
+attr_reader :star
+
+def setup
+  size(640, 360, P2D)
+  smooth()
+  # First create the shape
+  @star = create_shape()
+  star.begin_shape()
+  # You can set fill and stroke
+  star.fill(102)
+  star.stroke(255)
+  star.stroke_weight(2)
+  # Here, we are hardcoding a series of vertices
+  star.vertex(0, -50)
+  star.vertex(14, -20)
+  star.vertex(47, -15)
+  star.vertex(23, 7)
+  star.vertex(29, 40)
+  star.vertex(0, 25)
+  star.vertex(-29, 40)
+  star.vertex(-23, 7)
+  star.vertex(-47, -15)
+  star.vertex(-14, -20)
+  star.end_shape(CLOSE)
+end
+
+def draw
+  background(51)
+  # We can use translate to move the PShape
+  translate(mouseX, mouseY)
+  # Display the shape
+  shape(star)
+end
+

data/samples/processing_app/topics/create_shapes/primitive_pshape.rb

@@ -0,0 +1,29 @@
+#
+# PrimitivePShape. 
+# 
+# Using a PShape to display a primitive shape (in this case, ellipse). 
+#
+
+
+# The PShape object
+attr_reader :circle
+
+def setup 
+  size(640, 360, P2D)
+  # Creating the PShape as an ellipse
+  # The corner is -50,-50 so that the center is at 0,0 
+  @circle = create_shape(ELLIPSE, -50, -25, 100, 50)
+end
+
+def draw
+  background(51)
+  # We can dynamically set the stroke and fill of the shape
+  circle.set_stroke(color(255))  
+  circle.set_stroke_weight(4)
+  circle.set_fill(color(map(mouseX, 0, width, 0, 255)))
+  # We can use translate to move the PShape
+  translate(mouse_x, mouse_y)
+  # Drawing the PShape
+  shape(circle)
+end
+

data/samples/processing_app/topics/create_shapes/wiggle_pshape.rb

@@ -0,0 +1,22 @@
+#
+# WigglePShape. 
+# 
+# How to move the individual vertices of a PShape
+#
+
+load_library 'wiggler'
+
+attr_reader :wiggler
+
+def setup
+  size(640, 360, P2D)
+  @wiggler = Wiggler.new width, height
+end
+
+def draw
+  background(255)
+  wiggler.display
+  wiggler.wiggle
+end
+
+

data/samples/processing_app/topics/drawing/continuous_lines.rb

@@ -0,0 +1,17 @@
+#
+# Continuous Lines. 
+# 
+# Click and drag the mouse to draw a line. 
+#
+
+def setup
+  size(640, 360)
+  background(102)
+end
+
+def draw
+  stroke(255)
+  if mouse_pressed?
+    line(mouse_x, mouse_y, pmouse_x, pmouse_y)
+  end
+end

data/samples/processing_app/topics/drawing/pattern.rb

@@ -0,0 +1,30 @@
+#
+# Patterns. 
+# 
+# Move the cursor over the image to draw with a software tool 
+# which responds to the speed of the mouse. 
+#
+ 
+def setup
+  size(640, 360)
+  background(102)
+end
+
+def draw
+  # Call the variable_ellipse method and send it the
+  # parameters for the current mouse position
+  # and the previous mouse position
+  variable_ellipse(mouse_x, mouse_y, pmouse_x, pmouse_y)
+end
+
+
+# The simple method variable_ellipse was created specifically 
+# for this program. It calculates the speed of the mouse
+# and draws a small ellipse if the mouse is moving slowly
+# and draws a large ellipse if the mouse is moving quickly 
+
+def variable_ellipse(x, y, px, py)
+  speed = (x - px).abs + (y - py).abs
+  stroke(speed)
+  ellipse(x, y, speed, speed)
+end

data/samples/processing_app/topics/drawing/pulses.rb

@@ -0,0 +1,33 @@
+#
+# Pulses. 
+# 
+# Software drawing instruments can follow a rhythm or abide by rules independent
+# of drawn gestures. This is a form of collaborative drawing in which the draftsperson
+# controls some aspects of the image and the software controls others.
+#
+
+attr_reader :angle
+
+def setup
+  size(640, 360)
+  background(102)
+  noStroke
+  fill(0, 102)
+  @angle = 0
+end
+
+def draw
+  # Draw only when mouse is pressed
+  if mouse_pressed?
+    @angle += 5
+    val = cos(radians(angle)) * 12.0
+    (0 ... 360).step(75) do |a|
+      xoff = cos(radians(a)) * val
+      yoff = sin(radians(a)) * val
+      fill(0)
+      ellipse(mouse_x + xoff, mouse_y + yoff, val, val)
+    end
+    fill(255)
+    ellipse(mouse_x, mouse_y, 2, 2)
+  end
+end

data/samples/processing_app/topics/drawing/scribble_plotter.rb

@@ -0,0 +1,77 @@
+#
+# Scribble Plotter  
+# by Ira Greenberg. 
+# 
+# Using 2-dimensional arrays, record end points
+# and replot scribbles between points. 
+#
+
+SCRIBBLE = 0
+HATCHING = 1
+attr_reader :xy
+
+def setup
+  size(640, 360)
+  background(0)
+  
+  
+  # Record points
+  # X positions 
+  x = [125, 475, 475, 125]
+  # Y positions
+  y = [100, 100, 260, 260]
+  @xy = [x, y]
+  
+  # Call plotting function
+  make_rect(xy)
+end
+
+def make_rect(pts)
+  stroke(255)
+  
+  # Scribble variables, that get passed as arguments to the scribble function
+  steps = 100
+  scrib_val = 3.0
+  (0 ... xy.length).each do |i| 
+    # Plots vertices
+    stroke_weight(5)
+    point(pts[0][i], pts[1][i])
+    
+    # Call scribble function
+    stroke_weight(0.5)
+    if (i > 0) 
+      scribble(pts[0][i], pts[1][i], pts[0][i-1], pts[1][i-1], steps, scrib_val, SCRIBBLE)
+    end
+    if (i == pts[0].length-1)
+      # Show some hatching between last 2 points
+      scribble(pts[0][i], pts[1][i], pts[0][0], pts[1][0], steps, scrib_val*2, HATCHING)
+    end
+  end
+end
+
+
+# Scribble function plots lines between end points, 
+# determined by steps and scrib_val arguments.
+# two styles are available: SCRIBBLE and HATCHING, which
+# are interestingly only dependent on parentheses
+# placement in the line function calls.
+
+
+def scribble(x1, y1, x2, y2, steps, scrib_val, style)
+  
+  x_step = (x2-x1) / steps
+  y_step = (y2-y1) / steps
+  (0 ... steps).each do |i|
+    if(style == SCRIBBLE)
+      if (i < steps-1)
+        line(x1, y1, x1 += x_step+rand(-scrib_val .. scrib_val), y1 += y_step + rand(-scrib_val .. scrib_val))      
+      else
+        # extra line needed to attach line back to point- not necessary in HATCHING style
+        line(x1, y1, x2, y2)
+      end
+    elsif (style == HATCHING)
+      line(x1, y1, (x1 += x_step)+rand(-scrib_val .. scrib_val), (y1 += y_step) + rand(-scrib_val .. scrib_val))
+    end
+  end
+end
+

data/samples/processing_app/topics/effects/lens.rb

@@ -13,84 +13,82 @@ require 'ruby-processing'
 # destination look like a lens is beeing held over the source 
 # picture. Based on lens formula by on Abe Racadabra.
 
-class Lens < Processing::App
 
-  def setup
-    render_mode P2D
-    @lens_d            = 160
-    @lens_list         = []
-    @xx, @yy, @dx, @dy = 0, 0, 3, 3
-    
-    # Create buffered image for lens effect.
-    @lens_effect = create_graphics(width, height, P2D)
-    
-    # Load background image.
-    @lens_effect.begin_draw
-    @lens_effect.image(load_image('red_smoke.jpg'), 0, 0, width, height)
-    @lens_effect.end_draw
-    image(@lens_effect, 0, 0, width, height)
-    
-    # Create buffered image for warping.
-    @lens_image  = create_graphics(@lens_d, @lens_d, P2D)
-    @lens_image2 = create_graphics(@lens_d, @lens_d, P2D)
-    
-    compute_lens_transformation
-  end
+
+def setup
+  size 640, 300, P3D
+  @lens_d            = 160
+  @lens_list         = []
+  @xx, @yy, @dx, @dy = 0, 0, 3, 3
+  
+  # Create buffered image for lens effect.
+  @lens_effect = create_graphics(width, height, P2D)
+  
+  # Load background image.
+  @lens_effect.begin_draw
+  @lens_effect.image(load_image('red_smoke.jpg'), 0, 0, width, height)
+  @lens_effect.end_draw
+  image(@lens_effect, 0, 0, width, height)
+  
+  # Create buffered image for warping.
+  @lens_image  = create_graphics(@lens_d, @lens_d, P2D)
+  @lens_image2 = create_graphics(@lens_d, @lens_d, P2D)
   
-  def compute_lens_transformation
-    mag_factor = 40
-    m, a, b    = 0, 0, 0
-    r          = @lens_d / 2
-    s          = sqrt(r*r - mag_factor*mag_factor)
-    
-    for y in (-r...r)
-      for x in (-r..r)
-        if (x*x + y*y >= s*s)
-          a, b = x, y
-        else
-          z = sqrt(r*r - x*x - y*y)
-          a = (x * mag_factor / z + 0.5).to_i
-          b = (y * mag_factor / z + 0.5).to_i
-        end
-        @lens_list[(y+r) * @lens_d + (x+r)] = (b+r) * @lens_d + (a+r)
+  compute_lens_transformation
+end
+
+def compute_lens_transformation
+  mag_factor = 40
+  m, a, b    = 0, 0, 0
+  r          = @lens_d / 2
+  s          = sqrt(r*r - mag_factor*mag_factor)
+  
+  for y in (-r...r)
+    for x in (-r..r)
+      if (x*x + y*y >= s*s)
+        a, b = x, y
+      else
+        z = sqrt(r*r - x*x - y*y)
+        a = (x * mag_factor / z + 0.5).to_i
+        b = (y * mag_factor / z + 0.5).to_i
       end
+      @lens_list[(y+r) * @lens_d + (x+r)] = (b+r) * @lens_d + (a+r)
     end
   end
+end
+
+def bounce_lens
+  @dx = -@dx if (@xx+@dx+@lens_d > @lens_effect.width)  || (@xx+@dx < 0)
+  @dy = -@dy if (@yy+@dy+@lens_d > @lens_effect.height) || (@yy+@dy < 0)
+end
+
+def move_lens
+  @xx += @dx
+  @yy += @dy
+end
+
+def draw
+  bounce_lens
+  move_lens
   
-  def bounce_lens
-    @dx = -@dx if (@xx+@dx+@lens_d > @lens_effect.width)  || (@xx+@dx < 0)
-    @dy = -@dy if (@yy+@dy+@lens_d > @lens_effect.height) || (@yy+@dy < 0)
-  end
+  # Save the background of image at the coordinate where the
+  # lens effect will be applied.
+  @lens_image2.copy(@lens_effect, @xx, @yy, @lens_d, @lens_d, 0, 0, @lens_d, @lens_d)
   
-  def move_lens
-    @xx += @dx
-    @yy += @dy
-  end
+  # Output into a buffered image for reuse.
+  @lens_image.load_pixels
   
-  def draw
-    bounce_lens
-    move_lens
-        
-    # Save the background of image at the coordinate where the
-    # lens effect will be applied.
-    @lens_image2.copy(@lens_effect, @xx, @yy, @lens_d, @lens_d, 0, 0, @lens_d, @lens_d)
-    
-    # Output into a buffered image for reuse.
-    @lens_image.load_pixels
-    
-    # For each pixel in the destination, apply the color from the 
-    # appropriate pixel in the saved background. The @lens_list array
-    # tells us the appropriate offset.
-    # This inner loop has been optimized a bit.
-    px, px2  = @lens_image.pixels, @lens_image2.pixels
-    list     = @lens_list
-    px.length.times {|i| px[i] = px2[list[i]] }
-    @lens_image.update_pixels
-    
-    # Overlay the lens
-    image(@lens_image, @xx, @yy, @lens_d, @lens_d)
-  end
+  # For each pixel in the destination, apply the color from the 
+  # appropriate pixel in the saved background. The @lens_list array
+  # tells us the appropriate offset.
+  # This inner loop has been optimized a bit.
+  px, px2  = @lens_image.pixels, @lens_image2.pixels
+  list     = @lens_list
+  px.length.times {|i| px[i] = px2[list[i]] }
+  @lens_image.update_pixels
   
+  # Overlay the lens
+  image(@lens_image, @xx, @yy, @lens_d, @lens_d)
 end
 
-Lens.new :title => "Lens", :width => 640, :height => 360
+

data/samples/processing_app/topics/file_io/data/positions.txt

@@ -0,0 +1,206 @@
+70	35
+69	35
+68	39
+67	42
+66	47
+64	51
+64	54
+63	57
+60	60
+58	64
+51	69
+48	72
+44	73
+39	75
+35	75
+30	75
+25	75
+21	75
+17	73
+13	69
+12	66
+11	61
+11	57
+10	49
+10	45
+10	38
+12	32
+13	29
+16	23
+20	19
+24	16
+27	15
+31	13
+33	13
+37	13
+40	15
+42	16
+45	19
+46	21
+47	24
+48	26
+48	29
+48	33
+47	39
+43	45
+42	47
+38	50
+35	51
+32	51
+30	51
+27	50
+27	50
+26	46
+26	41
+29	36
+30	34
+31	33
+31	33
+32	33
+33	33
+34	33
+34	33
+35	33
+37	33
+39	33
+42	32
+44	31
+46	29
+48	29
+49	27
+52	24
+53	23
+57	19
+61	16
+63	14
+67	13
+69	12
+69	12
+77	11
+77	11
+80	11
+86	16
+90	21
+93	25
+95	29
+95	32
+95	33
+95	37
+94	41
+93	44
+92	46
+91	49
+89	51
+87	55
+85	59
+82	62
+80	64
+79	67
+77	69
+74	71
+68	72
+65	73
+63	73
+62	73
+60	72
+58	69
+57	67
+57	66
+56	60
+56	56
+56	54
+58	49
+60	47
+62	47
+63	47
+67	48
+70	52
+73	55
+74	57
+74	58
+74	60
+74	62
+73	65
+70	68
+67	69
+65	70
+63	70
+62	70
+60	68
+57	65
+55	64
+50	62
+46	61
+40	60
+38	60
+36	60
+32	61
+30	62
+27	64
+26	68
+25	71
+25	77
+25	81
+26	84
+28	86
+31	87
+33	88
+36	88
+39	86
+41	85
+43	83
+44	81
+45	76
+45	74
+45	71
+40	67
+37	65
+34	63
+33	61
+33	61
+32	60
+33	49
+37	45
+41	41
+45	39
+47	38
+51	37
+54	37
+58	38
+61	41
+63	44
+65	46
+66	49
+66	51
+67	55
+67	58
+67	60
+66	62
+64	65
+63	66
+61	67
+60	68
+58	68
+55	69
+54	69
+51	69
+48	69
+46	68
+45	66
+44	65
+44	63
+44	61
+44	59
+44	56
+44	55
+45	53
+47	52
+49	50
+50	48
+51	47
+52	46
+54	46
+55	45
+55	45
+56	44
+57	44