basis-processing 0.4 → 0.4.1

data/basis.gemspec

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

data/lib/basis_processing.rb

@@ -0,0 +1,4 @@
+require 'transform.rb'
+require 'ranges.rb'
+require 'matrix_operations.rb'
+require 'screen.rb'

data/lib/coordinate_system.rb

@@ -0,0 +1,99 @@
+require 'ranges'
+require 'ruby-processing'
+require 'matrix_operations'
+
+include Math
+
+class Axis
+	attr_accessor :basis_vector, :range
+	def initialize(basis_vector, range)
+		@basis_vector = basis_vector
+		@range = range
+	end
+end
+
+class CoordinateSystem
+	include MatrixOperations
+	attr_accessor :x_basis_vector, :y_basis_vector
+
+	def initialize(x_axis, y_axis, transform, artist)
+		@artist = artist
+		@x_axis = x_axis
+		@y_axis = y_axis
+		@x_basis_vector = x_axis.basis_vector
+		@y_basis_vector = y_axis.basis_vector
+		@basis_transform = transform
+		@basis_matrix = 
+				[
+					[@x_basis_vector[:x],@y_basis_vector[:x]],
+					[@x_basis_vector[:y],@y_basis_vector[:y]]
+				]
+
+		d = @basis_matrix[0][0]*@basis_matrix[1][1] - @basis_matrix[0][1]*@basis_matrix[1][0]
+		@inverse_basis = 
+				[
+					[@basis_matrix[1][1]/d, -@basis_matrix[0][1]/d],
+					[-@basis_matrix[1][0]/d, @basis_matrix[0][0]/d]
+				]
+
+		@standard_transform = MatrixOperations::into2Dx2D(MatrixOperations::into2Dx2D(@basis_matrix, @basis_transform), @inverse_basis)
+	end
+
+	def tick_vectors
+		unnormalised_vectors =
+		{
+			:x_tick_vector => MatrixOperations::into2Dx1D(rotation(-90),@x_basis_vector),
+			:y_tick_vector => MatrixOperations::into2Dx1D(rotation(90),@y_basis_vector)
+		}
+		{
+			:x_tick_vector => normal(unnormalised_vectors[:x_tick_vector]),
+			:y_tick_vector => normal(unnormalised_vectors[:y_tick_vector])
+		}
+	end
+
+	def normal(vector)
+		magnitude = sqrt(vector[:x]**2 + vector[:y]**2)
+		{:x => 5*vector[:x]/magnitude, :y => 5*vector[:y]/magnitude}
+	end
+
+	def sum(v1, v2)
+		{:x => v1[:x] + v2[:x], :y => v1[:y] + v2[:y]}
+	end
+
+	def x_ticks(x_basis_interval)
+		lines = []
+		t_vectors = tick_vectors
+		@x_axis.range.run(x_basis_interval) do |i,v|
+			tick_origin = standard_basis({:x => i, :y => 0})
+			lines << {:label => v, :from => tick_origin, :to => sum(tick_origin, t_vectors[:x_tick_vector])}
+		end
+		lines
+	end
+
+	def y_ticks(y_basis_interval)
+		lines = []
+		t_vectors = tick_vectors
+		@y_axis.range.run(y_basis_interval) do |i,v|
+			tick_origin = standard_basis({:x => 0, :y => i})
+			lines << {:label => v, :from => tick_origin, :to => sum(tick_origin, t_vectors[:y_tick_vector])}
+		end
+		lines
+	end
+
+	def rotation(angle)
+		radians = angle * PI/180.0
+		[[cos(radians), -sin(radians)],[sin(radians),cos(radians)]]
+	end
+
+
+	def standard_basis(point)
+		standard_point =
+		{
+			:x => @x_basis_vector[:x]*point[:x] + @y_basis_vector[:x]*point[:y], 
+			:y => @x_basis_vector[:y]*point[:x] + @y_basis_vector[:y]*point[:y]
+		}
+
+		MatrixOperations::into2Dx1D(@standard_transform, standard_point)
+	end
+end
+

data/lib/demo.rb

@@ -0,0 +1,42 @@
+require 'ranges'
+require 'transform'
+require 'coordinate_system'
+require 'screen'
+
+class Demo < Processing::App
+	app = self
+	def setup
+		smooth
+		background(0,0,0)
+		color_mode(RGB, 1.0)
+		stroke(1,1,0,1)
+
+		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 => 10, :y => -1}, {:x => 300, :y => 900})
+		screen = Screen.new(screen_transform, self)
+		screen.draw_axes(basis,10,10)
+		stroke(1,1,0,1)
+		fill(1,1,0)
+		points.each do |p|
+			screen.plot(p, basis)
+		end
+	end
+	  
+	def draw
+	end
+end
+
+w = 1200
+h = 1000
+
+Demo.new(:title => "My Sketch", :width => w, :height => h)
+

data/lib/matrix_operations.rb

@@ -0,0 +1,16 @@
+module MatrixOperations
+	def MatrixOperations.into2Dx2D(first, second)
+		[
+			[second[0][0]*first[0][0] + second[1][0]*first[0][1], second[0][1]*first[0][0] + second[1][1]*first[0][1]],
+			[second[0][0]*first[1][0] + second[1][0]*first[1][1], second[0][1]*first[1][0] + second[1][1]*first[1][1]]
+		]
+	end
+
+	def MatrixOperations.into2Dx1D(transform, point)
+		{
+			:x => transform[0][0]*point[:x] + transform[0][1]*point[:y], 
+			:y => transform[1][0]*point[:x] + transform[1][1]*point[:y]
+		}
+	end
+end
+

data/lib/ranges.rb

@@ -0,0 +1,48 @@
+class ContinuousRange
+	attr_accessor :minimum, :maximum
+
+	def initialize(range)
+		@minimum = range[:minimum]
+		@maximum = range[:maximum]
+	end
+
+	def interval
+		@maximum - @minimum
+	end
+
+	def index(element)
+		element.to_f
+	end
+
+	def run(interval)
+		current = @minimum
+		while(current <= @maximum)
+			yield(current,current)
+			current += interval
+		end
+	end
+end
+
+class DiscreteRange
+	attr_accessor :values
+	def initialize(v)
+		@values = v[:values]
+	end
+
+	def interval
+		@values.count
+	end
+
+	def index(element)
+		@values.index(element)
+	end
+
+	def run(interval)
+		current = 0
+		while(current <= @values.count - 1)
+			yield(current,@values[current])
+			current += interval
+		end
+	end
+end
+

data/lib/screen.rb

@@ -0,0 +1,41 @@
+require 'transform'
+
+class Screen
+	def initialize(transform, artist)
+		@transform = transform
+		@artist = artist
+	end
+
+	def plot(point, basis)
+		standard_point = basis.standard_basis(point)
+		p = @transform.apply(standard_point)
+		@artist.ellipse(p[:x], p[:y], 5, 5)
+	end
+
+	def draw_ticks(ticks, displacement)
+		ticks.each do |l|
+			from = @transform.apply(l[:from])
+			to = @transform.apply(l[:to])
+			@artist.line(from[:x],from[:y],to[:x],to[:y])
+			@artist.fill(1)
+			@artist.text(l[:label], to[:x]+displacement[:x], to[:y]+displacement[:y])
+		end
+	end
+
+	def draw_axes(basis, 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)
+		@artist.line(screen_origin[:x],screen_origin[:y],x_basis_edge[:x],x_basis_edge[:y])
+		@artist.line(screen_origin[:x],screen_origin[:y],y_basis_edge[:x],y_basis_edge[:y])
+
+		draw_ticks(basis.x_ticks(x_interval), {:x => 0, :y => 20})
+		draw_ticks(basis.y_ticks(y_interval), {:x => -50, :y => 0})
+	end
+end
+

data/lib/transform.rb

@@ -0,0 +1,18 @@
+class Transform
+	attr_accessor :scale, :origin
+	def initialize(scale, origin)
+		@origin = origin
+		@scale = scale
+	end
+
+	def apply(p)
+		{ :x => @origin[:x] + p[:x] * @scale[:x], :y => @origin[:y] + p[:y] * @scale[:y]}
+	end
+end
+
+class SignedTransform < Transform
+	def apply(p)
+		{ :x => @origin[:x] + p[:x] * (@scale[:x]<=>0.0).to_i, :y => @origin[:y] + p[:y] * (@scale[:y]<=>0.0).to_i}
+	end
+end
+

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: basis-processing
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 13
   prerelease: 
   segments: 
   - 0
   - 4
-  version: "0.4"
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Avishek Sen Gupta
@@ -29,6 +30,13 @@ files:
 - .gitignore
 - README
 - basis.gemspec
+- lib/basis_processing.rb
+- lib/coordinate_system.rb
+- lib/demo.rb
+- lib/matrix_operations.rb
+- lib/ranges.rb
+- lib/screen.rb
+- lib/transform.rb
 homepage: http://avishek.net/blog
 licenses: []