gooby 1.2.0 → 2.0.0

data/lib/gooby_sax_path_parser.rb

@@ -0,0 +1,43 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+---
+
+This class is used to explore the structure of large xml files which are
+too large and deep to visually comprehend, such Garmin xml/tcx files.
+
+=end
+
+class GoobySaxPathParser < GoobyBaseSaxParser
+ 
+  attr_reader :counter
+      
+  def subclass_initialize
+    @tags, @mappings, @counter = [], {}, GoobyCounterHash.new
+  end  
+  
+  def on_start_element(name, attributes, prefix=nil, uri=nil, namespaces=nil)
+    @tags.push(name) 
+    @counter.increment('on_start_element')
+    @counter.increment(current_path)
+    attributes.keys.each { | key | @counter.increment("#{current_path}@#{key}") }
+  end
+  
+  def on_end_element(name, prefix=nil, uri=nil)        
+    @tags.pop   
+  end 
+  
+  def current_path
+    @tags.join('|')
+  end
+  
+  def display_structure
+    @counter.sorted_keys.each { | key | 
+      count = @counter.value(key)
+      puts sprintf("%-9d %-100s", count, key)
+    }
+  end
+  
+end

data/lib/gooby_tcx_extractor.rb

@@ -0,0 +1,71 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+class GoobyTcxExtractor < GoobyBaseObject
+  
+  attr_reader :file, :out_dir, :lines, :files_written, :files_extracted_info
+  
+  def extract(file, out_dir)
+    @file, @out_dir, @files_written, @files_extracted_info = file, out_dir, 0, {}
+    
+    puts "GoobyTcxExtractor - file: #{@file}  out_dir: #{@out_dir}"
+    @lines = read_file_as_lines(@file)
+    puts "file has been read; line count: #{lines_read}"
+    current_activity_start_index, current_activity_lines, current_id = 0, [], ''
+
+    @lines.each_with_index { | line, index |
+      if line.match('<Activity')
+        current_activity_start_index = index
+        current_activity_lines, current_id = [], ''
+        current_activity_lines << xml_prolog_line
+        current_activity_lines << root_xml_tag
+        current_activity_lines << '  <Activities>'         
+        current_activity_lines << '  <!-- comment placeholder -->'
+      end
+      current_activity_lines << line.rstrip
+      if line.match('<Id') && (index == (current_activity_start_index + 1))
+        current_id = scrub_id(line.strip)
+      end
+      if line.match('</Activity')
+        current_activity_lines << '  </Activities>' 
+        current_activity_lines << '</TrainingCenterDatabase>'
+        write_activity_file(current_activity_lines, current_id, current_activity_start_index)
+        current_activity_lines = []
+        ObjectSpace.garbage_collect
+      end 
+    }
+    puts "files written: #{@files_written}"
+  end
+  
+  def lines_read
+    @lines.size
+  end
+  
+  private
+  
+  def write_activity_file(lines, id, start_idx)
+    filename = "#{@out_dir}/#{id}_tcx.xml"
+    lines[3] = "  <!-- Activity Id: #{id}  Extracted by Gooby on #{Time.now} from Garmin tcx file #{@file} -->"
+    write_lines(filename, lines)
+    @files_written = @files_written + 1
+    @files_extracted_info[filename] = "lines: #{lines.size} start_idx: #{start_idx}"
+    puts sprintf("file written: %-50s  lines: %-7d  start_index: %d", filename, lines.size, start_idx) 
+  end
+  
+  def scrub_id(id)
+    id.tr('-:TZ<>','___   ').strip.split[1].strip # 2007-03-03T15:58:57Z
+  end
+  
+  def xml_prolog_line
+    '<?xml version="1.0" encoding="UTF-8" standalone="no" ?>'
+  end
+  
+  def root_xml_tag
+    '<TrainingCenterDatabase xmlns="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2 http://www.garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd">'
+  end
+  
+end

data/lib/gooby_track_log_parser.rb

@@ -0,0 +1,114 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+class GoobyTracksLogParser < GoobyBaseObject
+
+  attr_reader :logs_file, :trackpoints 
+  
+  def parse(logs_file)
+    @logs_file, @trackpoints = logs_file, []
+    @log_lines = IO.readlines(@logs_file, "\r") # funky line ends on this file; not \n
+    puts "#{@log_lines.size} lines read from file #{@logs_file}"
+    parse_trackpoints
+    post_process_trackpoints
+    #  @current_trackpoint = GoobyTrackpoint.new
+  end
+  
+  def parse_trackpoints
+    
+    # The input file looks like the following:
+    # Format: DDD  M/D/Y H:M:S  -5.00 hrs  Datum[116]: WGS 84
+    # ID  Date Time Latitude  Longitude Altitude
+    # L ACTIVE LOG
+    # T 11/16/2008 08:43:06.000 35.21357  -81.29359 262.6
+    # T 11/16/2008 08:44:13.000 35.21363  -81.29353 265.0
+    # T 11/16/2008 08:44:16.000 35.21366  -81.29349 262.6
+    
+    sequence = 0
+    @log_lines.each { | line |
+      tokens = line.split
+      if (tokens.size > 5) && (tokens[0] == 'T')
+        sequence  = sequence + 1
+        mmddccyy  = tokens[1].strip
+        time      = tokens[2].strip
+        latitude  = tokens[3].strip
+        longitude = tokens[4].strip
+        altitude  = tokens[5].strip
+        tkpt = GoobyTrackpoint.new
+        tkpt.set('ActivityId',       '')
+        tkpt.set('LapStartTime',     '')
+        tkpt.set('LapSeq',           '1')
+        tkpt.set('Seq',              sequence)
+        tkpt.set('Time',             reformatDateTime(mmddccyy, time))
+        tkpt.set('ElapsedTime',      '')
+        tkpt.set('LatitudeDegrees',  latitude)
+        tkpt.set('LongitudeDegrees', longitude)
+        tkpt.set('AltitudeMeters',   altitude.to_f / METERS_PER_FOOT)
+        tkpt.set('Distance',         '')
+        tkpt.set('Pace',             '')
+        tkpt.set('MPH',              '')
+        @trackpoints << tkpt                                     
+      end
+    }
+  end
+  
+  def reformatDate(mmddccyy)
+    date_tokens = mmddccyy.split('/')
+    "#{date_tokens[2]}-#{date_tokens[0]}-#{date_tokens[1]}"
+  end
+    
+  # Return a String value in this format: 2007-03-03T15:58:57Z
+  def reformatDateTime(mmddccyy, time)
+    time_tokens = time.split('.')
+    "#{reformatDate(mmddccyy)}T#{time_tokens[0]}Z"
+  end
+  
+  def post_process_trackpoints
+    # Trackpoint,"","","","",2008-11-16T08:43:06Z,"",35.21357,-81.29359,262.6,0.0,"",""
+    # set('ActivityId',       row[1])
+    # set('LapStartTime',     row[2])
+    # set('LapSeq',           row[3])
+    # set('Seq',              row[4])
+    # set('Time',             row[5])
+    # set('ElapsedTime',      row[6])
+    # set('LatitudeDegrees',  row[7])
+    # set('LongitudeDegrees', row[8])
+    # set('AltitudeMeters',   row[9])
+    # set('Distance',         row[10])
+    # set('Pace',             row[11])
+    # set('MPH',              row[12])  
+    
+    cumulative_distance, first_tkpt_dttm, prev_tkpt = 0.0, nil, nil     
+    if @trackpoints.size > 0
+      activity_id = @trackpoints[0].time
+    else
+      return
+    end
+    @trackpoints.each { | tkpt |
+      tkpt.set('ActivityId',   activity_id)
+      tkpt.set('LapStartTime', activity_id)      
+      if prev_tkpt
+        incremental_distance = tkpt.proximity(prev_tkpt)
+        cumulative_distance = cumulative_distance + incremental_distance
+        tkpt.set('Distance', cumulative_distance)
+      else
+        first_tkpt_dttm = tkpt.dttm
+        tkpt.set('Distance', 0.0)
+      end
+      tkpt.compute_elapsed_time(first_tkpt_dttm)
+      tkpt.compute_cumulative_pace_and_mph(first_tkpt_dttm)
+      prev_tkpt = tkpt
+    }       
+  end
+
+  def trackpoints_to_csv
+    lines = []
+    @trackpoints.each { | trackpoint | lines << trackpoint.to_csv }
+    lines
+  end
+  
+end

data/lib/gooby_trackpoint.rb

@@ -0,0 +1,276 @@
+=begin
+
+Gooby = Google APIs + Ruby.  Copyright 2009 by Chris Joakim.
+Gooby is available under GNU General Public License (GPL) license.
+
+=end
+
+class GoobyTrackpoint < GoobyXmlObject
+  
+  def time
+    get('Time')
+  end
+  
+  def dttm
+    GoobyDtTm.new(time)
+  end
+  
+  def latitude
+    get('LatitudeDegrees').to_f
+  end  
+  
+  def longitude
+    get('LongitudeDegrees').to_f
+  end
+  
+  def altitude
+    altitude_meters * METERS_PER_FOOT
+  end  
+  
+  def altitude_rounded
+    sprintf("%5.1f", altitude)
+  end
+    
+  def altitude_meters
+    get('AltitudeMeters').to_f
+  end
+  
+  def dump
+    puts to_csv
+  end
+  
+  def activity_id
+    get('ActivityId')
+  end  
+  
+  def lap_seq
+    get('LapSeq')
+  end
+  
+  def lap_start_time
+    get('LapStartTime')
+  end
+  
+  def distance
+    get('Distance').to_f
+  end  
+  
+  def distance_rounded
+    sprintf("%3.3f", distance)
+  end
+
+  def pace
+    get('Pace')
+  end
+  
+  def mph
+    get('MPH')
+  end 
+  
+  def elapsed_time
+    get('ElapsedTime')
+  end     
+  
+  def degrees_diff(another_tkpt)
+    if another_tkpt
+      lat_diff = latitude  - another_tkpt.latitude
+      lng_diff = longitude - another_tkpt.longitude
+      lat_diff.abs + lng_diff.abs
+    else
+      360
+    end
+  end
+  
+  def same_location?(another_tkpt)
+    if another_tkpt
+      return false if latitude  != another_tkpt.latitude
+      return false if longitude != another_tkpt.longitude
+      true
+    else
+      false
+    end
+  end
+  
+  def proximity(another_tkpt, uom='m')
+    if same_location?(another_tkpt)
+      return 0.0
+    end
+    if another_tkpt
+      arg1  = latitude
+      arg2  = another_tkpt.latitude
+      arg3  = latitude
+      arg4  = another_tkpt.latitude
+      theta = longitude - another_tkpt.longitude
+      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
+      # puts "proximity #{another_tkpt.sequence} a1: #{arg1} a2: #{arg2} a3: #{arg3} a4: #{arg4} t: #{theta} r1: #{res1} r2: #{res2} r3: #{res3} r4: #{res4} r5: #{res5} #{dist}"
+      if !dist.nan?
+        dist = Math.acos(dist.to_f)
+        if (!dist.nan?)    
+          dist = rad2deg(dist)
+          if !dist.nan?
+            dist = dist * 60.0 * 1.1515;
+            if !dist.nan?
+              if uom == "km"
+                 dist = dist * 1.609344;
+              elsif uom == "n"
+                 dist = dist * 0.8684;
+              end  
+            end
+          end
+        end
+        return dist.to_f
+      else
+        return 0.0
+      end
+    else
+      return 0.0
+    end
+  end  
+
+  def deg2rad(degrees)
+    (((0.0 + degrees.to_f) * Math::PI) / 180.0)
+  end
+
+  def rad2deg(radians)
+    (((0.0 + radians.to_f) * 180.0) / Math::PI)
+  end
+
+  def compute_elapsed_time(first_tkpt_dttm)
+    set('ElapsedTime', dttm.hhmmss_diff(first_tkpt_dttm))
+  end
+  
+  def compute_cumulative_pace_and_mph(first_tkpt_dttm)
+    if distance > 0.0
+      secs_diff  = dttm.seconds_diff(first_tkpt_dttm)
+      secs_mile  = ((secs_diff.to_f) / distance)
+      mins_mile  = (secs_mile / 60.0)
+      whole_mins = mins_mile.floor 
+      fract_mins = mins_mile - (whole_mins.to_f)
+      fract_secs = fract_mins * 60.0
+      if fract_secs < 10
+        pace = sprintf("%d:0%2.2f", whole_mins, fract_secs)
+      else
+        pace = sprintf("%d:%2.2f", whole_mins, fract_secs)
+      end
+      set('Pace', pace)  
+      hours = secs_diff / 3600.0
+      mph   = sprintf("%5.3f", distance / hours) 
+      set('MPH', sprintf("%5.3f", mph))        
+    else 
+      set('Pace', '0:00')
+      set('MPH',  '0.00')
+    end
+  end
+
+  def from_csv(row)
+    if row && row.size > 12
+      set('ActivityId',       row[1])
+      set('LapStartTime',     row[2])
+      set('LapSeq',           row[3])
+      set('Seq',              row[4])
+      set('Time',             row[5])
+      set('ElapsedTime',      row[6])
+      set('LatitudeDegrees',  row[7])
+      set('LongitudeDegrees', row[8])
+      set('AltitudeMeters',   row[9])
+      set('Distance',         row[10])
+      set('Pace',             row[11])
+      set('MPH',              row[12])
+    end
+  end
+  
+  def to_csv
+    csv_string = FasterCSV.generate do | csv |
+      csv << ['Trackpoint', activity_id, lap_start_time, lap_seq, sequence, time, elapsed_time, latitude, longitude, altitude, distance, pace, mph ]
+    end  
+    csv_string.strip
+  end
+  
+  def as_glatlng(comment_out, gen_comments, tkpt_count, curr_idx, start_dttm)
+    comment_out ? comment = '// ' : comment = ''    
+    "\n            #{comment}points.push(new GLatLng(#{latitude},#{longitude})); "
+  end
+  
+  def split_info(a_dttm) 
+    # if split?
+    #   hhmmss = ''
+    #   if @prev_split
+    #     return "#{@split} #{dttm.hhmmss_diff(@prev_split.dttm())}"
+    #   else
+    #     return "#{@split} #{dttm.hhmmss_diff(a_dttm)}"
+    #   end
+    # else
+    #   ""
+    # end
+    ''
+  end
+  
+  def split?
+    false
+  end
+  
+  def as_one_point_info_window_html(label=nil)
+    td_style="style='padding-left:12px;padding-right:1px;'"    
+    s = "\"<table align='left'>"
+    s << "<tr><td colspan='2'><b>#{label}</b></td></tr>" if label
+    if GoobyBaseObject.boolean_config_value('gmap_info_window_latutude')
+      s << "<tr><td>Latitude:  </td><td #{td_style}>#{latitude}</td></tr>"
+    end
+    if GoobyBaseObject.boolean_config_value('gmap_info_window_longitude')
+      s << "<tr><td>Longitude: </td><td #{td_style}>#{longitude}</td></tr>"
+    end    
+    s << "</table>\""
+    s
+  end
+  
+  def as_quoted_info_window_html(checkpoint, start_dttm)
+    "\"#{as_info_window_html(checkpoint, start_dttm)}\""
+  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)
+      td_style="style='padding-left:12px;padding-right:1px;'"
+      if checkpoint.to_i == 0
+        s << "<tr><td colspan='2'><b>Start!</b></td></tr>"
+      elsif checkpoint.to_i == 999999
+        s << "<tr><td colspan='2'><b>Finish!</b></td></tr>"
+      else
+        s << "<tr><td colspan='2'><b>Mile #{checkpoint}</b></td></tr>"
+      end
+      
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_distance')
+        s << "<tr><td>Distance:     </td><td #{td_style}>#{distance_rounded}</td></tr>"
+      end
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_elapsed_time')
+        s << "<tr><td>Elapsed Time: </td><td #{td_style}>#{elapsed_time}</td></tr>"
+      end
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_average_pace')
+        s << "<tr><td>Average Pace: </td><td #{td_style}>#{pace}</td></tr>"
+      end
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_average_mph')
+        s << "<tr><td>Average MPH: </td><td #{td_style}>#{mph}</td></tr>"
+      end      
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_latutude')
+        s << "<tr><td>Latitude:     </td><td #{td_style}>#{latitude}</td></tr>"
+      end
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_longitude')
+        s << "<tr><td>Longitude:    </td><td #{td_style}>#{longitude}</td></tr>"
+      end
+      if GoobyBaseObject.boolean_config_value('gmap_info_window_altitude')
+        s << "<tr><td>Altitude:     </td><td #{td_style}>#{altitude_rounded}</td></tr>"
+      end
+      s
+    end
+    s << "</table>"
+    s
+  end 
+  
+end