Add Henon Explorer

Author: monkstone

basics/objects/library/shapes/circle.rb

@@ -0,0 +1,42 @@
+
+# Learning Processing
+# Daniel Shiffman
+# http://www.learningprocessing.com
+
+# Example 22-2: Polymorphism
+
+# Circle class inherits Processing:Proxy module methods from Shape
+# Inherits all instance variables from parent + adding one using the
+# post_initialize hook method. Use of change_color makes initialization of @c
+# irrelevant, but without example is spoiled.
+require_relative 'shape'
+
+class Circle < Shape
+  
+  attr_reader :c, :x, :y, :r
+
+  def post_initialize(args)
+    # get color :c or default
+    @c = args.fetch(:c, color(rand(255), 100))
+  end
+
+  # Call the parent jiggle, but do some more stuff too
+  def jiggle
+    super
+    # The Circle jiggles both size and location.
+    @r += rand(-1..1.0)
+    @r = r.clamp(0, 100)
+  end
+
+  def display
+    ellipse_mode(CENTER)
+    fill(c)
+    stroke(0)
+    ellipse(x, y, r, r)
+  end
+
+  def run
+    jiggle
+    display
+  end
+end

basics/objects/library/shapes/circle2.rb

@@ -0,0 +1,50 @@
+# Learning Processing
+# Daniel Shiffman
+# http://www.learningprocessing.com
+
+# Example 22-2: Polymorphism
+require_relative 'shape'
+# Circle class inherits Processing:Proxy module methods from Shape
+# Inherits all instance variables from parent + adding one using the
+# post_initialize hook method. Use of change_color makes initilization of @c
+# irrelevant, but without example is spoiled.
+class Circle2 < Shape
+
+  attr_reader :c, :x, :y, :r
+
+  def initialize(x:, y:, r:)
+    super
+  end
+
+  def post_initialize(args)
+    @c = args[:c]          # Also deal with this new instance variable
+  end
+
+  # Call the parent jiggle, but do some more stuff too
+  def jiggle
+    super
+    # The Circle jiggles both size and location.
+    @r += rand(-1..1.0)
+    @r = r.clamp(0, 100)
+  end
+
+  # The change_color function is unique to the Circle class.
+  # @HACK color(COLORS.sample) produces solid color we can add transparency
+  # for these colors (all negative int)
+  def change_color
+    @c = color(COLORS.sample) + (100<<24)
+  end
+
+  def display
+    ellipse_mode(CENTER)
+    fill(c)
+    stroke(0)
+    ellipse(x, y, r, r)
+  end
+
+  def run
+    jiggle
+    change_color
+    display
+  end
+end

basics/objects/library/shapes/shape.rb

@@ -0,0 +1,38 @@
+# Learning Processing
+# Daniel Shiffman
+# http://www.learningprocessing.com
+
+# Example 22-2: Polymorphism
+# class Shape does not require Processing::Proxy but can pass it on to
+# the inheriting classes Square and Circle (NB: change to using run)
+class Shape
+  include Processing::Proxy
+  COLORS = %w(#ff0000 #ffff00 #3333ff #33cc33)
+  attr_reader :x, :y, :r
+
+  def initialize(x:, y:, r:, **opts)
+    @x = x
+    @y = y
+    @r = r
+    post_initialize(opts)
+  end
+
+  def jiggle
+    @x += rand(-1..1.0)
+    @y += rand(-1..1.0)
+  end
+
+  def post_initialize(_args)
+    'not implemented'
+  end
+
+  # A generic shape does not really know how to be displayed.
+  # This will be overridden in the child classes.
+  def display
+    'not implemented'
+  end
+
+  def run
+    'not implemented'
+  end
+end

basics/objects/library/shapes/shapes.rb

@@ -0,0 +1,4 @@
+require_relative 'shape'
+require_relative 'circle'
+require_relative 'circle2'
+require_relative 'square'

basics/objects/library/shapes/square.rb

@@ -0,0 +1,27 @@
+# Learning Processing
+# Daniel Shiffman
+# http://www.learningprocessing.com
+
+# Example 22-2: Polymorphism
+require_relative 'shape'
+# Square class can inherit Processing::Proxy methods from Shape
+# Variables are inherited from the parent.
+# We could also add variables unique to the Square class if we so desire
+# NB: run could be the only visible method
+class Square < Shape
+  # Inherits constructor from parent
+  # Inherits jiggle from parent
+
+  # The square overrides its parent for display.
+  def display
+    rect_mode(CENTER)
+    fill(175)
+    stroke(0)
+    rect(x, y, r, r)
+  end
+  
+  def run
+    jiggle
+    display
+  end
+end

contributed/decagon_grid.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'picrate'
+# Example of a grid of decagons with perlin noise after Lenny Herzog
+class DecagonGrid < Processing::App
+  load_library :pdf
+  NOISE_STRENGTH = 80.0
+  THETA = 36
+  attr_reader :version, :save, :noise_generator
+
+  def setup
+    sketch_title 'Decagon Grid'
+    frame_rate 24
+    @version = 0
+    @save = false
+    @noise_generator = lambda do |x, y, seed|
+      NOISE_STRENGTH * noise(
+        x / 150.0,
+        y / 150.0 + seed * 2,
+        seed
+      ) - 100
+    end
+  end
+
+  def draw
+    begin_record(PDF, data_path("Line_#{version}.pdf")) if save
+    background(255)
+    no_fill
+    stroke(0)
+    stroke_weight(1)
+    grid(height + 100, width + 100, 50, 50) do |cy, cx|
+      begin_shape
+      (0..360).step(THETA) do |angle|
+        x = (DegLut.cos(angle) * 60) + cx
+        y = (DegLut.sin(angle) * 60) + cy
+        noise_value = noise_generator.call(x, y, millis / 5_000.0)
+        x += noise_value
+        y += noise_value
+        vertex(x, y)
+      end
+      end_shape(CLOSE)
+    end
+    return unless save
+
+    end_record
+    @version += 1
+    @save = false
+  end
+
+  def mouse_pressed
+    @save = true
+  end
+
+  def settings
+    size(1000, 1000)
+  end
+end
+
+DecagonGrid.new

contributed/gravitational_attraction.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'picrate'
+# Gravitational Attraction (3D)
+# by Daniel Shiffman.
+# Simulating gravitational attraction
+# G ---> universal gravitational constant
+# m1 --> mass of object #1
+# m2 --> mass of object #2
+# d ---> distance between objects
+# F = (G*m1*m2)/(d*d)
+# For the basics of working with Vec3D, see
+# https://ruby-processing.github.io/PiCrate/classes/vec3d/
+# as well as examples in library/vecmath/vec3d
+
+class GravitationalAttraction3D < Processing::App
+  attr_reader :planets, :sun, :angle
+
+  def setup
+    sketch_title 'Gravitational Attraction (3D)'
+    @planets = (0..10).map do
+      Planet.new(
+        rand(0.15..1.8),
+        rand(-width / 2..width / 2),
+        rand(-height / 2..height / 2),
+        rand(-100..100)
+      )
+    end
+    @sun = Sun.new
+    @angle = 0
+  end
+
+  def draw
+    background(0, 0, 100)
+    # Setup the scene
+    sphere_detail(12)
+    lights
+    translate(width / 2, height / 2)
+    rotate_y(angle)
+    # Display the Sun
+    sun.display(g)
+    # All the Planets
+    planets.each do |planet|
+      # Sun attracts Planets
+      force = sun.attract(planet)
+      planet.apply_force(force)
+      # Update and draw Planets
+      planet.update
+      planet.display(g)
+    end
+    # Rotate around the scene
+    @angle += 0.005
+  end
+
+  def settings
+    size(640, 360, P3D)
+  end
+end
+
+GravitationalAttraction3D.new
+
+# Gravitational Attraction (3D)
+# Daniel Shiffman <http://www.shiffman.net>
+# A class for an orbiting Planet
+class Planet
+
+  attr_reader :position, :velocity, :acceleration, :mass
+
+  def initialize(m, x, y, z)
+    @mass = m
+    @position = Vec3D.new(x, y, z)
+    @velocity = Vec3D.new(1, 0, 0) # Arbitrary starting velocity
+    @acceleration = Vec3D.new
+  end
+
+  # Newton's 2nd Law (F = M*A) applied
+  def apply_force(force)
+    @acceleration += (force / mass)
+  end
+
+  # Our motion algorithm (aka Euler Integration)
+  def update
+    @velocity += acceleration # Velocity changes with acceleration
+    @position += velocity # position changes with velocity
+    @acceleration *= 0
+ end
+
+  # Draw the Planet
+  def display(graphics)
+    graphics.no_stroke
+    graphics.fill(255)
+    graphics.push_matrix
+    graphics.translate(position.x, position.y, position.z)
+    graphics.sphere(mass * 8)
+    graphics.pop_matrix
+  end
+end
+# Gravitational Attraction (3D)
+# Daniel Shiffman <http://www.shiffman.net>
+# A class for an attractive body in our world
+class Sun
+  G = 0.4
+  attr_reader :mass, :position
+
+  def initialize
+    @position = Vec3D.new
+    @mass = 20
+  end
+
+  def attract(other)
+    (position - other.position).tap do |force| # Calculate direction of force
+      # d = force.mag # Distance between objects
+      # Limit the distance to avoid very close or very far objects
+      distance = force.mag.clamp(7.0, 25.0) # clamp available since ruby 2.4
+      # Calculate gravitional force magnitude
+      strength = (G * mass * other.mass) / (distance * distance)
+      force.set_mag(strength) # force vector --> magnitude * direction
+    end
+  end
+
+  # Draw Sun
+  def display(graphics)
+    graphics.no_stroke
+    graphics.fill(200, 200, 0)
+    graphics.push_matrix
+    graphics.translate(position.x, position.y, position.z)
+    graphics.sphere(mass * 2)
+    graphics.pop_matrix
+  end
+end

data/henon_2.0000.jpg.tif

@@ -0,0 +1,40 @@
+#!/usr/bin/env jruby
+
+require 'picrate'
+
+class FeatherFractal < Processing::App
+  A = -0.48
+  B = 0.93
+
+  def settings
+    size(640, 480)
+  end
+
+  def setup
+    background(235, 215, 182)
+    color_mode(HSB, 360, 1.0, 1.0)
+    stroke(0)
+    sketch_title 'Fantastic Feather Fractal'
+    no_loop
+  end
+
+  def draw
+    x = 4.0
+    y = 0.0
+    120_000.times do |i|
+      x1 = B * y + func(x)
+      y = -x + func(x1)
+      x = x1
+      fill(i % 360, 1.0, 1.0)
+      p = 350 + x * 26
+      q = 280 - y * 26
+      circle(p, q, 5)
+    end
+  end
+
+  def func(x)
+    A * x - (1.0 - A) * ((2 * (x**2)) / (1.0 + x**2))
+  end
+end
+
+FeatherFractal.new