gpx_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d28ab6aad3c8f49b2a1623c39a58a54a550e2fc
+  data.tar.gz: 9e87c82457414596fdad17d515489e7cf4a01375
+SHA512:
+  metadata.gz: f1e26c42d0a11f5e6598f0f486b189ebdb37bf0af645dea7320ff7a736150a877123bf02d2996d7ffa885978b2e203406e870efcc197f8b397c05135b303b328
+  data.tar.gz: 241a076a866fefeb6e476ef24aa26e40f44941a82cdc6ad6041e1a7fe613d37cae92648743194288fdcb017c9da6c0ce8f91a118bb45ab07b0276d84facc9281

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs = ['.', 'lib', 'test']
+  task.test_files = FileList['test/test_*.rb']
+  task.verbose = true
+end

data/lib/gpx_ruby.rb

@@ -0,0 +1,24 @@
+module GpxRuby
+
+require 'nokogiri'
+require 'time'
+require 'tempfile'
+require 'gpx_ruby/gpx/point'
+require 'gpx_ruby/gpx/track'
+require 'gpx_ruby/gpx/parsers/track_parser'
+require 'gpx_ruby/gpx/document'
+require 'gpx_ruby/gpx/parser'
+
+  class << self
+
+    def File(input)
+      Gpx::Parser.new(input).parse
+    end
+
+    def XML(xml_string)
+      Gpx::Parser.new(xml: xml_string).parse
+    end
+
+  end
+
+end

data/lib/gpx_ruby/gpx/document.rb

@@ -0,0 +1,19 @@
+module GpxRuby
+
+  module Gpx
+
+    class Document
+
+      attr_accessor :version, :creator, :tracks
+
+      def initialize(a_hash)
+        @creator = a_hash[:creator]
+        @version = a_hash[:version]
+        @tracks = a_hash[:tracks]
+      end
+
+    end
+
+  end
+
+end

data/lib/gpx_ruby/gpx/parser.rb

@@ -0,0 +1,54 @@
+module GpxRuby
+
+  module Gpx
+
+    class Parser
+
+      def initialize(input)
+        @xml = case input
+                 when File
+                   input.read
+                 when Tempfile
+                   input.read
+                 when String
+                   ::File.open(input, 'r') { |f| f.read }
+                 when Hash
+                   if input[:file_path] && input[:file_path].is_a?(String)
+                   ::File.open(input[:file_path], 'r') { |f| f.read }
+                   end
+                   if input[:xml] && input[:xml].is_a?(String)
+                     input[:xml]
+                   elsif input[:file] && (input[:file].is_a?(File) || input[:file].is_a?(Tempfile))
+                     input[:file].read
+                   else
+                     raise 'Error: invalid input!'
+                  end
+                 else
+                   raise 'Error: invalid input!'
+               end
+      end
+
+
+      def parse
+        doc = Nokogiri::XML(@xml)
+        @gpx_node = doc.at_xpath('//xmlns:gpx')
+
+        properties = {
+            creator: @gpx_node.at_xpath('@creator').value,
+            version: @gpx_node.at_xpath('@version').value.to_f,
+            tracks: []
+        }
+
+        # parse track elements
+        tracks = Parsers::TrackParser.new(@gpx_node).parse
+        properties = properties.merge(tracks: tracks)
+
+        Document.new properties
+      end
+
+
+    end
+
+  end
+
+end

data/lib/gpx_ruby/gpx/parsers/track_parser.rb

@@ -0,0 +1,121 @@
+module GpxRuby
+
+  module Gpx
+
+    module Parsers
+
+      class TrackParser
+
+        def initialize(gpx_node)
+          @gpx_node = gpx_node
+        end
+
+        def parse
+          tracks = []
+          if track_nodes = @gpx_node.xpath('./xmlns:trk')
+            # iterate over all tracks
+            track_nodes.each do |trk|
+              trk_segments = trk.xpath('./xmlns:trkseg')
+
+              # map track segments for this track
+              track_segments = trk_segments.map do |trkseg|
+
+                # map all track points for this track segment
+                track_points = trkseg.xpath('./xmlns:trkpt').map do |trkpt|
+
+                  lat = trkpt.at_xpath('./@lat').value.to_f
+                  lon = trkpt.at_xpath('./@lon').value.to_f
+
+                  time = begin
+                    DateTime.xmlschema(trkpt.at_xpath('./xmlns:time').text).to_time
+                  rescue
+                    nil
+                  end
+
+                  elevation =  begin
+                    trkpt.at_xpath('./xmlns:ele').text.to_f
+                  rescue
+                    nil
+                  end
+
+                  Track::Point.new lat: lat, lon: lon, time: time, elevation: elevation
+                end
+
+                Track::Segment.new track_points
+              end
+
+              trk_name = begin
+                trk.at_xpath('./xmlns:name').text
+              rescue
+                nil
+              end
+
+              trk_cmt = begin
+                trk.at_xpath('./xmlns:cmt').text
+              rescue
+                nil
+              end
+
+              trk_src = begin
+                trk.at_xpath('./xmlns:src').text
+              rescue
+                nil
+              end
+
+              trk_desc = begin
+                trk.at_xpath('./xmlns:desc').text
+              rescue
+                nil
+              end
+
+              trk_number = begin
+                trk.at_xpath('./xmlns:number').text
+              rescue
+                nil
+              end
+
+              trk_url = begin
+                trk.at_xpath('./xmlns:url').text
+              rescue
+                nil
+              end
+
+              trk_url_name = begin
+                trk.at_xpath('./xmlns:urlname').text
+              rescue
+                nil
+              end
+
+              trk_time = begin
+                DateTime.xmlschema(trk.at_xpath('./xmlns:time').text).to_time
+              rescue
+                nil
+              end
+
+              track_hash = {
+                  segments: track_segments,
+                  name: trk_name,
+                  time: trk_time,
+                  source: trk_src,
+                  description: trk_desc,
+                  number: trk_number,
+                  comment: trk_cmt,
+                  url: trk_url,
+                  url_name: trk_url_name
+              }
+
+              tracks << Track.new(track_hash)
+            end
+
+          end
+
+          tracks
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/gpx_ruby/gpx/point.rb

@@ -0,0 +1,78 @@
+module GpxRuby
+
+  module Gpx
+
+    class Point
+
+      attr_accessor :lat, :lon
+
+      RADIUS_KM = 6371
+
+      def initialize(a_hash)
+        @lat = a_hash[:lat]
+        @lon = a_hash[:lon]
+      end
+
+
+      def [](index)
+        case index
+          when 0
+            lat
+          when 1
+            lon
+          else
+            raise 'Invalid index!'
+        end
+      end
+
+      def +(a_point)
+        nlat = lat + a_point.lat
+        nlon = lon + a_point.lon
+        Point.new lat: nlat, lon: nlon
+      end
+
+      def /(a_scalar)
+        nlat = lat / a_scalar.to_f
+        nlon = lon / a_scalar.to_f
+        Point.new lat: nlat, lon: nlon
+      end
+
+      def to_s
+        "lat: #{lat}, lon: #{lon}"
+      end
+
+      def to_a
+        [lat, lon]
+      end
+
+      def to_hash
+        { lat: lat, lon: lon }
+      end
+
+      alias_method :to_h, :to_hash
+
+
+      def distance(a_point)
+        p_point = self
+        rad_per_deg, radius_meter = Math::PI/180, RADIUS_KM * 1000
+
+        dlon_rad = (a_point.lon-p_point.lon) * rad_per_deg
+        dlat_rad = (a_point.lat-p_point.lat) * rad_per_deg
+
+        lat1_rad = p_point.lat * rad_per_deg
+        lat2_rad = a_point.lat * rad_per_deg
+
+        p_point = 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(p_point), Math::sqrt(1-p_point))
+
+        radius_meter * c
+      end
+
+
+    end
+
+  end
+
+
+
+end

data/lib/gpx_ruby/gpx/track.rb

@@ -0,0 +1,100 @@
+module GpxRuby
+
+  module Gpx
+
+    class Track
+
+      attr_accessor :segments, :name, :time,
+                    :description, :source, :comment,
+                    :number, :url, :url_name
+
+      def initialize(a_hash)
+        @name = a_hash[:name]
+        @time = a_hash[:time]
+        @segments = a_hash[:segments] || []
+        @number = a_hash[:number]
+        @source = a_hash[:source]
+        @url = a_hash[:url]
+        @url_name = a_hash[:url_name]
+        @comment = a_hash[:comment]
+        @description = a_hash[:description]
+      end
+
+      def points
+        @points ||= @segments.map {|segment| segment.points }.reduce(:+)
+      end
+
+      def distance
+        @distance ||= @segments.map {|segment| segment.distance }.reduce(:+)
+      end
+
+      def total_time
+        start_time = @segments.first.points.first.time
+        end_time = @segments.last.points.last.time
+        end_time - start_time rescue 0
+      end
+
+      def center_of_gravity
+        track_points  = points
+        len = track_points.size
+        center = track_points.reduce(:+)
+        center / len
+      end
+
+
+      class Point < Gpx::Point
+
+        attr_accessor :lat, :lon, :time, :elevation
+
+        def initialize(params)
+          @lat = params[:lat]
+          @lon = params[:lon]
+          @time = params[:time]
+          @elevation = params[:elevation]
+        end
+
+        def to_a
+          [@lat,@lon]
+        end
+
+      end
+
+
+      class Segment
+
+        attr_accessor :points
+
+        def initialize(points)
+          @points = points || []
+        end
+
+        def distance
+          if @distance
+            @distance
+          else
+            zipped_points = @points[0...-1].zip(@points[1..-1])
+            distances = zipped_points.map {|(p,q)| p.distance(q) }
+            @distance = distances.reduce(:+)
+          end
+        end
+
+        def total_time
+          start_time, end_time = @points.first.time, @points.last.time
+          end_time - start_time rescue 0
+        end
+
+        def center_of_gravity
+          track_points  = points
+          len = track_points.size
+          center = track_points.reduce(:+)
+          center / len
+        end
+
+      end
+
+    end
+
+  end
+
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module GpxRuby
+  VERSION = '0.1.0'
+end

data/test/test_gpx_parser.rb

@@ -0,0 +1,167 @@
+require 'test/test_helper'
+
+class TestGpxParser < MiniTest::Test
+
+  def setup
+    @gpx_parser = GpxRuby::Gpx::Parser.new './test/run_keeper.gpx'
+    @gpx_file = @gpx_parser.parse
+  end
+
+  def test_should_read_gpx_file
+    gpx_parser = GpxRuby::Gpx::Parser.new File.open('./test/run_keeper.gpx','r')
+    gpx_file = gpx_parser.parse
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_read_gpx_temp_file
+    xml = File.open('./test/run_keeper.gpx','r') { |f| f.read }
+    tmp_file = Tempfile.open('blah.gpx')
+    tmp_file.write xml
+    tmp_file.rewind
+    gpx_parser = GpxRuby::Gpx::Parser.new tmp_file
+    gpx_file = gpx_parser.parse
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_read_file_path
+    gpx_parser = GpxRuby::Gpx::Parser.new './test/run_keeper.gpx'
+    gpx_file = gpx_parser.parse
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_read_gpx_xml
+    xml = File.open('./test/run_keeper.gpx') do |f|
+      f.read
+    end
+    gpx_parser = GpxRuby::Gpx::Parser.new xml: xml
+    gpx_file = gpx_parser.parse
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_read_gpx_xml_using_a_shortcut
+    xml = File.open('./test/run_keeper.gpx') do |f|
+      f.read
+    end
+    gpx_file = GpxRuby::XML(xml)
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_read_gpx_file_using_a_shortcut
+    gpx_file = GpxRuby::File './test/run_keeper.gpx'
+    assert gpx_file.creator
+    assert gpx_file.version
+  end
+
+
+  def test_should_compute_center_of_gravity
+    gpx_parser = GpxRuby::Gpx::Parser.new './test/run_keeper.gpx'
+    gpx_file = gpx_parser.parse
+    track = gpx_file.tracks.first
+    pp 'center of gravity: %s' % track.center_of_gravity
+  end
+
+
+  def test_should_read_fell_loops
+    gpx_file = GpxRuby::File './test/gpx_samples/fells_loop.gpx'
+    assert gpx_file.creator
+    assert gpx_file.version
+    track = gpx_file.tracks.first
+    assert track.nil?
+    gpx_file.tracks.each  do |track|
+      assert track.name || track.name.nil?
+      assert track.time || track.time.nil?
+      assert track.distance
+    end
+  end
+
+
+  def test_should_read_boise_front
+    gpx_file = GpxRuby.File './test/gpx_samples/BoiseFront.gpx'
+    assert gpx_file.creator
+    assert gpx_file.version
+    track = gpx_file.tracks.first
+    assert track.nil? == false
+    assert track.total_time == 0
+    gpx_file.tracks.each  do |track|
+      assert track.name || track.name.nil?
+      assert track.time || track.time.nil?
+      assert track.distance
+    end
+  end
+
+
+  def test_should_read_track
+    track = @gpx_file.tracks.first
+    assert track
+    assert track.is_a? GpxRuby::Gpx::Track
+  end
+
+
+  def test_should_read_track_segments
+    track = @gpx_file.tracks.first
+    track_segments = track.segments
+    assert track_segments.size == 4
+  end
+
+
+  def test_should_read_track_segment_points
+    track = @gpx_file.tracks.first
+    track_segment = track.segments.last
+    assert track_segment.points.size > 0
+    track_points = track_segment.points
+    track_points.each do |track_point|
+      assert track_point.lat
+      assert track_point.lon
+      assert track_point.elevation
+    end
+
+  end
+
+
+  def test_should_read_track_points
+    track = @gpx_file.tracks.first
+    assert track
+    assert track.points.size > 0
+    track_points = track.points
+    track_points.each do |track_point|
+      assert track_point.lat
+      assert track_point.lon
+      assert track_point.elevation
+    end
+  end
+
+
+  def test_should_compute_total_track_segment_distance
+    track = @gpx_file.tracks.first
+    puts track.segments.map {|segment| segment.distance }
+  end
+
+
+  def test_should_compute_total_track_distance
+    track = @gpx_file.tracks.first
+    puts track.distance
+  end
+
+
+  def test_should_compute_total_track_time
+    track = @gpx_file.tracks.first
+    puts track.total_time
+  end
+
+
+  def test_should_compute_total_segment_time
+    track = @gpx_file.tracks.first
+    puts track.segments.map {|segment| segment.total_time }
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/autorun'
+require 'gpx_ruby'
+require 'pp'

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: gpx_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Rüeedlinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+description: A simple gpx file parser for reading gpx files.
+email: a.rueedlinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/gpx_ruby.rb
+- lib/gpx_ruby/gpx/document.rb
+- lib/gpx_ruby/gpx/parser.rb
+- lib/gpx_ruby/gpx/parsers/track_parser.rb
+- lib/gpx_ruby/gpx/point.rb
+- lib/gpx_ruby/gpx/track.rb
+- lib/version.rb
+- test/test_gpx_parser.rb
+- test/test_helper.rb
+homepage: http://github.com/lexruee/gpx_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A gpx file parser for reading gpx files.
+test_files: []