processing 0.5.30 → 0.5.32

data/lib/processing/image.rb

@@ -10,6 +10,7 @@ module Processing
     # @private
     def initialize(image)
       @image = image
+      @pixels, @error = nil, false
     end
 
     # Gets width of image.
@@ -17,7 +18,7 @@ module Processing
     # @return [Numeric] width of image
     #
     def width()
-      @image.width
+      @image&.width || (@error ? -1 : 0)
     end
 
     # Gets height of image.
@@ -25,7 +26,7 @@ module Processing
     # @return [Numeric] height of image
     #
     def height()
-      @image.height
+      @image&.height || (@error ? -1 : 0)
     end
 
     alias w width
@@ -36,7 +37,7 @@ module Processing
     # @return [Array<Numeric>] [width, height]
     #
     def size()
-      @image.size
+      [width, height]
     end
 
     # Sets the color of the pixel.
@@ -48,21 +49,43 @@ module Processing
     # @return [nil] nil
     #
     def set(x, y, c)
-      @image.bitmap[x, y] = self.class.fromColor__ c
+      getInternal__.bitmap[x, y] = self.class.fromColor__ c
       nil
     end
 
-
     # Returns the color of the pixel.
     #
     # @return [Integer] color value (0xAARRGGBB)
     #
     def get(x, y)
-      @image.bitmap[x, y]
+      getInternal__.bitmap[x, y]
         .map {|n| (n * 255).to_i.clamp 0, 255}
         .then {|r, g, b, a| self.class.toColor__ r, g, b, a}
     end
 
+    # Loads all pixels to the 'pixels' array.
+    #
+    # @return [nil] nil
+    #
+    def loadPixels()
+      @pixels = getInternal__.pixels
+    end
+
+    # Update the image pixels with the 'pixels' array.
+    #
+    # @return [nil] nil
+    #
+    def updatePixels()
+      return unless @pixels
+      getInternal__.pixels = @pixels
+      @pixels = nil
+    end
+
+    # An array of all pixels.
+    # Call loadPixels() before accessing the array.
+    #
+    attr_reader :pixels
+
     # Applies an image filter.
     #
     # overload filter(shader)
@@ -86,7 +109,7 @@ module Processing
     #
     def resize(width, height)
       @image = Rays::Image.new(width, height).paint do |painter|
-        painter.image @image, 0, 0, width, height
+        painter.image getInternal__, 0, 0, width, height
       end
       nil
     end
@@ -132,7 +155,7 @@ module Processing
     #
     def blend(img = nil, sx, sy, sw, sh, dx, dy, dw, dh, mode)
       img ||= self
-      @image.paint do |painter|
+      getInternal__.paint do |painter|
         img.drawImage__ painter, sx, sy, sw, sh, dx, dy, dw, dh, blend_mode: mode
       end
       nil
@@ -145,13 +168,18 @@ module Processing
     # @return [nil] nil
     #
     def save(filename)
-      @image.save filename
+      getInternal__.save filename
       nil
     end
 
     # @private
     def getInternal__()
-      @image
+      @image or raise 'Invalid image object'
+    end
+
+    # @private
+    def setInternal__(image, error = false)
+      @image, @error = image, error
     end
 
     # @private

data/lib/processing/shape.rb

@@ -0,0 +1,294 @@
+module Processing
+
+
+  # Shape object.
+  #
+  class Shape
+
+    # @private
+    def initialize(polygon = nil, children = nil, context: nil)
+      @polygon, @children      = polygon, children
+      @context                 = context || Context.context__
+      @visible, @fill, @matrix = true, nil, nil
+      @type = @points = @curvePoints = @colors = @texcoords = @close = nil
+      @contours = @contourPoints = @contourColors = @contourTexCoords = nil
+    end
+
+    # Gets width of shape.
+    #
+    # @return [Numeric] width of shape
+    #
+    def width()
+      polygon = getInternal__ or return 0
+      (@bounds ||= polygon.bounds).width
+    end
+
+    # Gets height of shape.
+    #
+    # @return [Numeric] height of shape
+    #
+    def height()
+      polygon = getInternal__ or return 0
+      (@bounds ||= polygon.bounds).height
+    end
+
+    alias w width
+    alias h height
+
+    # Returns whether the shape is visible or not.
+    #
+    # @return [Boolean] visible or not
+    #
+    def isVisible()
+      @visible
+    end
+
+    alias visible? isVisible
+
+    # Sets whether to display the shape or not.
+    #
+    # @return [nil] nil
+    #
+    def setVisible(visible)
+      @visible = !!visible
+      nil
+    end
+
+    def beginShape(type = nil)
+      raise "beginShape() cannot be called twice" if drawingShape__
+      @type        = type
+      @points    ||= []
+      @curvePoints = []
+      @colors    ||= []
+      @texcoords ||= []
+      @close       = nil
+      @contours  ||= []
+      clearCache__
+      nil
+    end
+
+    def endShape(close = nil)
+      raise "endShape() must be called after beginShape()" unless drawingShape__
+      @close = close == GraphicsContext::CLOSE || @contours.size > 0
+      if @close && @curvePoints.size >= 8
+        x, y = @curvePoints[0, 2]
+        2.times {curveVertex x, y}
+      end
+      @curvePoints = nil
+      nil
+    end
+
+    def beginContour()
+      raise "beginContour() must be called after beginShape()" unless drawingShape__
+      @contourPoints, @contourColors, @contourTexCoords = [], [], []
+      nil
+    end
+
+    def endContour()
+      raise "endContour() must be called after beginContour()" unless drawingContour__
+      @contours << Rays::Polyline.new(
+        *@contourPoints, colors: @contourColors, texcoords: @contourTexCoords,
+        loop: true, hole: true)
+      @contoursPoints = @contoursColors = @contoursTexCoords = nil
+      nil
+    end
+
+    def vertex(x, y, u = nil, v = nil)
+      raise "vertex() must be called after beginShape()" unless drawingShape__
+      raise "Either 'u' or 'v' is missing" if (u == nil) != (v == nil)
+      u   ||= x
+      v   ||= y
+      color = @fill || @context.getFill__
+      if drawingContour__
+        @contourPoints    << x << y
+        @contourColors    << color
+        @contourTexCoords << u << v
+      else
+        @points    << x << y
+        @colors    << color
+        @texcoords << u << v
+      end
+    end
+
+    def curveVertex(x, y)
+      raise "curveVertex() must be called after beginShape()" unless drawingShape__
+      @curvePoints << x << y
+      if @curvePoints.size >= 8
+        Rays::Polygon.curve(*@curvePoints[-8, 8])
+          .first.to_a.tap {|a| a.shift if @curvePoints.size > 8}
+          .each {|p| vertex p.x, p.y}
+      end
+      nil
+    end
+
+    def bezierVertex(x2, y2, x3, y3, x4, y4)
+      raise "bezierVertex() must be called after beginShape()" unless drawingShape__
+      x1, y1 = @points[-2, 2]
+      raise "vertex() is required before calling bezierVertex()" unless x1 && y1
+      Rays::Polygon.bezier(x1, y1, x2, y2, x3, y3, x4, y4)
+        .first.to_a.tap {|a| a.shift}
+        .each {|p| vertex p.x, p.y}
+      nil
+    end
+
+    def quadraticVertex(cx, cy, x3, y3)
+      x1, y1 = @points[-2, 2]
+      raise "vertex() is required before calling quadraticVertex()" unless x1 && y1
+      bezierVertex(
+        x1 + (cx - x1) * 2.0 / 3.0, y1 + (cy - y1) * 2.0 / 3.0,
+        x3 + (cx - x3) * 2.0 / 3.0, y3 + (cy - y3) * 2.0 / 3.0,
+        x3,                         y3)
+      nil
+    end
+
+    # @private
+    def drawingShape__()
+      @curvePoints
+    end
+
+    # @private
+    def drawingContour__()
+      @contourPoints
+    end
+
+    def fill(*args)
+      @fill = @context.toRaysColor__(*args)
+    end
+
+    def setVertex(index, point)
+      return nil unless @points && @points[index * 2, 2]&.size == 2
+      @points[index * 2, 2] = [point.x, point.y]
+    end
+
+    def getVertex(index)
+      return nil unless @points
+      point = @points[index * 2, 2]
+      return nil unless point&.size == 2
+      @context.createVector(*point)
+    end
+
+    def getVertexCount()
+      return 0 unless @points
+      @points.size / 2
+    end
+
+    def setFill(*args)
+      color = @context.toRaysColor__(*args)
+      count = getVertexCount
+      if count > 0
+        if @colors
+          @colors.fill color
+        else
+          @colors = [color] * count
+        end
+        clearCache__
+      elsif @polygon
+        @polygon = @polygon.transform do |polylines|
+          polylines.map {|pl| pl.with colors: pl.points.map {color}}
+        end
+      end
+    end
+
+    def addChild(child)
+      return unless @children
+      @children.push child
+      nil
+    end
+
+    def getChild(index)
+      @children&.[](index)
+    end
+
+    def getChildCount()
+      @children&.size || 0
+    end
+
+    def translate(x, y, z = 0)
+      matrix__.translate x, y, z
+      nil
+    end
+
+    def rotate(angle)
+      matrix__.rotate @context.toDegrees__(angle)
+      nil
+    end
+
+    def scale(x, y, z = 1)
+      matrix__.scale x, y, z
+      nil
+    end
+
+    def resetMatrix()
+      @matrix = nil
+    end
+
+    def rotateX = nil
+    def rotateY = nil
+    def rotateZ = nil
+
+    # @private
+    def clearCache__()
+      @polygon = nil# clear cache
+    end
+
+    # @private
+    def matrix__()
+      @matrix ||= Rays::Matrix.new
+    end
+
+    # @private
+    def getInternal__()
+      unless @polygon
+        return nil unless @points && @close != nil
+        @polygon = self.class.createPolygon__(
+          @type, @points, @close, @colors, @texcoords)
+        @polygon += @contours if @polygon
+      end
+      @polygon
+    end
+
+    # @private
+    def draw__(painter, x, y, w = nil, h = nil)
+      poly = getInternal__
+
+      backup = nil
+      if @matrix && (poly || @children)
+        backup = painter.matrix
+        painter.matrix = backup * @matrix
+      end
+
+      if poly
+        if w || h
+          painter.polygon poly, x, y, w,h
+        else
+          painter.polygon poly, x, y
+        end
+      end
+      @children&.each {|o| o.draw__ painter, x, y, w, h}
+
+      painter.matrix = backup if backup
+    end
+
+    # @private
+    def self.createPolygon__(
+      type, points, close = false, colors = nil, texcoords = nil)
+
+      kwargs = {colors: colors, texcoords: texcoords}
+      g, p   = GraphicsContext, Rays::Polygon
+      case type
+      when g::POINTS         then p.points(        *points)
+      when g::LINES          then p.lines(         *points)
+      when g::TRIANGLES      then p.triangles(     *points, **kwargs)
+      when g::TRIANGLE_FAN   then p.triangle_fan(  *points, **kwargs)
+      when g::TRIANGLE_STRIP then p.triangle_strip(*points, **kwargs)
+      when g::QUADS          then p.quads(         *points, **kwargs)
+      when g::QUAD_STRIP     then p.quad_strip(    *points, **kwargs)
+      when g::TESS, nil      then p.new(           *points, **kwargs, loop: close)
+      else raise ArgumentError, "invalid polygon type '#{type}'"
+      end
+    end
+
+  end# Shape
+
+
+end# Processing

data/lib/processing/vector.rb

@@ -463,9 +463,9 @@ module Processing
     # @return [Vector] rotated this object
     #
     def rotate(angle)
-      angle = @context ?
-        @context.toAngle__(angle) : angle * GraphicsContext::RAD2DEG__
-      @point.rotate! angle
+      deg = @context ?
+        @context.toDegrees__(angle) : angle * GraphicsContext::RAD2DEG__
+      @point.rotate! deg
       self
     end
 

data/processing.gemspec

@@ -25,10 +25,10 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_runtime_dependency 'xot',       '~> 0.1.40'
-  s.add_runtime_dependency 'rucy',      '~> 0.1.41'
-  s.add_runtime_dependency 'rays',      '~> 0.1.46'
-  s.add_runtime_dependency 'reflexion', '~> 0.1.54'
+  s.add_runtime_dependency 'xot',       '~> 0.1.41'
+  s.add_runtime_dependency 'rucy',      '~> 0.1.43'
+  s.add_runtime_dependency 'rays',      '~> 0.1.48'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.56'
 
   s.files            = `git ls-files`.split $/
   s.test_files       = s.files.grep %r{^(test|spec|features)/}

data/test/helper.rb

@@ -5,28 +5,61 @@
 require 'xot/test'
 require 'processing/all'
 
+require 'digest/md5'
+require 'fileutils'
 require 'tempfile'
 require 'test/unit'
 
 include Xot::Test
 
 
-def temppath(ext: nil, &block)
+DEFAULT_DRAW_HEADER = <<~END
+  background 100
+  fill 255, 0, 0
+  stroke 0, 255, 0
+  strokeWeight 50
+END
+
+
+def test_with_p5?()
+  ENV['TEST_WITH_P5'] == '1'
+end
+
+def md5(s)
+  Digest::MD5.hexdigest s
+end
+
+def mkdir(dir: nil, filename: nil)
+  path = dir || File.dirname(filename)
+  FileUtils.mkdir_p path unless File.exist? path
+end
+
+def test_label(index = 1)
+  caller_locations[index].then {|loc| "#{loc.label}_#{loc.lineno}"}
+end
+
+def temp_path(ext: nil, &block)
   f     = Tempfile.new
   path  = f.path
-  path += ".#{ext}" if ext
+  path += ext if ext
   f.close!
   block.call path
   File.delete path
 end
 
+def draw_output_path(label, *sources, ext: '.png', dir: ext)
+  src  = sources.compact.then {|ary| ary.empty? ? '' : "_#{md5 ary.join("\n")}"}
+  path = File.join __dir__, dir, label + src + ext
+  mkdir filename: path
+  path
+end
+
 def get_pixels(image)
   %i[@image @image__]
     .map {image.instance_variable_get _1}
     .compact
     .first
-    .bitmap
-    .to_a
+    .pixels
 end
 
 def graphics(width = 10, height = 10, *args, &block)
@@ -35,6 +68,14 @@ def graphics(width = 10, height = 10, *args, &block)
   end
 end
 
+def test_draw(*sources, width: 1000, height: 1000, pixelDensity: 1, label: nil)
+  graphics(width, height, pixelDensity).tap do |g|
+    g.beginDraw {g.instance_eval sources.compact.join("\n")}
+    g.save draw_output_path(label, *sources) if label
+  end
+end
+
+
 def assert_equal_vector(v1, v2, delta = 0.000001)
   assert_in_delta v1.x, v2.x, delta
   assert_in_delta v1.y, v2.y, delta
@@ -52,3 +93,44 @@ def assert_equal_pixels(expected, actual, threshold: 1.0)
     The rate of the same pixel #{equal_rate} is below the threshold #{threshold}
   EOS
 end
+
+def assert_equal_draw(
+  *shared_header, expected, actual, default_header: DEFAULT_DRAW_HEADER,
+  width: 1000, height: 1000, threshold: 1.0, label: test_label)
+
+  e = test_draw default_header, *shared_header, expected, label: "#{label}_expected"
+  a = test_draw default_header, *shared_header, actual,   label: "#{label}_actual"
+
+  assert_equal_pixels e, a, threshold: threshold
+end
+
+def assert_p5_draw(
+  *sources, default_header: DEFAULT_DRAW_HEADER,
+  width: 1000, height: 1000, threshold: 0.99, label: test_label, **kwargs)
+
+  return unless test_with_p5?
+
+  source = [default_header, *sources].compact.join("\n")
+  path   = draw_output_path "#{label}_expected", source
+
+  pd     = draw_p5rb width, height, source, path, **kwargs
+  actual = test_draw source, width: width, height: height, pixelDensity: pd
+  actual.save path.sub('_expected', '_actual')
+
+  assert_equal_pixels actual.loadImage(path), actual, threshold: threshold
+end
+
+def assert_p5_fill(*sources, **kwargs)
+  assert_p5_draw 'noStroke', *sources, label: test_label, **kwargs
+end
+
+def assert_p5_stroke(*sources, **kwargs)
+  assert_p5_draw 'noFill; stroke 0, 255, 0', *sources, label: test_label, **kwargs
+end
+
+def assert_p5_fill_stroke(*sources, **kwargs)
+  assert_p5_draw 'stroke 0, 255, 0', *sources, label: test_label, **kwargs
+end
+
+
+require_relative 'p5' if test_with_p5?

data/test/{draw/p5.rb → p5.rb}

@@ -13,7 +13,7 @@ def browser(width, height, headless: true)
   hash[key] ||= Ferrum::Browser.new headless: headless, window_size: [width, height]
 end
 
-def get_p5rb_html(width, height, draw_src)
+def get_p5rb_html(width, height, draw_src, webgl: false)
   <<~END
     <html>
       <head>
@@ -34,12 +34,10 @@ def get_p5rb_html(width, height, draw_src)
         </script>
         <script type="text/ruby">
           def setup()
-            createCanvas #{width}, #{height}
+            createCanvas #{width}, #{height}#{webgl ? ', WEBGL' : ''}
           end
           def draw()
-            background 0
-            fill 255, 0, 0
-            noStroke
+            #{webgl ? 'translate -width / 2, -height / 2' : ''}
             #{draw_src}
             JS.global.completed
           end
@@ -51,12 +49,28 @@ def get_p5rb_html(width, height, draw_src)
   END
 end
 
-def draw_p5rb(width, height, draw_src, path, headless: true)
+def sleep_until (try: 3, timeout: 10, &block)
+  now = -> offset = 0 {Time.now.to_f + offset}
+  limit = now[timeout]
+  until block.call
+    if now[] > limit
+      limit = now[timeout]
+      try -= 1
+      next if try > 0
+      raise 'Drawing timed out in p5.rb'
+    end
+    sleep 0.1
+  end
+end
+
+def draw_p5rb(width, height, draw_src, path, headless: true, webgl: false)
   b = browser width, height, headless: headless
   unless File.exist? path
     b.reset
-    b.main_frame.content = get_p5rb_html width, height, draw_src
-    sleep 0.1 until b.evaluate 'document.querySelector("#completed") != null'
+    b.main_frame.content = get_p5rb_html width, height, draw_src, webgl: webgl
+    sleep_until do
+      b.evaluate 'document.querySelector("#completed") != null'
+    end
     b.screenshot path: path
   end
   b.device_pixel_ratio

data/test/test_font.rb

@@ -5,12 +5,43 @@ class TestFont < Test::Unit::TestCase
 
   P = Processing
 
-  def font()
-    P::Font.new Rays::Font.new(nil, 10)
+  def font(*args)
+    P::Font.new(Rays::Font.new *args).tap {|font|
+      def font.intern()
+        getInternal__
+      end
+    }
+  end
+
+  def test_initialize()
+    assert_not_nil        font(nil)    .intern.name
+    assert_equal 'Arial', font('Arial').intern.name
+
+    assert_equal 12, font         .intern.size
+    assert_equal 10, font(nil, 10).intern.size
+  end
+
+  def test_size()
+    f  = font nil, 10
+    id = f.intern.object_id
+
+    assert_equal 10, f.intern.size
+
+    f.setSize__ 11
+    assert_equal 11, f.intern.size
+    assert_not_equal id, f.intern.object_id
+
+    f.setSize__ 10
+    assert_equal 10, f.intern.size
+    assert_equal id, f.intern.object_id
   end
 
   def test_inspect()
     assert_match %r|#<Processing::Font: name:'[\w\s]+' size:[\d\.]+>|, font.inspect
   end
 
+  def test_list()
+    assert_not P::Font.list.empty?
+  end
+
 end# TestFont

data/test/test_graphics.rb

@@ -3,12 +3,6 @@ require_relative 'helper'
 
 class TestGraphics < Test::Unit::TestCase
 
-  P = Processing
-
-  def graphics(w = 10, h = 10)
-    P::Graphics.new w, h
-  end
-
   def test_beginDraw()
     g = graphics
     g.beginDraw
@@ -24,7 +18,7 @@ class TestGraphics < Test::Unit::TestCase
       g.ellipseMode :corner
       g.ellipse 0, 0, g.width, g.height
     end
-    temppath(ext: 'png') do |path|
+    temp_path(ext: '.png') do |path|
       assert_nothing_raised {g.save path}
       assert_equal_pixels g, g.loadImage(path)
     end