gooby 1.1.0 → 1.2.0

data/lib/gooby_lap.rb

@@ -0,0 +1,30 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=begin rdoc
+  Instances of this class represent a <Lap> aggregate object from a
+  Forerunner XML file.
+=end
+  
+  class Lap < GoobyObject
+  
+    attr_accessor :number, :startTime, :duration, :length, :begin_position, :end_position
+  
+    def initialize(num)
+      @number = num  
+    end
+
+    def to_s
+      return "Lap: num: #{@number} start: #{@startTime} dur: #{@duration} len: #{@length} begin: #{@begin_position.to_s} end: #{@end_position.to_s}"
+    end
+
+  end 
+
+end # end of module

data/lib/gooby_line.rb

@@ -0,0 +1,80 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+  class Line < GoobyObject  
+  
+    attr_accessor :raw_data, :tokens
+  
+    def initialize(raw='', delim=nil, strip=false)
+      if strip
+        @raw_data = raw.strip
+      else
+        @raw_data = raw
+      end
+      
+      @tokens   = tokenize(@raw_data, delim, strip=false)  
+    end
+  
+    public
+    
+    def token(idx)
+      @tokens[idx]
+    end
+    
+    def token_count
+      @tokens.size
+    end
+
+    def token_idx_equals(idx, value)
+      if idx < token_count
+        if @tokens[idx] == value
+          return true
+        end
+      end
+      false
+    end
+    
+    def match(pattern)
+      @raw_data.match(pattern)
+    end
+    
+    def is_comment
+      s = @raw_data.strip
+      (s.match('^#')) ? true : false
+    end
+
+    def is_populated_non_comment
+      s = @raw_data.strip
+      if s.size == 0
+        return false
+      end
+      if is_comment
+        return false
+      end
+      return true   
+    end
+    
+    def concatinate_tokens(start_idx = 0)
+      s = ''
+      idx = -1
+      @tokens.each { |tok| 
+        idx = idx + 1
+        if idx >= start_idx
+          s << tok
+          s << ' '
+        end
+      }
+      s.strip!
+      s
+    end
+
+  end
+
+end # end of module

data/lib/gooby_object.rb

@@ -0,0 +1,22 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=begin rdoc
+  This is the abstract superclass of several Gooby classes.  
+  It includes module GoobyKernel.
+=end
+  
+  class GoobyObject  
+    
+    include Gooby::GoobyKernel  
+    
+  end
+
+end # end of module

data/lib/gooby_point.rb

@@ -0,0 +1,172 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+    
+  class Point < GoobyObject  
+  
+    attr_accessor :number, :latitude, :longitude, :altitude, :uom, :note
+  
+    def initialize(*args)
+      @number, @latitude, @longitude, @altitude, @uom, @heartbeat, @note = '', '', '', '', 'm', -1, ''
+      if args
+        if args.size == 1
+          initialize_from_string(args[0]) # yaml 
+        else
+          initialize_from_array(args)
+        end      
+      end
+    end
+    
+    def csv_delim
+      '|'
+    end
+    
+    def english_system
+      if @uom
+        (@uom == 'm') ? true : false
+      else
+        return true  # english is the default
+      end
+    end
+    
+    def metric_system
+      return false if !english_system
+    end
+        
+    def initialize_from_array(args)
+      @latitude  = args[0] if args.size > 0
+      @longitude = args[1] if args.size > 1
+      @altitude  = args[2] if args.size > 2
+      @note      = args[3] if args.size > 3
+    end
+    
+    def initialize_from_string(yaml_value_string) 
+      tokens = yaml_value_string.split
+      if (tokens.size > 2)
+        @latitude    = tokens[0]
+        @longitude   = tokens[1]
+        @note        = ''
+        count        = 0
+        tokens.each { |tok|
+          count = count + 1
+          if (count > 2)
+            @note << tok
+            @note << ' '
+          end
+        } 
+      end
+    end
+      
+    public
+  
+    def has_coordinates?
+      return false if @latitude == nil
+      return false if @latitude.size < 1
+      return false if @longitude == nil
+      return false if @longitude .size < 1
+      return true
+    end
+    
+    def to_s
+      return "lat: #{@latitude} lng: #{@longitude} alt: #{@altitude} note: #{@note}"
+    end
+
+    def to_formatted_string
+      s =  "lat: #{@latitude.to_s.ljust(20)}"
+      s << " lng: #{@longitude.to_s.ljust(20)}"
+      s << " poi.#{@number.to_s.ljust(12)}"  if @number
+      s << " #{@note}" if @note
+      s      
+    end
+  
+    def to_csv
+      return "#{@latitude}#{csv_delim}#{@longitude}#{csv_delim}#{@altitude}"
+    end
+    
+    def latitude_as_float
+      @latitude ? @latitude.to_f : invalid_latitude
+    end
+  
+    def longitude_as_float
+      @longitude ? @longitude.to_f : invalid_longitude
+    end
+  
+    def altitude_as_float
+      @altitude ? @altitude.to_f : invalid_altitude
+    end
+
+    def heartbeat_as_float
+      @heartbeat? @heartbeat.to_f : invalid_heartbeat
+    end
+        
+    def degrees_diff(another_point)      
+      if (another_point)
+        puts "this:  #{to_s}" if false
+        puts "other: #{another_point.to_s}"  if false
+        puts "lats:  #{latitude_as_float}  #{another_point.latitude_as_float}"  if false
+        puts "lngs:  #{longitude_as_float}  #{another_point.longitude_as_float}"  if false
+        lat_diff = latitude_as_float  - another_point.latitude_as_float
+        lng_diff = longitude_as_float - another_point.longitude_as_float
+        diff = lat_diff.abs + lng_diff.abs
+        puts "diff: #{diff} #{lat_diff} #{lng_diff}"  if false
+        diff
+      else
+        360
+      end
+    end 
+    
+    def proximity(another_point, uom)
+      if (another_point)
+        arg1  = latitude_as_float
+        arg2  = another_point.latitude_as_float
+        arg3  = latitude_as_float
+        arg4  = another_point.latitude_as_float
+        theta = longitude_as_float - another_point.longitude_as_float  
+        res1  = Math.sin(deg2rad(arg1))
+        res2  = Math.sin(deg2rad(arg2))
+        res3  = Math.cos(deg2rad(arg3))
+        res4  = Math.cos(deg2rad(arg4))
+        res5  = Math.cos(deg2rad(theta.to_f))
+        dist  = ((res1 * res2) + (res3 * res4 * res5)).to_f
+        
+        if (!dist.nan?)
+          dist = Math.acos(dist.to_f)
+          if (!dist.nan?)    
+            dist = rad2deg(dist)
+            if (!dist.nan?)
+              dist = dist * 60 * 1.1515;
+              if (!dist.nan?)
+                if uom == "km"
+                   dist = dist * 1.609344;
+                end 
+                if uom == "n"
+                   dist = dist * 0.8684;
+                end  
+              end
+            end
+          end
+          return dist.to_f
+        else
+          return 0
+        end
+      else
+        return 0
+      end
+    end  
+  
+    def deg2rad(degrees)
+      (((0 + degrees) * Math::PI) / 180)
+    end
+  
+    def rad2deg(radians)
+      (((0 + radians) * 180) / Math::PI)
+    end
+  end
+
+end # end of module

data/lib/gooby_run.rb

@@ -0,0 +1,213 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+=begin rdoc
+  Instances of this class represent a <Run> aggregate object from a
+  Forerunner XML file.  
+
+  Additionally, there is distance, pace, and Google Map generation logic 
+  in this class.
+=end 
+
+  class Run < GoobyObject 
+  
+    attr_accessor :number, :run_id, :descr, :notes, :tracks, :tkpts, :laps, :distance
+  
+    def initialize(number=0, descr='')
+      @number = number
+      @run_id = nil      
+      @descr  = descr
+      @notes  = ''         
+      @tracks = Array.new
+      @tkpts  = Array.new
+      @laps   = Array.new 
+      @distance = 0
+      @configuration = Hash.new
+      @logProgress = true
+      @finished    = false
+    end
+
+    public
+  
+   # This method is invoked at end-of-parsing.  
+    def finish()
+       @logProgress = false
+       unless @finished
+         @tracks.each { |trk| 
+           trk.trackpoints().each { |tkpt|
+             tkpt.run_number = @number
+             @tkpts.push(tkpt)             
+           }
+         }      
+         compute_distance_and_pace
+         compute_splits
+         set_run_ids
+         @finished = true
+       end  
+     end  
+   
+    public  
+  
+    def add_track(trk)
+      if trk != nil
+        @tracks.push(trk) 
+      end   
+    end
+  
+    def trackpoint_count()
+      @tkpts.size()
+    end
+  
+    def add_lap(lap)
+      @laps.push(lap)    
+    end
+  
+    def lap_count()
+      @laps.size    
+    end
+  
+    def start_dttm()
+      count = 0
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          return tkpt.dttm()
+        }
+      }
+      return nil    
+    end
+  
+    def end_dttm()
+      lastOne = nil
+      @tracks.each { |trk| 
+        trk.trackpoints().each { |tkpt|
+          lastOne = tkpt.dttm()
+        }
+      }
+      lastOne
+    end
+  
+    def duration()
+      first = start_dttm()
+      last  = end_dttm()
+      if first
+        if last
+          return last.hhmmss_diff(first)
+        end
+      end
+      return "00:00:00" 
+    end
+
+    def start_yyyy_mm_dd
+      if start_dttm() 
+        start_dttm().yyyy_mm_dd()
+      else
+          ""
+      end
+    end
+  
+    def start_hh_mm_ss
+      if start_dttm() 
+        start_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end    
+  
+    def end_hh_mm_ss
+      if end_dttm() 
+        end_dttm().hh_mm_ss()
+      else
+          ""
+      end
+    end
+  
+    def to_s
+      finish() unless @finished 
+      s = "Run: #{@number} date: #{start_yyyy_mm_dd} distance: #{distance} duration: #{duration} "
+      s << "  tracks: #{@tracks.size} tkpts: #{trackpoint_count} laps: #{lap_count} "
+      s << "  notes: #{@notes} "
+      s
+    end
+  
+    def print_string     
+      finish() unless @finished       
+      "Run number=#{@number}  tracks=#{@tracks.size} tkpts=#{@tkpts.size} laps=#{@laps.size} distance=#{@distance} "
+    end
+  
+    def put_csv()
+      finish() unless @finished
+      puts "#{@number}|#{}|#{start_yyyy_mm_dd()}|#{start_hh_mm_ss()}|#{end_hh_mm_ss}|#{duration()}|#{@distance}|#{@tracks.size}|#{trackpoint_count()}|#{lap_count}|#{@notes.strip}" 
+    end
+  
+    def put_tkpt_csv()
+      finish() unless @finished    
+      @tkpts.each { | tkpt | 
+        @prev_tkpt = tkpt  if (@prev_tkpt == nil)
+        puts tkpt.to_csv(@prev_tkpt) 
+      }
+    end
+    
+    def put_laps
+      @laps.each { | lap | puts lap.to_s }      
+    end
+  
+    private 
+  
+    def compute_distance_and_pace
+      cumulative_dist = 0.to_f;
+      curr_index = -1
+      prev_tkpt  = nil
+      start_dttm = nil
+      @tkpts.each { | tkpt |
+        curr_index = curr_index + 1
+        if curr_index == 0
+          start_dttm = tkpt.dttm()
+          prev_tkpt  = tkpt
+        else
+          cumulative_dist = tkpt.compute_distance_and_pace(curr_index, start_dttm, cumulative_dist, prev_tkpt)  
+          prev_tkpt = tkpt      
+        end
+      }
+      @distance = cumulative_dist
+    end
+  
+    def compute_splits
+      nextSplitDist = 1.00
+      prev_splitTkpt = nil
+      loop1Count = 0;
+      @tkpts.each { |tkpt|
+        loop1Count = loop1Count + 1
+        if tkpt.cumulative_distance() >= nextSplitDist
+          tkpt.set_split(0 + nextSplitDist, prev_splitTkpt)
+          nextSplitDist = nextSplitDist + 1.00
+          prev_splitTkpt = tkpt
+        end
+      } 
+      # set first and last booleans
+      count = 0
+      @tkpts.each { |tkpt|
+        count = count + 1
+        tkpt.first = true  if count == 1
+        tkpt.last  = true  if count == loop1Count
+      }         
+    end
+    
+    def set_run_ids
+      @tkpts.each { |tkpt|
+        if (@run_id == nil)
+          @run_id = tkpt.dttm.rawdata
+        end
+        tkpt.run_id = @run_id
+      }
+    end
+
+  end
+
+end # end of module