andrewhao-gpx 0.7

data/.gitignore

@@ -0,0 +1,3 @@
+tests/output/*
+.*.swp
+Gemfile.lock

data/ChangeLog

@@ -0,0 +1,60 @@
+2010-02-27	Doug Fales <doug@falesafeconsulting.com>
+	* Putting the gem building stuff into a gemspec.
+	* Fixing some tests since git does not believe in empty directories.
+	* Fixing README formatting.
+
+2010-02-27	Doug Fales <doug@falesafeconsulting.com>
+	* README edits.
+	* More rdoc tweaks.
+	* Changing README to rdoc ext for github.
+
+2009-10-13	Doug Fales <doug@falesafeconsulting.com>
+	* Adding the ability to write GPX to a string in addition to a file.  Thanks to Douglas Robertson for the patch.
+
+2009-09-27	Doug Fales <doug@falesafeconsulting.com>
+	* Adding a patch from Douglas Robertson that allows using version 1.0 of the schema for output.
+
+2009-07-07	Doug Fales <doug@falesafeconsulting.com>
+	* Adding changelog.
+	* Revving to version 0.5.
+	* Changing my contact email address.
+	* Patches from Tom Verbeure (mtbguru.com) to work with libxml-ruby 1.x.
+
+2009-06-17	Doug Fales <doug@falesafeconsulting.com>
+	* Patch from Kang-min Liu to support speed element.
+
+2008-02-19	Doug Fales <doug@falesafeconsulting.com>
+	* Revving to 0.4.
+	* Adding some new unit tests and fixing several file export bugs reported by Jochen Topf. New unit tests also uncovered a bug where the number of trackpoints reported in a file was twice the actual number.
+
+2008-02-11	Doug Fales <doug@falesafeconsulting.com>
+	* Going to version 0.3.
+	* Updating unit tests in light of recent fixes to routes and waypoints code.
+
+2008-02-08	Doug Fales <doug@falesafeconsulting.com>
+	* Thanks to Mike Gauland for discovering some route- and waypoint-related bugs.  I've fixed them and also added #to_s on Waypoint so it's easier to debug.
+
+2007-12-04	Doug Fales <doug@falesafeconsulting.com>
+	* Thanks to Christian Koerner for finding and fixing these bugs in the waypoint code.
+	* Another patch from Gaku Ueda.  This one allows you to pass in a string of GPX data using the :gpx_date => option.  Thanks Gaku!
+
+2007-11-30	Doug Fales <doug@falesafeconsulting.com>
+	* Updating the version #.
+	* Updates courtesy of Gaku Ueda:  * Adding support for GPX 1.0 as well as 1.1 (since libxml namespace parsing    was hard-coded to 1.1. previously).  * Adding a GPX 1.0 unit test file.  * Miscellaneous updates to make it work with Ruby 1.8.6.
+
+2006-12-04	Doug Fales <doug@falesafeconsulting.com>
+	* First stab at using libxml-ruby instead of REXML.  I'm seeing the unit tests finish in under 14 seconds.  That is compared to 2 minutes using REXML.
+
+2006-12-03	Doug Fales <doug@falesafeconsulting.com>
+	* Fixing more nil time exceptions.
+	* Fixing an exception in contains_time?.
+
+2006-11-28	Doug Fales <doug@falesafeconsulting.com>
+	* A couple of fixes to make the library comply with the different attribute names possible on the bounds element.
+
+2006-10-28	Doug Fales <doug@falesafeconsulting.com>
+	* Fixing nil time bug.
+
+2006-10-14	Doug Fales <doug@falesafeconsulting.com>
+	* Initial import of gpx gem.
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in seryz.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,46 @@
+= GPX Gem
+
+Copyright (C) 2006 Doug Fales mailto:doug@falesafeconsulting.com
+
+== What It Does
+
+This library reads GPX files and provides an API for reading and manipulating
+the data as objects.  For more info on the GPX format, see
+http://www.topografix.com/gpx.asp.
+
+In addition to parsing GPX files, this library is capable of converting
+Magellan NMEA files to GPX, and writing new GPX files.  It can crop and delete
+rectangular areas within a file, and it also calculates some meta-data about
+the tracks and points in a file (such as distance, duration, average speed,
+etc).
+
+== Examples
+
+Reading a GPX file, and cropping its contents to a given area:
+         gpx =  GPX::GPXFile.new(:gpx_file => filename)   # Read GPX file
+         bounds = GPX::Bounds.new(params)                 # Create a rectangular area to crop
+         gpx.crop(bounds)                                 # Crop it
+         gpx.write(filename)                              # Save it
+
+Converting a Magellan track log to GPX:
+      if GPX::MagellanTrackLog::is_magellan_file?(filename)
+         GPX::MagellanTrackLog::convert_to_gpx(filename, "#{filename}.gpx")
+      end
+
+
+== Notes
+
+This library was written to bridge the gap between my Garmin Geko
+and my website, WalkingBoss.org (RIP).  For that reason, it has always been more of a
+work-in-progress than an attempt at full GPX compliance.  The track side of the
+library has seen much more use than the route/waypoint side, so if you're doing
+something with routes or waypoints, you may need to tweak some things.  
+
+Since this code uses XML to read an entire GPX file into memory, it is not
+the fastest possible solution for working with GPX data, especially if you are
+working with tracks from several days or weeks.  
+
+Finally, it should be noted that none of the distance/speed calculation or
+crop/delete code has been tested under International Date Line-crossing
+conditions.  That particular part of the code will likely be unreliable if
+you're zig-zagging across 180 degrees longitude routinely.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+desc "Run all unit tests"
+Rake::TestTask.new("test") { |t|
+  t.libs << "lib"
+  t.pattern = 'tests/*_test.rb'
+  t.verbose = true
+}
+
+# Genereate the RDoc documentation
+desc "Create documentation"
+Rake::RDocTask.new("doc") { |rdoc|
+  rdoc.title = "Ruby GPX API"
+  rdoc.rdoc_dir = 'html'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}

data/gpx.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gpx/version'
+
+Gem::Specification.new do |s|
+  s.name = 'andrewhao-gpx'
+  s.version = GPX::VERSION
+  s.authors = ["Guillaume Dott", "Doug Fales", "Andrew Hao"]
+  s.email = ["guillaume+github@dott.fr", "doug.fales@gmail.com", "andrewhao@gmail.com"]
+  s.summary = %q{A basic API for reading and writing GPX files.}
+  s.description = %q{A basic API for reading and writing GPX files.}
+
+  s.files = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.has_rdoc = true
+
+  s.homepage = "http://www.github.com/andrewhao/gpx"
+  s.add_dependency 'rake'
+  s.add_dependency 'nokogiri'
+end

data/lib/gpx.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2006  Doug Fales
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'time'
+require 'nokogiri'
+
+require 'gpx/version'
+
+require 'gpx/gpx'
+require 'gpx/gpx_file'
+require 'gpx/bounds'
+require 'gpx/track'
+require 'gpx/route'
+require 'gpx/segment'
+require 'gpx/point'
+require 'gpx/trackpoint'
+require 'gpx/waypoint'
+require 'gpx/magellan_track_log'

data/lib/gpx/bounds.rb

@@ -0,0 +1,74 @@
+#--
+# Copyright (c) 2006  Doug Fales
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+module GPX
+  class Bounds < Base
+    attr_accessor :min_lat, :max_lat, :max_lon, :min_lon, :center_lat, :center_lon
+
+    # Creates a new bounds object with the passed-in min and max longitudes
+    # and latitudes.
+    def initialize(opts = { :min_lat => 90.0, :max_lat => -90.0, :min_lon => 180.0, :max_lon => -180.0})
+      @min_lat, @max_lat  = opts[:min_lat].to_f, opts[:max_lat].to_f
+      @min_lon, @max_lon  = opts[:min_lon].to_f, opts[:max_lon].to_f
+    end
+
+    # Returns the middle latitude.
+    def center_lat
+      distance = (max_lat - min_lat)/2.0
+      (min_lat + distance)
+    end
+
+    # Returns the middle longitude.
+    def center_lon
+      distance = (max_lon - min_lon)/2.0
+      (min_lon + distance)
+    end
+
+    # Returns true if the pt is within these bounds.
+    def contains?(pt)
+      (pt.lat >=  min_lat and pt.lat <= max_lat and pt.lon >= min_lon and pt.lon <= max_lon)
+    end
+
+    # Adds an item to itself, expanding its min/max lat/lon as needed to
+    # contain the given item.  The item can be either another instance of
+    # Bounds or a Point.
+    def add(item)
+      if(item.respond_to?(:lat) and item.respond_to?(:lon))
+        @min_lat = item.lat if item.lat < @min_lat
+        @min_lon = item.lon if item.lon < @min_lon
+        @max_lat = item.lat if item.lat > @max_lat
+        @max_lon = item.lon if item.lon > @max_lon
+      else
+        @min_lat = item.min_lat if item.min_lat < @min_lat
+        @min_lon = item.min_lon if item.min_lon < @min_lon
+        @max_lat = item.max_lat if item.max_lat > @max_lat
+        @max_lon = item.max_lon if item.max_lon > @max_lon
+      end
+    end
+
+    # Returns the min_lat, min_lon, max_lat, and max_lon in a labeled string.
+    def to_s
+      "min_lat: #{min_lat} min_lon: #{min_lon} max_lat: #{max_lat} max_lon: #{max_lon}"
+    end
+
+  end
+end

data/lib/gpx/gpx.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright (c) 2006  Doug Fales
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+module GPX
+  # A common base class which provides a useful initializer method to many
+  # class in the GPX library.
+  class Base
+    # This initializer can take an XML::Node and scrape out any text
+    # elements with the names given in the "text_elements" array.  Each
+    # element found underneath "parent" with a name in "text_elements" causes
+    # an attribute to be initialized on the instance.  This means you don't
+    # have to pick out individual text elements in each initializer of each
+    # class (Route, TrackPoint, Track, etc).  Just pass an array of possible
+    # attributes to this method.
+    def instantiate_with_text_elements(parent, text_elements)
+      text_elements.each do |el|
+        child_xpath = "#{el}"
+        unless parent.at(child_xpath).nil?
+          val = parent.at(child_xpath).inner_text
+          self.send("#{el}=", val)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/gpx/gpx_file.rb

@@ -0,0 +1,302 @@
+#--
+# Copyright (c) 2006  Doug Fales
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+module GPX
+  class GPXFile < Base
+    attr_accessor :tracks, :routes, :waypoints, :bounds, :lowest_point, :highest_point, :duration, :ns, :time, :name, :version, :creator
+
+    DEFAULT_CREATOR = "GPX RubyGem #{GPX::VERSION} -- http://dougfales.github.io/gpx/".freeze
+
+    # This initializer can be used to create a new GPXFile from an existing
+    # file or to create a new GPXFile instance with no data (so that you can
+    # add tracks and points and write it out to a new file later).
+    # To read an existing GPX file, do this:
+    #         gpx_file = GPXFile.new(:gpx_file => 'mygpxfile.gpx')
+    #         puts "Speed: #{gpx_file.average_speed}"
+    #         puts "Duration: #{gpx_file.duration}"
+    #         puts "Bounds: #{gpx_file.bounds}"
+    #
+    # To read a GPX file from a string, use :gpx_data.
+    #         gpx_file = GPXFile.new(:gpx_data => '<xml ...><gpx>...</gpx>)
+    # To create a new blank GPXFile instance:
+    #         gpx_file = GPXFile.new
+    # Note that you can pass in any instance variables to this form of the initializer, including Tracks or Segments:
+    #         some_track = get_track_from_csv('some_other_format.csv')
+    #         gpx_file = GPXFile.new(:tracks => [some_track])
+    #
+    def initialize(opts = {})
+      @duration = 0
+      if(opts[:gpx_file] or opts[:gpx_data])
+        if opts[:gpx_file]
+          gpx_file = opts[:gpx_file]
+          gpx_file = File.open(gpx_file) unless gpx_file.is_a?(File)
+          @xml = Nokogiri::XML(gpx_file)
+        else
+          @xml = Nokogiri::XML(opts[:gpx_data])
+        end
+
+        reset_meta_data
+        bounds_element = (@xml.at("metadata/bounds") rescue nil)
+        if bounds_element
+          @bounds.min_lat = get_bounds_attr_value(bounds_element, %w{ min_lat minlat minLat })
+          @bounds.min_lon = get_bounds_attr_value(bounds_element, %w{ min_lon minlon minLon})
+          @bounds.max_lat = get_bounds_attr_value(bounds_element, %w{ max_lat maxlat maxLat})
+          @bounds.max_lon = get_bounds_attr_value(bounds_element, %w{ max_lon maxlon maxLon})
+        else
+          get_bounds = true
+        end
+
+        @time = Time.parse(@xml.at("metadata/time").inner_text) rescue nil
+        @name = @xml.at("metadata/name").inner_text rescue nil
+        @tracks = []
+        @xml.search("trk").each do |trk|
+          trk = Track.new(:element => trk, :gpx_file => self)
+          update_meta_data(trk, get_bounds)
+          @tracks << trk
+        end
+        @waypoints = []
+        @xml.search("wpt").each { |wpt| @waypoints << Waypoint.new(:element => wpt, :gpx_file => self) }
+        @routes = []
+        @xml.search("rte").each { |rte| @routes << Route.new(:element => rte, :gpx_file => self) }
+        @tracks.delete_if { |t| t.empty? }
+
+        calculate_duration
+      else
+        reset_meta_data
+        opts.each { |attr_name, value| instance_variable_set("@#{attr_name.to_s}", value) }
+        unless(@tracks.nil? or @tracks.size.zero?)
+          @tracks.each { |trk| update_meta_data(trk) }
+          calculate_duration
+        end
+      end
+      @tracks ||= []
+      @routes ||= []
+      @waypoints ||= []
+    end
+
+    def get_bounds_attr_value(el, possible_names)
+      result = nil
+      possible_names.each do |name|
+        result = el[name]
+        break unless result.nil?
+      end
+      return (result.to_f rescue nil)
+    end
+
+    # Returns the distance, in kilometers, meters, or miles, of all of the
+    # tracks and segments contained in this GPXFile.
+    def distance(opts = { :units => 'kilometers' })
+      case opts[:units]
+      when /kilometers/i
+        return @distance
+      when /meters/i
+        return (@distance * 1000)
+      when /miles/i
+        return (@distance * 0.62)
+      end
+    end
+
+    # Returns the average speed, in km/hr, meters/hr, or miles/hr, of this
+    # GPXFile.  The calculation is based on the total distance divided by the
+    # total duration of the entire file.
+    def average_speed(opts = { :units => 'kilometers' })
+      case opts[:units]
+      when /kilometers/i
+        return @distance / (@duration/3600.0)
+      when /meters/i
+        return (@distance * 1000) /  (@duration/3600.0)
+      when /miles/i
+        return (@distance * 0.62) / (@duration/3600.0)
+      end
+    end
+
+    # Crops any points falling within a rectangular area.  Identical to the
+    # delete_area method in every respect except that the points outside of
+    # the given area are deleted.  Note that this method automatically causes
+    # the meta data to be updated after deletion.
+    def crop(area)
+      reset_meta_data
+      keep_tracks = []
+      tracks.each do |trk|
+        trk.crop(area)
+        unless trk.empty?
+          update_meta_data(trk)
+          keep_tracks << trk
+        end
+      end
+      @tracks = keep_tracks
+      routes.each { |rte| rte.crop(area) }
+      waypoints.each { |wpt| wpt.crop(area) }
+    end
+
+    # Deletes any points falling within a rectangular area.  The "area"
+    # parameter is usually an instance of the Bounds class.  Note that this
+    # method cascades into similarly named methods of subordinate classes
+    # (i.e. Track, Segment), which means, if you want the deletion to apply
+    # to all the data, you only call this one (and not the one in Track or
+    # Segment classes).  Note that this method automatically causes the meta
+    # data to be updated after deletion.
+    def delete_area(area)
+      reset_meta_data
+      keep_tracks = []
+      tracks.each do |trk|
+        trk.delete_area(area)
+        unless trk.empty?
+          update_meta_data(trk)
+          keep_tracks << trk
+        end
+      end
+      @tracks =  keep_tracks
+      routes.each { |rte| rte.delete_area(area) }
+      waypoints.each { |wpt| wpt.delete_area(area) }
+    end
+
+    # Resets the meta data for this GPX file.  Meta data includes the bounds,
+    # the high and low points, and the distance.
+    def reset_meta_data
+      @bounds = Bounds.new
+      @highest_point = nil
+      @lowest_point = nil
+      @distance = 0.0
+    end
+
+    # Updates the meta data for this GPX file.  Meta data includes the
+    # bounds, the high and low points, and the distance.  This is useful when
+    # you modify the GPX data (i.e. by adding or deleting points) and you
+    # want the meta data to accurately reflect the new data.
+    def update_meta_data(trk, get_bounds = true)
+      @lowest_point   = trk.lowest_point if(@lowest_point.nil? or (!trk.lowest_point.nil? and trk.lowest_point.elevation < @lowest_point.elevation))
+      @highest_point  = trk.highest_point if(@highest_point.nil? or (!trk.highest_point.nil? and trk.highest_point.elevation > @highest_point.elevation))
+      @bounds.add(trk.bounds) if get_bounds
+      @distance += trk.distance
+    end
+
+    # Serialize the current GPXFile to a gpx file named <filename>.
+    # If the file does not exist, it is created.  If it does exist, it is overwritten.
+    def write(filename, update_time = true)
+      @time = Time.now if(@time.nil? or update_time)
+      @name ||= File.basename(filename)
+      doc = generate_xml_doc
+      File.open(filename, 'w') { |f| f.write(doc.to_xml) }
+    end
+
+    def to_s(update_time = true)
+      @time = Time.now if(@time.nil? or update_time)
+      doc = generate_xml_doc
+      doc.to_xml
+    end
+
+    def inspect
+      "<#{self.class.name}:...>"
+    end
+
+    private
+    def generate_xml_doc
+      @version ||= '1.1'
+      version_dir = version.gsub('.','/')
+
+      doc = Nokogiri::XML::Builder.new do |xml|
+        xml.gpx(
+          'xsi' => "http://www.w3.org/2001/XMLSchema-instance",
+          'version' => @version.to_s,
+          'creator' => @creator.nil? ? DEFAULT_CREATOR : @creator.to_s,
+          'xsi:schemaLocation' => "http://www.topografix.com/GPX/#{version_dir} http://www.topografix.com/GPX/#{version_dir}/gpx.xsd") \
+        {
+            # version 1.0 of the schema doesn't support the metadata element, so push them straight to the root 'gpx' element
+            if (@version == '1.0') then
+              xml.name @name
+              xml.time @time.xmlschema
+              xml.bound(
+                minlat: bounds.min_lat,
+                minlon: bounds.min_lon,
+                maxlat: bounds.max_lat,
+                maxlon: bounds.max_lon,
+              )
+            else
+              xml.metadata {
+                xml.name @name
+                xml.time @time.xmlschema
+                xml.bound(
+                  minlat: bounds.min_lat,
+                  minlon: bounds.min_lon,
+                  maxlat: bounds.max_lat,
+                  maxlon: bounds.max_lon,
+                )
+              }
+            end
+
+            tracks.each do |t|
+              xml.trk {
+                xml.name t.name
+
+                t.segments.each do |seg|
+                  xml.trkseg {
+                    seg.points.each do |p|
+                      xml.trkpt(lat: p.lat, lon: p.lon) {
+                        xml.time p.time.xmlschema unless p.time.nil?
+                        xml.ele p.elevation unless p.elevation.nil?
+                      }
+                    end
+                  }
+                end
+              }
+            end unless tracks.nil?
+
+            waypoints.each do |w|
+              xml.wpt(lat: w.lat, lon: w.lon) {
+                Waypoint::SUB_ELEMENTS.each do |sub_elem|
+                  xml.send(sub_elem, w.send(sub_elem)) if w.respond_to?(sub_elem) && !w.send(sub_elem).nil?
+                end
+              }
+            end unless waypoints.nil?
+
+            routes.each do |r|
+              xml.rte {
+                xml.name r.name
+
+                r.points.each do |p|
+                  xml.rtept(lat: p.lat, lon: p.lon) {
+                    xml.time p.time.xmlschema unless p.time.nil?
+                    xml.ele p.elevation unless p.elevation.nil?
+                  }
+                end
+              }
+            end unless routes.nil?
+          }
+      end
+
+      return doc
+    end
+
+    # Calculates and sets the duration attribute by subtracting the time on
+    # the very first point from the time on the very last point.
+    def calculate_duration
+      @duration = 0
+      if(@tracks.nil? or @tracks.size.zero? or @tracks[0].segments.nil? or @tracks[0].segments.size.zero?)
+        return @duration
+      end
+      @duration = (@tracks[-1].segments[-1].points[-1].time - @tracks.first.segments.first.points.first.time)
+    rescue
+      @duration = 0
+    end
+  end
+end