gpx 0.7 → 0.8.1

data/lib/gpx/gpx.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006  Doug Fales 
+# 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
@@ -21,29 +21,26 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 module GPX
-  VERSION = "0.7"
-
   # 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
 
-	# 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
 end

data/lib/gpx/gpx_file.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006  Doug Fales 
+# 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
@@ -21,250 +21,325 @@
 # 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, :version, :time, :name
+  class GPXFile < Base
+    attr_accessor :tracks, :routes, :waypoints, :bounds, :lowest_point, :highest_point, :duration, :ns, :time, :name, :version, :creator, :description
 
+    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]
-              #case gpx_file
-              #when String
-              #   gpx_file = File.open(gpx_file)
-              #end
-              gpx_file = gpx_file.name if gpx_file.is_a?(File) 
-              @xml = Hpricot(File.open(gpx_file))
-            else
-              @xml = Hpricot(opts[:gpx_data])
-            end
-            # set XML namespace for XML find
-            #if @xml.root.namespaces.namespace
-            #  @ns = 'gpx:' + @xml.root.namespaces.namespace.href
-            #else
-            #  @ns = 'gpx:http://www.topografix.com/GPX/1/1'  # default to GPX 1.1
-            #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
+    # 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
+      @attributes = {}
+      @namespace_defs = []
+      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
 
-		    @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? }
+        gpx_element = @xml.at('gpx')
+        @attributes = gpx_element.attributes
+        @namespace_defs = gpx_element.namespace_definitions
+        #$stderr.puts gpx_element.attributes.sort.inspect
+        #$stderr.puts @xmlns.inspect
+        #$stderr.puts @xsi.inspect
+        @version = gpx_element['version']
+        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
 
-            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
+        @time = Time.parse(@xml.at("metadata/time").inner_text) rescue nil
+        @name = @xml.at("metadata/name").inner_text rescue nil
+        @description = @xml.at('metadata/desc').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? }
 
-      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)
+        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
 
-      # 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
+    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 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
+    # 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
 
-      # 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) }
+    # 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
 
-      # 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) }
+    # 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
 
-      # 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
+    # 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
 
-      # 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
+    # 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
 
-      # 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
-         doc.save(filename, :indent => true)
+    # 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
+
+    def recalculate_distance
+      @distance = 0
+      @tracks.each do |track|
+        track.recalculate_distance
+        @distance += track.distance
       end
+    end
+
+    private
+    def attributes_and_nsdefs_as_gpx_attributes
+      #$stderr.puts @namespace_defs.inspect
+      gpx_header = {}
+      @attributes.each do |k,v|
+        k = v.namespace.prefix + ':' + k if v.namespace
+        gpx_header[k] = v.value
+      end 
 
-      def to_s(update_time = true)
-         @time = Time.now if(@time.nil? or update_time)
-         doc = generate_xml_doc
-         doc.to_s
+      @namespace_defs.each do |nsd|
+        tag = 'xmlns'
+        if nsd.prefix
+          tag += ':' + nsd.prefix
+        end
+        gpx_header[tag] = nsd.href
       end
+      return gpx_header
+    end
+ 
+    def generate_xml_doc
+      @version ||= '1.1'
+      version_dir = version.gsub('.','/')
 
-      private 
-      def generate_xml_doc
-         doc = Document.new
-         doc.root = Node.new('gpx')
-         gpx_elem = doc.root
-         gpx_elem['xsi'] = "http://www.w3.org/2001/XMLSchema-instance"
-         @version = '1.1' if (@version.nil? || !(['1.0', '1.1'].include?(@version))) # default to version 1.1 of the schema (only version 1.0 and 1.1 of the schema exist)
-         version_dir = @version.gsub('.','/')
-         gpx_elem['xmlns'] = @ns || "http://www.topografix.com/GPX/#{version_dir}" 
-         gpx_elem['version'] = "#{@version}"
-         gpx_elem['creator'] = "GPX RubyGem #{GPX::VERSION} Copyright 2006-2009 Doug Fales -- http://gpx.rubyforge.org/" 
-         gpx_elem['xsi:schemaLocation'] = "http://www.topografix.com/GPX/#{version_dir} http://www.topografix.com/GPX/#{version_dir}/gpx.xsd"
+      gpx_header = attributes_and_nsdefs_as_gpx_attributes
+      
+      gpx_header['version'] = @version.to_s if !gpx_header['version']
+      gpx_header['creator'] = DEFAULT_CREATOR if !gpx_header['creator']
+      gpx_header['xsi:schemaLocation'] = "http://www.topografix.com/GPX/#{version_dir} http://www.topografix.com/GPX/#{version_dir}/gpx.xsd" if !gpx_header['xsi:schemaLocation']
+      gpx_header['xmlns:xsi'] = "http://www.w3.org/2001/XMLSchema-instance" if !gpx_header['xsi'] and !gpx_header['xmlns:xsi']
+      
+      #$stderr.puts gpx_header.keys.inspect
 
-         # setup the metadata elements
-         name_elem = Node.new('name')
-         name_elem << @name
-         time_elem = Node.new('time')
-         time_elem << @time.xmlschema
+      doc = Nokogiri::XML::Builder.new do |xml|
+        xml.gpx(gpx_header) \
+        {
+            # 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
 
-         # 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
-           gpx_elem << name_elem
-           gpx_elem << time_elem
-           gpx_elem << bounds.to_xml                      
-         else
-           meta_data_elem = Node.new('metadata')
-           meta_data_elem << name_elem
-           meta_data_elem << time_elem
-           meta_data_elem << bounds.to_xml           
-           gpx_elem << meta_data_elem
-         end
+            tracks.each do |t|
+              xml.trk {
+                xml.name t.name
 
-         tracks.each    { |t| gpx_elem << t.to_xml } unless tracks.nil?
-         waypoints.each { |w| gpx_elem << w.to_xml } unless waypoints.nil?
-         routes.each    { |r| gpx_elem << r.to_xml } unless routes.nil?
+                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?
+                        xml << p.extensions.to_xml unless p.extensions.nil?
+                      }
+                    end
+                  }
+                end
+              }
+            end unless tracks.nil?
 
-         return doc
-      end
+            waypoints.each do |w|
+              xml.wpt(lat: w.lat, lon: w.lon) {
+                xml.time w.time.xmlschema unless w.time.nil?
+                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?
 
-      # 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
+            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
 
-   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