JRubyArt (Code as Art)

Getting Started On Windows

Sat, 28 Sep 2019 06:00:00 +0000

Getting Started With JRubyArt

If you love to code because it is a creative process, then you should give JRubyArt a try because it can be used to create music, art, animations, videos and much more. Also since it is based on the latest Processing you can access a vast range of libraries to make the difficult things easier.

Why JRubyArt?

Since Processing already comes wrapped in an easy-to-use package, you may ask: “why should I bother with JRubyArt?”

The answer: if you know how to write Ruby, you can use Processing as a visual presentation layer of a much more complex program. Games, interactive art exhibits, innovative music projects, anything you can imagine; it’s all at your fingertips.

Additionally, you don’t have to declare types, voids, or understand the differences between floats and ints to get started, as you do in pure Processing.

Although there are some drawbacks to using the Ruby version Processing (slower start up time, and sometimes performance), having Ruby’s API available to translate your ideas into sketches more than makes up for them.

Setup

Setting JRubyArt since JRubyArt-2.0 does not require a vanilla processing install, but still requires some configuration to point to your libraries folder.

Install wget which is also available as cygwin package, openjdk (17.01+), and some version of ruby-2.6+ preferably jruby-9.3+. If you encounter linkage problems it might be worth looking at Eclipse Temurin distribution or OpenJ9.

JRuby

It might actually be simpler to just install jruby on Windows rather than struggle with MRI ruby, but you may also want to install cygwin or similar in any case (cygwin has a wget package).

If you’ve already installed MRI ruby is also possible to run JRubyArt without a system install of jruby. But a jruby install might be needed to use JRubyArt with other gems eg toxiclibs.

Possibly the simplest way to get MRI ruby on windows is via rubyinstaller, uses MinGW. Alternatively you can install cygwin and use rvm to install MRI ruby.

JRubyArt

Installing JRubyArt assumes you have installed a recent version of ruby (which can be either MRI ruby (preferably 2.5.* and not 2.7.* or safer JRuby-9.3.3.0)

gem install jruby_art

If you haven’t installed JRubyArt before, the simplest way to set the configuration, and to install samples is:-

k9 --install # no arguments

this also installs jruby-complete

If you have installed JRubyArt before, the simplest way to set the configuration is:-

k9 -if config

Using -f or --force flag forces the removal of the previous configuration.

To check your configuration:-

k9 --check # or -?

The config file is config.yml in the ~/.jruby_art folder, which you should edit if required.

To explore command line options:-

k9 --help # or k9 -h

Running examples

To explore the installed examples:-

cd ~/k9_samples
rake # to run examples randomly as a demo
# or check available tasks with
rake --tasks
# use a task to randomly run a group of sketches eg
rake shaders # runs the shader examples

Create your own sketches

To create a simple sketch:-

k9 -c fred 200 200 # sketch name=Fred width=200 height=200 mode=default
k9 -c my_sketch 300 300 p2d # sketch name=MySketch width=300 height=300 mode=P2D

Edit fred.rb or my_sketch.rb with your favourite editor preferably vim, emacs or atom.

To run sketch using the command line

k9 -r fred.rb

To run a sketch from editor see editors

Read more about using the processing api here

Processing

Installing processing is optional but you could us it download the processing.org and contributed libraries. You can check to see what platforms are supported here.

Read more about using the processing api here

Getting Started on Linux

Sat, 28 Sep 2019 06:00:00 +0000

Getting Started With JRubyArt

Why JRubyArt?

Since Processing already comes wrapped in an easy-to-use package, you may ask: “why should I bother with JRubyArt?”

Additionally, you don’t have to declare types, voids, or understand the differences between floats and ints to get started, as you do in pure Processing.

Pure JRuby Setup Archlinux

Install Software as required:-

It is probably OK to use default OpenJDK but if you encounter problems install Eclipse Temurin instead. You can if you like use latest OpenJ9, or even graalvm

sudo pacman -S ruby # installs ruby-2.6
sudo pacman -S jruby # installs jruby-9.2.14.0

Install gems as required

gem install jruby_art
gem install toxiclibs # optional
gem install pbox2d # optional
gem install geomerative # optional

If you wish install vanilla processing, but it is not required since JRubyArt-2.0.

If you haven’t installed JRubyArt before you should:-

k9 --install # no arguments

To configure JRubyArt, install samples, and also install jruby-complete

If you have installed JRubyArt before you should:-

k9 -fi config # -f or --force flags force removal of previous configuration

Use:-

k9 --help # or -h to show command line options
# or
k9 --check # or -? to check configuration

Pure JRuby Setup Debian (Mint, Ubuntu)

Java

It should be possible to current default-jdk on Debian (openjdk 11.0.9.1 on Linux Mint when I last checked) only if you encounter problems should you install Eclipse Temurin version which is available as a deb package.

sudo apt install default-jdk # On Mint probably similar on other Debian distros

This will set up update-alternatives for you, which you can use to switch between jdk versions see below

To install adoptopenjdk you can do following:-

wget -qO - https://adoptopenjdk.jfrog.io/adoptopenjdk/api/gpg/key/public | sudo apt-key add -

sudo add-apt-repository --yes https://adoptopenjdk.jfrog.io/adoptopenjdk/deb/

sudo apt-get install -y software-properties-common

sudo apt-get update

sudo apt-get install adoptopenjdk # only if you have linker issues.

Use debian update-alternatives tool to manage configuration for java:-

sudo update-alternatives --config java # to configure if required
sudo update-alternatives --config javac # to configure if required
sudo update-alternatives --config jar # to configure if required

MRI Ruby

Install MRI ruby, if you are not using rvm or rbenv, then you should create a home in a local folder to store your gems eg ~/.gem/ruby/2.6.0 to store your gems:-

mkdir -p ~/.gem/ruby/2.6.0.0

To get gem command to use this location set GEM_HOME and GEM_PATH in ~/.profile and add the GEM_PATH/bin to PATH as below:-

export GEM_HOME="$HOME/.gem/ruby/2.6.0"
export GEM_PATH="$HOME/.gem/ruby/2.6.0"
# set PATH so it includes user's private bin directories
export PATH="$HOME/bin:$HOME/.local/bin:$GEM_PATH/bin:$PATH"

JRuby

Download and install latest jruby (in the /opt folder makes sense)

Use update-alternatives to install and maintain configuration eg for jruby:-

sudo update-alternatives --install /usr/bin/jruby jruby /opt/jruby-9.3.1.0/bin/jruby 100
sudo update-alternatives --config jruby # to configure if required

JRubyArt

Install gems as required

gem install jruby_art
gem install toxiclibs # optional
gem install pbox2d # optional
gem install geomerative # optional

If you wish install vanilla processing, but it is not required since JRubyArt-2.0.

If you haven’t installed JRubyArt before you should:-

k9 --install # no arguments

To configure JRubyArt, install samples, and also install jruby-complete

If you have installed JRubyArt before you should:-

k9 -fi config # -f or --force flags force removal of previous configuration

Use:-

k9 --help # or -h to show command line options
# or
k9 --check # or -? to check configuration

Installing JRubyArt assumes you have installed a recent version of ruby (which can be either MRI ruby or JRuby)

gem install jruby_art

If you haven’t installed JRubyArt before, the simplest way to set the configuration, and to install samples is:-

k9 --install # no arguments

this also installs jruby-complete

If you have installed JRubyArt before, the simplest way to set the configuration is:-

k9 -if config

Using -f or --force flag forces the removal of the previous configuration.

To check your configuration:-

k9 --check # or -?

The config file is config.yml in the ~/.jruby_art folder, which you should edit if required.

To explore command line options:-

k9 --help # or k9 -h

To explore the installed examples:-

cd ~/k9_samples
rake # to run examples randomly as a demo
# or check available tasks with
rake --tasks
# use a task to randomly run a group of sketches eg
rake shaders # runs the shader examples

To create a simple sketch:-

k9 -c fred 200 200 # sketch name=Fred width=200 height=200 mode=default
k9 -c my_sketch 300 300 p2d # sketch name=MySketch width=300 height=300 mode=P2D

Edit fred.rb or my_sketch.rb with your favourite editor preferably vim, emacs or atom.

To run sketch using the command line

k9 -r fred.rb

To run a sketch from editor see [editors][editors]

Processing

Installing processing is optional but you could us it download the processing.org and contributed libraries. You can check to see what platforms are supported here.

Running examples

To explore the installed examples:-

cd ~/k9_samples
rake # to run examples randomly as a demo
# or check available tasks with
rake --tasks
# use a task to randomly run a group of sketches eg
rake shaders # runs the shader examples

Create your own sketches

To create a simple sketch:-

k9 -c fred 200 200 # sketch name=Fred width=200 height=200 mode=default
k9 -c my_sketch 300 300 p2d # sketch name=MySketch width=300 height=300 mode=P2D

Edit fred.rb or my_sketch.rb with your favourite editor preferably vim, emacs or atom.

To run sketch using the command line

k9 -r fred.rb

To run a sketch from editor see [editors][editors]

Read more about using the processing api here

Getting Started on MacOS

Sat, 28 Sep 2019 06:00:00 +0000

Getting Started With JRubyArt

Why JRubyArt?

Since Processing already comes wrapped in an easy-to-use package, you may ask: “why should I bother with JRubyArt?”

Additionally, you don’t have to declare types, voids, or understand the differences between floats and ints to get started, as you do in pure Processing.

Java

Most OpenJDK builds 17+ seem to be ok now including ibm and graal versions if you have any difficulties then try Eclipse Temurin.

brew install wget # yes!!! you do need wget, curl won't work
brew cask install adoptopenjdk # or openJ9 which may require manual install

JRuby

It is possible to get away without doing system install of JRuby (using jruby-complete instead) but the default configuration assumes a JRuby install. There is homebrew script for this too.

brew install jruby # installs latest JRubyArt

You don’t need rvm or rbenv for JRubyArt since we call jruby directly when needed, in fact you may find a combination of MRI for regular ruby commands and jruby only when needed (called internally to run a sketch) works for you. MRI gem command installs jruby_art far quicker than jgem, but jgem install is a lot safer.

JRubyArt

gem install jruby_art

Install other gems as required

jgem install toxiclibs # optional
jgem install pbox2d # optional
jgem install geomerative # optional
jgem install wordcram # optional

If you wish install vanilla processing, but it is not required since JRubyArt-2.0.

If you haven’t installed JRubyArt before you should:-

k9 --install # no arguments

To configure JRubyArt, install samples, and also install jruby-complete

If you have installed JRubyArt before you should:-

k9 -fi config # -f or --force flags force removal of previous configuration

Use:-

k9 --help # or -h to show command line options
# or
k9 --check # or -? to check configuration

Running examples

To explore the installed examples:-

cd ~/k9_samples
rake # to run examples randomly as a demo
# or check available tasks with
rake --tasks
# use a task to randomly run a group of sketches eg
rake shaders # runs the shader examples

Create your own sketches

To create a simple sketch:-

k9 -c fred 200 200 # sketch name=Fred width=200 height=200 mode=default
k9 -c my_sketch 300 300 p2d # sketch name=MySketch width=300 height=300 mode=P2D

Edit fred.rb or my_sketch.rb with your favourite editor preferably vim, emacs or atom.

To run sketch using the command line

k9 -r fred.rb

To run a sketch from editor see editors

Read more about using the processing api here

Welcome to JRubyArt!

Sat, 28 Sep 2019 06:00:00 +0000

Check out:-

For more info on how to get the most out of JRubyArt see the JRubyArt WebSite and my JRubyArt blog. File all bugs/feature requests at JRubyArt issues.

def setup
  sketch_title 'Sketch Title'
end

def draw
  # the sketch loop
end

def settings
  size 200, 200
  # full_screen # replaces size for full screen sketches
  # smooth  
end

Example Sketches:-

see installed sketches and book examples The Nature of Code Sketches

Installing Contributed Java Libraries for JRubyArt

Mon, 23 Sep 2019 06:00:00 +0000

Listing Libraries and their urls

wget http://download.processing.org/contribs/contribs.txt

NB toxiclibs, pbox2d, joonsrenderer, wordcram and geomerative libraries are available as rubygems, further the libraries in the contributed list only contains libraries curated (filtered) by Prisoner John, there are many more that are available out there eg Joshua Davis hype.

An example library listing in contribs.txt:-

library
minRevision=228
name=gicentreUtils
maxRevision=0
sentence=Assists creation of data visualization sketches.
url=http://www.gicentre.org/utils/
prettyVersion=3.4.0
paragraph=Includes color utilities, statistical graphics, morphing classes, spatial utilities and map projections, force-directed layouts and text input/output. Together these make the task of creating data visualization sketches much faster by providing code for commonly repeated tasks such as zooming in and out of a sketch, setting up color tables etc. For documentation and examples, see the [gicentreUtils pages](http://www.gicentre.org/utils/).
version=14
authors=[Jo Wood](http://gicentre.org/) and [Aidan Slingsby](http://gicentre.org/)
download=http://staff.city.ac.uk/~jwo/giCentre/utils/gicentreUtils.zip
type=library
id=004

Installing a library

Install libraries to your ~/.jruby_art/libraries folder. NB: this created for you when you install the video or sound libraries.

jruby_art -i Sound
jruby_art -i Video

It can make sense to convert the library names and jars from camelcase to snakecase, (ie when library creators have messed up) you just need to be consistent, see below

cd ~/.jruby_art/libraries
wget http://staff.city.ac.uk/~jwo/giCentre/utils/gicentreUtils.zip
unzip gicentreUtils.zip # NB: British English spelling of centre
mv gicentreUtils gicenter_utils # Use snake case, and convert spelling
cd gicenter_utils/library
mv gicentreUtils.jar gicenter_utils.jar

Here is an example sketch translated to JRubyArt, main differences are how we load libraries and access package namespace in JRubyArt. Also note the use of the data_path wrapper to access sketch data folder. Another twist is the need to cast array of ruby Numbers to java float.

# Sketch to demonstrate the use of the BarChart class to draw simple bar charts.
# Version 1.3, 6th February, 2016.
# Author Jo Wood, giCentre.
load_library :gicenter_utils
include_package 'org.gicentre.utils.stat' # British spelling

def settings
  size(800, 300)
  smooth
end

def setup # a static sketch no need for draw loop
  sketch_title 'Bar Chart Sketch'
  title_font = load_font(data_path('Helvetica-22.vlw'))
  small_font = load_font(data_path('Helvetica-12.vlw'))
  text_font(small_font)
  bar_chart = BarChart.new(self)
  data_float = [
    2_462, 2_801, 3_280, 3_983, 4_490, 4_894, 5_642, 6_322, 6_489, 6_401,
    7_657, 9_649, 9_767, 12_167, 15_154, 18_200, 23_124, 28_645, 39_471
  ]
  bar_chart.setData(data_float.to_java(:float))
  data_label = %w(1830 1840 1850 1860 1870 1880 1890 1900 1910 1920 1930 1940 1950 1960 1970 1980 1990 2000 2010)
  bar_chart.setBarLabels(data_label)
  bar_chart.setBarColour(color(200, 80, 80, 100))
  bar_chart.setBarGap(2)
  bar_chart.setValueFormat('$###,###')
  bar_chart.showValueAxis(true)
  bar_chart.showCategoryAxis(true)
  background(255)
  bar_chart.draw(10, 10, width - 20, height - 20)
  fill(120)
  text_font(title_font)
  text('Income per person, United Kingdom', 70, 30)
  text_height = text_ascent # of title font
  text_font(small_font)
  text('Gross domestic product measured in inflation-corrected $US', 70, 30 + text_height)
end

Watching Sketches

Sun, 07 Jan 2018 05:15:13 +0000

Any editor

From console:-

mkdir 'any_name'
cd 'any_name'
touch 'fred.rb'

Vim

Open new console

cd 'any_name'
vim fred.rb

In 1st console

k9 -w fred.rb
# A bare sketch is displayed with a default size, background etc.

Edit sketch in vim eg

background 0
# Sketch reloads on `:w` save with a black background
# PS: in processing this is a so called static sketch (ie no draw loop)
# no interaction is possible via mouse etc

Other editors eg atom

From console

atom fred.rb
# opens sketch for editing in atom

From same console

k9 -w fred.rb
# As above a bare sketch is displayed with default background

Edit sketch in atom, on save sketch will reload

Normal sketches (ie with draw loop, sketch_title etc)

Use the JRubyArt sketch creator facility to create an outline sketch as follows

k9 -c fred 200 200
# creates fred.rb, with `size 200, 200` you can do interesting
# things with code in the draw loop

Then watch, and edit as above (with editor of choice, preferably vim for console, or atom for gui, with language-jruby-art package).

Suggested exercises:-

set background and fill in the draw loop, draw ellipse (or rect) in fixed location, then substitute mouse_x or mouse_y for x or y coordinates…
Experiment with no background, semi transparent background, or semi transparent fill eg background(color(200, 0, 0, 50)) or fill(200, 100)

Vector Classes and Duck Typing

Sun, 07 Jan 2018 05:15:13 +0000

Duck Typing and Vector classes

Since JRubyArt-1.4.5, Vec2D and Vec3D classes support duck-typing copy constructors. This means that the source vector need only supply accessor methods for :x and :y (that return either float or fixnum). Note :z can be supplied for Vec3D constructor, else z is set to zero, however supply z to Vec2D constructor it will be ignored see below:-

Vector = Struct.new(:x, :y) # simple valid duck-type
fred = Vector.new(1, 4)
ted = Vec2D.new(fred)
ted.inspect
# "Vec2D(x = 1.0000, y = 4.0000)"
ted3 = Vec3D.new(fred)
ted3.inspect
# "Vec3D(x = 1.0000, y = 4.0000, z = 0.0000)"
bob = Vec2D.new(ted3)
bob.inspect
# Vec2D(x = 1.0000, y = 4.0000)
Vector3 = Struct.new(:x, :y, :z) # simple valid duck-type
fred3 = Vector.new(8.0, 7.0, 10)
bob3 = Vec3D.new(fred3)
bob3.inspect
# Vec3D(x = 8.0000, y = 7.0000, z = 10.0000)

Note despite fixnum entry Vec2D and Vec3D values are stored as float (well actually as a java double, but that’s an implementation detail)

Installing Ruby

Wed, 08 Feb 2017 05:15:13 +0000

Installing ruby

There may be problems using the latest MRI ruby releases (should work OK with ruby-2.6), default setup is to use most recent JRuby, rather than a combination of MRI ruby and JRuby-Complete.

Managers

Many Rubyists use Ruby managers to manage multiple Rubies. They confer various advantages but are not officially supported. Their respective communities are very helpful, however do not use them unless you absolutely must, they are generally an absolute pain and not needed for JRubyArt (which ultimately runs directly from java when using jruby-complete or from an installed jruby over which rvm and rbenv have no control over, you have been warned)

Installing jruby

For windows see JRuby wiki

For Arch Linux

$ sudo pacman -S jruby

This should install the latest stable JRuby version.

For Debian linux

Get the latest version from http://jruby.org/download

cd /opt
tar xzvf /pathToDownload/jruby-bin-9.3.x.x.tar.gz

You could the use the excellent update-alternatives to provide symbolic links to ruby, jruby, jirb jgem etc.

For MacOS user using the Homebrew as a package manager.

$ brew install jruby

This will again generally install the the latest jruby for you.

Managers

As far as I know rvm and rbenv are completely useless with jruby (further bundler is also as good as useless for JRubyArt)

The processing api

Sat, 21 Jan 2017 06:24:13 +0000

JRubyArt is the closest thing to a ruby DSL for vanilla processing, it supports bare sketches, and static sketches, and most of the processing-api see below:-

The processing-api

Most of the processing methods, as explained in the Processing Language API, are available as instance methods on your Processing::App. (frame_rate, ellipse, and the 158 others.) This makes it easy as pie to use them within your sketch, but you should prefer snake case to camel case and there are some caveats. Here is an example of a bare sketch (you can if you wish create a class wrapped sketch), the main difference with vanilla processing (from the processing ide) is that you need to explicitly create a settings method to set the size and sketch mode.

def settings
  size 200, 200
  smooth 8
end

def setup
  sketch_title 'Triangles Gone Wild' # JRubyArt & propane
  color_mode RGB, 1.0
  frame_rate 30
  fill 0.8, 0.6, 0.4
end

def draw
  triangle(rand(width), rand(height), rand(width), rand(height), rand(width), rand(height))
end

Caveats

Here are some the main differences moving from vanilla processing to JRubyArt:-

You do not declare types in ruby vec = PVector.new instead of PVector vec = new PVector() for example, however in this case you should use Vec2D and Vec3D, which are alternatives to PVector (but with methods that are much more ruby-like, and have extended functionality).
There are no void methods (what’s evaluated gets returned without needing an explicit return)
Everything is an object (this includes primitive types float, integer etc cf. java) see more
Confusing for beginners and especially pythonistas there is often more than one way to do it
Processing makes heavy use of java inner classes (to make methods and values somewhat globally available) JRubyArt provides the Processing::Proxy mixin to somewhat mimic this behaviour see Ball. An alternative to consider is to use delegator methods using extend Forwardable, requires require 'forwardable' see JRubyArt example.
Use mouse_pressed? and key_pressed? to access mouse_pressed and key_pressed as variables (ruby can’t cope with overloading the mouse_pressed and key_pressed methods like java) see example.

In general you should try and code in regular ruby (in JRubyArt), only using processing short-cuts / methods when you need to (ie when ruby alternatives don’t exist, many processing short-cuts just aren’t needed in ruby). From 3. above you should use:-

a**b for pow(a, b)
theta.degrees for degrees(theta)
theta.radians for radians(theta)
x.abs for abs(x)
x.ceil for ceil(x)
x.round for round(x)
str.strip for trim(str)
str.hex for hex(str)
string.to_i(base=16) for unhex(str)

Other ruby methods to prefer are:-

rand(x) to random(x)
rand(lo..hi) to random(lo, hi)
puts val (or even just p val) to println(val)
map1d(val, (range1), (range2)) to map(value, start1, stop1, start2, stop2)
(lo..hi).clip(amt) to constrain(amt, lo, hi) it is how it is implemented

To avoid confusion use with ruby map use map1d for processing map function see example.

Comparison JRubyArt-2.6 and JRubyArt-1.7

Mon, 28 Sep 2015 06:24:13 +0000

JRubyArt is actively being developed, ruby-processing should be considered to be deprecated and is no-longer actively maintained. The only possible justification to prefer to use ruby-processing is to be compatible with processing-2.2.1. So since January 2017 table below has been modified to address what you need to know, now that you have decided to switch from ruby-processing to JRubyArt

feature	JRubyArt-1.7	JRubyArt-2.6
binary	k9	k9
run opts	-r, -w, -l	-r, -w, -l
jruby version	9.2.14.0 (2.5.7)	9.3.0.0+ (2.6.8)
jdk version	jdk8	jdk11+
config	PROCESSING_ROOT	not required

The settings method was introduced to vanilla processing since processing-3.0. However this is hidden for users of the processing ide but required by Eclipse users. The settings method is where size belongs or full_screen, also you should set smooth and pixel_density here. Retina users can make use of their hi-dpi display by setting pixel_density(2), NB: size should be first line of settings, and if used pixel_density(2) should be next.

In JRubyArt use the data_path wrapper to return the absolute path for the data folder see here (this means --nojruby flag is obsolete since even shader sketches should now run with an installed jruby). Set JRUBY: false in config.yml to use jruby-complete instead of an installed jruby (crucial if you haven’t installed jruby on your system).