picrate 0.0.2-java → 0.0.3-java

data/docs/_gems/other_gems/other_gems.md

@@ -0,0 +1,198 @@
+---
+layout: post
+title:  'Using Gems in picrate'
+keywords: gem, library, picrate
+permalink: gems/other_gems.html
+---
+```ruby
+#####################################################################
+# Using the ai4r gem in picrate.
+# A simple example that demonstrates using
+# a back-propagation neural network. Use the drop box menu to
+# select a pre-built shape. To draw a test shape tick drawing check-box,
+# release the mouse when drawing a discontinuous shape eg cross.
+# Clear the sketch with clear button.
+# Press evaluate and result is printed to the console....
+####################################################################
+
+require 'ai4r'
+require 'json'
+
+#....................
+
+load_library :control_panel
+
+attr_reader  :img, :img_pixels, :ci_input, :cr_input, :tr_input, :sq_input, :net, :points, :panel, :hide, :drawing, :source_string
+
+def settings
+  size(320, 320)
+end
+
+def setup
+  sketch_title 'AI4R Sketch'
+  control_panel do |c|
+    c.title'control'
+    c.look_feel 'Nimbus'
+    c.checkbox :drawing
+    c.button :clear
+    c.button :evaluate
+    c.menu :shape, ['CIRCLE', 'CROSS', 'CROSS_WITH_NOISE', 'SQUARE', 'SQUARE_WITH_NOISE', 'TRIANGLE', 'DEFAULT']
+    @panel = c
+  end
+  @hide = false
+  @source_string = open(data_path('data.json'), 'r'){ |file| file.read }
+  triangle = JSON.parse(source_string)['TRIANGLE']
+  square = JSON.parse(source_string)['SQUARE']
+  cross = JSON.parse(source_string)['CROSS']
+  circle = JSON.parse(source_string)['CIRCLE']
+  @points = []
+  srand 1
+  @net = Ai4r::NeuralNetwork::Backpropagation.new([256, 3])
+  @tr_input = triangle.flatten.collect { |input| input.to_f / 127.0}
+  @sq_input = square.flatten.collect { |input| input.to_f / 127.0}
+  @cr_input = cross.flatten.collect { |input| input.to_f / 127.0}
+  @ci_input = circle.flatten.collect { |input| input.to_f / 127.0}
+  train  
+  background 255
+end
+
+
+def draw
+  # only make control_panel visible once, or again when hide is false
+  unless hide
+    @hide = true
+    panel.set_visible(hide)    
+  end
+  if drawing
+    stroke_weight 32
+    stroke 127
+    points.each_cons(2) { |ps, pe| line ps.x, ps.y, pe.x, pe.y}
+  else    
+    no_fill
+    stroke_weight(32)
+    stroke(127)
+    case @shape
+    when 'CIRCLE'
+      background(255)
+      draw_circle
+      @shape = 'DEFAULT'
+    when 'CROSS'
+      background(255)
+      draw_cross      
+      @shape = 'DEFAULT'
+    when 'CROSS_WITH_NOISE','SQUARE_WITH_NOISE'
+      background(255)
+      draw_shape @shape
+      @shape = 'DEFAULT'
+    when 'SQUARE'
+      background(255)
+      draw_square
+      @shape = 'DEFAULT'
+    when 'TRIANGLE'
+      background(255)
+      draw_triangle
+      @shape = 'DEFAULT'
+    end
+  end
+end
+
+def draw_shape shp
+  shape = JSON.parse(source_string)[shp]
+  background(255)
+  no_stroke
+  (0  ... width / 20).each do |i|
+    (0  ... height / 20).each do |j|
+      col = 255 - shape[i][j]
+      fill(col)
+      rect(i * 20, j * 20,  20,  20)
+    end
+  end
+end
+
+def train
+  puts 'Training Network Please Wait'
+  101.times do |i|
+    error = net.train(tr_input, [1.0, 0, 0])
+    error = net.train(sq_input, [0, 1.0, 0])
+    error = net.train(cr_input, [0, 0, 1.0])
+    error = net.train(ci_input, [0, 1.0, 1.0])
+    puts "Error after iteration #{i}:\t#{format('%0.5f', error)}" if i%20 == 0
+  end
+end
+
+def result_label(result)
+  if result.reduce(0, :+).between?(1.9, 2.1)
+    if result[0] < 0.01 && result[1].between?(0.99, 1.0) && result[2].between?(0.99, 1.0)
+      return 'CIRCLE'
+    else
+      return 'UNKNOWN'
+    end
+  elsif result.reduce(0, :+).between?(0.95, 1.1)
+    if result[0].between?(0.95, 1.0) && (result[1] + result[2]) < 0.01
+      return 'TRIANGLE'
+    elsif result[1].between?(0.95, 1.0) && (result[0] + result[2]) < 0.01
+      return 'SQUARE'
+    elsif result[2].between?(0.95, 1.0) && (result[1] + result[0]) < 0.01
+      return 'CROSS'
+    else
+      return 'UNKNOWN'	  
+    end
+  end
+  return 'UNKNOWN'
+end
+
+def mouse_dragged
+  points << Vec2D.new(mouse_x, mouse_y)
+end
+
+def mouse_released
+  points.clear
+end
+
+def draw_circle
+  ellipse(width / 2, height / 2, 320 - 32, 320 - 32)
+end
+
+def draw_square
+  rect(16, 16, 320 - 32, 320 - 32)
+end
+
+def draw_cross
+  line(width / 2, 0, width / 2, 320)
+  line(0, height / 2,  320 , height / 2)
+end
+
+def draw_triangle
+  triangle(width / 2, 32, 24, height - 16,  width - 24, height - 16)
+end
+
+def clear
+  background 255
+end
+
+def evaluate    
+  load_pixels
+  img_pixels = []
+  (0...height).step(20) do |y|
+    row = []
+    (0...width).step(20) do |x|
+      row << 255 - brightness(pixels[(y + 10) * width + x + 10])
+    end
+    img_pixels << row
+  end  	
+  puts "#{net.eval(img_pixels.flatten).inspect} => #{result_label(net.eval(img_pixels.flatten))}"   	
+end
+```
+data.json
+```json
+
+{"TRIANGLE":[[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,25,229,229,25,0,0,0,0,0,0],[0,0,0,0,0,0,127,127,127,127,0,0,0,0,0,0],[0,0,0,0,0,25,229,25,25,229,25,0,0,0,0,0],[0,0,0,0,0,127,127,0,0,127,127,0,0,0,0,0],[0,0,0,0,25,229,25,0,0,25,229,25,0,0,0,0],[0,0,0,0,127,127,0,0,0,0,127,127,0,0,0,0],[0,0,0,25,229,25,0,0,0,0,25,229,25,0,0,0],[0,0,0,127,127,0,0,0,0,0,0,127,127,0,0,0],[0,0,25,229,25,0,0,0,0,0,0,25,229,25,0,0],[0,0,127,127,0,0,0,0,0,0,0,0,127,127,0,0],[0,25,229,25,0,0,0,0,0,0,0,0,25,229,25,0],[0,127,127,0,0,0,0,0,0,0,0,0,0,127,127,0],[25,229,25,0,0,0,0,0,0,0,0,0,0,25,229,25],[127,127,0,0,0,0,0,0,0,0,0,0,0,0,127,127],[255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255]]
+,"SQUARE":[[255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255]]
+,"CROSS":[[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127],[127,127,127,127,127,127,127,127,127,127,127,127,127,127,127,127],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0]]
+,"CIRCLE":[[0,0,0,0,32,64,64,80,80,64,64,32,0,0,0,0],[0,0,32,64,96,103,64,64,64,64,96,96,64,32,0,0],[0,32,96,128,96,32,0,0,0,0,32,89,128,96,32,0],[0,64,128,96,18,0,0,0,0,0,0,0,64,128,64,0],[32,96,96,18,0,0,0,0,0,0,0,0,0,82,101,32],[64,103,32,0,0,0,0,0,0,0,0,0,0,32,96,64],[64,64,0,0,0,0,0,0,0,0,0,0,0,0,64,68],[80,64,0,0,0,0,0,0,0,0,0,0,0,0,64,104],[80,64,0,0,0,0,0,0,0,0,0,0,0,0,64,106],[64,64,0,0,0,0,0,0,0,0,0,0,0,0,64,70],[64,96,32,0,0,0,0,0,0,0,0,0,0,32,96,64],[32,96,88,0,0,0,0,0,0,0,0,0,0,64,119,32],[0,64,128,64,0,0,0,0,0,0,0,0,32,113,70,0],[0,32,96,128,81,32,0,0,0,0,32,64,113,96,32,0],[0,0,32,64,102,96,64,64,64,64,96,119,70,32,0,0],[0,0,0,0,32,64,69,105,106,70,64,32,0,0,0,0]]
+,"TRIANGLE_WITH_NOISE":[[25,0,0,0,0,0,0,25,127,0,0,25,0,0,0,0],[0,0,0,0,76,0,25,229,229,25,0,0,0,0,76,0],[0,76,0,0,0,0,127,25,127,76,0,0,0,0,0,178],[0,0,0,178,0,25,229,25,25,229,25,0,0,0,76,0],[0,0,0,0,0,76,127,0,76,127,127,0,0,0,0,0],[0,25,0,0,25,229,25,0,25,25,229,25,0,0,0,0],[25,0,0,0,127,127,0,0,0,0,127,127,178,0,0,76],[0,0,76,76,229,25,0,0,25,0,25,229,25,0,0,0],[0,0,0,127,127,0,76,178,0,0,0,127,127,0,0,0],[0,0,25,229,25,0,0,0,0,0,0,25,229,25,0,0],[0,0,127,127,0,0,0,0,76,0,0,0,127,127,0,0],[0,25,229,25,0,0,0,0,0,0,0,0,25,229,25,0],[0,127,127,0,76,0,0,76,0,0,0,0,0,127,127,0],[25,229,25,0,0,76,0,0,0,25,0,0,0,25,229,25],[127,127,0,0,0,0,0,0,0,0,0,0,0,0,127,127],[255,255,255,255,25,255,255,255,255,255,25,255,255,255,255,255]]
+,"SQUARE_WITH_NOISE":[[255,76,255,255,255,153,255,255,255,255,255,102,255,255,255,255],[255,0,0,0,0,178,0,0,0,0,0,0,0,0,0,255],[255,0,76,0,0,0,0,178,0,153,25,0,0,0,0,0],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,102,0,102,0,0,0,25,0,76,0,0,102,0,255],[255,0,0,0,0,0,0,25,0,0,0,0,0,0,0,0],[255,0,0,0,76,153,0,0,25,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,102,0,0,0,0,178,0,0,255],[255,102,102,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,0,178,0,0,76,0,0,0,0,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,76,0,0,0,0,0,178,255],[255,0,76,0,102,0,0,0,0,153,0,0,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,25,0,0,255],[255,0,0,153,0,0,0,178,0,0,0,178,0,0,0,255],[255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255],[255,255,255,255,76,255,255,255,255,0,255,255,25,255,25,255]]
+,"CROSS_WITH_NOISE":[[0,0,0,0,0,0,76,76,127,0,76,0,0,0,25,0],[0,25,0,0,0,25,0,127,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,76,0,0,0],[0,0,25,204,0,0,0,127,127,0,102,0,0,0,25,0],[0,0,0,0,0,76,0,127,0,0,0,0,25,0,0,0],[0,0,0,204,0,0,0,127,127,0,0,0,0,0,0,25],[0,0,0,0,0,0,0,127,127,0,76,0,0,0,0,0],[127,127,127,204,127,76,127,127,127,127,127,127,127,127,0,5],[127,127,127,127,127,127,127,127,25,127,127,127,127,25,0,0],[0,0,0,204,0,0,0,102,127,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,102,0,0,0,0,0,0],[0,0,0,0,0,102,0,127,127,0,0,0,0,0,0,0],[102,0,0,102,0,0,0,127,127,0,0,0,25,0,0,0],[0,0,0,0,0,25,0,127,102,102,76,0,0,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,255,0,0,0],[0,0,0,0,0,0,0,127,127,0,0,0,0,0,0,0]]
+,"CIRCLE_WITH_NOISE":[[0,0,0,0,21,0,21,128,128,21,0,21,0,0,0,0],[0,0,8,17,128,128,110,0,0,21,128,128,98,21,0,0],[0,8,21,128,21,21,0,0,0,0,21,21,128,21,21,0],[0,0,128,21,0,0,0,0,0,0,0,0,21,128,2,0],[21,128,21,0,0,0,0,0,0,0,0,0,0,21,128,21],[0,128,42,0,0,0,0,0,0,0,0,0,0,31,128,0],[0,25,0,0,0,0,0,0,0,0,0,0,0,0,21,21],[128,0,0,0,0,0,0,0,0,0,0,0,0,0,89,128],[23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128],[21,24,12,0,0,0,0,0,0,0,0,0,0,0,128,21],[0,128,21,0,0,0,0,0,0,0,0,0,0,32,128,0],[21,42,21,21,0,0,0,0,0,0,0,0,0,21,128,27],[0,13,128,21,21,0,0,0,0,0,0,0,21,128,86,0],[0,3,21,128,21,31,0,0,0,0,21,21,128,21,0,0],[0,0,0,88,128,128,128,3,89,128,128,128,21,0,0,0],[0,0,0,0,21,0,21,128,128,21,0,21,0,0,0,0]]}
+#......
+```

data/docs/_layouts/post.html

@@ -1,15 +1,15 @@
 ---
 layout: default
 ---
-<article class="post" itemscope itemtype="http://schema.org/BlogPosting">
+<div class="post">
 
   <header class="post-header">
-    <h1 class="post-title" itemprop="name headline">{{ page.title }}</h1>
-    <p class="post-meta"><time datetime="{{ page.date | date_to_xmlschema }}" itemprop="datePublished">{{ page.date | date: "%b %-d, %Y" }}</time>{% if page.author %} • <span itemprop="author" itemscope itemtype="http://schema.org/Person"><span itemprop="name">{{ page.author }}</span></span>{% endif %}</p>
+    <h1 class="post-title">{{ page.title }}</h1>
+    <p class="post-meta">{{ page.date | date: "%b %-d, %Y" }}{% if page.author %} • {{ page.author }}{% endif %}{% if page.meta %} • {{ page.meta }}{% endif %}</p>
   </header>
 
-  <div class="post-content" itemprop="articleBody">
+  <article class="post-content">
     {{ content }}
-  </div>
+  </article>
 
-</article>
+</div>

data/docs/_libraries/control_panel.md

@@ -0,0 +1,137 @@
+---
+layout: post
+title:  "Control Panel<sup>2</sup>"
+keywords: library, framework, gui, processing
+permalink: libraries/control_panel.html
+---
+Inspired by Nodebox, picrate (copied from ruby-processing) provides a way to control the instance variables of your sketch with a control panel. You can create sliders, buttons, menus and checkboxes that set instance variables on your sketch. Since ruby-processing-2.0 you need to explicitly set the panel visible from the processing sketch (see included examples). Start by loading in the `control_panel` library, and then define your panel like so:-
+NB: revised version for picrate-2.7.2+
+
+__Simple Buttons Example__
+
+```ruby
+require 'picrate'
+
+class SimpleButton < Processing::App
+  load_library :control_panel
+
+  attr_reader :back
+
+  def setup
+    sketch_title 'Simple Button'
+    control_panel do |c|
+      c.look_feel 'Nimbus'
+      c.title 'Control Button'
+      c.button :color_background # needs a defined :color_background method
+      c.button :exit { exit } # button with optional block
+    end
+    color_mode RGB, 1
+    @back = [0, 0, 1.0]
+  end
+
+  def color_background
+    @back = [rand, rand, rand]
+  end
+
+  def draw
+    background *back
+  end
+
+  def settings
+    size 300, 300
+  end
+end
+
+SimpleButton.new
+
+```
+__More Complete Example__
+
+```ruby
+
+require 'picrate'
+
+class ControlPanelExample < Processing::App
+  load_library :control_panel
+
+  def settings
+    size(200, 200)
+  end
+
+  def setup
+    sketch_title 'Control Panel Example'
+    control_panel do |c|
+      c.look_feel "Nimbus"
+      c.slider :opacity
+      c.slider(:app_width, 5..60, 20) { reset! } # see reset! method
+      c.menu(:options, ['one', 'two', 'three'], 'two') { |m| load_menu_item(m) }
+      c.checkbox :paused
+      c.button :reset!
+    end
+  end
+
+  def draw
+  # Rest of the code follows
+  end
+
+  # eg
+  def reset!
+    # some action you want performed on button pressed
+  end
+end
+
+ControlPanelExample.new
+
+```
+
+This code will create a sketch with a control panel for adjusting the value of the `@opacity`, `@app_width`, `@options`, and `@paused` instance variables. The button will call the `reset!` method when clicked (a method defined by you in your sketch). The `app_width` slider will range from 5 to 60 instead of (the default) 0 to 100. The instance variable will be initialized at 20 when the sketch is loaded. The `app_width` and `options` controls have had callbacks attached to them. The callbacks will run, passing in the value of the control, any time the control changes. It all looks like this:
+
+![control panel](http://s3.amazonaws.com/jashkenas/images/control_panel.png)
+
+Here is the classic ruby-processing JWishy sketch translated for picrate, basically you enter the control_panel items in a block, to experiment just add a single item at a time and check that it works (eg :button or :checkbox)
+
+Start by loading in the control_panel library, and then define your panel in setup like so:
+
+```ruby
+require 'picrate'
+
+class JWishy < Processing::App
+  load_library :control_panel
+  attr_reader :panel
+
+  def settings
+    size 600, 600
+  end
+
+  def setup
+    sketch_title 'Wishy Worm'
+    control_panel do |c|
+      c.title 'Control Panel'
+      c.look_feel 'Nimbus'
+      c.slider    :bluish, 0.0..1.0, 0.5
+      c.slider    :alpha,  0.0..1.0, 0.5
+      c.checkbox  :go_big
+      c.button    :reset
+      c.menu      :shape, %w(oval square triangle)
+    end
+    @hide = false
+    @shape = 'oval'
+    @go_big = false
+    @x_wiggle, @y_wiggle = 10.0, 0
+    @magnitude = 8.15
+    @back_color = [0.06, 0.03, 0.18]
+    color_mode RGB, 1
+    ellipse_mode CORNER
+    smooth
+  end
+
+  #....rest of code
+
+  def draw
+    #.... rest of draw
+  end
+
+```
+![JWishy]({{site.github.url}}/assets/jwishy.png)
+
+See also [penrose](https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec2d/penrose.rb) and [bezier playground](https://github.com/ruby-processing/picrate-examples/blob/master/contributed/bezier_playground.rb) sketches. See ruby code [here](https://github.com/ruby-processing/picrate/blob/master/library/control_panel/control_panel.rb).

data/docs/_libraries/custom.md

@@ -0,0 +1,126 @@
+---
+layout: post
+title:  "custom ruby library<sup>3</sup>"
+keywords: library, ruby, custom
+permalink: libraries/custom.html
+---
+<sup>3</sup><i>A custom ruby library</i>
+
+The custom ruby library `library/palette/palette.rb`
+
+```ruby
+class Palette
+  include Processing::Proxy # needed to access 'color' and 'map1d'
+  attr_reader :palette
+
+  def initialize
+    @palette = make_palette
+  end
+
+  def make_palette
+    (0..256).map do |i|
+      # Create the bands of colour for the palette (256 is the maximum colour))
+      case i
+      when 0..64 # Range of reds
+        color(*[map1d(i, 0..64, 1..255), 0, 0])
+      when 64..128 # Range of orange
+        color(*[255, map1d(i, 64..128, 1..255), 0])
+      when 128..172 # range of yellow
+        color(*[255, 255, map1d(i, 128..172, 1..255)])
+      else
+        color(*[180, 0, 0])
+      end
+    end
+  end
+
+  def self.create_palette
+    Palette.new.palette
+  end
+end
+```
+
+A sketch using the custom palette library:-
+
+```ruby
+require 'picrate'
+
+# After original by Alex Young https://github.com/alexyoung/fire-p5r
+
+# Algorithm:
+# 1. Create an indexed palette of red, orange and yellows
+# 2. Loop:
+# 3.   Draw a random set of colours from the palette at the bottom of the screen
+# 4.   Loop through each pixel and average the colour index value around it
+# 5.   Reduce the average by a fire intensity factor
+
+# jruby fire.rb
+class Fire < Processing::App
+  load_library :palette
+
+  def settings
+    size 320, 240
+  end
+
+  def setup
+    sketch_title 'Fire'
+    frame_rate 30
+    @palette = Palette.create_palette
+    @fire = []
+    @scale = 8
+    @width = width / @scale
+    @height = height / @scale
+    @intensity = 2
+  end
+
+  def draw
+    background 0
+    update_fire
+  end
+
+  def update_fire
+    random_line @height - 1
+    (0..@height - 2).each do |y|
+      (0..@width).each do |x|
+        # Wrap
+        left = x.zero? ? fire_data(@width - 1, y) : fire_data(x - 1, y)
+        right = (x == @width - 1) ? fire_data(0, y) : fire_data(x + 1, y)
+        below = fire_data(x, y + 1)
+        # Get the average pixel value
+        average = (left.to_i + right.to_i + (below.to_i * 2)) / 4
+        # Fade the flames
+        average -= @intensity if average > @intensity
+        set_fire_data x, y, average
+        fill @palette[average]
+        stroke @palette[average]
+        rect x * @scale, (y + 1) * @scale, @scale, @scale
+      end
+    end
+  end
+
+  def fire_data(x, y)
+    @fire[offset(x, y)]
+  end
+
+  def set_fire_data(x, y, value)
+    @fire[offset(x, y)] = value.to_i
+  end
+
+  def random_offset
+    rand(0..@palette.size)
+  end
+
+  def random_line(y)
+    (0...@width).each do |x|
+      @fire[offset(x, y)] = random_offset
+    end
+  end
+
+  def offset(x, y)
+    (y * @width) + x
+  end
+end
+
+Fire.new
+```
+
+See also this [example](https://github.com/ruby-processing/picrate-examples/blob/master/topics/vectors/cubes_in_cube.rb), makes most sense when you might re-use your library for several sketches.

data/docs/_libraries/custom_java.md

@@ -0,0 +1,162 @@
+---
+layout: post
+title:  "custom java library<sup>4</sup>"
+keywords: library, ruby, custom
+permalink: libraries/custom_java.html
+---
+<sup>4</sup><i>A custom java library</i>
+
+See [github](https://github.com/ruby-processing/picrate-examples/tree/master/nature-of-code/xor) for the java source that gets compiled to `nn.jar`, where the `nn.jar` is nested in `library/nn` folder. Here is the sketch that uses the custom nn library:-
+
+__xor.rb__
+
+```ruby
+require 'picrate'
+# The Nature of Code
+# Daniel Shiffman
+# https://natureofcode.com
+# XOR Multi-Layered Neural Network Example
+# Neural network code is all in the 'code' folder
+class Xor < Processing::App
+  load_library :nn
+
+  require_relative './landscape'
+  include_package 'nn'
+
+  ITERATIONS_PER_FRAME = 5
+
+  attr_reader :inputs, :nn, :count, :land, :theta, :f, :result, :known
+
+  def setup
+    sketch_title 'XOR'
+    @theta = 0.0
+    # Create a landscape object
+    @land = Landscape.new(20, 300, 300)
+    @f = create_font('Courier', 12, true)
+    @nn = Network.new(2, 4)
+    @count = 0
+    # Create a list of 4 training inputs
+    @inputs = []
+    inputs << [1.0, 0]
+    inputs << [0, 1.0]
+    inputs << [1.0, 1.0]
+    inputs << [0, 0.0]
+  end
+
+  def draw
+    lights
+    ITERATIONS_PER_FRAME.times do
+      inp = inputs.sample
+      # Compute XOR
+      @known = ((inp[0] > 0.0 && inp[1] > 0.0) || (inp[0] < 1.0 && inp[1] < 1.0)) ? 0 : 1.0
+      # Train that sucker!
+      @result = nn.train(inp, known)
+      @count += 1
+    end
+    # Ok, visualize the solution space
+    background(175)
+    push_matrix
+    translate(width / 2, height / 2 + 20, -160)
+    rotate_x(Math::PI / 3)
+    rotate_z(theta)
+    # Put a little BOX on screen
+    push_matrix
+    stroke(50)
+    no_fill
+    translate(-10, -10, 0)
+    box(280)
+    land.calculate(nn)
+    land.render
+    # Draw the landscape
+    pop_matrix
+    @theta += 0.0025
+    pop_matrix
+    # Display overal neural net stats
+    network_status
+  end
+
+  def network_status
+    mse = 0.0
+    text_font(f)
+    fill(0)
+    text('Your friendly neighborhood neural network solving XOR.', 10, 20)
+    text(format('Total iterations: %d', count), 10, 40)
+    mse += (result - known) * (result - known)
+    rmse = Math.sqrt(mse / 4.0)
+    out = format('Root mean squared error: %.5f', rmse)
+    hint DISABLE_DEPTH_SORT
+    text(out, 10, 60)
+    hint ENABLE_DEPTH_SORT
+  end
+
+  def settings
+    size(400, 400, P3D)
+  end
+end
+
+Xor.new
+```
+__landscape.rb__
+
+```ruby
+# The Nature of Code
+# Daniel Shiffman
+# https://natureofcode.com
+
+# "Landscape" example
+class Landscape
+  include Processing::Proxy
+
+  attr_reader :scl, :w, :h, :rows, :cols, :z, :zoff
+
+  def initialize(scl, w, h)
+    @scl, @w, @h  = scl, w, h
+    @cols = w / scl
+    @rows = h / scl
+    @z = Array.new(cols, Array.new(rows, 0.0))
+    @zoff = 0
+  end
+
+  # Calculate height values (based off a neural network)
+  def calculate(nn)
+    val = lambda do |curr, net, x, y|
+      curr * 0.95 + 0.05 * (net.feed_forward([x, y]) * 280.0 - 140.0)
+    end
+    @z = (0...cols).map do |i|
+      (0...rows).map do |j|
+        val.call(z[i][j], nn, i * 1.0 / cols, j * 1.0 / cols)
+      end
+    end
+  end
+
+  # Render landscape as grid of quads
+  def render
+    # Every cell is an individual quad
+    # (could use quad_strip here, but produces funny results, investigate this)
+    (0...z.size - 1).each do |x|
+      (0...z[0].size - 1).each do |y|
+        # one quad at a time
+        # each quad's color is determined by the height value at each vertex
+        # (clean this part up)
+        no_stroke
+        push_matrix
+        begin_shape(PConstants::QUADS)
+        translate(x * scl - w * 0.5, y * scl - h * 0.5, 0)
+        fill(z[x][y] + 127, 220)
+        vertex(0, 0, z[x][y])
+        fill(z[x + 1][y] + 127, 220)
+        vertex(scl, 0, z[x + 1][y])
+        fill(z[x + 1][y + 1] + 127, 220)
+        vertex(scl, scl, z[x + 1][y + 1])
+        fill(z[x][y + 1] + 127, 220)
+        vertex(0, scl, z[x][y + 1])
+        end_shape
+        pop_matrix
+      end
+    end
+  end
+end
+
+```
+
+See also the [pbox2d](https://github.com/ruby-processing/jbox2d) gem.