move mycelium to demo

Author: monkstone

demo/library/branch/branch.rb

@@ -0,0 +1,75 @@
+require 'forwardable'
+
+# Here we use the PiCrate Vec2D class, and not toxis Vec2D. We avoid using
+# ToxicLibsSupport, by using our own AppRender to translate Vec2D to vertices.
+# Further we use the power of ruby (metaprogramming) to make Branch enumerable
+# and use Forwardable to define which enumerable methods we want to use.
+class Branch
+  include Enumerable
+  extend Forwardable
+  def_delegators(:@children, :<<, :each, :length)
+  # variance angle for growth direction per time step
+  THETA = Math::PI / 6
+  # max segments per branch
+  MAX_LEN = 100
+  # max recursion limit
+  MAX_GEN = 3
+  # branch chance per time step
+  BRANCH_CHANCE = 0.05
+  # branch angle variance
+  BRANCH_THETA = Math::PI / 3
+  attr_reader :position, :dir, :path, :children, :xbound, :speed, :ybound, :app
+
+  def initialize(app, pos, dir, speed)
+    @app = app
+    @position = pos
+    @dir = dir
+    @speed = speed
+    @path = []
+    @children = []
+    @xbound = Boundary.new(0, app.width)
+    @ybound = Boundary.new(0, app.height)
+    path << pos
+  end
+
+  def run
+    grow
+    display
+  end
+
+  private
+
+  # NB: use of both rotate! (changes original) rotate (returns a copy) of Vec2D
+  def grow
+    check_bounds(position + (dir * speed)) if path.length < MAX_LEN
+    @position += (dir * speed)
+    dir.rotate!(rand(-0.5..0.5) * THETA)
+    path << position
+    if (length < MAX_GEN) && (rand < BRANCH_CHANCE)
+      branch_dir = dir.rotate(rand(-0.5..0.5) * BRANCH_THETA)
+      self << Branch.new(app, position.copy, branch_dir, speed * 0.99)
+    end
+    each(&:grow)
+  end
+
+  def display
+    app.begin_shape
+    app.stroke(255)
+    app.no_fill
+    path.each { |vec| vec.to_vertex(app.renderer) }
+    app.end_shape
+    each(&:display)
+  end
+
+  def check_bounds(pos)
+    dir.x *= -1 if xbound.exclude? pos.x
+    dir.y *= -1 if ybound.exclude? pos.y
+  end
+end
+
+# we are looking for excluded values
+Boundary = Struct.new(:lower, :upper) do
+  def exclude?(val)
+    !(lower...upper).cover? val
+  end
+end

demo/library/branch3D/branch3D.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+require_relative './rotator'
+
+class Branch
+  include Enumerable
+  extend Forwardable
+  def_delegators(:@children, :<<, :each, :length)
+  # variance angle for growth direction per time step
+  THETA = Math::PI / 6
+  # max segments per branch
+  MAX_LEN = 100
+  # max recursion limit
+  MAX_GEN = 3
+  # branch chance per time step
+  BRANCH_CHANCE = 0.05
+  # branch angle variance
+  BRANCH_THETA = Math::PI / 4
+  attr_reader :position, :dir, :path, :children, :xbound, :speed, :ybound, :app, :zbound
+
+  def initialize(app, pos, dir, speed)
+    @app = app
+    @position = pos
+    @dir = dir
+    @speed = speed
+    @path = []
+    @children = []
+    @xbound = Boundary.new(-600, 600)
+    @ybound = Boundary.new(-150, 150)
+    @zbound = Boundary.new(-150, 150)
+    path << pos
+  end
+
+  def run
+    grow
+    display
+  end
+
+  private
+
+  def grow
+    check_bounds(position + (dir * speed))
+    @position += (dir * speed)
+    (0..2).each do |axis|
+      Rotate.axis!(axis, dir, rand(-0.5..0.5) * THETA)
+    end
+    path << position
+    if (length < MAX_GEN) && (rand < BRANCH_CHANCE)
+      branch_dir = dir.copy
+      (0..2).each do |axis|
+        Rotate.axis!(axis, branch_dir, rand(-0.5..0.5) * BRANCH_THETA)
+      end
+      self << Branch.new(app, position.copy, branch_dir, speed * 0.99)
+    end
+    each(&:grow)
+  end
+
+  def display
+    app.begin_shape
+    app.stroke 255
+    app.stroke_weight 0.5
+    app.no_fill
+    path.each { |vec| vec.to_vertex(app.renderer) }
+    app.end_shape
+    each(&:display)
+  end
+
+  def check_bounds(pos)
+    dir.x *= -1 if xbound.exclude? pos.x
+    dir.y *= -1 if ybound.exclude? pos.y
+    dir.z *= -1 if zbound.exclude? pos.z
+  end
+end
+
+# we are looking for excluded values
+Boundary = Struct.new(:lower, :upper) do
+  def exclude?(val)
+    true unless (lower...upper).cover? val
+  end
+end

demo/library/branch3D/rotator.rb

@@ -0,0 +1,23 @@
+# Rotator module is required because rotate is not implemented for
+# PiCrate 3D. Here we use Vec2D.rotate! to do Euclid rotation about an
+# axis (we can then apply the rotation to each axis in turn)
+# NB: we use quaternions in ArcBall (to avoid gimbal lock)
+module Rotate
+  def self.axis!(axis, vec, theta)
+    array = vec.to_a
+    array.slice! axis
+    other = Vec2D.new(*array).rotate! theta
+    case axis
+    when 0 # xaxis
+      vec.y = other.x
+      vec.z = other.y
+    when 1 # yaxis
+      vec.x = other.x
+      vec.z = other.y
+    else # zaxis, by default
+      vec.x = other.x
+      vec.y = other.y
+    end
+    vec
+  end
+end

demo/mycelium.rb

@@ -0,0 +1,32 @@
+require 'picrate'
+
+# Simple recursive branching system inspired by mycelium growth
+# After an original by Karsten Schmidt
+# The vanilla processing sketch was part of the SAC 2013 workshop project
+# translated to PiCrate by Martin Prout 2018
+class Mycelium < Processing::App
+  load_library :branch
+
+  attr_reader :renderer, :root
+
+  def setup
+    @renderer = AppRender.new(self)
+    @root = Branch.new(
+      self,
+      Vec2D.new(0, height / 2),
+      Vec2D.new(1, 0),
+      10.0
+    )
+  end
+
+  def draw
+    background(0)
+    root.run
+  end
+
+  def settings
+    full_screen
+  end
+end
+
+Mycelium.new

demo/mycelium_box.rb

@@ -0,0 +1,38 @@
+require 'picrate'
+require 'arcball'
+# Simple recursive branching system inspired by mycelium growth
+# After an original by Karsten Schmidt
+# The vanilla processing sketch was part of the SAC 2013 workshop project
+# translated to PiCrate by Martin Prout 2018
+class MyceliumBox < Processing::App
+  load_library :branch3D
+
+  attr_reader :renderer, :root
+
+  def setup
+    sketch_title 'Mycelium Box'
+    Processing::ArcBall.init self
+    @renderer = AppRender.new(self)
+    @root = Branch.new(
+      self,
+      Vec3D.new(0, 10, 10),
+      Vec3D.new(1, 0, 0),
+      6.0
+    )
+  end
+
+  def draw
+    background(0)
+    no_fill
+    stroke_weight 2
+    stroke(200, 0, 0, 100)
+    box(1200, 300, 300)
+    root.run
+  end
+
+  def settings
+    size(1280, 600, P3D)
+  end
+end
+
+MyceliumBox.new

demo/recursive_pentagon.rb

@@ -0,0 +1,90 @@
+require 'picrate'# After an openprocessing sketch by C.Andrews
+class RecursivePentagons < Processing::App
+  attr_reader :strut_factor, :renderer
+
+  def setup
+    sketch_title 'Recursive Pentagons'
+    @strut_factor = 0.2
+    @renderer = AppRender.new self # so we can send Vec2D :to_vertex
+    background(255)
+    no_loop
+  end
+
+  def draw
+    translate(width / 2, height / 2)
+    angle = TWO_PI / 5
+    radius = width / 2
+    points = (0...5).map do |i|
+      x = radius * cos(angle * i)
+      y = radius * sin(angle * i)
+      Vec2D.new(x, y)
+    end
+    fractal = Pentagon.new(points, 4)
+    fractal.draw
+  end
+
+  def settings
+    size(800, 800)
+  end
+end
+
+RecursivePentagon.new
+
+# Here we include Processing::Proxy to mimic vanilla processing inner class
+# access.
+class Pentagon
+  include Processing::Proxy
+  attr_reader :points ,:branches, :level, :midpoints, :innerpoints
+
+  def initialize(points, levels)
+    @points = points
+    @level = levels
+    return if level.zero? # so called guard clause in ruby simplifies code
+
+    @midpoints = (0...5).map do |i| # build an array of midpoints
+      midpoint(points[i], points[(i + 1) % 5])
+    end
+    @innerpoints = (0...5).map do |i| # build an array of inner points
+      opposite = points[(i + 3) % 5]
+      x = midpoints[i].x + (opposite.x - midpoints[i].x) * strut_factor
+      y = midpoints[i].y + (opposite.y - midpoints[i].y) * strut_factor
+      Vec2D.new(x, y)
+    end
+    # Create the Pentagon objects representing the six inner
+    # pentagons
+    # the shape is very regular, so we can build the ring of five
+    @branches = (0...5).map do |i|
+      p = [
+        midpoints[i],
+        innerpoints[i],
+        innerpoints[(i + 1) % 5],
+        midpoints[(i + 1) % 5],
+        points[(i + 1) % 5]
+      ]
+      Pentagon.new(p, level - 1)
+    end
+    # add the final innermost pentagon
+    branches << Pentagon.new(innerpoints, level - 1)
+  end
+  # This is a simple helper function that takes in two points (as Vec2D) and
+  # returns the midpoint between them as Vec2D.
+  def midpoint(point1, point2)
+    (point2 + point1) * 0.5
+  end
+  # This draws the fractal. If this is on level 0, we just draw the
+  # pentagon formed by the points. When not level 0, iterate through the
+  # six branches and tell them to draw themselves.
+  def draw
+    if level.zero?
+      no_fill
+      begin_shape
+      points.each do |point|
+        point.to_vertex(renderer)
+      end
+      points[0].to_vertex(renderer)
+      end_shape
+    else
+      branches.each(&:draw)
+    end
+  end
+end