Learning JRubyArt

Plans For Future Development

Sat, 04 Dec 2021 06:00:00 +0000

Subtle Changes for Vec2D

Recent discussions about vectors and the py5 project persuaded me to prefer wedge product over cross product for 2D vectors (since by definition there is no such thing as cross product that returns a scalar). In the first instance I will keep the cross product in the api, but it will be deprecated in favor of the ^ (wedge product operator). See PiCrate example :collinear? method.

Use of jdk17

Initially propane will be changed to require jdk17 (probably by xmas 2017), for JRubyArt and PiCrate, I will wait to see what processing.org and jruby.org do, there will be no going back otherwise the change will be pointless (since I am currently using jdk 17 to test and run both projects)!!!

Instance Of Pattern Matching

Sat, 16 Oct 2021 06:00:00 +0000

Recently I’ve been exploring the goodies to come when I upgrade my ruby-processing projects to jdk17 (might happen this christmas or before if vanilla processing gets there 1st). Since JRuby14 we have:-

Pattern Matching for instanceof in Java

From my Vec2D implementation in java

Extending JRuby, Compile and Jar Java Extension Code

Sat, 09 Oct 2021 06:00:00 +0000

Do you want to create a JRuby extension?

Previously you may have seen guides by Yoko Harada (yokolet) and James Coglan which suggest you use the Rake-Compiler to compile your code. However those recommendations were made before the polyglot maven compiler existed, which is now the recommended way to compile and jar your ruby code. You can now write your pom file in ruby (and get regular pom.xml emitted useful when working with a java ide such as netbeans). For a basic example see jruby-examples which demonstrates how to create a ruby class and ruby module in java. The article by James Coglan remains in interesting, as it shows how you should create a java extension of a gem with an existing MRI extension. The beauty of maven is that you can pull in jar dependencies from maven central including jruby-base.jar which is the recommended jruby dependency when compiling jruby extension (was jruby.jar but that may cause dependency conflicts).

For a JRubyArt example see the Vec3D class, you can use/abuse this class like any regular ruby class, it can be monkey-patched or refined like any other ruby class see a previous blog entry. Another interesting example is the MathTool module in particular the grid and mesh_grid methods, which demonstrates how to create a method that takes a ruby block (uses yield).

Creating a maven wrapper

If you want to specify the a version of of maven used, or allow users to build your project without installing maven, you could add a maven wrapper, to do this run the following command in your project folder:-

mvn -N io.takari:maven:wrapper -Dmaven=3.8.3

Users are then able to build your project using the local maven wrapper command mvnw on unix based systems or mvnw.cmd on windows. In practice you will probably create a Rakefile at this stage, which will use the wrapper command to execute maven tasks in order. See for example Rakefile for JRubyArt.

Processing4 on RaspberryPI4

Fri, 08 Oct 2021 06:00:00 +0000

Currently vanilla Processing4 does not support running on the RaspberryPI. Previously processing was restricted to running on Buster (now RaspbianOS) in 32 bit mode. For the future jdk17+ support is likely to be 64 bit mode. Thus there is strong case for using a 64 bit OS on RaspberryPI3 and RaspberryPI4, and I would recommend ManjaroArm (XFCE).

Create and run processing sketches in Ruby using PiCrate (approximates to processing4)

I’ve released a new version of PiCrate which works on both RaspberryPI4 and RaspberryPI3B+ with both 32 bit (RaspbianOS) and 64 bit (Manjaro Arm) operating systems. However in the longterm I’m likely to be dropping 32 bit support.

This above sketch is using the regular processing video library and a USB camera, you should not need to use legacy driver…

You can also create and run py5 sketches on ManjaroArm (RaspbianOS is untested)

See processing forum

Refinements vs Monkey Patching

Sun, 26 Sep 2021 06:00:00 +0000

Since ruby-2.4.0 there is an alternative to monkey-patching. See Ribbon Doodle sketches.

Monkey Patching

#!/usr/bin/env jruby -w
# frozen_string_literal: true
require 'picrate'
# Adapted to use Processing Vec2D and Vec3D classes by Martin Prout

# Use Face Struct triangle 'mesh'.
Face = Struct.new(:a, :b, :c) # triangle mesh face

Vec3D.class_eval do # re-open the Vec3D class to add rotation functionality
  def rotate_y(theta)
    co = Math.cos(theta)
    si = Math.sin(theta)
    xx = co * x - si * z
    self.z = si * x + co * z
    self.x = xx
    self
  end

  def rotate_x(theta)
    co = Math.cos(theta)
    si = Math.sin(theta)
    zz = co * z - si * y
    self.y = si * z + co * y
    self.z = zz
    self
  end
end

class Doodle < Processing::App
  # After a toxiclibs "MeshDoodle" sketch by Karsten Schmidt
  # Adapted to use JRubyArt Vec2D and Vec3D classes by Martin Prout
  # Note: The extension of Vec3D class to support rotations, and the ruby Struct
  # Face for triangle 'mesh'. Also an example of AppRenderer for Vec3D => vertex

  attr_reader :prev, :p, :q, :rotation, :faces, :pos, :weight

  def settings
    size(600, 600, P3D)
  end

  def setup
    sketch_title 'Ribbon Doodle'
    @weight = 0
    @prev = Vec3D.new
    @p = Vec3D.new
    @q = Vec3D.new
    @rotation = Vec2D.new
    @faces = []
  end

  def draw
    background(0)
    lights
    translate(width / 2, height / 2, 0)
    rotate_x(rotation.x)
    rotate_y(rotation.y)
    no_stroke
    begin_shape(TRIANGLES)
    # iterate over all faces/triangles of the 'mesh'
    faces.each do |f|
      # create vertices for each corner point
      f.a.to_vertex(renderer)
      f.b.to_vertex(renderer)
      f.c.to_vertex(renderer)
    end
    end_shape
    # update rotation
    @rotation += Vec2D.new(0.014, 0.0237)
  end

  def mouse_moved
    # get 3D rotated mouse position
    @pos = Vec3D.new(mouse_x - width / 2, mouse_y - height / 2, 0)
    pos.rotate_x(rotation.x)
    pos.rotate_y(rotation.y)
    # use distance to previous point as target stroke weight
    @weight += (sqrt(pos.dist(prev)) * 2 - weight) * 0.1
    # define offset points for the triangle strip
    a = pos + Vec3D.new(0, 0, weight)
    b = pos + Vec3D.new(0, 0, -weight)
    # add 2 faces to the mesh
    faces << Face.new(p, b, q)
    faces << Face.new(p, a, b)
    # store current points for next iteration
    @prev = pos
    @p = a
    @q = b
  end

  def renderer
    @renderer ||= GfxRender.new(self.g)
  end
end

Doodle.new

# Use Face Struct triangle 'mesh'.
Face = Struct.new(:a, :b, :c) # triangle mesh face
require 'picrate'

# Using refinements with the Vec3D class to support rotations

module RotateVec3D
  refine Vec3D do
    def rotate_y!(theta)
      co = Math.cos(theta)
      si = Math.sin(theta)
      xx = co * x - si * z
      self.z = si * x + co * z
      self.x = xx
      self
    end

    def rotate_x!(theta)
      co = Math.cos(theta)
      si = Math.sin(theta)
      zz = co * z - si * y
      self.y = si * z + co * y
      self.z = zz
      self
    end
  end
end

# After a toxiclibs "MeshDoodle" sketch by Karsten Schmidt
class Doodle < Processing::App
  using RotateVec3D
  attr_reader :prev, :p, :q, :rotation, :faces, :pos, :weight

  def settings
    size(600, 600, P3D)
  end

  def setup
    sketch_title 'Ribbon Doodle'
    @weight = 0
    @prev = Vec3D.new
    @p = Vec3D.new
    @q = Vec3D.new
    @rotation = Vec2D.new
    @faces = []
  end

  def draw
    background(0)
    lights
    translate(width / 2, height / 2, 0)
    rotate_x(rotation.x)
    rotate_y(rotation.y)
    no_stroke
    begin_shape(TRIANGLES)
    # iterate over all faces/triangles of the 'mesh'
    faces.each do |f|
      # create vertices for each corner point
      f.a.to_vertex(renderer)
      f.b.to_vertex(renderer)
      f.c.to_vertex(renderer)
    end
    end_shape
    # update rotation
    @rotation += Vec2D.new(0.014, 0.0237)
  end

  def mouse_moved
    # get 3D rotated mouse position
    @pos = Vec3D.new(mouse_x - width / 2, mouse_y - height / 2, 0)
    pos.rotate_x!(rotation.x)
    pos.rotate_y!(rotation.y)
    # use distance to previous point as target stroke weight
    @weight += (sqrt(pos.dist(prev)) * 2 - weight) * 0.1
    # define offset points for the triangle strip
    a = pos + Vec3D.new(0, 0, weight)
    b = pos + Vec3D.new(0, 0, -weight)
    # add 2 faces to the mesh
    faces << Face.new(p, b, q)
    faces << Face.new(p, a, b)
    # store current points for next iteration
    @prev = pos
    @p = a
    @q = b
  end

  # An example of GfxRenderer usage for Vec3D => vertex conversion
  def renderer
    @renderer ||= GfxRender.new(g)
  end
end

Doodle.new

py5 feature envy

Sat, 17 Jul 2021 06:00:00 +0000

Recently I have been experimenting with py5 (an implementation of processing that can be run with native python-3.8+), previously there was processing.py (based on jython, an implementation of python in java). In some ways ruby-processing projects are similar to processing.py except because of jruby they are somewhat closer to the the current native ruby than is jython that is currently stuck on python-2.7. The big frustration with processing.py and jython is the inability to use numpy and any other C library. This limitation similarly applies to my ruby-processing projects which are based on jruby, however thanks to its design it it is rather well integrated with java.

How does py5 manage to interoperate with native python?

It does this by using JPype.

JPype is a Python module to provide full access to Java from within Python. It allows Python to make use of Java only libraries, exploring and visualization of Java structures, development and testing of Java libraries, scientific computing, and much more. By gaining the best of both worlds using Python for rapid prototyping and Java for strong typed production code, JPype provides a powerful environment for engineering and code development.

This is achieved not through re-implementing Python, as Jython has done, but rather through interfacing at the native level in both virtual machines. This shared memory based approach achieves decent computing performance, while providing the access to the entirety of CPython and Java libraries.

Using numpy with py5

See my experiments with py5, where I found using numpy did indeed confer great performance benefits to sketches involving pixel manipulation.

Unique features to py5

Ability to integrate with jupyter notebooks

py5-generator

The hooking up of these features in py5 depends on the py5-generator, which looks a bit complicated to to me, kudos to Jim Schmitz the creator of py5. Makes the meta programming used in ruby-processing projects look very straightforward.

Experimental Propane GEM

Sun, 24 Jan 2021 06:00:00 +0000

I have just released a pre-release propane gem (3.7.0.pre) with experimental ios-arm64 support requires testing.You probably should install azul jdk for native mac support (otherwise you’ll be reliant Rosetta2 wrapper).

jgem install propane --pre

Experimenting With Graal on RaspberryPI4

Sun, 25 Oct 2020 06:00:00 +0000

Recently I’ve been working on Newton Fractal Sketches using ruby Complex Math, which are quite testing for the RaspberryPI processor. Up till now I’d been reasonably happy with the performance of OpenJDK14 with my PiCrate sketches, but the Newton Fractal sketches run quite slowly (especially compared with processing.py and jython). So finally I bit the bullet and gave the latest GraalVM a go, which is now available for aarch64. Running on Manjaro ARM OS, I installed Graal on /opt, I then unset archlinux-java and used my ~/.bashrc to control which jvm was used:-

Here is a test sketch

# frozen_string_literal: true

require 'picrate'

class NewtonFractal < Processing::App
  IMGX = 512
  IMGY = 512
  MAXIT = 20 # max iterations allowed
  EPS = 1e-3 # max error allowed
  COMPLEX = Complex(1e-6, 1e-6) # step increment

  attr_reader :xa, :xb, :ya, :yb, :z, :img, :start

  def settings
    size(IMGX, IMGY)
  end

  def setup
    sketch_title 'Newton Fractal'
    #color_mode(HSB)
    @start = Time.now
    # Drawing area
    @xa = -1.0
    @xb = 1.0
    @ya = -1.0
    @yb = 1.0
    @img = create_image(width, height, RGB).tap do |image|
      image.load_pixels
      grid(IMGY, IMGX) do |y, x|
        zy = y * (yb - ya) / (IMGY - 1) + ya
        zx = x * (xb - xa) / (IMGX - 1) + xa
        @z = Complex(zx, zy)
        (0...MAXIT).each do |i|
          # Newton iteration
          z0 =  z - func(z) / ((func(z + COMPLEX) - func(z)) / COMPLEX)
          break if (z0 - z).abs2 < EPS * EPS

          @z = z0
          # pixels[x + y * width] = color(i % 5 * 64, i % 17 * 16, i % 9 * 32)
          image.pixels[x + y * width] = color(i % 5 * 64, i % 9 * 32, i % 17 * 16)
        end
      end
    end
    no_loop
  end

  def draw
    set(0, 0, img)
    puts Time.now - start
  end

  def func(z)
    z**3.0 - 1.0
    # z**4 - 1.0
  end
end

NewtonFractal.new

This sketch took over 2 minutes to develop on OpenJDK14 and less than a minute to develop on the GraalVM. Also I found a community PKGBUILD build, which require a fakeroot, install as follows (then you can use archlinux-java to switch jvm:-

sudo pacman -S fakeroot
git clone https://aur.archlinux.org/jdk11-graalvm-bin.git
cd jkd11-graalvm-bin
makepkg -si

Refinements in Ruby-Processing

Fri, 02 Oct 2020 06:00:00 +0000

Since ruby-2.4 there is a possibility of using refinements in ruby-processing projects, recently I’ve been working on sketches using complex numbers. It occurred to me I could use refinements (instead of monkey patching) to extend the Vec2D class support complex number operations, here is what I came up with:-

require 'picrate'

module CVec2D
  refine Vec2D do
    def complex_mult(vec_b)
      Vec2D.new(
        self.x*vec_b.x - self.y*vec_b.y, self.x*vec_b.y + self.y*vec_b.x
      )
    end

    def inverse
      Vec2D.new(self.x, -self.y) / self.dot(self)
    end

    def complex_divide(vec_b)
      self.complex_mult(vec_b.inverse)
    end

    def complex_exp
      Vec2D.new(Math.exp(self.x) * Math.cos(self.y), Math.exp(self.x) * Math.sin(self.y))
    end

    def complex_log
      Vec2D.new(Math.log(self.mag), Math.atan2(self.y, self.x));
    end

    def complex_power(vec_b)
      self.complex_log.complex_mult(vec_b).complex_exp
    end
  end
end

class RefineVec2D
  using CVec2D
  attr_reader :vec_a, :vec_b

  def initialize
    @vec_a = Vec2D.new(3, 4)
    @vec_b = Vec2D.new(5, 6)
  end

  def test
    puts vec_a.complex_divide(vec_b)
    puts vec_a.complex_mult(vec_b)
    puts vec_a.inverse
    puts vec_a.complex_power(Vec2D.new(3, 0))
  end
end

test_refine = RefineVec2D.new
test_refine.test

Here is the output:-

Vec2D(x = 0.6393, y = 0.0328)
Vec2D(x = -9.0000, y = 38.0000)
Vec2D(x = 0.1200, y = -0.1600)
Vec2D(x = -117.0000, y = 44.0000)
                       

64 Bit OS RaspberryPI4

Wed, 06 May 2020 06:00:00 +0000

Although RaspberryPI foundation are working on a 64 bit (RaspberryPI OS) it is very much beta, and the only thing that seems to have spurred them to it, is the release of the 8gb version of the RaspberryPI4. However Archlinux ARM is now exclusively 64 bit and my opinion very much ready to go (and I’m sure they’ll take advantage of RaspberryPI foundations work). Recently I released a version of PiCrate that is compatible with both 32 bit and 64 bit distros.