Simple pixellator using a cfdg end point

In hommage to guigui's original, the output cfdg file is called haddock.cfdg (after capt haddock "tintin"), the sketch data gets shoved into data.cfdg, that is called from haddock.cfdg by the cfdg program (requires version 3.0+). To adjust to different axis conventions I could just have made y negative. But because evolution of an non deterministic design (this isn't one) is from centre out, I adjusted x and y accordingly. Tune-able value is skip 3..10 is sensible choice, you could also add a posterize filter if needed. Nice to have would be a rectangle mask to define area to pixel-ate. Where an actual image is uses as basis you might be better doing img.load_pixels and accessing the pixel array thus img.pixels[x +y * width]. However the following sketch could be readily adapted to use processing generated images.

load_library :file_chooser
attr_reader :img, :data, :skip

###########
# Example file chooser (in this case as an image file chooser).
# We delay setting size of sketch until we know image size, probably
# would not work vanilla processing. Note we can wrap much code in the
# file_chooser block, no need for reflection. As with selectInput vanilla
# processing.
###########

def setup
  color_mode(HSB, 1.0);
  file_chooser do |fc|
    fc.look_feel "Gtk+"                            # optional, default is "Metal"
    fc.set_filter "Image Files",  [".png", ".jpg"] # easily customizable chooser
    @img = load_image(fc.display)                  # fc.display returns a path String
    size(img.width, img.height)
  end
  @skip = 5
  @data = []
end

def draw
  background img                                  # img must be same size as sketch
end

def write_data name, data
  open("data.cfdg", "w") do |pw|
    pw.puts "shape #{name}{\n"
    data.each do |row|
      pw.puts "  #{row[0]}[x #{row[1]} y #{row[2]} s #{row[3]} hue #{row[4]} sat #{row[5]} brightness #{row[6]}]\n"
    end
    pw.puts "}\n"
  end
end

def write_start start, data
  open("#{start}.cfdg", "w") do |pw|
  pw.puts "CF::Background = [b -1]"
  pw.puts "startshape #{start}\n"
  pw.puts "shape dot{CIRCLE[]}\n"
  pw.puts "import data.cfdg\n"
end
write_data start, data
end

def mouse_clicked
  export = Thread.new do
    load_pixels
    shp = "dot"
    (skip ... img.width).step(skip) do |x|
      (skip ... img.height).step(skip) do |y|
        pix = pixels[x +y * width]
        sat = saturation(pix)
        hue = hue(pix)
        sz = brightness(pix) * skip
        data << [shp, -width/2 + x, height/2 - y, sz.round(2), (hue * 360).round, sat.round(4), 1] if sz > 0.03
      end
    end
    write_start "haddock", data
  end  
  export.join
  puts "done"
end

The Gtk+ look and feel using openjdk

I just did some further experiments with my ruby-processing file chooser, and now I think the "Gtk+" look and feel might be the way to go on linux:-

However it is not that you should call the "Gtk+" look and feel, you should probably call "Metal", but specify system wide that the system and default look and feel is GTK (on archlinux you can do this in /etc/jre.sh in others you might use a flag or otherwise specify an environmental variable, be sure to set GTK fonts too).

Image Viewer Ruby Processing

Here is a little sketch, exploring the possibility of using my file_chooser to create a neat little image viewer. I does not make too much sense on its own, but we can take a look at images in ruby-processing, and then possibly do something with them along the lines of exporting to a "pixelated" sketch to cfdg for example.

load_library :file_chooser
attr_reader :img

###########
# Example usage of file_chooser (in this case image file chooser) 
# not sure this is exactly possible with vanilla processing. Here we
# defer setting the size of the sketch, until we know the size of image.
###########

def setup
  file_chooser do |fc|
    fc.look_feel "Nimbus"
    fc.set_filter "Image Files",  [".png", ".jpg"]
    my_file = fc.display
    @img = load_image(my_file)
    size img.width, img.height
  end
end

def draw
  background img
end

File Chooser Library For ruby-processing

Well here it is in action my ruby-processing file_chooser library, that like control panel takes a block the fc.display returns a a string that you can use in load_image etc to load a file, you can do all this in a block if you like (see below). Is a replacement for vanilla processing selectInput function that relies on reflection (and the chooser cannot be so easily customised). PS the my_file temporary variable is not required. The chooser starts in the users home folder on unix (mac/linux) or the working directory on windoes.

load_library :file_chooser
attr_reader :img

###########
# Example file chooser (in this case image file chooser)
# the image loading and resizing is encapsulated in the block,
# borrows heavily off control_panel. 
###########

def setup
  size 600, 600
  file_chooser do |fc|
    fc.look_feel "Nimbus"
    fc.set_filter "Image Files",  [".png", ".jpg"]
    my_file = fc.display
    @img = load_image(my_file)
    img.resize(width, height)
  end
end

def draw
  image img, 0, 0
end

The Chooser (a customised JFileChooser)

The Sketch

File Chooser in JRuby

Having convinced myself that the vanilla processing selectInput is a piece of crap (yet more reflection nonsense) I though I had better come up with an alternative for ruby processing, here is such an example (yielded by my good friend google and a bit of imagination, works for me):-

require 'rbconfig'
require 'pathname'

System = Java::JavaLang::System
JFile = Java::JavaIo::File
JXChooser = Java::javax::swing::JFileChooser

class ImageFilter < Java::javax::swing::filechooser::FileFilter
  def accept fobj
    return [".png",".jpg"].include? File.extname(fobj.to_s).downcase
    return fobj.isDirectory
  end

  def getDescription
    "Image Files"
  end
end


# Detect OS
OS = case RbConfig::CONFIG['host_os']
  when /darwin/      then :mac
  when /mswin|mingw/ then :windows
else
  :unix
end

# Asks the user to choose an editor.
# Returns either a Pathname object or nil (if canceled)
def pickImage
  # Create a FileChooser
  fc = JXChooser.new("Image Chooser")
  fc.set_dialog_title("Please select an image")
  fc.setFileFilter ImageFilter.new

  if :mac == OS
    fc.setCurrentDirectory(JFile.new(System.getProperty("user.home") << "/Pictures"))
  elsif :windows == OS
    fc.setCurrentDirectory(JFile.new(System.getProperty("user.dir")))
  else
    fc.setCurrentDirectory(JFile.new(System.getProperty("user.home")))
  end

  success = fc.show_open_dialog(nil)
  if success == JXChooser::APPROVE_OPTION
    return Pathname.new(fc.get_selected_file.get_absolute_path)
  else
    nil
  end
end

puts "The user picked: #{pickImage}"

# EOF

This would be the wrapper for ruby-processing?

def select_input(*args, &block)
  if block_given?
    # code using FileChooser output?
  else
    raise ArgumentError, "select_input must be called with a block" , caller
  end
end

Ruby-processing-2.1.3 is released (features processing-2.0.2)

In recent weeks I've changed the default mode of ruby-processing from using the included jruby-complete by default to using an external (system installed) jruby. So the --jruby flag is now deprecated (it doesn't do anything) and is replaced by the --nojruby flag which causes the installed jruby-complete to be used instead of the system version. The jruby-complete is retained for the following uses:-

1. To support application export
2. To run certain sketches (mainly GLSL shader sketches) that wont run with installed jruby
3. For people without an installed jruby (for whatever reason), make sure and use --nojruby flag.

Anyway I've also revisited, some of the samples with a view to introducing some more idiomatic ruby, and one thing I came up with was the idea to replace the heavyweight PVector class with a lightweight Struct alternative when the PVector class was being used as a repository for x, y, z values.

Vect = Struct.new(:x, :y, :z) do
  def add v
    self.x += v.x
    self.y += v.y
    self.z += v.z
  end
end

Netbeans for ruby-processing

Hey this looks pretty promising, you can now install a plugin for netbeans-7.3 (for ruby and ruby-on-rails development). I will report how I get on install seemed to go ok, Once I figured out I needed to add *.jar as well as *.nbm sub-modules.