quickroute 0.1.0

data/README.md

@@ -0,0 +1,29 @@
+# QuickRoute JPEG Parser for Ruby
+
+Parses the GPS data embedded to JPEG files output by [QuickRoute](http://www.matstroeng.se/quickroute/en/).
+
+© Jarkko Laine 2011. Licensed under the [WTFPL](http://en.wikipedia.org/wiki/WTFPL).
+
+## Installation
+
+    gem install quickroute
+
+
+**Note!** Only works in Ruby >1.9.2
+
+## Usage
+
+```ruby
+@filename = '2010-silja-rastit.jpg'
+qp = QuickrouteJpegParser.new(@filename, true) # true => calculates
+times and distances.
+qp.sessions.first.route.elapsed_time / 60
+# => 43.766666666666666
+qp.sessions.first.route.segments.first.waypoints.size
+# => 992
+qp.sessions.first.route.segments.first.waypoints.map{|wp| [wp.position.longitude, wp.position.latitude]}
+# => [[22.78103777777778, 60.29233194444444], 
+#     ...
+#     [22.77652638888889, 60.293416388888886],
+#     [22.77655638888889, 60.29344361111111]]
+```

data/lib/date_time_parser.rb

@@ -0,0 +1,12 @@
+module DateTimeParser
+  def read_date_time(data)
+    val = BinData::Uint64le.read(data)
+    LOGGER.debug "val is #{val.inspect}"
+    val -= 9223372036854775808 if val >= 9223372036854775808
+    val -= 4611686018427387904 if val >= 4611686018427387904
+    LOGGER.debug "after tweaks val is #{val.inspect}"
+    val = (val - 621355968000000000) / 10000000.0
+    LOGGER.debug "time was #{Time.at(val)}"
+    val
+  end
+end

data/lib/handle.rb

@@ -0,0 +1,31 @@
+require 'matrix'
+
+class Handle
+  attr_reader :transformation_matrix,
+              :parameterized_location,
+              :pixel_location,
+              :type
+
+  include BinData
+  def initialize(data)
+    @transformation_matrix = Matrix.build(3,3) do
+      DoubleLe.read(data)
+    end
+    LOGGER.debug "matrix is #{@transformation_matrix.inspect}"
+    @parameterized_location = ParameterizedLocation.new(
+      BinData::Uint32le.read(data),
+      DoubleLe.read(data)
+    )
+    LOGGER.debug "parameterized location is #{@parameterized_location.inspect}"
+
+    # pixel location
+    @pixel_location = Point.new(
+      DoubleLe.read(data),
+      DoubleLe.read(data)
+    )
+    LOGGER.debug "pixel_location is #{@pixel_location.inspect}"
+
+    @type = BinData::Int16le.read(data)
+    LOGGER.debug "handle type is #{@type}"
+  end
+end

data/lib/jpeg_reader.rb

@@ -0,0 +1,35 @@
+module JpegReader
+  def self.fetch_data_from(filename)
+    data = ""
+
+    File.open(filename, "r") do |f|
+      if f.read(2) == "\xff\xd8".to_b
+        while !f.eof?
+          break if f.read(1) != "\xff".to_b
+
+          if f.read(1) == "\xe0".to_b # APP0
+            quickroute_segment = false
+            length = BinData::Uint16be.read(f)
+
+            if length >= 12
+              if f.read(10) == "QuickRoute".to_b
+                data << f.read(length - 12)
+                quickroute_segment = true
+              else
+                f.seek(length - 12, ::IO::SEEK_CUR)
+              end
+            else
+              f.seek(length - 2, ::IO::SEEK_CUR)
+            end
+
+            break if !quickroute_segment && !data.empty?
+          else
+            break
+          end
+        end
+      end
+    end
+
+    data
+  end
+end

data/lib/lap.rb

@@ -0,0 +1,25 @@
+class Lap
+  TYPES = {
+    :start => 0,
+    :lap   => 1,
+    :stop  => 2
+  }
+
+  attr_reader :time, :type
+  attr_accessor :position, :distance, :straight_line_distance
+
+  include DateTimeParser
+
+  def initialize(data = nil)
+    read_data(data) if data
+  end
+
+  def read_data(data)
+    @time = read_date_time(data)
+    @type = BinData::Uint8be.read(data)
+  end
+
+  def is_of_type?(*types)
+    types.any?{|t| type == TYPES[t]}
+  end
+end

data/lib/long_lat.rb

@@ -0,0 +1,53 @@
+class LongLat
+  # earth radius in meters
+  RHO = 6378200
+
+  attr_accessor :longitude, :latitude
+
+  def initialize(longitude, latitude)
+    @longitude, @latitude = longitude, latitude
+  end
+
+  def self.from_data(data)
+    new(
+      BinData::Int32le.read(data) / 3600000.0,
+      BinData::Int32le.read(data) / 3600000.0
+    )
+  end
+
+  def distance_to(other)
+    distance_point_to_point(point_matrix, other.point_matrix)
+  end
+
+  def point_matrix
+    Matrix[[RHO * sin_phi * cos_theta],
+           [RHO * sin_phi * sin_theta],
+           [RHO * cos_phi]]
+  end
+
+  private
+
+  def sin_phi
+    Math::sin(0.5 * Math::PI + latitude / 180 * Math::PI)
+  end
+
+  def cos_phi
+    Math::cos(0.5 * Math::PI + latitude / 180 * Math::PI)
+  end
+
+  def sin_theta
+    Math::sin(longitude / 180 * Math::PI)
+  end
+
+  def cos_theta
+    Math::cos(longitude / 180 * Math::PI)
+  end
+
+  def distance_point_to_point(p0, p1)
+    sum = 0
+    p0.each_with_index do |el, row, col|
+      sum += ((p1[row, col] - el)**2)
+    end
+    Math.sqrt(sum)
+  end
+end

data/lib/parameterized_location.rb

@@ -0,0 +1,8 @@
+class ParameterizedLocation
+  attr_reader :segment_index, :value
+
+  def initialize(segment_index, value)
+    @segment_index = segment_index
+    @value = value
+  end
+end

data/lib/parse_test.rb

@@ -0,0 +1,4 @@
+require_relative 'quickroute'
+@filename = "../2010-ankkurirastit.jpg"
+qp = QuickrouteJpegParser.new(@filename, false)
+LOGGER.debug qp.inspect

data/lib/person.rb

@@ -0,0 +1,16 @@
+class Person
+  attr_reader :name, :club, :id
+
+  def initialize(data)
+    length = BinData::Uint16le.read(data)
+    LOGGER.debug "person length is #{length}"
+    @name = BinData::String.new(:length => length).read(data)
+    LOGGER.debug "person name is #{@name}"
+    length = BinData::Uint16le.read(data)
+    LOGGER.debug "club length is #{length}"
+    @club = BinData::String.new(:length => length).read(data)
+
+    @id = BinData::Uint32be.read(data)
+    LOGGER.debug "id is #{@id}"
+  end
+end

data/lib/point.rb

@@ -0,0 +1,7 @@
+class Point
+  attr_reader :x, :y
+
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+end

data/lib/quickroute.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bindata'
+require "logger"
+require 'binary_search/pure'
+
+require_relative 'string_extensions'
+require_relative 'tag_data_extractor'
+require_relative 'date_time_parser'
+require_relative 'jpeg_reader'
+
+require_relative 'handle'
+require_relative 'point'
+require_relative 'parameterized_location'
+require_relative 'lap'
+require_relative 'person'
+require_relative 'route'
+require_relative 'route_segment'
+require_relative 'session'
+require_relative 'session_info'
+require_relative 'waypoint'
+
+require_relative 'long_lat'
+require_relative 'rectangle'
+require_relative 'quickroute_jpeg_parser'
+
+LOGGER = Logger.new(STDOUT)
+LOGGER.level = Logger::WARN
+
+#@filename = "../2010-ankkurirastit.jpg"
+#@f = File.open(@filename, 'r')

data/lib/quickroute_jpeg_parser.rb

@@ -0,0 +1,108 @@
+TAGS ={
+  1  => :version,
+  2  => :map_corner_positions,
+  3  => :image_corner_positions,
+  4  => :map_location_and_size_in_pixels,
+  5  => :sessions,
+  6  => :session,
+  7  => :route,
+  8  => :handles,
+  9  => :projection_origin,
+  10 => :laps,
+  11 => :session_info
+}
+
+class QuickrouteJpegParser
+  include BinData
+  attr_reader :sessions, :map_corner_positions, :image_corner_positions,
+              :map_location_and_size_in_pixels, :version
+
+  def initialize(filename, calculate)
+    @map_corner_positions = {}
+    @image_corner_positions = {}
+
+    start_time = Time.now
+
+    data = fetch_data_from(filename)
+
+    if !data.empty?
+      process_data(data)
+      calculate_data if calculate
+    end
+
+    end_time = Time.now
+    @execution_time = end_time - start_time
+  end
+
+  private
+
+  def calculate_data
+    sessions.each{|s| s.calculate}
+  end
+
+  def fetch_data_from(filename)
+    JpegReader.fetch_data_from(filename)
+  end
+
+  def process_data(data)
+    LOGGER.debug "Starting to process data"
+    data = StringIO.new(data)
+
+    while !data.eof?
+      tag = TagDataExtractor.read(data)
+      LOGGER.debug "tag: #{tag.inspect}, tag length: #{tag.data_length.inspect}"
+      read_tag(tag, data)
+    end
+  end
+
+  def read_tag(tag, data)
+    send("set_#{TAGS[tag.tag]}", data)
+  end
+
+  def set_version(data)
+    LOGGER.debug "Reading version number"
+    @version = version_number(data)
+    LOGGER.debug "version is: #{@version}"
+  end
+
+  def set_map_corner_positions(data)
+    LOGGER.debug "Reading map corner positions:"
+    @map_corner_positions = corner_positions(data)
+    LOGGER.debug "#{@map_corner_positions.inspect}"
+  end
+
+  def set_image_corner_positions(data)
+    LOGGER.debug "Reading image corner number"
+    @image_corner_positions = corner_positions(data)
+    LOGGER.debug "#{@image_corner_positions.inspect}"
+  end
+
+  def set_map_location_and_size_in_pixels(data)
+    LOGGER.debug "Reading map location and size"
+    @map_location_and_size_in_pixels = Rectangle.read(data)
+    LOGGER.debug "#{@map_location_and_size_in_pixels.inspect}"
+  end
+
+  def set_sessions(data)
+    @sessions = Session.read_sessions(data)
+  end
+
+  def corner_positions(data)
+    {:sw => read_long_lat(data),
+      :nw => read_long_lat(data),
+      :ne => read_long_lat(data),
+      :se => read_long_lat(data)}
+  end
+
+  def version_number(data)
+    [BinData::Uint8be.read(data),
+      BinData::Uint8be.read(data),
+      BinData::Uint8be.read(data),
+      BinData::Uint8be.read(data)].join(".")
+  end
+
+  def read_long_lat(data)
+    LongLat.from_data(data)
+  end
+
+end

data/lib/rectangle.rb

@@ -0,0 +1,7 @@
+class Rectangle < BinData::Record
+  endian :little
+  uint16 :x
+  uint16 :y
+  uint16 :width
+  uint16 :height
+end

data/lib/route.rb

@@ -0,0 +1,100 @@
+class Route
+  WAYPOINT_ATTRIBUTES = {
+    :position => 1,
+    :time => 2,
+    :heart_rate => 4,
+    :altitude => 8
+  }
+
+  attr_reader :attributes, :extra_waypoints_attributes_length,
+    :segments, :distance, :elapsed_time
+
+  def self.from_data(data)
+    new.read_data(data)
+  end
+
+  def initialize
+    LOGGER.debug "initializing new route"
+    @segments = []
+    @distance = 0
+    @elapsed_time = 0
+  end
+
+  def read_data(data)
+    @attributes = BinData::Uint16le.read(data)
+    @extra_waypoints_attributes_length = BinData::Uint16be.read(data)
+    read_segments_from(data)
+    self
+  end
+
+  def has_attribute?(attribute)
+    0 != (attributes & WAYPOINT_ATTRIBUTES[attribute])
+  end
+
+  def calculate_parameters
+    segments.each{|s| s.calculate_waypoints}
+  end
+
+  def parameterized_location_from_time(time)
+    return unless segment = segment_for_time(time)
+    segment.parameterized_location_from_time(time)
+  end
+
+  def position_from_parameterized_location(location)
+    return unless location
+    w0, w1, t = waypoints_and_parameter_from_parameterized_location(location)
+
+    LongLat.new(
+      w0.position.longitude + t * (w1.position.longitude - w0.position.longitude),
+      w0.position.latitude + t * (w1.position.latitude - w0.position.latitude)
+    )
+  end
+
+  def distance_from_parameterized_location(location)
+    return unless location
+    w0, w1, t = waypoints_and_parameter_from_parameterized_location(location)
+    w0.distance + t * (w1.distance - w0.distance)
+  end
+
+  def waypoints_and_parameter_from_parameterized_location(location)
+    return unless location && segment = segments[location.segment_index]
+
+    waypoints = segment.waypoints
+
+    value = location.value.to_i
+
+    if value >= waypoints.size - 1
+      value = waypoints.size - 2
+    end
+
+    t = location.value - value
+
+    waypoints.size < 2 ?
+      [waypoints[0], waypoints[0], 0] :
+      [waypoints[value], waypoints[value + 1], t]
+  end
+
+  def add_distance(dist)
+    @distance += dist
+  end
+
+  def add_elapsed_time(time)
+    @elapsed_time += time
+  end
+
+  private
+
+  def segment_for_time(time)
+    segments.find{|s| s.has_time?(time) }
+  end
+
+  def read_segments_from(data)
+    segment_count = BinData::Uint32le.read(data)
+    LOGGER.debug "reading #{segment_count} segments"
+    segment_count.times do |i|
+      segment = RouteSegment.new(self, data)
+
+      @segments << segment
+    end
+  end
+end

data/lib/route_segment.rb

@@ -0,0 +1,77 @@
+class RouteSegment
+  EPSILON = 0.001
+
+  attr_accessor :route, :last_time
+  attr_reader :waypoints
+
+  def initialize(route, data = nil)
+    LOGGER.debug "Initializing route segment"
+    @route = route
+
+    @waypoints = []
+    read_waypoints(data) if data
+  end
+
+  def read_waypoints(data)
+    waypoint_count = BinData::Uint32le.read(data)
+    LOGGER.debug "reading #{waypoint_count} waypoints"
+    waypoint_count.times do |j|
+      waypoint = Waypoint.new(self, data)
+      add_waypoint(waypoint)
+      @last_time = waypoint.time
+    end
+  end
+
+  def add_waypoint(*points)
+    points.each do |point|
+      waypoints << point
+    end
+  end
+
+  def calculate_waypoints
+    segment_distance = 0
+    waypoints.each_with_index do |wp, idx|
+      segment_distance += (idx == 0 ? 0 : wp.distance_to(waypoints[idx - 1]))
+      wp.distance = route.distance + segment_distance
+
+      wp.elapsed_time = route.elapsed_time + wp.time - waypoints.first.time
+    end
+    @route.add_distance(segment_distance)
+    @route.add_elapsed_time(waypoints.last.time - waypoints.first.time)
+  end
+
+  def index
+    @route.segments.index(self)
+  end
+
+  def parameterized_location_from_time(time)
+    lower, upper = 0, waypoints.size - 1
+
+    # Binary search to find the closest waypoint
+    while lower <= upper
+      idx = lower + (upper - lower) / 2
+      currtime = waypoints[idx].time
+      if (time - currtime).abs < EPSILON
+        return ParameterizedLocation.new(index, idx)
+      end
+
+      if time < currtime
+        upper = idx - 1
+      else
+        lower = idx + 1
+      end
+    end
+
+    t0 = waypoints[upper].time
+    t1 = waypoints[lower].time
+    if t1 == t0
+      return ParameterizedLocation.new(index, upper)
+    end
+
+    ParameterizedLocation.new(index, upper + (time - t0) / (t1 - t0))
+  end
+
+  def has_time?(time)
+    ((waypoints.first.time - EPSILON)..(waypoints.last.time + EPSILON)).include?(time)
+  end
+end

data/lib/session.rb

@@ -0,0 +1,113 @@
+class Session
+  include BinData
+  attr_accessor :route
+  attr_reader :laps, :handles,
+    :projection_origin, :session_info,
+    :straight_line_distance
+
+  def self.read_sessions(data)
+    sessions = []
+    session_count = BinData::Uint32le.read(data)
+    LOGGER.debug "reading #{session_count} sessions"
+
+    session_count.times do |i|
+      tag = TagDataExtractor.read(data)
+
+      LOGGER.debug "in session #{i}, tag is #{tag} and is #{tag.data_length} bytes long"
+
+      if TAGS[tag.tag] == :session
+        sessions << read_session(data, tag.data_length)
+      end
+    end
+    sessions
+  end
+
+  def self.read_session(data, tag_data_length)
+    new.parse_data(data, tag_data_length)
+  end
+
+  def initialize
+    @laps = []
+    @handles = []
+    @straight_line_distance = 0
+    LOGGER.debug "Reading new session"
+  end
+
+  def calculate
+    LOGGER.debug("starting to calculate shit for #{self.inspect}")
+    route.calculate_parameters
+    calculate_laps
+  end
+
+  def calculate_laps
+    last_distance, last_lap = 0, nil
+
+    @laps.each do |lap|
+      pl = route.parameterized_location_from_time(lap.time)
+      lap.position = route.position_from_parameterized_location(pl)
+
+      distance = route.distance_from_parameterized_location(pl)
+      if lap.is_of_type?(:lap, :stop)
+        lap.distance = distance - last_distance
+
+        if last_lap
+          lap.straight_line_distance = lap.position.distance_to(last_lap.position)
+        else
+          lap.straight_line_distance = 0
+        end
+        @straight_line_distance += lap.straight_line_distance
+      end
+      last_distance = distance
+      last_lap = lap
+    end
+
+    LOGGER.debug("Laps after calculation: #{@laps.inspect}")
+  end
+
+  def parse_data(data, tag_data_length)
+    start_pos = data.pos
+    while data.pos < (start_pos + tag_data_length)
+      tag = TagDataExtractor.read(data)
+
+      LOGGER.debug "tag is #{tag}, #{tag.data_length} bytes"
+
+      send("set_#{TAGS[tag.tag]}", data)
+    end
+    self
+  end
+
+  private
+
+  def set_route(data)
+    LOGGER.debug "reading route"
+    @route = Route.new.read_data(data)
+  end
+
+  def set_handles(data)
+    LOGGER.debug "reading handles"
+    handle_count = Uint32le.read(data)
+    LOGGER.debug "reading #{handle_count} handles"
+    handle_count.times do |i|
+      @handles << Handle.new(data)
+    end
+  end
+
+  def set_projection_origin(data)
+    LOGGER.debug "reading project origin"
+    @projection_origin = LongLat.from_data(data)
+  end
+
+  def set_laps(data)
+    LOGGER.debug "reading laps"
+    lap_count = Uint32le.read(data)
+    LOGGER.debug "reading #{lap_count} laps"
+    lap_count.times do
+      @laps << Lap.new(data)
+    end
+  end
+
+  def set_session_info(data)
+    LOGGER.debug "reading session info"
+    @session_info = SessionInfo.new(data)
+  end
+end

data/lib/session_info.rb

@@ -0,0 +1,11 @@
+class SessionInfo
+  attr_reader :person
+
+  def initialize(data)
+    @person = Person.new(data)
+
+    length = BinData::Uint16le.read(data)
+    LOGGER.debug "description length is #{length}"
+    @description = BinData::String.new(:length => length).read(data)
+  end
+end

data/lib/string_extensions.rb

@@ -0,0 +1,5 @@
+class String
+  def to_b
+    BinData::String.new(self).to_binary_s
+  end
+end

data/lib/tag_data_extractor.rb

@@ -0,0 +1,5 @@
+class TagDataExtractor < BinData::Record
+  endian  :little
+  uint8be :tag
+  uint32  :data_length
+end

data/lib/waypoint.rb

@@ -0,0 +1,58 @@
+class Waypoint
+  include BinData
+  include DateTimeParser
+
+  attr_reader :segment, :time, :heart_rate, :altitude
+  attr_accessor :distance, :position, :elapsed_time
+
+  def initialize(segment, data = nil)
+    @segment = segment
+    @distance = 0
+    read_data(data) if data
+  end
+
+  def read_data(data)
+    if route.has_attribute?(:position)
+      LOGGER.debug "route did have the position attribute"
+      @position = LongLat.from_data(data)
+      LOGGER.debug "waypoint position: #{@position.inspect}"
+    end
+
+    if route.has_attribute?(:time)
+      LOGGER.debug "route did have the time attribute"
+      time_type = BinData::Uint8le.read(data)
+      if time_type == 0
+        time = read_date_time(data)
+      else
+        time = last_time + BinData::Uint16le.read(data) / 1000
+      end
+      LOGGER.debug "time was #{Time.at(time)}"
+      @time = time
+    end
+
+    if route.has_attribute?(:heart_rate)
+      LOGGER.debug "route did have the heart rate attribute"
+      @heartrate = Uint8be.read(data)
+    end
+
+    if route.has_attribute?(:altitude)
+      LOGGER.debug "route did have the altitude attribute"
+      @altitude = Uint16le.read(data)
+      LOGGER.debug "altitude was #{@altitude}"
+    end
+
+    data.seek(route.extra_waypoints_attributes_length, ::IO::SEEK_CUR)    
+  end
+
+  def last_time
+    segment.last_time
+  end
+
+  def route
+    segment.route
+  end
+
+  def distance_to(other)
+    position.distance_to(other.position)
+  end
+end

data/spec/integration/parsing_spec.rb

@@ -0,0 +1,108 @@
+require_relative '../spec_helper'
+
+describe "Parsing existing jpg file without calculation" do
+  before(:all) do
+    @filename = File.join(File.expand_path(File.dirname(__FILE__)),
+                          '../fixtures/2010-Ankkurirastit.jpg')
+
+    @qp = QuickrouteJpegParser.new(File.join(@filename), false)
+  end
+
+  it "should have correct version" do
+    @qp.version.should == "1.0.0.0"
+  end
+
+  it "should have correct size in pixels" do
+    @qp.map_location_and_size_in_pixels.width.should == 1365
+    @qp.map_location_and_size_in_pixels.height.should == 1556
+  end
+
+  it "should have one session" do
+    @qp.sessions.size.should equal(1)
+  end
+
+  describe "session" do
+    before do
+      @it = @qp.sessions.first
+    end
+
+    it "should have correct session info" do
+      @it.session_info.person.name.should == "kari ja maria"
+    end
+
+    it "should have 17 laps" do
+      @it.laps.size.should equal(17)
+    end
+
+    describe "lap" do
+      it "should have correct time" do
+        Time.at(@it.laps.first.time).to_s.should == "2010-04-18 11:48:03 +0300"
+      end
+    end
+
+    it "should have 39 handles" do
+      @it.handles.size.should equal(39)
+    end
+
+    it "should have correct projection origin" do
+      @it.projection_origin.latitude.should == 60.33081694444444
+      @it.projection_origin.longitude.should == 22.894455
+    end
+
+    describe "route" do
+      it "should have one segment" do
+        @it.route.segments.size.should equal(1)
+      end
+
+      describe "segment" do
+        it "should have 1001 waypoints" do
+          @it.route.segments.first.waypoints.size.should equal(1001)
+        end
+
+        describe "first waypoint" do
+          before do
+            @wp = @it.route.segments.first.waypoints.first
+          end
+
+          it "should have correct time set" do
+            Time.at(@wp.time).to_s.should == "2010-04-18 11:48:03 +0300"
+          end
+
+          it "should have correct position" do
+            @wp.position.latitude.should == 60.34066361111111
+            @wp.position.longitude.should == 22.904983333333334
+          end
+
+          it "should have correct altitude" do
+            @wp.altitude.should == 62
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "Parsing existing jpg file with calculation" do
+  before(:all) do
+    @filename = File.join(File.expand_path(File.dirname(__FILE__)),
+                          '../fixtures/2010-Ankkurirastit.jpg')
+
+    @qp = QuickrouteJpegParser.new(File.join(@filename), true)
+  end
+
+  describe "session" do
+    it "should have correct straight line distance" do
+      @qp.sessions.first.straight_line_distance.round.should == 6750
+    end
+  end
+
+  describe "route" do
+    it "should have correct distance" do
+      @qp.sessions.first.route.distance.round.should == 7566
+    end
+
+    it "should have correct elapsed time" do
+      @qp.sessions.first.route.elapsed_time.should == 2706.0
+    end
+  end
+end

data/spec/models/lap_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+describe Lap do
+  before(:each) do
+    @it = Lap.new
+  end
+
+  describe "setting position" do
+    it "should set the position ivar and be readable" do
+      long_lat = LongLat.new(0,0)
+      @it.position = long_lat
+
+      @it.position.should == long_lat
+    end 
+  end
+
+  describe "setting distance" do
+    it "should work" do
+      @it.distance = 69
+      @it.distance.should == 69
+    end
+  end
+
+  describe "setting straight line distance" do
+    it "should work" do
+      @it.straight_line_distance = 69
+      @it.straight_line_distance.should == 69
+    end
+  end
+end

data/spec/models/quickroute_jpeg_parser_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+
+describe QuickrouteJpegParser do
+  describe '#new' do
+    describe 'with calculate == false' do
+      it "should not calculate values" do
+        #TagDataExtractor.stub!(:extract_tag_data).and_return([5, 16])
+        JpegReader.stub!(:fetch_data_from).and_return("")
+        @session = Session.new
+        Session.stub!(:read_sessions).and_return([@session])
+        @session.should_not_receive(:calculate)
+        @parser = QuickrouteJpegParser.new("filename", false)
+      end
+    end
+  end
+end

data/spec/models/route_segment_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../spec_helper'
+
+describe RouteSegment do
+  before(:each) do
+    @route = Route.new
+    @it = RouteSegment.new(@route)
+    @wp1 = Waypoint.new(@it)
+    @wp2 = Waypoint.new(@it)
+    @wp3 = Waypoint.new(@it)
+  end
+
+  describe "#add_waypoints" do
+    it "should add waypoints to the segment" do
+      @it.add_waypoint(@wp1, @wp2, @wp3)
+      @it.waypoints.should == [@wp1, @wp2, @wp3]
+    end
+  end
+
+  describe "#calculate_waypoints" do
+    before(:each) do
+      @it.add_waypoint(@wp1, @wp2, @wp3)
+      @wp2.should_receive(:distance_to).with(@wp1).and_return(10)
+      @wp3.should_receive(:distance_to).with(@wp2).and_return(20)
+
+      t1 = Time.now.to_i
+      @wp1.should_receive(:time).at_least(:once).and_return(t1)
+      @wp2.should_receive(:time).at_least(:once).and_return(t1 + 60)
+      @wp3.should_receive(:time).at_least(:once).and_return(t1 + 180)
+
+      @it.calculate_waypoints
+    end
+
+    it "should calculate the total distance for each waypoint" do
+      @wp1.distance.should == 0
+      @wp2.distance.should == 10
+      @wp3.distance.should == 30
+    end
+
+    it "should calculate the total elapsed time for each waypoint" do
+      @wp1.elapsed_time.should == 0
+      @wp2.elapsed_time.should == 60
+      @wp3.elapsed_time.should == 180
+    end
+
+    it "should update route's distance and time in the end" do
+      @route.distance.should == 30
+      @route.elapsed_time == 180
+    end
+  end
+end

data/spec/models/route_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe Route do
+  before(:each) do
+    @it = Route.new
+  end
+
+  describe "#calculate_parameters" do
+    before(:each) do
+      @segment = stub
+      @it.stub(:segments).and_return([@segment])
+    end
+
+    it "should calculate total distance for each segment" do
+      @segment.should_receive(:calculate_waypoints)
+      @it.calculate_parameters
+    end
+  end
+
+  describe "#add_distance" do
+    it "should add given distance" do
+      @it.distance.should == 0
+      @it.add_distance(180)
+      @it.distance.should == 180
+    end
+  end
+
+  describe "#add_elapsed_time" do
+    it "should add given elapsed time" do
+      @it.elapsed_time.should == 0
+      @it.add_elapsed_time(180)
+      @it.elapsed_time.should == 180
+    end
+  end
+end

data/spec/models/session_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../spec_helper'
+
+describe Session do
+  before(:each) do
+    @it = Session.new
+    @it.route = @route = Route.new
+  end
+
+  describe "calculate" do
+    it "should call route.calculate" do
+      @route.should_receive(:calculate_parameters)
+      @it.calculate
+    end
+  end
+end

data/spec/models/waypoint_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../spec_helper'
+
+describe Waypoint do
+  before(:each) do
+    @route = Route.new
+    @segment = stub(:segment, :route => @route)
+    @position = LongLat.new(0,0)
+    LongLat.stub(:from_data).and_return(@position)
+    @it = Waypoint.new(@segment)
+  end
+
+  it "should have a zero distance" do
+    @it.distance.should == 0
+  end
+
+  it "should be able to set elapsed time" do
+    @it.elapsed_time = 180
+    @it.elapsed_time.should == 180
+  end
+
+  describe "#distance_to" do
+    it "should delegate to position" do
+      @other = Waypoint.new(@segment)
+      @op = LongLat.new(0,1)
+      @other.position = @op
+      @it.position = @position
+      @position.should_receive(:distance_to).with(@op).and_return(50)
+      @it.distance_to(@other).should == 50
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../lib/quickroute'

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: quickroute
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jarkko Laine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70239720740460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70239720740460
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: &70239720739980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239720739980
+- !ruby/object:Gem::Dependency
+  name: binary_search
+  requirement: &70239720739520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70239720739520
+description: Library for parsing the GPS data embedded to JPG files by QuickRoute
+  (http://www.matstroeng.se/quickroute/en/).
+email: jarkko@jlaine.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/date_time_parser.rb
+- lib/handle.rb
+- lib/jpeg_reader.rb
+- lib/lap.rb
+- lib/long_lat.rb
+- lib/parameterized_location.rb
+- lib/parse_test.rb
+- lib/person.rb
+- lib/point.rb
+- lib/quickroute.rb
+- lib/quickroute_jpeg_parser.rb
+- lib/rectangle.rb
+- lib/route.rb
+- lib/route_segment.rb
+- lib/session.rb
+- lib/session_info.rb
+- lib/string_extensions.rb
+- lib/tag_data_extractor.rb
+- lib/waypoint.rb
+- spec/fixtures/2010-Ankkurirastit.jpg
+- spec/integration/parsing_spec.rb
+- spec/models/lap_spec.rb
+- spec/models/quickroute_jpeg_parser_spec.rb
+- spec/models/route_segment_spec.rb
+- spec/models/route_spec.rb
+- spec/models/session_spec.rb
+- spec/models/waypoint_spec.rb
+- spec/spec_helper.rb
+- README.md
+homepage: https://github.com/jarkko/quickroute-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: Parser library for QuickRoute JPG files with embedded route data
+test_files: []