re-arrange grid method

Author: monkstone

contributed/25_squares.rb renamed to examples/grid_method/25_squares.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env jruby
+require 'propane'
+#  Example of using noise to rotate a grid of arrows
+#
+class GenerativeArrowRotate < Propane::App
+
+  load_library :pdf
+  attr_reader :version, :time_seed, :save_one_frame, :arrow
+  STEP = 40
+  POINTS = [
+    [0, -55], [6, 0], [16, 10], [2, 10], [0, -10], [-2, 10], [-16, 10], [-6, 0]
+  ].freeze
+
+  def setup
+    sketch_title 'Generative Arrow'
+    # resolution does not really matter since we are working with vectors
+    frame_rate(35)
+    @version = 0 # if we grab multiple frames, they will be numbered
+    @time_seed = 0.1 # seed for the third dimension of the noise
+    @save_one_frame = false
+    create_arrow
+  end
+
+  def draw
+    # turn on recording for this frame if we clicked the mouse
+    begin_record(PDF, data_path("Line_#{version}.pdf")) if (save_one_frame == true)
+    background(255)
+    @time_seed = millis / 5000.0 # change noise over time
+    grid(width, height, STEP, STEP) do |cx, cy|  # iterate down and accross the page
+      push_matrix
+      translate(cx + STEP / 2, cy + STEP / 2) # set the position of each arrow
+      # rotate using noise
+      rotate(4.0 * PI * noise(cx / 400.0, cy / 400.0, time_seed))
+      # scale(1)
+      shape(arrow) # draw our arrow
+      pop_matrix
+    end
+    if (save_one_frame == true)
+      end_record
+      @save_one_frame = false
+      @version += 1
+    end
+  end
+
+  def mouse_pressed
+    @save_one_frame = true
+  end
+
+  def create_arrow # custom shape for our arrow
+    @arrow = create_shape
+    arrow.begin_shape
+    arrow.fill(200, 0, 0)
+    arrow.no_stroke
+    arrow.stroke_weight(2)
+    POINTS.each { |pt| arrow.vertex(*pt) }
+    arrow.end_shape(CLOSE)
+  end
+
+  def settings
+    size(1000, 1000)
+  end
+end
+
+GenerativeArrowRotate.new

examples/grid_method/data/background.png

@@ -0,0 +1,55 @@
+#!/usr/bin/env jruby
+require 'propane'
+# Part of the ReCode Project (http://recodeproject.com)
+# Based on "Hex Variation" by William Kolmyjec
+# Originally published in "Computer Graphics and Art" vol3 no4, 1978
+# Copyright (c) 2012 Steve Berrick - OSI/MIT license (http://recodeproject/license).
+class HexVariation < Propane::App
+
+  SIZE = 20 # hexagon radius
+  ANGLES = [0, THIRD_PI, THIRD_PI * 2].freeze
+
+  def setup
+    sketch_title 'Hex Variation'
+    no_loop
+    no_fill
+    stroke(0)
+    stroke_weight(2)
+  end
+
+  def draw
+    # clear background
+    background(255)
+    # line length (hypotenuse)
+    h = sin(THIRD_PI) * SIZE
+    jsize = height  / h
+    isize = width / (3 * SIZE)
+    grid(isize, 2 + jsize.to_i) do |i, j|
+      # reference points (centre of each hexagon)
+      x = i * SIZE * 3 + (SIZE / 2)
+      y = j * h
+      # offset each odd row
+      x += SIZE * 1.5 unless (j % 2).zero?
+      push_matrix
+      translate(x, y)
+      # random hexagon rotation (0, 120, 240 degrees)
+      rotate(ANGLES.sample)
+      # draw line
+      line(0, -h, 0, h)
+      # draw arcs
+      arc(-SIZE, 0, SIZE, SIZE, -THIRD_PI, THIRD_PI)
+      arc( SIZE, 0, SIZE, SIZE,  THIRD_PI * 2, THIRD_PI * 4)
+      pop_matrix
+    end
+  end
+
+  def mouse_pressed
+    redraw
+  end
+
+  def settings
+    size 600, 900
+  end
+end
+
+HexVariation.new

examples/grid_method/data/mask.png

@@ -0,0 +1,172 @@
+#!/usr/bin/env jruby
+require 'propane'
+# Luciernagas
+# After an original by Marcel Miranda aka reaktivo
+# https://github.com/reaktivo/rp-luciernagas
+# translated and updated by Martin Prout for JRubyArt
+# features use of Vec2D class and grid method
+class Luciernagas < Propane::App
+
+load_library :control_panel
+
+attr_reader :panel, :hide, :image_mask, :spots
+ACCURACY = 4
+
+# Firefly holder
+Flyer = Struct.new(:pos, :to_pos, :rotation, :positions)
+
+def settings
+  size 1024, 480, P2D
+  smooth
+end
+
+def setup
+  sketch_title 'Luciernagas'
+  control_panel do |control|
+    control.title 'Firefly Controller'
+    control.look_feel 'Nimbus'
+    control.slider(:speed, 0..20, 5)
+    control.slider(:tail_length, 0..400, 30)
+    control.slider(:rotation_max, 0..30, 7)
+    control.slider(:target_radius, 5...100, 20)
+    control.slider(:spot_distance, 5..200, 80)
+    control.button :reset
+    @panel = control
+  end
+  @hide = false
+  @spotlight = create_spotlight
+  @background = load_image(data_path('background.png'))
+  @image_mask = load_image(data_path('mask.png'))
+  load_spots(image_mask, ACCURACY)
+  reset
+end
+
+def reset
+  @flyers = (0..100).map { create_flyer }
+end
+
+def draw
+  unless hide
+    @hide = true
+    panel.set_visible(hide)
+  end
+  image @background, 0, 0
+  draw_lights
+  draw_flyers
+end
+
+def draw_lights
+  lights = create_graphics width, height, P2D
+  lights.begin_draw
+  @flyers.each do |flyer|
+    lights.push_matrix
+    position = flyer.pos
+    lights.translate position.x, position.y
+    lights.image @spotlight, -@spotlight.width / 2, -@spotlight.height / 2
+    lights.pop_matrix
+  end
+  lights.end_draw
+  image_mask.mask lights
+  image image_mask, 0, 0
+end
+
+def draw_flyers
+  rotation_max = @rotation_max / 100 * TWO_PI
+  @flyers.each do |flyer|
+    # check if point reached
+    if flyer.pos.dist(flyer.to_pos) <  @target_radius
+      spot = find_spot_near flyer.pos, @spot_distance
+      flyer.to_pos = spot
+    end
+    # set new rotation
+    to_rotation = (flyer.to_pos - flyer.pos).heading
+    to_rotation = find_nearest_rotation(flyer.rotation, to_rotation)
+    # rotate to new direction
+    if flyer.rotation < to_rotation
+      flyer.rotation = flyer.rotation + rotation_max
+      flyer.rotation = to_rotation if flyer.rotation > to_rotation
+    else
+      flyer.rotation = flyer.rotation - rotation_max
+      flyer.rotation = to_rotation if flyer.rotation < to_rotation
+    end
+    # add tail position
+    flyer.positions << flyer.pos.dup
+    flyer.positions.shift while flyer.positions.size > @tail_length
+    # set flyer position
+    flyer.pos.x = flyer.pos.x + @speed * cos(flyer.rotation)
+    flyer.pos.y = flyer.pos.y + @speed * sin(flyer.rotation)
+    # draw flyer tail
+    draw_tail flyer
+    # draw flyer
+    no_stroke
+    fill 201, 242, 2
+    push_matrix
+    translate flyer.pos.x, flyer.pos.y
+    ellipse 0, 0, 5, 5
+    pop_matrix
+  end
+end
+
+def create_flyer
+  spot = rand_spot
+  to_spot = find_spot_near spot, @spot_distance
+  rotation = rand * TWO_PI
+  Flyer.new(spot, to_spot, rotation, [])
+end
+
+def draw_tail(flyer)
+  positions = flyer.positions
+  return unless positions && !positions.empty?
+  alpha_add = (255 / positions.size).to_i
+  positions.each_index do |i|
+    stroke(255, i * alpha_add)
+    if i < positions.size - 2
+      line(positions[i].x, positions[i].y, positions[i + 1].x, positions[i + 1].y)
+    end
+  end
+end
+
+def load_spots(spot_image, accuracy = ACCURACY)
+  @spots = []
+  spot_image.load_pixels
+  corner_color = spot_image.get 0, 0
+  grid(spot_image.width, spot_image.height, accuracy, accuracy) do |x, y|
+    color = spot_image.get(x, y)
+    spots << Vec2D.new(x, y) if color != corner_color
+  end
+end
+
+def rand_spot
+  spots.sample
+end
+
+def find_spot_near(pos, distance)
+  spot = Vec2D.new(Float::INFINITY, Float::INFINITY)
+  spot = rand_spot until spot.dist(pos) < distance
+  spot
+end
+
+def find_nearest_rotation(from, to)
+  dif = (to - from) % TWO_PI
+  if dif != dif % PI
+    dif = dif < 0 ? dif + TWO_PI : dif - TWO_PI
+  end
+  from + dif
+end
+
+def create_spotlight
+  size = 60
+  spotlight = create_graphics size, size, P2D
+  spotlight.begin_draw
+  spotlight.no_stroke
+  spotlight.fill 255, 60
+  # spotlight.fill 255, 40
+  half_size = size / 2
+  spotlight.ellipse half_size, half_size, half_size, half_size
+  spotlight.filter BLUR, 4
+  spotlight.end_draw
+  spotlight
+end
+end
+
+Luciernagas.new