processing 0.5.29 → 0.5.31

data/lib/processing/shape.rb

@@ -0,0 +1,183 @@
+module Processing
+
+
+  # Shape object.
+  #
+  class Shape
+
+    # @private
+    def initialize(polygon = nil, children = nil, context: nil)
+      @polygon, @children = polygon, children
+      @context            = context || Context.context__
+      @visible, @matrix   = true, nil
+      @mode = @points = @closed = 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(mode = nil)
+      @mode     = mode
+      @points ||= []
+      @polygon  = nil# clear cache
+      nil
+    end
+
+    def endShape(close = nil)
+      raise "endShape() must be called after beginShape()" unless @points
+      @closed = close == GraphicsContext::CLOSE
+      nil
+    end
+
+    def vertex(x, y)
+      raise "vertex() must be called after beginShape()" unless @points
+      @points << x << y
+    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 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 matrix__()
+      @matrix ||= Rays::Matrix.new
+    end
+
+    # @private
+    def getInternal__()
+      unless @polygon
+        return nil unless @points && @closed != nil
+        @polygon = self.class.createPolygon__ @mode, @points, @closed
+      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__(mode, points, close = false)
+      g = GraphicsContext
+      case mode
+      when g::POINTS         then Rays::Polygon.points(        *points)
+      when g::LINES          then Rays::Polygon.lines(         *points)
+      when g::TRIANGLES      then Rays::Polygon.triangles(     *points)
+      when g::TRIANGLE_FAN   then Rays::Polygon.triangle_fan(  *points)
+      when g::TRIANGLE_STRIP then Rays::Polygon.triangle_strip(*points)
+      when g::QUADS          then Rays::Polygon.quads(         *points)
+      when g::QUAD_STRIP     then Rays::Polygon.quad_strip(    *points)
+      when g::TESS, nil      then Rays::Polygon.new(*points, loop: close)
+      else raise ArgumentError, "invalid polygon mode '#{mode}'"
+      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,14 +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.39'
-  s.add_runtime_dependency 'rucy',      '~> 0.1.40'
-  s.add_runtime_dependency 'rays',      '~> 0.1.45'
-  s.add_runtime_dependency 'reflexion', '~> 0.1.53'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'test-unit'
-  s.add_development_dependency 'yard'
+  s.add_runtime_dependency 'xot',       '~> 0.1.41'
+  s.add_runtime_dependency 'rucy',      '~> 0.1.42'
+  s.add_runtime_dependency 'rays',      '~> 0.1.47'
+  s.add_runtime_dependency 'reflexion', '~> 0.1.55'
 
   s.files            = `git ls-files`.split $/
   s.test_files       = s.files.grep %r{^(test|spec|features)/}

data/test/helper.rb

@@ -5,38 +5,133 @@
 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, &block)
-  Processing::Graphics.new(width, height).tap do |g|
+def graphics(width = 10, height = 10, *args, &block)
+  Processing::Graphics.new(width, height, *args).tap do |g|
     g.beginDraw {block.call g, g.getInternal__} if 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
   assert_in_delta v1.z, v2.z, delta
 end
+
+def assert_equal_pixels(expected, actual, threshold: 1.0)
+  exp_pixels = get_pixels expected
+  act_pixels = get_pixels actual
+  raise "Number of pixels does not match" if act_pixels.size != exp_pixels.size
+
+  equal_count = exp_pixels.zip(act_pixels).count {|a, b| a == b}
+  equal_rate  = equal_count.to_f / act_pixels.size.to_f
+  assert equal_rate >= threshold, <<~EOS
+    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)
+
+  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, headless: true
+  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/p5.rb

@@ -0,0 +1,76 @@
+require 'open-uri'
+require 'ferrum'
+
+RUBY_URL = 'https://cdn.jsdelivr.net/npm/ruby-3_2-wasm-wasi@next/dist/browser.script.iife.js'
+P5JS_URL = 'https://cdn.jsdelivr.net/npm/p5@1.5.0/lib/p5.js'
+P5RB_URL = 'https://raw.githubusercontent.com/ongaeshi/p5rb/master/docs/lib/p5.rb'
+
+P5RB_SRC = URI.open(P5RB_URL) {|f| f.read}
+
+def browser(width, height, headless: true)
+  hash        = ($browsers ||= {})
+  key         = [width, height, headless]
+  hash[key] ||= Ferrum::Browser.new headless: headless, window_size: [width, height]
+end
+
+def get_p5rb_html(width, height, draw_src)
+  <<~END
+    <html>
+      <head>
+        <script src="#{RUBY_URL}"></script>
+        <script src="#{P5JS_URL}"></script>
+        <script type="text/ruby">#{P5RB_SRC}</script>
+        <style type="text/css">
+          body {margin: 0;}
+        </style>
+        <script type="text/javascript">
+          function completed() {
+            id = 'completed'
+            if (document.querySelector("#" + id)) return;
+            let e = document.createElement("span");
+            e.id = id;
+            document.body.appendChild(e);
+          }
+        </script>
+        <script type="text/ruby">
+          def setup()
+            createCanvas #{width}, #{height}
+          end
+          def draw()
+            #{draw_src}
+            JS.global.completed
+          end
+          P5::init
+        </script>
+      </head>
+      <body><main></main></body>
+    </html>
+  END
+end
+
+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)
+  b = browser width, height, headless: headless
+  unless File.exist? path
+    b.reset
+    b.main_frame.content = get_p5rb_html width, height, draw_src
+    sleep_until do
+      b.evaluate 'document.querySelector("#completed") != null'
+    end
+    b.screenshot path: path
+  end
+  b.device_pixel_ratio
+end

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,9 +18,9 @@ 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 get_pixels(g), get_pixels(g.loadImage path)
+      assert_equal_pixels g, g.loadImage(path)
     end
   end