vector_geometry 0.0.1

data/lib/geometry/vector/vector.rb

@@ -0,0 +1,223 @@
+
+module Geometry
+
+  class Vector
+
+    # Return an x/y vector based on a magnitude and a heading.
+    def self.from_polar(magnitude, angle, options = {})
+      angle = Geometry.deg_to_rad(angle) if options[:unit] = :deg
+
+      y = Math.sin(angle) * magnitude
+      x = Math.cos(angle) * magnitude
+      
+      self.new(x,y)
+    end
+
+    attr_accessor :x, :y, :z
+
+    def initialize(x, y, z = 0)
+      @x = x.to_f
+      @y = y.to_f
+      @z = z.to_f
+    end
+
+    def add(other)      
+      self.class.new(@x + other.x, @y + other.y, @z + other.z)
+    end
+    alias :+ :add
+
+    def subtract(other)
+      self.class.new(@x - other.x, @y - other.y, @z - other.z)
+    end
+    alias :- :subtract
+
+    def multiply(n)
+      scale(n.to_f)
+    end
+    alias :* :multiply
+
+    def divide(n)      
+      scale(1.0/n.to_f)
+    end
+    alias :/ :divide
+
+    # Return the magnitude of self.
+    def magnitude
+      Math.sqrt(@x ** 2 + @y ** 2 + @z ** 2)
+    end
+    alias :r :magnitude
+
+    def scale(scalar)
+      self.class.new(@x * scalar, @y * scalar, @z * scalar)
+    end
+
+    # Normalize self, that is, return the unit vector with the same direction as self.
+    def normalize
+      divide(magnitude)
+    end
+
+    def heading
+      Math.atan2(@y,@x)
+    end
+
+    # Return the dot product of self and the passed in vector.
+    def dot(other)      
+      return (@x * other.x) + (@y * other.y) + (@z * other.z)
+    end
+    alias :scalar_product :dot
+
+    # Return the cross product of self and the passed in vector.
+    def cross(other)
+      new_x = (@y * other.z) - (@z * other.y)
+      new_y = (@z * other.x) - (@x * other.z)
+      new_z = (@x * other.y) - (@y * other.x)
+
+      self.class.new(new_x, new_y, new_z)
+    end
+    alias :vector_product :cross
+
+    
+    # Return the magnitude of the cross product of self and the passed in vector.
+    def cross_length(other)
+      # cross(other).magnitude
+
+      # It is more efficient to not create a new Vector object since we are only returning 
+      # a scalar value 
+      new_x = (@y * other.z) - (@z * other.y)
+      new_y = (@z * other.x) - (@x * other.z)
+      new_z = (@x * other.y) - (@y * other.x)
+
+      Math.sqrt(new_x ** 2 + new_y ** 2 + new_z ** 2)
+    end
+
+    # Return the unit vector of the cross product of self and the passed in vector.
+    def cross_normal(other)
+      cross(other).normalize
+    end
+
+    # Return the angle (in radians) between self and the passed in vector.
+    def angle(other)
+
+      # Two options here:
+      #
+      # 1.  Math.atan2(other.cross_length(self), dot(other)) 
+      #
+      #     This is stable but slower (x 1.5)
+      #
+      # 2.  Math.acos(dot(other) / (r * other.r)) 
+      #
+      #     This is faster but unstable around 0 and pi where the gradient of acos approaches 
+      #     infinity. An alternative way to view this is that the gradient of cos approaches
+      #     zero and small differences in angle can be indistinguishable at some number of 
+      #     decimal places.
+      #
+      
+      # Math.acos(dot(other) / (r * other.r)) 
+      Math.atan2(other.cross_length(self), dot(other)) 
+    end
+
+    # Return the cartesian distance between self and the passed vector
+    def distance(other)
+      (other - self).magnitude.abs
+    end
+
+    # Returns true of the passed in vector is perpendicular to self.
+    def orthogonal?(other)
+      dot(other) == 0
+    end
+
+    # Returns true if the passed in vector is parallel to self.
+    def parallel?(other)
+      cross(other).magnitude == 0
+    end
+
+    def ==(other)
+      @x == other.x && @y == other.y && @z == other.z
+    end
+
+    # Calculate the distance of self from the infinite line passing through the two passed in points.
+    def distance_from_line(point_a,point_b)
+      
+      # Define the line as the vector between two points
+      line_vector  = point_b - point_a
+
+      # Define a second vector representing the distance between self and the line start
+      point_vector = self - point_a
+
+      # The magnitude of the cross product is equal to the area of the parallelogram described
+      # by the two vectors. Dividing by the line length gives the perpendicular distance.
+      (line_vector.cross(point_vector).magnitude / line_vector.magnitude).abs
+    end  
+
+    # Calculate the distance of self from the line segment starting and ending with the two passed in points.
+    def distance_from_line_segment(point_a,point_b)
+
+      # Define the line as the vector between two points
+      line_vector  = point_b - point_a
+      
+      # Define a second vector representing the distance between self and the line start
+      point_vector = self - point_a
+
+      # Determine if self falls within the perpendicular 'shadow' of the line by calculating
+      # the projection of the point vector onto the line.
+      #
+      # The dot product divided by the magnitude of the line gives the absolute projection
+      # of the point vector onto the line.
+      #
+      # Dividing again by the line magnitude gives the relative projection along the line, 
+      # i.e. the ratio of the projection to the line. Values between 0-1 indicate that the
+      # point falls within the perpendicular shadow.
+      #
+      projection_ratio = line_vector.dot(point_vector) / line_vector.magnitude ** 2
+
+      if projection_ratio >= 1
+        # The point is beyond point b, calculate distance to point b
+        distance = (point_b - self).magnitude
+      elsif projection_ratio <= 0
+        # The point is beyond point a, calculate distance to point a
+        distance = (point_a - self).magnitude
+      else
+        # The point is in the shadow of the line, return the perpendicular distance
+        distance = line_vector.cross(point_vector).magnitude / line_vector.magnitude
+      end
+
+      return distance.abs
+    end
+
+    def distance_from_polyline(polyline)
+      
+      # memoize the last processed point as both array and vector objects
+      last_array  = polyline.first
+      last_vector = self.class.new(last_array[0], last_array[1], last_array[2]) # this should support 3 arguments surely?!
+
+      minimum_distance = 999999999999
+
+      polyline[1..-1].each do |vertex|  
+
+        next if vertex == last_array  
+
+        start_vector = last_vector
+        end_vector   = self.class.new(vertex[0],vertex[1], vertex[2]) # this should support 3 arguments surely?!
+
+        this_segment_distance = distance_from_line_segment(start_vector, end_vector)
+
+        if(this_segment_distance < minimum_distance)
+          minimum_distance = this_segment_distance
+        end
+
+        last_array  = vertex
+        last_vector = end_vector
+      end
+
+      return minimum_distance
+    end
+
+    def inspect
+      puts "[#{@x}, #{@y}, #{@z}]"
+    end
+
+    protected
+
+  end
+
+end

data/lib/vector_geometry.rb

@@ -0,0 +1,6 @@
+require "geometry/geometry"
+require "geometry/spheroid/base"
+require "geometry/spheroid/sphere"
+require "geometry/vector/vector"
+require "geometry/vector/geo_vector"
+require "geometry/vector/earth_vector"

data/spec/exercises_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+# require 'geometry'
+
+include Geometry
+
+describe Vector do
+
+	context "30 degrees and magnitude 2" do
+
+    before do
+    	@angle     = 30 # degrees
+    	@magnitude = 2
+
+    	@vector = Vector.from_polar(@magnitude, @angle, :unit => :deg)
+    end
+
+    it "should calculate the x component" do
+
+      @vector.x.should be_within(0.00001).of(Math.sqrt(3))
+    end
+
+
+    it "should calculate the y component" do
+
+      @vector.y.should be_within(0.00001).of(1)
+    end
+
+  end
+
+  context "39 degrees and magnitude 55" do
+
+    before do
+    	@angle     = 39 # degrees
+    	@magnitude = 55
+
+    	@vector = Vector.from_polar(@magnitude, @angle, :unit => :deg)
+    end
+
+    it "should calculate the x component" do
+
+      @vector.x.should be_within(0.01).of(42.74)
+    end
+
+
+    it "should calculate the y component" do
+
+      @vector.y.should be_within(0.01).of(34.61)
+    end
+
+  end
+
+  context "44 degrees and magnitude 28" do
+
+    before do
+    	@angle     = 28 # degrees
+    	@magnitude = 44
+
+    	@vector = Vector.from_polar(@magnitude, @angle, :unit => :deg)
+    end
+
+    it "should calculate the x component" do
+
+      @vector.x.should be_within(0.01).of(38.84)
+    end
+
+
+    it "should calculate the y component" do
+
+      @vector.y.should be_within(0.01).of(20.65)
+    end
+
+  end
+
+  context "2,2 plus 2,1" do
+
+
+    it "should calculate the resultant vector" do
+
+      vector_1 = Vector.new(2,2)
+      vector_2 = Vector.new(2,1)
+
+      resultant = vector_1 + vector_2
+
+      resultant.x.should eql 4.0
+      resultant.y.should eql 3.0
+      resultant.magnitude.should eql 5.0
+    end
+
+  end
+
+  context "40,0 plus 0,50" do
+
+
+    it "should calculate the resultant vector" do
+
+      vector_1 = Vector.new(40,0)
+      vector_2 = Vector.new(0,50)
+
+      resultant = vector_1 + vector_2
+
+      resultant.x.should eql 40.0
+      resultant.y.should eql 50.0
+      resultant.magnitude.should be_within(0.1).of(64.0)
+    end
+
+  end
+
+  context "4,2 plus 2,5" do
+
+
+    it "should calculate the resultant vector" do
+
+      vector_1 = Vector.new(4,2)
+      vector_2 = Vector.new(2,5)
+
+      resultant = vector_1 + vector_2
+
+      resultant.x.should eql 6.0
+      resultant.y.should eql 7.0
+      resultant.magnitude.should be_within(0.02).of(9.2)
+    end
+
+  end
+
+  context "2,3,4 and 5,6,7" do
+
+    it "should calucate the cross product" do
+      vector_1 = Vector.new(2,3,4)
+      vector_2 = Vector.new(5,6,7)
+
+      resultant = vector_1.cross(vector_2)
+
+      resultant.x.should eql -3.0
+      resultant.y.should eql  6.0
+      resultant.z.should eql -3.0
+    end
+
+  end
+
+  context "great circle" do
+
+    before do
+      @point_1 = [51.454007, -0.263672]
+      @point_2 = [55.862982, -4.251709]
+    end
+
+    it "should calculate a great circle distance using the haversine formula" do
+      hv_distance = Geometry.haversine_distance(@point_1,@point_2,Geometry::Spheroid::Earth.mean_radius,:unit => :deg)
+      
+      hv_distance.should be_within(0.0001).of(556.0280983558)
+    end
+
+    it "should calculate a great circle distance using the angle between two cartesian vectors" do
+      vector_1 = EarthVector.from_geographic(@point_1[0],@point_1[1])
+      vector_2 = EarthVector.from_geographic(@point_2[0],@point_2[1])
+
+      angle      = vector_1.angle(vector_2)
+      vec_distance = angle * Geometry::Spheroid::Earth.mean_radius
+      
+      vec_distance.should be_within(0.0000001).of(557.4229505894594)
+    end
+
+    it "should calculate distance between point using Pythagoras' theorum" do
+
+      # Scale longitude change according to latitude
+      # Perhaps taking the mean latitude between the two points would be an improvement
+      deg_ew = (@point_2[1] - @point_1[1]) * Math.cos(@point_1[0])
+      deg_ns = (@point_1[0] - @point_2[0])
+      
+      # Calculate angle change using Pythagoras
+      deg_change = Math.sqrt(deg_ew ** 2 + deg_ns ** 2)
+
+      # Convert to radians and calculate distance
+      py_distance = Geometry.deg_to_rad(deg_change) * Geometry::Spheroid::Earth.mean_radius
+
+      py_distance.should be_within(0.000001).of(517.4118204446571)
+    end
+
+    it "haversine and geocentric vector approaches should be equal" do
+      # Haversine
+      hv_distance = Geometry.haversine_distance(@point_1,@point_2,Geometry::Spheroid::Earth.mean_radius,:unit => :deg)
+
+      # Vector
+      vector_1 = EarthVector.from_geographic(@point_1[0],@point_1[1], :geocentric => true)
+      vector_2 = EarthVector.from_geographic(@point_2[0],@point_2[1], :geocentric => true)
+      vec_distance = vector_1.angle(vector_2) * Geometry::Spheroid::Earth.mean_radius
+
+      hv_distance.should be_within(0.0000001).of(vec_distance)
+    end
+
+    it "Pythagoras should underestimate great circle" do
+      # Since the pythagoras approach assumes a flat surface
+
+      # Haversine
+      hv_distance = Geometry.haversine_distance(@point_1,@point_2,Geometry::Spheroid::Earth.mean_radius,:unit => :deg)
+
+      # Pythagoras
+      deg_ew = (@point_2[1] - @point_1[1]) * Math.cos(@point_1[0])
+      deg_ns = (@point_1[0] - @point_2[0])
+      deg_change  = Math.sqrt(deg_ew ** 2 + deg_ns ** 2)
+      py_distance = Geometry.deg_to_rad(deg_change) * Geometry::Spheroid::Earth.mean_radius
+      
+      py_distance.should be < hv_distance
+    end
+
+  end
+
+  it "should convert degrees to radians" 
+
+end

data/spec/geo_vector_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Geometry::GeoVector do 
+
+  it "should calculate the great circle intersection" do
+    point_1 = Geometry::GeoVector.from_geographic(  0.0,  0.0)
+		point_2 = Geometry::GeoVector.from_geographic(  0.0, 10.0)
+		point_3 = Geometry::GeoVector.from_geographic( 20.0, 10.0)
+		point_4 = Geometry::GeoVector.from_geographic(-20.0, 10.0)
+
+		intersection = Geometry::GeoVector.from_great_circle_intersection(point_1,point_2,point_3,point_4)
+
+		intersection.should be_a Geometry::GeoVector
+		
+		coords = intersection.to_geographic(:unit=>:deg)
+
+		coords.first.should be_within(0.001).of(0.0)
+		coords.last.should be_within(0.001).of(-170.0)
+
+		antipode_coords = intersection.antipode.to_geographic(:unit=>:deg)
+
+		antipode_coords.first.should be_within(0.001).of(0.0)
+		antipode_coords.last.should be_within(0.001).of(10.0)
+  end
+
+  it "should calculate a great circle distance" do
+  	point_1 = Geometry::EarthVector.from_geographic(0.0,  0.0)
+		point_2 = Geometry::EarthVector.from_geographic(0.0, 10.0)
+
+		geo_vector_estimate = point_1.great_circle_distance(point_2)
+
+		haversine_estimate = Geometry.haversine_distance([0.0,  0.0], [0.0,  10.0], Geometry::Spheroid::Earth.mean_radius, :unit => :deg)
+
+		haversine_estimate.should be_within(0.001).of(geo_vector_estimate)
+
+  end
+	
+end