More video library stuff with JRubyArt

The latest JRubyArt has a configurable library loader here is it being used to load the processing-3.0 video library:-
The library can be in a local 'library', folder in the default "~/.jruby_art/libraries", or in a "~/.jruby_art/libraries/config.yml" defined alternative folder.

require 'jruby_art'

# Test your Webcam with this sketch
class TestCapture < Processing::App
  load_library :video
  include_package 'processing.video'
  attr_reader :cam

  def setup
    size(960, 544)
    cameras = Capture.list
    fail 'There are no cameras available for capture.' if (cameras.length == 0)
    p 'Matching cameras available:'
    size_pattern = Regexp.new(format('%dx%d', width, height))
    select = cameras.grep size_pattern # filter available cameras
    select.uniq.map { |cam| p cam.strip }
    fail 'There are no matching cameras.' if (select.length == 0)
    start_capture(select[0])
  end

  def start_capture(cam_string)
    # The camera can be initialized directly using an
    # element from the array returned by list:
    @cam = Capture.new(self, cam_string)
    p format('Using camera %s', cam_string)
    cam.start
  end

  def draw
    return unless cam.available
    cam.read
    image(cam, 0, 0)
    # The following does the same, and is faster when just drawing the image
    # without any additional resizing, transformations, or tint.
    # set(0, 0, cam)
  end
end

TestCapture.new(title: 'Test Capture')

ASCII Capture sketch with JRubyArt

To get this sketch to work I placed the processing library jars in an adjacent library folder, also needed font in adjacent data folder. See jruby_art on github. It occurs to me that a library naming convention and library_loader utility like ruby-processing would be nice to have, perhaps with default location '~/.jruby_art/libraries' with a local library alternative (WIP) library_loader since implemented for JRubyArt.

#
# ASCII Video
# by Ben Fry, translated to jruby_art by Martin Prout.
#
#
# Text chars have been used to represent images since the earliest computers.
# This sketch is a simple homage that re-interprets live video as ASCII text.
# See the key_pressed function for more options, like changing the font size.
#
require 'jruby_art'

Dir[File.join('library', '*.jar')].each do |jar|
  require_relative jar
end

class AsciiVideoCapture < Processing::App
  attr_reader :bright, :char, :cheat_screen, :font, :font_size, :letters, :video
  # All ASCII characters, sorted according to their visual density
  LETTER_STRING = %q{ .`-_':,;^=+/\"|)\\<>)iv%xclrs{*}I?!][1taeo7zjLunT#JCwfy325Fp6mqSghVd4EgXPGZbYkOA&8U$@KHDBWNMR0Q}
  LETTER_ORDER = LETTER_STRING.scan(/./)

  def setup
    size(640, 480)
    init_video
    @font_size = 1.5
    @font = load_font(data_path('UniversLTStd-Light-48.vlw'))
    # for the 256 levels of brightness, distribute the letters across
    # the an array of 256 elements to use for the lookup
    @letters = (0...256).map do |i|
      LETTER_ORDER[map1d(i, (0...256), (0...LETTER_ORDER.length))]
    end
    # current brightness for each point
    @bright = Array.new(video.width * video.height, 128)
  end

  def init_video
    # This the default video input, see the test_capture
    # example if it creates an error
    @video = Java::ProcessingVideo::Capture.new(self, 160, 120)
    # Start capturing the images from the camera
    video.start
    @cheat_screen = false
  end

  def capture_event(c)
    c.read
    background 0
  end

  def draw
    return unless (video.available == true)
    capture_event(video)
    push_matrix
    hgap = width / video.width
    vgap = height / video.height
    scale([hgap, vgap].max * font_size)
    text_font(font, font_size)
    index = 0
    video.load_pixels
    (0...video.height).each do
      # Move down for next line
      translate(0,  1.0 / font_size)
      push_matrix
      (0...video.width).each do
        pixel_color = video.pixels[index]
        # Faster method of calculating r, g, b than red(), green(), blue()
        r = pixel_color >> 16 & 0xff
        g = pixel_color >> 8 & 0xff
        b = pixel_color & 0xff
        # Another option would be to properly calculate brightness as luminance:
        # luminance = 0.3*red + 0.59*green + 0.11*blue
        # Or you could instead red + green + blue, and make the the values[] array
        # 256*3 elements long instead of just 256.
        pixel_bright = [r, g, b].max
        # The 0.1 value is used to damp the changes so that letters flicker less
        diff = pixel_bright - bright[index]
        bright[index] += diff * 0.1
        fill(pixel_color)
        text(letters[bright[index]], 0, 0)
        # Move to the next pixel
        index += 1
        # Move over for next character
        translate(1.0 / font_size, 0)
      end
      pop_matrix
    end
    pop_matrix
    # image(video, 0, height - video.height)
    # set() is faster than image() when drawing untransformed images
    set(0, height - video.height, video) if cheat_screen
  end

  MESSAGE = <<-EOS
  Controls are:
  g to save_frame, f & F to set font size
  c to toggle cheat screen display
  EOS

  #
  # Handle key presses:
  # 'c' toggles the cheat screen that shows the original image in the corner
  # 'g' grabs an image and saves the frame to a tiff image
  # 'f' and 'F' increase and decrease the font size
  #
  def key_pressed
    case key
    when 'g' then save_frame
    when 'c' then @cheat_screen = !cheat_screen
    when 'f' then @font_size *= 1.1
    when 'F' then @font_size *= 0.9
    else
      warn MESSAGE
    end
  end
end

AsciiVideoCapture.new(title: 'Video Capture Sketch')

MDArray gem is available to JRubyArt (handy for image processing)

Sketch makes use of MDArray convenience index function. Requires to be run as "k9 run sobel.rb" to get image stuff to work, but interestingly mdarray gem also just loads...(cf ruby-processing)

require 'jruby_art'
require 'mdarray'

class Strobel < Processing::App
  attr_reader :img, :edge

  def setup
    size 300, 225
    @img = load_image('engine.png')
    @edge = create_image(300, 225, ALPHA)
    edge.load_pixels
    img.load_pixels
    generate(img)
  end

  def draw
    image edge, 0, 0
    filter(GRAY)
  end

  def generate(from_image)
    sbx = MDArray.int([3, 3], [-1, 0, 1, -2, 0, 2, -1, 0, 1])
    sby = MDArray.int([3, 3], [1, 2, 1, 0, 0, 0, -1, -2, -1])
    edg = MDArray.int([225, 300])  # this seems Irish, but is correct
    pxls = from_image.pixels
    (1...from_image.width - 2).each do |x|
      (1...from_image.height - 2).each do |y|
        pixel_x = (sbx[0, 0] * pxls[x - 1 + width * (y - 1)]) + (sbx[0, 1] * pxls[x + width * (y - 1)]) + (sbx[0, 2] * pxls[x + 1+ width * (y - 1)]) +
          (sbx[1, 0] * pxls[x - 1+ width * y])   + (sbx[1, 1] * pxls[x + width * y])   + (sbx[1, 2] * pxls[x + 1+ width * y]) +
          (sbx[2, 0] * pxls[x - 1+ width * y + 1]) + (sbx[2, 1] * pxls[x + width * y + 1]) + (sbx[2, 2] * pxls[x + 1 + width * (y + 1)])
        pixel_y = (sby[0, 0] * pxls[x - 1+ width * (y - 1)]) + (sby[0, 1] * pxls[x + width * (y - 1)]) + (sby[0, 2] * pxls[x + 1+ width * (y - 1)]) +
          (sby[1, 0] * pxls[x - 1+ width * y])   + (sby[1, 1] * pxls[x + width * y])   + (sby[1, 2] * pxls[x + 1+ width * y]) +
          (sby[2, 0] * pxls[x - 1+ width * (y + 1)]) + (sby[2, 1] * pxls[x + width * (y + 1)]) + (sby[2, 2] * pxls[x + 1+ width * (y + 1)])
        val = Math.hypot(pixel_x, pixel_y).ceil
        edg[y, x] = val
      end
    end
    edge.pixels = edg.to_a # load pixels from MDArray
  end

  def mouse_pressed
    save('engine_edge.png')
  end
end

Strobel.new(title: 'Sobel Edge Detect')

before

edge detected