laptimer-geometry 0.0.1

data/spec/lap_counter_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require File.expand_path('../../src/lap_counter', __FILE__)
+
+describe LapCounter do
+	it "should find a straight segment witch is valid" do
+		true.should be_true
+	end
+end

data/spec/line_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require File.expand_path('../../src/geometry', __FILE__)
+
+describe Line do
+	before do
+		# first semi-line
+		@pointA = {:x => 2, :y => 1}
+		@pointB = {:x => 4, :y => 3}
+		#second semi-line
+		@pointC = {:x => 3, :y => 1}
+		@pointD = {:x => 2, :y => 4}
+		#third semi-line
+		@pointE = {:x => 3, :y => 0}
+		@pointF = {:x => 1, :y => 2}
+	end
+
+	it "should find the gradient of the straight line" do
+		sl = Line.new(@pointA, @pointB)
+		sl.gradient.should be_eql(1.to_f)
+	end
+
+	it "should find the linear touch of the line" do
+		sl = Line.new(@pointA, @pointB)
+		sl.linear_touch.should be_eql(-1.to_f)
+
+		# Double Test
+		sl2 = Line.new(@pointE, @pointF)
+		sl2.linear_touch.should be_eql(3.to_f)
+	end
+
+	it "should include anotther point from the line" do
+		pointC = {:x => 3, :y => 2}
+		sl = Line.new(@pointA, @pointB)
+		sl.include?(pointC).should be_true
+	end
+
+	it "should intercept with the other line (3,0) and (1,2)" do
+		sl = Line.new(@pointA, @pointB)
+		sl2 = Line.new(@pointC, @pointD)
+		sl.intercept?(sl2).should be_true
+		sl3 = Line.new(@pointE, @pointF)
+		sl.intercept?(sl3).should be_true
+	end
+
+	it "two concurrent lines should intercept at (2,2)" do
+		pA = {:x => 1, :y => 1}
+		pB = {:x => 3, :y => 3}
+		pC = {:x => 1, :y => 3}
+		pD = {:x => 3, :y => 1}
+		sl = Line.new(pA, pB)
+		sl2 = Line.new(pC, pD)
+		sl.intercept?(sl2).should be_true
+		sl.intercept_at(sl2).should be_eql({:x => 2.0, :y => 2.0})
+	end
+
+	it "should not intercept with a parallel line" do 
+		pA = {:x => 1, :y => 1}
+		pB = {:x => 3, :y => 3}
+		pC = {:x => 2, :y => 1}
+		pD = {:x => 3, :y => 2}
+		sl = Line.new(pA, pB)
+		sl2 = Line.new(pC, pD)
+		sl.intercept?(sl2).should be_false
+	end
+
+	it "should intercept between the 2 original points of the first line" do
+		pA = {:x => 1, :y => 1}
+		pB = {:x => 3, :y => 3}
+		pC = {:x => 1, :y => 3}
+		pD = {:x => 3, :y => 1}
+		sl = Line.new(pA, pB)
+		sl2 = Line.new(pC, pD)
+		sl.intercept_line_segment?(sl2).should be_true
+	end
+
+	it "should not find an interception between the two segments" do
+		pA = {:x => 1, :y => 1}
+		pB = {:x => 3, :y => 3}
+		pC = {:x => 4, :y => 3}
+		pD = {:x => 6, :y => 1}
+		sl = Line.new(pA, pB)
+		sl2 = Line.new(pC, pD)
+		sl.intercept_line_segment?(sl2).should be_false
+	end
+
+	it "should intercept event in the negative Y quadrant" do 
+		flag_line = Line.new({:x => 1, :y => -1, }, {:x => 3, :y => -4})
+		segment1 = Line.new({:x => 1, :y => -3}, {:x => 3, :y => -1})
+
+		flag_line.intercept_line_segment?(segment1).should be_true
+	end
+
+
+	it "should intercept event in the negative X quadrant" do 
+		flag_line = Line.new({:x => -1, :y => 1, }, {:x => -3, :y => 4})
+		segment1 = Line.new({:x => -3, :y => 1}, {:x => -1, :y => 3})
+
+		flag_line.intercept_line_segment?(segment1).should be_true
+	end
+
+	it "should intercept event in the all negative quadrant" do 
+		flag_line = Line.new({:x => -1, :y => -1, }, {:x => -3, :y => -3})
+		segment1 = Line.new({:x => -1, :y => -3}, {:x => -2, :y => -2})
+
+		flag_line.intercept_line_segment?(segment1).should be_true
+	end
+
+	it "should intercept when segments are in different quadrants" do 
+		flag_line = Line.new({:x => -1, :y => 1, }, {:x => -3, :y => 4})
+		segment1 = Line.new({:x => 1, :y => 3}, {:x => 3, :y => 1})
+
+		flag_line.intercept_line_segment?(segment1).should be_false
+	end
+
+	it "should calculate the distance using the Earth radius Nelson Piquet" do 
+		point1 = {:x => -47.900648, :y => -15.772954} 
+		point2 = {:x => -47.900365, :y => -15.772869}
+		point3 = {:x => -47.90025, :y => -15.772835}
+		Geometry.calculate_distance(point1, point2).should be_true
+		Geometry.calculate_distance(point1, point3).should be_true
+	end
+
+	it "should find the crossing segment with some real coordinates - Aut. Nelson Piquet" do 
+		flag_line = Line.new({:x => -47.900333, :y => -15.772656, }, {:x => -47.900148, :y => -15.773056})
+		segment1 = Line.new({:x => -47.900648, :y => -15.772954}, {:x =>-47.899923, :y => -15.772683})
+
+		flag_line.intercept_line_segment?(segment1).should be_true
+	end
+
+	it "should not accept the crossing form real segments with they do not touch - Aut. Nelson Piquet" do
+		flag_line = Line.new({:x => -47.900333, :y => -15.772656, }, {:x => -47.900148, :y => -15.773056}) 
+		segment1 = Line.new({:x => -47.900648, :y => -15.772954}, {:x =>-47.900365, :y => -15.772869})
+
+		flag_line.intercept_line_segment?(segment1).should be_false
+	end
+
+end

data/src/geometry.rb

@@ -0,0 +1,129 @@
+module Geometry
+  include Math
+  extend Math
+  
+  def distance(point1, point2)
+  	x1 = (point1[:x] > 0) ? point1[:x] : (point1[:x]*-1 )
+  	x2 = (point2[:x] > 0) ? point2[:x] : (point2[:x]*-1 )
+  	y1 = (point1[:y] > 0) ? point1[:y] : (point1[:y]*-1 )
+  	y2 = (point2[:y] > 0) ? point2[:y] : (point2[:y]*-1 )
+    hypot x1 - x2, y1 - y2
+  end
+
+	def calculate_distance(point1, point2)
+		x1 = point1[:x] * Math::PI / 180
+		x2 = point2[:x] * Math::PI / 180
+		y1 = point1[:y] * Math::PI / 180
+		y2 = point2[:y] * Math::PI / 180
+
+		s = sin(y2)*sin(y1)+(cos(y2)*cos(y1)*cos(x2 - x1))
+		rad_distance = acos(s)
+		degree_distance = rad_distance/(Math::PI/180)
+		earth_radius = 6378
+		distance_km = earth_radius*degree_distance		
+		distance_km
+	end
+
+  module_function :distance
+  module_function :calculate_distance
+end
+
+class Line
+	include Math
+	def initialize(pointA, pointB)
+		@a, @b, @c = nil, nil, nil
+		@gradient = nil
+		@linear = nil
+		@pointA = pointA
+		@pointB = pointB
+		calculate_gradient
+		calculate_linear
+	end	
+
+	def pointA
+		@pointA
+	end
+
+	def pointB
+		@pointB
+	end
+
+	def gradient(ac = nil)
+		if ac.nil?
+			@gradient
+		else
+			@gradient = ac
+		end
+
+		@gradient
+	end
+
+	# m(x2-x1) - y2 + y1 = 0
+	def include?(point) 
+		result = @gradient * (point[:x] - @pointA[:x]) - point[:y] + @pointA[:y]
+		if(result == 0)
+			true
+		else
+			false
+		end
+	end
+
+	def intercept?(line)	
+		(intercept_at(line).nil? == true) ? false : true
+	end
+
+	def intercept_at(line)
+		if @gradient != line.gradient								
+			x = calculate_x_from_two_lines(self, line)
+			y = (@gradient*x.to_f) + @linear
+			
+			new_point = { :x => sprintf('%.6f',x).to_f, :y => sprintf('%.6f',y).to_f}
+			return new_point
+		end
+
+		return nil
+	end
+
+	def linear_touch
+		@linear
+	end
+
+	def intercept_line_segment?(line)
+		
+		# verify the distance
+		if intercept?(line)
+			interception_point = intercept_at(line)
+
+			distance_segment = Geometry.calculate_distance(line.pointA, line.pointB)
+			distance_A_line_segment = Geometry.calculate_distance(line.pointA, interception_point)
+			distance_B_line_segment = Geometry.calculate_distance(line.pointB, interception_point)
+
+			if distance_A_line_segment > distance_segment 
+				return false
+			elsif distance_B_line_segment > distance_segment
+				return false
+			else
+				return true
+			end
+		end
+
+		return false
+	end
+
+	private
+	def calculate_gradient
+		@gradient = (@pointB[:y] - @pointA[:y]) / (@pointB[:x] - @pointA[:x]).to_f
+	end
+
+	def calculate_linear
+		@linear = nil
+		if not @gradient.nil?
+			@linear =  @pointA[:y].to_f - (@gradient * @pointA[:x].to_f )
+		end
+		@linear
+	end
+
+	def calculate_x_from_two_lines(line1, line2)
+		(line2.linear_touch - line1.linear_touch) / (line1.gradient - line2.gradient)
+	end
+end

data/src/lap_counter.rb

@@ -0,0 +1,2 @@
+class LapCounter
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: laptimer-geometry
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eduardo Marques
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-03 00:00:00 Z
+dependencies: []
+
+description: "    laptimer-geometry is a gem created to help the coordinates calculations used in a laptimer software.\n"
+email: edhana@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- src/geometry.rb
+- src/lap_counter.rb
+- spec/lap_counter_spec.rb
+- spec/line_spec.rb
+homepage: http://github.com/edhana/laptimer-geometry
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- src
+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.8.5
+signing_key: 
+specification_version: 3
+summary: Implementation of basic 2D geometry algorithms, to help with a lap timer system written in Ruby
+test_files: 
+- spec/lap_counter_spec.rb
+- spec/line_spec.rb