broutes 0.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzQyYjM1NDdiMDY2Njk3ZmJiOGY0NGM5YmMwYjU3MGVlNGZmMmE4Mg==
+  data.tar.gz: !binary |-
+    YTJiZjQ3Nzk5NTA1YTE1NzYwODA2YTlkNjQzYmJiMDQxNTljYzM0Yg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWRmMTYwMGY1OTQ1ODdhZWY2NjE1MzkyNmFjZDA5MzNlMjMxNmVkMzViMTA5
+    MGI4Yjk0ZTI2YTRkMjgwMDkxZjE5ZWZkMzE3MTQxN2M2YWU2OTAzYTNlMmQ4
+    YmYzM2JlOThiMTkxYzUzNmI2MjlmNDBmNmM5M2YzZWFkYmYzZjI=
+  data.tar.gz: !binary |-
+    Y2U5NmE5OWIyMzVhYzA3Y2FlMmNhN2M0MjA5YjdlYTU2NjVjMWQ2MmVkZGUw
+    NzQ4NWY0MTFmMDQwYzNlMjNjZTZlNzVhNTU0ZmNlOTZkNTBlMjZlY2ZkMTM1
+    Y2E5NjEzZWFiNGFmYmM5OTAzNDUxZDc0NDVkNGI4OGFhYTc5MDE=

data/lib/broutes/formats/factory.rb

@@ -0,0 +1,22 @@
+# Public : provides factory method for loading appropriate route file parser
+module Broutes::Formats
+  class Factory
+    # Public : factory method
+    #
+    # format   - Symbol describing the format [:gpx_track, :tcx, :fit]
+    #
+    # Returns a route file parser
+    def get(format)
+      case format
+      when :gpx_track, 'application/gpx+xml', /\.gpx$/
+        GpxTrack.new
+      when :tcx, 'application/vnd.garmin.tcx+xml', /\.tcx$/
+        Tcx.new
+      when :fit, 'application/vnd.ant.fit', /\.fit$/
+        FitFile.new
+      else
+        raise ArgumentError.new("Unrecognised format #{format}. Supported formats are :gpx_track, :tcx, :fit")
+      end
+    end
+  end
+end

data/lib/broutes/formats/fit_file.rb

@@ -0,0 +1,41 @@
+require 'fit'
+
+module Broutes::Formats
+  class FitFile
+
+    def load(file, route)
+      fit_file = Fit::File.read(file)
+      Broutes.logger.info {"Started fit processing"}
+      i = 0
+      fit_file.records.select {|r| r.content && r.content.record_type == :record }.each do |r|
+        begin
+          pr = r.content
+          data = { time: record_time(r) }
+          data[:lat] = convert_position(pr.position_lat) if pr.respond_to?(:position_lat)
+          data[:lon] = convert_position(pr.position_long) if pr.respond_to?(:position_long)
+          data[:elevation] = pr.altitude if pr.respond_to?(:altitude)
+          [:distance, :heart_rate, :power, :speed, :cadence, :temperature].each do |m| 
+            data[m] = pr.send(m) if pr.respond_to?(m) 
+          end
+
+          route.add_point(data)
+          i += 1
+        rescue => e
+          Broutes.logger.debug {"#{e.message} for #{r}"}
+        end
+      end
+      Broutes.logger.info {"Loaded #{i} data points"}
+    end
+
+    def convert_position(value)
+      (8.381903171539307e-08 * value).round(5)
+    end
+
+    def record_time(record)
+      utc_seconds = record.content.timestamp
+      utc_seconds += record.header.time_offset if record.header.compressed_timestamp? 
+      Time.new(1989, 12, 31) + utc_seconds
+    end
+
+  end
+end

data/lib/broutes/formats/gpx_route.rb

@@ -0,0 +1,9 @@
+require 'nokogiri'
+
+module Broutes::Formats
+  class GpxRoute
+    def load(file, route)
+
+    end
+  end
+end

data/lib/broutes/formats/gpx_track.rb

@@ -0,0 +1,30 @@
+require 'nokogiri'
+
+module Broutes::Formats
+  class GpxTrack
+
+    def load(file, route)
+      doc = Nokogiri::XML(file)
+      Broutes.logger.info {"Loaded #{file} into #{doc.to_s.slice(0, 10)}"}
+
+      i = 0
+      doc.css('trkpt').each do |node|
+        p = route.add_point(lat: node['lat'].to_f, lon: node['lon'].to_f, elevation: point_elevation(node), time: point_time(node))
+        i += 1
+      end
+      Broutes.logger.info {"Loaded #{i} data points"}
+    end
+
+    def point_elevation(node)
+      if elevation_node = node.at_css('ele')
+        elevation_node.inner_text.to_f
+      end
+    end
+
+    def point_time(node)
+      if time_node = node.at_css('time')
+        DateTime.parse(time_node.inner_text).to_time
+      end
+    end
+  end
+end

data/lib/broutes/formats/tcx.rb

@@ -0,0 +1,96 @@
+require 'nokogiri'
+
+module Broutes::Formats
+  class Tcx
+    def load(file, route)
+      doc = Nokogiri::XML(file)
+      Broutes.logger.info {"Loaded #{file} into #{doc.to_s.slice(0, 10)}"}
+
+      i = 0
+      doc.css('Trackpoint').each do |node|
+        data = {
+          elevation: point_elevation(node), 
+          time: point_time(node), 
+          distance: point_distance(node), 
+          heart_rate: point_heart_rate(node),
+          power: point_power(node),
+          speed: point_speed(node),
+          cadence: point_cadence(node)
+          }
+        if location = point_location(node)
+          data[:lat] = location[0]
+          data[:lon] = location[1]
+        end
+        
+        p = route.add_point(data)
+        i += 1
+      end
+      Broutes.logger.info {"Loaded #{i} data points"}
+
+      # Load in summary values if time and distance nil, ie no points
+      unless route.total_time
+        route.total_time = doc.css('Activities > Activity > Lap > TotalTimeSeconds').reduce(0) { |sum, node| 
+          sum + node.inner_text.to_i
+        }
+      end
+
+      unless route.total_distance
+        route.total_distance = doc.css('Activities > Activity > Lap > DistanceMeters').reduce(0) { |sum, node| 
+          sum + node.inner_text.to_i
+        }
+      end
+
+      unless route.started_at
+        route.started_at = DateTime.parse(doc.css('Activities > Activity > Lap').first['StartTime']).to_time
+      end
+    end
+
+    def point_location(node)
+      if position_node = node.at_css('Position')
+        [ position_node.at_css('LatitudeDegrees').inner_text.to_f, position_node.at_css('LongitudeDegrees').inner_text.to_f ]
+      end
+    end
+
+    def point_distance(node)
+      if distance_node = node.at_css('DistanceMeters')
+        distance_node.inner_text.to_f
+      end
+    end
+
+    def point_elevation(node)
+      if elevation_node = node.at_css('AltitudeMeters')
+        elevation_node.inner_text.to_f
+      end
+    end
+
+    def point_time(node)
+      if time_node = node.at_css('Time')
+        DateTime.parse(time_node.inner_text).to_time
+      end
+    end
+
+    def point_heart_rate(node)
+      if hr_node = node.at_css('HeartRateBpm')
+        hr_node.inner_text.to_i
+      end
+    end
+
+    def point_cadence(node)
+      if cadence_node = node.at_css('Cadence')
+        cadence_node.inner_text.to_i
+      end
+    end
+
+    def point_power(node)
+      if power_node = node.at_xpath('.//tpx:Watts', 'tpx' => 'http://www.garmin.com/xmlschemas/ActivityExtension/v2')
+        power_node.inner_text.to_i
+      end
+    end
+
+    def point_speed(node)
+      if speed_node = node.at_xpath('.//tpx:Speed', 'tpx' => 'http://www.garmin.com/xmlschemas/ActivityExtension/v2')
+        speed_node.inner_text.to_f
+      end
+    end
+  end
+end

data/lib/broutes/formats.rb

@@ -0,0 +1,9 @@
+module Broutes
+  module Formats
+    require_relative 'formats/factory'
+    require_relative 'formats/gpx_track'
+    require_relative 'formats/gpx_route'
+    require_relative 'formats/tcx'
+    require_relative 'formats/fit_file'
+  end
+end

data/lib/broutes/geo_point.rb

@@ -0,0 +1,56 @@
+require 'time'
+
+module Broutes
+  class GeoPoint
+    attr_accessor :lat, :lon, :elevation, :distance, :heart_rate, :power, :speed, :cadence, :temperature
+    attr_reader :time
+
+    def initialize(args={})
+      args.each_pair do |key, value| send("#{key}=", value) if respond_to?("#{key}=") end
+    end
+
+    def self.from_hash(h)
+      GeoPoint.new(h)
+    end
+
+    def has_location?
+      lat && lon
+    end
+
+    def time=(value)
+      if value.is_a?(String)
+        @time = DateTime.parse(value).to_time
+      else
+        @time = value
+      end
+    end
+
+    def ==(other)
+      lat == other.lat &&
+      lon == other.lon &&
+      elevation == other.elevation &&
+      distance == other.distance &&
+      time == other.time &&
+      heart_rate == other.heart_rate &&
+      power == other.power &&
+      speed == other.speed &&
+      cadence == other.cadence &&
+      temperature == other.temperature
+    end
+
+    def to_hash
+      h = {}
+      h['lat'] = lat if lat
+      h['lon'] = lon if lon
+      h['elevation'] = elevation if elevation
+      h['distance'] = distance if distance
+      h['time'] = time if time
+      h['heart_rate'] = heart_rate if heart_rate
+      h['power'] = power if power
+      h['speed'] = speed if speed
+      h['cadence'] = cadence if cadence
+      h['temperature'] = temperature if temperature
+      h
+    end
+  end
+end

data/lib/broutes/geo_route.rb

@@ -0,0 +1,109 @@
+module Broutes
+  class GeoRoute
+
+    attr_reader :start_point, :end_point, :started_at, :ended_at, :total_time
+    attr_writer :total_distance, :started_at
+    attr_accessor :total_time
+
+    def points
+      get_points.to_enum
+    end
+
+    def initialize(args={})
+      args.each_pair do |key, value| 
+        if key.to_sym == :points
+          value.each { |p| add_point(p) }
+        else
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+    end
+
+    def self.from_hash(h)
+      route = GeoRoute.new h
+    end
+
+    def to_hash
+      h = {
+        'total_distance' => total_distance,
+        'total_time' => total_time,
+        'total_ascent' => total_ascent,
+        'total_descent' => total_ascent,
+        'points' => points.collect { |p| p.to_hash }
+      }
+      h['start_point'] = start_point.to_hash if start_point
+      h['end_point'] = end_point.to_hash if end_point
+      h['started_at'] = @started_at if @started_at
+      h
+    end
+
+    def add_point(args)
+      point = GeoPoint.new(args)
+      if @start_point
+        if point.distance
+          @total_distance = point.distance
+        else
+          if distance = Maths.haversine_distance(@end_point, point)
+            @total_distance += distance
+          end
+        end
+
+        @total_time = point.time - @start_point.time if point.time
+      else
+        @start_point = point
+        @total_distance = point.distance || 0
+      end
+
+      point.distance = @total_distance
+      process_elevation_delta(@end_point, point)
+
+      @end_point = point
+      get_points << point
+    end
+
+    def process_elevation_delta(last_point, new_point)
+      if last_point && new_point && last_point.elevation && new_point.elevation
+        delta = new_point.elevation - last_point.elevation
+        @_total_ascent = self.total_ascent + (delta > 0 ? delta : 0)
+        @_total_descent = self.total_descent - (delta < 0 ? delta : 0)
+      end
+    end
+
+    def started_at
+      return @started_at if @started_at
+      @start_point.time if @start_point
+    end
+
+    def ended_at
+      @end_point.time if @end_point
+    end
+
+    def total_ascent
+      @_total_ascent ||= 0
+    end
+
+    def total_descent
+      @_total_descent ||= 0
+    end
+
+    # Public : Total distance measured between points in whole metres
+    #
+    # Returns Float distance in m
+    def total_distance
+      @total_distance.round if @total_distance
+    end
+
+    # Public : Measure of how hilly the route is. Measured as total ascent (m) / distance (km)
+    #
+    # Returns Float measure
+    def hilliness
+      (total_distance > 0) ? (total_ascent * 1000 / total_distance) : 0
+    end
+
+    private
+
+    def get_points
+      @_points ||= []
+    end
+  end
+end

data/lib/broutes/maths.rb

@@ -0,0 +1,26 @@
+module Broutes
+  module Maths
+    class << self
+      def haversine_distance(p1, p2)
+        return unless p1.has_location? && p2.has_location?
+        
+        dlat = p2.lat - p1.lat
+        dlon = p2.lon - p1.lon
+    
+        dlon_rad = dlon * RAD_PER_DEG
+        dlat_rad = dlat * RAD_PER_DEG
+    
+        lat1_rad = p1.lat * RAD_PER_DEG
+        lon1_rad = p1.lon * RAD_PER_DEG
+    
+        lat2_rad = p2.lat * RAD_PER_DEG
+        lon2_rad = p2.lon * RAD_PER_DEG
+    
+        a = (Math.sin(dlat_rad/2))**2 + Math.cos(lat1_rad) * Math.cos(lat2_rad) * (Math.sin(dlon_rad/2))**2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+    
+        EARTH_RADIUS * c
+      end
+    end
+  end
+end

data/lib/broutes/version.rb

@@ -0,0 +1,3 @@
+module Broutes
+  VERSION = "0.1.3".freeze
+end

data/lib/broutes.rb

@@ -0,0 +1,26 @@
+module Broutes
+  require 'logger'
+  require_relative 'broutes/geo_route'
+  require_relative 'broutes/geo_point'
+  require_relative 'broutes/maths'
+  require_relative 'broutes/formats'
+
+  RAD_PER_DEG = 0.017453293  #  PI/180
+  EARTH_RADIUS = 6371000 #m
+
+  def self.from_file(file, format)
+    raise "unable to interpret format #{format}" unless processor = Formats::Factory.new.get(format)
+    Broutes.logger.debug {"found processor #{processor} for #{file}"}
+    route = GeoRoute.new
+    processor.load(file, route)
+    route
+  end
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+end

data/spec/broutes/formats/factory_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Formats::Factory do
+  describe "#get" do
+
+    let(:factory) { Formats::Factory.new }
+
+    context "when :gpx_track passed" do
+      it "returns GpxTrack" do
+        factory.get(:gpx_track).should be_an_instance_of(Formats::GpxTrack)
+      end
+    end
+    context "when 'application/vnd.ant.fit' passed" do
+      it "returns FitFile" do
+        factory.get('application/vnd.ant.fit').should be_an_instance_of(Formats::FitFile)
+      end
+    end
+    context "when :fit passed" do
+      it "returns FitFile" do
+        factory.get(:fit).should be_an_instance_of(Formats::FitFile)
+      end
+    end
+    context "when unrecognised" do
+      it "raises ArgumentError nil" do
+        expect { factory.get(random_string) }.to raise_error(ArgumentError)
+      end
+    end
+    context "tcx filename" do
+      it "returns Tcx" do
+        factory.get("2012-12-30-12-23.tcx").should be_an_instance_of(Formats::Tcx)
+      end
+    end
+  end
+end

data/spec/broutes/formats/fit_file_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Formats::FitFile do
+  describe "#load" do
+    before(:all) do
+      @file = open_file('sample.fit')
+      @target = Formats::FitFile.new
+      @route = GeoRoute.new
+
+      @target.load(@file, @route)
+    end
+
+    it "sets the start point lat" do
+      @route.start_point.lat.should eq(52.93066)
+    end
+    it "sets the start point lon" do
+      @route.start_point.lon.should eq(-1.22402)
+    end
+    it "sets the heart rate" do
+      @route.start_point.heart_rate.should eq(88)
+    end
+    it "sets the power" do
+      @route.start_point.power.should eq(96)
+    end
+    it "extracts the cadence" do
+      @route.start_point.cadence.should eq(51)
+    end
+    it "extracts the speed" do
+      @route.start_point.speed.should eq(4.024)
+    end
+    it "extracts the speed" do
+      @route.start_point.temperature.should eq(11.0)
+    end
+    it "sets the total distance" do
+      @route.total_distance.should eq(92068)
+    end
+    it "sets the total ascent" do
+      @route.total_ascent.round.should eq(1176)
+    end
+    it "sets the total descent" do
+      @route.total_descent.round.should eq(1177)
+    end
+    it "sets the total time" do
+      @route.total_time.round.should eq(13675)
+    end
+    it "sets the started_at" do
+      @route.started_at.to_i.should eq(Time.new(2012, 5, 12, 7, 29, 45).to_i)
+    end
+    it "sets the ended_at" do
+      @route.ended_at.to_i.should eq(Time.new(2012, 5, 12, 11, 17, 40).to_i)
+    end
+
+  end
+end

data/spec/broutes/formats/gpx_route_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Formats::GpxRoute do
+  describe "#load" do
+    it "loads it properly"
+  end
+end

data/spec/broutes/formats/gpx_track_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Formats::GpxTrack do
+  describe "#load" do
+    before(:all) do
+      @file = open_file('single_lap_gpx_track.gpx')
+      @target = Formats::GpxTrack.new
+      @route = GeoRoute.new
+
+      @target.load(@file, @route)
+    end
+
+    it "sets the start point lat" do
+      @route.start_point.lat.should eq(52.9552055)
+    end
+    it "sets the start point lon" do
+      @route.start_point.lon.should eq(-1.1558583)
+    end
+    it "sets the total distance" do
+      @route.total_distance.should eq(7088)
+    end
+    it "sets the total ascent" do
+      @route.total_ascent.round.should eq(34)
+    end
+    it "sets the total descent" do
+      @route.total_descent.round.should eq(37)
+    end
+    it "sets the total time" do
+      @route.total_time.round.should eq(1231)
+    end
+    it "sets the started_at" do
+      @route.started_at.to_i.should eq(Time.new(2011, 5, 19, 17, 57, 21).to_i)
+    end
+    it "sets the ended_at" do
+      @route.ended_at.to_i.should eq(Time.new(2011, 5, 19, 18, 17, 52).to_i)
+    end
+  end
+  describe "when file doesn't have elevation" do
+    before(:all) do
+      @file = open_file('single_lap_gpx_track_no_elevation.gpx')
+      @target = Formats::GpxTrack.new
+      @route = GeoRoute.new
+
+      @target.load(@file, @route)
+    end
+
+    it "sets the start point lat" do
+      @route.start_point.lat.should eq(52.926467718938)
+    end
+    it "sets the start point lon" do
+      @route.start_point.lon.should eq(-1.216092432889)
+    end
+    it "sets the total distance" do
+      @route.total_distance.should eq(123955)
+    end
+    it "sets the total ascent" do
+      @route.total_ascent.should eq(0)
+    end
+    it "sets the total descent" do
+      @route.total_descent.should eq(0)
+    end
+  end
+end