basis-processing 0.1

data/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/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/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/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/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

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: basis-processing
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Avishek Sen Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-20 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.
+email: avishek.sen.gupta@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- transform.rb
+- ranges.rb
+- coordinate_system.rb
+- matrix_operations.rb
+- screen.rb
+homepage: http://avishek.net/blog
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Basis provides a set of classes for easily plotting and transforming arbitrary 2D coordinate systems by specifying their basis vectors in Ruby-Processing.
+test_files: []
+