postrunner 0.0.11 → 0.1.0

data/lib/postrunner/HRV_Analyzer.rb

@@ -0,0 +1,178 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = HRV_Analyzer.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2015 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
+# published by the Free Software Foundation.
+#
+
+require 'postrunner/LinearPredictor'
+
+module PostRunner
+
+  # This class analyzes the heart rate variablity based on the R-R intervals
+  # in the given FIT file. It can compute RMSSD and a HRV score if the data
+  # quality is good enough.
+  class HRV_Analyzer
+
+    attr_reader :rr_intervals, :timestamps
+
+    # Create a new HRV_Analyzer object.
+    # @param fit_file [Fit4Ruby::Activity] FIT file to analyze.
+    def initialize(fit_file)
+      @fit_file = fit_file
+      collect_rr_intervals
+    end
+
+    # The method can be used to check if we have valid HRV data. The FIT file
+    # must have HRV data and the measurement duration must be at least 30
+    # seconds.
+    def has_hrv_data?
+      !@fit_file.hrv.empty? && total_duration > 30.0
+    end
+
+    # Return the total duration of all measured intervals in seconds.
+    def total_duration
+      @timestamps[-1]
+    end
+
+    # Compute the root mean square of successive differences.
+    # @param start_time [Float] Determines at what time mark (in seconds) the
+    #        computation should start.
+    # @param duration [Float] The duration of the total inteval in seconds to
+    #        be considered for the computation. This value should be larger
+    #        then 30 seconds to produce meaningful values.
+    def rmssd(start_time = 0.0, duration = nil)
+      # Find the start index based on the requested interval start time.
+      start_idx = 0
+      @timestamps.each do |ts|
+        break if ts >= start_time
+        start_idx += 1
+      end
+      # Find the end index based on the requested interval duration.
+      if duration
+        end_time = start_time + duration
+        end_idx = start_idx
+        while end_idx < (@timestamps.length - 1) &&
+              @timestamps[end_idx] < end_time
+          end_idx += 1
+        end
+      else
+        end_idx = -1
+      end
+
+      last_i = nil
+      sum = 0.0
+      cnt = 0
+      @rr_intervals[start_idx..end_idx].each do |i|
+        if i && last_i
+          sum += (last_i - i) ** 2.0
+          cnt += 1
+        end
+        last_i = i
+      end
+
+      Math.sqrt(sum / cnt)
+    end
+
+    # The RMSSD value is not very easy to memorize. Alternatively, we can
+    # multiply the natural logarithm of RMSSD by -20. This usually results in
+    # values between 1.0 (for untrained) and 100.0 (for higly trained)
+    # athletes. Values larger than 100.0 are rare but possible.
+    # @param start_time [Float] Determines at what time mark (in seconds) the
+    #        computation should start.
+    # @param duration [Float] The duration of the total inteval in seconds to
+    #        be considered for the computation. This value should be larger
+    #        then 30 seconds to produce meaningful values.
+    def lnrmssdx20(start_time = 0.0, duration = nil)
+      -20.0 * Math.log(rmssd(start_time, duration))
+    end
+
+    # This method is similar to lnrmssdx20 but it tries to search the data for
+    # the best time period to compute the lnrmssdx20 value from.
+    def lnrmssdx20_1sigma
+      # Create a new Array that consists of rr_intervals and timestamps
+      # tuples.
+      set = []
+      0.upto(@rr_intervals.length - 1) do |i|
+        set << [ @rr_intervals[i] ? @rr_intervals[i] : 0.0, @timestamps[i] ]
+      end
+
+      percentiles = Percentiles.new(set)
+      # Compile a list of all tuples with rr_intervals that are outside of the
+      # PT84 (aka +1sigma range. Sort the list by time.
+      not_1sigma = percentiles.not_tp_x(84.13).sort { |e1, e2| e1[1] <=> e2[1] }
+
+      # Then find the largest time gap in that list. So all the values in that
+      # gap are within TP84.
+      gap_start = gap_end = 0
+      last = nil
+      not_1sigma.each do |e|
+        if last
+          if (e[1] - last) > (gap_end - gap_start)
+            gap_start = last
+            gap_end = e[1]
+          end
+        end
+        last = e[1]
+      end
+      # That gap should be at least 30 seconds long. Otherwise we'll just use
+      # all the values.
+      return lnrmssdx20 if gap_end - gap_start < 30
+
+      lnrmssdx20(gap_start, gap_end - gap_start)
+    end
+
+    private
+
+    def collect_rr_intervals
+      # The rr_intervals Array stores the beat-to-beat time intervals (R-R).
+      # If one or move beats have been skipped during measurement, a nil value
+      # is inserted.
+      @rr_intervals = []
+      # The timestamps Array stores the relative (to start of sequence) time
+      # for each interval in the rr_intervals Array.
+      @timestamps = []
+
+      # Each Fit4Ruby::HRV object has an Array called 'time' that contains up
+      # to 5 R-R interval durations. If less than 5 are present, they are
+      # filled with nil.
+      raw_rr_intervals = []
+      @fit_file.hrv.each do |hrv|
+        raw_rr_intervals += hrv.time.compact
+      end
+      return if raw_rr_intervals.empty?
+
+      window = 20
+      intro_mean = raw_rr_intervals[0..4 * window].reduce(:+) / (4 * window)
+      predictor = LinearPredictor.new(window, intro_mean)
+
+      # The timer accumulates the interval durations.
+      timer = 0.0
+      raw_rr_intervals.each do |dt|
+        timer += dt
+        @timestamps << timer
+
+        # Sometimes the hrv data is missing one or more beats. The next
+        # detected beat is than listed with the time interval since the last
+        # detected beat. We try to detect these skipped beats by looking for
+        # time intervals that are 1.5 or more times larger than the predicted
+        # value for this interval.
+        if (next_dt = predictor.predict) && dt > 1.5 * next_dt
+          @rr_intervals << nil
+        else
+          @rr_intervals << dt
+          # Feed the value into the predictor.
+          predictor.insert(dt)
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/postrunner/LinearPredictor.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = LinearPredictor.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2015 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
+# published by the Free Software Foundation.
+#
+
+module PostRunner
+
+  # For now we use a trivial adaptive linear predictor that just uses the
+  # average of past values to predict the next value.
+  class LinearPredictor
+
+    # Create a new LinearPredictor object.
+    # @param n [Fixnum] The number of coefficients the predictor should use.
+    def initialize(n, default = nil)
+      @values = Array.new(n, default)
+      @size = n
+      @next = nil
+    end
+
+    # Tell the predictor about the actual next value.
+    # @param value [Float] next value
+    def insert(value)
+      @values << value
+
+      if @values.length > @size
+        @values.shift
+        @next = @values.reduce(:+) / @size
+      end
+    end
+
+    # @return [Float] The predicted value of the next sample.
+    def predict
+      @next
+    end
+
+  end
+
+end
+

data/lib/postrunner/Main.rb

@@ -3,7 +3,7 @@
 #
 # = Main.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
@@ -16,7 +16,10 @@ require 'perobs'
 
 require 'postrunner/version'
 require 'postrunner/Log'
+require 'postrunner/DirUtils'
 require 'postrunner/RuntimeConfig'
+require 'postrunner/FitFileStore'
+require 'postrunner/PersonalRecords'
 require 'postrunner/ActivitiesDB'
 require 'postrunner/MonitoringDB'
 require 'postrunner/EPO_Downloader'
@@ -25,20 +28,40 @@ module PostRunner
 
   class Main
 
+    include DirUtils
+
     def initialize(args)
       @filter = nil
       @name = nil
+      @force = false
       @attribute = nil
       @value = nil
-      @activities = nil
-      @monitoring = nil
       @db_dir = File.join(ENV['HOME'], '.postrunner')
 
       return if (args = parse_options(args)).nil?
 
-      @cfg = RuntimeConfig.new(@db_dir)
+      create_directory(@db_dir, 'PostRunner data')
       @db = PEROBS::Store.new(File.join(@db_dir, 'database'))
+      # Create a hash to store configuration data in the store unless it
+      # exists already.
+      cfg = (@db['config'] ||= @db.new(PEROBS::Hash))
+      cfg['unit_system'] ||= :metric
+      cfg['version'] ||= VERSION
+      # We always override the data_dir as the user might have moved the data
+      # directory. The only reason we store it in the DB is to have it
+      # available throught the application.
+      cfg['data_dir'] = @db_dir
+      # Always update html_dir setting so that the DB directory can be moved
+      # around by the user.
+      cfg['html_dir'] = File.join(@db_dir, 'html')
+
+      setup_directories
+      if (errors = @db.check) != 0
+        Log.fatal "Postrunner database is corrupted: #{errors} errors found"
+      end
       execute_command(args)
+
+      @db.sync
     end
 
     private
@@ -81,6 +104,11 @@ EOT
           @filter = Fit4Ruby::FitFilter.new unless @filter
           @filter.ignore_undef = true
         end
+        opts.on('--force',
+                'Import files even if they have been deleted from the ' +
+                'database before.') do
+          @force = true
+        end
 
         opts.separator ""
         opts.separator "Options for the 'import' command:"
@@ -104,7 +132,7 @@ EOT
           return nil
         end
         opts.on('--version', 'Show version number') do
-          $stderr.puts VERSION
+          puts VERSION
           return nil
         end
 
@@ -119,6 +147,9 @@ check [ <fit file> | <ref> ... ]
 dump <fit file> | <ref>
            Dump the content of the FIT file.
 
+events [ <ref> ]
+           List all the events of the specified activies.
+
 import [ <fit file> | <directory> ]
            Import the provided FIT file(s) into the postrunner database. If no
            file or directory is provided, the directory that was used for the
@@ -187,16 +218,50 @@ EOT
       end
     end
 
+    def setup_directories
+      create_directory(@db['config']['html_dir'], 'HTML output')
+
+      %w( icons jquery flot openlayers postrunner ).each do |dir|
+        # This file should be in lib/postrunner. The 'misc' directory should be
+        # found in '../../misc'.
+        misc_dir = File.realpath(File.join(File.dirname(__FILE__),
+                                           '..', '..', 'misc'))
+        unless Dir.exists?(misc_dir)
+          Log.fatal "Cannot find 'misc' directory under '#{misc_dir}': #{$!}"
+        end
+        src_dir = File.join(misc_dir, dir)
+        unless Dir.exists?(src_dir)
+          Log.fatal "Cannot find '#{src_dir}': #{$!}"
+        end
+        dst_dir = @db['config']['html_dir']
+
+        begin
+          FileUtils.cp_r(src_dir, dst_dir)
+        rescue IOError
+          Log.fatal "Cannot copy auxilliary data directory '#{dst_dir}': #{$!}"
+        end
+      end
+    end
+
     def execute_command(args)
-      @activities = ActivitiesDB.new(@db_dir, @cfg)
-      @monitoring = MonitoringDB.new(@db, @cfg)
+      # Create or load the FitFileStore data.
+      unless (@ffs = @db['file_store'])
+        @ffs = @db['file_store'] = @db.new(FitFileStore)
+      end
+      # Create or load the PersonalRecords data.
+      unless (@records = @db['records'])
+        @records = @db['records'] = @db.new(PersonalRecords)
+      end
       handle_version_update
+      import_legacy_archive
 
       case (cmd = args.shift)
       when 'check'
         if args.empty?
-          @activities.check
-          @activities.generate_all_html_reports
+          @ffs.check
+          Log.info "Datebase cleanup started. Please wait ..."
+          @db.gc
+          Log.info "Database cleanup finished"
         else
           process_files_or_activities(args, :check)
         end
@@ -205,23 +270,25 @@ EOT
       when 'dump'
         @filter = Fit4Ruby::FitFilter.new unless @filter
         process_files_or_activities(args, :dump)
+      when 'events'
+        process_files_or_activities(args, :events)
       when 'import'
         if args.empty?
           # If we have no file or directory for the import command, we get the
           # most recently used directory from the runtime config.
-          process_files([ @cfg.get_option(:import_dir) ], :import)
+          process_files([ @db['config']['import_dir']  ], :import)
         else
           process_files(args, :import)
           if args.length == 1 && Dir.exists?(args[0])
             # If only one directory was specified as argument we store the
             # directory for future use.
-            @cfg.set_option(:import_dir, args[0])
+            @db['config']['import_dir'] = args[0]
           end
         end
       when 'list'
-        @activities.list
+        @ffs.list_activities
       when 'records'
-        @activities.show_records
+        puts @records.to_s
       when 'rename'
         unless (@name = args.shift)
           Log.fatal 'You must provide a new name for the activity'
@@ -237,7 +304,7 @@ EOT
         process_activities(args, :set)
       when 'show'
         if args.empty?
-          @activities.show_list_in_browser
+          @ffs.show_list_in_browser
         else
           process_activities(args, :show)
         end
@@ -277,7 +344,7 @@ EOT
 
       activity_refs.each do |a_ref|
         if a_ref[0] == ':'
-          activities = @activities.find(a_ref[1..-1])
+          activities = @ffs.find(a_ref[1..-1])
           if activities.empty?
             Log.warn "No matching activities found for '#{a_ref}'"
             return
@@ -287,6 +354,8 @@ EOT
           Log.fatal "Activity references must start with ':': #{a_ref}"
         end
       end
+
+      nil
     end
 
     def process_files(files_or_dirs, command)
@@ -334,9 +403,9 @@ EOT
       end
 
       if fit_entity.is_a?(Fit4Ruby::Activity)
-        return @activities.add(fit_file_name, fit_entity)
-      elsif fit_entity.is_a?(Fit4Ruby::Monitoring_B)
-        return @monitoring.add(fit_file_name, fit_entity)
+        return @ffs.add_fit_file(fit_file_name, fit_entity, @force)
+      #elsif fit_entity.is_a?(Fit4Ruby::Monitoring_B)
+      #  return @monitoring.add(fit_file_name, fit_entity)
       else
         Log.error "#{fit_file_name} is not a recognized FIT file"
         return false
@@ -348,13 +417,15 @@ EOT
       when :check
         activity.check
       when :delete
-        @activities.delete(activity)
+        @ffs.delete_activity(activity)
       when :dump
         activity.dump(@filter)
+      when :events
+        activity.events
       when :rename
-        @activities.rename(activity, @name)
+        @ffs.rename_activity(activity, @name)
       when :set
-        @activities.set(activity, @attribute, @value)
+        @ffs.set_activity_attribute(activity, @attribute, @value)
       when :show
         activity.show
       when :sources
@@ -375,9 +446,9 @@ EOT
         Log.fatal("You must specify 'metric' or 'statute' as unit system.")
       end
 
-      if @cfg[:unit_system].to_s != args[0]
-        @cfg.set_option(:unit_system, args[0].to_sym)
-        @activities.generate_all_html_reports
+      if @db['config']['unit_system'].to_s != args[0]
+        @db['config']['unit_system'] = args[0].to_sym
+        @ffs.change_unit_system
       end
     end
 
@@ -386,16 +457,16 @@ EOT
         Log.fatal('You must specify a directory')
       end
 
-      if @cfg[:html_dir] != args[0]
-        @cfg.set_option(:html_dir, args[0])
-        @activities.create_directories
-        @activities.generate_all_html_reports
+      if @db['config']['html_dir'] != args[0]
+        @db['config']['html_dir'] =  args[0]
+        @ffs.create_directories
+        @ffs.generate_all_html_reports
       end
     end
 
     def update_gps_data
       epo_dir = File.join(@db_dir, 'epo')
-      @cfg.create_directory(epo_dir, 'GPS Data Cache')
+      create_directory(epo_dir, 'GPS Data Cache')
       epo_file = File.join(epo_dir, 'EPO.BIN')
 
       if !File.exists?(epo_file) ||
@@ -403,7 +474,7 @@ EOT
         # The EPO file only changes every 6 hours. No need to download it more
         # frequently if it already exists.
         if EPO_Downloader.new.download(epo_file)
-          unless (remotesw_dir = @cfg[:import_dir])
+          unless (remotesw_dir = @db['config']['import_dir'])
             Log.error "No device directory set. Please import an activity " +
                       "from your device first."
             return
@@ -426,14 +497,45 @@ EOT
     end
 
     def handle_version_update
-      if @cfg.get_option(:version) != VERSION
+      if @db['config']['version'] != VERSION
         Log.warn "PostRunner version upgrade detected."
-        @activities.handle_version_update
-        @cfg.set_option(:version, VERSION)
+        @ffs.handle_version_update
+        @db['config']['version'] = VERSION
         Log.info "Version upgrade completed."
       end
     end
 
+    # Earlier versions of PostRunner used a YAML file to store the activity
+    # data. This method transfers the data from the old storage to the new
+    # FitFileStore based database.
+    def import_legacy_archive
+      old_fit_dir = File.join(@db_dir, 'old_fit_dir')
+      create_directory(old_fit_dir, 'Old Fit')
+
+      cfg = RuntimeConfig.new(@db_dir)
+      activities = ActivitiesDB.new(@db_dir, cfg).activities
+      # Ensure that activities are sorted from earliest to last to properly
+      # recognize the personal records during import.
+      activities.sort! { |a1, a2| a1.timestamp <=> a2.timestamp }
+      activities.each do |activity|
+        file_name = File.join(@db_dir, 'fit', activity.fit_file)
+        next unless File.exists?(file_name)
+
+        Log.info "Converting #{activity.fit_file} to new DB format"
+        @db.transaction do
+          unless (new_activity = @ffs.add_fit_file(file_name))
+            Log.warn "Cannot convert #{file_name} to new database format"
+            next
+          end
+          new_activity.sport = activity.sport
+          new_activity.sub_sport = activity.sub_sport
+          new_activity.name = activity.name
+          new_activity.norecord = activity.norecord
+          FileUtils.move(file_name, File.join(old_fit_dir, activity.fit_file))
+        end
+      end
+    end
+
   end
 
 end