joule 1.0.0

data/README.rdoc

@@ -0,0 +1,18 @@
+= Joule
+
+== Description
+
+Joule is a  Ruby library for parsing bicycle powermeter data.
+
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2008 - 2009 Andrew Olson
+
+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,48 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'rake/gempackagetask'
+
+task :default => [:test]
+
+desc 'Test Joule.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' 
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+
+
+
+
+spec = Gem::Specification.new do |s|
+  s.name = "joule"
+  s.summary = "A Ruby library for parsing bicycle powermeter data."
+  s.description = ""
+  s.homepage = "http://github.com/anolson/joule"
+  
+  s.version = "1.0.0"
+  s.date = "2010-1-5"
+  
+  s.authors = ["Andrew Olson"]
+  s.email = "anolson@gmail.com"
+  
+  s.require_paths = ["lib"]
+  s.files = Dir["lib/**/*"] + ["README.rdoc", "Rakefile"]
+  s.extra_rdoc_files = ["README.rdoc"]
+  
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Joule", "--main", "README.rdoc"]
+  
+  s.rubygems_version = "1.3.4"
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2")
+  s.add_dependency("nokogiri", ">= 1.4.1")
+  s.add_dependency("fastercsv", ">=1.4.0")
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg| 
+  pkg.need_tar = true 
+end 

data/lib/joule.rb

@@ -0,0 +1,14 @@
+require 'joule/array'
+require 'joule/float'
+
+require 'joule/data_point'
+require 'joule/marker'
+require 'joule/calculator'
+require 'joule/units_conversion'
+
+require 'joule/csv'
+require 'joule/ibike'
+require 'joule/powertap'
+require 'joule/srm'
+require 'joule/tcx'
+

data/lib/joule/array.rb

@@ -0,0 +1,23 @@
+class Array
+  def summation
+    inject{|sum, value| 
+      sum + value}
+  end
+
+  def maximum
+    inject {|max, value| value>max ? value : max}
+  end
+
+  def average
+    summation/length
+  end
+
+  def average_maximum(size)
+    mean_max = {:start => 0.0, :value=> 0.0}
+      each_index do |i|
+        mean = slice(i, size).average
+        mean > mean_max[:value] &&  mean_max = {:start => i, :value => mean}
+      end
+    mean_max
+  end
+end

data/lib/joule/calculator.rb

@@ -0,0 +1,3 @@
+require 'joule/calculator/marker_calculator'
+require 'joule/calculator/peak_power_calculator'
+require 'joule/calculator/power_calculator'

data/lib/joule/calculator/marker_calculator.rb

@@ -0,0 +1,40 @@
+module Joule
+  module Calculator
+    module MarkerCalculator
+      
+      def calculate_marker_averages(marker)
+        marker.average_power = Joule::Calculator::PowerCalculator::average(
+          self.data_points[marker.start..marker.end].collect() {|v| v.power})
+
+        marker.average_speed = Joule::Calculator::PowerCalculator::average(
+          self.data_points[marker.start..marker.end].collect() {|v| v.speed})
+
+        marker.average_cadence = Joule::Calculator::PowerCalculator::average(
+          self.data_points[marker.start..marker.end].collect() {|v| v.cadence})
+
+        marker.average_heartrate = Joule::Calculator::PowerCalculator::average(
+          self.data_points[marker.start..marker.end].collect() {|v| v.heartrate})
+      end
+
+      def calculate_marker_maximums(marker)
+        marker.maximum_power = Joule::Calculator::PowerCalculator::maximum(
+           self.data_points[marker.start..marker.end].collect() {|value| value.power})
+
+         marker.maximum_speed = Joule::Calculator::PowerCalculator::maximum(
+           self.data_points[marker.start..marker.end].collect() {|value| value.speed})
+
+         marker.maximum_cadence = Joule::Calculator::PowerCalculator::maximum(
+           self.data_points[marker.start..marker.end].collect() {|value| value.cadence})
+
+         marker.maximum_heartrate = Joule::Calculator::PowerCalculator::maximum(
+           self.data_points[marker.start..marker.end].collect() {|value| value.heartrate})
+      end
+
+      def calculate_marker_training_metrics(marker)
+        marker.normalized_power = Joule::Calculator::PowerCalculator::normalized_power( 
+          self.data_points[marker.start..marker.end].collect() {|value| value.power}, self.properties.record_interval)
+      end
+      
+    end
+  end
+end

data/lib/joule/calculator/peak_power_calculator.rb

@@ -0,0 +1,28 @@
+module Joule
+  module Calculator
+    module PeakPowerCalculator
+      
+      def calculate_peak_power_values(options = {})
+        power_values = @data_points.collect{|v| v.power}
+        options[:durations].each { |duration|
+          @peak_powers << calculate_peak_power_value(duration, options[:total_duration], power_values)
+        }
+
+      end
+
+      def calculate_peak_power_value(duration, total_duration, power_values)
+        if duration > total_duration
+          { :duration => duration, 
+            :value => 0,
+            :start => 0 } 
+        else
+           peak_power = Joule::PowerCalculator::peak_power(power_values, (duration/@properties.record_interval))
+           { :duration => duration, 
+             :value => peak_power[:value],
+             :start => peak_power[:start] }
+        end
+      end
+      
+    end
+  end
+end

data/lib/joule/calculator/power_calculator.rb

@@ -0,0 +1,48 @@
+module Joule
+  module Calculator
+    class PowerCalculator
+      def self.average(values)
+        values.average
+      end
+
+      def self.maximum(values)
+        values.maximum
+      end
+
+      def self.total(values)
+        values.sum
+      end
+
+      def self.peak_power(values, size)
+        values.average_maximum size
+      end
+    
+      def self.training_stress_score(duration_seconds, threshold_power)
+        if(threshold_power > 0)
+          normalized_work = normalized_power * duration_seconds
+          raw_training_stress_score = normalized_work * intensity_factor(threshold_power)
+          (raw_training_stress_score/(threshold_power * 3600)) * 100
+        end
+      end
+
+      def self.intensity_factor(normalized_power, threshold_power)
+        if(threshold_power > 0)
+          normalized_power/threshold_power
+        end
+      end
+    
+      def self.normalized_power(values, record_interval)
+        thirty_second_record_count = 30 / record_interval
+        thirty_second_rolling_power = Array.new
+        if(values.length > thirty_second_record_count)
+          values.slice(thirty_second_record_count..-1).each_slice(thirty_second_record_count) { |s|
+            thirty_second_rolling_power << s.average ** 4
+          }
+          thirty_second_rolling_power.average ** 0.25
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/joule/csv.rb

@@ -0,0 +1 @@
+require 'joule/csv/parser'

data/lib/joule/csv/parser.rb

@@ -0,0 +1,68 @@
+require 'fastercsv'
+
+module Joule
+  module CSV
+    class Parser
+      include Joule::Calculator::MarkerCalculator
+      include Joule::Calculator::PeakPowerCalculator
+      include Joule::UnitsConversion
+
+      attr_reader :properties, :markers, :data_points, :peak_powers
+
+
+      def initialize(data)
+        @data = data
+        @markers = Array.new
+        @data_points = Array.new
+        @peak_powers = Array.new
+      end
+
+      def get_parser
+        header = FasterCSV.parse(@data).shift
+        if header[0].to_s.downcase.eql?("ibike")
+          return IbikeFileParser.new(data)
+        else
+          return PowertapFileParser.new(data)
+        end
+      end
+
+      def parse(options = {})
+        parse_header
+        parse_markers
+        parse_data_points
+
+        if(options[:calculate_marker_values])
+          calculate_marker_values()
+        end
+
+        if(options[:calculate_peak_power_values])
+          calculate_peak_power_values(:durations => options[:durations], :total_duration => @markers.first.duration_seconds)
+        end
+
+      end
+
+      protected
+      def create_workout_marker(records)
+        Marker.new(:start => 0, :end => records.size - 1, :comment => "")
+      end
+
+      def calculate_marker_values
+        @markers.each_with_index { |marker, i|
+          calculate_marker_averages marker      
+          calculate_marker_maximums marker
+          calculate_marker_training_metrics marker
+
+          if i.eql?(0) 
+            marker.distance = @data_points.last.distance
+            marker.duration_seconds = @data_points.last.time
+          else
+            marker.distance = @data_points[marker.end].distance - @data_points[marker.start].distance
+            marker.duration_seconds = @data_points[marker.end].time - @data_points[marker.start].time
+          end
+          marker.energy = (marker.average_power.round * marker.duration_seconds)/1000        
+        }
+      end
+
+    end
+  end
+end

data/lib/joule/data_point.rb

@@ -0,0 +1,20 @@
+module Joule
+  class DataPoint
+    attr_accessor :altitude, :cadence, :distance, :heartrate, :latitude, :longitude, :power, :speed, :time, :time_of_day, :time_with_pauses, :torque 
+
+    def initialize()
+      @time_of_day = 0
+      @time = 0
+      @time_with_pauses=0
+      @power = 0.0
+      @speed = 0.0
+      @cadence = 0
+      @distance = 0.0
+      @altitude = 0.0
+      @latitude = 0.0
+      @longitude = 0.0
+      @heartrate = 0
+      @torque = 0.0
+    end
+  end  
+end

data/lib/joule/float.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+# 
+# 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.
+
+class Float
+  remove_method :round
+ 
+  # Rounds the float with the specified precision.
+  #
+  # x = 1.337
+  # x.round # => 1
+  # x.round(1) # => 1.3
+  # x.round(2) # => 1.34
+  def round(precision = nil)
+    if precision
+      magnitude = 10.0 ** precision
+      (self * magnitude).round / magnitude
+    else
+      super()
+    end
+  end
+end

data/lib/joule/ibike.rb

@@ -0,0 +1,2 @@
+require 'joule/ibike/parser'
+require 'joule/ibike/properties'

data/lib/joule/ibike/parser.rb

@@ -0,0 +1,66 @@
+module Joule
+  module IBike
+    class Parser < Joule::CSV::Parser
+      IBIKE = '.csv'
+      SPEED = 0
+      WINDSPEED = 1
+      POWER = 2
+      DISTANCE = 3
+      CADENCE = 4
+      HEARTRATE = 5
+      ELEVATION = 6
+      SLOPE = 7
+      DFPM_POWER = 11
+      LATITUDE = 12
+      LONGITUDE = 13
+      TIMESTAMP = 14
+
+      def parse_header()
+        records = FasterCSV.parse(@data)
+        header = records.shift
+
+        @properties = Joule::IBike::Properties.new
+        @properties.version=header[1]
+        @properties.units=header[2]
+        header = records.shift
+        @properties.date_time = Time.mktime(header[0].to_i, header[1].to_i, header[2].to_i, header[3].to_i, header[4].to_i, header[5].to_i)
+        records.shift
+        header = records.shift
+        @properties.total_weight = header[0]
+        @properties.energy = header[1]
+        @properties.record_interval = header[4].to_i
+        @properties.starting_elevation = header[5]
+        @properties.total_climbing = header[6]
+        @properties.wheel_size = header[7]
+        @properties.temperature = header[8]
+        @properties.starting_pressure = header[9]
+        @properties.wind_scaling = header[10]
+        @properties.riding_tilt = header[11]
+        @properties.calibration_weight = header[12]
+        @properties.cm = header[13]
+        @properties.cda = header[14]
+        @properties.crr = header[15]
+      end
+
+      def parse_data_points()
+        records = FasterCSV.parse(@data).slice(5..-1)
+        records.each_with_index { |record, index|
+          data_point  = DataPoint.new
+          data_point.time  = index * @properties.record_interval
+          data_point.speed = convert_speed(record[SPEED].to_f)
+          data_point.power = record[POWER].to_f
+          data_point.distance = convert_distance(record[DISTANCE].to_f)
+          data_point.cadence = record[CADENCE].to_i
+          data_point.heartrate = record[HEARTRATE].to_i
+          @data_points << data_point 
+        }
+      end
+
+      def parse_markers
+        records = FasterCSV.parse(@data).slice(5..-1)
+        @markers << create_workout_marker(records)
+      end
+
+    end
+  end
+end

data/lib/joule/ibike/properties.rb

@@ -0,0 +1,52 @@
+module Joule
+  module IBike
+    class Properties
+      ENGLISH_UNITS = "english"
+      METRIC_UNITS = "metric"
+
+      attr_accessor :version 
+      attr_accessor :units 
+      attr_accessor :date_time 
+      attr_accessor :total_weight 
+      attr_accessor :energy 
+      attr_accessor :record_interval 
+      attr_accessor :starting_elevation 
+      attr_accessor :total_climbing 
+      attr_accessor :wheel_size 
+      attr_accessor :temperature 
+      attr_accessor :starting_pressure 
+      attr_accessor :wind_scaling 
+      attr_accessor :riding_tilt 
+      attr_accessor :calibration_weight 
+      attr_accessor :cm 
+      attr_accessor :cda 
+      attr_accessor :crr
+
+      def distance_units_are_english?
+        self.units_are_english?
+      end
+
+      def distance_units_are_metric?
+        self.units_are_metric?
+      end
+
+      def speed_units_are_english?
+        self.units_are_english?
+      end
+
+      def distance_units_are_metric?
+        self.units_are_metric?
+      end
+
+      def units_are_english?
+        self.units.eql?(ENGLISH_UNITS)
+      end
+
+      def units_are_metric?
+        self.units.eql?(METRIC_UNITS)
+      end
+
+    end
+  end    
+end
+

data/lib/joule/marker.rb

@@ -0,0 +1,53 @@
+class Marker
+  attr_accessor :active
+  attr_accessor :average_cadence
+  attr_accessor :average_heartrate
+  attr_accessor :average_power
+  attr_accessor :average_power_to_weight
+  attr_accessor :average_speed
+  attr_accessor :comment
+  attr_accessor :duration_seconds
+  attr_accessor :distance
+  attr_accessor :end
+  attr_accessor :energy
+  attr_accessor :intensity_factor
+  attr_accessor :maximum_cadence
+  attr_accessor :maximum_heartrate
+  attr_accessor :maximum_power
+  attr_accessor :maximum_power_to_weight
+  attr_accessor :maximum_speed 
+  attr_accessor :normalized_power 
+  attr_accessor :start
+  attr_accessor :start_time
+  attr_accessor :training_stress_score 
+  
+  
+  def initialize(options = {})
+    @active = true
+    @average_cadence = 0
+    @average_heartrate = 0
+    @average_power = 0.0
+    @average_power_to_weight = 0.0
+    @average_speed = 0.0
+    @comment = ""
+    @duration_seconds = 0
+    @distance = 0.0
+    @end = options[:end]
+    @energy = 0
+    @intensity_factor = 0
+    @maximum_cadence = 0
+    @maximum_heartrate = 0
+    @maximum_power = 0.0
+    @maximum_power_to_weight = 0.0
+    @maximum_speed = 0.0
+    @normalized_power = 0
+    @start = options[:start]
+    @training_stress_score = 0.0
+    
+  end
+  
+  def start_time_in_seconds
+    (@start_time.hour * 3600) + (@start_time.min * 60) + @start_time.sec
+  end
+end
+

data/lib/joule/powertap.rb

@@ -0,0 +1,2 @@
+require 'joule/powertap/parser'
+require 'joule/powertap/properties'

data/lib/joule/powertap/parser.rb

@@ -0,0 +1,82 @@
+module Joule
+  module PowerTap
+    class Parser < Joule::CSV::Parser
+      MINUTES = 0
+      TORQUE = 1
+      SPEED = 2
+      POWER = 3
+      DISTANCE = 4
+      CADENCE = 5
+      HEARTRATE = 6
+      MARKER = 7
+
+      def parse_header()
+        header = FasterCSV.parse(@data).shift
+        records = FasterCSV.parse(@data) 
+        @properties = Joule::PowerTap::Properties.new
+        @properties.speed_units = header[SPEED].to_s.downcase
+        @properties.power_units = header[POWER].to_s.downcase
+        @properties.distance_units = header[DISTANCE].to_s.downcase
+        calculate_record_interval(records)
+      end
+
+      def parse_data_points()
+        records = FasterCSV.parse(@data) 
+        records.shift
+
+        records.each { |record|
+          data_point = DataPoint.new
+          data_point.time  = (record[MINUTES].to_f * 60).to_i
+          data_point.torque = record[TORQUE].to_f
+          data_point.speed = convert_speed(record[SPEED].to_f)
+          data_point.power = record[POWER].to_f
+          data_point.distance = convert_distance(record[DISTANCE].to_f)
+          data_point.cadence = record[CADENCE].to_i
+          data_point.heartrate = (record[HEARTRATE].to_i < 0) && 0 || record[HEARTRATE].to_i
+
+          @data_points << data_point
+        }  
+      end
+
+      def parse_markers
+        records = FasterCSV.parse(@data) 
+        records.shift
+        @markers << create_workout_marker(records)
+
+        current_marker_index = 0
+
+        records.each_with_index { |record, index|
+          if(record[MARKER].to_i > current_marker_index )
+            create_marker(index)
+            current_marker_index = current_marker_index + 1
+          end 
+        }
+
+        #set the end of the last marker
+        set_previous_marker_end(records.size - 1)  
+      end
+
+      def create_marker(start)
+        if(@markers.size.eql?(1))
+          @markers << Marker.new(:start => 0)
+        end  
+        set_previous_marker_end(start - 1)
+        @markers << Marker.new(:start => start)
+      end
+
+      def set_previous_marker_end(value)
+        if(@markers.size > 1)
+          @markers.last.end = value
+        end
+      end
+
+      def calculate_record_interval(records)
+        times = Array.new
+        records[1..30].each_slice(2) {|s| times << ((s[1][MINUTES].to_f - s[0][MINUTES].to_f)  * 60) }
+        @properties.record_interval = times.average.round
+      end
+
+    end
+    
+  end
+end

data/lib/joule/powertap/properties.rb

@@ -0,0 +1,32 @@
+module Joule
+  module PowerTap
+    class Properties
+      ENGLISH_SPEED_UNITS = "miles/h"
+      ENGLISH_POWER_UNITS = "watts"
+      ENGLISH_DISTANCE_UNITS = "miles"
+
+      METRIC_SPEED_UNITS = "km/h"
+      METRIC_POWER_UNITS = "watts"
+      METRIC_DISTANCE_UNITS = "km"
+
+      attr_accessor :speed_units, :power_units, :distance_units, :record_interval
+
+      def speed_units_are_english?()
+        return self.speed_units.eql?(ENGLISH_SPEED_UNITS)
+      end
+
+      def speed_units_are_metric?()
+        return self.speed_units.eql?(METRIC_SPEED_UNITS)
+      end
+
+      def distance_units_are_english?()
+        return self.distance_units.eql?(ENGLISH_DISTANCE_UNITS)
+      end
+
+      def distance_units_are_metric?()
+        return self.distance_units.eql?(METRIC_DISTANCE_UNITS)
+      end 
+
+    end
+  end
+end

data/lib/joule/srm.rb

@@ -0,0 +1,2 @@
+require 'joule/srm/parser'
+require 'joule/srm/properties'

data/lib/joule/srm/parser.rb

@@ -0,0 +1,152 @@
+require 'kconv'
+
+module Joule
+  module SRM
+    class Parser
+       include Joule::Calculator::MarkerCalculator
+       include Joule::Calculator::PeakPowerCalculator
+
+       SRM = '.srm'
+       HEADER_SIZE=86
+       MARKER_SIZE=270
+       BLOCK_SIZE=6
+
+       attr_reader :properties, :markers, :data_points, :peak_powers
+
+       def initialize(data)
+         @data = data  
+         @data_points = Array.new
+         @markers = Array.new
+         @peak_powers = Array.new
+       end
+
+       def parse(options = {})
+         parse_header
+         parse_markers
+         parse_blocks
+         parse_data_points
+         parse_data_point_times
+
+         if(options[:calculate_marker_values])
+           calculate_marker_values()
+         end
+
+         if(options[:calculate_peak_power_values])
+           calculate_peak_power_values(:durations => options[:durations], :total_duration => @markers.first.duration_seconds)
+         end
+       end
+
+       def parse_header()
+         str = @data.slice(0, HEADER_SIZE)
+         @properties = Joule::SRM::Properties.new
+         @properties.ident=str.slice(0,4)
+         @properties.srm_date = str.slice(4,2).unpack('S')[0]
+         @properties.wheel_size = str.slice(6,2).unpack('S')[0]
+         @properties.record_interval_numerator = str.slice(8,1).unpack('C')[0]
+         @properties.record_interval_denominator = str.slice(9,1).unpack('C')[0]
+         @properties.block_count = str.slice(10,2).unpack('S')[0]
+         @properties.marker_count = str.slice(12,2).unpack('S')[0]
+         @properties.comment = str.slice(16,70).toutf8.strip
+
+         str=@data.slice(HEADER_SIZE + 
+           (MARKER_SIZE * (@properties.marker_count + 1 )) + 
+           (BLOCK_SIZE * @properties.block_count) , 6)
+
+         @properties.zero_offset = str.slice(0,2).unpack('S')[0]
+         @properties.slope = str.slice(2,2).unpack('S')[0]
+         @properties.record_count = str.slice(4,2).unpack('S')[0]   
+       end
+
+       def parse_markers
+         marker_offset = HEADER_SIZE
+
+         (@properties.marker_count + 1).times { |i|
+           str = @data.slice(marker_offset + (i * MARKER_SIZE), MARKER_SIZE)
+
+           marker = Marker.new
+           marker.comment = str.slice(0, 255).strip
+           marker.active = str.slice(255)
+           marker.start = str.slice(256,2).unpack('S')[0] - 1
+           marker.end = str.slice(258,2).unpack('S')[0] - 1
+           @markers << marker        
+         }
+
+       end
+
+       def parse_blocks
+         block_offset = HEADER_SIZE + (MARKER_SIZE * (@properties.marker_count + 1 ))
+
+         @blocks = Array.new
+         @properties.block_count.times {|i|
+           str=@data.slice(block_offset + (i * BLOCK_SIZE), BLOCK_SIZE)
+
+           block = Hash.new
+           block[:time] = str.slice(0,4).unpack('I')[0]
+           block[:count] = str.slice(4,2).unpack('S')[0].to_i
+           @blocks << block
+         }
+       end
+
+       def parse_data_points()
+         count = 0
+         start = HEADER_SIZE + (MARKER_SIZE * (@properties.marker_count + 1 )) + (BLOCK_SIZE * @properties.block_count) + 7
+         total_distance = 0
+
+         while count < @properties.record_count
+           record=@data.slice(start + (count * 5), 5)
+           byte1=record.slice(0)
+           byte2=record.slice(1)
+           byte3=record.slice(2)
+           data_point = DataPoint.new
+
+           data_point.time = count * @properties.record_interval
+           data_point.power = ( (byte2 & 0x0F) | (byte3 << 4) ).to_f
+           data_point.speed = ( ( ( (byte2 & 0xF0) << 3) | (byte1 & 0x7F) ) * 32 ) #stored in mm/s
+           data_point.cadence = record.slice(3)
+           data_point.heartrate = record.slice(4)
+
+           total_distance = total_distance + (data_point.speed * @properties.record_interval) 
+           data_point.distance = total_distance #in mm
+
+           @data_points << data_point
+           count=count + 1
+         end
+       end
+
+       def parse_data_point_times
+         count = 0
+         @blocks.each { |block|
+          relative_count = 0
+           while relative_count < block[:count]
+             @data_points[count].time_of_day =  block[:time]/100 + (@properties.record_interval*relative_count)
+             @data_points[count].time_with_pauses = block[:time]/100 - @blocks[0][:time]/100 + (@properties.record_interval*(relative_count + 1))
+
+             relative_count=relative_count+1
+             count=count+1
+           end
+         }
+
+         @properties.date_time = data_points.first.time_of_day.to_i
+       end
+
+       def calculate_marker_values
+         @markers.each_with_index { |marker, i|
+           calculate_marker_averages marker      
+           calculate_marker_maximums marker
+           calculate_marker_training_metrics marker
+
+           if i.eql?(0)
+             marker.distance = @data_points.last.distance
+           else
+             marker.distance = @data_points[marker.end + 1].distance - @data_points[marker.start].distance
+           end
+
+           marker.duration_seconds = (marker.end - marker.start + 1) * @properties.record_interval
+           marker.energy = (marker.average_power.round * marker.duration_seconds)/1000
+
+         }
+       end
+
+     end
+  end
+end

data/lib/joule/srm/properties.rb

@@ -0,0 +1,31 @@
+module Joule
+  module SRM
+    class Properties
+      attr_accessor :ident, :srm_date, :start_date_time, :wheel_size, :record_interval_numerator,
+        :record_interval_denominator, :block_count, :marker_count, :comment, 
+        :zero_offset, :record_count, :slope
+
+      def record_interval 
+        return self.record_interval_numerator/self.record_interval_denominator
+      end
+
+      def date
+        Date.new(1880,1,1) + self.srm_date
+      end
+
+      def slope
+        @slope/305.58
+      end
+
+      def date_time=(time)
+        self.start_date_time = Time.mktime(self.date.year.to_i, self.date.month.to_i, self.date.day.to_i) + time
+      end
+
+      def date_time
+        self.start_date_time
+      end
+    end  
+  end
+end
+
+

data/lib/joule/tcx.rb

@@ -0,0 +1,2 @@
+require 'joule/tcx/parser'
+require 'joule/tcx/properties'

data/lib/joule/tcx/parser.rb

@@ -0,0 +1,177 @@
+require 'nokogiri'
+
+module Joule
+  module TCX
+    class Parser
+      include Joule::Calculator::MarkerCalculator
+      include Joule::Calculator::PeakPowerCalculator
+
+      attr_reader :data_points, :markers, :properties, :peak_powers
+
+      def initialize(string_or_io)
+        @string_or_io = string_or_io
+        @data_points = Array.new
+        @properties = Joule::TCX::Properties.new
+        @markers = Array.new
+        @peak_powers = Array.new
+        @has_native_speed = false
+      end
+
+      def parse(options = {})
+        @properties.record_interval = 1
+        @total_record_count = 0
+        parse_activity("Biking")
+        create_workout_marker()
+
+        if(options[:calculate_marker_values])
+          calculate_marker_values()
+        end
+
+        if(options[:calculate_peak_power_values])
+          calculate_peak_power_values(:durations => options[:durations], :total_duration => @markers.first.duration_seconds)
+        end
+
+      end
+
+      private  
+      def create_workout_marker
+        if(@markers.size > 1)
+          @markers << Marker.new(:start => 0, :end => @data_points.size - 1)
+        end
+      end
+
+      def parse_activity(sport)
+        document = Nokogiri::XML::Document.parse(@string_or_io)
+        document.xpath("//xmlns:Activity[@Sport='#{sport}']").each do |activity|
+          @properties.id = activity.at("./xmlns:Id").content
+
+          activity.children.each do |child|
+            parse_lap(child) if child.name == "Lap"
+          end
+
+          calculate_speed if(!@has_native_speed)
+
+        end
+      end
+
+      def parse_lap(lap_node)
+
+        marker = Marker.new
+        marker.start_time = DateTime.parse(lap_node.attribute("StartTime").content)
+
+        if(@markers.size == 0)
+          @properties.start_date_time = marker.start_time
+        end
+
+        if @data_points.size > 0
+          marker.start = @data_points.last.time + 1
+        else
+          marker.start= 0
+        end
+
+        lap_node.children.each do |child|
+          marker.duration_seconds = child.content.to_i if child.name == "TotalTimeSeconds" 
+          # puts "Distance in meters: #{child.content}" if child.name == "DistanceMeters"
+          # puts "Maximum Speed: #{child.content}" if child.name == "MaximumSpeed"
+          # puts "Calories: #{child.content}" if child.name == "Calories"
+          # puts "Intensity: #{child.content}" if child.name == "Intensity"
+          # puts "Cadence: #{child.content}" if child.name == "Cadence"  
+          # puts "Trigger Method: #{child.content}" if child.name == "TriggerMethod"  
+          parse_track(child) if(child.name == "Track")
+        end
+        marker.end = @data_points.last.time
+        @markers << marker
+      end
+
+      def parse_track(track)
+        @trackpoint_count = 0
+        track.children.each do |trackpoint|
+          parse_trackpoint(trackpoint) if(trackpoint.name == "Trackpoint")
+
+        end
+
+      end
+
+      def parse_trackpoint(trackpoint)
+        data_point = DataPoint.new
+
+        trackpoint.children.each do |data|
+          parse_times(data, data_point) if(data.name == "Time")
+          data_point.altitude = data.content.to_f if data.name == "AltitudeMeters"
+          data_point.distance = (data.content.to_f * 1000) if data.name == "DistanceMeters"
+          data_point.cadence = data.content.to_i if data.name == "Cadence"
+          parse_heartrate(data, data_point) if data.name == "HeartRateBpm"
+          parse_extensions(data, data_point) if data.name == "Extensions"
+          parse_position(data, data_point) if data.name == "Position" 
+        end
+        @data_points << data_point
+        @trackpoint_count = @trackpoint_count + 1
+        @total_record_count = @total_record_count + 1
+      end
+
+      def parse_times(data, data_point)
+        time_of_day =  DateTime.parse(data.content)
+        data_point.time_of_day = (time_of_day.hour * 3600) + (time_of_day.min * 60) + time_of_day.sec
+        data_point.time = @total_record_count * @properties.record_interval
+
+        if(@trackpoint_count == 0)
+          track_start_time = data_point.time_of_day
+          @track_offset_in_seconds = track_start_time - @properties.start_time_in_seconds
+        end
+        data_point.time_with_pauses = (@trackpoint_count * @properties.record_interval) + @track_offset_in_seconds
+      end
+
+      def parse_heartrate(heartrate, data_point)
+        heartrate.children.each do |child|
+          data_point.heartrate = child.content.to_i if child.name == "Value"
+        end
+      end
+
+      def parse_extensions(extensions, data_point)
+        extensions.children.each do |extension|
+          extension.children.each do |tpx|
+            (data_point.speed = tpx.content.to_f; @has_native_speed = true;) if(tpx.name == "Speed")
+            (data_point.power = tpx.content.to_f) if(tpx.name == "Watts")
+          end 
+        end  
+      end
+
+      def parse_position(position, data_point)
+        position.children.each do |child|
+          (data_point.latitude = child.content.to_f) if child.name == "LatitudeDegrees"
+          (data_point.longitude = child.content.to_f) if child.name == "LongitudeDegrees"
+        end
+      end
+
+      def calculate_marker_values
+        @markers.each_with_index { |marker, i|
+          calculate_marker_averages marker      
+          calculate_marker_maximums marker
+          calculate_marker_training_metrics marker
+
+          if i.eql?(0)
+            marker.distance = @data_points.last.distance
+          else
+            marker.distance = @data_points[marker.end + 1].distance - @data_points[marker.start].distance
+          end
+
+          marker.duration_seconds = (marker.end - marker.start + 1) * @properties.record_interval
+          marker.energy = (marker.average_power.round * marker.duration_seconds)/1000
+
+        }
+      end
+
+      def calculate_speed
+        @data_points.each_with_index { |v, i| 
+          if(i == 0)
+            delta = v.distance 
+          else
+            delta = v.distance - @data_points[i-1].distance
+          end
+          v.speed = delta / @properties.record_interval      
+        }
+      end
+    end
+    
+  end
+end

data/lib/joule/tcx/properties.rb

@@ -0,0 +1,11 @@
+module Joule
+  module TCX
+    class Properties
+      attr_accessor :id, :record_interval, :start_date_time
+
+      def start_time_in_seconds
+        (@start_date_time.hour * 3600) + (@start_date_time.min * 60) + @start_date_time.sec
+      end
+    end  
+  end
+end

data/lib/joule/units_conversion.rb

@@ -0,0 +1,55 @@
+module Joule
+  module UnitsConversion
+    def convert_speed(speed)
+      #convert to mm/s
+      if self.properties.speed_units_are_english?
+        miles_per_hour_to_millimeters_per_second speed
+      else
+        kilometers_per_hour_to_millimeters_per_second speed
+      end
+    end
+
+    def convert_distance(distance)
+      #convert distance to mm
+      if self.properties.distance_units_are_english?
+        miles_to_millimeters distance
+      else
+        kilometers_to_millimeters distance
+      end
+    end
+
+    def miles_per_hour_to_millimeters_per_second(speed)
+      speed * 447.04 
+    end
+
+    def millimeters_per_second_to_miles_per_hour(speed)
+      speed / 447.04 
+    end
+
+    def kilometers_per_hour_to_millimeters_per_second(speed)
+      speed * 277.78 
+    end
+
+    def millimeters_per_second_to_kilometers_per_hour(speed)
+      speed / 277.78 
+    end
+
+    def miles_to_millimeters(distance)
+      distance * 1609344
+    end
+
+    def millimeters_to_miles(distance)
+      distance / 1609344
+    end
+
+    def kilometers_to_millimeters(distance)
+      distance * 1000000
+    end
+
+    def millimeters_to_kilometers(distance)
+      distance / 1000000
+    end
+
+  end  
+end
+

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: joule
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew Olson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-05 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fastercsv
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: 
+description: ""
+email: anolson@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/joule
+- lib/joule/array.rb
+- lib/joule/calculator
+- lib/joule/calculator/marker_calculator.rb
+- lib/joule/calculator/peak_power_calculator.rb
+- lib/joule/calculator/power_calculator.rb
+- lib/joule/calculator.rb
+- lib/joule/csv
+- lib/joule/csv/parser.rb
+- lib/joule/csv.rb
+- lib/joule/data_point.rb
+- lib/joule/float.rb
+- lib/joule/ibike
+- lib/joule/ibike/parser.rb
+- lib/joule/ibike/properties.rb
+- lib/joule/ibike.rb
+- lib/joule/marker.rb
+- lib/joule/powertap
+- lib/joule/powertap/parser.rb
+- lib/joule/powertap/properties.rb
+- lib/joule/powertap.rb
+- lib/joule/srm
+- lib/joule/srm/parser.rb
+- lib/joule/srm/properties.rb
+- lib/joule/srm.rb
+- lib/joule/tcx
+- lib/joule/tcx/parser.rb
+- lib/joule/tcx/properties.rb
+- lib/joule/tcx.rb
+- lib/joule/units_conversion.rb
+- lib/joule.rb
+- README.rdoc
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/anolson/joule
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Joule
+- --main
+- README.rdoc
+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: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A Ruby library for parsing bicycle powermeter data.
+test_files: []
+