postrunner 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7079467bfe7e66fd8fd3f18f607a94aeabe9924
-  data.tar.gz: 501da89a9f177cde254dd0fe9170df23089ec387
+  metadata.gz: 99ae2bd8b3b82d191caf48131b2859c4f4e29720
+  data.tar.gz: ca9b0777ec1fe947bd2aeefa969b7c6e45d52d19
 SHA512:
-  metadata.gz: e12ab80e6e5ac8761cc5766d967a80f6e38d5fbd50a1a782ec3bbf40099a0fc0912a7b1878b2bba8a7b9d3f96b73c2fa47672e5987f1cd7d45db83b5173e00ac
-  data.tar.gz: 527efab9134703a38207197f2ad384cdbb6ba7ce242ce8f6ee589868f0b08c83fcd0229afcc6cebf928f88e27cad46abaa4b9e24ea1719009e99e1ac6b20f66f
+  metadata.gz: 89b8afc287b91f5f787e00da5b13642f2e2b86fd73296bd7d70580069698ce36c794773d16377d029eedb92f16293722c70605e79ab100c67442b51e4b7efd70
+  data.tar.gz: 2089af8448f6151f7d3dfd1a1e9ccfeaa4849fa59e1f9b3b30ea8df798ac8b673e639beb494d07aef40c234abe3999a39764523defacf3524e61ee0263cfc2d8

data/README.md

@@ -3,8 +3,11 @@
 PostRunner is an application to manage FIT files such as those
 produced by Garmin products like the Forerunner 620 (FR620) and Fenix
 3. It allows you to import the files from the device and inspect them.
-It can also update satellite orbit prediction (EPO) data on the device
-to speed-up fix times.
+In addition to the common features like plotting pace, heart rates,
+elevation and other captured values it also provides a heart rate
+variability (HRV) analysis. It can also update satellite orbit prediction
+(EPO) data on the device to speed-up fix times. It is an offline
+alternative to Garmin Connect.
 
 ## Installation
 

data/Rakefile

@@ -1,8 +1,24 @@
+$:.unshift File.join(File.dirname(__FILE__))
+
+# Add the lib directory to the search path if it isn't included already
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require 'rake/clean'
+require 'yard'
+YARD::Rake::YardocTask.new
 
-RSpec::Core::RakeTask.new
+Dir.glob( 'tasks/*.rake').each do |fn|
+  begin 
+    load fn;
+  rescue LoadError
+    puts "#{fn.split('/')[1]} tasks unavailable: #{$!}"
+  end
+end
 
-task :default => :spec
+task :default  => :spec
 task :test => :spec
 
+desc 'Run all unit and spec tests'

data/lib/postrunner/ActivitiesDB.rb

@@ -3,7 +3,7 @@
 #
 # = ActivitiesDB.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2014, 2015 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 2014, 2015, 2016 by Chris Schlaeger <cs@taskjuggler.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
@@ -68,7 +68,6 @@ module PostRunner
         NavButtonDef.new('record.png', "records-0.html")
       ])
 
-      @records = PersonalRecords.new(self)
       sync if sync_needed
     end
 
@@ -140,7 +139,6 @@ module PostRunner
       succ = successor(activity)
 
       @activities.delete(activity)
-      @records.delete_activity(activity)
 
       # The HTML activity views contain links to their predecessors and
       # successors. After deleting an activity, we need to re-generate these
@@ -167,16 +165,6 @@ module PostRunner
       sync
     end
 
-    def check
-      @records.delete_all_records
-      @activities.sort do |a1, a2|
-        a1.timestamp <=> a2.timestamp
-      end.each { |a| a.check }
-      @records.sync
-      # Ensure that HTML index is up-to-date.
-      ActivityListView.new(self).update_index_pages
-    end
-
     def ref_by_fit_file(fit_file)
       i = 1
       @activities.each do |activity|
@@ -278,14 +266,6 @@ module PostRunner
       puts ActivityListView.new(self).to_s
     end
 
-    def show_records
-      puts @records.to_s
-    end
-
-    def activity_records(activity)
-      @records.activity_records(activity)
-    end
-
     # Launch a web browser and show an HTML file.
     # @param html_file [String] file name of the HTML file to show
     def show_in_browser(html_file)
@@ -336,7 +316,6 @@ module PostRunner
         Log.fatal "Cannot write archive file '#{@archive_file}': #{$!}"
       end
 
-      @records.sync
       ActivityListView.new(self).update_index_pages
     end
 

data/lib/postrunner/Activity.rb

@@ -14,6 +14,7 @@ require 'fit4ruby'
 
 require 'postrunner/ActivitySummary'
 require 'postrunner/DataSources'
+require 'postrunner/EventList'
 require 'postrunner/ActivityView'
 require 'postrunner/Schema'
 require 'postrunner/QueryResult'
@@ -196,6 +197,11 @@ module PostRunner
       QueryResult.new(value, schema)
     end
 
+    def events
+      @fit_activity = load_fit_file unless @fit_activity
+      puts EventList.new(self, @db.cfg[:unit_system]).to_s
+    end
+
     def show
       generate_html_view #unless File.exists?(@html_file)
 
@@ -374,6 +380,21 @@ module PostRunner
       ActivitySubTypes[@sub_sport] || 'Undefined'
     end
 
+    def distance(timestamp, unit_system)
+      @fit_activity = load_fit_file unless @fit_activity
+
+      @fit_activity.records.each do |record|
+        if record.timestamp >= timestamp
+          unit = { :metric => 'km', :statute => 'mi'}[unit_system]
+          value = record.get_as('distance', unit)
+          return '-' unless value
+          return "#{'%.2f %s' % [value, unit]}"
+        end
+      end
+
+      '-'
+    end
+
     private
 
     def load_fit_file(filter = nil)

data/lib/postrunner/ActivityLink.rb

@@ -30,7 +30,7 @@ module PostRunner
       doc.unique(:activitylink_style) { doc.style(style) }
 
       doc.a(@activity.name, { :class => 'activity_link',
-                              :href => @activity.fit_file[0..-5] + '.html' })
+                              :href => @activity.html_file_name(false) })
       if @show_record_icon && @activity.has_records?
         doc.img(nil, { :src => 'icons/record-small.png',
                        :style => 'vertical-align:middle' })

data/lib/postrunner/ActivityListView.rb

@@ -24,12 +24,12 @@ module PostRunner
 
     include Fit4Ruby::Converters
 
-    def initialize(db)
-      @db = db
-      @unit_system = @db.cfg[:unit_system]
+    def initialize(ffs)
+      @ffs = ffs
+      @unit_system = @ffs.store['config']['unit_system']
       @page_size = 20
       @page_no = -1
-      @last_page = (@db.activities.length - 1) / @page_size
+      @last_page = (@ffs.activities.length - 1) / @page_size
     end
 
     def update_index_pages
@@ -46,7 +46,7 @@ module PostRunner
     private
 
     def generate_html_index_page(page_index)
-      views = @db.views
+      views = @ffs.views
       views.current_page = 'index.html'
 
       pages = PagingButtons.new((0..@last_page).map do |i|
@@ -59,7 +59,8 @@ module PostRunner
       @view.doc.head { @view.doc.style(style) }
       body(@view.doc)
 
-      output_file = File.join(@db.cfg[:html_dir], pages.current_page)
+      output_file = File.join(@ffs.store['config']['html_dir'],
+                              pages.current_page)
       @view.write(output_file)
     end
 
@@ -85,9 +86,9 @@ module PostRunner
         { :halign => :right }
       ])
       t.body
-      activities = @page_no == -1 ? @db.activities :
-        @db.activities[(@page_no * @page_size)..
-                       ((@page_no + 1) * @page_size - 1)]
+      activities = @page_no == -1 ? @ffs.activities :
+        @ffs.activities[(@page_no * @page_size)..
+                        ((@page_no + 1) * @page_size - 1)]
       activities.each do |a|
         t.row([
           i += 1,

data/lib/postrunner/ActivitySummary.rb

@@ -14,6 +14,8 @@ require 'fit4ruby'
 
 require 'postrunner/FlexiTable'
 require 'postrunner/ViewFrame'
+require 'postrunner/HRV_Analyzer'
+require 'postrunner/Percentiles'
 
 module PostRunner
 
@@ -79,29 +81,54 @@ module PostRunner
               "#{session.avg_heart_rate} bpm" : '-' ])
       t.row([ 'Max. HR:', session.max_heart_rate ?
               "#{session.max_heart_rate} bpm" : '-' ])
+      if @activity.sport == 'running' || @activity.sport == 'multisport'
+        t.row([ 'Avg. Run Cadence:',
+                session.avg_running_cadence ?
+                "#{(2 * session.avg_running_cadence).round} spm" : '-' ])
+        t.row([ 'Avg. Stride Length:',
+                local_value(session, 'avg_stride_length', '%.2f %s',
+                            { :metric => 'm', :statute => 'ft' }) ])
+        t.row([ 'Avg. Vertical Oscillation:',
+                local_value(session, 'avg_vertical_oscillation', '%.1f %s',
+                            { :metric => 'cm', :statute => 'in' }) ])
+        t.row([ 'Vertical Ratio:',
+                session.vertical_ratio ?
+                "#{session.vertical_ratio}%" : '-' ])
+        t.row([ 'Avg. Ground Contact Time:',
+                session.avg_stance_time ?
+                "#{session.avg_stance_time.round} ms" : '-' ])
+        t.row([ 'Avg. Ground Contact Time Balance:',
+                session.avg_gct_balance ?
+                "#{session.avg_gct_balance}% L / " +
+                "#{100.0 - session.avg_gct_balance}% R" : ';' ])
+      end
+      if @activity.sport == 'cycling'
+        t.row([ 'Avg. Cadence:',
+                session.avg_candence ?
+                "#{(2 * session.avg_candence).round} rpm" : '-' ])
+      end
+
       t.row([ 'Training Effect:', session.total_training_effect ?
               session.total_training_effect : '-' ])
-      t.row([ 'Avg. Run Cadence:',
-              session.avg_running_cadence ?
-              "#{(2 * session.avg_running_cadence).round} spm" : '-' ])
-      t.row([ 'Avg. Vertical Oscillation:',
-              local_value(session, 'avg_vertical_oscillation', '%.1f %s',
-                          { :metric => 'cm', :statute => 'in' }) ])
-      t.row([ 'Avg. Ground Contact Time:',
-              session.avg_stance_time ?
-              "#{session.avg_stance_time.round} ms" : '-' ])
-      t.row([ 'Avg. Stride Length:',
-              local_value(session, 'avg_stride_length', '%.2f %s',
-                          { :metric => 'm', :statute => 'ft' }) ])
+
+      rec_info = @fit_activity.recovery_info
+      t.row([ 'Ignored Recovery Time:',
+              rec_info ? secsToDHMS(rec_info * 60) : '-' ])
+
       rec_hr = @fit_activity.recovery_hr
       end_hr = @fit_activity.ending_hr
       t.row([ 'Recovery HR:',
               rec_hr && end_hr ?
               "#{rec_hr} bpm [#{end_hr - rec_hr} bpm]" : '-' ])
+
       rec_time = @fit_activity.recovery_time
-      t.row([ 'Recovery Time:', rec_time ? secsToHMS(rec_time * 60) : '-' ])
-      vo2max = @fit_activity.vo2max
-      t.row([ 'VO2max:', vo2max ? vo2max : '-' ])
+      t.row([ 'Suggested Recovery Time:',
+              rec_time ? secsToDHMS(rec_time * 60) : '-' ])
+
+      hrv = HRV_Analyzer.new(@fit_activity)
+      if hrv.has_hrv_data?
+        t.row([ 'HRV Score:', "%.1f" % hrv.lnrmssdx20_1sigma ])
+      end
 
       t
     end

data/lib/postrunner/ActivityView.rb

@@ -14,7 +14,9 @@ require 'fit4ruby'
 
 require 'postrunner/View'
 require 'postrunner/ActivitySummary'
+require 'postrunner/EventList'
 require 'postrunner/DeviceList'
+require 'postrunner/DataSources'
 require 'postrunner/UserProfileView'
 require 'postrunner/TrackView'
 require 'postrunner/ChartView'
@@ -25,26 +27,25 @@ module PostRunner
 
     def initialize(activity, unit_system)
       @activity = activity
-      db = @activity.db
+      ffs = @activity.store['file_store']
       @unit_system = unit_system
 
-      views = db.views
+      views = ffs.views
       views.current_page = nil
 
       # Sort activities in reverse order so the newest one is considered the
       # last report by the pagin buttons.
-      activities = db.activities.sort do |a1, a2|
+      activities = ffs.activities.sort do |a1, a2|
         a1.timestamp <=> a2.timestamp
       end
 
-      pages = PagingButtons.new(activities.map do |a|
-        "#{a.fit_file[0..-5]}.html"
-      end, false)
-      pages.current_page = "#{@activity.fit_file[0..-5]}.html"
+      pages = PagingButtons.new(
+        activities.map { |a| a.html_file_name(false) }, false)
+      pages.current_page = @activity.html_file_name(false)
 
       super("PostRunner Activity: #{@activity.name}", views, pages)
       generate_html(@doc)
-      write(File.join(db.cfg[:html_dir], pages.current_page))
+      write(@activity.html_file_name)
     end
 
     private
@@ -73,6 +74,7 @@ module PostRunner
             }
             doc.div({ :class => 'right_col' }) {
               ChartView.new(@activity, @unit_system).to_html(doc)
+              EventList.new(@activity, @unit_system).to_html(doc)
             }
           }
           doc.div({ :class => 'two_col' }) {

data/lib/postrunner/ChartView.rb

@@ -10,6 +10,8 @@
 # published by the Free Software Foundation.
 #
 
+require 'postrunner/HRV_Analyzer'
+
 module PostRunner
 
   class ChartView
@@ -19,6 +21,137 @@ module PostRunner
       @sport = activity.sport
       @unit_system = unit_system
       @empty_charts = {}
+      @hrv_analyzer = HRV_Analyzer.new(@activity.fit_activity)
+
+      @charts = [
+        {
+          :id => 'pace',
+          :label => 'Pace',
+          :unit => select_unit('min/km'),
+          :graph => :line_graph,
+          :colors => '#0A7BEE',
+          :show => @sport == 'running' || @sport = 'multisport',
+        },
+        {
+          :id => 'speed',
+          :label => 'Speed',
+          :unit => select_unit('km/h'),
+          :graph => :line_graph,
+          :colors => '#0A7BEE',
+          :show => @sport != 'running'
+        },
+        {
+          :id => 'altitude',
+          :label => 'Elevation',
+          :unit => select_unit('m'),
+          :graph => :line_graph,
+          :colors => '#5AAA44',
+          :show => @activity.sub_sport != 'treadmill'
+        },
+        {
+          :id => 'heart_rate',
+          :label => 'Heart Rate',
+          :unit => 'bpm',
+          :graph => :line_graph,
+          :colors => '#900000',
+          :show => true
+        },
+        {
+          :id => 'hrv',
+          :label => 'Heart Rate Variability',
+          :short_label => 'HRV',
+          :unit => 'ms',
+          :graph => :line_graph,
+          :colors => '#900000',
+          :show => @hrv_analyzer.has_hrv_data?
+        },
+        {
+          :id => 'hrv_score',
+          :label => 'HRV Score (30s Window)',
+          :short_label => 'HRV Score',
+          :graph => :line_graph,
+          :colors => '#900000',
+          :show => false
+        },
+        {
+          :id => 'run_cadence',
+          :label => 'Run Cadence',
+          :unit => 'spm',
+          :graph => :point_graph,
+          :colors => [ [ '#EE3F2D', 151 ], [ '#F79666', 163 ],
+                       [ '#A0D488', 174 ], [ '#96D7DE', 185 ],
+                       [ '#A88BBB', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'stride_length',
+          :label => 'Stride Length',
+          :unit => select_unit('m'),
+          :graph => :point_graph,
+          :colors => [ ['#506DE1', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'vertical_oscillation',
+          :label => 'Vertical Oscillation',
+          :short_label => 'Vert. Osc.',
+          :unit => select_unit('cm'),
+          :graph => :point_graph,
+          :colors => [ [ '#A88BBB', 67 ], [ '#96D7DE', 84 ],
+                       [ '#A0D488', 101 ], [ '#F79666', 118 ],
+                       [ '#EE3F2D', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'vertical_ratio',
+          :label => 'Vertical Ratio',
+          :unit => '%',
+          :graph => :point_graph,
+          :colors => [ [ '#CF45BD', 6.1 ], [ '#4FBEED', 7.4 ],
+                       [ '#6AB03A', 8.6 ], [ '#EDA14F', 10.1 ],
+                       [ '#FF5558', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'stance_time',
+          :label => 'Ground Contact Time',
+          :short_label => 'GCT',
+          :unit => 'ms',
+          :graph => :point_graph,
+          :colors => [ [ '#A88BBB', 208 ], [ '#96D7DE', 241 ],
+                       [ '#A0D488', 273 ], [ '#F79666', 305 ],
+                       [ '#EE3F2D', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'gct_balance',
+          :label => 'Ground Contact Time Balance',
+          :short_label => 'GCT Balance',
+          :unit => '%',
+          :graph => :point_graph,
+          :colors => [ [ '#FF5558', 47.8 ], [ '#EDA14F', 49.2 ],
+                       [ '#6AB03A', 50.7 ], [ '#EDA14F', 52.2 ],
+                       [ '#FF5558', nil ] ],
+          :show => @sport == 'running' || @sport == 'multisport'
+        },
+        {
+          :id => 'cadence',
+          :label => 'Cadence',
+          :unit => 'rpm',
+          :graph => :line_graph,
+          :colors => '#A88BBB',
+          :show => @sport == 'cycling'
+        },
+        {
+          :id => 'temperature',
+          :label => 'Temperature',
+          :short_label => 'Temp.',
+          :unit => 'C',
+          :graph => :line_graph,
+          :colors => '#444444',
+          :show => true
+        }
+      ]
     end
 
     def to_html(doc)
@@ -34,19 +167,10 @@ module PostRunner
       }
 
       doc.script(java_script)
-      if @sport == 'running' || @sport == 'multisport'
-        chart_div(doc, 'pace', "Pace (#{select_unit('min/km')})")
+      @charts.each do |chart|
+        label = chart[:label] + (chart[:unit] ? " (#{chart[:unit]})" : '')
+        chart_div(doc, chart[:id], label) if chart[:show]
       end
-      if @sport != 'running'
-        chart_div(doc, 'speed', "Speed (#{select_unit('km/h')})")
-      end
-      chart_div(doc, 'altitude', "Elevation (#{select_unit('m')})")
-      chart_div(doc, 'heart_rate', 'Heart Rate (bpm)')
-      chart_div(doc, 'run_cadence', 'Run Cadence (spm)')
-      chart_div(doc, 'vertical_oscillation',
-                "Vertical Oscillation (#{select_unit('cm')})")
-      chart_div(doc, 'stance_time', 'Ground Contact Time (ms)')
-      chart_div(doc, 'temperature', 'Temperature (°C)')
     end
 
     private
@@ -56,8 +180,10 @@ module PostRunner
       when :metric
         metric_unit
       when :statute
-        { 'min/km' => 'min/mi', 'm' => 'ft', 'cm' => 'in', 'km/h' => 'mph',
-          'bpm' => 'bpm', 'spm' => 'spm', 'ms' => 'ms' }[metric_unit]
+        { 'min/km' => 'min/mi', 'km/h' => 'mph',
+          'mm' => 'in', 'cm' => 'in', 'm' => 'ft',
+          'bpm' => 'bpm', 'rpm' => 'rpm', 'spm' => 'spm', '%' => '%',
+          'ms' => 'ms' }[metric_unit]
       else
         Log.fatal "Unknown unit system #{@unit_system}"
       end
@@ -97,33 +223,9 @@ EOT
       s = "$(function() {\n"
 
       s << tooltip_div
-      if @sport == 'running' || @sport == 'multisport'
-        s << line_graph('pace', 'Pace', 'min/km', '#0A7BEE' )
-      end
-      if @sport != 'running'
-        s << line_graph('speed', 'Speed', 'km/h', '#0A7BEE' )
+      @charts.each do |chart|
+        s << send(chart[:graph], chart) if chart[:show]
       end
-      s << line_graph('altitude', 'Elevation', 'm', '#5AAA44')
-      s << line_graph('heart_rate', 'Heart Rate', 'bpm', '#900000')
-      s << point_graph('run_cadence', 'Run Cadence', 'spm',
-                       [ [ '#EE3F2D', 151 ],
-                         [ '#F79666', 163 ],
-                         [ '#A0D488', 174 ],
-                         [ '#96D7DE', 185 ],
-                         [ '#A88BBB', nil ] ])
-      s << point_graph('vertical_oscillation', 'Vertical Oscillation', 'cm',
-                       [ [ '#A88BBB', 67 ],
-                         [ '#96D7DE', 84 ],
-                         [ '#A0D488', 101 ],
-                         [ '#F79666', 118 ],
-                         [ '#EE3F2D', nil ] ])
-      s << point_graph('stance_time', 'Ground Contact Time', 'ms',
-                       [ [ '#A88BBB', 208 ],
-                         [ '#96D7DE', 241 ],
-                         [ '#A0D488', 273 ],
-                         [ '#F79666', 305 ],
-                         [ '#EE3F2D', nil ] ])
-      s << line_graph('temperature', 'Temperature', 'C', '#444444')
 
       s << "\n});\n"
 
@@ -158,35 +260,54 @@ EOT
 EOT
     end
 
-    def line_graph(field, y_label, unit, color = nil)
-      s = "var #{field}_data = [\n"
+    def line_graph(chart)
+      s = "var #{chart[:id]}_data = [\n"
 
       data_set = []
       start_time = @activity.fit_activity.sessions[0].start_time.to_i
       min_value = nil
-      @activity.fit_activity.records.each do |r|
-        value = r.get_as(field, select_unit(unit))
-
-        next unless value
-
-        if field == 'pace'
-          # Slow speeds lead to very large pace values that make the graph
-          # hard to read. We cap the pace at 20.0 min/km to keep it readable.
-          if value > (@unit_system == :metric ? 20.0 : 36.0 )
-            value = nil
+      if chart[:id] == 'hrv_score'
+        0.upto(@hrv_analyzer.total_duration.to_i - 30) do |t|
+          next unless (hrv_score = @hrv_analyzer.lnrmssdx20(t, 30)) > 0.0
+          min_value = hrv_score if min_value.nil? || min_value > hrv_score
+          data_set << [ t * 1000, hrv_score ]
+        end
+      elsif chart[:id] == 'hrv'
+        1.upto(@hrv_analyzer.rr_intervals.length - 1) do |idx|
+          curr_intvl = @hrv_analyzer.rr_intervals[idx]
+          prev_intvl = @hrv_analyzer.rr_intervals[idx - 1]
+          next unless curr_intvl && prev_intvl
+
+          # Convert the R-R interval duration to ms.
+          dt = (curr_intvl - prev_intvl) * 1000.0
+          min_value = dt if min_value.nil? || min_value > dt
+          data_set << [ @hrv_analyzer.timestamps[idx] * 1000, dt ]
+        end
+      else
+        @activity.fit_activity.records.each do |r|
+          value = r.get_as(chart[:id], chart[:unit] || '')
+
+          next unless value
+
+          if chart[:id] == 'pace'
+            # Slow speeds lead to very large pace values that make the graph
+            # hard to read. We cap the pace at 20.0 min/km to keep it readable.
+            if value > (@unit_system == :metric ? 20.0 : 36.0 )
+              value = nil
+            else
+              value = (value * 3600.0 * 1000).to_i
+            end
+            min_value = 0.0
           else
-            value = (value * 3600.0 * 1000).to_i
+            min_value = value if (min_value.nil? || min_value > value)
           end
-          min_value = 0.0
-        else
-          min_value = value if (min_value.nil? || min_value > value)
+          data_set << [ ((r.timestamp.to_i - start_time) * 1000).to_i, value ]
         end
-        data_set << [ ((r.timestamp.to_i - start_time) * 1000).to_i, value ]
       end
 
       # We don't want to plot charts with all nil values.
       unless data_set.find { |v| v[1] != nil }
-        @empty_charts[field] = true
+        @empty_charts[chart[:id]] = true
         return ''
       end
       s << data_set.map do |set|
@@ -196,17 +317,17 @@ EOT
 
       s << lap_marks(start_time)
 
-      chart_id = "#{field}_chart"
+      chart_id = "#{chart[:id]}_chart"
       s << <<"EOT"
 	  	var plot = $.plot(\"##{chart_id}\",
-             [ { data: #{field}_data,
-                 #{color ? "color: \"#{color}\"," : ''}
-                 lines: { show: true#{field == 'pace' ? '' :
+             [ { data: #{chart[:id]}_data,
+                 #{chart[:colors] ? "color: \"#{chart[:colors]}\"," : ''}
+                 lines: { show: true#{chart[:id] == 'pace' ? '' :
                                       ', fill: true'} } } ],
              { xaxis: { mode: "time" },
                grid: { markings: lap_marks, hoverable: true }
 EOT
-      if field == 'pace'
+      if chart[:id] == 'pace'
         s << ", yaxis: { mode: \"time\",\n" +
              "           transform: function (v) { return -v; },\n" +
              "           inverseTransform: function (v) { return -v; } }"
@@ -216,34 +337,35 @@ EOT
       end
       s << "});\n"
       s << lap_mark_labels(chart_id, start_time)
-      s << hover_function(chart_id, y_label, select_unit(unit)) + "\n"
+      s << hover_function(chart_id, chart[:short_label] || chart[:label],
+                          select_unit(chart[:unit] || '')) + "\n"
     end
 
-    def point_graph(field, y_label, unit, colors)
-      # We need to split the field values into separate data sets for each
+    def point_graph(chart)
+      # We need to split the y-values into separate data sets for each
       # color. The max value for each color determines which set a data point
       # ends up in.
       # Initialize the data sets. The key for data_sets is the corresponding
       # index in colors.
       data_sets = {}
-      colors.each.with_index { |cp, i| data_sets[i] = [] }
+      chart[:colors].each.with_index { |cp, i| data_sets[i] = [] }
 
-      # Now we can split the field values into the sets.
+      # Now we can split the y-values into the sets.
       start_time = @activity.fit_activity.sessions[0].start_time.to_i
       @activity.fit_activity.records.each do |r|
         # Undefined values will be discarded.
-        next unless (value = r.send(field))
+        next unless (value = r.send(chart[:id]))
 
         # Find the right set by looking at the maximum allowed values for each
         # color.
-        colors.each.with_index do |col_max_value, i|
+        chart[:colors].each.with_index do |col_max_value, i|
           col, range_max_value = col_max_value
           if range_max_value.nil? || value < range_max_value
             # A range_max_value of nil means all values allowed. The value is
             # in the allowed range for this set, so add the value as x/y pair
             # to the set.
             x_val = (r.timestamp.to_i - start_time) * 1000
-            data_sets[i] << [ x_val, r.get_as(field, select_unit(unit)) ]
+            data_sets[i] << [ x_val, r.get_as(chart[:id], chart[:unit] || '') ]
             # Abort the color loop since we've found the right set already.
             break
           end
@@ -252,32 +374,35 @@ EOT
 
       # We don't want to plot charts with all nil values.
       if data_sets.values.flatten.empty?
-        @empty_charts[field] = true
+        @empty_charts[chart[:id]] = true
         return ''
       end
 
       # Now generate the JS variable definitions for each set.
       s = ''
       data_sets.each do |index, ds|
-        s << "var #{field}_data_#{index} = [\n"
+        s << "var #{chart[:id]}_data_#{index} = [\n"
         s << ds.map { |dp| "[ #{dp[0]}, #{dp[1]} ]" }.join(', ')
         s << " ];\n"
       end
 
       s << lap_marks(start_time)
 
-      chart_id = "#{field}_chart"
+      chart_id = "#{chart[:id]}_chart"
       s << "var plot = $.plot(\"##{chart_id}\", [\n"
       s << data_sets.map do |index, ds|
-             "{ data: #{field}_data_#{index},\n" +
-             "  color: \"#{colors[index][0]}\",\n" +
-             "  points: { show: true, fillColor: \"#{colors[index][0]}\", " +
+             "{ data: #{chart[:id]}_data_#{index},\n" +
+             "  color: \"#{chart[:colors][index][0]}\",\n" +
+             "  points: { show: true, " +
+             "            fillColor: \"#{chart[:colors][index][0]}\", " +
              "            fill: true, radius: 2 } }"
            end.join(', ')
-      s << "], { xaxis: { mode: \"time\" },
-                 grid: { markings: lap_marks, hoverable: true } });\n"
+      s << "], { xaxis: { mode: \"time\" }, " +
+           (chart[:id] == 'gct_balance' ? gct_balance_yaxis(data_sets) : '') +
+           "     grid: { markings: lap_marks, hoverable: true } });\n"
       s << lap_mark_labels(chart_id, start_time)
-      s << hover_function(chart_id, y_label, select_unit(unit))
+      s << hover_function(chart_id, chart[:short_label] || chart[:label],
+                          select_unit(chart[:unit] || ''))
 
       s
     end
@@ -337,6 +462,39 @@ EOT
       s
     end
 
+    def gct_balance_yaxis(data_set)
+      # Decompose hash of array with x/y touples into a flat array of just y
+      # values.
+      yvalues = data_set.values.flatten(1).map { |touple| touple[1] }
+      # Find the largest and smallest value and round it up and down to the
+      # next Fixnum.
+      max = yvalues.max.ceil
+      min = yvalues.min.floor
+      # Ensure that the range 49 - 51 is always included.
+      max = 51.0 if max < 51.0
+      min = 49.0 if min > 49.0
+      # The graph is large to fit 6 ticks quite nicely.
+      tick_step = ((max - min) / 6.0).ceil
+      # Generate an Array with the tick values
+      tick_values = (0..5).to_a.map { |i| min + i * tick_step }
+      # Remove values that are larger than max
+      tick_values.delete_if { |v| v > max }
+      # Generate an Array of tick/label touples
+      ticks = []
+      tick_labels = tick_values.each do |value|
+        label = if value < 50
+                  "#{100 - value}%R"
+                elsif value > 50
+                  "#{value}%L"
+                else
+                  '50/50'
+                end
+        ticks << [ value, label ]
+      end
+      # Convert the tick/label Array into a Flot yaxis definition.
+      "yaxis: { ticks: #{ticks.inspect} }, "
+    end
+
   end
 
 end