postrunner 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea10a2814c3c25363117c69d85a1f5e0d4c07c2c
-  data.tar.gz: f0c72064a97183bfee97978e11a534bd9c2d5c5e
+  metadata.gz: c470dc3a2d1c211ae2c294e98392d9a2621b2ade
+  data.tar.gz: 201bf757b216cb48ab8bf4cf9ace6fae602b7730
 SHA512:
-  metadata.gz: 644edbd1db0ad2fe562e74a2d09b61ad2664942b1b0aaf31647a96d948cb9c2eb5951fd79a07302d4d2099215f76189b20524071fdd5a1b5d46d340dad851c8a
-  data.tar.gz: b2d3a31c489a3bc506c4d3d809abc35f4eb059edcf94fee1a8b630b52dbdc3e9e580b94825209123890ca670dc6999f28074a1e618c05342935d14a7abd4c167
+  metadata.gz: 2e9a5edc603c22081b74c538f5249943eabc266bb9eb54083c57e7664f948df27f9881a83f47d2db28862360c614e81cd2139b9775819ce46c7321b1d59a104e
+  data.tar.gz: 9bcd6103ac667230b1309b1bf31bcdda583ba651d016dee32510786faa8da52d13f4d06daf8c069f0ff4bdfb3d0563a1a324f865f55e80ef82ede97bbc291b20

data/README.md

@@ -2,12 +2,14 @@
 
 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.
-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.
+3 or Fenix 3HR. It allows you to import the files from the device and
+analyze the data. 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 GPS fix times.
+It is an offline alternative to Garmin Connect. The software has been
+developed and tested on Linux but should work on other operating
+systems as well.
 
 ## Installation
 

data/lib/postrunner/DailyMonitoringAnalyzer.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = DailyMonitoringAnalzyer.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 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
+# published by the Free Software Foundation.
+#
+
+require 'fit4ruby'
+
+module PostRunner
+
+  class DailyMonitoringAnalyzer
+
+    attr_reader :window_start_time, :window_end_time
+
+    class MonitoringSample
+
+      attr_reader :timestamp, :activity_type, :cycles, :steps,
+                  :floors_climbed, :floors_descended, :distance,
+                  :active_calories, :weekly_moderate_activity_minutes,
+                  :weekly_vigorous_activity_minutes
+
+      def initialize(m)
+        @timestamp = m.timestamp
+        types = [
+          'generic', 'running', 'cycling', 'transition',
+          'fitness_equipment', 'swimming', 'walking', 'unknown7',
+          'resting', 'unknown9'
+        ]
+        if (cati = m.current_activity_type_intensity)
+          @activity_type = types[cati & 0x1F]
+          @activity_intensity = (cati >> 5) & 0x7
+        else
+          @activity_type = m.activity_type
+        end
+        @active_time = m.active_time
+        @active_calories = m.active_calories
+        @ascent = m.ascent
+        @descent = m.descent
+        @floors_climbed = m.floors_climbed
+        @floors_descended = m.floors_descended
+        @cycles = m.cycles
+        @distance = m.distance
+        @duration_min = m.duration_min
+        @heart_rate = m.heart_rate
+        @steps = m.steps
+        @weekly_moderate_activity_minutes = m.weekly_moderate_activity_minutes
+        @weekly_vigorous_activity_minutes = m.weekly_vigorous_activity_minutes
+      end
+
+    end
+
+    def initialize(monitoring_files, day)
+      # Day as Time object. Midnight UTC.
+      day_as_time = Time.parse(day + "-00:00:00+00:00").gmtime
+
+      @samples = []
+      extract_data_from_monitor_files(monitoring_files, day_as_time)
+
+      # We must have information about the local time zone the data was
+      # recorded in. Abort if not available.
+      return unless @utc_offset
+    end
+
+    def total_distance
+      distance = 0.0
+      @samples.each do |s|
+        if s.distance && s.distance > distance
+          distance = s.distance
+        end
+      end
+
+      distance
+    end
+
+    def total_floors
+      floors_climbed = floors_descended = 0.0
+
+      @samples.each do |s|
+        if s.floors_climbed && s.floors_climbed > floors_climbed
+          floors_climbed = s.floors_climbed
+        end
+        if s.floors_descended && s.floors_descended > floors_descended
+          floors_descended = s.floors_descended
+        end
+      end
+
+      { :floors_climbed => (floors_climbed / 3.048).floor,
+        :floors_descended => (floors_descended / 3.048).floor }
+    end
+
+    def steps_distance_calories
+      total_cycles = Hash.new(0.0)
+      total_distance = Hash.new(0.0)
+      total_calories = Hash.new(0.0)
+
+      @samples.each do |s|
+        at = s.activity_type
+        if s.cycles && s.cycles > total_cycles[at]
+          total_cycles[at] = s.cycles
+        end
+        if s.distance && s.distance > total_distance[at]
+          total_distance[at] = s.distance
+        end
+        if s.active_calories && s.active_calories > total_calories[at]
+          total_calories[at] = s.active_calories
+        end
+      end
+
+      distance = calories = 0.0
+      if @monitoring_info
+        if @monitoring_info.activity_type &&
+           @monitoring_info.cycles_to_distance &&
+           @monitoring_info.cycles_to_calories
+          walking_cycles_to_distance = running_cycles_to_distance = nil
+          walking_cycles_to_calories = running_cycles_to_calories = nil
+
+          @monitoring_info.activity_type.each_with_index do |at, idx|
+            if at == 'walking'
+              walking_cycles_to_distance =
+                @monitoring_info.cycles_to_distance[idx]
+              walking_cycles_to_calories =
+                @monitoring_info.cycles_to_calories[idx]
+            elsif at == 'running'
+              running_cycles_to_distance =
+                @monitoring_info.cycles_to_distance[idx]
+              running_cycles_to_calories =
+                @monitoring_info.cycles_to_calories[idx]
+            end
+          end
+          distance = total_distance.values.inject(0.0, :+)
+          calories = total_calories.values.inject(0.0, :+) +
+            @monitoring_info.resting_metabolic_rate
+        end
+      end
+
+      { :steps => ((total_cycles['walking'] + total_cycles['running']) * 2 +
+                   total_cycles['generic']).to_i,
+        :distance => distance, :calories => calories }
+    end
+
+    def intensity_minutes
+      moderate_minutes = vigorous_minutes = 0.0
+      @samples.each do |s|
+        if s.weekly_moderate_activity_minutes &&
+           s.weekly_moderate_activity_minutes > moderate_minutes
+          moderate_minutes = s.weekly_moderate_activity_minutes
+        end
+        if s.weekly_vigorous_activity_minutes &&
+           s.weekly_vigorous_activity_minutes > vigorous_minutes
+          vigorous_minutes = s.weekly_vigorous_activity_minutes
+        end
+      end
+
+      { :moderate_minutes => moderate_minutes,
+        :vigorous_minutes => vigorous_minutes }
+    end
+
+    def steps_goal
+      if @monitoring_info && @monitoring_info.goal_cycles &&
+         @monitoring_info.goal_cycles[0]
+        @monitoring_info.goal_cycles[0]
+      else
+        0
+      end
+    end
+
+    def samples
+      @samples.length
+    end
+
+    private
+
+    def get_monitoring_info(monitoring_file)
+      # The monitoring files have a monitoring_info section that contains a
+      # timestamp in UTC and a local_time field for the same time in the local
+      # time. If any of that isn't present, we use an offset of 0.
+      if (mis = monitoring_file.monitoring_infos).nil? || mis.empty? ||
+         (mi = mis[0]).nil? || mi.local_time.nil? || mi.timestamp.nil?
+        return nil
+      end
+
+      mi
+    end
+
+    # Load monitoring data from monitoring_b FIT files into Arrays.
+    # @param monitoring_files [Array of Monitoring_B] FIT files to read
+    # @param day [Time] Midnight UTC of the day to analyze
+    def extract_data_from_monitor_files(monitoring_files, day)
+      monitoring_files.each do |mf|
+        next unless (mi = get_monitoring_info(mf))
+
+        utc_offset = mi.local_time - mi.timestamp
+        # Midnight (local time) of the requested day.
+        window_start_time = day - utc_offset
+        # Midnight (local time) of the next day
+        window_end_time = window_start_time + 24 * 60 * 60
+
+        # Ignore all files with data prior to the potential time window.
+        next if mf.monitorings.empty? ||
+                mf.monitorings.last.timestamp < window_start_time
+
+        if @utc_offset.nil?
+          # The instance variables will only be set once we have found our
+          # first monitoring file that matches the requested day. We use the
+          # local time setting for this first file even if it changes in
+          # subsequent files.
+          @window_start_time = window_start_time
+          @window_end_time = window_end_time
+          @utc_offset = utc_offset
+        end
+
+        if @monitoring_info.nil? && @window_start_time <= mi.local_time &&
+           mi.local_time < @window_end_time
+          @monitoring_info = mi
+        end
+
+        mf.monitorings.each do |m|
+          # Ignore all entries outside our time window. It's important to note
+          # that records with a midnight timestamp contain totals from the day
+          # before.
+          next if m.timestamp <= @window_start_time ||
+                  m.timestamp > @window_end_time
+
+          @samples << MonitoringSample.new(m)
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/postrunner/DailySleepAnalyzer.rb

@@ -12,206 +12,499 @@
 
 require 'fit4ruby'
 
+require 'postrunner/SleepCycle'
+
 module PostRunner
 
   # This class extracts the sleep information from a set of monitoring files
   # and determines when and how long the user was awake or had a light or deep
-  # sleep.
+  # sleep. Determining the sleep state of a person purely based on wrist
+  # movement data is not very accurate. It gets a lot more accurate when heart
+  # rate data is available as well. The heart rate describes a sinus-like
+  # curve that aligns with the sleep cycles. Each sinus cycle corresponds to a
+  # sleep cycle. Unfortunately, current Garmin devices only use a default
+  # sampling time of 15 minutes. Since a sleep cycle is broken down into
+  # various sleep phases that normally last 10 - 15 minutes, there is a fairly
+  # high margin of error to determine the exact timing of the sleep cycle.
+  #
+  # HR High  -----+   +-------+        +------+
+  # HR Low        +---+       +--------+      +---
+  # Mov High --+         +-------+  +-----+     +--
+  # Mov Low    +---------+       +--+     +-----+
+  # Phase   wk n1  n3 n2 rem n2 n3 n2 rem n2 n3 n2
+  # Cycle     1               2               3
+  #
+  # Legend: wk: wake n1: NREM1, n2: NREM2, n3: NREM3, rem: REM sleep
+  #
+  # Too frequent or too strong movements abort the cycle to wake.
   class DailySleepAnalyzer
 
-    # Utility class to store the interval of a sleep/wake phase.
-    class SleepInterval < Struct.new(:from_time, :to_time, :phase)
-    end
+    attr_reader :sleep_cycles, :utc_offset,
+                :total_sleep, :rem_sleep, :deep_sleep, :light_sleep,
+                :resting_heart_rate, :window_start_time, :window_end_time
 
-    attr_reader :sleep_intervals, :utc_offset,
-                :total_sleep, :deep_sleep, :light_sleep
+    TIME_WINDOW_MINUTES = 24 * 60
 
     # Create a new DailySleepAnalyzer object to analyze the given monitoring
     # files.
     # @param monitoring_files [Array] A set of Monitoring_B objects
     # @param day [String] Day to analyze as YY-MM-DD string
-    def initialize(monitoring_files, day)
-      @noon_yesterday = @noon_today = @utc_offset = nil
-      @sleep_intervals = []
+    # @param window_offest_secs [Fixnum] Offset (in seconds) of the time
+    #        window to analyze against the midnight of the specified day
+    def initialize(monitoring_files, day, window_offest_secs)
+      @window_start_time = @window_end_time = @utc_offset = nil
+
+      # The following activity types are known:
+      #  [ :undefined, :running, :cycling, :transition,
+      #    :fitness_equipment, :swimming, :walking, :unknown7,
+      #    :resting, :unknown9 ]
+      @activity_type = Array.new(TIME_WINDOW_MINUTES, nil)
+      # The activity values in the FIT files can range from 0 to 7.
+      @activity_intensity = Array.new(TIME_WINDOW_MINUTES, nil)
+      # Wrist motion data is not very well suited to determine wake or sleep
+      # states. A single movement can be a turning motion, a NREM1 jerk or
+      # even a movement while you dream. The fewer motions are detected, the
+      # more likely you are really asleep. To even out single spikes, we
+      # average the motions over a period of time. This Array stores the
+      # weighted activity.
+      @weighted_sleep_activity = Array.new(TIME_WINDOW_MINUTES, 8)
+      # We classify the sleep activity into :wake, :low_activity and
+      # :no_activity in this Array.
+      @sleep_activity_classification = Array.new(TIME_WINDOW_MINUTES, nil)
+
+      # The data from the monitoring files is stored in Arrays that cover 24
+      # hours at 1 minute resolution. The algorithm currently cannot handle
+      # time zone or DST changes. The day is always 24 hours and the local
+      # time at noon the previous day is used for the whole window.
+      @heart_rate = Array.new(TIME_WINDOW_MINUTES, nil)
+      # From the wrist motion data and if available from the heart rate data,
+      # we try to guess the sleep phase (:wake, :rem, :nrem1, :nrem2, :nrem3).
+      # This Array will hold a minute-by-minute list of the guessed sleep
+      # phase.
+      @sleep_phase = Array.new(TIME_WINDOW_MINUTES, :wake)
+      # The DailySleepAnalzyer extracts the sleep cycles from the monitoring
+      # data. Each night usually has 5 - 6 sleep cycles. If we have heart rate
+      # data, those cycles can be identified fairly well. If we have to rely
+      # on wrist motion data only, we usually find more cycles than there
+      # actually were. Each cycle is captured as SleepCycle object.
+      @sleep_cycles = []
+      # The resting heart rate.
+      @resting_heart_rate = nil
 
       # Day as Time object. Midnight UTC.
       day_as_time = Time.parse(day + "-00:00:00+00:00").gmtime
-      extract_data_from_monitor_files(monitoring_files, day_as_time)
-      fill_sleep_activity
-      smoothen_sleep_activity
-      analyze
-      trim_wake_periods_at_ends
+      extract_data_from_monitor_files(monitoring_files, day_as_time,
+                                      window_offest_secs)
+
+      # We must have information about the local time zone the data was
+      # recorded in. Abort if not available.
+      return unless @utc_offset
+
+      fill_monitoring_data
+      categorize_sleep_activity
+
+      if categorize_sleep_heart_rate
+        # We have usable heart rate data for the sleep periods. Correlating
+        # wrist motion data with heart rate cycles will greatly improve the
+        # sleep phase and sleep cycle detection.
+        categorize_sleep_phase_by_hr_level
+        @sleep_cycles.each do |c|
+          # Adjust the cycle boundaries to align with REM phase.
+          c.adjust_cycle_boundaries(@sleep_phase)
+          # Detect sleep phases for each cycle.
+          c.detect_phases(@sleep_phase)
+        end
+      else
+        # We have no usable heart rate data. Just guess sleep phases based on
+        # wrist motion data.
+        categorize_sleep_phase_by_activity_level
+        @sleep_cycles.each { |c| c.detect_phases(@sleep_phase) }
+      end
+      dump_data
+      delete_wake_cycles
+      determine_resting_heart_rate
       calculate_totals
     end
 
     private
 
-    def extract_utc_offset(monitoring_file)
+    def get_monitoring_info(monitoring_file)
       # The monitoring files have a monitoring_info section that contains a
       # timestamp in UTC and a local_time field for the same time in the local
       # time. If any of that isn't present, we use an offset of 0.
-      if (mi = monitoring_file.monitoring_infos).nil? || mi.empty? ||
-         (localtime = mi[0].local_time).nil?
-        return 0
+      if (mis = monitoring_file.monitoring_infos).nil? || mis.empty? ||
+         (mi = mis[0]).nil? || mi.local_time.nil? || mi.timestamp.nil?
+        return nil
       end
 
-      # Otherwise the delta in seconds between UTC and localtime is the
-      # offset.
-      localtime - mi[0].timestamp
+      mi
     end
 
-    def extract_data_from_monitor_files(monitoring_files, day)
-      # We use an Array with entries for every minute from noon yesterday to
-      # noon today.
-      @sleep_activity = Array.new(24 * 60, nil)
+    # Load monitoring data from monitoring_b FIT files into Arrays.
+    # @param monitoring_files [Array of Monitoring_B] FIT files to read
+    # @param day [Time] Midnight UTC of the day to analyze
+    # @param window_offest_secs [Fixnum] Difference between midnight and the
+    #        start of the time window to analyze.
+    def extract_data_from_monitor_files(monitoring_files, day,
+                                        window_offest_secs)
       monitoring_files.each do |mf|
-        utc_offset = extract_utc_offset(mf)
+        next unless (mi = get_monitoring_info(mf))
+
+        utc_offset = mi.local_time - mi.timestamp
+        # Midnight (local time) of the requested day.
+        midnight_today = day - utc_offset
         # Noon (local time) the day before the requested day. The time object
         # is UTC for the noon time in the local time zone.
-        noon_yesterday = day - 12 * 60 * 60 - utc_offset
+        window_start_time = midnight_today + window_offest_secs
         # Noon (local time) of the current day
-        noon_today = day + 12 * 60 * 60 - utc_offset
+        window_end_time = window_start_time + TIME_WINDOW_MINUTES * 60
+
+        # Ignore all files with data prior to the potential time window.
+        next if mf.monitorings.empty? ||
+                mf.monitorings.last.timestamp < window_start_time
+
+        if @utc_offset.nil?
+          # The instance variables will only be set once we have found our
+          # first monitoring file that matches the requested day. We use the
+          # local time setting for this first file even if it changes in
+          # subsequent files.
+          @window_start_time = window_start_time
+          @window_end_time = window_end_time
+          @utc_offset = utc_offset
+        end
 
         mf.monitorings.each do |m|
-          # Ignore all entries outside our 24 hour window from noon the day
-          # before to noon the current day.
-          next if m.timestamp < noon_yesterday || m.timestamp >= noon_today
-
-          if @noon_yesterday.nil? && @noon_today.nil?
-            # The instance variables will only be set once we have found our
-            # first monitoring file that matches the requested day. We use the
-            # local time setting for this first file even if it changes in
-            # subsequent files.
-            @noon_yesterday = noon_yesterday
-            @noon_today = noon_today
-            @utc_offset = utc_offset
-          end
+          # Ignore all entries outside our time window.
+          next if m.timestamp < @window_start_time ||
+                  m.timestamp >= @window_end_time
+
+          # The index (minutes after noon yesterday) to address all the value
+          # arrays.
+          index = (m.timestamp - @window_start_time) / 60
 
+          # The activity type and intensity are stored in the same FIT field.
+          # We'll break them into 2 separate values.
           if (cati = m.current_activity_type_intensity)
-            activity_type = cati & 0x1F
+            @activity_type[index] = cati & 0x1F
+            @activity_intensity[index] = (cati >> 5) & 0x7
+          end
 
-            # Compute the index in the @sleep_activity Array.
-            index = (m.timestamp - @noon_yesterday) / 60
-            if activity_type == 8
-              intensity = (cati >> 5) & 0x7
-              @sleep_activity[index] = intensity
-            else
-              @sleep_activity[index] = false
-            end
+          # Store heart rate data if available.
+          if m.heart_rate
+            @heart_rate[index] = m.heart_rate
           end
         end
       end
 
     end
 
-    def fill_sleep_activity
+    def fill_monitoring_data
+      # The FIT files only contain a timestamped entry when new values have
+      # been measured. The timestamp marks the end of the period where the
+      # recorded values were current.
+      #
+      # We want to have an entry for every minute. So we have to replicate the
+      # found value for all previous minutes until we find another valid
+      # entry.
       current = nil
-      @sleep_activity = @sleep_activity.reverse.map do |v|
-        v.nil? ? current : current = v
-      end.reverse
+      [ @activity_type, @activity_intensity, @heart_rate ].each do |dataset|
+        current = nil
+        # We need to fill back-to-front, so we reverse the array during the
+        # fill. And reverse it back at the end.
+        dataset.reverse!.map! do |v|
+          v.nil? ? current : current = v
+        end.reverse!
+      end
+    end
 
+    # Dump all input and intermediate data for the sleep tracking into a CSV
+    # file if DEBUG mode is enabled.
+    def dump_data
       if $DEBUG
-        File.open('sleep-data.csv', 'w') do |f|
-          f.puts 'Date;Value'
-          @sleep_activity.each_with_index do |v, i|
-            f.puts "#{@noon_yesterday + i * 60};#{v.is_a?(Fixnum) ? v : 8}"
+        File.open('monitoring-data.csv', 'w') do |f|
+          f.puts 'Date;Activity Type;Activity Level;Weighted Act. Level;' +
+                 'Heart Rate;Activity Class;Heart Rate Class;Sleep Phase'
+          0.upto(TIME_WINDOW_MINUTES - 1) do |i|
+            at = @activity_type[i]
+            ai = @activity_intensity[i]
+            wsa = @weighted_sleep_activity[i]
+            hr = @heart_rate[i]
+            sac = @sleep_activity_classification[i]
+            shc = @sleep_heart_rate_classification[i]
+            sp = @sleep_phase[i]
+            f.puts "#{@window_start_time + i * 60};" +
+                   "#{at.is_a?(Fixnum) ? at : ''};" +
+                   "#{ai.is_a?(Fixnum) ? ai : ''};" +
+                   "#{wsa};" +
+                   "#{hr.is_a?(Fixnum) ? hr : ''};" +
+                   "#{sac ? sac.to_s : ''};" +
+                   "#{shc ? shc.to_s : ''};" +
+                   "#{sp.to_s}"
           end
         end
       end
     end
 
-    def smoothen_sleep_activity
-      window_size = 30
-
-      @smoothed_sleep_activity = Array.new(24 * 60, nil)
-      0.upto(24 * 60 - 1).each do |i|
-        window_start_idx = i - window_size
-        window_end_idx = i
-        sum = 0.0
-        (i - window_size + 1).upto(i).each do |j|
-          sum += j < 0 ? 8.0 :
-                 @sleep_activity[j].is_a?(Fixnum) ? @sleep_activity[j] : 8
+    def categorize_sleep_activity
+      delta = 7
+      0.upto(TIME_WINDOW_MINUTES - 1) do |i|
+        intensity_sum = 0
+        weight_sum = 0
+
+        (i - delta).upto(i + delta) do |j|
+          next if i < 0 || i >= TIME_WINDOW_MINUTES
+
+          weight = delta - (i - j).abs
+          intensity_sum += weight *
+            (@activity_type[j] != 8 ? 8 : @activity_intensity[j])
+          weight_sum += weight
         end
-        @smoothed_sleep_activity[i] = sum / window_size
+
+        # Normalize the weighted intensity sum
+        @weighted_sleep_activity[i] =
+          intensity_sum.to_f / weight_sum
+
+        @sleep_activity_classification[i] =
+          if @weighted_sleep_activity[i] > 2.2
+            :wake
+          elsif @weighted_sleep_activity[i] > 0.5
+            :low_activity
+          else
+            :no_activity
+          end
       end
+    end
 
-      if $DEBUG
-        File.open('smoothed-sleep-data.csv', 'w') do |f|
-          f.puts 'Date;Value'
-          @smoothed_sleep_activity.each_with_index do |v, i|
-            f.puts "#{@noon_yesterday + i * 60};#{v}"
+    # During the nightly sleep the heart rate is alternating between a high
+    # and a low frequency. The actual frequencies vary so that we need to look
+    # for the transitions to classify each sample as high or low.
+    def categorize_sleep_heart_rate
+      @sleep_heart_rate_classification = Array.new(TIME_WINDOW_MINUTES, nil)
+
+      last_heart_rate = 0
+      current_category = :high_hr
+      last_transition_index = 0
+      last_transition_delta = 0
+      transitions = 0
+
+      0.upto(TIME_WINDOW_MINUTES - 1) do |i|
+        if @sleep_activity_classification[i] == :wake ||
+           @heart_rate[i].nil? || @heart_rate[i] == 0
+          last_heart_rate = 0
+          current_category = :high_hr
+          last_transition_index = i + 1
+          last_transition_delta = 0
+          next
+        end
+
+        if last_heart_rate
+          if current_category == :high_hr
+            if last_heart_rate > @heart_rate[i]
+              # High/low transition found
+              current_category = :low_hr
+              transitions += 1
+              last_transition_delta = last_heart_rate - @heart_rate[i]
+              last_transition_index = i
+            elsif last_heart_rate < @heart_rate[i] &&
+                  last_transition_delta < @heart_rate[i] - last_heart_rate
+              # The previously found high segment was wrongly categorized as
+              # such. Convert it to low segment.
+              last_transition_index.upto(i - 1) do |j|
+                @sleep_heart_rate_classification[j] = :low_hr
+              end
+              # Now we are in a high segment.
+              current_category = :high_hr
+              last_transition_delta += @heart_rate[i] - last_heart_rate
+              last_transition_index = i
+            end
+          else
+            if last_heart_rate < @heart_rate[i]
+              # Low/High transition found.
+              current_category = :high_hr
+              transitions += 1
+              last_transition_delta = @heart_rate[i] - last_heart_rate
+              last_transition_index = i
+            elsif last_heart_rate > @heart_rate[i] &&
+                  last_transition_delta < last_heart_rate - @heart_rate[i]
+              # The previously found low segment was wrongly categorized as
+              # such. Convert it to high segment.
+              last_transition_index.upto(i - 1) do |j|
+                @sleep_heart_rate_classification[j] = :high_hr
+              end
+              # Now we are in a low segment.
+              current_category = :low_hr
+              last_transition_delta += last_heart_rate - @heart_rate[i]
+              last_transition_index = i
+            end
           end
+          @sleep_heart_rate_classification[i] = current_category
         end
+
+        last_heart_rate = @heart_rate[i]
       end
+
+      # We consider the HR transition data good enough if we have found at
+      # least 3 transitions.
+      transitions > 3
     end
 
-    def analyze
-      current_phase = :awake
-      current_phase_start = @noon_yesterday
-      @sleep_intervals = []
-
-      @smoothed_sleep_activity.each_with_index do |v, idx|
-        if v < 0.25
-          phase = :deep_sleep
-        elsif v < 1.5
-          phase = :light_sleep
-        else
-          phase = :awake
+    # Use the wrist motion data and heart rate data to guess the sleep phases
+    # and sleep cycles.
+    def categorize_sleep_phase_by_hr_level
+      rem_possible = false
+      current_hr_phase = nil
+      cycle = nil
+
+      0.upto(TIME_WINDOW_MINUTES - 1) do |i|
+        sac = @sleep_activity_classification[i]
+        hrc = @sleep_heart_rate_classification[i]
+
+        if hrc != current_hr_phase
+          if current_hr_phase.nil?
+            if hrc == :high_hr
+              # Wake/High transition.
+              rem_possible = false
+            else
+              # Wake/Low transition. Should be very uncommon.
+              rem_possible = true
+            end
+            cycle = SleepCycle.new(@window_start_time, i)
+          elsif current_hr_phase == :high_hr
+            rem_possible = false
+            if hrc.nil?
+              # High/Wake transition. Wakeing up from light sleep.
+              if cycle
+                cycle.end_idx = i - 1
+                @sleep_cycles << cycle
+                cycle = nil
+              end
+            else
+              # High/Low transition. Going into deep sleep
+              if cycle
+                # A high/low transition completes the cycle if we already have
+                # a low/high transition for this cycle. The actual end
+                # should be the end of the REM phase, but we have to correct
+                # this and the start of the new cycle later.
+                cycle.high_low_trans_idx = i
+                if cycle.low_high_trans_idx
+                  cycle.end_idx = i - 1
+                  @sleep_cycles << cycle
+                  cycle = SleepCycle.new(@window_start_time, i, cycle)
+                end
+              end
+            end
+          else
+            if hrc.nil?
+              # Low/Wake transition. Waking up from deep sleep.
+              rem_possible = false
+              if cycle
+                cycle.end_idx = i - 1
+                @sleep_cycles << cycle
+                cycle = nil
+              end
+            else
+              # Low/High transition. REM phase possible
+              rem_possible = true
+              cycle.low_high_trans_idx = i if cycle
+            end
+          end
         end
+        current_hr_phase = hrc
 
-        if current_phase != phase
-          t = @noon_yesterday + 60 * idx
-          @sleep_intervals << SleepInterval.new(current_phase_start, t,
-                                                current_phase)
-          current_phase = phase
-          current_phase_start = t
-        end
+        next unless hrc && sac
+
+        @sleep_phase[i] =
+          if hrc == :high_hr
+            if sac == :no_activity
+              :nrem1
+            else
+              rem_possible ? :rem : :nrem1
+            end
+          else
+            if sac == :no_activity
+              :nrem3
+            else
+              :nrem2
+            end
+          end
       end
-      @sleep_intervals << SleepInterval.new(current_phase_start, @noon_today,
-                                            current_phase)
     end
 
-    def trim_wake_periods_at_ends
-      first_deep_sleep_idx = last_deep_sleep_idx = nil
+    def categorize_sleep_phase_by_activity_level
+      @sleep_phase = []
+      mappings = { :wake => :wake, :low_activity => :nrem1,
+                   :no_activity => :nrem3 }
+
+      current_cycle_start = nil
+      current_phase = @sleep_activity_classification[0]
+      current_phase_start = 0
+
+      0.upto(TIME_WINDOW_MINUTES - 1) do |idx|
+        # Without HR data, we need to use other threshold values to determine
+        # the activity classification. Hence we do it again here.
+        @sleep_activity_classification[idx] = sac =
+          if @weighted_sleep_activity[idx] > 2.2
+            :wake
+          elsif @weighted_sleep_activity[idx] > 0.01
+            :low_activity
+          else
+            :no_activity
+          end
+
+        @sleep_phase << mappings[sac]
 
-      @sleep_intervals.each_with_index do |p, idx|
-        if p.phase == :deep_sleep ||
-           (p.phase == :light_sleep && ((p.to_time - p.from_time) > 15 * 60))
-          first_deep_sleep_idx = idx unless first_deep_sleep_idx
-          last_deep_sleep_idx = idx
+        # Sleep cycles start at wake/non-wake transistions.
+        if current_cycle_start.nil? && sac != :wake
+          current_cycle_start = idx
         end
-      end
 
-      return unless first_deep_sleep_idx && last_deep_sleep_idx
+        if current_phase != sac || idx >= TIME_WINDOW_MINUTES
+          # We have detected the end of a phase.
+          if (current_phase == :no_activity || sac == :wake) &&
+             current_cycle_start
+            # The end of the :no_activity phase marks the end of a sleep cycle.
+            @sleep_cycles << (cycle = SleepCycle.new(@window_start_time,
+                                                     current_cycle_start,
+                                                     @sleep_cycles.last))
+            cycle.end_idx = idx
+            current_cycle_start = nil
+          end
 
-      if first_deep_sleep_idx > 0 &&
-         @sleep_intervals[first_deep_sleep_idx - 1].phase == :light_sleep
-         first_deep_sleep_idx -= 1
-      end
-      if last_deep_sleep_idx < @sleep_intervals.length - 2 &&
-         @sleep_intervals[last_deep_sleep_idx + 1].phase == :light_sleep
-        last_deep_sleep_idx += 1
+          current_phase = sac
+          current_phase_start = idx
+        end
       end
+    end
 
-      @sleep_intervals =
-        @sleep_intervals[first_deep_sleep_idx..last_deep_sleep_idx]
+    def delete_wake_cycles
+      wake_cycles = []
+      @sleep_cycles.each { |c| wake_cycles << c if c.is_wake_cycle? }
+
+      wake_cycles.each { |c| c.unlink }
+      @sleep_cycles.delete_if { |c| wake_cycles.include?(c) }
     end
 
-    def calculate_totals
-      @total_sleep = @light_sleep = @deep_sleep = 0
-      @sleep_intervals.each do |p|
-        if p.phase != :awake
-          seconds = p.to_time - p.from_time
-          @total_sleep += seconds
-          if p.phase == :light_sleep
-            @light_sleep += seconds
-          else
-            @deep_sleep += seconds
-          end
+    def determine_resting_heart_rate
+      # Find the smallest heart rate. TODO: While being awake.
+      @heart_rate.each_with_index do |heart_rate, idx|
+        next unless heart_rate && heart_rate > 0
+        if @resting_heart_rate.nil? || @resting_heart_rate > heart_rate
+          @resting_heart_rate = heart_rate
         end
       end
     end
 
+    def calculate_totals
+      @total_sleep = @light_sleep = @deep_sleep = @rem_sleep = 0
+
+      @sleep_cycles.each do |p|
+        @total_sleep += p.total_seconds.values.inject(0, :+)
+        @light_sleep += p.total_seconds[:nrem1] + p.total_seconds[:nrem2]
+        @deep_sleep += p.total_seconds[:nrem3]
+        @rem_sleep += p.total_seconds[:rem]
+      end
+    end
+
     # Return the begining of the current day in local time as Time object.
     def begining_of_today(time = Time.now)
       sec, min, hour, day, month, year = time.to_a