gooby 1.1.0 → 1.2.0

data/lib/gooby_simple_xml_parser.rb

@@ -0,0 +1,50 @@
+=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
+  Sample implementation of a REXML::StreamListener SAX parser.
+  This class isn't actually used in Gooby, but is retained for future use.
+=end 
+
+  class SimpleXmlParser
+   
+    include REXML::StreamListener
+  
+    attr_accessor :tag_count, :watched_tags
+  
+    def initialize
+      @tag_count = 0
+      @counter_hash = CounterHash.new
+    end
+  
+    public
+
+  # SAX API method.  Increments the tagname in the counter hash.  
+    def tag_start(tag_name, attrs)   
+      @tag_count = @tag_count + 1
+      @counter_hash.increment(tag_name)
+    end
+
+  # SAX API method.  No impl.
+    def tag_end(tagname)   
+    end
+  
+  # SAX API method.  No impl.  
+    def text(txt)
+    end
+
+  # Prints the state of this object (the counter hash).
+    def dump   
+      puts @counter_hash.to_s
+    end
+
+  end
+
+end # end of module

data/lib/gooby_test_helper.rb

@@ -0,0 +1,23 @@
+=begin
+
+Gooby = Google APIs + Ruby
+Gooby - Copyright 2007 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+module Gooby
+
+  module TestHelper  
+    
+    def setup
+      puts "test: #{name}"
+    end
+    
+    def teardown
+      @debug = false
+    end
+
+  end
+
+end # end of module

data/lib/gooby_track.rb

@@ -0,0 +1,47 @@
+=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 <Track> aggregate object from a Forerunner
+  XML file.  Note that a <Run> may contain more than one <Track> aggregates.
+=end
+  
+  class Track < GoobyObject
+  
+    attr_reader :number, :descr, :trackpoints
+  
+    def initialize(num=0, descr='')
+      @number = num      
+      @descr  = descr
+      @trackpoints = Array.new      
+    end
+  
+    public
+  
+    def add_trackpoint(tkpt)
+      @trackpoints.push(tkpt)   
+    end
+  
+    def size
+      @trackpoints.size
+    end
+      
+    def to_s
+      return "Trk: #{@descr} tkpts: #{size}"
+    end
+    
+    def dump
+      puts "Track: '#{@descr}'  tkpts: #{size}"
+      @trackpoints.each { |tkpt| puts tkpt.to_csv } 
+    end
+    
+  end 
+  
+end # end of module

data/lib/gooby_track_point.rb

@@ -0,0 +1,229 @@
+=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 Trackpoint < Point
+    
+    attr_accessor  :first, :last, :number, :run_number, :dttm, :prev_tkpt, :lap_number, :lap_seq, :lap_distance, :lap_elapsed
+    attr_accessor  :cumulative_distance, :cumulative_pace, :incremental_distance, :split, :prev_split
+    attr_accessor  :first, :last, :run_id, :run_number
+    attr_accessor  :run_start_dttm 
+  
+    def initialize(num, lat, lng, alt, hb, time_string, uom, auxInfoHash=Hash.new(''))
+      @number       = num
+      @run_number   = 0
+      @auxInfoHash  = auxInfoHash
+      @lap_seq      = 1
+      @lap_distance = 0
+      lap_num = @auxInfoHash['lap_number']
+      if (lap_num && lap_num.size > 0)
+        @lap_number = lap_num.to_i
+      else
+        @lap_number = 0
+      end
+      # initialize superclass variables:
+      @latitude  = lat.to_s
+      @longitude = lng.to_s
+      @altitude  = alt.to_f
+      @uom       = uom       
+      @altitude  = @altitude * 3.2736  if (@uom == 'm')
+      @heartbeat = hb.to_s
+      if ((@heartbeat == nil) || (@heartbeat == ''))
+        @heartbeat = -1
+      end
+      @note      = note.to_s
+      @dttm      = DtTm.new(time_string)
+      @first     = false
+      @last      = false
+      @prev_tkpt = nil      
+      @cumulative_distance, @incremental_distance, @split = 0.0, 0.0, 0.0
+      @cumulative_pace = ""
+    end
+  
+    public
+
+    def point
+      Point.new(@latitude, @longitude, @altitude, @note)
+    end
+      
+    def position
+      Point.new(@latitude, @longitude, @altitude, @note)
+    end
+    
+    def to_s
+      "Tkpt: #{@number} #{super.to_s} date: #{@dttm.to_s} cdist: #{@cumulative_distance}"
+    end
+  
+    def to_csv(prev_tkpt=nil)    
+      first_lap_start_time_s = @auxInfoHash['first_lap_start_time']
+      curr_lap_start_time_s  = @auxInfoHash['curr_lap_start_time']
+      lap_elapsed   = ''
+      total_elapsed = ''
+      
+      if (first_lap_start_time_s && (first_lap_start_time_s.size > 0) && 
+          curr_lap_start_time_s  && (curr_lap_start_time_s.size > 0)) # garmin205 & 305
+        first_lap_start_time = DtTm.new(first_lap_start_time_s)
+        first_lap_start_time = @run_start_dttm
+        curr_lap_start_time  = DtTm.new(curr_lap_start_time_s)
+        lap_elapsed   = @dttm.hhmmss_diff(curr_lap_start_time) 
+        total_elapsed = @dttm.hhmmss_diff(first_lap_start_time)
+      else # garmin 201
+        total_elapsed = @dttm.hhmmss_diff(@run_start_dttm)
+        lap_elapsed   = total_elapsed
+      end
+
+      delim = csv_delim
+      csv =  "#{@run_id}.#{@number}" # <-- primary key
+      csv << "#{delim}#{@run_id}"      
+      csv << "#{delim}#{@dttm.yyyy_mm_dd_hh_mm_ss('|')}"
+      csv << "#{delim}#{@number}"
+      csv << "#{delim}#{position.to_csv}"
+      csv << "#{delim}#{@heartbeat}"      
+      csv << "#{delim}#{@cumulative_distance}"
+      csv << "#{delim}#{uom}"      
+      csv << "#{delim}#{total_elapsed}"
+      csv << "#{delim}#{@lap_seq}"
+      csv << "#{delim}#{@lap_distance}"
+      csv << "#{delim}#{lap_elapsed}"
+      csv
+    end
+    
+    def self.csv_header
+      "#cols: primary_key|run_id|date|time|tkpt_num|latitude|longitude|altitude|heartbeat|run_distance|uom|run_elapsed|lap_tkpt_number|lap_distance|lap_elapsed"
+    end
+    
+    def to_geo_s
+      ss = position.to_csv
+      "Tkpt: #{@number} | #{ss} | #{@descr}"
+    end
+    
+    def compute_distance_and_pace(curr_index, start_dttm, prev_cumulative_dist, prev_trackpoint)
+      @prev_tkpt = prev_trackpoint
+      @cumulative_distance = prev_cumulative_dist.to_f
+      @run_start_dttm = start_dttm
+        
+      if @prev_tkpt
+        @incremental_distance = proximity(@prev_tkpt, @uom)         
+        if (!@incremental_distance.nan?)
+          @cumulative_distance =  @cumulative_distance + @incremental_distance.to_f
+          if (@lap_number == prev_trackpoint.lap_number)
+            @lap_seq      = prev_trackpoint.lap_seq + 1                  
+            @lap_distance = prev_trackpoint.lap_distance + @incremental_distance
+          else
+            @lap_seq = 1
+            @lap_distance = @incremental_distance
+          end
+        end
+        compute_cumulative_pace(start_dttm)
+        @cumulative_distance
+      else
+        @lap_seq = 1
+        0  
+      end    
+    end
+  
+    def compute_cumulative_pace(start_dttm)      
+      if @cumulative_distance > 0
+        secsDiff  = @dttm.seconds_diff(start_dttm)
+        secsMile  = ((secsDiff.to_f) / (@cumulative_distance.to_f))
+        minsMile  = (secsMile / 60)
+        wholeMins = minsMile.floor 
+        fractMins = minsMile - (wholeMins.to_f)
+        fractSecs = fractMins * 60
+        secsStr   = fractSecs.to_s
+        tokens    = secsStr.split('.')
+        whole, fract = '', ''
+        if tokens.size > 1
+          whole = tokens[0]
+          fract = tokens[1]
+          fract = fract[0,3] if fract.size > 3
+          if (whole.to_f < 10)
+            secsStr = "0#{whole}.#{fract}"
+          else
+            secsStr = "#{whole}.#{fract}"
+          end  
+        end 
+        #s1 = " | #{secsDiff} #{secsMile} #{minsMile} #{wholeMins} #{fractMins} #{fractSecs} #{whole} #{fract} #{@cumulative_distance} "
+        s2 = sprintf("%d:%5s", minsMile, secsStr)
+        @cumulative_pace = "#{s2} per #{@uom}"
+      else 
+        @cumulative_pace = ""
+      end
+    end
+  
+    def set_split(n, tkpt)
+      @split, @prev_split = n, tkpt
+    end
+  
+    def is_split()
+     (@split >= 1)
+    end
+  
+    def split_info(dtTm) 
+      if is_split
+        hhmmss = ''
+        if @prev_split
+          return "#{@split} #{@dttm.hhmmss_diff(@prev_split.dttm())}"
+        else
+          return "#{@split} #{@dttm.hhmmss_diff(dtTm)}"
+        end
+      else
+          ""
+      end
+    end
+
+    public 
+    
+    def as_glatlng(comment_out, gen_comments, tkpt_count, curr_idx, start_dttm)
+      comment_out ? comment = '// ' : comment = ''
+      if gen_comments
+        secs_diff = @dttm.seconds_diff(start_dttm)
+        fmt_time  = @dttm.hhmmss_diff(start_dttm)
+          "\n            #{comment}points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); " +
+            "// (#{curr_idx + 1} of #{tkpt_count}) #{@dttm.to_s} #{secs_diff} #{fmt_time} #{@cumulative_distance} #{split_info(start_dttm)} #{project_embedded_comment} "
+      else
+          "\n            #{comment}points.push(new GLatLng(#{latitude_as_float},#{longitude_as_float})); // #{project_embedded_comment} "  
+      end      
+    end
+  
+    def as_info_window_html(checkpoint, start_dttm)
+      s = "\"<table align='left'>"
+      if checkpoint
+        secs_diff = @dttm.seconds_diff(start_dttm)
+        fmt_time  = @dttm.hhmmss_diff(start_dttm)
+                
+        if checkpoint == 'Start'
+          s << "<tr><td colspan='2'><b>Start!</b></td></tr>"
+        elsif checkpoint == 'Finish'
+          s << "<tr><td colspan='2'><b>Finish!</b></td></tr>"
+        else
+          if (@uom == 'km')
+            s << "<tr><td colspan='2'><b>Kilometer #{checkpoint}</b></td></tr>"
+          else
+            s << "<tr><td colspan='2'><b>Mile #{checkpoint}</b></td></tr>"
+          end
+        end
+        s << "<tr><td>Distance:</td><td>#{@cumulative_distance} #{@uom}</td></tr>"
+        s << "<tr><td>Time of Day:</td><td>#{@dttm.to_s}</td></tr>" 
+        s << "<tr><td>Elapsed Time:</td><td>#{fmt_time}</td></tr>"  
+        s << "<tr><td>Average Pace:</td><td>#{@cumulative_pace}</td></tr>"      
+        s << "<tr><td>Lat/Lng:</td><td>#{latitude_as_float} , #{longitude_as_float}</td></tr>" 
+        s << "<tr><td>Altitude:</td><td>#{altitude_as_float}</td></tr>"
+        if (@heartbeat && (@heartbeat.size > 1) && (@heartbeat.to_i > 0))
+          s << "<tr><td>Heartbeat:</td><td>#{@heartbeat}</td></tr>"
+        end
+        s
+      end
+      s << "</table>\""
+      s
+    end
+    
+  end  
+
+end # end of module

data/lib/gooby_training_center_xml_parser.rb

@@ -0,0 +1,224 @@
+=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 are used to parse a Garmin TrainingCenter XML(TCX) file
+  in a SAX-like manner.  Instances of the model classes - History, Run, Track,
+  Trackpoint, etc. are created in this parsing process.  
+
+  See http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd for the XML
+  Schema Definition for Garmin TrainingCenter XML.  
+=end
+  
+  class TrainingCenterXmlParser  
+  
+    DETAIL_TAGS = %w( Notes StartTime Duration Length Time
+                      TotalTimeSeconds DistanceMeters   
+                      LatitudeDegrees LongitudeDegrees AltitudeMeters HeartRateBpm Value BeginPosition EndPosition )
+  
+    include REXML::StreamListener
+  
+    attr_reader :uom, :history, :cvHash, :tagCount
+  
+    def initialize(uom)
+      @uom                   = uom
+      @cv_hash               = Hash.new("")
+      @tag_count             = 0
+      @run_count             = 0
+      @lap_count             = 0
+      @track_count           = 0
+      @trackpoint_count      = 0
+      @curr_text             = "";
+      @history               = History.new
+      @curr_run              = nil
+      @curr_lap              = nil
+      @curr_track            = nil
+      @curr_begin_position   = nil
+      @@curr_end_position    = nil
+      @first_lap_start_time  = nil
+      @curr_lap_start_time   = ''
+      @in_heart_rate_bpm     = false
+      @in_value              = false      
+    end
+  
+    public
+ 
+    # SAX API method; handles 'Activity', 'Lap', 'Track', 'HeartRateBpm'. 
+    def tag_start(tagname, attrs) 
+      @tag_count += 1
+      @currTag = tagname
+      @cv_hash[tagname] = ''
+    
+      if detail_tag?(tagname)
+        @inDetail = true
+      end
+    
+      if is_tag?('Activity', tagname)
+        @run_count = @run_count + 1
+        @lap_count = 0
+        @track_count = 0
+        @trackpoint_count = 0
+        @curr_run  = Run.new(@run_count)
+        @history.add_run(@curr_run)
+        @cv_hash['Notes'] = ''
+        return
+      end
+    
+      if is_tag?('Lap', tagname)
+        @lap_count =  @lap_count + 1
+        @curr_lap  = Lap.new(@lap_count)
+        
+        attrs.each { |attr|
+          name = attr[0]
+          val  = attr[1]
+          if (name && (name == 'StartTime')) 
+            if (@first_lap_start_time == nil)
+              @first_lap_start_time = "#{val}"
+            end
+            @curr_lap_start_time = "#{val}" 
+          end
+        }
+        return
+      end
+    
+      if is_tag?('Track', tagname)
+        @track_count = @track_count + 1      
+        @curr_track  = Track.new(@track_count)
+        return   
+      end
+
+      if is_tag?('HeartRateBpm', tagname)
+        @in_heart_rate_bpm = true
+        return   
+      end
+
+    end
+
+    # SAX API method; handles 'Position', 'Trackpoint', 'Track', 'Lap', 'Run', 'HeartRateBpm', 'Value'.
+    def tag_end(tagname) 
+      if @inDetail 
+        if is_tag?('Value',  tagname) && @in_heart_rate_bpm
+          @cv_hash['HeartRateBpm'] = "#{@curr_text.strip!}" 
+        else
+          @cv_hash[tagname] = @curr_text          
+        end           
+      else
+        if is_tag?('Position', tagname)
+          lat  = @cv_hash['LatitudeDegrees']
+          long = @cv_hash['LongitudeDegrees']
+          @curr_begin_position = Point.new(lat.strip, long.strip)
+          @@curr_end_position  = Point.new(lat.strip, long.strip)       
+        end 
+        
+        if is_tag?('BeginPosition', tagname)
+          lat  = @cv_hash['LatitudeDegrees']
+          long = @cv_hash['LongitudeDegrees']
+          @curr_begin_position = Point.new(lat.strip, long.strip)      
+        end
+        
+        if is_tag?('EndPosition', tagname)
+          lat  = @cv_hash['LatitudeDegrees']
+          long = @cv_hash['LongitudeDegrees']
+          @@curr_end_position = Point.new(lat.strip, long.strip)      
+        end
+              
+        if is_tag?('Trackpoint', tagname)
+          @trackpoint_count = @trackpoint_count + 1
+          lat  = @cv_hash['LatitudeDegrees']
+          long = @cv_hash['LongitudeDegrees']
+          alt  = @cv_hash['AltitudeMeters'] 
+          hb   = @cv_hash['HeartRateBpm'] 
+          hb ? hb = hb.to_s : hb = '-1'
+          time = @cv_hash['Time'] 
+          hash = Hash.new('')
+          hash['lap_number']           = "#{@lap_count}"          
+          hash['first_lap_start_time'] = "#{@first_lap_start_time}"
+          hash['curr_lap_start_time']  = "#{@curr_lap_start_time}"                           
+          tp = Trackpoint.new(@trackpoint_count, lat, long, alt, hb, time, @uom, hash)
+          @curr_track.add_trackpoint(tp) if tp.has_coordinates?
+          
+          @cv_hash['LatitudeDegrees']  = ''
+          @cv_hash['LongitudeDegrees'] = ''
+          @cv_hash['AltitudeMeters']   = ''
+          @cv_hash['HeartRateBpm']     = ''
+          @cv_hash['Time']             = ''
+        end
+      
+        if is_tag?('Track', tagname)
+          if @curr_run != nil
+            @curr_run.add_track(@curr_track)
+          end
+        end
+      
+        if is_tag?('Lap', tagname)      
+          @curr_run.add_lap(@curr_lap)
+        end
+      
+        if is_tag?('Activity', tagname)
+          @curr_run.notes =  @cv_hash['Notes'] 
+        end
+        
+        if is_tag?('HeartRateBpm', tagname)
+          @in_heart_rate_bpm = false
+          return   
+        end
+
+      end
+    
+      @inDetail = false    
+      @curr_text = ""
+      @currTag  = ""                     
+    end
+
+    # SAX API method.
+    def text(txt)  
+      if @inDetail
+        @curr_text = @curr_text + txt
+      end
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def gdump()      
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with to_s.
+    def dump()        
+      @history.runs().each { |run| puts run.to_s } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_csv.
+    def put_run_csv() 
+      @history.runs().each { |run| run.put_csv() } 
+    end
+
+  # Iterate all parsed Run objects and print each with put_tkpt_csv.
+    def put_all_run_tkpt_csv() 
+      @history.runs.each { |run| run.put_tkpt_csv() } 
+    end
+
+    private 
+  
+    def is_tag?(tagname, value)
+      tagname == value
+    end
+  
+    def detail_tag?(tagname)
+      DETAIL_TAGS.each { |typ| 
+        if typ == tagname 
+          return true    
+        end
+      }
+      return false
+    end
+    
+  end
+
+end # end of module