gpx 0.7 → 0.8.1

data/lib/gpx/segment.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,202 +21,233 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 module GPX
-
-   # A segment is the basic container in a GPX file.  A Segment contains points
-   # (in this lib, they're called TrackPoints).  A Track contains Segments.  An
-   # instance of Segment knows its highest point, lowest point, earliest and
-   # latest points, distance, and bounds.
-   class Segment < Base
-
-      attr_reader :earliest_point, :latest_point, :bounds, :highest_point, :lowest_point, :distance
-      attr_accessor :points, :track 
-
-      # If a XML::Node object is passed-in, this will initialize a new
-      # Segment based on its contents.  Otherwise, a blank Segment is created.
-      def initialize(opts = {})
-         @gpx_file = opts[:gpx_file]
-         @track = opts[:track]
-         @points = []
-         @earliest_point = nil
-         @latest_point = nil
-         @highest_point = nil
-         @lowest_point = nil
-         @distance = 0.0
-         @bounds = Bounds.new
-         if(opts[:element])
-            segment_element = opts[:element]
-            last_pt = nil
-            if segment_element.is_a?(Hpricot::Elem)
-               segment_element.search("//trkpt").each do |trkpt| 
-                  pt = TrackPoint.new(:element => trkpt, :segment => self, :gpx_file => @gpx_file)  
-                  unless pt.time.nil?
-                     @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
-                     @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
-                  end
-                  unless pt.elevation.nil?
-                     @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
-                     @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
-                  end
-                  @bounds.min_lat = pt.lat if pt.lat < @bounds.min_lat
-                  @bounds.min_lon = pt.lon if pt.lon < @bounds.min_lon
-                  @bounds.max_lat = pt.lat if pt.lat > @bounds.max_lat
-                  @bounds.max_lon = pt.lon if pt.lon > @bounds.max_lon
-
-                  @distance += haversine_distance(last_pt, pt) unless last_pt.nil?
-
-                  @points << pt
-                  last_pt  = pt
-               end
-            end
-         end
-      end
-
-      # Tack on a point to this Segment.  All meta-data will be updated.
-      def append_point(pt)
-         last_pt = @points[-1]
-         @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
-         @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
-         @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
-         @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
-         @bounds.min_lat = pt.lat if pt.lat < @bounds.min_lat
-         @bounds.min_lon = pt.lon if pt.lon < @bounds.min_lon
-         @bounds.max_lat = pt.lat if pt.lat > @bounds.max_lat
-         @bounds.max_lon = pt.lon if pt.lon > @bounds.max_lon
-         @distance += haversine_distance(last_pt, pt) unless last_pt.nil?
-         @points << pt
-      end
-
-      # Returns true if the given time is within this Segment.
-      def contains_time?(time)
-         (time >= @earliest_point.time and time <= @latest_point.time) rescue false
-      end
-
-      # Finds the closest point in time to the passed-in time argument.  Useful
-      # for matching up time-based objects (photos, video, etc) with a
-      # geographic location.
-      def closest_point(time)
-         find_closest(points, time)
-      end
-
-      # Deletes all points within this Segment that lie outside of the given
-      # area (which should be a Bounds object).
-      def crop(area)
-         delete_if { |pt| not area.contains?(pt) }
-      end
-
-      # Deletes all points in this Segment that lie within the given area.
-      def delete_area(area)
-         delete_if{ |pt| area.contains?(pt) }
-      end
-
-      # A handy method that deletes points based on a block that is passed in.
-      # If the passed-in block returns true when given a point, then that point
-      # is deleted.  For example:
-      #         delete_if{ |pt| area.contains?(pt) }
-      def delete_if
-         reset_meta_data
-         keep_points = []
-         last_pt = nil
-         points.each do |pt| 
-            unless yield(pt)
-               keep_points << pt
-               update_meta_data(pt, last_pt)
-               last_pt = pt
-            end
-         end
-         @points = keep_points
-      end
-
-      # Returns true if this Segment has no points.
-      def empty?
-         (points.nil? or (points.size == 0))
-      end
-
-      # Converts this Segment to a XML::Node object.
-      def to_xml
-         seg = Node.new('trkseg')
-         points.each { |pt| seg <<  pt.to_xml }
-         seg
-      end
-
-      # Prints out a nice summary of this Segment.
-      def to_s
-         result = "Track Segment\n"
-         result << "\tSize: #{points.size} points\n"
-         result << "\tDistance: #{distance} km\n"
-         result << "\tEarliest Point: #{earliest_point.time.to_s} \n"
-         result << "\tLatest Point: #{latest_point.time.to_s} \n"
-         result << "\tLowest Point: #{lowest_point.elevation} \n"
-         result << "\tHighest Point: #{highest_point.elevation}\n "
-         result << "\tBounds: #{bounds.to_s}"
-         result
-      end
-
-      protected
-      def find_closest(pts, time)
-         return pts.first if pts.size == 1
-         midpoint = pts.size/2
-         if pts.size == 2
-            diff_1 = pts[0].time - time
-            diff_2 = pts[1].time - time
-            return (diff_1 < diff_2 ? pts[0] : pts[1])
-         end
-         if time >= pts[midpoint].time and time <= pts[midpoint+1].time
-
-            return pts[midpoint]
-
-         elsif(time <= pts[midpoint].time)
-            return find_closest(pts[0..midpoint], time)
-         else
-            return find_closest(pts[(midpoint+1)..-1], time)
-         end
-      end
-
-      RADIUS = 6371; # earth's mean radius in km
-
-      # Calculate the Haversine distance between two points. This is the method
-      # the library uses to calculate the cumulative distance of GPX files. 
-      def haversine_distance(p1, p2)
-         d_lat = p2.latr - p1.latr;
-         d_lon = p2.lonr - p1.lonr;
-         a = Math.sin(d_lat/2) * Math.sin(d_lat/2) + Math.cos(p1.latr) * Math.cos(p2.latr) * Math.sin(d_lon/2) * Math.sin(d_lon/2);
-         c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
-         d = RADIUS * c;
-         return d;
-      end
-
-      # Calculate the plain Pythagorean difference between two points.  Not currently used.
-      def pythagorean_distance(p1, p2)
-         Math.sqrt((p2.latr - p1.latr)**2 + (p2.lonr - p1.lonr)**2)
-      end
-
-      # Calculates the distance between two points using the Law of Cosines formula.  Not currently used.
-      def law_of_cosines_distance(p1, p2)
-         (Math.acos(Math.sin(p1.latr)*Math.sin(p2.latr) + Math.cos(p1.latr)*Math.cos(p2.latr)*Math.cos(p2.lonr-p1.lonr)) * RADIUS)
-      end
-
-      def reset_meta_data
-         @earliest_point = nil
-         @latest_point = nil
-         @highest_point = nil
-         @lowest_point = nil
-         @distance = 0.0
-         @bounds = Bounds.new
-      end
-
-      def update_meta_data(pt, last_pt)
-         unless pt.time.nil?
-            @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
-            @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
-         end
-         unless pt.elevation.nil?
-            @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
-            @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
-         end
-         @bounds.add(pt)
-         @distance += haversine_distance(last_pt, pt) unless last_pt.nil?
-      end
-
-   end
+  # A segment is the basic container in a GPX file.  A Segment contains points
+  # (in this lib, they're called TrackPoints).  A Track contains Segments.  An
+  # instance of Segment knows its highest point, lowest point, earliest and
+  # latest points, distance, and bounds.
+  class Segment < Base
+
+    attr_reader :earliest_point, :latest_point, :bounds, :highest_point, :lowest_point, :distance
+    attr_accessor :points, :track
+
+    # If a XML::Node object is passed-in, this will initialize a new
+    # Segment based on its contents.  Otherwise, a blank Segment is created.
+    def initialize(opts = {})
+      @gpx_file = opts[:gpx_file]
+      @track = opts[:track]
+      @points = []
+      @earliest_point = nil
+      @latest_point = nil
+      @highest_point = nil
+      @lowest_point = nil
+      @distance = 0.0
+      @bounds = Bounds.new
+      if(opts[:element])
+        segment_element = opts[:element]
+        last_pt = nil
+        if segment_element.is_a?(Nokogiri::XML::Node)
+          segment_element.search("trkpt").each do |trkpt|
+            pt = TrackPoint.new(:element => trkpt, :segment => self, :gpx_file => @gpx_file)
+            append_point(pt)
+          end
+        end
+      end
+    end
+
+    # Tack on a point to this Segment.  All meta-data will be updated.
+    def append_point(pt)
+      last_pt = @points[-1]
+      unless pt.time.nil?
+        @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
+        @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+      end
+      unless pt.elevation.nil?
+        @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
+        @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
+      end
+      @bounds.min_lat = pt.lat if pt.lat < @bounds.min_lat
+      @bounds.min_lon = pt.lon if pt.lon < @bounds.min_lon
+      @bounds.max_lat = pt.lat if pt.lat > @bounds.max_lat
+      @bounds.max_lon = pt.lon if pt.lon > @bounds.max_lon
+      @distance += haversine_distance(last_pt, pt) unless last_pt.nil?
+      @points << pt
+    end
+
+    # Returns true if the given time is within this Segment.
+    def contains_time?(time)
+      (time >= @earliest_point.time and time <= @latest_point.time) rescue false
+    end
+
+    # Finds the closest point in time to the passed-in time argument.  Useful
+    # for matching up time-based objects (photos, video, etc) with a
+    # geographic location.
+    def closest_point(time)
+      find_closest(points, time)
+    end
+
+    # Deletes all points within this Segment that lie outside of the given
+    # area (which should be a Bounds object).
+    def crop(area)
+      delete_if { |pt| not area.contains?(pt) }
+    end
+
+    # Deletes all points in this Segment that lie within the given area.
+    def delete_area(area)
+      delete_if{ |pt| area.contains?(pt) }
+    end
+
+    # A handy method that deletes points based on a block that is passed in.
+    # If the passed-in block returns true when given a point, then that point
+    # is deleted.  For example:
+    #         delete_if{ |pt| area.contains?(pt) }
+    def delete_if
+      reset_meta_data
+      keep_points = []
+      last_pt = nil
+      points.each do |pt|
+        unless yield(pt)
+          keep_points << pt
+          update_meta_data(pt, last_pt)
+          last_pt = pt
+        end
+      end
+      @points = keep_points
+    end
+
+    # Returns true if this Segment has no points.
+    def empty?
+      (points.nil? or (points.size == 0))
+    end
+
+    # Prints out a nice summary of this Segment.
+    def to_s
+      result = "Track Segment\n"
+      result << "\tSize: #{points.size} points\n"
+      result << "\tDistance: #{distance} km\n"
+      result << "\tEarliest Point: #{earliest_point.time.to_s} \n"
+      result << "\tLatest Point: #{latest_point.time.to_s} \n"
+      result << "\tLowest Point: #{lowest_point.elevation} \n"
+      result << "\tHighest Point: #{highest_point.elevation}\n "
+      result << "\tBounds: #{bounds.to_s}"
+      result
+    end
+
+    def find_point_by_time_or_offset(indicator)
+      if indicator.nil?
+        return nil
+      elsif indicator.is_a?(Integer)
+        return closest_point(@earliest_point.time + indicator)
+      elsif(indicator.is_a?(Time))
+        return closest_point(indicator)
+      else
+        raise Exception, "find_end_point_by_time_or_offset requires an argument of type Time or Integer"
+      end
+    end
+  
+    # smooths the location data in the segment (by recalculating the location as an average of 20 neighbouring points.  Useful for removing noise from GPS traces.
+    def smooth_location_by_average(opts={})
+      seconds_either_side = opts[:averaging_window] || 20
+
+      #calculate the first and last points to which the smoothing should be applied
+      earliest = (find_point_by_time_or_offset(opts[:start]) || @earliest_point).time
+      latest = (find_point_by_time_or_offset(opts[:end]) || @latest_point).time
+
+      tmp_points = []
+
+      @points.each do |point|
+        if point.time > latest || point.time < earliest
+          tmp_points.push point #add the point unaltered
+          next 
+        end
+        lat_av = 0.to_f
+        lon_av = 0.to_f
+        alt_av = 0.to_f
+        n = 0
+        # k ranges from the time of the current point +/- 20s 
+        (-1*seconds_either_side..seconds_either_side).each do |k|
+          # find the point nearest to the time offset indicated by k
+          contributing_point = closest_point(point.time + k)
+          #sum up the contributions to the average
+          lat_av += contributing_point.lat
+          lon_av += contributing_point.lon
+          alt_av += contributing_point.elevation
+          n += 1
+        end
+        # calculate the averages
+        tmp_point = point.clone
+        tmp_point.lon = ((lon_av) / n).round(7)
+        tmp_point.elevation = ((alt_av) / n).round(2)
+        tmp_point.lat = ((lat_av) / n).round(7)
+        tmp_points.push tmp_point
+      end
+      last_pt = nil
+      @distance = 0
+      @points.clear
+      reset_meta_data
+      #now commit the averages back and recalculate the distances
+      tmp_points.each do |point|
+        append_point(point)
+      end
+    end
+
+    protected
+    def find_closest(pts, time)
+      return pts.first if pts.size == 1
+      midpoint = pts.size/2
+      if pts.size == 2
+        diff_1 = pts[0].time - time
+        diff_2 = pts[1].time - time
+        return (diff_1 < diff_2 ? pts[0] : pts[1])
+      end
+      if time >= pts[midpoint].time and time <= pts[midpoint+1].time
+
+        return pts[midpoint]
+
+      elsif(time <= pts[midpoint].time)
+        return find_closest(pts[0..midpoint], time)
+      else
+        return find_closest(pts[(midpoint+1)..-1], time)
+      end
+    end
+
+    # Calculate the Haversine distance between two points. This is the method
+    # the library uses to calculate the cumulative distance of GPX files.
+    def haversine_distance(p1, p2)
+      p1.haversine_distance_from(p2)
+    end
+
+    # Calculate the plain Pythagorean difference between two points.  Not currently used.
+    def pythagorean_distance(p1, p2)
+      p1.pythagorean_distance_from(p2)
+    end
+
+    # Calculates the distance between two points using the Law of Cosines formula.  Not currently used.
+    def law_of_cosines_distance(p1, p2)
+      p1.law_of_cosines_distance_from(p2)
+    end
+
+    def reset_meta_data
+      @earliest_point = nil
+      @latest_point = nil
+      @highest_point = nil
+      @lowest_point = nil
+      @distance = 0.0
+      @bounds = Bounds.new
+    end
+
+    def update_meta_data(pt, last_pt)
+      unless pt.time.nil?
+        @earliest_point = pt if(@earliest_point.nil? or pt.time < @earliest_point.time)
+        @latest_point   = pt if(@latest_point.nil? or pt.time > @latest_point.time)
+      end
+      unless pt.elevation.nil?
+        @lowest_point   = pt if(@lowest_point.nil? or pt.elevation < @lowest_point.elevation)
+        @highest_point  = pt if(@highest_point.nil? or pt.elevation > @highest_point.elevation)
+      end
+      @bounds.add(pt)
+      @distance += haversine_distance(last_pt, pt) unless last_pt.nil?
+    end
+
+  end
 
 end

data/lib/gpx/track.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,129 +21,123 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 module GPX
+  # In GPX, a single Track can hold multiple Segments, each of which hold
+  # multiple points (in this library, those points are instances of
+  # TrackPoint).  Each instance of this class has its own meta-data, including
+  # low point, high point, and distance.  Of course, each track references an
+  # array of the segments that copmrise it, but additionally each track holds
+  # a reference to all of its points as one big array called "points".
+  class Track < Base
+    attr_reader :points, :bounds, :lowest_point, :highest_point, :distance
+    attr_accessor :segments, :name, :gpx_file
 
-   # In GPX, a single Track can hold multiple Segments, each of which hold
-   # multiple points (in this library, those points are instances of
-   # TrackPoint).  Each instance of this class has its own meta-data, including
-   # low point, high point, and distance.  Of course, each track references an
-   # array of the segments that copmrise it, but additionally each track holds
-   # a reference to all of its points as one big array called "points".
-   class Track < Base
-      attr_reader :points, :bounds, :lowest_point, :highest_point, :distance
-      attr_accessor :segments, :name, :gpx_file
-
-      # Initialize a track from a XML::Node, or, if no :element option is
-      # passed, initialize a blank Track object.
-      def initialize(opts = {})
-         @gpx_file = opts[:gpx_file]
-         @segments = []
-         @points = []
-         reset_meta_data
-         if(opts[:element]) 
-            trk_element = opts[:element]
-            @name = (trk_element.at("//name").inner_text rescue "")
-            trk_element.search("//trkseg").each do |seg_element|
-               seg = Segment.new(:element => seg_element, :track => self, :gpx_file => @gpx_file)
-               update_meta_data(seg)
-               @segments << seg
-            end
-         end
-      end
-       
-      # Append a segment to this track, updating its meta data along the way.
-      def append_segment(seg)
-         update_meta_data(seg)
-         @segments << seg
-         @points.concat(seg.points) unless seg.nil?
+    # Initialize a track from a XML::Node, or, if no :element option is
+    # passed, initialize a blank Track object.
+    def initialize(opts = {})
+      @gpx_file = opts[:gpx_file]
+      @segments = []
+      @points = []
+      reset_meta_data
+      if(opts[:element])
+        trk_element = opts[:element]
+        @name = (trk_element.at("name").inner_text rescue "")
+        trk_element.search("trkseg").each do |seg_element|
+          seg = Segment.new(:element => seg_element, :track => self, :gpx_file => @gpx_file)
+          update_meta_data(seg)
+          @segments << seg
+        end
       end
+    end
 
-      # Returns true if the given time occurs within any of the segments of this track.
-      def contains_time?(time)
-         segments.each do |seg|
-            return true if seg.contains_time?(time)
-         end
-         return false
-      end
+    # Append a segment to this track, updating its meta data along the way.
+    def append_segment(seg)
+      update_meta_data(seg)
+      @segments << seg
+      @points.concat(seg.points) unless seg.nil?
+    end
 
-      # Finds the closest point (to "time") within this track.  Useful for
-      # correlating things like pictures, video, and other events, if you are
-      # working with a timestamp.
-      def closest_point(time)
-         segment = segments.select { |s| s.contains_time?(time) }
-         segment.first
+    # Returns true if the given time occurs within any of the segments of this track.
+    def contains_time?(time)
+      segments.each do |seg|
+        return true if seg.contains_time?(time)
       end
+      return false
+    end
 
-      # Removes all points outside of a given area and updates the meta data.
-      # The "area" paremeter is usually a Bounds object.
-      def crop(area)
-         reset_meta_data
-         segments.each do |seg| 
-            seg.crop(area) 
-            update_meta_data(seg) unless seg.empty?
-         end
-         segments.delete_if { |seg| seg.empty? }
-      end
+    # Finds the closest point (to "time") within this track.  Useful for
+    # correlating things like pictures, video, and other events, if you are
+    # working with a timestamp.
+    def closest_point(time)
+      segment = segments.select { |s| s.contains_time?(time) }
+      segment.first
+    end
 
-      # Deletes all points within a given area and updates the meta data.  
-      def delete_area(area)
-         reset_meta_data
-         segments.each do |seg| 
-            seg.delete_area(area) 
-            update_meta_data(seg) unless seg.empty?
-         end
-         segments.delete_if { |seg| seg.empty? }
+    # Removes all points outside of a given area and updates the meta data.
+    # The "area" paremeter is usually a Bounds object.
+    def crop(area)
+      reset_meta_data
+      segments.each do |seg|
+        seg.crop(area)
+        update_meta_data(seg) unless seg.empty?
       end
+      segments.delete_if { |seg| seg.empty? }
+    end
 
-      # Returns true if this track has no points in it.  This should return
-      # true even when the track has empty segments.
-      def empty?
-         (points.nil? or points.size.zero?)
+    # Deletes all points within a given area and updates the meta data.
+    def delete_area(area)
+      reset_meta_data
+      segments.each do |seg|
+        seg.delete_area(area)
+        update_meta_data(seg) unless seg.empty?
       end
+      segments.delete_if { |seg| seg.empty? }
+    end
 
-      # Creates a new XML::Node from the contents of this instance.
-      def to_xml
-         trk= Node.new('trk')
-         name_elem = Node.new('name')
-         name_elem <<  name
-         trk <<  name_elem
-         segments.each do |seg|
-            trk <<  seg.to_xml
-         end
-         trk
-      end
+    # Returns true if this track has no points in it.  This should return
+    # true even when the track has empty segments.
+    def empty?
+      (points.nil? or points.size.zero?)
+    end
 
-      # Prints out a friendly summary of this track (sans points).  Useful for
-      # debugging and sanity checks.
+    # Prints out a friendly summary of this track (sans points).  Useful for
+    # debugging and sanity checks.
 
-      def to_s
-         result = "Track \n"
-         result << "\tName: #{name}\n"
-         result << "\tSize: #{points.size} points\n"
-         result << "\tSegments: #{segments.size} \n"
-         result << "\tDistance: #{distance} km\n"
-         result << "\tLowest Point: #{lowest_point.elevation} \n"
-         result << "\tHighest Point: #{highest_point.elevation}\n "
-         result << "\tBounds: #{bounds.to_s}"
-         result
-      end
-
-      protected
+    def to_s
+      result = "Track \n"
+      result << "\tName: #{name}\n"
+      result << "\tSize: #{points.size} points\n"
+      result << "\tSegments: #{segments.size} \n"
+      result << "\tDistance: #{distance} km\n"
+      result << "\tLowest Point: #{lowest_point.elevation} \n"
+      result << "\tHighest Point: #{highest_point.elevation}\n "
+      result << "\tBounds: #{bounds.to_s}"
+      result
+    end
 
-      def update_meta_data(seg)
-         @lowest_point   = seg.lowest_point if(@lowest_point.nil? or seg.lowest_point.elevation < @lowest_point.elevation)
-         @highest_point  = seg.highest_point if(@highest_point.nil? or seg.highest_point.elevation > @highest_point.elevation)
-         @bounds.add(seg.bounds)
-         @distance += seg.distance
-         @points.concat(seg.points)
+    def recalculate_distance
+      @distance = 0
+      @segments.each do |seg|
+        @distance += seg.distance
       end
+    end
+ 
+    protected
 
-      def reset_meta_data
-         @bounds = Bounds.new
-         @highest_point = nil
-         @lowest_point = nil
-         @distance = 0.0
-         @points = []
-      end
+    def update_meta_data(seg)
+      @lowest_point   = seg.lowest_point if(@lowest_point.nil? or seg.lowest_point.elevation < @lowest_point.elevation)
+      @highest_point  = seg.highest_point if(@highest_point.nil? or seg.highest_point.elevation > @highest_point.elevation)
+      @bounds.add(seg.bounds)
+      @distance += seg.distance
+      @points.concat(seg.points)
+    end
+
+    def reset_meta_data
+      @bounds = Bounds.new
+      @highest_point = nil
+      @lowest_point = nil
+      @distance = 0.0
+      @points = []
+    end
 
-   end
+  end
 end