stressfactor 0.0.1

data/lib/stressfactor/average_pace_accumulator.rb

@@ -0,0 +1,24 @@
+module Stressfactor
+  class AveragePaceAccumulator
+    attr_accessor :intervals
+
+    def initialize(intervals)
+      @intervals = intervals
+    end
+
+    def average_pace(strategy: :raw)
+      strategy_klass = strategy == :raw ? RawPaceStrategy : GradeAdjustedPaceStrategy
+      intervals.inject(0) do |acc, interval|
+        weighted_interval = (interval.distance / total_distance) * strategy_klass.calculate_for_interval(interval)
+        acc + weighted_interval
+      end
+    end
+    private
+    # Total elapsed time in minutes
+    def total_distance
+      @total_distance ||= intervals.inject(0) do |acc, interval|
+        acc + interval.distance
+      end
+    end
+  end
+end

data/lib/stressfactor/gpx_loader.rb

@@ -0,0 +1,39 @@
+module Stressfactor
+  class GpxLoader
+    attr_reader :gpx
+
+    def initialize(gpx_file_path)
+      @gpx = GPX::GPXFile.new(gpx_file: gpx_file_path)
+    end
+
+    # units: seconds
+    def total_time
+      intervals.inject(0) do |acc, i|
+        acc + i.time
+      end
+    end
+
+    # An array of instantaneous pace times in min/km from comparing
+    # two trackpoints
+    def intervals
+      @intervals ||= begin
+        points.map do |p1|
+          idx = points.index(p1)
+          p2 = points[idx+1]
+
+          if p2
+            Interval.new(p1, p2)
+          else
+            nil
+          end
+        end
+      end
+      @intervals.compact
+    end
+
+    # An array of GPX::TrackPoint objects.
+    def points
+      @points ||= gpx.tracks.flat_map(&:points)
+    end
+  end
+end

data/lib/stressfactor/grade_adjusted_pace_strategy.rb

@@ -0,0 +1,24 @@
+# Inspired by the work CTM Davies' research, as discussed by the Strava
+# blog: http://engineering.strava.com/improving-grade-adjusted-pace/
+module Stressfactor
+  class GradeAdjustedPaceStrategy < PaceStrategy
+    attr_accessor :interval
+
+    def self.calculate_for_interval(interval)
+      observed_pace = interval.time(units: :minutes) / interval.distance
+      interval.grade > 0 ? incline_pace(interval, observed_pace) : decline_pace(interval, observed_pace)
+    end
+
+    def self.decline_pace(interval, observed_pace)
+      coefficient_per_grade_point = 0.01815
+      grade = interval.grade
+      observed_pace / (1 - (coefficient_per_grade_point * grade))
+    end
+
+    def self.incline_pace(interval, observed_pace)
+      coefficient_per_grade_point = 0.033
+      grade = interval.grade
+      observed_pace / (1 + (coefficient_per_grade_point * grade))
+    end
+  end
+end

data/lib/stressfactor/interval.rb

@@ -0,0 +1,35 @@
+module Stressfactor
+  class Interval
+    attr_accessor :start_point, :end_point
+
+    def initialize(start_point, end_point)
+      @start_point = start_point
+      @end_point = end_point
+    end
+
+    # time in seconds
+    def time(options={})
+      delta = end_point.time - start_point.time
+      delta /= 60.0 if options[:units] == :minutes
+      delta
+    end
+
+    # distance in km
+    def distance
+      end_point.haversine_distance_from(start_point)
+    end
+
+    # grade in percent incline/decline
+    def grade
+      elevation_change = end_point.elevation - start_point.elevation
+      # Normalize to meters
+      distance_change = distance * 1000
+      radians = Math.atan(elevation_change / distance_change)
+      180 * radians / Math::PI
+    end
+
+    def to_s
+      "i: #{time}s | #{distance * 1000}m | #{grade}%"
+    end
+  end
+end

data/lib/stressfactor/pace_calculator.rb

@@ -0,0 +1,24 @@
+require "ostruct"
+
+module Stressfactor
+  class PaceCalculator
+    attr_accessor :gpx_loader
+
+    def initialize(gpx_loader)
+      @gpx_loader = gpx_loader
+    end
+
+    def calculate(strategy: :grade_adjusted, units: :metric)
+      pace = AveragePaceAccumulator.new(intervals).average_pace(strategy: strategy)
+      pace *= (1/0.621371) if units == :english
+      pace
+    end
+
+    private
+
+    def intervals
+      gpx_loader.intervals
+    end
+  end
+end
+

data/lib/stressfactor/pace_strategy.rb

@@ -0,0 +1,11 @@
+# Abstract base class for pace strategies.
+module Stressfactor
+  class PaceStrategy
+    attr_reader :intervals
+
+    def initialize(intervals)
+      @intervals = intervals
+    end
+
+  end
+end

data/lib/stressfactor/raw_pace_strategy.rb

@@ -0,0 +1,14 @@
+# Take the exact average over all paces over the set of
+# run intervals.
+module Stressfactor
+  class RawPaceStrategy < PaceStrategy
+
+    def self.calculate_for_interval(interval)
+      interval.time(units: :minutes) / interval.distance
+    end
+
+    def calculate
+      AveragePaceAccumulator.new(intervals).average_pace(strategy: :raw)
+    end
+  end
+end

data/lib/stressfactor/stress_calculator.rb

@@ -0,0 +1,29 @@
+# Implements the actual TSS algorithm.
+module Stressfactor
+  class StressCalculator
+    attr_reader :threshold_pace, :loader
+
+    def initialize(threshold_pace: threshold_pace, loader: loader)
+      @threshold_pace = threshold_pace
+      @loader = loader
+    end
+
+    def calculate
+      (total_time * normalized_graded_pace * intensity_factor * 100) / (threshold_pace * 3600)
+    end
+
+    private
+
+    def total_time
+      loader.total_time
+    end
+
+    def intensity_factor
+      normalized_graded_pace / threshold_pace
+    end
+
+    def normalized_graded_pace
+      @normalized_graded_pace ||= PaceCalculator.new(loader).calculate(strategy: :grade_adjusted, units: :metric)
+    end
+  end
+end

data/lib/stressfactor/version.rb

@@ -0,0 +1,3 @@
+module Stressfactor
+  VERSION = "0.0.1"
+end

data/scripts/analyze_sample_gpx.rb

@@ -0,0 +1,7 @@
+require_relative "../lib/stressfactor"
+require "pry"
+file = GPX::GPXFile.new(:gpx_file => "examples/data/sample.gpx")
+pc = Stressfactor::PaceCalculator.new(file)
+pace = pc.calculate
+puts pace
+binding.pry

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+require_relative "../lib/stressfactor.rb"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/stressfactor/gpx_loader_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Stressfactor::GpxLoader do
+  let(:intervals) do
+    [Stressfactor::Interval.new(p1, p2),
+     Stressfactor::Interval.new(p2, p3)]
+  end
+
+  let(:end_time) { Time.now }
+  let(:p1) do
+    GPX::TrackPoint.new(
+      :lat => 37.7985474,
+      :lon => -122.2554386,
+      :elevation => 10.0,
+      :time => end_time - 10
+    )
+  end
+
+  let(:p2) do
+    GPX::TrackPoint.new(
+      :lat => 37.7985583,
+      :lon => -122.2554564,
+      :elevation => 15.0,
+      :time => end_time - 3
+    )
+  end
+
+  let(:p3) do
+    GPX::TrackPoint.new(
+      :lat => 37.7986548,
+      :lon => -122.2555806,
+      :elevation => 10.0,
+      :time => end_time
+    )
+  end
+
+  let(:path) { "path/to/gpx.gpx" }
+  let(:points) { [p1, p2, p3] }
+  let(:gpx) { double("gpx") }
+  let(:track) { double("track", points: points) }
+  subject { Stressfactor::GpxLoader.new(path) }
+
+  before do
+    expect(GPX::GPXFile).to receive(:new).and_return(gpx)
+    expect(gpx).to receive(:tracks).and_return([track])
+  end
+
+  describe "#intervals" do
+    it "returns two intervals" do
+      expect(subject.intervals).to be_all{|i| i.is_a?(Stressfactor::Interval)}
+    end
+  end
+
+  describe "#total_time" do
+    it "returns correct elapsed time" do
+      expect(subject.total_time).to eq 10
+    end
+  end
+end

data/spec/stressfactor/grade_adjusted_pace_strategy_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Stressfactor::GradeAdjustedPaceStrategy do
+  let(:end_time) { Time.now }
+  let(:p1) do
+    GPX::TrackPoint.new(
+      :lat => 37.7985474,
+      :lon => -122.2554386,
+      :elevation => 10.0,
+      :time => end_time - 10
+    )
+  end
+  let(:p2) do
+    GPX::TrackPoint.new(
+      :lat => 37.7985583,
+      :lon => -122.2554564,
+      :elevation => 15.0,
+      :time => end_time - 3
+    )
+  end
+  let(:p3) do
+    GPX::TrackPoint.new(
+      :lat => 37.7986548,
+      :lon => -122.2555806,
+      :elevation => 10.0,
+      :time => end_time
+    )
+  end
+
+  let(:intervals) do
+    [interval]
+  end
+
+  let(:interval) { Stressfactor::Interval.new(p1, p2) }
+
+  subject { described_class.new(intervals) }
+
+  describe ".calculate_for_interval" do
+    subject { described_class.calculate_for_interval(interval) }
+
+    it "compensates for the negative coefficient of 3.3% for every 1% incline" do
+      expected_pace = 18.100632981302162
+      expect(subject).to eq expected_pace
+    end
+
+    context "for declines" do
+      let(:interval) { Stressfactor::Interval.new(p2, p3) }
+
+      it "compensates for the positive coefficient of 1.815% for every 1% decline" do
+        expected_pace = 2.459421791214623
+        expect(subject).to eq expected_pace
+      end
+    end
+  end
+end

data/spec/stressfactor/interval_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Stressfactor::Interval do
+  subject { described_class.new(p1, p2) }
+  let(:t1) { Time.now }
+  let(:t2) { t1 + 3 }
+  let(:t3) { t1 + 6 }
+  let(:p1) { GPX::TrackPoint.new(:time => t1, :lat => 0.00001, :lon => 0.00001, :elevation => 10) }
+  let(:p2) { GPX::TrackPoint.new(:time => t2, :lat => 0.00002, :lon => 0.00002, :elevation => 15) }
+  let(:p3) { GPX::TrackPoint.new(:time => t3, :elevation => 5) }
+
+  describe "#time" do
+    context "for adjacent points" do
+      it "calculates the time between the two points" do
+        expect(subject.time).to eq(3)
+      end
+    end
+
+    it "calculates time in minutes" do
+      expect(subject.time(units: :minutes)).to eq(0.05)
+    end
+
+    context "for a different set of points" do
+      subject { described_class.new(p1, p3) }
+
+      it "calculates the time between a second set of points" do
+        expect(subject.time).to eq(6)
+      end
+    end
+  end
+
+  describe "#distance" do
+    it "returns haversine distance from one point to the other" do
+      expect(p2).to receive(:haversine_distance_from).with(p1).and_return(10)
+      expect(subject.distance).to eq(10)
+    end
+  end
+
+  describe "#grade" do
+    it "returns the integer angle in radians of the elevation change" do
+      expected_grade = 72.54128654632675
+      expect(subject.grade).to eq(expected_grade)
+    end
+  end
+
+  describe "#to_s" do
+    it "returns a string with debug info" do
+      expect(subject.to_s).to be_instance_of String
+    end
+  end
+end