sgslib 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fc3371c28ba4e23106c0a6ec7438269c4e127a4
-  data.tar.gz: 513b37fe44496a798e3c9a332fa7446bd35d7a93
+  metadata.gz: a552ab707d5da785deb99f2b4118c2e3df9ebfe2
+  data.tar.gz: 36f82fa588da1882b67f32a8cff7709e4f4ca3c9
 SHA512:
-  metadata.gz: cc840557ca82d76640c300cd2fb93745da198f5827444ff38afd84c2a11aabfd429dcfd600cc54ea30020c28acecd2a9b5719f820a8d277e8060e5ed97e20d73
-  data.tar.gz: a574b15c37a867713b01cf4583edfafa4623461c433d30ad87512d47b507d76224abe8b91aaaefed6ad65d4a3e8d57ed46f1921ce8e461aebd41f5fa3a8979b9
+  metadata.gz: 1aec2712b93140cb27373d170dcbc5a9371ff7d451055752ca8c9c323d59080591f7012b790179c7abd07bd87dd9ec809b72033f374e172a25a54f67f88d74e8
+  data.tar.gz: 991805459fe5a66e8c2efc0be306a1d368abb1bedb76ab20bbfc73139aa4bfc0f7ca216844ede153e8529e5aebf6093fe99b4b91548db0dce501fb36d48eb6b9

data/lib/sgs/course.rb

@@ -0,0 +1,178 @@
+#
+# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
+# software; you can redistribute it and/or modify it under the terms of the
+# GNU General Public License as published by the Free Software Foundation;
+# either version 2, or (at your option) any later version.
+#
+# It is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this product; see the file COPYING.  If not, write to the Free
+# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+##
+# Routines for handling sailboat navigation and route planning.
+#
+# The code on this page was derived from formulae on the Movable Type site:
+# http://www.movable-type.co.uk/scripts/latlong.html
+#
+
+require 'date'
+
+module SGS
+  ##
+  #
+  # A class to handle the course sailed, as well as polar speed calculations.
+  # For speed calculations, it takes a range of polars as polynomials and
+  # then applies them.
+  class Course
+    attr_reader :awa, :speed
+    attr_writer :polar_curve
+
+    TACK_NAME = ["Starboard", "Port"].freeze
+    STARBOARD = 0
+    PORT = 1
+
+    #
+    # Right now, we have one polar - from a Catalina 22.
+    # Note that the speed is the same, regardless of the tack.
+    STANDARD = [
+       -3.15994,
+       23.8741,
+      -27.4595,
+       16.4868,
+       -5.15663,
+        0.743936,
+       -0.0344716
+    ].freeze
+
+    #
+    # Set up the default values
+    def initialize(wind = nil)
+      @polar_curve = STANDARD
+      @awa = 0.0
+      @speed = 0.0
+      @wind = wind || Bearing.new(0.0, 10.0)
+      @heading = nil
+      self.heading = 0
+    end
+
+    #
+    # Return the current heading
+    def heading
+      @heading
+    end
+
+    #
+    # Return the heading in degrees
+    def heading_d
+      Bearing.rtod @heading
+    end
+
+    #
+    # Return the wind direction/speed
+    def wind
+      @wind
+    end
+
+    #
+    # Return the Apparent Wind Angle (AWA) in degrees
+    def awa_d
+      Bearing.rtod @awa
+    end
+
+    #
+    # Return the current tack
+    def tack
+      (@awa and @awa < 0.0) ? PORT : STARBOARD
+    end
+
+    #
+    # Return the tack name
+    def tack_name
+      TACK_NAME[tack]
+    end
+
+    #
+    # Set the heading
+    def heading=(new_heading)
+      return if @heading and @heading == new_heading
+      if new_heading > 2*Math::PI
+        new_heading -= 2*Math::PI
+      elsif new_heading < 0.0
+        new_heading += 2*Math::PI
+      end
+      @heading = new_heading
+      self.awa = @wind.angle - @heading
+    end
+
+    #
+    # Set the wind direction and recompute the AWA if appropriate. Note
+    # that we don't care about wind speed (for now)
+    def wind=(new_wind)
+      return if @wind and @wind.angle == new_wind.angle
+      @wind = new_wind
+      self.awa = @wind.angle - @heading
+    end
+
+    #
+    # Calculate the AWA based on our heading and wind direction
+    def awa=(new_awa)
+      if new_awa < -Math::PI
+        new_awa += 2*Math::PI
+      elsif new_awa > Math::PI
+        new_awa -= 2*Math::PI
+      end
+      return if @awa == new_awa
+      @awa = new_awa
+      compute_speed
+    end
+
+    #
+    # Compute a relative VMG based on the waypoint
+    def relative_vmg(waypt)
+      relvmg = @speed * Math::cos(waypt.bearing.angle - @heading) / waypt.distance
+      puts "Relative VMG to WPT: #{waypt.name} is #{relvmg}"
+      relvmg
+    end
+
+    #
+    # Compute the hull speed from the polar. This is just a guestimate of how
+    # fast the boat will travel at the particular apparent wind angle.
+    def compute_speed
+      awa = @awa.abs
+      return 0.0 if awa < 0.75
+      ap = 1.0
+      @speed = 0.0
+      @polar_curve.each do |poly_val|
+        @speed += poly_val * ap
+        ap *= awa
+      end
+      @speed /= 2.5           # Fudge for small boat
+      if @speed < 0.0
+        @speed = 0.0
+      end
+    end
+
+    #
+    # Convert to a string
+    def to_s
+      "Heading %dd (wind %.1f@%dd, AWA:%dd, speed=%.2fknots)" % [heading_d, wind.distance, wind.angle_d, awa_d, speed]
+    end
+  end
+end

data/lib/sgs/location.rb

@@ -32,6 +32,11 @@ require 'date'
 require 'json'
 
 module SGS
+  #
+  # Nominal radius of the planet, in nautical miles.
+  # http://en.wikipedia.org/wiki/Earth_radius#Mean_radii
+  EARTH_RADIUS = 3440.069528437724
+
   ##
   #
   # Class for dealing with latitude/longitude. Includes methods for parsing,
@@ -43,11 +48,6 @@ module SGS
   class Location
     attr_accessor :latitude, :longitude
 
-    #
-    # Nominal radius of the planet, in nautical miles.
-    # http://en.wikipedia.org/wiki/Earth_radius#Mean_radii
-    EARTH_RADIUS = 3440.069528437724
-
     #
     # Create the Location instance.
     def initialize(lat = nil, long = nil)
@@ -55,6 +55,13 @@ module SGS
       @longitude = long.to_f if long
     end
 
+    #
+    # The difference between two locations is a Bearing
+    def -(loc)
+      puts "Distance from #{self} to #{loc}"
+      Bearing.compute(self, loc)
+    end
+
     #
     # Calculate a new position from the current position
     # given a bearing (angle and distance)
@@ -66,18 +73,18 @@ module SGS
     #              Math.cos(lat1)*Math.sin(d/R)*Math.cos(angle) );
     # var lon2 = lon1 + Math.atan2(Math.sin(angle)*Math.sin(d/R)*Math.cos(lat1), 
     #                     Math.cos(d/R)-Math.sin(lat1)*Math.sin(lat2));
-    def calculate(bearing)
+    def +(bearing)
       loc = Location.new
       sin_angle = Math.sin(bearing.angle)
       cos_angle = Math.cos(bearing.angle)
-      sin_dstr = Math.sin(bearing.distance / EARTH_RADIUS)
-      cos_dstr = Math.cos(bearing.distance / EARTH_RADIUS)
+      sin_dstr = Math.sin(bearing.distance / SGS::EARTH_RADIUS)
+      cos_dstr = Math.cos(bearing.distance / SGS::EARTH_RADIUS)
       sin_lat1 = Math.sin(@latitude)
       cos_lat1 = Math.cos(@latitude)
       loc.latitude = Math.asin(sin_lat1*cos_dstr + cos_lat1*sin_dstr*cos_angle)
-      sin_lat2 = Math.sin(loc.latitude)
+      sin_lat2 = Math.sin(@latitude)
       loc.longitude = @longitude + Math.atan2(sin_angle*sin_dstr*cos_lat1,
-                              cos_dstr - sin_lat1*sin_lat2)
+                                              cos_dstr - sin_lat1*sin_lat2)
       loc
     end
 
@@ -139,42 +146,42 @@ module SGS
 
     #
     # Display the lat/long as it would appear in a KML file.
-    def to_kml(sep = ' ')
+    def to_kml(sep = ',')
       vals = [@longitude, @latitude, 0.0]
-      str_vals = vals.map {|val| "%.6f" % Bearing.radians_to_degrees(val)}
+      str_vals = vals.map {|val| "%.8f" % Bearing.rtod(val)}
       str_vals.join(sep)
     end
 
     #
     # Helper functions for working in degrees.
-    def latitude_degrees
-      Bearing.radians_to_degrees @latitude
+    def latitude_d
+      Bearing.rtod @latitude
     end
 
-    def latitude_degrees=(val)
-      @latitude = Bearing.degrees_to_radians val
+    def latitude_d=(val)
+      @latitude = Bearing.dtor val
     end
 
     def latitude_array(fmt = nil)
-      make_ll_array latitude_degrees, "NS", fmt
+      make_ll_array latitude_d, "NS", fmt
     end
 
-    def longitude_degrees
-      Bearing.radians_to_degrees @longitude
+    def longitude_d
+      Bearing.rtod @longitude
     end
 
-    def longitude_degrees=(val)
-      @longitude = Bearing.degrees_to_radians val
+    def longitude_d=(val)
+      @longitude = Bearing.dtor val
     end
 
     def longitude_array(fmt = nil)
-      make_ll_array longitude_degrees, "EW", fmt
+      make_ll_array longitude_d, "EW", fmt
     end
 
     #
     # Subtract one location from another, returning a bearing
     def -(loc)
-      Bearing.calculate(self, loc)
+      Bearing.compute(self, loc)
     end
 
   private
@@ -186,7 +193,7 @@ module SGS
       val = args.shift
       val = val + args.shift / 60.0 if args.length > 0
       val = val + args.shift / 3600.0 if args.length > 0
-      Bearing.degrees_to_radians val * ((nsew.index(dir) == 1) ? -1 : 1)
+      Bearing.dtor val * ((nsew.index(dir) == 1) ? -1 : 1)
     end
 
     #
@@ -198,7 +205,7 @@ module SGS
       else
         chr = str[0]
       end
-      "%8.6f%c" % [Bearing.radians_to_degrees(val), chr]
+      "%8.6f%c" % [Bearing.rtod(val), chr]
     end
 
     #
@@ -235,18 +242,18 @@ module SGS
     #
     # Create a bearing from an angle in degrees.
     def self.degrees(angle, distance)
-      new(Bearing.degrees_to_radians(angle), distance)
+      new(Bearing.dtor(angle), distance)
     end
 
     #
     # Handy function to translate degrees to radians
-    def self.degrees_to_radians(deg)
+    def self.dtor(deg)
       deg.to_f * Math::PI / 180.0
     end
 
     #
     # Handy function to translate radians to degrees
-    def self.radians_to_degrees(rad)
+    def self.rtod(rad)
       rad.to_f * 180.0 / Math::PI
     end
 
@@ -259,7 +266,7 @@ module SGS
     #
     # Another handy function to re-adjust an angle (in degrees) away from
     # negative.
-    def self.absolute_degrees(angle)
+    def self.absolute_d(angle)
       (angle + 360) % 360
     end
 
@@ -279,7 +286,7 @@ module SGS
     # var x = Math.cos(lat1)*Math.sin(lat2) -
     #         Math.sin(lat1)*Math.cos(lat2)*Math.cos(dLon);
     # var angle = Math.atan2(y, x).toDeg();
-    def self.calculate(loc1, loc2)
+    def self.compute(loc1, loc2)
       bearing = new
       sin_lat1 = Math.sin(loc1.latitude)
       sin_lat2 = Math.sin(loc2.latitude)
@@ -288,7 +295,7 @@ module SGS
       sin_dlon = Math.sin(loc2.longitude - loc1.longitude)
       cos_dlon = Math.cos(loc2.longitude - loc1.longitude)
       bearing.distance = Math.acos(sin_lat1*sin_lat2 + cos_lat1*cos_lat2*cos_dlon) *
-                                Location::EARTH_RADIUS
+                                SGS::EARTH_RADIUS
       y = sin_dlon * cos_lat2
       x = cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_dlon
       bearing.angle = Math.atan2(y, x)
@@ -309,8 +316,8 @@ module SGS
 
     #
     # Return the angle (in degrees)
-    def angle_degrees
-      Bearing.radians_to_degrees(@angle).to_i
+    def angle_d
+      Bearing.rtod(@angle).to_i
     end
 
     #
@@ -322,7 +329,7 @@ module SGS
     #
     # Convert to a string
     def to_s
-      "BRNG %03dd,%.3fnm" % [angle_degrees, @distance]
+      "BRNG %03dd,%.3fnm" % [angle_d, @distance]
     end
   end
 end

data/lib/sgs/mission.rb

@@ -29,319 +29,328 @@
 # Routines for handling sailboat navigation and route planning.
 #
 require 'date'
+require 'nokogiri'
 
 module SGS
   #
   # Handle a specific mission.
   class Mission
-    attr_accessor :id, :where, :time, :start_time
-    attr_accessor :course, :heading, :twa, :vmg
-    attr_accessor :waypoints, :repellors, :track
-    attr_accessor :root_dir
+    attr_accessor :attractors, :repellors, :track
+    attr_accessor :where, :time, :course, :distance
 
     #
-    # Create the attractors and repellors
-    def initialize(id = 0)
-      @root_dir = "."
-      @waypoints = []
+    # Create the attractors and repellors as well as the track array
+    # and other items. @where is our current TrackPoint, @current_wpt is
+    # the waypoint we're working (-1 if none), @course is the heading/speed
+    # the boat is on.
+    def initialize
+      @attractors = []
       @repellors = []
-      @track = []
-      @id = id
-      @time = DateTime.now
-      @wpt_index = -1
-      @heading = -1
-      @course = -1
-      @tack = 0
+      @track = nil
+      @current_wpt = -1
+      @start_time = @time = nil
+      @where = nil
+      @course = Course.new
+      @distance = 0
+      @swing = 60
     end
 
     #
     # Load a new mission from the missions directory.
-    def self.load(id)
+    def self.load(filename)
       mission = new
-      mission.id = id
-      mission.read(File.open(mission.filename))
+      mission.read(File.open(filename))
       mission
     end
 
-    #
-    # Parse a mission file.
-    def read(file)
-      file.each do |line|
-        unless line =~ /^#/
-          args = line.split(':')
-          code = args[0]
-          loc = Location.parse_str(args[1])
-          vec = Bearing.degrees(args[2], args[3])
-          name = args[4].strip
-          case code
-          when /\d/
-            @waypoints[code.to_i] = Waypoint.new(loc, vec, name)
-          when /[Xx]/
-            @where = loc
-            @wind = vec
-            compute_heading if active?
-          when /[Rr]/
-            @repellors << Waypoint.new(loc, vec, name, Waypoint::REPELLOR)
-          end
-        end
-      end
-      @wpt_index = -1
-    end
-
-    #
-    # Save the mission.
-    def save
-      write(File.open(filename, 'w'))
-    end
-
-    #
-    # Write a mission to a file.
-    def write(file)
-      file.puts "#\n# My starting position."
-      file.puts "X:%s:0:12:Starting position" % @where
-      file.puts "#\n# Waypoints."
-      @waypoints.each_with_index do |wpt, i|
-        file.puts "%d:%s:%d:%f:%s" % [i,
-                                      wpt.location,
-                                      wpt.chord.angle_degrees,
-                                      wpt.chord.distance,
-                                      wpt.name]
-      end
-    end
-
     #
     # Commence a mission...
     def commence(time = nil)
-      @start_time = time || DateTime.now
-      @time = @start_time
-      @wpt_index = 0
-      @have_new_waypoint = true
-      @have_new_heading = true
-      @have_new_tack = false
+      @start_time = @time = time || Time.now
+      @track = [TrackPoint.new(time, @where)]
+      @current_wpt = 0
     end
 
     #
     # Terminate a mission.
     def terminate
-      @wpt_index = -1
-    end
-
-    #
-    # On-mission means we have something to do. In other words, we have a
-    # waypoint to get to.
-    def active?
-      @wpt_index >= 0 and @wpt_index < @waypoints.count
+      puts "***** Mission terminated! *****"
+      @current_wpt = -1
     end
 
     #
-    # Set our current  location (and timestamp).
-    def set_location(where, time = nil)
-      @where = where
-      @time = time || DateTime.now
+    # Compute the best heading based on our current position and the position
+    # of the current attractor. This is where the heavy-lifting happens
+    def navigate
+      return unless active?
+      puts "Attempting to navigate to #{waypoint}"
       #
-      # Update the track with our new position, and find the next waypoint.
-      @track << Track.new(@time, @where.clone)
-      again = false
-      begin
-        wpt = @waypoints[@wpt_index]
-        puts ">>Waypoint is #{wpt}"
-        wpt.compute_bearing(@where)
-        puts ">>Course #{wpt.bearing}"
-        if wpt.in_scope?
-          puts "We're at the mark. Time to find the next waypoint..."
-          @wpt_index += 1
-          @have_new_waypoint = again = true
-        else
-          again = false
-        end
-      end while again and active?
+      # First off, compute distance and bearing from our current location
+      # to every attractor and repellor.
+      @attractors[@current_wpt..-1].each do |waypt|
+        waypt.compute_bearing(@where)
+        puts "Angle: #{waypt.bearing.angle_d}, Distance: #{waypt.bearing.distance} (adj:#{waypt.distance})"
+      end
+      @repellors.each do |waypt|
+        waypt.compute_bearing(@where)
+        puts "Angle: #{waypt.bearing.angle_d}, Distance: #{waypt.bearing.distance} (adj:#{waypt.distance})"
+      end
       #
-      # OK, now compute our heading...
-      if active?
-        newc = wpt.bearing.angle_degrees
-        if newc != @course
-          puts "New course: #{newc}"
-          @course = newc
-          compute_heading
-        end
+      # Right. Now look to see if we've achieved the current waypoint and
+      # adjust, accordingly
+      while active? and reached? do
+        next_waypoint!
       end
-    end
-    #
-    # Compute the most effective TWA/VMG for the course.
-    # Because I tend to forget, here's a run-down of the terminology...
-    # @course is where we're trying to get to. It is our compass bearing to the
-    # next mark or finish or whatever. @heading is the compass bearing we're
-    # going to sail to, which may not be the same as our course (we can't sail
-    # upwind, for example). alpha is the difference between our heading and the
-    # course. @twa is the true wind angle, relative to the front of the boat.
-    # Negative values mean a port tack, positive values are starboard. @vmg is
-    # the velocity made-good. In other words, the speed at which we're heading
-    # to the mark. It's defined as Vcos(alpha) where V is the velocity through
-    # the water.
-    def compute_heading
-      puts "Computing Heading and TWA..."
-      wad = @wind.angle_degrees.to_i
-      puts "Wind angle:%03dd" % wad
-      puts "Required course:%03dd" % @course
-      polar = Polar.new
-      @twa ||= 0
+      return unless active?
+      puts "Angle to next waypoint: #{waypoint.bearing.angle_d}d"
+      puts "Adjusted distance to waypoint is #{@distance}"
       #
-      # Try an alpha angle between -60 and +60 degrees either side of the
-      # course. The point of this exercise is to compute the TWA for that
-      # heading, compute the speed at that trial TWA, and then compute
-      # the VMG for it. We compute the maximum VMG (and TWA) and use that
-      # to drive the boat. The PVMG is the poisoned version of the VMG,
-      # adjusted so that the opposite tack is less-favoured.
-      ideal_twa = 0
-      ideal_vmg = 0.0
-      max_pvmg = 0.0
-      curr_tack = @twa < 0.0 ? -1 : 1
-      puts "Current tack is %d" % curr_tack
-      (-60..60).each do |alpha|
-        newh = Bearing.absolute_degrees(@course + alpha)
-        twa = 180 - (720 + wad - @course - alpha) % 360
-        puts "Trial heading of %03dd (alpha=%d, TWA=%d)" % [newh, alpha, twa]
-        speed = polar.speed(Bearing.degrees_to_radians(twa))
-        vmg = polar.vmg(Bearing.degrees_to_radians(alpha))
+      # Now, start the vector field analysis by examining headings either side
+      # of the bearing to the waypoint.
+      best_course = @course
+      best_relvmg = 0.0
+      puts "Currently on a #{@course.tack_name} tack (heading is #{@course.heading_d} degrees)"
+      (-@swing..@swing).each do |alpha_d|
+        puts ">> Computing swing of #{alpha_d} degrees"
+        new_course = Course.new(@course.wind)
+        new_course.heading = waypoint.bearing.angle + Bearing.dtor(alpha_d)
         #
-        # Adjust the speed to favour the current tack.
-        tack_err = twa < 0.0 ? -curr_tack : curr_tack
-        pvmg = vmg + vmg * tack_err / 5.0
-        if vmg > 1.7 and false
-          puts "Trial TWA: %3d, speed:%.5fkn, VMG:%.6fkn" % [twa, speed, vmg]
+        # Ignore head-to-wind cases, as they're pointless.
+        next if new_course.speed < 0.001
+        puts "AWA:#{new_course.awa_d}, heading:#{new_course.heading_d}, speed:#{new_course.speed}"
+        relvmg = 0.0
+        relvmg = new_course.relative_vmg(@attractors[@current_wpt])
+        @attractors[@current_wpt..-1].each do |waypt|
+          relvmg += new_course.relative_vmg(waypt)
         end
-        if pvmg > max_pvmg
-          max_pvmg = pvmg
-          ideal_twa = twa
-          ideal_vmg = vmg
+        @repellors.each do |waypt|
+          relvmg -= new_course.relative_vmg(waypt)
+        end
+        relvmg *= 0.1 if new_course.tack != @course.tack
+        puts "Relative VMG: #{relvmg}"
+        if relvmg > best_relvmg
+          puts "Best heading (so far)"
+          best_relvmg = relvmg
+          best_course = new_course
         end
       end
-      #
-      # For the various angles, we have computed the best TWA and VMG. Now
-      # adjust our settings, accordingly. Don't use the poisoned VMG.
-      @twa = ideal_twa
-      @vmg = ideal_vmg
-      @have_new_tack = (@twa * curr_tack) < 0
-      puts "> Best TWA is %d, VMG is %.6fknots" % [@twa, @vmg]
-      #
-      # Check to see if we have a new heading.
-      newh = Bearing::absolute_degrees(wad - @twa)
-      puts "> HDG:%03dd, Err:%03dd" % [newh, newh - @course]
-      if newh != @heading
-        puts "New Heading! %03dd" % newh
-        @have_new_heading = true
-        @heading = newh
-      end
+      puts "Best RELVMG: #{best_relvmg}"
+      puts "TACKING!" if best_course.tack != @course.tack
+      puts "New HDG: #{best_course.heading_d} (AWA:#{best_course.awa_d}), WPT:#{waypoint.name}"
+      @course = best_course
     end
 
     #
-    # Set the wind data.
-    def wind_data(angle, speed = 0.0)
-      @wind = Bearing.degrees(angle, speed)
-      puts "Wind:#{@wind}"
-      compute_heading if active?
+    # Set new position
+    def set_position(time, loc)
+      @where = loc
+      @time = time
+      @track << TrackPoint.new(@time, @where)
     end
 
     #
-    # Wind speed (Beaufort scale)
-    BEAUFORT = [0, 1, 4, 7, 11, 17, 22, 28, 34, 41]
-    def wind_beaufort
-      ws = @wind.speed
+    # Advance the mission by a number of seconds (computing the new location
+    # in the process). Fake out the speed and thus the location.
+    def simulated_movement(how_long = 60)
+      puts "Advancing mission by #{how_long}s"
+      distance = @course.speed * how_long.to_f / 3600.0
+      puts "Travelled #{distance * 1852.0} metres in that time."
+      set_position(@time + how_long, @where + Bearing.new(@course.heading, distance))
+    end
+
+    #
+    # On-mission means we have something to do. In other words, we have a
+    # waypoint to get to.
+    def active?
+      @current_wpt >= 0 and @current_wpt < @attractors.count
     end
 
     #
-    # Are we at a new waypoint?
-    def new_waypoint?
-      hnw = @have_new_waypoint
-      @have_new_waypoint = false
-      active? and hnw
+    # How long has the mission been active?
+    def elapsed
+      @time - @start_time
     end
 
     #
-    # Do we have a new heading?
-    def new_heading?
-      hnh = @have_new_heading
-      @have_new_heading = false
-      active? and hnh
+    # Return the current waypoint.
+    def waypoint
+      active? ? @attractors[@current_wpt] : nil
     end
 
     #
-    # Do we need to tack?
-    def tacking?
-      hnt = @have_new_tack
-      @have_new_tack = false
-      active? and hnt
+    # Have we reached the waypoint? Note that even though the waypoints have
+    # a "reached" circle, we discard the last 10m on the basis that it is
+    # within the GPS error.
+    def reached?
+      @distance = @attractors[@current_wpt].distance
+      puts "ARE WE THERE YET? (dist=#{@distance})"
+      return true if @distance <= 0.0027
+      #
+      # Check to see if the next WPT is nearer than the current one
+      #if @current_wpt < (@attractors.count - 1)
+      #  next_wpt = @attractors[@current_wpt + 1]
+      #  brng = @attractors[@current_wpt].location - next_wpt.location
+      #  angle = Bearing.absolute(waypoint.bearing.angle - next_wpt.bearing.angle)
+      #  return true if brng.distance > next_wpt.distance and
+      #                 angle > (0.25 * Math::PI) and
+      #                 angle < (0.75 * Math::PI)
+      #end
+      puts "... Sadly, no."
+      return false
     end
 
     #
-    # Return the next (current) waypoint.
-    def waypoint
-      active? ? @waypoints[@wpt_index] : nil
+    # Advance to the next waypoint. Return TRUE if
+    # there actually is one...
+    def next_waypoint!
+      raise "No mission currently active" unless active?
+      @current_wpt += 1
+      puts "Attempting to navigate to #{waypoint.name}" if active?
     end
+
     #
     # Return the mission status as a string
     def status_str
-      mins = (@time - @start_time) * 24.0 * 60.0
-      hours = (mins / 60.0).to_i
+      mins = elapsed / 60
+      hours = mins / 60
+      mins %= 60
       days = hours / 24
-      mins = (mins % 60.0).to_i
       hours %= 24
-      str = ">>>#{@time}, "
+      str = ">>> #{@time}, "
       if days < 1
-        str += "%dh%dm" % [hours, mins]
+        str += "%dh%02dm" % [hours, mins]
       else
-        str += "%dd%dh" % [days, mins]
+        str += "+%dd%%02dh%02dm" % [days, hours, mins]
       end
       str + ": My position is #{@where}"
     end
 
     #
-    # Name/path of mission file.
-    def filename
-      @root_dir + "/missions/%03d" % id
+    # Compute the remaining distance from the current location
+    def overall_distance
+      start_wpt = active? ? @current_wpt : 0
+      dist = 0.0
+      loc = @where
+      @attractors[start_wpt..-1].each do |wpt|
+        wpt.compute_bearing(loc)
+        dist += wpt.bearing.distance
+        loc = wpt.location
+      end
+      dist
+     end
+
+    #
+    # Parse a mission file.
+    def read(file)
+      file.each do |line|
+        unless line =~ /^#/
+          args = line.split(':')
+          code = args[0]
+          loc = Location.parse_str(args[1])
+          nrml = Bearing.dtor args[2].to_i
+          dist = args[3].to_f
+          name = args[4].chomp
+          case code
+          when /[Xx]/
+            @where = loc
+            @course.wind = Bearing.new(nrml, dist)
+          when /\d/
+            @attractors[code.to_i] = Waypoint.new(loc, nrml, dist, name)
+          when /[Rr]/
+            @repellors << Waypoint.new(loc, nrml, dist, name, true)
+          end
+        end
+      end
+      @current_wpt = -1
     end
 
     #
-    # Save the track.
-    def track_save
-      kml_write(File.open(track_filename, 'w'))
+    # Write a mission to a file.
+    def write(filename)
+      File.open(filename, 'w') do |file|
+        file.puts "#\n# My starting position."
+        file.puts ["X", @where.to_s, @course.wind.angle_d.to_i, @course.wind.distance.to_i, "Starting position"].join(':')
+        file.puts "#\n# Attractors."
+        @attractors.each_with_index do |wpt, i|
+          file.puts "%d:%s:%d:%f:%s" % [i,
+                                        wpt.location,
+                                        wpt.normal_d,
+                                        wpt.radius,
+                                        wpt.name]
+        end
+        file.puts "#\n# Repellors."
+        @repellors.each do |wpt|
+          file.puts "r:%s:%d:%f:%s" % [wpt.location,
+                                        wpt.normal_d,
+                                        wpt.radius,
+                                        wpt.name]
+        end
+      end
     end
 
     #
-    # The name of the track file
-    def track_filename
-      @root_dir + "/tracks/output-%03d.kml" % id
+    # Save the track.
+    def track_save(filename)
+      kml_write(File.open(filename, 'w'))
     end
 
     #
     # Write the track data as a KML file.
+#                xml.LineString {
+#                  xml.extrude 1
+#                  xml.tessellate 1
+#                  xml.coordinates wpt.to_kml
+#                }
+#              }
+#              xml.Placemark {
+#                xml.styleUrl "#attractorLine"
+#                xml.LineString {
+#                  xml.extrude 1
+#                  xml.tessellate 1
+#                  xml.coordinates wpt.to_axis_kml
+#                }
+#              }
     def kml_write(file)
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.kml('xmlns' => 'http://www.opengis.net/kml/2.2',
                 'xmlns:gx' => 'http://www.google.com/kml/ext/2.2') {
           xml.Folder {
-            xml_line_style(xml, "waypointLine", "0xffcf0000", 4)
+            xml_line_style(xml, "attractorLine", "0xffcf0000", 4)
             xml_line_style(xml, "repellorLine", "0xff00007f", 4)
             xml_line_style(xml, "trackLine")
-            @waypoints.each do |wpt|
+            @attractors.each do |wpt|
               xml.Placemark {
                 xml.name wpt.name
-                xml.styleUrl "#waypointLine"
-                xml.LineString {
-                  xml.extrude 1
-                  xml.tessellate 1
-                  xml.coordinates wpt.to_kml
+                xml.styleUrl "#attractorLine"
+                xml.Point {
+                  xml.coordinates wpt.location.to_kml
                 }
               }
+            end
+            @repellors.each do |wpt|
               xml.Placemark {
-                xml.styleUrl "#waypointLine"
-                xml.LineString {
-                  xml.extrude 1
-                  xml.tessellate 1
-                  xml.coordinates wpt.to_axis_kml
+                xml.name wpt.name
+                xml.styleUrl "#repellorLine"
+                xml.Point {
+                  xml.coordinates wpt.location.to_kml
                 }
               }
             end
+            xml.Placemark {
+              xml.name "Track"
+              xml.styleUrl "#trackLine"
+              xml.GX_Track {
+                @track.each do |pt|
+                  xml.when pt.time.strftime('%Y-%m-%dT%H:%M:%S+00:00')
+                  end
+                @track.each do |pt|
+                  xml.GX_coord pt.location.to_kml(' ')
+                end
+              }
+            }
+          }
+        }
+      end
       # Requires a hack to get rid of the 'gx:' for the when tag.
       file.puts builder.to_xml.gsub(/GX_/, 'gx:')
     end

data/lib/sgs/nmea.rb

@@ -55,7 +55,7 @@ module SGS
     # Parse an NMEA string into its component parts.
     def parse(str)
       str.chomp!
-      if str[0] != 36
+      if str[0] != "$"
         return -1
       end
       str, sum = str[1..-1].split('*')
@@ -80,7 +80,7 @@ module SGS
         return nil
       end
       gps = SGS::GPS.new
-      gps.valid = @args[2] == "A"
+      gps.is_valid if @args[2] == "A"
       hh = @args[1][0..1].to_i
       mm = @args[1][2..3].to_i
       ss = @args[1][4..-1].to_f
@@ -92,7 +92,7 @@ module SGS
       gps.time = Time.gm(yy, mn, dd, hh, mm, ss, us)
       gps.location = Location.parse ll_nmea(@args[3,4]), ll_nmea(@args[5,6])
       gps.sog = @args[7].to_f
-      gps.cmg = Bearing.degrees_to_radians @args[8].to_f
+      gps.cmg = Bearing.dtor @args[8].to_f
       gps
     end
 
@@ -107,7 +107,7 @@ module SGS
       @args.concat gps.location.latitude_array
       @args.concat gps.location.longitude_array("%03d%07.4f")
       @args[7] = "%.2f" % gps.sog
-      @args[8] = "%.2f" % Bearing.radians_to_degrees(gps.cmg)
+      @args[8] = "%.2f" % Bearing.radians_to_d(gps.cmg)
       @args[9] = gps.time.strftime("%d%m%y")
       @args.concat ['', '']
       @args << 'A'

data/lib/sgs/redis_base.rb

@@ -139,6 +139,7 @@ module SGS
         end
         $redis.incr count_name
       end
+      true
     end
 
     #

data/lib/sgs/version.rb

@@ -1,3 +1,3 @@
 module SGS
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/sgs/waypoint.rb

@@ -34,82 +34,113 @@ module SGS
   #
   # Waypoint, Attractor, and Repellor definitions
   class Waypoint < RedisBase
-    attr_accessor :location, :chord, :type, :name, :bearing, :distance
+    attr_accessor :location, :normal, :radius, :name, :repellor, :bearing
+    attr_reader :bearing, :distance
 
     #
-    # Types of waypoints
-    START_LINE = 0
-    FINISH_LINE = 1
-    WAYPOINT = 2
-    REPELLOR = 3
-
-    def initialize(location = nil, chord = nil, name = "", type = WAYPOINT)
+    # Define a new Attractor or Repellor, based on certain parameters.
+    # The location is the centre of the waypoint. The normal is the compass
+    # angle of the start of the semicircle, and the radius is the size of
+    # the arc. You can specify an optional name for the waypoint and also
+    # indicate if we should be attracted or repelled by it.
+    def initialize(location = nil, normal = 0.0, radius = 0.1, name = "", repellor = false)
       @location = location || Location.new
-      @chord = chord
-      @type = type
+      @normal = normal
+      @radius = radius
       @name = name
+      @repellor = repellor
+      @bearing = nil
+      @distance = 0
     end
 
     #
-    # Calculate the back-vector from the waypoint to the specified position
-    # Calculate the adjusted distance between the mark and the set location.
+    # Calculate the back-vector from the waypoint to the specified position.
+    # Calculate the adjusted distance between the position and the mark.
     # Check to see if our back-bearing from the waypoint to our location is
-    # inside the chord of the waypoint. If so, reduce the distance to the
-    # waypoint by the length of the chord.
+    # inside the chord of the waypoint, which is a semicircle commencing at
+    # the normal. If so, reduce the distance to the waypoint by the length
+    # of the chord. @distance is the adjusted distance to the location
     def compute_bearing(loc)
-      @bearing = Bearing.calculate(loc, @location)
+      @bearing = loc - @location
       @distance = @bearing.distance
-      d = Bearing.new(@bearing.back_angle - @chord.angle, @distance)
-      # A chord angle of 0 gives a semicircle from 180 to 360 degrees
-      # (inclusive). If our approach angle is within range, then reduce our
-      # distance to the mark by the chord distance (radius).
-      unless d.angle > 0.0 and d.angle < Math::PI
-        @distance -= @chord.distance
-      end
+      d = Bearing.new(@bearing.back_angle - @normal, @bearing.distance)
+      # A chord angle of 0 gives a semicircle from 0 to 180 degrees. If our
+      # approach angle is within range, then reduce our distance to the mark
+      # by the chord distance (radius).
+      @distance -= @radius if d.angle >= 0.0 and d.angle < Math::PI
+      @distance = 0.0 if @distance < 0.0
       @distance
     end
 
+    #
+    # Is this an attractor?
+    def attractor?
+      @repellor == false
+    end
+
+    #
+    # Is this a repellor?
+    def repellor?
+      @repellor == true
+    end
+
     #
     # Is the waypoint in scope? In other words, is our angle inside the chord.
     def in_scope?
       puts "In-scope distance is %f..." % @distance
-      @distance <= 0.0
+      @distance == 0.0
+    end
+
+    #
+    # Convert the waypoint normal to/from degrees
+    def normal_d
+      Bearing.rtod @normal
+    end
+
+    #
+    # Convert the waypoint normal to/from degrees
+    def normal_d=(val)
+      @normal = Bearing.dtor val
     end
 
     #
     # Pretty version of the waypoint.
     def to_s
-      "'#{@name}' at #{@location} => #{chord}"
+      "'#{@name}' at #{@location} => #{normal_d}%#{@radius}"
     end
 
     #
     # Display a string for a KML file
     def to_kml
-      c2 = @chord.clone
-      c2.angle += Math::PI
-      pos1 = @location.calculate(@chord)
-      pos2 = @location.calculate(c2)
-      "#{pos1.to_kml(',')} #{pos2.to_kml(',')}"
+      puts "TO KML!"
+      #p self
+      #c2 = @chord.clone
+      #c2.angle += Math::PI
+      #pos1 = @location.calculate(@chord)
+      #pos2 = @location.calculate(c2)
+      #"#{pos1.to_kml(',')} #{pos2.to_kml(',')}"
     end
 
     #
     # Show the axis line for the waypoint (as a KML)
     def to_axis_kml
-      c2 = @chord.clone
-      c2.angle += 1.5 * Math::PI
-      pos1 = @location.calculate(c2)
-      "#{@location.to_kml(',')} #{pos1.to_kml(',')}"
+      puts "TO_AXIS_KML!"
+      #::FIXME::
+      #c2 = @chord.clone
+      #c2.angle += 1.5 * Math::PI
+      #pos1 = @location.calculate(c2)
+      #"#{@location.to_kml(',')} #{pos1.to_kml(',')}"
     end
   end
 
   #
-  # Store the track over the ground.
-  class Track
+  # Store an individual track point.
+  class TrackPoint
     attr_accessor :time, :location
 
-    def initialize(time, location)
-      @time = time
-      @location = location
+    def initialize(time = nil, location = nil)
+      @time = time ? time.clone : nil
+      @location = location ? location.clone : nil
     end
   end
 end

data/lib/sgslib.rb

@@ -33,13 +33,13 @@ require 'sgs/location'
 require 'sgs/nmea'
 require 'sgs/gps'
 require 'sgs/waypoint'
-require 'sgs/polar'
 require 'sgs/alarm'
 require 'sgs/timing'
 require 'sgs/command'
 require 'sgs/otto'
+require 'sgs/course'
 require 'sgs/navigate'
-#require 'mission'
+require 'sgs/mission'
 
 module SGS
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sgslib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Dermot Tynan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-22 00:00:00.000000000 Z
+date: 2018-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,7 @@ files:
 - bin/setup
 - lib/sgs/alarm.rb
 - lib/sgs/command.rb
+- lib/sgs/course.rb
 - lib/sgs/gps.rb
 - lib/sgs/location.rb
 - lib/sgs/logger.rb
@@ -93,7 +94,6 @@ files:
 - lib/sgs/navigate.rb
 - lib/sgs/nmea.rb
 - lib/sgs/otto.rb
-- lib/sgs/polar.rb
 - lib/sgs/redis_base.rb
 - lib/sgs/setup.rb
 - lib/sgs/timing.rb
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: Sailboat Guidance System

data/lib/sgs/polar.rb

@@ -1,86 +0,0 @@
-#
-# Copyright (c) 2013, Kalopa Research.  All rights reserved.  This is free
-# software; you can redistribute it and/or modify it under the terms of the
-# GNU General Public License as published by the Free Software Foundation;
-# either version 2, or (at your option) any later version.
-#
-# It is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-# for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this product; see the file COPYING.  If not, write to the Free
-# Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-# THIS SOFTWARE IS PROVIDED BY KALOPA RESEARCH "AS IS" AND ANY EXPRESS OR
-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-# IN NO EVENT SHALL KALOPA RESEARCH BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-
-##
-# Routines for handling sailboat navigation and route planning.
-#
-# The code on this page was derived from formulae on the Movable Type site:
-# http://www.movable-type.co.uk/scripts/latlong.html
-#
-
-require 'date'
-
-module SGS
-  ##
-  #
-  # A class to handle boat polar calculations. It takes a range of polars
-  # as polynomials and then applies them.
-  class Polar
-    # Right now, we have one polar - from a Catalina 22.
-    # Note that the speed is the same, regardless of the tack.
-    STANDARD = [
-       -3.15994,
-       23.8741,
-      -27.4595,
-       16.4868,
-       -5.15663,
-        0.743936,
-       -0.0344716
-    ].freeze
-
-    #
-    # set up the default values
-    def initialize
-      @curve = STANDARD
-    end
-
-    #
-    # Compute the hull speed from the polar
-    # :awa: is the apparent wind angle (in radians)
-    # :wspeed: is the wind speed (in knots)
-    def speed(awa, wspeed = 0.0)
-      awa = awa.to_f.abs
-      ap = 1.0
-      @speed = 0.0
-      @curve.each do |poly_val|
-        @speed += poly_val * ap
-        ap *= awa
-      end
-      @speed /= 1.529955
-      if @speed < 0.0
-        @speed = 0.0
-      end
-      @speed
-    end
-
-    #
-    # Calculate the VMG from the angle to the mark.
-    def vmg(alpha)
-      Math::cos(alpha) * @speed
-    end
-  end
-end