ruby-processing 2.6.3 → 2.6.4

data/samples/external_library/java_processing/grafica/oktoberfest_example.rb

@@ -1,83 +0,0 @@
-require 'csv'
-load_library :grafica
-include_package 'grafica'
-
-MONTH_NAMES = %w(January February March April May June July August September October November December)
-DAYS_PER_MONTH = [31,28,31,30,31,30,31,31,30,31,30,31]
-DAYS_PER_MONTH_LEAP_YEAR = [31,29,31,30,31,30,31,31,30,31,30,31]
-
-attr_reader :plot, :points_oktoberfest, :points_elections
-
-def setup
-  size(800, 400)
-  
-  # Load the Oktoberfest vs. Bundestagswahl (German elections day) Google 
-  # search history file (obtained from the Google trends page). 
-  # The csv file has the following format: 
-  # year,month,day,oktoberfest,bundestagswahl
-  # 2004,0,1,5,1
-  # ...
-  @points_oktoberfest = GPointsArray.new
-  @points_elections = GPointsArray.new
-  
-  
-  data = CSV.read("data/OktoberfestVSGermanElections.csv", :headers => true).map{|row| row.to_hash}
-  data.each do |row|
-    # You access the values via their column name (set by using headers option above)
-    year = row["year"].to_i
-    month = row["month"].to_i
-    day = row["day"].to_i
-    date = get_exact_date(year, month, day)
-    oktoberfest_count = row["oktoberfest"].to_i
-    elections_count = row["bundestagswahl"].to_i
-    points_oktoberfest.add(date, oktoberfest_count, MONTH_NAMES[month])
-    points_elections.add(date, elections_count, MONTH_NAMES[month])
-  end
-  # Create the plot
-  @plot = GPlot.new(self)
-  plot.set_dim(700, 300)
-  plot.set_title_text("Oktoberfest vs. Bundestagwahl Google search history")
-  plot.getXAxis.set_axis_label_text("Year")
-  plot.getYAxis.set_axis_label_text("Google normalized searches")
-  plot.getXAxis.setNTicks(10)
-  plot.set_points(points_oktoberfest)
-  plot.set_line_color(color(100, 100, 100))
-  plot.add_layer("German elections day", points_elections)
-  plot.get_layer("German elections day").set_line_color(color(255, 100, 255))
-  plot.activate_point_labels
-end
-
-def draw
-  background(255)
-  
-  # Draw the plot  
-  plot.begin_draw
-  plot.draw_box
-  plot.drawXAxis
-  plot.drawYAxis
-  plot.draw_title
-  plot.draw_grid_lines(GPlot::VERTICAL)
-  plot.draw_filled_contours(GPlot::HORIZONTAL, 0)
-  plot.draw_legend(%w(Oktoberfest Bundestagswahl), 
-    [0.07,0.22], 
-    [0.92, 0.92])
-  plot.draw_labels
-  plot.end_draw
-end 
-
-def get_exact_date(year, month, day)
-  leap_year = false
-  if (year % 400 == 0) 
-    leap_year = true
-  elsif (year % 100 == 0) 
-    leap_year = false
-  elsif (year % 4 == 0) 
-    leap_year = true
-  end
-  if leap_year
-    return year + (month + (day - 1) / DAYS_PER_MONTH_LEAP_YEAR[month]) / 12.0
-  else
-    return year + (month + (day - 1)/ DAYS_PER_MONTH[month]) / 12.0
-  end
-end
-

data/samples/external_library/java_processing/guido/slider.rb

@@ -1,54 +0,0 @@
-load_library :guido
-import 'de.bezier.guido'
-
-def setup
-  size 400, 400
-  Interactive.make self
-  @slider = Slider.new  10, height - 20, width - 20, 10
-end
-
-def draw
-  background 180
-  fill 255
-  v = 10 + @slider.value * (width - 30)
-  ellipse width / 2, height / 2, v, v
-end
-
-class Slider < ActiveElement
-  
-  attr_reader :value
-  
-  def initialize (x, y, w, h)
-    super x, y, w, h
-    @x = x
-    @y = y
-    @width = w
-    @height = h
-    @hover = false
-    @value = 0
-    @value_x = x
-  end
-  
-  def mouseEntered(mx, my)
-    @hover = true
-  end
-  
-  def mouseExited(mx, my)
-    @hover = false
-  end
-  
-  def mouseDragged(mx, my, dx, dy)
-    @value_x = mx - @height / 2    
-    @value_x = @x if (@value_x < @x) 
-    @value_x = @x + @width - @height if (@value_x > @x + @width - @height)    
-    @value = map(@value_x, @x, @x + @width - @height, 0, 1)
-  end
-  
-  def draw
-    no_stroke
-    fill @hover ? 220 : 150
-    rect @x, @y, @width, @height
-    fill 120
-    rect @value_x, @y, @height, @height
-  end
-end 

data/samples/external_library/java_processing/hemesh/data/java_args.txt

@@ -1,2 +0,0 @@
--XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
-

data/samples/external_library/java_processing/hemesh/library/vbo/mesh_to_vbo.rb

@@ -1,43 +0,0 @@
-# mesh_to_vbo.rb, with java_imports becomes a specialist class
-module MS  
-  java_import 'wblut.hemesh.HEC_IsoSurface'
-  java_import 'wblut.hemesh.HE_Mesh'
-  java_import 'wblut.hemesh.HEM_Smooth'
-  
-  class MeshToVBO 
-    
-    attr_reader :parent
-    
-    def initialize(parent)
-      @parent = parent
-    end
-    
-    def meshToVBO(mesh, col = nil)
-      tri_mesh = mesh.get
-      tri_mesh.triangulate
-      retained = parent.create_shape
-      retained.begin_shape(TRIANGLES)
-      if col
-        retained.fill(col)
-      else # we will have a light grey color, created by bit shifting
-        fcol = (255 >> 24) & 0xFF|(211 >> 16) & 0xFF|(211 >> 8) & 0xFF|211
-        retained.fill(fcol)
-      end
-      retained.ambient(50)
-      retained.specular(50)
-      mesh.fItr.each do |face|  # call each on the hemesh mesh iterator
-        he = face.getHalfedge
-        begin      # this block is the ruby equivalent of do while
-          vx = he.getVertex
-          vn = vx.getVertexNormal
-          retained.normal(vn.xf, vn.yf, vn.zf)
-          retained.vertex(vx.xf, vx.yf, vx.zf)
-          he = he.getNextInFace
-        end while (he != face.getHalfedge)
-      end
-      retained.end_shape
-      return retained
-    end
-  end
-end
-

data/samples/external_library/java_processing/hemesh/twin_iso.rb

@@ -1,69 +0,0 @@
-load_libraries :hemesh, :vbo, :vecmath
-
-include MS # module MS imports necessary java classes and contains ruby MeshToVBO class
-
-RES = 20
-
-attr_reader :mesh_ret, :inv_mesh_ret, :render
-
-def setup
-  size(800, 800, P3D)
-  ArcBall.init(self)
-  smooth(8)
-  values = []               # build a multi-dimensional array in ruby
-  (0..RES).each do |i|    # the inclusive range is intentional here
-    valu = []
-    (0..RES).each do |j|
-      val = []
-      (0..RES).each do |k|
-        val << 2.1 * noise(0.35 * i, 0.35 * j, 0.35 * k)
-      end
-      valu << val
-    end
-    values << valu
-  end
-  
-  creator = HEC_IsoSurface.new
-  creator.set_resolution(RES,RES, RES) # number of cells in x,y,z direction
-  creator.set_size(400.0/RES, 400.0/RES, 400.0/RES) # cell size
-  
-  # JRuby requires a bit of help to determine correct 'java args', particulary with 
-  # overloaded arrays args as seen below. Note we are saying we have an 'array' of  
-  # 'float array' here, where the values can also be double[][][].
-  java_values = values.to_java(Java::float[][]) # pre-coerce values to java
-  creator.set_values(java_values)               # the grid points
-  
-  creator.set_isolevel(1)   # isolevel to mesh
-  creator.set_invert(false) # invert mesh
-  creator.set_boundary(100) # value of isoFunction outside grid
-  # use creator.clear_boundary to set boundary values to "no value".
-  # A boundary value of "no value" results in an open mesh
-  
-  mesh = HE_Mesh.new(creator)
-  # mesh.modify(HEM_Smooth.new.set_iterations(10).setAutoRescale(true))
-  creator.set_invert(true)
-  
-  inv_mesh = HE_Mesh.new(creator)
-  inv_mesh.modify(HEM_Smooth.new.set_iterations(10).set_auto_rescale(true))
-  @render = MeshToVBO.new(self)
-  no_stroke
-  # no color args produces a default light grey fill
-  @mesh_ret = render.meshToVBO(mesh, color(200, 0, 0))
-  @inv_mesh_ret = render.meshToVBO(inv_mesh, color(0, 0, 200))
-end
-
-def draw
-  background(120)
-  lights
-  define_lights
-  shape(inv_mesh_ret)
-  shape(mesh_ret)
-end
-
-def define_lights
-  ambient(80, 80, 80)
-  ambient_light(80, 80, 80)
-  point_light(30, 30, 30, 0, 0, 1)
-  directional_light(40, 40, 50, 0, 0, 1)
-  spot_light(30, 30, 30, 0, 40, 200, 0, -0.5, 0.5, PI / 2, 2)
-end

data/samples/external_library/java_processing/pbox2d/bumpy_surface_noise.rb

@@ -1,57 +0,0 @@
-# The Nature of Code
-# <http:#www.shiffman.net/teaching/nature>
-# Spring 2010
-# PBox2D example
-
-# An uneven surface
-
-load_library :jbox2d
-load_library :surface
-
-include SB
-
-attr_reader :surface, :box2d, :particles
-
-def setup
-  size(500,300)
-  smooth
-  
-  # Initialize box2d physics and create the world
-  @box2d = Processing::Box2d::Box2d.new(self)
-  box2d.create_world
-  # We are setting a custom gravity
-  box2d.set_gravity(0, -20)
-  
-  # Create the empty list
-  @particles = []
-  # Create the surface
-  @surface = Surface.new(box2d)
-end
-
-def draw
-  # If the mouse is pressed, we make new particles
-  
-  
-  # We must always step through time!
-  box2d.step
-  
-  background(138, 66, 54)  
-  # Draw the surface
-  surface.display
-  # NB question mark is reqd to call mouse_pressed value, else method gets called.
-  particles << Particle.new(box2d, mouse_x, mouse_y, rand(2.0..6)) if mouse_pressed?    
-  # Draw all particles
-  particles.each do |p|
-    p.display
-  end  
-  # Particles that leave the screen, we delete them
-  # (note they have to be deleted from both the box2d world and our list
-  particles.each_with_index do |p, i|
-    if (p.done)
-      particles.delete_at(i)
-    end
-  end  
-  # Just drawing the framerate to see how many particles it can handle
-  fill(0)
-  text("framerate: #{frame_rate.to_i}", 12, 16)
-end

data/samples/external_library/java_processing/pbox2d/contact_test.rb

@@ -1,23 +0,0 @@
-load_library 'jbox2d'
-require 'jruby/core_ext'
-class JContactListener
-  include org.jbox2d.callbacks.ContactListener
-
-  def initialize()
-  end
-  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact c)"
-  def begin_contact(c)
-  end
-  java_signature "void endContact(org.jbox2d.dynamics.contacts.Contact c)"
-  def end_contact(c)
-  end
-  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact,org.jbox2d.callbacks.ContactImpulse )"
-  def pre_solve(c, ci)
-  end
-  java_signature "void beginContact(org.jbox2d.dynamics.contacts.Contact,org.jbox2d.callbacks.ContactImpulse )"
-  def post_solve(c, ci)
-  end 
-end
-
-
-

data/samples/external_library/java_processing/pbox2d/data/java_args.txt

@@ -1,2 +0,0 @@
--XX:CompileCommand=dontinline,org.jruby.runtime.invokedynamic.InvokeDynamicSupport::invocationFallback 
-

data/samples/external_library/java_processing/pbox2d/library/custom_shape/custom_shape.rb

@@ -1,158 +0,0 @@
-module B2D
-  include_package 'pbox2d'
-  include_package 'org.jbox2d.collision.shapes'
-  include_package 'org.jbox2d.common'
-  include_package 'org.jbox2d.dynamics'
-  java_import 'pbox2d.PBox2D'
-  
-  
-  # The Nature of Code
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2011
-  # PBox2D example
-  # A rectangular box
-  
-  class CustomShape
-
-    # We need to keep track of a Body and a width and height
-    attr_reader :body, :box2d
-    
-    # Constructor
-    def initialize(b2d, x, y)
-      # Add the box to the box2d world
-      @box2d = b2d  
-      make_body(B2D::Vec2.new(x, y))          
-    end
-    
-    # This function removes the particle from the box2d world
-    def kill_body!
-      box2d.destroy_body(body)
-    end
-    
-    # Is the particle ready for deletion?
-    def done
-      # Let's find the screen position of the particle
-      pos = box2d.get_body_pixel_coord(body)
-      # Is it off the bottom of the screen?
-      if (pos.y > $app.height)
-        kill_body!
-        return true
-      end
-      return false
-    end
-    
-    # Drawing the box
-    def display
-      # We look at each body and get its screen position
-      pos = box2d.get_body_pixel_coord(body)
-      # Get its angle of rotation
-      a = body.get_angle
-      
-      f = body.get_fixture_list
-      ps = f.get_shape
-      
-      
-      rect_mode(CENTER)
-      push_matrix
-      translate(pos.x, pos.y)
-      rotate(-a)
-      fill(175)
-      stroke(0)
-      begin_shape
-        # For every vertex, convert to pixel vector
-        ps.get_vertex_count.times do |i|
-          v = box2d.vector_world_to_pixels(ps.get_vertex(i))
-          vertex(v.x, v.y)
-        end
-      end_shape(CLOSE)
-      pop_matrix
-    end
-    
-    # This function adds the rectangle to the box2d world
-    def make_body(center)
-      
-      # Define a polygon (this is what we use for a rectangle)
-      sd = B2D::PolygonShape.new
-      
-      vertices = []
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-15, 25))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(15, 0))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(20, -15))
-      vertices << box2d.vector_pixels_to_world(B2D::Vec2.new(-10, -10))
-      sd.set(vertices.to_java(Java::OrgJbox2dCommon::Vec2), vertices.length)
-      
-      # Define the body and make it from the shape
-      bd = B2D::BodyDef.new
-      bd.type = B2D::BodyType::DYNAMIC
-      bd.position.set(box2d.coord_pixels_to_world(center))
-      @body = box2d.create_body(bd)
-      
-      body.create_fixture(sd, 1.0)
-      
-      
-      # Give it some initial random velocity
-      body.set_linear_velocity(Vec2.new(rand(-5..5), rand(2..5)))
-      body.set_angular_velocity(rand(-5..5))
-    end
-  end
-  
-  # The Nature of Code
-  # <http://www.shiffman.net/teaching/nature>
-  # Spring 2012
-  # PBox2D example
-  
-  # A fixed boundary class (now incorporates angle)
-  
-  
-  
-  class Boundary
-    
-    attr_reader :box2d, :b, :x, :y, :w, :h #, :a
-    
-    def initialize(b2d, x, y, w, h, a)
-      @box2d = b2d
-      @x = x
-      @y = y
-      @w = w
-      @h = h
-
-      # Define the polygon
-      sd = B2D::PolygonShape.new
-
-      # Figure out the box2d coordinates
-      box2dW = box2d.scalar_pixels_to_world(w/2)
-      box2dH = box2d.scalar_pixels_to_world(h/2)
-      # We're just a box
-      sd.set_as_box(box2dW, box2dH)
-      
-      
-      # Create the body
-      bd = B2D::BodyDef.new
-      bd.type = B2D::BodyType::STATIC
-      bd.angle = a
-      bd.position.set(box2d.coord_pixels_to_world(x,y))
-      @b = box2d.create_body(bd)
-      
-      # Attached the shape to the body using a Fixture
-      b.create_fixture(sd,1)
-    end
-    
-    # Draw the boundary, it doesn't move so we don't have to ask the Body for location
-    def display
-      fill(0)
-      stroke(0)
-      stroke_weight(1)
-      rect_mode(CENTER)
-      a = b.get_angle
-      push_matrix
-      translate(x,y)
-      rotate(-a)
-      rect(0,0,w,h)
-      pop_matrix
-    end
-    
-  end
-end
-  
-  
-