hrmparser 0.6.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+

data/CHANGELOG.txt

@@ -0,0 +1,35 @@
+0.6.0 - August 15, 2009
+	Add support for Timex
+	
+0.5.0 - July 25, 2009
+	Handle stop time in GPX
+
+0.4.9 - June 10, 2009
+	Support TCX with only LAT and LNG
+
+0.4.8 - May 23, 2009
+	Fixed importing when TCX LAP duration are totally completely incredibly insanely wrong
+	
+0.4.6 - May 11th, 2009
+	Added support for Suunto full variables including speed, distance, etc.
+	
+0.4.4 - May 10th, 2009
+	Fixed time-zone offset in parsing suunto data.
+	
+0.4.2 - May 9th, 2009
+	Fixed GPX to grab time from first trackpoint.
+
+0.4.1 - May 9th, 2009
+	Added GPX support.  
+	NOTE: all workouts do NOT account for stopped time.  
+		duration is simply last time - first time.  Will be fixed in future version.
+		
+0.4.0 - May 8th, 2009
+	Added initial support for Suunto T6.  Just grabs HRs for now.
+
+0.3.1 - May 6th, 2009
+	Handles missing data in a trackpoint now, including no lat and lng.
+	
+0.2.3
+	Now should keep lat and lng set to nil when they don't exist in garmin files.
+	

data/README.rdoc

@@ -0,0 +1,42 @@
+= hrmparser
+
+* http://github.com/teich/hrmparser/tree/master
+
+== DESCRIPTION:
+
+A ruby parser for polar and garmin hrm
+
+== FEATURES/PROBLEMS:
+
+* Imports garmin 405.  Generates a workout object with some averages calculated.
+* Not the fastest right now.  
+* Very very early.  
+
+== REQUIREMENTS:
+
+* hpricot
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Oren Teich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+
+#%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+#require File.dirname(__FILE__) + '/lib/hrmparser'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+# $hoe = Hoe.new('teich-hrmparser', HRMParser::VERSION::STRING) do |p|
+#   p.developer('Oren Teich', 'oren@teich.net')
+#   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+#   p.rubyforge_name       = p.name # TODO this is default value
+#   # p.extra_deps         = [
+#   #   ['activesupport','>= 2.0.2'],
+#   # ]
+#   p.extra_dev_deps = [
+#     ['newgem', ">= #{::Newgem::VERSION}"]
+#   ]
+#   
+#   p.clean_globs |= %w[**/.DS_Store tmp *.log]
+#   path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+#   p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+#   p.rsync_args = '-av --delete --ignore-errors'
+# end
+# 
+# require 'newgem/tasks' # load /tasks/*.rake
+# Dir['tasks/**/*.rake'].each { |t| load t }
+# 
+# # TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "hrmparser"
+    gemspec.summary = "Heart Rate Monitor Parser"
+    gemspec.email = "oren@teich.net"
+    gemspec.homepage = "http://github.com/teich/hrmparser"
+    gemspec.description = "Parses Polar and Garmin HRM files."
+    gemspec.authors = ["Oren Teich"]
+    
+    gemspec.files.exclude 'spec/samples/**/*'
+    gemspec.test_files.exclude 'spec/samples/**/*'
+    
+  end
+  Jeweler::GemcutterTasks.new  
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+# Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }  
+
+# require 'spec/rake/spectask'
+# Spec::Rake::SpecTask.new(:spec) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.spec_files = FileList['spec/**/*_spec.rb']
+# end
+# 
+# Spec::Rake::SpecTask.new(:rcov) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.pattern = 'spec/**/*_spec.rb'
+#   spec.rcov = true
+# end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 6

data/hrmparser.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hrmparser}
+  s.version = "0.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Oren Teich"]
+  s.date = %q{2009-12-13}
+  s.description = %q{Parses Polar and Garmin HRM files.}
+  s.email = %q{oren@teich.net}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "CHANGELOG.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "hrmparser.gemspec",
+     "lib/hrmparser.rb",
+     "lib/hrmparser/arraymath.rb",
+     "lib/hrmparser/importer.rb",
+     "lib/hrmparser/importer/garmin.rb",
+     "lib/hrmparser/importer/gpx.rb",
+     "lib/hrmparser/importer/polar.rb",
+     "lib/hrmparser/importer/suunto.rb",
+     "lib/hrmparser/importer/timex.rb",
+     "lib/hrmparser/trackpoint.rb",
+     "lib/hrmparser/workout.rb",
+     "spec/arraymath_spec.rb",
+     "spec/hrmparser_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/teich/hrmparser}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Heart Rate Monitor Parser}
+  s.test_files = [
+    "spec/arraymath_spec.rb",
+     "spec/hrmparser_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/hrmparser/arraymath.rb

@@ -0,0 +1,25 @@
+require 'enumerator'
+
+# Set of basic array math functions.  
+module ArrayMath
+
+	def aaverage
+		accum = self.asum
+		return nil if accum.nil? || self.size == 0
+		accum.to_f / self.size
+	end
+
+	def asum
+		self.map {|i| return nil if i.is_a?(String)}
+		inject(0){ |sum,item| sum + item }
+	end
+
+	## Retun array FACTOR smaller.  Average values to get smaller
+	def smoothed(factor)
+		self.enum_for(:each_slice, factor).map { |snipit| snipit.compact.aaverage }
+	end  
+end
+
+class Array
+	include ArrayMath
+end

data/lib/hrmparser/importer/garmin.rb

@@ -0,0 +1,89 @@
+module Importer
+	class Garmin
+		def initialize(opts = {:data => nil})
+			@data = opts[:data]
+		end
+
+		def restore
+			workout = HRMParser::Workout.new(:duration => 0)
+			#data = Importer.read_in_file(@file_name)
+
+			@xml = Hpricot::XML(@data)
+			workout.time = Time.parse((@xml/:Id).innerHTML)
+
+      # Grab the duration from the lap.  This _can_ be totally, completly wrong - AKA 10 years long.
+      # So if we have trackpoints, we'll replace it down lower
+      (@xml/:Lap).each do |lap|
+        f_time =  (lap/:TotalTimeSeconds).innerHTML
+        workout.duration += Float f_time
+      end
+
+			found = false
+			trackpoints = Array.new
+			distance_one = nil
+			time_one = nil
+
+      totaldistance = 0
+      
+			(@xml/:Trackpoint).each do |t| 
+				found = true
+				trackpoint = HRMParser::TrackPoint.new
+
+				trackpoint.time = Time.parse((t/:Time).innerHTML)
+
+				hr = (t/:HeartRateBpm/:Value).innerHTML
+				alt = (t/:AltitudeMeters).innerHTML
+				dis = (t/:DistanceMeters).innerHTML
+
+				trackpoint.hr =       hr != "" ? hr.to_i : nil
+				trackpoint.altitude = alt != "" ? alt.to_f : nil
+				trackpoint.distance = dis != "" ? dis.to_f : nil
+
+				(t/:Position).each do |p|
+					trackpoint.lat = (p/:LatitudeDegrees).innerHTML.to_f
+					trackpoint.lng = (p/:LongitudeDegrees).innerHTML.to_f
+				end
+
+        if trackpoint.distance.nil? && !trackpoint.lat.nil?
+          totaldistance += trackpoint.calc_distance(trackpoints.last, trackpoint)
+				  trackpoint.distance = totaldistance
+        end
+        trackpoint.speed = trackpoint.calc_speed(trackpoints.last, trackpoint)
+        
+        trackpoints << trackpoint
+
+
+				## CALCULATE SPEED.  ICK.
+			  # if distance_one.nil?
+			 #         distance_one = trackpoint.distance
+			 #         time_one = trackpoint.time
+			 #       else
+			 #         distance_two = trackpoint.distance
+			 #         next if distance_two.nil?
+			 #         time_two = trackpoint.time
+			 #         time_delta = time_two - time_one
+			 #         distance_delta = distance_two - distance_one
+			 #         if (distance_delta > 0 && time_delta > 0)
+			 #           trackpoint.speed = distance_delta / time_delta  
+			 #           distance_one = distance_two
+			 #           time_one = time_two
+			 #         else 
+			 #           trackpoint.speed = nil
+			 #         end      
+			 #       end
+			end 
+
+			if found
+			  workout.duration = trackpoints.last.time - trackpoints.first.time
+				workout.trackpoints = trackpoints
+				workout.calc_average_speed! 
+				workout.calc_altitude_gain!
+				workout.calc_average_hr!
+				workout.set_distance_from_trackpoints!
+			end
+
+			return workout
+		end
+
+	end
+end

data/lib/hrmparser/importer/gpx.rb

@@ -0,0 +1,51 @@
+module Importer
+	class GPX
+		def initialize(opts = {:data => nil, :time_zone => "UTC"})
+			@data = opts[:data]
+		end
+
+		def restore
+			workout = HRMParser::Workout.new(:duration => 0)
+			@xml = Hpricot::XML(@data)
+
+			# Set the time based on first trackpoint.  Seen an instance where the gpx begining time is wrong
+			ttime = (@xml/:trk/:trkpt/:time).first.innerHTML
+			workout.time = Time.parse(ttime)
+
+			trackpoints = []
+			distance = 0
+			workout.duration = 0
+			last_trackpoint = false
+			(@xml/:trk).each do |trk|
+				(trk/:trkpt).each do |trkpt|
+					trackpoint = HRMParser::TrackPoint.new
+					trackpoint.altitude = (trkpt/:ele).innerHTML.to_f
+					trackpoint.time = Time.parse((trkpt/:time).innerHTML)
+
+					trackpoint.lat = (trkpt.attributes)["lat"].to_f
+					trackpoint.lng = (trkpt.attributes)["lon"].to_f
+
+					distance += trackpoint.calc_distance(trackpoints.last, trackpoint)
+					trackpoint.distance = distance
+
+					trackpoint.speed = trackpoint.calc_speed(trackpoints.last, trackpoint)
+
+					if last_trackpoint && trackpoints.last && trackpoint.speed
+            workout.duration += trackpoint.time - last_trackpoint.time if trackpoint.speed > 0.04
+          end
+					trackpoints << trackpoint
+					last_trackpoint = trackpoint
+
+				end
+			end
+
+      # workout.duration = trackpoints.last.time - trackpoints.first.time
+			workout.trackpoints = trackpoints
+			workout.calc_average_speed! 
+			workout.calc_altitude_gain!
+			workout.distance = trackpoints.last.distance
+			return workout
+		end
+	end
+
+end

data/lib/hrmparser/importer/polar.rb

@@ -0,0 +1,103 @@
+module Importer
+	class Polar
+
+		attr_reader :time_zone
+
+		def initialize(opts = {:data => nil, :time_zone => "UTC"})
+			@data = opts[:data]
+			@time_zone = opts[:time_zone]
+		end      
+
+		def restore
+			workout = HRMParser::Workout.new(:duration => 0)
+
+			params = parse_params
+
+			date = params["Date"] + " " + params["StartTime"] + " " + @time_zone
+
+			length_array = params["Length"].split(/:/)
+			workout.duration = (length_array[0].to_f * 3600) + (length_array[1].to_f * 60) + (length_array[2].to_f)
+			workout.time = Time.parse(date)
+
+			workout.trackpoints = get_trackpoints(workout.time, params["Interval"].to_i)
+
+			workout.calc_average_hr!
+
+			return workout
+		end
+
+
+
+		private
+
+		# def parse_tabbed_blocks
+		#   # This is the list of tabbed blocks
+		#   tabbed_blocks = %w[IntTimes ExtraData Sumary-123 Summary-TH]
+		#   tabbed_blocks.each do |block_name|
+		#     @polarHash[block_name] = []
+		#     block_text = find_block(block_name)
+		#     block_text.each do |block_line|
+		#       @polarHash[block_name] << block_line.split(/\t/)
+		#     end
+		#   end
+		# end
+
+		# Params is the only "ini" style block
+		def parse_params
+			hash = {}
+			param_block = find_block("Params")
+			param_block.each do |param|
+				# /=/ in case that doesn't work
+				key, value = param.split("=", 2)
+				key = key.strip unless key.nil?
+				value = value.strip unless value.nil?
+				hash[key] = value unless key.nil?
+			end
+			return hash
+		end
+
+		# Polar file has [Foo] blocks.  Return the data in the block
+		def find_block(header)
+			found = false
+			block = []
+			@data.each do |line|
+				line.chomp!
+				found = false if line =~ /^\[.*\]$/
+				block << line if found
+				found = true if line =~ /\[#{header}\]/
+			end
+			return block
+		end
+
+		def parse_hrdata
+			hrdata = []
+			block_text = find_block("HRData")
+			block_text.each do |block_line|
+				hrdata << block_line.chomp
+			end
+			return hrdata
+		end
+
+		def get_trackpoints(start_time, interval)
+			trackpoints = []
+			rrcounter = 0
+
+			hrdata = parse_hrdata
+			hrdata.each do |hrd|
+				tp = HRMParser::TrackPoint.new
+
+				if (interval == 238)
+					rrcounter += hrd.to_i
+					tp.hr = 60000 / hrd.to_i
+					tp.time = start_time + (rrcounter/1000)
+				else
+					tp.hr = hrd.to_i
+					tp.time = start_time + (interval * trackpoints.size)
+				end
+
+				trackpoints << tp
+			end
+			return trackpoints
+		end
+	end
+end

data/lib/hrmparser/importer/suunto.rb

@@ -0,0 +1,102 @@
+module Importer
+	class Suunto
+		attr_reader :time_zone
+
+		def initialize(opts = {:data => nil, :time_zone => "UTC"})
+			@data = opts[:data]
+			@time_zone = opts[:time_zone]
+		end
+
+		def restore
+			workout = HRMParser::Workout.new(:duration => 0)
+
+			params = parse_params("HEADER")
+
+			# Using DateTime because 1.8 at leas doesn't have a Time.strptime
+			# And european ordeirng consfuses time.parse
+			# TODO: must be some better way
+			dt = DateTime.strptime(params["STARTTIME"], "%d.%m.%Y %H:%M.%S")
+			time_for_parse = dt.strftime("%b %d %H:%M:%S @time_zone %Y")
+
+			workout.time = Time.parse(time_for_parse)
+			workout.duration = params["DURATION"].to_f
+
+			workout.trackpoints = get_trackpoints
+
+			workout.calc_average_hr!
+			workout.calc_altitude_gain!
+			workout.calc_average_speed! 
+			workout.set_distance_from_trackpoints!
+
+			return workout
+		end
+
+		private 
+
+		def parse_params(string)
+			hash = {}
+			param_block = find_block(string)
+			param_block.each do |param|
+				# /=/ in case that doesn't work
+				key, value = param.split("=", 2)
+				key = key.strip unless key.nil?
+				value = value.strip unless value.nil?
+				hash[key] = value unless key.nil?
+			end
+			return hash
+		end
+
+		def find_block(header)
+			found = false
+			block = []
+			@data.each do |line|
+				line.chomp!
+				found = false if line =~ /^\[.*\]$/
+				block << line if found
+				found = true if line =~ /\[#{header}\]/
+			end
+			return block
+		end
+
+		def parse_data(string)
+			data = []
+			block_text = find_block(string)
+			block_text.each do |block_line|
+				data << block_line.chomp
+			end
+			return data
+		end
+
+		def get_trackpoints
+			trackpoints = []
+			logs = parse_data("POINTS")
+			for line in logs do
+				type, date, time, altitude, blank, blank, hr, epoc, respiration, ventilation, vo2, kcal, blank, blank, distance, speed, cadence, temp = line.split(/,/)
+				next if type == "\"T6LAP\""
+
+				trackpoint = HRMParser::TrackPoint.new
+
+				points_f = %w[epoc kcal speed]
+				points_i = %w[altitude hr respiration ventilation vo2 distance cadence temp]
+
+				points_f.each do |p|
+					value = (eval p).to_f
+					value = nil if value == 0.0
+					trackpoint.send("#{p}=".to_sym, value)
+				end
+				
+				points_i.each do |p| 
+					value = (eval p).to_i
+					value = nil if value == 0
+					trackpoint.send("#{p}=".to_sym, value)
+				end
+				dt = DateTime.strptime(date + " " + time, "%d.%m.%Y %H:%M.%S")
+				time_for_parse = dt.strftime("%b %d %H:%M:%S @time_zone %Y")
+				trackpoint.time = Time.parse(time_for_parse)
+
+				trackpoints << trackpoint
+			end
+			return trackpoints
+		end
+	end
+end

data/lib/hrmparser/importer/timex.rb

@@ -0,0 +1,118 @@
+module Importer
+	class Timex
+		attr_reader :time_zone
+
+		def initialize(opts = {:data => nil, :time_zone => "UTC"})
+			@data = opts[:data]
+			@time_zone = opts[:time_zone]
+		end
+		
+		def restore
+		  workout = HRMParser::Workout.new(:duration => 0)
+		  
+		  params = parse_params("session data")
+		  
+		  dt = DateTime.strptime(params["Sessiondate"], "%d/%m/%Y %H:%M:%S")
+			time_for_parse = dt.strftime("%b %d %H:%M:%S @time_zone %Y")
+
+			workout.time = Time.parse(time_for_parse)
+			workout.duration = params["duration"].to_f
+			
+      workout.trackpoints = get_trackpoints(workout.time)
+
+			workout.calc_average_hr!
+			workout.calc_altitude_gain!
+			workout.calc_average_speed! 
+			workout.set_distance_from_trackpoints!
+			
+			return workout
+		  
+	  end
+	  
+	  
+	  private 
+
+		def parse_params(string)
+			hash = {}
+			param_block = find_block(string)
+			param_block.each do |param|
+				# /=/ in case that doesn't work
+				key, value = param.split("=", 2)
+				key = key.strip unless key.nil?
+				value = value.strip unless value.nil?
+				hash[key] = value unless key.nil?
+			end
+			return hash
+		end
+
+		def find_block(header)
+			found = false
+			block = []
+			@data.each do |line|
+				line.chomp!
+				found = false if line =~ /^\[.*\]$/
+				block << line if found
+				found = true if line =~ /\[#{header}\]/
+			end
+			return block
+		end
+		
+		def parse_data(string)
+			data = []
+			block_text = find_block(string)
+			block_text.each do |block_line|
+				data << block_line.chomp
+			end
+			return data
+		end
+		
+		def get_trackpoints(base_time)
+			trackpoints = []
+			have_gps = false
+			logs = parse_data("recorded")
+      fields = logs[0].split(/,/)
+      have_gps = true if fields.size > 5
+      
+  		for line in logs do
+  		  if have_gps
+		      if line =~ /^".*"/ then line.gsub!(/"(.*?)"/,'\1') end  # remove double-quotes at string beginning & end
+          seconds, hr, speed_imperial, distance_imperial, data_flag, lng, lat, altitude, acqs, trueh, magh = line.split(/,/)
+		    else
+		      seconds, hr, speed_imperial, distance_imperial, data_flag = line.split(/,/)
+	      end
+	      
+	      
+	      ## Convert speed and distance to metric - meters specifically
+	      distance = distance_imperial.to_f * 1609.344
+	      speed = speed_imperial.to_f * 0.44704
+	      
+	      
+				trackpoint = HRMParser::TrackPoint.new
+
+				points_f = %w[speed distance lat lng altitude]
+				points_i = %w[hr]
+
+        
+				points_f.each do |p|
+					value = (eval p).to_f
+					value = nil if value == 0.0
+					trackpoint.send("#{p}=".to_sym, value)
+				end
+				
+				points_i.each do |p| 
+					value = (eval p).to_i
+					value = nil if value == 0
+					trackpoint.send("#{p}=".to_sym, value)
+				end
+				
+				trackpoint.time = base_time + seconds.to_i
+
+				trackpoints << trackpoint
+			end
+			return trackpoints
+		end
+		
+		
+		
+	end
+end

data/lib/hrmparser/importer.rb

@@ -0,0 +1,38 @@
+require 'importer/garmin'
+require 'importer/polar'
+require 'importer/suunto'
+require 'importer/gpx'
+require 'importer/timex'
+
+module Importer
+	def Importer.file_type(name)
+		case name
+		when /\.tcx$/i
+			return "GARMIN_XML" 
+		when /\.hrm$/i
+			return "POLAR_HRM"
+		when /\.sdf$/i
+			return "SUUNTO"
+		when /\.gpx$/i
+			return "GPX"
+		when /\.csv$/i
+		  f = File.new(name)
+		  first_line = f.readline
+		  f.close
+		  if first_line.chomp == "[Timex Trainer Data File]"
+		    return "TIMEX"
+	    else
+	      return "UNKNOWN CSV"
+      end
+		end
+	end
+
+	def Importer.read_in_file(name)
+		if File.readable?(name)
+			return open(name, "r")
+		else 
+			puts "FILE ERROR, can't read #{name}"
+		end
+	end
+end
+

data/lib/hrmparser/trackpoint.rb

@@ -0,0 +1,50 @@
+module HRMParser
+	class TrackPoint
+
+		RAD_PER_DEG = 0.017453293  #  PI/180  
+
+		attr_accessor :lat, :lng, :altitude, :speed, :hr, :distance, :time, :cadence, :temp, :kcal, :epoc, :respiration, :ventilation, :vo2, :cadence
+
+		def initialize(opts = {:lat => nil, :lng => nil, :altitude => nil, :speed => nil, :hr => nil, :distance => nil, :cadence => nil, :time => Time.now})
+			@lat = opts[:lat]
+			@lng = opts[:lng]
+			@altitude = opts[:altitude]
+			@speed = opts[:speed]
+			@hr = opts[:hr]
+			@distance = opts[:distance]
+			@time = opts[:time]
+			@cadence = opts[:cadence]    
+		end
+
+		def calc_distance(pointA, pointB)
+			return 0 if pointA.nil? || pointA.lat.nil? || pointB.nil? || pointB.lat.nil?
+
+			dlng = pointB.lng - pointA.lng  
+			dlat = pointB.lat - pointA.lat  
+
+			dlat_rad = dlat * RAD_PER_DEG  
+			dlng_rad = dlng * RAD_PER_DEG   
+
+			lat1_rad = pointA.lat * RAD_PER_DEG  
+			lng1_rad = pointA.lng * RAD_PER_DEG  
+
+			lat2_rad = pointB.lat * RAD_PER_DEG  
+			lng2_rad = pointB.lng * RAD_PER_DEG
+
+			a = (Math.sin(dlat_rad/2))**2 + Math.cos(lat1_rad) * Math.cos(lat2_rad) * (Math.sin(dlng_rad/2))**2  
+			c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a))
+
+			return 6371000 * c
+		end
+
+		def calc_speed(pointA, pointB)
+			return nil if pointA.nil? || pointA.lat.nil? || pointB.nil? || pointB.lat.nil?
+			time_delta = pointB.time - pointA.time
+			return nil if time_delta == 0
+			distance_delta = pointB.distance - pointA.distance
+			return distance_delta / time_delta
+		end
+	end
+end
+
+

data/lib/hrmparser/workout.rb

@@ -0,0 +1,66 @@
+module HRMParser
+	class Workout
+		attr_accessor :duration, :distance, :time, :name, :file_name, :trackpoints
+		attr_reader :average_hr, :data, :average_speed, :altitude_gain
+
+		def initialize(opts = {:duration => nil, :distance => nil, :time => Time.now, :name => nil, :file_name => nil})
+			@duration = opts[:duration]
+			@name = opts[:name]
+			@time = opts[:time]
+			@distance = opts[:distance]
+			@file_name = opts[:file_name]
+
+			@data = nil
+			@trackpoints = {}
+		end
+
+
+		def calc_average_hr!
+			ahr = heart_rates.compact.aaverage
+			@average_hr = ahr == 0.0 ? nil : ahr
+		end
+
+		def calc_average_speed! 
+			aspeed = speeds.compact.aaverage
+			@average_speed = aspeed == 0.0 ? nil : aspeed
+		end
+
+		def calc_altitude_gain!
+			gain = 0
+			smoothed_altitude = altitudes.compact.smoothed(10)
+			start = smoothed_altitude.first
+			smoothed_altitude.each do |alt|
+				diff = alt - start
+				if (diff > 0.5)
+					gain += diff
+				end
+				start = alt
+			end
+			@altitude_gain = gain == 0.0 ? nil : gain
+
+		end
+
+
+		## Some helper functions that return specific files from trackpoint as array
+		def heart_rates
+			@trackpoints.map {|tp| tp.hr }
+		end
+
+		def speeds
+			@trackpoints.map {|tp| tp.speed }
+		end
+
+		def altitudes
+			@trackpoints.map { |tp| tp.altitude }
+		end 
+		
+		def set_distance_from_trackpoints!
+			@trackpoints.reverse_each do |tp|
+				if !tp.distance.nil?
+					self.distance = tp.distance
+					break
+				end
+			end	
+		end
+	end
+end

data/lib/hrmparser.rb

@@ -0,0 +1,12 @@
+require 'rubygems' 
+require 'hpricot'
+require 'time'
+
+module HRMParser; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/hrmparser')
+
+require 'arraymath'
+require 'trackpoint'
+require 'workout'
+require 'importer'

data/spec/arraymath_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+module ArrayMath
+  describe "ArrayMath" do
+    context "Sum" do
+      it "sums an array" do
+        array = [1,2,3,4,5]
+        array.asum.should == 15
+      end
+      it "can not sum an array of strings" do
+        array = ["hello", "goodbye"]
+        array.asum.should == nil
+      end
+    end
+    context "average" do
+      it "averages an array of integers and returns a float" do
+        array = [2,3,4,3,2]
+        array.aaverage.should == 2.8
+      end
+      it "averages an array of floats" do
+        array = [1.5,2.5,3.5,2.5,1.5]
+        array.aaverage.should == 2.3
+      end
+    end
+  end
+end

data/spec/hrmparser_spec.rb

@@ -0,0 +1,298 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+module HRMParser
+  describe "TrackPoint" do
+    context "new trackpoint" do
+      it "has no variables set" do
+        hrm = TrackPoint.new
+        hrm.speed == nil
+        hrm.distance == nil
+        hrm.lat.should == nil
+        hrm.lng.should == nil
+        hrm.altitude.should == nil
+        hrm.hr.should == nil
+      end
+    end
+  end
+
+  describe "Workout" do
+    context "new workout" do
+      it "has no variables set" do
+        workout = Workout.new
+        workout.distance.should == nil
+        workout.duration.should == nil
+        workout.average_hr.should == nil
+        workout.name.should == nil
+        workout.file_name.should == nil
+      end
+      it "set name through initializer" do
+        workout = Workout.new(:name => "test workout")
+        workout.name.should == "test workout"
+      end
+      it "can not set average_hr during init" do
+        workout = Workout.new(:average_hr => 150)
+        workout.average_hr.should == nil
+      end
+    end
+    
+    context "Identifies files" do
+      it "identify file as garmin" do
+        type = Importer.file_type("spec/samples/small-garmin.TCX")
+        type.should == "GARMIN_XML"
+      end
+      it "identification returns nil if no file specified" do
+        type = Importer.file_type("")
+        type.should == nil
+      end
+      it "identify file as polar" do
+        type = Importer.file_type("spec/samples/polarRS400.hrm")
+        type.should == "POLAR_HRM"
+      end
+      it "identifies timex" do
+        type = Importer.file_type("spec/samples/timex/HR.csv")
+        type.should == "TIMEX"
+      end
+    end
+
+    # context "Parse a GPS file" do
+    #    it "finds the duration, time" do
+    #      filename = "spec/samples/gps-with-suunto.gpx"
+    #      data = File.read(filename)
+    #      importer = Importer::GPX.new(:data => data)
+    #      workout = importer.restore
+    #      workout.time.should == Time.parse("Thu May 07 21:32:31 UTC 2009")
+    #        
+    #      # Duration is actualy less, but we don't account for stopped time right now
+    #      workout.duration.should be_close(6284,1)
+    #    end
+    #    it "calculates the distance and speed" do
+    #      filename = "spec/samples/gps-with-suunto.gpx"
+    #      data = File.read(filename)
+    #      importer = Importer::GPX.new(:data => data)
+    #      workout = importer.restore
+    #      workout.average_speed.should be_close(6.7, 0.2)
+    #      workout.distance.should be_close(26427, 1)
+    #    end
+    #    it "handles files with drops" do
+    #      filename = "spec/samples/gps-flat-run.gpx"
+    #      data = File.read(filename)
+    #      importer = Importer::GPX.new(:data => data)
+    #      workout = importer.restore
+    #      workout.average_speed.should be_close(2.9, 0.2)
+    #      workout.distance.should be_close(11453, 1)
+    #      workout.altitude_gain.should be_close(325, 10)
+    #    end
+    #    it "deals with stopping and calculates duration correctly" do
+    #      filename = "spec/samples/gps-with-stops.gpx"
+    #      data = File.read(filename)
+    #      importer = Importer::GPX.new(:data => data)
+    #      workout = importer.restore
+    #      workout.average_speed.should be_close(6.5, 0.2)
+    #      workout.distance.should be_close(5230, 1)
+    #      workout.altitude_gain.should be_close(11, 10)
+    #      workout.duration.should be_close(1149, 1)
+    #    end
+    #    
+    #    it "deals with stopping and calculates duration correctly" do
+    #      filename = "spec/samples/gps-with-stops-2.gpx"
+    #      data = File.read(filename)
+    #      importer = Importer::GPX.new(:data => data)
+    #      workout = importer.restore
+    #      workout.average_speed.should be_close(5.7, 0.2)
+    #      workout.distance.should be_close(3099, 1)
+    #      workout.altitude_gain.should be_close(24, 10)
+    #      workout.duration.should be_close(564, 1)
+    #    end
+    #    
+    #  end
+    # 
+    #  context "Parse garmin file" do
+    #      it "finds workout start time on a short workout" do
+    #        filename = "spec/samples/indoor-garmin-405.TCX"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.time.should == Time.parse("Fri Aug 22 01:04:55 UTC 2008")
+    #      end
+    #      it "finds the duration on a short workout" do
+    #        filename = "spec/samples/indoor-garmin-405.TCX"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.duration.should be_close(755, 1)
+    #      end
+    #      it "indoor workout has no trackpoints" do
+    #        filename = "spec/samples/indoor-garmin-405.TCX"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.distance.should be_nil
+    #        workout.average_hr.should be_nil
+    #        workout.average_speed.should be_nil
+    #        workout.altitude_gain.should be_nil
+    #        workout.trackpoints.should == {}
+    #      end
+    #      it "parses files with only LAT and LNG" do
+    #        filename = "spec/samples/garmin-only-lat-lng.tcx"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.distance.should be_close(172052, 1)
+    #        workout.average_hr.should be_nil
+    #        workout.average_speed.should be_close(5.93, 0.1)
+    #        workout.altitude_gain.should be_close(372, 10)
+    #      end
+    #   
+    #      # Parsing the full XML is just slow.  Commenting out for now.
+    #      it "gets workout level settings for outdoor workout" do
+    #        filename = "spec/samples/outdoor-garmin-405.TCX"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.distance.should be_close(11740, 5)
+    #        workout.average_hr.should be_close(149.7, 0.5)
+    #        workout.average_speed.should be_close(1.5, 0.2)
+    #        workout.altitude_gain.should be_close(580, 25)
+    #      end
+    #   
+    #      it "gets workout level settings for weird distance workout" do
+    #        filename = "spec/samples/garmin-405-dies-distance.TCX"
+    #        data = File.read(filename)
+    #        importer = Importer::Garmin.new(:data => data)
+    #        workout = importer.restore
+    #        workout.distance.should be_close(9426, 1)
+    #        workout.average_hr.should == nil
+    #        workout.average_speed.should be_close(6.7, 0.2)
+    #        workout.altitude_gain.should be_close(40, 10)
+    #      end
+    #   
+    #      it "doesn't have any 0 in latitude" do
+    #           filename = "spec/samples/garmin-405-with-0-0.TCX"
+    #           data = File.read(filename)
+    #           importer = Importer::Garmin.new(:data => data)
+    #           workout = importer.restore
+    #           workout.trackpoints.map {|tp| tp.lat.should_not == 0.0}
+    #           workout.trackpoints.map {|tp| tp.lat.should_not == "undefined"}
+    #         end
+    #         
+    #         it "handles files with INSANE duration" do
+    #           filename = "spec/samples/insane-duration.TCX"
+    #           data = File.read(filename)
+    #           importer = Importer::Garmin.new(:data => data)
+    #           workout = importer.restore
+    #           workout.duration.should be_close(4996, 0.2)
+    #         end
+    #    end
+    #   
+    #    context "Parse polar RS400 file" do
+    #        it "finds the duration and time" do
+    #          filename ="spec/samples/polarRS400.hrm"
+    #          data = File.read(filename)
+    #          importer = Importer::Polar.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.duration.should be_close(3569,1)
+    #          workout.time.should == Time.parse("Thu Apr 16 12:01:55 -0700 2009")
+    #        end
+    #        it "calculates the average heartrate" do
+    #          filename ="spec/samples/polarRS400.hrm"          
+    #          data = File.read(filename)
+    #          importer = Importer::Polar.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.average_hr.should be_close(145, 1)
+    #        end
+    #      end
+    #      
+    #      context "Parse a Polar RR file" do
+    #        it "calculates the heart rate from RR" do
+    #          filename ="spec/samples/polarRS800-RR.hrm"         
+    #          data = File.read(filename)
+    #          importer = Importer::Polar.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.trackpoints.each {|tp| tp.hr.should < 220 && tp.hr.should > 30}
+    #          workout.average_hr.should be_close(115, 1)
+    #          workout.average_speed.should == nil
+    #        end
+    #      end
+    #      
+    #      context "Parse a Suunto T6C RR file" do
+    #        it "finds the duration and time" do
+    #          filename = "spec/samples/suunto-t6-RR-stops.sdf"
+    #          data = File.read(filename)
+    #          importer = Importer::Suunto.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.duration.should be_close(4781,1)
+    #          workout.time.should == Time.parse("Thu May 07 14:16:07 -0700 2009")
+    #        end
+    #        it "calculates the average HR & altitude" do
+    #          filename = "spec/samples/suunto-t6-RR-stops.sdf"
+    #          data = File.read(filename)
+    #          importer = Importer::Suunto.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.average_hr.should be_close(152,1)
+    #          workout.average_speed.should == nil
+    #          workout.trackpoints.each { |tp| tp.speed.should == nil }
+    #          workout.altitude_gain.should be_close(115, 10)
+    #        end
+    #        it "calculates the speed and distance" do
+    #          filename = "spec/samples/suunto-with-cadence-speed-distance.sdf"
+    #          data = File.read(filename)
+    #          importer = Importer::Suunto.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+    #          workout = importer.restore
+    #          workout.average_hr.should be_close(131,1)
+    #          workout.average_speed.should be_close(9.3, 0.1)
+    #          workout.altitude_gain.should be_close(75, 15)
+    #          workout.distance.should == 124597
+    #        end
+    #      end
+        
+        context "Parse Timex CSV" do
+          it "handles HR only" do
+            filename = "spec/samples/timex/HR.csv"
+            data = File.read(filename)
+            importer = Importer::Timex.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+            workout = importer.restore
+            workout.duration.should be_close(3298, 1)
+            workout.time.should == Time.parse("Jan 01 09:27:26 -0800 2009")
+            workout.average_hr.should be_close(81,1)
+          end
+          
+          it "does speed and distance" do
+            filename = "spec/samples/timex/Speed+Distance.csv"
+            data = File.read(filename)
+            importer = Importer::Timex.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+            workout = importer.restore
+            workout.duration.should be_close(2580, 1)
+            workout.time.should == Time.parse("Feb 01 08:27:02  -0800 2009")
+            workout.average_hr.should == nil
+            workout.distance.should be_close(8391, 1)
+            workout.average_speed.should be_close(3.2, 0.2)
+          end
+          
+          it "handles a GPS only file" do
+            filename = "spec/samples/timex/GPS.csv"
+            data = File.read(filename)
+            importer = Importer::Timex.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+            workout = importer.restore
+            workout.duration.should be_close(1937, 1)
+            workout.time.should == Time.parse("Jun 01 12:03:12 -0700 2009")
+            workout.average_hr.should == nil
+            workout.distance.should be_close(6035, 1)
+            workout.average_speed.should be_close(3.05, 0.05)
+          end
+          
+          it "handles GPS & HR" do
+            filename = "spec/samples/timex/GPS+HR.csv"
+            data = File.read(filename)
+            importer = Importer::Timex.new(:data => data, :time_zone => "Pacific Time (US & Canada)")
+            workout = importer.restore
+            workout.duration.should be_close(2677.0, 1)
+            workout.time.should == Time.parse("Jul 01 12:00:43 -0700 2009")
+            workout.average_hr.should be_close(169,1)
+            workout.distance.should be_close(6435, 1)
+            workout.average_speed.should be_close(2.34, 0.05)
+          end
+        end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+lib_path = File.expand_path("#{dir}/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+$_spec_spec = true # Prevents Kernel.exit in various places
+
+require 'spec'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'hrmparser'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: hrmparser
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+platform: ruby
+authors: 
+- Oren Teich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-13 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Parses Polar and Garmin HRM files.
+email: oren@teich.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- CHANGELOG.txt
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- hrmparser.gemspec
+- lib/hrmparser.rb
+- lib/hrmparser/arraymath.rb
+- lib/hrmparser/importer.rb
+- lib/hrmparser/importer/garmin.rb
+- lib/hrmparser/importer/gpx.rb
+- lib/hrmparser/importer/polar.rb
+- lib/hrmparser/importer/suunto.rb
+- lib/hrmparser/importer/timex.rb
+- lib/hrmparser/trackpoint.rb
+- lib/hrmparser/workout.rb
+- spec/arraymath_spec.rb
+- spec/hrmparser_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/teich/hrmparser
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Heart Rate Monitor Parser
+test_files: 
+- spec/arraymath_spec.rb
+- spec/hrmparser_spec.rb
+- spec/spec_helper.rb