postrunner 0.0.2 → 0.0.3

data/lib/postrunner/Activity.rb

@@ -1,18 +1,22 @@
 require 'fit4ruby'
-require 'postrunner/RuntimeConfig'
+
+require 'postrunner/ActivityReport'
+require 'postrunner/ActivityView'
 
 module PostRunner
 
   class Activity
 
-    attr_reader :fit_file
-    attr_accessor :name
+    attr_reader :fit_file, :name, :fit_activity
+    attr_accessor :db
 
     # This is a list of variables that provide data from the fit file. To
     # speed up access to it, we cache the data in the activity database.
-    @@CachedVariables = %w( start_time distance duration avg_speed )
+    @@CachedVariables = %w( timestamp total_distance total_timer_time
+                            avg_speed )
 
-    def initialize(fit_file, fit_activity, name = nil)
+    def initialize(db, fit_file, fit_activity, name = nil)
+      @db = db
       @fit_file = fit_file
       @fit_activity = fit_activity
       @name = name || fit_file
@@ -24,6 +28,15 @@ module PostRunner
       end
     end
 
+    def check
+      @fit_activity = load_fit_file
+      Log.info "FIT file #{@fit_file} is OK"
+    end
+
+    def dump(filter)
+      @fit_activity = load_fit_file(filter)
+    end
+
     def yaml_initialize(tag, value)
       # Create attr_readers for cached variables.
       @@CachedVariables.each { |v| self.class.send(:attr_reader, v.to_sym) }
@@ -37,7 +50,7 @@ module PostRunner
     end
 
     def encode_with(coder)
-      attr_ignore = %w( @fit_activity )
+      attr_ignore = %w( @db @fit_activity )
 
       instance_variables.each do |v|
         v = v.to_s
@@ -47,15 +60,45 @@ module PostRunner
       end
     end
 
-    def method_missing(method_name, *args, &block)
-      fit_file = File.join(Config['fit_dir'], @fit_file)
+    def show
+      @fit_activity = load_fit_file unless @fit_activity
+      view = ActivityView.new(self, File.join(@db.db_dir, 'html'))
+      #view = TrackView.new(self, '../../html')
+      #view.generate_html
+      #chart = ChartView.new(self, '../../html')
+      #chart.generate_html
+    end
+
+    def summary
+      @fit_activity = load_fit_file unless @fit_activity
+      puts ActivityReport.new(@fit_activity).to_s
+    end
+
+    def rename(name)
+      @name = name
+    end
+
+    def register_records(db)
+      @fit_activity.personal_records.each do |r|
+        if r.longest_distance == 1
+          # In case longest_distance is 1 the distance is stored in the
+          # duration field in 10-th of meters.
+          db.register_result(r.duration * 10.0 , 0, r.start_time, @fit_file)
+        else
+          db.register_result(r.distance, r.duration, r.start_time, @fit_file)
+        end
+      end
+    end
+
+    private
+
+    def load_fit_file(filter = nil)
+      fit_file = File.join(@db.fit_dir, @fit_file)
       begin
-        @fit_activity = Fit4Ruby.read(fit_file) unless @fit_activity
+        return Fit4Ruby.read(fit_file, filter)
       rescue Fit4Ruby::Error
-        Log.error "Cannot read #{fit_file}: #{$!}"
-        return false
+        Log.fatal $!
       end
-      @fit_activity.send(method_name, *args, &block)
     end
 
   end

data/lib/postrunner/ActivityReport.rb

@@ -0,0 +1,102 @@
+require 'fit4ruby'
+
+require 'postrunner/FlexiTable'
+require 'postrunner/ViewWidgets'
+
+module PostRunner
+
+  class ActivityReport
+
+    include Fit4Ruby::Converters
+    include ViewWidgets
+
+    def initialize(activity)
+      @activity = activity
+    end
+
+    def to_s
+      session = @activity.sessions[0]
+
+      summary(session).to_s + "\n" + laps.to_s
+    end
+
+    def to_html(doc)
+      session = @activity.sessions[0]
+
+      frame(doc, 'Summary') {
+        summary(session).to_html(doc)
+      }
+      frame(doc, 'Laps') {
+        laps.to_html(doc)
+      }
+    end
+
+    private
+
+    def summary(session)
+      t = FlexiTable.new
+      t.enable_frame(false)
+      t.body
+      t.row([ 'Date:', session.timestamp])
+      t.row([ 'Distance:', "#{'%.2f' % (session.total_distance / 1000.0)} km" ])
+      t.row([ 'Time:', secsToHMS(session.total_timer_time) ])
+      t.row([ 'Avg. Pace:',
+              "#{speedToPace(session.avg_speed)} min/km" ])
+      t.row([ 'Total Ascend:', "#{session.total_ascend} m" ])
+      t.row([ 'Total Descend:', "#{session.total_descent} m" ])
+      t.row([ 'Calories:', "#{session.total_calories} kCal" ])
+      t.row([ 'Avg. HR:', session.avg_heart_rate ?
+              "#{session.avg_heart_rate} bpm" : '-' ])
+      t.row([ 'Max. HR:', session.max_heart_rate ?
+              "#{session.max_heart_rate} bpm" : '-' ])
+      t.row([ 'Training Effect:', session.total_training_effect ?
+              session.total_training_effect : '-' ])
+      t.row([ 'Avg. Run Cadence:',
+              session.avg_running_cadence ?
+              "#{session.avg_running_cadence.round} spm" : '-' ])
+      t.row([ 'Avg. Vertical Oscillation:',
+              session.avg_vertical_oscillation ?
+              "#{'%.1f' % (session.avg_vertical_oscillation / 10)} cm" : '-' ])
+      t.row([ 'Avg. Ground Contact Time:',
+              session.avg_stance_time ?
+              "#{session.avg_stance_time.round} ms" : '-' ])
+      t.row([ 'Avg. Stride Length:',
+              session.avg_stride_length ?
+              "#{'%.2f' % (session.avg_stride_length / 2)} m" : '-' ])
+      rec_time = @activity.recovery_time
+      t.row([ 'Recovery Time:', rec_time ? secsToHMS(rec_time * 60) : '-' ])
+      vo2max = @activity.vo2max
+      t.row([ 'VO2max:', vo2max ? vo2max : '-' ])
+
+      t
+    end
+
+    def laps
+      t = FlexiTable.new
+      t.head
+      t.row([ 'Lap', 'Duration', 'Distance', 'Avg. Pace', 'Stride', 'Cadence',
+              'Avg. HR', 'Max. HR' ])
+      t.set_column_attributes(Array.new(8, { :halign => :right }))
+      t.body
+      @activity.sessions[0].laps.each.with_index do |lap, index|
+        t.cell(index + 1)
+        t.cell(secsToHMS(lap.total_timer_time))
+        t.cell('%.2f' % (lap.total_distance / 1000.0))
+        t.cell(speedToPace(lap.avg_speed))
+        t.cell(lap.total_strides ?
+               '%.2f' % (lap.total_distance / (2 * lap.total_strides)) : '')
+        t.cell(lap.avg_running_cadence && lap.avg_fractional_cadence ?
+               '%.1f' % (2 * lap.avg_running_cadence +
+                         (2 * lap.avg_fractional_cadence) / 100.0) : '')
+        t.cell(lap.avg_heart_rate.to_s)
+        t.cell(lap.max_heart_rate.to_s)
+        t.new_row
+      end
+
+      t
+    end
+
+  end
+
+end
+

data/lib/postrunner/ActivityView.rb

@@ -0,0 +1,133 @@
+require 'fit4ruby'
+
+require 'postrunner/HTMLBuilder'
+require 'postrunner/ActivityReport'
+require 'postrunner/ViewWidgets'
+require 'postrunner/TrackView'
+require 'postrunner/ChartView'
+
+module PostRunner
+
+  class ActivityView
+
+    include ViewWidgets
+
+    def initialize(activity, output_dir)
+      @activity = activity
+      @output_dir = output_dir
+      @output_file = nil
+
+      ensure_output_dir
+
+      @doc = HTMLBuilder.new
+      generate_html(@doc)
+      write_file
+      show_in_browser
+    end
+
+    private
+
+    def ensure_output_dir
+      unless Dir.exists?(@output_dir)
+        begin
+          Dir.mkdir(@output_dir)
+        rescue SystemCallError
+          Log.fatal "Cannot create output directory '#{@output_dir}': #{$!}"
+        end
+      end
+    end
+
+    def generate_html(doc)
+      @report = ActivityReport.new(@activity.fit_activity)
+      @track_view = TrackView.new(@activity)
+      @chart_view = ChartView.new(@activity)
+
+      doc.html {
+        head(doc)
+        body(doc)
+      }
+    end
+
+    def head(doc)
+      doc.head {
+        doc.meta({ 'http-equiv' => 'Content-Type',
+                   'content' => 'text/html; charset=utf-8' })
+        doc.meta({ 'name' => 'viewport',
+                   'content' => 'width=device-width, ' +
+                                'initial-scale=1.0, maximum-scale=1.0, ' +
+                                'user-scalable=0' })
+        doc.title("PostRunner Activity: #{@activity.name}")
+        style(doc)
+        view_widgets_style(doc)
+        @chart_view.head(doc)
+        @track_view.head(doc)
+      }
+    end
+
+    def style(doc)
+      doc.style(<<EOT
+.main {
+  width: 1210px;
+  margin: 0 auto;
+}
+.left_col {
+  float: left;
+  width: 400px;
+}
+.right_col {
+  float: right;
+  width: 600px;
+}
+.widget_container {
+	box-sizing: border-box;
+	width: 600px;
+	padding: 10px 15px 15px 15px;
+	margin: 15px auto 15px auto;
+	border: 1px solid #ddd;
+	background: #fff;
+	background: linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -o-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -ms-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -moz-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -webkit-linear-gradient(#f6f6f6 0, #fff 50px);
+	box-shadow: 0 3px 10px rgba(0,0,0,0.15);
+	-o-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-ms-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-moz-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-webkit-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+}
+EOT
+               )
+    end
+
+    def body(doc)
+      doc.body({ 'onload' => 'init()' }) {
+        doc.div({ 'class' => 'main' }) {
+          doc.div({ 'class' => 'left_col' }) {
+            @report.to_html(doc)
+            @track_view.div(doc)
+          }
+          doc.div({ 'class' => 'right_col' }) {
+            @chart_view.div(doc)
+          }
+        }
+      }
+    end
+
+    def write_file
+      @output_file = File.join(@output_dir, "#{@activity.fit_file[0..-5]}.html")
+      begin
+        File.write(@output_file, @doc.to_html)
+      rescue IOError
+        Log.fatal "Cannot write activity view file '#{@output_file}: #{$!}"
+      end
+    end
+
+    def show_in_browser
+      system("firefox \"#{@output_file}\" &")
+    end
+
+  end
+
+end
+

data/lib/postrunner/ChartView.rb

@@ -0,0 +1,195 @@
+require 'postrunner/ViewWidgets'
+
+module PostRunner
+
+  class ChartView
+
+    include ViewWidgets
+
+    def initialize(activity)
+      @activity = activity
+    end
+
+    def head(doc)
+      [ 'jquery/jquery-2.1.1.min.js', 'flot/jquery.flot.js',
+        'flot/jquery.flot.time.js' ].each do |js|
+        doc.script({ 'language' => 'javascript', 'type' => 'text/javascript',
+                     'src' => js })
+      end
+      doc.style(style)
+      doc.script(java_script)
+    end
+
+    def div(doc)
+      chart_div(doc, 'pace', 'Pace (min/km)')
+      chart_div(doc, 'altitude', 'Elevation (m)')
+      chart_div(doc, 'heart_rate', 'Heart Rate (bpm)')
+      chart_div(doc, 'cadence', 'Run Cadence (spm)')
+      chart_div(doc, 'vertical_oscillation', 'Vertical Oscillation (cm)')
+      chart_div(doc, 'stance_time', 'Ground Contact Time (ms)')
+    end
+
+    private
+
+    def style
+      <<EOT
+.chart-container {
+	box-sizing: border-box;
+	width: 600px;
+	height: 200px;
+	padding: 10px 15px 15px 15px;
+	margin: 15px auto 15px auto;
+	border: 1px solid #ddd;
+	background: #fff;
+	background: linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -o-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -ms-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -moz-linear-gradient(#f6f6f6 0, #fff 50px);
+	background: -webkit-linear-gradient(#f6f6f6 0, #fff 50px);
+	box-shadow: 0 3px 10px rgba(0,0,0,0.15);
+	-o-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-ms-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-moz-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+	-webkit-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+}
+.chart-placeholder {
+	width: 570px;
+	height: 200px;
+	font-size: 14px;
+	line-height: 1.2em;
+}
+EOT
+    end
+
+    def java_script
+      s = "$(function() {\n"
+
+      s << line_graph('pace', '#0A7BEE' )
+      s << line_graph('altitude', '#5AAA44')
+      s << line_graph('heart_rate', '#900000')
+      s << point_graph('cadence',
+                       [ [ '#EE3F2D', 151 ],
+                         [ '#F79666', 163 ],
+                         [ '#A0D488', 174 ],
+                         [ '#96D7DE', 185 ],
+                         [ '#A88BBB', nil ] ], 2)
+      s << point_graph('vertical_oscillation',
+                       [ [ '#A88BBB', 6.7 ],
+                         [ '#96D7DE', 8.4 ],
+                         [ '#A0D488', 10.1 ],
+                         [ '#F79666', 11.8 ],
+                         [ '#EE3F2D', nil ] ], 0.1)
+      s << point_graph('stance_time',
+                       [ [ '#A88BBB', 208 ],
+                         [ '#96D7DE', 241 ],
+                         [ '#A0D488', 273 ],
+                         [ '#F79666', 305 ],
+                         [ '#EE3F2D', nil ] ])
+
+      s << "\n});\n"
+
+      s
+    end
+
+    def line_graph(field, color = nil)
+      s = "var #{field}_data = [\n"
+
+      first = true
+      start_time = @activity.fit_activity.sessions[0].start_time.to_i
+      @activity.fit_activity.records.each do |r|
+        if first
+          first = false
+        else
+          s << ', '
+        end
+        value = r.send(field)
+        if field == 'pace'
+          if value > 20.0
+            value = nil
+          else
+            value = (value * 3600.0 * 1000).to_i
+          end
+        end
+        s << "[ #{((r.timestamp.to_i - start_time) * 1000).to_i}, " +
+             "#{value ? value : 'null'} ]"
+      end
+
+      s << <<"EOT"
+	  	];
+
+	  	$.plot("##{field}_chart",
+             [ { data: #{field}_data,
+                 #{color ? "color: \"#{color}\"," : ''}
+                 lines: { show: true#{field == 'pace' ? '' : ', fill: true'} } } ],
+             { xaxis: { mode: "time" }
+EOT
+      if field == 'pace'
+        s << ", yaxis: { mode: \"time\",\n" +
+             "           transform: function (v) { return -v; },\n" +
+             "           inverseTransform: function (v) { return -v; } }"
+      end
+      s << "});\n"
+    end
+
+    def point_graph(field, colors, multiplier = 1)
+      # We need to split the field 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] = [] }
+
+      # Now we can split the field 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.instance_variable_get('@' + field))
+        value *= multiplier
+
+        # Find the right set by looking at the maximum allowed values for each
+        # color.
+        colors.each.with_index do |col_max_value, i|
+          col, max_value = col_max_value
+          if max_value.nil? || value < max_value
+            # A 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, value ]
+            # Abort the color loop since we've found the right set already.
+            break
+          end
+        end
+      end
+
+      # Now generate the JS variable definitions for each set.
+      s = ''
+      data_sets.each do |index, ds|
+        s << "var #{field}_data_#{index} = [\n"
+        s << ds.map { |dp| "[ #{dp[0]}, #{dp[1]} ]" }.join(', ')
+        s << " ];\n"
+      end
+
+      s << "$.plot(\"##{field}_chart\", [\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]}\", " +
+             "            fill: true, radius: 2 } }"
+           end.join(', ')
+      s << "], { xaxis: { mode: \"time\" } });\n"
+
+      s
+    end
+
+    def chart_div(doc, field, title)
+      frame(doc, title) {
+        doc.div({ 'id' => "#{field}_chart", 'class' => 'chart-placeholder'})
+      }
+    end
+
+  end
+
+end
+