geo_vectors 0.5.0

data/lib/geo_vectors.rb

@@ -0,0 +1,7 @@
+require 'geo_vectors/geo_point'
+require 'geo_vectors/geo_vector'
+require 'geo_vectors/vector_parser'
+require 'geo_vectors/point_vector'
+require 'geo_vectors/bearing_vector'
+require 'geo_vectors/direction_vector'
+require 'geo_vectors/geo_vectors'

data/lib/geo_vectors/bearing_vector.rb

@@ -0,0 +1,87 @@
+require 'geo_vectors/geo_vector'
+
+class BearingVector < GeoVector
+  include GeoDistance::Extract
+  include GeoUnits::Converter
+  
+  attr_reader :bearing
+  attr_reader :distance
+
+  # should be Distance objects!
+  def initialize dist, bearing
+    dist, bearing = [bearing, dist] if bearing.kind_of? GeoDistance
+    self.bearing   = bearing
+    self.distance  = dist
+  end
+
+  def direction
+    begin
+      bearing_to_dir bearing
+    rescue
+      bearing
+    end
+  end     
+
+  def random_vector                             
+    BearingVector.new distance.random, random_bearing
+  end
+
+  def add_to_point! point
+    dest_point = point.destination_point bearing, distance.in_kms
+    point.lat = dest_point.lat
+    point.lng = dest_point.lng
+    point        
+  end
+
+  def add_to_point point
+    self.dup.add_to_point! point 
+  end
+
+  # normalize to within 0-360 degrees
+  def bearing= brng
+    @bearing  = brng.normalize_degrees
+  end
+
+  def distance= dist
+    @distance = extract_distance dist
+  end 
+
+  def reverse
+    self.dup.reverse!
+  end
+
+  def reverse!
+    reverse_bearing! 
+    self    
+  end
+
+  def scale! scale
+    @distance = distance * scale 
+  end
+  
+  def unit
+    distance.unit
+  end
+  
+  def to_s
+    "#{distance}, bearing: #{bearing} degrees"
+  end
+  
+  protected
+
+  def reverse_bearing!
+    shift = case bearing
+    when 0
+      0
+    when -360..0
+      180
+    when 0..360
+      -180
+    end
+    self.bearing = bearing + shift
+  end
+  
+  def random_bearing
+    rand(360 * 100)  / 100
+  end  
+end

data/lib/geo_vectors/core_ext.rb

@@ -0,0 +1,54 @@
+require 'geo_vectors/util/geo_distance'
+
+class Fixnum
+  include GeoDistance::Unit
+end
+
+class Float
+  include GeoDistance::Unit
+end
+
+class GeoVector
+  module Macros
+    def point_vector
+      PointVector.new self.geo_point
+    end
+    alias_method :vector, :point_vector
+    alias_method :geo_vector, :point_vector
+    alias_method :p_vector, :point_vector
+  end
+end
+
+class GeoPoint
+  include ::GeoVector::Macros
+end
+
+class Hash
+  include GeoVector::Macros
+end
+
+class String
+  include GeoVector::Macros
+end
+
+class Array
+  include GeoVector::Macros
+
+  def b_vector
+    raise ArgumentException, "To create a BearingVector, the Array must contain at least 2 elements, one for bearing and oen for distance" if !(size >= 2)
+    BearingVector.new self[0], self[1]
+  end
+  alias_method :bearing_vector, :b_vector  
+
+  def d_vector
+    raise ArgumentException, "To create a DirectionVector, the Array must contain at least 2 elements, one for bearing and oen for distance" if !(size >= 2)
+    raise ArgumentException, "The second element in the Array must be a Symbol defining the direction of the vector" if !self[1].kind_of?(Symbol)
+    DirectionVector.new self[0], self[1]
+  end  
+  alias_method :direction_vector, :d_vector    
+  
+  def to_point
+    geo_point
+  end
+end    
+  

data/lib/geo_vectors/direction_vector.rb

@@ -0,0 +1,59 @@
+require 'geo_vectors/geo_vector'
+
+class DirectionVector < GeoVector
+  include GeoDistance::Extract
+  include GeoDirection
+  
+  attr_reader :direction # direction symbol :N, :S, :SW, etc.
+  attr_reader :distance # GeoDistance object
+
+  def initialize dist, dir
+    dist, dir = [dir, dist] if dir.kind_of? GeoDistance
+    @distance   = extract_distance dist
+    @direction  = get_valid_direction dir
+  end
+
+  def random_vector                             
+    DirectionVector.new distance.random, random_direction
+  end
+
+  def direction= dir
+    @direction = get_valid_direction dir
+  end
+
+  def distance= dist
+    @distance = extract_distance dist
+  end
+
+  def scale! scale
+    @distance *= scale 
+  end
+  
+  def unit
+    distance.unit
+  end
+    
+  def as_bearing_vector 
+    to_bearing_vector direction, distance
+  end    
+
+  def as_point_vector 
+    to_point_vector direction, distance
+  end 
+  
+  # return new point from adding vector to point
+  def add_to_point point
+    vec = as_bearing_vector
+    point.destination_point vec.bearing, vec.distance.in_kms
+  end
+
+  # add vector directly to point (destructive update)
+  def add_to_point! point
+    vec = as_bearing_vector
+    dest = point.destination_point vec.bearing, vec.distance.in_kms
+    point.lat = dest.lat
+    point.lng = dest.lng
+    point
+  end
+     
+end

data/lib/geo_vectors/geo_point.rb

@@ -0,0 +1,33 @@
+class GeoPoint  
+  include GeoCalc
+  
+  def + *args
+    self.dup.add! *args
+  end
+  alias_method :add, :+
+  alias_method :<<, :+
+  
+  def add! *args
+    vec = GeoVector::Parser.create_vector *args
+    vec.add_to_point! self
+  end  
+
+  def - *args
+    self.dup.sub! *args
+  end
+  alias_method :sub, :-
+  
+  def sub! *args
+    vec = GeoVector::Parser.create_vector *args
+    vec.sub_from_point! self
+  end  
+
+  def vector
+    to_lat_lng.vector
+  end
+
+  def geo_point
+    self
+  end
+  
+end

data/lib/geo_vectors/geo_vector.rb

@@ -0,0 +1,56 @@
+require 'geo_calc'
+require 'geo_vectors/core_ext'
+require 'geo_vectors/util'
+
+# A Vector consists of info that can transform a point into a destination point given some operation on that info  
+class GeoVector
+  attr_reader :unit  
+
+  def initialize
+    @unit = :degrees
+  end
+
+  def add! vector
+    raise '#add! method must be implemented by including class'
+  end
+
+  def scale! scalar
+    raise '#scale! method must be implemented by including class'
+  end
+
+  def direction
+    raise '#distance method must be implemented by including class'
+  end
+
+  def distance
+    raise '#distance method must be implemented by including class'
+  end
+
+  def add vector
+    self.dup.add! vector
+  end
+  
+  alias_method :<<, :add
+  alias_method :+,  :add
+
+  def sub! vector
+    add! vector.reverse
+  end
+
+  def sub vector
+    self.dup.sub vector
+  end
+  alias_method :-,  :sub
+  
+  def scale scalar
+    self.dup.scale! scalar
+  end      
+  alias_method :*,  :scale
+  alias_method :enhance, :*
+  alias_method :grow_by, :*
+
+  def / scalar
+    scale (1.0 / scalar)
+  end
+  alias_method :reduce, :/    
+end

data/lib/geo_vectors/geo_vectors.rb

@@ -0,0 +1,92 @@
+# Operations that apply on a collection of GeoVector
+class GeoVectors < Array
+  include Enumerable
+  # include GeoVector
+  attr_reader :vectors
+
+  def initialize *vectors
+    self.vectors = vectors
+  end
+
+  def vectors= *vectors
+    vectors = vectors.flatten
+    raise ArgumentError, "GeoVectors can only contain GeoVector instances" if !vectors.only_kinds_of? GeoVector
+    @vectors = vectors
+  end
+
+  # iterate each and call direction
+  def directions
+    vectors.map {|v| v.direction }
+  end
+
+  def distances
+    vectors.map {|v| v.distance }
+  end
+
+  def each &block
+    vectors.each { |v| yield v }
+  end
+
+  # return new point from adding vector to point
+  def add_to_point point
+    add_to_point! point.dup
+  end
+
+  # add vector directly to point (destructive update)
+  def add_to_point! point
+    vectors.each do |v|
+      point.add! v
+    end
+    point
+  end
+
+  def sub_from_point point
+    reverse_directions.add_to_point point    
+  end
+
+  def sub_from_point! point
+    reverse_directions.add_to_point! point
+  end
+
+  def scale! scalar
+    each {|v| v.scale! scalar }
+    self
+  end      
+
+  def scale scalar
+    self.dup.scale! scalar
+  end      
+  alias_method :*,  :scale
+  alias_method :enhance, :*
+  alias_method :grow_by, :*
+
+  def / scalar
+    scale (1.0 / scalar)
+  end
+  alias_method :reduce, :/    
+
+
+  def reverse_directions
+    vectors.each do |v|
+      v.reverse!
+    end    
+    self
+  end
+
+  def to_s
+    vectors.inject([]) do |res, v|
+      res << v.to_s
+      res
+    end.join(' ; ')
+  end
+  
+  protected
+  
+  def check_valid!
+    raise "Only works for an Array of GeoVector" if !valid?
+  end
+  
+  def valid?
+    kind_of?(Array) && only_kinds_of?(GeoVector)
+  end
+end  

data/lib/geo_vectors/point_vector.rb

@@ -0,0 +1,85 @@
+require 'geo_vectors/geo_vector'
+require 'sugar-high/kind_of'
+require 'proxy_party'
+require 'geo_vectors/point_vector/vector_ops'
+require 'geo_vectors/point_vector/point_ops'
+
+class PointVector < GeoVector
+  include GeoCalc
+  include VectorOps
+  include PointOps
+
+  attr_accessor :point
+  proxy :point
+  
+  def initialize *args
+    if args[0].kind_of?(GeoPoint) && args.size == 1
+      @point = args[0] 
+    else
+      args = normalize_points(args[0], args[1]) if args.only_kinds_of?(GeoPoint) && args.size == 2
+      @point = GeoPoint.new *args
+    end
+  end
+
+  def direction
+    brng = bearing
+    begin
+      bearing_to_dir brng
+    rescue
+      brng
+    end
+  end     
+
+  def bearing
+    origin.bearing_to(point).to_precision(2).to_f
+  end
+  
+  def point= *args
+    @point = GeoPoint.new *args
+  end
+
+  def length unit = :kms
+    origin.distance_to(point)
+  end
+
+  def distance unit = :kms
+    origin.distance_to(point).send unit
+  end
+
+  def x; lng; end
+  def y; lat; end
+
+  def scale! scalar
+    self.lat = self.lat * scalar
+    self.lng = self.lng * scalar
+    self
+  end      
+
+  def reverse
+    self.dup.reverse!
+  end
+
+  def reverse!
+    self.point.reverse_point!
+    self    
+  end
+
+  protected
+
+  def normalize_points p1, p2
+    lng, lat = [ delta_lat(p1, p2), delta_lng(p1, p2) ]
+  end
+
+  def delta_lat p1, p2
+    p2.lat - p1.lat
+  end
+
+  def delta_lng p1, p2
+    p2.lng - p1.lng
+  end
+  
+  def origin
+    [0, 0].geo_point
+  end
+end
+