basis-processing 0.4.9 → 0.5.0

data/.gitignore

@@ -1,2 +1,3 @@
 *.*~
+*~
 *.gem

data/README

@@ -18,52 +18,74 @@ To use Basis functionality in your code, it is enough to:
 
 Here's some example code, which plots random points.
 
-    require 'rubygems'`
-    require 'basis_processing'`
-
-    class Demo < Processing::App
-    app = self
-    def setup
-        smooth
-        background(0,0,0)
-        color_mode(RGB, 1.0)
- 
-        points = []
-        100.times {points << {:x => random(200), :y => random(300)}}
- 
-        x_basis_vector = {:x => 1.0, :y => 0.0}
-        y_basis_vector = {:x => 0.0, :y => 1.0}
- 
-        x_range = ContinuousRange.new({:minimum => 0, :maximum => 200})
-        y_range = ContinuousRange.new({:minimum => 0, :maximum => 300})
- 
-        basis = CoordinateSystem.new(Axis.new(x_basis_vector,x_range), Axis.new(y_basis_vector,y_range), [[4,0],[0,2]], self)
-        screen_transform = SignedTransform.new({:x => 1, :y => -1}, {:x => 300, :y => 900})
-        screen = Screen.new(screen_transform, self)
-        screen.join = true
-        screen.draw_axes(basis,10,10)
-        stroke(1,1,0,1)
-        fill(1,1,0)
-        rect_mode(CENTER)
-        points.each do |p|
-                screen.plot(p, basis, :bar => true) {|p| rect(p[:x], p[:y], 5, 5)}
-        end
-    end
- 
-    def draw
-    end
-    end
- 
-    w = 1200
-    h = 1000
- 
-    Demo.new(:title => "My Sketch", :width => w, :height => h)
-
-You have a few options when plotting a point. Consider the line:
+	require 'rubygems'
+	Gem.clear_paths
+	ENV['GEM_HOME'] = '/home/avishek/jruby/jruby-1.6.3/lib/ruby/gems/1.8'
+	ENV['GEM_PATH'] = '/home/avishek/jruby/jruby-1.6.3/lib/ruby/gems/1.8'
+
+	require 'basis_processing'
+
+	class Demo < Processing::App
+		include Interactive
+		app = self
+		def setup
+			smooth
+			background(0,0,0)
+			color_mode(RGB, 1.0)
+			stroke(1,1,0,1)
+			@highlight_block = lambda do |p|
+						rect_mode(CENTER)
+						stroke(1,0,0)
+						fill(1,0,0)
+						rect(p[:x], p[:y], 5, 5)
+					   end
+
+			@passive_block = lambda do |p|
+						rect_mode(CENTER)
+						stroke(1,1,0,1)
+						fill(1,1,0)
+						rect(p[:x], p[:y], 5, 5)
+					   end
+
+			points = []
+			200.times {|n|points << {:x => n, :y => random(300)}}
+
+			x_basis_vector = {:x => 1.0, :y => 0.0}
+			y_basis_vector = {:x => 0.0, :y => 1.0}
+
+			x_range = ContinuousRange.new({:minimum => 0, :maximum => 200})
+			y_range = ContinuousRange.new({:minimum => 0, :maximum => 300})
+
+			@basis = CoordinateSystem.new(Axis.new(x_basis_vector,x_range), Axis.new(y_basis_vector,y_range), [[4,0],[0,2]], self)
+			screen_transform = SignedTransform.new({:x => 1, :y => -1}, {:x => 300, :y => 900})
+			@screen = Screen.new(screen_transform, self, @basis)
+			@screen.join=true
+			@screen.draw_axes(10,10)
+			stroke(1,1,0,1)
+			fill(1,1,0)
+			rect_mode(CENTER)
+			points.each do |p|
+				@screen.plot(p, :track => true) {|p| rect(p[:x], p[:y], 5, 5)}
+			end
+		end
+	end
+
+	w = 1200
+	h = 1000
+
+	Demo.new(:title => "My Sketch", :width => w, :height => h)
+
+You have a few options when plotting a point. If you specify ':bar => true', like the line below:
 
 	screen.plot(p, basis, :bar => true) {|p| rect(p[:x], p[:y], 5, 5)}
 
-If you omit `:bar => true` or don't specify any options, Basis will plot the points without connecting them to the X-axis.
+it will connect the point with the x-axis. If you omit `:bar => true` or don't specify any options, Basis will plot the points without connecting them to the X-axis.
 If you omit the block at the end of the call, Basis will plot the point using a circle. Use the block to customise how you wish to represent the point graphically.
 You can toggle the joining of the points with lines by setting the join attribute of Screen to on (joins points)/off (no joining). The default is false.
 
+Version 0.5.0 introduces experimental support for mouseover interactivity without extra effort on your part. To allow interactions to happen, you must specify ':track => true' while plotting a point, as in the line below:
+
+	@screen.plot(p, :track => true) {|p| rect(p[:x], p[:y], 5, 5)}
+
+To actually enable interactivity, you must 'include' the Interactive module in your sketch class, as in the demonstration code above. Interactivity is a work in progress at the moment.
+

data/basis.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s| 
   s.name = "basis-processing"
-  s.version = "0.4.9"
+  s.version = "0.5.0"
   s.author = "Avishek Sen Gupta"
   s.email = "avishek.sen.gupta@gmail.com"
   s.homepage = "http://avishek.net/blog"

data/lib/basis_processing.rb

@@ -3,3 +3,5 @@ require 'ranges.rb'
 require 'matrix_operations.rb'
 require 'coordinate_system.rb'
 require 'screen.rb'
+require 'interactive'
+

data/lib/demo.rb

@@ -6,12 +6,26 @@ ENV['GEM_PATH'] = '/home/avishek/jruby/jruby-1.6.3/lib/ruby/gems/1.8'
 require 'basis_processing'
 
 class Demo < Processing::App
+	include Interactive
 	app = self
 	def setup
-#		smooth
+		smooth
 		background(0,0,0)
 		color_mode(RGB, 1.0)
 		stroke(1,1,0,1)
+		@highlight_block = lambda do |p|
+					rect_mode(CENTER)
+					stroke(1,0,0)
+					fill(1,0,0)
+					rect(p[:x], p[:y], 5, 5)
+				   end
+
+		@passive_block = lambda do |p|
+					rect_mode(CENTER)
+					stroke(1,1,0,1)
+					fill(1,1,0)
+					rect(p[:x], p[:y], 5, 5)
+				   end
 
 		points = []
 		200.times {|n|points << {:x => n, :y => random(300)}}
@@ -22,21 +36,18 @@ class Demo < Processing::App
 		x_range = ContinuousRange.new({:minimum => 0, :maximum => 200})
 		y_range = ContinuousRange.new({:minimum => 0, :maximum => 300})
 
-		basis = CoordinateSystem.new(Axis.new(x_basis_vector,x_range), Axis.new(y_basis_vector,y_range), [[4,0],[0,2]], self)
+		@basis = CoordinateSystem.new(Axis.new(x_basis_vector,x_range), Axis.new(y_basis_vector,y_range), [[4,0],[0,2]], self)
 		screen_transform = SignedTransform.new({:x => 1, :y => -1}, {:x => 300, :y => 900})
-		screen = Screen.new(screen_transform, self)
-		screen.join=true
-		screen.draw_axes(basis,10,10)
+		@screen = Screen.new(screen_transform, self, @basis)
+		@screen.join=true
+		@screen.draw_axes(10,10)
 		stroke(1,1,0,1)
 		fill(1,1,0)
 		rect_mode(CENTER)
 		points.each do |p|
-			screen.plot(p, basis) {|p| rect(p[:x], p[:y], 5, 5)}
+			@screen.plot(p, :track => true) {|p| rect(p[:x], p[:y], 5, 5)}
 		end
 	end
-	  
-	def draw
-	end
 end
 
 w = 1200

data/lib/interactive.rb

@@ -0,0 +1,30 @@
+module Interactive
+	attr :screen, :basis
+
+	def mouseMoved(p)
+		p = {:x => p.getX(), :y => p.getY()}
+		@old_points ||= []
+		@points_to_highlight = []
+		index = @screen.points.index do |i|
+			onscreen_point = @screen.transformed(i)
+			(p[:x] - onscreen_point[:x]).abs < 4.0 && (p[:y] - onscreen_point[:y]).abs < 4.0
+		end
+		return if index == nil
+		@points_to_highlight = [{:x => @screen.points[index][:x], :y => @screen.points[index][:y]}]
+		redraw
+	end
+
+	def draw
+		@screen.join = false
+		@old_points ||= []
+		@points_to_highlight ||= []
+		@old_points.each do |old|
+			@screen.plot(old) {|p| @passive_block.call(p) if @passive_block}
+		end
+		@points_to_highlight.each do |new_rectangle|
+			@screen.plot(new_rectangle) {|p| @highlight_block.call(p) if @highlight_block}
+		end
+		@old_points = @points_to_highlight
+	end
+end
+

data/lib/screen.rb

@@ -1,22 +1,25 @@
 require 'transform'
 
 class Screen
+	attr_accessor :points
+
 	def join=(should_join)
 		@should_join = should_join
 		@buffer = nil if !@should_join
 	end
 	
-	def initialize(transform, artist)
+	def initialize(transform, artist, basis)
 		@transform = transform
 		@artist = artist
+		@basis = basis
 		join = false
+		@points = []
 	end
 
-	def plot(point, basis, options = {:bar => false}, &block)
-		standard_point = basis.standard_basis(point)
-		p = @transform.apply(standard_point)
-
-		standard_x_axis_point = @transform.apply(basis.standard_basis({:x => point[:x], :y => 0}))
+	def plot(point, options = {:bar => false, :track => false}, &block)
+		@points << point if options[:track]
+		p = transformed(point)
+		standard_x_axis_point = @transform.apply(@basis.standard_basis({:x => point[:x], :y => 0}))
 		if (block)
 			block.call(p)
 		else
@@ -28,9 +31,14 @@ class Screen
 		@buffer = p
 	end
 
-	def original(onscreen_point, basis)
+	def transformed(data_point)
+		standard_point = @basis.standard_basis(data_point)
+		@transform.apply(standard_point)
+	end
+	
+	def original(onscreen_point)
 		p = @transform.unapply(onscreen_point)
-		basis.original(p)
+		@basis.original(p)
 	end
 
 	def draw_ticks(ticks, displacement)
@@ -51,18 +59,17 @@ class Screen
 		{:x => 5*vector[:x]/magnitude, :y => 5*vector[:y]/magnitude}
 	end
 
-	def draw_axes(basis, x_interval, y_interval)
+	def draw_axes(x_interval, y_interval)
 		f = @artist.createFont("Georgia", 24, true);
 		@artist.text_font(f,16)
-		@artist.stroke(1,1,1,1)
 		axis_screen_transform = Transform.new({:x => 800, :y => -800}, @transform.origin)
 		origin = {:x => 0, :y => 0}
 		screen_origin = @transform.apply(origin)
-		x_basis_edge = axis_screen_transform.apply(basis.x_basis_vector)
-		y_basis_edge = axis_screen_transform.apply(basis.y_basis_vector)
+		x_basis_edge = axis_screen_transform.apply(@basis.x_basis_vector)
+		y_basis_edge = axis_screen_transform.apply(@basis.y_basis_vector)
 
-		x_ticks = basis.x_ticks(x_interval)
-		y_ticks = basis.y_ticks(y_interval)
+		x_ticks = @basis.x_ticks(x_interval)
+		y_ticks = @basis.y_ticks(y_interval)
 
 		x_ticks = x_ticks.collect {|t| {:from => @transform.apply(t[:from]), :to => @transform.apply(t[:to]), :label => t[:label]}}
 		y_ticks = y_ticks.collect {|t| {:from => @transform.apply(t[:from]), :to => @transform.apply(t[:to]), :label => t[:label]}}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: basis-processing
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
-  - 9
-  version: 0.4.9
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Avishek Sen Gupta
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-03 00:00:00 Z
+date: 2011-10-05 00:00:00 Z
 dependencies: []
 
 description: Basis provides a set of classes for easily plotting and transforming arbitrary 2D coordinate systems by specifying their basis vectors in Ruby-Processing.
@@ -33,6 +33,7 @@ files:
 - lib/basis_processing.rb
 - lib/coordinate_system.rb
 - lib/demo.rb
+- lib/interactive.rb
 - lib/matrix_operations.rb
 - lib/ranges.rb
 - lib/screen.rb