ruby-processing 2.4.3 → 2.4.4

data/samples/processing_app/library/vecmath/library/hilbert/hilbert.rb

@@ -35,23 +35,26 @@ end
 ###########################
 class Hilbert
   include Processing::Proxy
-  ADJUSTMENT = [0,  0.5,  1.5,  3.5,  7.5, 15]
   attr_reader :grammar, :axiom, :production, :premis, :rule,
-  :theta, :distance, :phi, :gen
+  :theta, :distance, :phi, :gen, :adj_array
 
-  def initialize(len, gen = 1)
+  def initialize(size: 1.0, gen: 1)
     @axiom = "X"                                           # AXIOM
     @rule = {"X" => "^<XF^<XFX-F^>>XFX&F+>>XFX-F>X->"}     # RULE
     @gen = gen
     @grammar = Grammar.new(axiom, rule) 
     @production = grammar.generate gen
-    @distance = len/(pow(2, gen) - 1)
-    @theta = Math::PI/180 * 90
-    @phi = Math::PI/180 * 90  
+    @distance = size / (gen**2 - 1)
+    @theta = radians 90
+    @phi = radians 90  
+    @adj_array = [0,  0.5,  1.5,  3.5,  7.5, 15].map{|x| Vec3D.new(x * -1, x, x * -1)}
+
   end
 
   def render()    
-    translate( -distance * ADJUSTMENT[gen], distance *  ADJUSTMENT[gen], -distance * ADJUSTMENT[gen])
+    #translate( -distance * ADJUSTMENT[gen], distance *  ADJUSTMENT[gen], -distance * ADJUSTMENT[gen])
+    adj = adj_array[gen] * distance
+    translate(adj.x, adj.y, adj.z)
     fill(0, 75, 152)
     light_specular(204, 204, 204)
     specular(255, 255, 255)
@@ -81,4 +84,4 @@ class Hilbert
     end
   end
 
-end   
+end   

data/samples/processing_app/library/vecmath/library/wiggler/wiggler.rb

@@ -10,12 +10,8 @@ class Wiggler
     @y = height/2 
     @yoff = 0
     # The "original" locations of the vertices make up a circle
-    @original = []
-    (0 ... TAU).step(0.2) do |a|
-      v = Vec2D.from_angle(a)
-      v *= 100
-      original << v
-    end
+
+    @original = (0 ... 5 * TAU).map{|a| Vec2D.from_angle(a * 0.2) * 100}
     
     # Now make the PShape with those vertices
     @s = create_shape
@@ -23,22 +19,18 @@ class Wiggler
     s.fill(127)
     s.stroke(0)
     s.stroke_weight(2)
-    original.each do |v|
-      s.vertex(v.x, v.y)
-    end
+    original.map{ |v| s.vertex(v.x, v.y)}
     s.end_shape(CLOSE)
   end
 
   def wiggle
     @xoff = 0
     # Apply an offset to each vertex
-    (0 ... s.get_vertex_count).each do |i|
+    rad = -> (pos){(Vec2D.from_angle(TAU * noise(xoff, yoff)) * 4) + pos}
+    
+    original.each_with_index do |pos, i| 
       # Calculate a new vertex location based on noise around "original" location
-      pos = original[i]
-      a = TAU*noise(xoff,yoff)
-      r = Vec2D.from_angle(a)
-      r *= 4
-      r += pos
+      r = rad.call(pos)
       # Set the location of each vertex to the new one
       s.set_vertex(i, r.x, r.y)
       # increment perlin noise x value

data/samples/processing_app/library/vecmath/seeking_neural.rb

@@ -0,0 +1,172 @@
+# Based on SeekingNeural example by Daniel Shiffman
+# The Nature of Code
+# http://natureofcode.com
+
+load_library :vecmath
+
+
+module SeekingNeural
+  class Perceptron
+    # Perceptron is created with n weights and learning constant
+    def initialize(n, c)
+      @weights = Array.new(n){ rand(0 .. 1.0) }
+      @c = c
+    end
+    
+    # Function to train the Perceptron
+    # Weights are adjusted based on vehicle's error
+    def train(forces, error)
+      trained = @weights.zip(forces.map{|f| f.to_a}
+        .map{|a, b| (a * error.x + b * error.y) * @c})
+      .map {|w, c| constrain(w + c, 0.0, 1.0)}
+      @weights = trained    
+    end
+    
+    # Give me a steering result
+    def feedforward(forces)
+      # Sum all values
+      forces.zip(@weights).map{|a, b| a * b}.inject(Vec2D.new, :+)
+    end
+  end
+  
+  # Seek
+  # Daniel Shiffman <http://www.shiffman.net>
+  
+  class Vehicle
+    
+    MAX_SPEED = 4
+    MAX_FORCE = 0.1
+    attr_reader :brain, :sz, :location, :targets, :desired  
+    attr_reader :maxforce_squared, :maxspeed_squared
+    
+    def initialize(n, x, y)
+      @brain = Perceptron.new(n, 0.001)
+      @acceleration = Vec2D.new
+      @velocity = Vec2D.new
+      @location = Vec2D.new(x, y)
+      @sz = 6.0
+      @maxspeed_squared = MAX_SPEED * MAX_SPEED
+      @maxforce_squared = MAX_FORCE * MAX_FORCE
+    end
+    
+    # Method to update location
+    def update(width, height)
+      # Update velocity
+      @velocity += @acceleration
+      # Limit speed
+      @velocity.set_mag(MAX_SPEED) {@velocity.mag_squared > maxspeed_squared}
+      @location += @velocity
+      # Reset acceleration to 0 each cycle
+      @acceleration *= 0
+      
+      @location.x = constrain(location.x, 0, width)
+      @location.y = constrain(location.y, 0, height)
+    end
+    
+    def apply_force(force)
+      # We could add mass here if we want A = F / M
+      @acceleration += force
+    end
+    
+    # Here is where the brain processes everything
+    def steer(targets, desired)
+      # Steer towards all targets
+      forces = targets.map{|target| seek(target) }
+      
+      # That array of forces is the input to the brain
+      result = brain.feedforward(forces)
+      
+      # Use the result to steer the vehicle
+      apply_force(result)
+      
+      # Train the brain according to the error
+      error = desired - location
+      brain.train(forces, error)
+    end
+    
+    # A method that calculates a steering force towards a target
+    # STEER = DESIRED MINUS VELOCITY
+    def seek(target)
+      desired = target - location  # A vector pointing from the location to the target
+      
+      # Normalize desired and scale to the maximum speed
+      desired.normalize!
+      desired *= MAX_SPEED
+      # Steering = Desired minus velocity
+      steer = desired - @velocity
+      steer.set_mag(MAX_FORCE) {steer.mag_squared > maxforce_squared} # Limit to a maximum steering force
+      steer
+    end
+    
+    def display
+      
+      # Draw a triangle rotated in the direction of velocity
+      theta = @velocity.heading + Math::PI / 2
+      fill(175)
+      stroke(0)
+      stroke_weight(1)
+      push_matrix
+      translate(location.x, location.y)
+      rotate(theta)
+      begin_shape
+        vertex(0, -sz)
+        vertex(-sz * 0.5, sz)
+        vertex(sz * 0.5, sz)
+      end_shape(CLOSE)
+      pop_matrix
+    end
+  end    
+end
+
+include SeekingNeural
+
+# A Vehicle controlled by a Perceptron
+attr_reader :targets, :desired, :v
+
+
+def setup
+  size(640, 360)
+  # The Vehicle's desired location
+  @desired = Vec2D.new(width/2, height/2)
+  
+  # Create a list of targets
+  make_targets
+  
+  # Create the Vehicle (it has to know about the number of targets
+  # in order to configure its brain)
+  @v = Vehicle.new(targets.size, rand(width), rand(height))
+end
+
+# Make a random ArrayList of targets to steer towards
+def make_targets
+  @targets = Array.new(8) { Vec2D.new(rand(width), rand(height)) }
+end
+
+def draw
+  background(255)
+  
+  # Draw a circle to show the Vehicle's goal
+  stroke(0)
+  stroke_weight(2)
+  fill(0, 100)
+  ellipse(desired.x, desired.y, 36, 36)
+  
+  # Draw the targets
+  targets.each do |target|
+    no_fill
+    stroke(0)
+    stroke_weight(2)
+    ellipse(target.x, target.y, 16, 16)
+    line(target.x, target.y - 16, target.x, target.y + 16)
+    line(target.x - 16, target.y, target.x + 16, target.y)
+  end
+  
+  # Update the Vehicle
+  v.steer(targets, desired)
+  v.update(width, height)
+  v.display
+end
+
+def mouse_pressed
+  make_targets
+end

data/samples/processing_app/topics/animation/animated_sprite.rb

@@ -15,7 +15,7 @@ attr_reader :xpos, :ypos, :animation1, :animation2
 def setup
   size(640, 360)
   background(255, 204, 0)
-  frameRate(24)
+  frame_rate(24)
   @animation1 = Animation.new("PT_Shifty_", 38)
   @animation2 = Animation.new("PT_Teddy_", 60)
   @ypos = height * 0.25
@@ -35,24 +35,21 @@ def draw
   end
 end
 
-class Animation < Array
+class Animation 
   attr_reader :images, :image_count, :frame
   
   def initialize(image_prefix, count)
     @image_count = count
     @frame = 0
-    image_count.times do |i|
-      # using ruby string format in preference to processing nf function
-      self << load_image("%s%04d%s" %  [image_prefix, i, ".gif"])
-    end
+    @images = (0 ... image_count).map{|i| load_image("%s%04d%s" %  [image_prefix, i, ".gif"])}
   end
 
   def display(xpos, ypos)
     @frame = (frame + 1) % image_count
-    image(self[frame], xpos, ypos)
+    image(images[frame], xpos, ypos)
   end
   
   def get_width
-    self[0].width
+    images[0].width
   end
 end

data/samples/processing_app/topics/animation/sequential.rb

@@ -6,7 +6,6 @@
 # Twelve images are loaded and each is displayed individually in a loop. 
 #
 
-
 NUM_FRAMES = 12  # The number of frames in the animation
 attr_reader :frame, :images
     
@@ -35,8 +34,8 @@ def draw
   offset = 0
   (-100 ... width).step(images[0].width) do |i|  
     image(images[(frame+offset) % NUM_FRAMES], i, -20)
-    offset+=2
+    offset += 2
     image(images[(frame+offset) % NUM_FRAMES], i, height/2)
-    offset+=2
+    offset += 2
   end
 end

data/samples/processing_app/topics/create_shapes/library/particle/particle_system.rb

@@ -42,7 +42,7 @@ end
 class Particle
   include Processing::Proxy
   
-  GRAVITY = PVector.new(0, 0.1) 
+  GRAVITY = Vec2D.new(0, 0.1) 
   
   attr_reader :center, :velocity, :lifespan, :s_shape, :part_size, 
   :width, :height, :sprite
@@ -64,7 +64,7 @@ class Particle
     s_shape.end_shape
 
     # Initialize center vector
-    @center = PVector.new 
+    @center = Vec2D.new 
     
     # Set the particle starting location
     rebirth(width/2, height/2)
@@ -74,8 +74,8 @@ class Particle
     theta = rand(-PI .. PI)
     speed = rand(0.5 .. 4)
     # A velocity with random angle and magnitude
-    @velocity = PVector.from_angle(theta)
-    @velocity.mult(speed)
+    @velocity = Vec2D.from_angle(theta)
+    @velocity *= speed
     # Set lifespan
     @lifespan = 255
     # Set location using translate
@@ -83,7 +83,7 @@ class Particle
     s_shape.translate(x, y) 
     
     # Update center vector
-    @center.set(x, y, 0)
+    @center.x, @center.y = x, y
   end
 
   # Is it off the screen, or its lifespan is over?
@@ -96,12 +96,12 @@ class Particle
     # Decrease life
     @lifespan = lifespan - 1
     # Apply gravity
-    velocity.add(GRAVITY)
+    @velocity += GRAVITY 
     s_shape.setTint(color(255, lifespan))
     # Move the particle according to its velocity
     s_shape.translate(velocity.x, velocity.y)
     # and also update the center
-    center.add(velocity)
+    @center += velocity
   end
 end
 

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

@@ -4,7 +4,7 @@
 # For guts of implementation see 'particle' library
 #
 
-load_library 'particle'
+load_libraries :vecmath, :particle
 
 # Particle System object and image
 attr_reader :ps 
@@ -32,7 +32,7 @@ def draw
   # Display frame rate
   fill(255, 0, 255)
   text_size(16)
-  text("Frame rate: #{frame_rate.round(1)}", 10, 20)
+  text("Frame rate: #{format('%.2f', frame_rate)}", 10, 20)
   
 end
 

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

@@ -1,6 +1,7 @@
 #
 # WigglePShape. 
-# 
+# wiggler library uses PVector, see vecmath library
+# examples to see alternative using Vec2D
 # How to move the individual vertices of a PShape
 #
 

data/samples/processing_app/topics/lsystems/koch.rb

@@ -6,7 +6,7 @@
 # Each recursive level is drawn in sequence. 
 #
 
-load_library 'koch'
+load_libraries :koch, :vecmath
 
 attr_reader :k
 

data/samples/processing_app/topics/lsystems/library/koch/koch_fractal.rb

@@ -7,8 +7,8 @@ class KochFractal
   attr_reader :start, :endk, :lines, :count
   
   def initialize width, height
-    @start = PVector.new(0, height - 20)
-    @endk = PVector.new(width, height - 20)  
+    @start = Vec2D.new(0, height - 20)
+    @endk = Vec2D.new(width, height - 20)  
     restart
   end
 
@@ -22,7 +22,7 @@ class KochFractal
   def restart 
     @count = 0      # Reset count
     @lines = []     # Empty the array list
-    lines << KochLine.new(start, endk)  # Add the initial line (from one end PVector to the other)
+    lines << KochLine.new(start, endk)  # Add the initial line (from one end Vector to the other)
   end
   
   def get_count
@@ -47,13 +47,13 @@ class KochFractal
   def iterate(before)
     now = []    # Create empty list
     before.each do |line|
-      # Calculate 5 koch PVectors (done for us by the line object)
+      # Calculate 5 koch Vectors (done for us by the line object)
       a = line.start                 
       b = line.kochleft
       c = line.kochmiddle
       d = line.kochright
       e = line.endk
-      # Make line segments between all the PVectors and add them
+      # Make line segments between all the Vectors and add them
       # Note how we can chain '<<' in ruby, could all be in one line.
       now << KochLine.new(a,b) << KochLine.new(b,c)
       now << KochLine.new(c,d) << KochLine.new(d,e)
@@ -68,18 +68,18 @@ end
 
 # Koch Curve
 # A class to describe one line segment in the fractal
-# Includes methods to calculate mid PVectors along the line according to the Koch algorithm
+# Includes methods to calculate mid Vectors along the line according to the Koch algorithm
 
 class KochLine
   include Processing::Proxy
   # Two PVectors,
-  # a is the "left" PVector and 
-  # b is the "right PVector
+  # a is the "left" Vector and 
+  # b is the "right Vector
   attr_reader :start, :endk
 
   def initialize(start, endk)
-    @start = start.get
-    @endk = endk.get
+    @start = start.dup
+    @endk = endk.dup
   end
 
   def display
@@ -89,28 +89,29 @@ class KochLine
 
   # This is easy, just 1/3 of the way
   def kochleft
-    v = PVector.sub(endk, start)
-    v.div(3)
-    v.add(start)
+    v = endk - start
+    v /= 3.0
+    v += start
     return v
   end    
 
-  # More complicated, have to use a little trig to figure out where this PVector is!
+  # More complicated, have to use a little trig to figure out where this Vector is!
   def kochmiddle
-    v = PVector.sub(endk, start)
-    v.div(3)    
-    p = start.get
-    p.add(v)    
-    v.rotate(-radians(60))
-    p.add(v)    
+    v = endk - start
+    v /= 3.0    
+    p = start.dup
+    p += v  
+    rot = radians(-60)
+    r = Vec2D.new((v.x * cos(rot)) - v.y * sin(rot), (v.x * sin(rot)) + (v.y * cos(rot))) 
+    p += r  
     return p
   end    
 
   # Easy, just 2/3 of the way
   def kochright
-    v = PVector.sub(start, endk)
-    v.div(3)
-    v.add(endk)
+    v = start - endk
+    v /= 3.0
+    v += endk
     return v
   end
 end