server-side-google-maps 0.0.5 → 0.1.0

data/README.md

@@ -11,25 +11,25 @@ To install:
 
 Then, to use within Ruby:
 
-    directions = Directions.new('Montreal, QC', 'Ottawa, ON', :mode => :driving)
+    route = ServerSideGoogleMaps::Route.new(['Montreal, QC', 'Ottawa, ON'], :mode => :driving)
     # Origin and destination accept [lat,lon] coordinates as well as strings
     # :mode => :driving is the default. Others are :bicycling and :walking
 
-    directions.status              # 'OK'
-    directions.origin_address      # 'Montreal, QC, Canada'
-    directions.origin_point        # [ 45.5086700, -73.5536800 ]
-    directions.destination_address # 'Ottawa, ON, Canada'
-    directions.destination_point   # [ 45.4119000, -75.6984600 ]
-    directions.points              # Array of [lat,lon] coordinates of route
-    directions.distance            # 199901 (metres)
-
-    route = Route.new(['Montreal, QC', 'Ottawa, ON', 'Toronto, ON'], :mode => :bicycling)
-    # All the same methods apply to route as to directions
+    route.status              # 'OK'
+    route.origin_address      # 'Montreal, QC, Canada'
+    route.origin_point        # [ 45.5086700, -73.5536800 ]
+    route.destination_address # 'Ottawa, ON, Canada'
+    route.destination_point   # [ 45.4119000, -75.6984600 ]
+    route.path.points         # Array of Point coordinates of route
+    route.points[0].latitude  # .latitude, .longitude, .distance_to_here
+    route.distance            # 199901 (metres)
 
     # We can also find elevations along a path
-    path = Path.new([ [ 45.5086700, -73.5536800 ], [ 45.4119000, -75.6984600 ] ]) # a straight line
-    path.elevations(20) # Array of equidistant altitudes, in metres, along the path
-    # Paths may only be up to around 230 points long, to comply with Google's URL length limit.
+    path = route.path
+    path.elevations(20) # Array of equidistant Points, each with an elevation
+    # Paths used for elevation may only be up to around 230 points long,
+    # to comply with Google's URL length limit. That's not hard to achieve:
+    simple_path = path.interpolate(230) # will create a new Path by interpolating
 
 One final `:mode` is `:direct`, which calculates `points` and estimates
 `distance` without querying Google. To ensure Google isn't queried, input

data/lib/server-side-google-maps.rb

@@ -5,6 +5,7 @@ require 'server-side-google-maps/version'
 require 'server-side-google-maps/directions'
 require 'server-side-google-maps/geo_math'
 require 'server-side-google-maps/path'
+require 'server-side-google-maps/point'
 require 'server-side-google-maps/route'
 require 'server-side-google-maps/server'
 

data/lib/server-side-google-maps/directions.rb

@@ -47,7 +47,7 @@ module ServerSideGoogleMaps
 
           other = Directions.new(origin, destination, params.merge(:mode => mode))
           if other.distance.to_f / distance < factor
-            @points = other.points
+            @path = other.path
             @distance = other.distance
           end
         end
@@ -71,31 +71,31 @@ module ServerSideGoogleMaps
     end
 
     def origin_point
-      @origin_point ||= origin_point_without_server || [ leg['start_location']['lat'], leg['start_location']['lng'] ]
+      @origin_point ||= origin_point_without_server || Point.new(leg['start_location']['lat'], leg['start_location']['lng'])
     end
 
     def destination_point
-      @destination_point ||= destination_point_without_server || [ leg['end_location']['lat'], leg['end_location']['lng'] ]
+      @destination_point ||= destination_point_without_server || Point.new(leg['end_location']['lat'], leg['end_location']['lng'])
     end
 
     def status
       @data['status']
     end
 
-    def points
-      @points ||= calculate_points
-    end
-
     def distance
       @distance ||= calculate_distance
     end
 
-    def estimated_distance
-      @estimated_distance ||= calculate_estimated_distance
+    def path
+      @path ||= Path.new(points)
     end
 
     private
 
+    def points # DEPRECATED
+      @points ||= calculate_points
+    end
+
     def origin_point_without_server
       calculate_point_without_server_or_nil(origin_input)
     end
@@ -107,7 +107,7 @@ module ServerSideGoogleMaps
     def calculate_point_without_server_or_nil(input)
       return input if Array === input
       m = LATLNG_STRING_REGEXP.match(input)
-      return [ m[1].to_f, m[3].to_f ] if m
+      return Point.new(m[1].to_f, m[3].to_f) if m
     end
 
     def route
@@ -124,34 +124,25 @@ module ServerSideGoogleMaps
 
     def calculate_points_and_levels
       polyline = route['overview_polyline']
-      return [ origin_point + [0], destination_point + [0]] unless polyline && polyline['points'] && polyline['levels']
+      return [ [origin_point.latitude, origin_point.longitude, 0], [destination_point.latitude, destination_point.longitude, 0]] unless polyline && polyline['points'] && polyline['levels']
       ::GoogleMapsPolyline.decode_polyline(polyline['points'], polyline['levels'])
     end
 
     def calculate_points
       return [ origin_point, destination_point ] if @direct
-      points = points_and_levels.map { |lat,lng,level| [lat,lng] }
+      points = points_and_levels.map { |lat,lng,level| Point.new(lat, lng) }
       points
     end
 
     def calculate_distance
-      return estimated_distance if @direct
+      if @direct
+        path.calculate_distances unless path.points[0].distance_along_path
+        return path.points[-1].distance_along_path
+      end
       if !leg['distance']
         return leg['steps'].collect{|s| s['distance']}.collect{|d| d ? d['value'].to_i : 0}.inject(0){|s,v| s += v}
       end
       leg['distance']['value']
     end
-
-    def calculate_estimated_distance
-      d = 0
-      last_point = points[0]
-
-      points[1..-1].each do |point|
-        d += GeoMath.latlng_distance(last_point, point)
-        last_point = point
-      end
-
-      d
-    end
   end
 end

data/lib/server-side-google-maps/path.rb

@@ -1,5 +1,7 @@
 module ServerSideGoogleMaps
   class Path
+    attr_reader(:points)
+
     def self.get_elevations(params)
       server = Server.new
       server.get('/maps/api/elevation', {:sensor => false}.merge(params))
@@ -10,15 +12,82 @@ module ServerSideGoogleMaps
       raise ArgumentError.new('path must have one or more points') unless points.length > 0
       i = 0
       @points = points.collect do |pt|
-        raise ArgumentError.new("path element #{i} must be a [latitude, longitude] Array") unless pt.length == 2
-        pt.dup
+        raise ArgumentError.new("path element #{i} must have .latitude and .longitude") unless pt.respond_to?(:latitude)
+        pt
       end
     end
 
-    # Returns an Array of n equidistant altitudes (in metres) along this path
+    # Returns a new Path with n equidistant Points along this Path, complete with .elevation
     def elevations(n)
       results = self.class.get_elevations(:path => "enc:#{encoded_path}", :samples => n)
-      results['results'].collect { |r| r['elevation'].to_f }
+      points = results['results'].collect do |r|
+        Point.new(
+          r['location']['lat'].to_f,
+          r['location']['lng'].to_f,
+          :elevation => r['elevation'].to_f
+        )
+      end
+      Path.new(points)
+    end
+
+    # Sets .distance on every Point in the Path
+    #
+    # Yes, this is a hack: it assumes all the Points will only belong to this Path.
+    # It's here because it's convenient.
+    def calculate_distances
+      total_distance = 0
+      last_point = nil
+      points.each do |point|
+        if last_point
+          distance_piece = last_point.distance(point)
+          total_distance += distance_piece
+        end
+        point.distance_along_path = total_distance
+        last_point = point
+      end
+    end
+
+    # Returns a Path that approximates this one, with n points
+    def interpolate(n)
+      calculate_distances unless points[0].distance_along_path
+
+      total_distance = points[-1].distance_along_path - points[0].distance_along_path
+      distance_step = 1.0 * total_distance / (n - 1)
+
+      ret = []
+      ret << Point.new(
+        points[0].latitude,
+        points[0].longitude,
+        :distance_along_path => points[0].distance_along_path
+      )
+
+      j = 0
+      current_distance = points[0].distance_along_path
+      (1...(n - 1)).each do |i|
+        current_distance += distance_step if i > 0
+        while j < (points.length - 2) && points[j + 1].distance_along_path < current_distance #&& points[j].distance_along_path == points[j + 1].distance_along_path
+          j += 1
+        end
+
+        point_before = points[j]
+        point_after = points[j + 1]
+        point_segment_length = point_after.distance_along_path - point_before.distance_along_path
+
+        fraction_after = (1.0 * current_distance - point_before.distance_along_path) / point_segment_length
+        fraction_before = 1.0 - fraction_after
+
+        ret << Point.new(
+          fraction_before * point_before.latitude + fraction_after * point_after.latitude,
+          fraction_before * point_before.longitude + fraction_after * point_after.longitude,
+          :distance_along_path => current_distance.round
+        )
+      end
+
+      ret << Point.new(
+        points[-1].latitude,
+        points[-1].longitude,
+        :distance_along_path => points[-1].distance_along_path
+      )
     end
 
     private
@@ -28,7 +97,7 @@ module ServerSideGoogleMaps
     end
 
     def points_1e5
-      @points.map { |latitude, longitude| [ (latitude * 1e5).to_i, (longitude * 1e5).to_i ] }
+      @points.map { |p| [ (p.latitude * 1e5).to_i, (p.longitude * 1e5).to_i ] }
     end
   end
 end

data/lib/server-side-google-maps/point.rb

@@ -0,0 +1,49 @@
+module ServerSideGoogleMaps
+  class Point
+    RADIUS_OF_EARTH = 6367000 # metres
+    DEGREES_TO_RADIANS = Math::PI / 180
+
+    attr_reader(:latitude, :longitude, :object, :elevation)
+    attr_accessor(:distance_along_path)
+
+    def initialize(latitude, longitude, options = {})
+      @latitude = latitude
+      @longitude = longitude
+      @object = options[:object] if options[:object]
+      @distance_along_path = options[:distance_along_path] if options[:distance_along_path]
+      @elevation = options[:elevation] if options[:elevation]
+    end
+
+    def ==(other)
+      latitude == other.latitude && longitude == other.longitude && object == other.object
+    end
+
+    # Calculates the distance to another point, in metres
+    #
+    # The method assumes the Earth is a sphere.
+    def distance(other)
+      lat1 = latitude * DEGREES_TO_RADIANS
+      lat2 = other.latitude * DEGREES_TO_RADIANS
+      dlat = lat2 - lat1
+      dlon = (longitude - other.longitude) * DEGREES_TO_RADIANS
+
+      # Optimize a tad. This method is slow.
+      sin_dlat = Math.sin(dlat / 2)
+      sin_dlon = Math.sin(dlon / 2)
+
+      a = sin_dlat * sin_dlat + Math.cos(lat1) * Math.cos(lat2) * sin_dlon * sin_dlon
+
+      sqrt_a = Math.sqrt(a)
+
+      c = 2 * Math.asin(1.0 < sqrt_a ? 1.0 : sqrt_a)
+
+      (RADIUS_OF_EARTH * c).to_i
+    end
+
+    def latlng_distance_squared(other)
+      latitude_difference = latitude - other.latitude
+      longitude_difference = longitude - other.longitude
+      latitude_difference * latitude_difference + longitude_difference * longitude_difference
+    end
+  end
+end

data/lib/server-side-google-maps/route.rb

@@ -32,22 +32,22 @@ module ServerSideGoogleMaps
       @directionses.last.destination_point
     end
 
-    def points
-      @points ||= calculate_points
+    def path
+      Path.new(points)
     end
 
     def distance
       @distance ||= @directionses.map{|d| d.distance}.inject(:+)
     end
 
-    def estimated_distance
-      @estimated_distance ||= @directionses.map{|d| d.estimated_distance}.inject(:+)
-    end
-
     private
 
+    def points # DEPRECATED
+      @points ||= calculate_points
+    end
+
     def calculate_points
-      pointses = @directionses.map { |d| d.points }
+      pointses = @directionses.map { |d| d.path.points }
 
       first = pointses.shift
 

data/lib/server-side-google-maps/version.rb

@@ -1,3 +1,3 @@
 module ServerSideGoogleMaps
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/spec/directions_spec.rb

@@ -70,8 +70,8 @@ module ServerSideGoogleMaps
 
       it('should have origin_point and destination_point') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON')
-        directions.origin_point.should == [ 45.5086700, -73.5536800 ]
-        directions.destination_point.should == [ 45.4119000, -75.6984600 ]
+        directions.origin_point.should == Point.new(45.5086700, -73.5536800)
+        directions.destination_point.should == Point.new(45.4119000, -75.6984600)
       end
 
       it('should have an "OK" status') do
@@ -81,11 +81,11 @@ module ServerSideGoogleMaps
 
       it('should have the proper points') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON')
-        points = directions.points
+        points = directions.path.points
         points.length.should == 138
-        points[0].should == [45.50867, -73.55368]
-        points[1].should == [45.50623, -73.55569]
-        points[-1].should == [45.4119, -75.69846]
+        points[0].should == Point.new(45.50867, -73.55368)
+        points[1].should == Point.new(45.50623, -73.55569)
+        points[-1].should == Point.new(45.4119, -75.69846)
       end
 
       it('should have the proper distance') do
@@ -94,27 +94,21 @@ module ServerSideGoogleMaps
         distance.should == 199901
       end
 
-      it('should supply an estimated_distance') do
-        directions = Directions.new('Montreal,QC', 'Ottawa,ON')
-        distance = directions.estimated_distance
-        distance.should == 199127
-      end
-
       it('should suggest a straight line, with :direct') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON', :mode => :direct)
-        directions.points.should == [[45.50867, -73.55368], [45.4119, -75.69846]]
+        directions.path.points.should == [Point.new(45.50867, -73.55368), Point.new(45.4119, -75.69846)]
         directions.distance.should == 167512
       end
 
       it('should suggest normal route if :find_shortcuts shortcuts are not short enough') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON', :find_shortcuts => [{ :factor => 0.5, :mode => :direct }])
-        directions.points.length.should > 2
+        directions.path.points.length.should > 2
         directions.distance.should == 199901
       end
 
       it('should suggest a shortcut if :find_shortcuts finds a shortcut') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON', :find_shortcuts => [{ :factor => 0.95, :mode => :direct }])
-        directions.points.length.should == 2
+        directions.path.points.length.should == 2
         directions.distance.should == 167512
       end
 
@@ -157,7 +151,7 @@ module ServerSideGoogleMaps
 
       it('should provide the start-point and end-point instead') do
         directions = Directions.new('Montreal,QC', 'Ottawa,ON')
-        directions.points.should == [[45.50867, -73.55368], [45.4119, -75.69846]]
+        directions.path.points.should == [Point.new(45.50867, -73.55368), Point.new(45.4119, -75.69846)]
       end
     end
   end

data/spec/path_spec.rb

@@ -15,7 +15,7 @@ module ServerSideGoogleMaps
       end
 
       it('should allow a 1-point path') do
-        pt = [ 45.5086700, -73.5536800 ]
+        pt = Point.new(45.5086700, -73.5536800)
         Path.new([pt])
       end
     end
@@ -37,22 +37,74 @@ module ServerSideGoogleMaps
       describe('#elevations') do
         it('should pass an encoded :path and :samples to #get_elevations') do
           Path.should_receive(:get_elevations).with(:path => 'enc:elwtGn}|_M~piJnlqb@', :samples => 20)
-          pt1 = [ 45.50867, -73.55368 ]
-          pt2 = [ 43.65235, -79.38240 ]
+          pt1 = Point.new(45.50867, -73.55368)
+          pt2 = Point.new(43.65235, -79.38240)
           path = Path.new([pt1, pt2])
           path.elevations(20)
         end
 
         it('should return the proper elevations') do
-          pt1 = [ 45.50867, -73.55368 ]
-          pt2 = [ 43.65235, -79.38240 ]
+          pt1 = Point.new(45.50867, -73.55368)
+          pt2 = Point.new(43.65235, -79.38240)
           path = Path.new([pt1, pt2])
           elevations = path.elevations(20)
-          elevations.length.should == 20 # the 20 is from the stub file, not the above argument
-          elevations[0].should == 15.3455887
-          elevations[19].should == 89.6621323
+          elevations.points.length.should == 20 # the 20 is from the stub file, not the above argument
+          elevations.points[0].elevation.should == 15.3455887
+          elevations.points[0].latitude.should == 45.50867
+          elevations.points[0].longitude.should == -73.55368
+          elevations.points[19].elevation.should == 89.6621323
         end
       end
     end
+
+    describe('#calculate_distances') do
+      it('should put 0 on a 1-element Path') do
+        p1 = Point.new(1.0, 2.0)
+        path = Path.new([p1])
+        path.calculate_distances
+        path.points[0].distance_along_path.should == 0
+      end
+
+      it('should calculate the distance for each element') do
+        p1 = Point.new(1.0, 2.0)
+        p2 = Point.new(4.0, 1.0)
+        p3 = Point.new(3.0, 8.0)
+        path = Path.new([p1, p2, p3])
+        path.calculate_distances
+        path.points[0].distance_along_path.should == 0
+        path.points[1].distance_along_path.should == 351371
+        path.points[2].distance_along_path.should == 1135696
+      end
+    end
+
+    describe('#interpolate') do
+      it('should return a new, interpolated Path with more than the original number of points') do
+        p1 = Point.new(1.0, 2.0)
+        p2 = Point.new(7.0, 2.0)
+        p3 = Point.new(7.0, 1.0)
+        path = Path.new([p1, p2, p3])
+        interpolated = path.interpolate(8)
+        interpolated.length.should == 8
+        interpolated[0].should == p1
+        interpolated[6].latitude.to_s.should == '6.9936056564358' # too many decimals...
+        interpolated[6].longitude.should == 2.0
+        interpolated[6].distance_along_path.should == 666039
+        interpolated[7].should == p3
+      end
+
+      it('should work okay when duplicate Points are on the Path') do
+        p1 = Point.new(1.0, 2.0)
+        p2 = Point.new(7.0, 2.0)
+        p2_2 = Point.new(7.0, 2.0)
+        p3 = Point.new(7.0, 1.0)
+        path = Path.new([p1, p2, p2_2, p3])
+        interpolated = path.interpolate(8)
+        interpolated[0].should == p1
+        interpolated[6].latitude.to_s.should == '6.9936056564358' # too many decimals...
+        interpolated[6].longitude.should == 2.0
+        interpolated[6].distance_along_path.should == 666039
+        interpolated[7].should == p3
+      end
+    end
   end
 end

data/spec/point_spec.rb

@@ -0,0 +1,50 @@
+require 'spec'
+
+module ServerSideGoogleMaps
+  describe(Point) do
+    describe('#initialize') do
+      it('should set latitude and longitude') do
+        point = Point.new(1.2, 3.4)
+        point.latitude.should == 1.2
+        point.longitude.should == 3.4
+      end
+
+      it('should work without an "object" option') do
+        point = Point.new(1.2, 3.4)
+        point.object.should == nil
+      end
+
+      it('should work with a "distance_along_path" option') do
+        point = Point.new(1.2, 3.4, :distance_along_path => 341)
+        point.distance_along_path.should == 341
+      end
+
+      it('should work with a "elevation" option') do
+        point = Point.new(1.2, 3.4, :elevation => 341)
+        point.elevation.should == 341
+      end
+
+      it('should allow an "object" option') do
+        object = [1, 2, 3]
+        point = Point.new(1.2, 3.4, :object => object)
+        point.object.should == object
+      end
+    end
+
+    describe('#latlng_distance_squared') do
+      it('should calculate the lat/lng distance squared') do
+        point1 = Point.new(1.0, 4.0)
+        point2 = Point.new(2.0, 6.0)
+        point1.latlng_distance_squared(point2).should == 5.0
+      end
+    end
+
+    describe('#distance') do
+      it('should calculate the distance') do
+        point1 = Point.new(1.0, 4.0)
+        point2 = Point.new(2.0, 6.0)
+        point1.distance(point2).should == 248412
+      end
+    end
+  end
+end

data/spec/route_spec.rb

@@ -58,18 +58,18 @@ module ServerSideGoogleMaps
 
       it('should return appropriate origin_point and destination_point') do
         route = Route.new(['Montreal,QC', 'Ottawa,ON', 'Toronto,ON'])
-        route.origin_point.should == [ 45.5086700, -73.5536800 ]
-        route.destination_point.should == [ 43.65235, -79.3824 ]
+        route.origin_point.should == Point.new(45.5086700, -73.5536800)
+        route.destination_point.should == Point.new(43.65235, -79.3824)
       end
 
       it('should concatenate the points from component directions') do
         route = Route.new(['Montreal,QC', 'Ottawa,ON', 'Toronto,ON'])
-        points = route.points
+        points = route.path.points
         points.length.should == 352
-        points[0].should == [45.50867, -73.55368]
-        points[137].should == [45.4119, -75.69846]
-        points[138].should == [45.40768, -75.69567]
-        points[351].should == [ 43.65235, -79.3824 ]
+        points[0].should == Point.new(45.50867, -73.55368)
+        points[137].should == Point.new(45.4119, -75.69846)
+        points[138].should == Point.new(45.40768, -75.69567)
+        points[351].should == Point.new(43.65235, -79.3824)
       end
 
       it('should have the proper distance') do
@@ -78,12 +78,6 @@ module ServerSideGoogleMaps
         distance.should == 649742
       end
 
-      it('should have the proper estimated_distance') do
-        route = Route.new(['Montreal,QC', 'Ottawa,ON', 'Toronto,ON'])
-        distance = route.estimated_distance
-        distance.should == 647730
-      end
-
       it('should not alter params') do
         original_params = {
           :mode => :driving,

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: server-side-google-maps
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
+  hash: 27
+  prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 5
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors: 
 - Adam Hooper
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-17 00:00:00 -05:00
-default_executable: 
+date: 2011-06-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: httparty
@@ -77,6 +76,7 @@ files:
 - lib/server-side-google-maps/directions.rb
 - lib/server-side-google-maps/geo_math.rb
 - lib/server-side-google-maps/path.rb
+- lib/server-side-google-maps/point.rb
 - lib/server-side-google-maps/route.rb
 - lib/server-side-google-maps/server.rb
 - lib/server-side-google-maps/version.rb
@@ -89,9 +89,9 @@ files:
 - spec/files/directions-Ottawa,ON-to-Toronto,ON.txt
 - spec/files/path1-get_elevations-result.txt
 - spec/path_spec.rb
+- spec/point_spec.rb
 - spec/route_spec.rb
 - spec/spec.rb
-has_rdoc: true
 homepage: http://github.com/adamh/server-side-google-maps
 licenses: []
 
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: server-side-google-maps
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Performs calculations with Google Maps