joule 1.0.0 → 1.0.1

data/README.rdoc

@@ -4,15 +4,60 @@
 
 Joule is a  Ruby library for parsing bicycle powermeter data.
 
+The following formats are supported:
+
+* SRM (.srm)
+* PowerTap (.csv)
+* iBike (.csv)
+* Garmin (.tcx)
+
+==Install 
+  sudo gem install joule
+
+==Usage
+  require 'joule'
+  
+  parser = Joule::SRM::Parser.new(IO.read("sample_srm_file.srm"))
+  workout = parser.parse(
+    :calculate_marker_values => true, 
+    :calculate_peak_power_values => true, 
+    :durations => [5, 300, 1200])
+
+  # data_points
+  workout.data_points.each { |v| 
+    puts "--Data Point--"
+    puts "Time: #{v.time}"
+    puts "Power: #{v.power}"
+  }
+
+  # markers
+  workout.markers.each { |v| 
+    puts "--Marker--"
+    puts "Duration: #{v.duration_seconds}"
+    puts "Average Power: #{v.average_power}"
+    puts "Normalized Power: #{v.average_power}"
+  }
+
+  # peak_powers
+  workout.peak_powers.each { |v|
+    puts "--Peak Power--"
+    puts "Duration: #{v.duration}"
+    puts "Peak Power: #{v.value}"
+  } 
+
+== Dependencies
+
+* nokogiri >= 1.4.1
+* fastercsv >=1.4.0
 
 == License
 
 (The MIT License)
 
-Copyright (c) 2008 - 2009 Andrew Olson
+Copyright (c) 2008 - 2010 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:
+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.
+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

@@ -9,22 +9,19 @@ task :default => [:test]
 desc 'Test Joule.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib' 
-  t.pattern = 'test/**/test_*.rb'
+  t.libs << 'test/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.description = "Joule parses and does some basic analyzing of powermeter data. Supported formats include SRM(.srm), Saris PowerTap(.csv), iBike(.csv), and Garmin(.tcx)"
   s.homepage = "http://github.com/anolson/joule"
   
-  s.version = "1.0.0"
-  s.date = "2010-1-5"
+  s.version = "1.0.1"
+  s.date = "2010-9-15"
   
   s.authors = ["Andrew Olson"]
   s.email = "anolson@gmail.com"
@@ -46,3 +43,11 @@ end
 Rake::GemPackageTask.new(spec) do |pkg| 
   pkg.need_tar = true 
 end 
+
+Rake::RDocTask.new do |doc|
+  doc.main = "README.rdoc"
+  doc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  doc.rdoc_dir = "doc"
+end
+
+

data/lib/joule.rb

@@ -1,14 +1,34 @@
 require 'joule/array'
-require 'joule/float'
+require 'joule/exception'
+require 'joule/hashable'
 
 require 'joule/data_point'
 require 'joule/marker'
 require 'joule/calculator'
+require 'joule/peak_power'
 require 'joule/units_conversion'
+require 'joule/workout'
 
+require 'joule/base'
 require 'joule/csv'
 require 'joule/ibike'
 require 'joule/powertap'
 require 'joule/srm'
 require 'joule/tcx'
 
+module Joule
+  
+  def Joule.parser(extension, data) 
+    if(extension.eql?(Joule::SRM::FILE_EXTENSION))
+      Joule::SRM::Parser.new(data)
+    elsif(extension.eql?(Joule::TCX::FILE_EXTENSION))
+      Joule::TCX::Parser.new(data)
+    elsif(extension.eql?(Joule::CSV::FILE_EXTENSION))
+      Joule::CSV.parser(extension, data)      
+    else
+      raise UnsupportedFileTypeException
+    end
+  end
+  
+end
+

data/lib/joule/base.rb

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

data/lib/joule/base/parser.rb

@@ -0,0 +1,50 @@
+module Joule
+  module Base
+    class Parser
+      include Joule::Calculator::MarkerCalculator
+      include Joule::Calculator::PeakPowerCalculator
+      
+      attr_accessor :workout
+      
+      def initialize(data)
+        @data = data  
+        @workout = Workout.new
+      end
+
+      # Parse powermeter data.
+      # == Options
+      #
+      # * <tt>:calculate_marker_values </tt> - calculate the totals, averages, and maximum values for each Marker.
+      #
+      # * <tt>:calculate_peak_power_values </tt> - calculate the PeakPower values for the Workout.
+      #
+      # * <tt>:durations </tt> - an Array of durations (in seconds) of the PeakPower values that you want to calculate.  Required if :calculate_peak_power_values => true.
+      #
+
+
+      def parse(options = {})
+
+        parse_properties
+        parse_workout
+        
+        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
+        @workout
+      end
+      
+      def parse_workout
+        raise NotImplementedError
+      end
+
+      def parse_properties
+        raise NotImplementedError
+      end
+    end    
+    
+  end
+end

data/lib/joule/calculator/marker_calculator.rb

@@ -4,35 +4,62 @@ module Joule
       
       def calculate_marker_averages(marker)
         marker.average_power = Joule::Calculator::PowerCalculator::average(
-          self.data_points[marker.start..marker.end].collect() {|v| v.power})
+          @workout.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})
+          @workout.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})
+          @workout.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})
+          @workout.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})
+           @workout.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})
+           @workout.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})
+           @workout.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})
+           @workout.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)
+          @workout.data_points[marker.start..marker.end].collect() {|value| value.power}, @workout.properties.record_interval)
+      end
+      
+      
+      def calculate_marker_totals(marker, index)
+        if(index == 0)
+          marker.distance = @workout.data_points.last.distance
+          marker.duration_seconds = @workout.data_points.last.time
+        else
+          if(marker.start == 0)
+            marker.distance = @workout.data_points[marker.end].distance - @workout.data_points[marker.start].distance
+            marker.duration_seconds = @workout.data_points[marker.end].time - @workout.data_points[marker.start].time
+          else
+            marker.distance = @workout.data_points[marker.end].distance - @workout.data_points[marker.start - 1].distance
+            marker.duration_seconds = @workout.data_points[marker.end].time - @workout.data_points[marker.start - 1].time
+          end 
+        end
+        
+        marker.energy = (marker.average_power.round * marker.duration_seconds)/1000        
+      end
+      
+      def calculate_marker_values(options = {})
+        @workout.markers.each_with_index { |marker, i|
+          calculate_marker_averages marker      
+          calculate_marker_maximums marker
+          calculate_marker_training_metrics marker
+          calculate_marker_totals marker, i  
+        }
       end
       
     end

data/lib/joule/calculator/peak_power_calculator.rb

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

data/lib/joule/calculator/power_calculator.rb

@@ -13,8 +13,12 @@ module Joule
         values.sum
       end
 
-      def self.peak_power(values, size)
-        values.average_maximum size
+      def self.peak_power(array, duration, size)
+        average_maximum = array.average_maximum size
+        peak_power = PeakPower.new(duration)
+        peak_power.start = average_maximum[:start]
+        peak_power.value = average_maximum[:value]
+        peak_power
       end
     
       def self.training_stress_score(duration_seconds, threshold_power)

data/lib/joule/csv.rb

@@ -1 +1,18 @@
-require 'joule/csv/parser'
+require 'fastercsv'
+require 'joule/csv/parser'
+
+module Joule
+  module CSV
+    FILE_EXTENSION = "csv"
+    
+    def CSV.parser(extension, data)
+      header = FasterCSV.parse(data).shift
+      if header[0].to_s.downcase.eql?("ibike")
+        Joule::IBike::Parser.new(data)
+      else
+        Joule::PowerTap::Parser.new(data)
+      end
+    end
+    
+  end
+end

data/lib/joule/csv/parser.rb

@@ -1,44 +1,11 @@
-require 'fastercsv'
-
 module Joule
   module CSV
-    class Parser
-      include Joule::Calculator::MarkerCalculator
-      include Joule::Calculator::PeakPowerCalculator
+    class Parser < Joule::Base::Parser
       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
+      def parse_workout()
         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
@@ -46,23 +13,6 @@ module Joule
         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

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

data/lib/joule/exception.rb

@@ -0,0 +1 @@
+require 'joule/exception/unsupported_file_type_exception.rb'