georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/georss.rb

@@ -1,132 +1,154 @@
-# require 'geo_ruby/simple_features/point'
-# require 'geo_ruby/simple_features/line_string'
-# require 'geo_ruby/simple_features/linear_ring'
-# require 'geo_ruby/simple_features/polygon'
-# require 'geo_ruby/simple_features/multi_point'
-# require 'geo_ruby/simple_features/multi_line_string'
-# require 'geo_ruby/simple_features/multi_polygon'
-# require 'geo_ruby/simple_features/geometry_collection'
-# require 'geo_ruby/simple_features/envelope'
-
 module GeoRuby
-
-  #Raised when an error in the GeoRSS string is detected
+  # Raised when an error in the GeoRSS string is detected
   class GeorssFormatError < StandardError
   end
 
-  #Contains tags possibly found on GeoRss Simple geometries
-  class GeorssTags < Struct.new(:featuretypetag,:relationshiptag,:elev,:floor,:radius)
+  # Contains tags possibly found on GeoRss Simple geometries
+  class GeorssTags < Struct.new(:featuretypetag, :relationshiptag,
+                                :elev, :floor, :radius)
   end
 
-  #Parses GeoRSS strings
-  #You can also use directly the static method Geometry.from_georss
+  # Parses GeoRSS strings
+  # You can also use directly the static method Geometry.from_georss
   class GeorssParser
     include GeoRuby::SimpleFeatures
     attr_reader :georss_tags, :geometry
 
-    #Parses the georss geometry  passed as argument and notifies the factory of events
-    #The parser assumes
-    def parse(georss,with_tags = false)
+    GEORSS_REGEX = /=['"]([^"']*)['"]/
+
+    # Parses the georss geometry  passed as argument and notifies
+    # the factory of events the parser assumes
+    def parse(georss, with_tags = false)
       @geometry = nil
       @georss_tags = GeorssTags.new
-      parse_geometry(georss,with_tags)
+      parse_geometry(georss, with_tags)
     end
 
     private
-    def parse_geometry(georss,with_tags)
+
+    def parse_geometry(georss, with_tags)
       georss.strip!
-      #check for W3CGeo first
+      # check for W3CGeo first
       if georss =~ /<[^:>]*:lat\s*>([^<]*)</
-        #if valid, it is W3CGeo
-        lat = $1.to_f
+        # if valid, it is W3CGeo
+        lat = Regexp.last_match[1].to_f
         if georss =~ /<[^:>]*:long\s*>([^<]*)</
-          lon = $1.to_f
-          @geometry = Point.from_x_y(lon,lat)
+          lon = Regexp.last_match[1].to_f
+          @geometry = Point.from_x_y(lon, lat)
         else
-          raise GeorssFormatError.new("Bad W3CGeo GeoRSS format")
+          fail GeorssFormatError, 'Bad W3CGeo GeoRSS format'
         end
       elsif georss =~ /^<\s*[^:>]*:where\s*>/
-        #GML format found
+        # GML format found
         gml = $'.strip
         if gml =~ /^<\s*[^:>]*:Point\s*>/
-          #gml point
+          # gml point
           if gml =~ /<\s*[^:>]*:pos\s*>([^<]*)/
-            point = $1.split(" ")
-            #lat comes first
-            @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+            point = Regexp.last_match[1].split(' ')
+            # lat comes first
+            @geometry = Point.from_x_y(point[1].to_f, point[0].to_f)
           else
-            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Point")
+            fail GeorssFormatError, 'Bad GML GeoRSS: Malformed Point'
           end
         elsif gml =~ /^<\s*[^:>]*:LineString\s*>/
           if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
-            xy = $1.split(" ")
+            xy = Regexp.last_match[1].split(' ')
             @geometry = LineString.new
-            0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+            0.upto(xy.size / 2 - 1) do |index|
+              @geometry << Point.from_x_y(xy[index * 2 + 1].to_f,
+                                          xy[index * 2].to_f)
+            end
           else
-            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed LineString")
+            fail GeorssFormatError, 'Bad GML GeoRSS: Malformed LineString'
           end
         elsif gml =~ /^<\s*[^:>]*:Polygon\s*>/
           if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
-            xy = $1.split(" ")
+            xy = Regexp.last_match[1].split(' ')
             @geometry = Polygon.new
             linear_ring = LinearRing.new
             @geometry << linear_ring
-            xy = $1.split(" ")
-            0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+            xy = Regexp.last_match[1].split(' ')
+            0.upto(xy.size / 2 - 1) do |index|
+              linear_ring << Point.from_x_y(xy[index * 2 + 1].to_f,
+                                            xy[index * 2].to_f)
+            end
           else
-            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Polygon")
+            fail GeorssFormatError, 'Bad GML GeoRSS: Malformed Polygon'
           end
         elsif gml =~ /^<\s*[^:>]*:Envelope\s*>/
           if gml =~ /<\s*[^:>]*:lowerCorner\s*>([^<]*)</
-            lc = $1.split(" ").collect { |x| x.to_f}.reverse
+            lc = Regexp.last_match[1].split(' ').collect(&:to_f).reverse
             if gml =~ /<\s*[^:>]*:upperCorner\s*>([^<]*)</
-              uc = $1.split(" ").collect { |x| x.to_f}.reverse
-              @geometry = Envelope.from_coordinates([lc,uc])
+              uc = Regexp.last_match[1].split(' ').collect(&:to_f).reverse
+              @geometry = Envelope.from_coordinates([lc, uc])
             else
-              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+              fail GeorssFormatError, 'Bad GML GeoRSS: Malformed Envelope'
             end
           else
-            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+            fail GeorssFormatError, 'Bad GML GeoRSS: Malformed Envelope'
           end
         else
-          raise GeorssFormatError.new("Bad GML GeoRSS format: Unknown geometry type")
+          fail GeorssFormatError, 'Bad GML GeoRSS: Unknown geometry type'
         end
       else
-        #must be simple format
+        # must be simple format
         if georss =~ /^<\s*[^>:]*:point([^>]*)>(.*)</m
-          tags = $1
-          point = $2.gsub(","," ").split(" ")
-          @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+          tags = Regexp.last_match[1]
+          point = Regexp.last_match[2].gsub(',', ' ').split(' ')
+          @geometry = Point.from_x_y(point[1].to_f, point[0].to_f)
         elsif georss =~ /^<\s*[^>:]*:line([^>]*)>(.*)</m
-          tags = $1
+          tags = Regexp.last_match[1]
           @geometry = LineString.new
-          xy = $2.gsub(","," ").split(" ")
-          0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          xy = Regexp.last_match[2].gsub(',', ' ').split(' ')
+          0.upto(xy.size / 2 - 1) do |index|
+            @geometry << Point.from_x_y(xy[index * 2 + 1].to_f,
+                                        xy[index * 2].to_f)
+          end
         elsif georss =~ /^<\s*[^>:]*:polygon([^>]*)>(.*)</m
-          tags = $1
+          tags = Regexp.last_match[1]
           @geometry = Polygon.new
           linear_ring = LinearRing.new
           @geometry << linear_ring
-          xy = $2.gsub(","," ").split(" ")
-          0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          xy = Regexp.last_match[2].gsub(',', ' ').split(' ')
+          0.upto(xy.size / 2 - 1) do |index|
+            linear_ring << Point.from_x_y(xy[index * 2 + 1].to_f,
+                                          xy[index * 2].to_f)
+          end
         elsif georss =~ /^<\s*[^>:]*:box([^>]*)>(.*)</m
-          tags = $1
+          tags = Regexp.last_match[1]
           corners = []
-          xy = $2.gsub(","," ").split(" ")
-          0.upto(xy.size/2 - 1) {|index| corners << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          xy = Regexp.last_match[2].gsub(',', ' ').split(' ')
+          0.upto(xy.size / 2 - 1) do |index|
+            corners << Point.from_x_y(xy[index * 2 + 1].to_f,
+                                      xy[index * 2].to_f)
+          end
           @geometry = Envelope.from_points(corners)
         else
-          raise GeorssFormatError.new("Bad Simple GeoRSS format: Unknown geometry type")
+          fail GeorssFormatError, 'Bad Simple GeoRSS format: ' \
+                                  'Unknown geometry type'
         end
 
-        #geometry found: parse tags
+        # geometry found: parse tags
         return unless with_tags
+        if tags =~ /featuretypetag#{GEORSS_REGEX}/
+          @georss_tags.featuretypetag = Regexp.last_match[1]
+        end
+
+        if tags =~ /relationshiptag#{GEORSS_REGEX}/
+          @georss_tags.relationshiptag = Regexp.last_match[1]
+        end
+
+        if tags =~ /elev#{GEORSS_REGEX}/
+          @georss_tags.elev = Regexp.last_match[1].to_f
+        end
+
+        if tags =~ /floor#{GEORSS_REGEX}/
+          @georss_tags.floor = Regexp.last_match[1].to_i
+        end
 
-        @georss_tags.featuretypetag = $1 if tags =~ /featuretypetag=['"]([^"']*)['"]/
-        @georss_tags.relationshiptag = $1 if tags =~ /relationshiptag=['"]([^'"]*)['"]/
-        @georss_tags.elev = $1.to_f if tags =~ /elev=['"]([^'"]*)['"]/
-        @georss_tags.floor = $1.to_i if tags =~ /floor=['"]([^'"]*)['"]/
-        @georss_tags.radius = $1.to_f if tags =~ /radius=['"]([^'"]*)['"]/
+        if tags =~ /radius#{GEORSS_REGEX}/
+          @georss_tags.radius = Regexp.last_match[1].to_f
+        end
 
       end
     end

data/lib/geo_ruby/gpx.rb

@@ -1 +1,113 @@
-require 'geo_ruby/gpx4r/gpx'
+require 'nokogiri'
+
+module GeoRuby
+  module Gpx4r
+    # An interface to GPX files
+    class GpxFile
+      attr_reader :record_count, :file_root #:xmin, :ymin, :xmax, :ymax, :zmin, :zmax, :mmin, :mmax, :file_length
+
+      include Enumerable
+
+      # Opens a GPX file. Both "abc.shp" and "abc" are accepted.
+      def initialize(file, *opts) # with_z = true, with_m = true)
+        @file_root = file.gsub(/\.gpx$/i, '')
+        fail MalformedGpxException.new('Missing GPX File') unless
+          File.exist? @file_root + '.gpx'
+        @points, @envelope = [], nil
+        @gpx = File.open(@file_root + '.gpx', 'rb')
+        opt = opts.reduce({}) { |a, e| e.merge(a) }
+        parse_file(opt[:with_z], opt[:with_m])
+      end
+
+      # force the reopening of the files compsing the shp. Close before calling this.
+      def reload!
+        initialize(@file_root)
+      end
+
+      # opens a GPX "file". If a block is given, the GpxFile object is yielded to it and is closed upon return. Else a call to <tt>open</tt> is equivalent to <tt>GpxFile.new(...)</tt>.
+      def self.open(file, *opts)
+        gpxfile = GpxFile.new(file, *opts)
+        if block_given?
+          yield gpxfile
+          # gpxfile.close
+        else
+          gpxfile
+        end
+      end
+
+      # Closes a gpxfile
+      def close
+        @gpx.close
+      end
+
+      # Tests if the file has no record
+      def empty?
+        record_count == 0
+      end
+
+      # Goes through each record
+      def each
+        (0...record_count).each do |i|
+          yield get_record(i)
+        end
+      end
+      alias_method :each_record, :each
+
+      # Returns record +i+
+      def [](i)
+        get_record(i)
+      end
+
+      # Returns all the records
+      def records
+        @points
+      end
+
+      # Return the GPX file as LineString
+      def as_line_string
+        GeoRuby::SimpleFeatures::LineString.from_points(@points)
+      end
+      alias_method :as_polyline, :as_line_string
+
+      # Return the GPX file as a Polygon
+      # If the GPX isn't closed, a line from the first
+      # to the last point will be created to close it.
+      def as_polygon
+        GeoRuby::SimpleFeatures::Polygon.from_points([@points[0] == @points[-1] ?  @points : @points.push(@points[0].clone)])
+      end
+
+      # Return GPX Envelope
+      def envelope
+        @envelope ||= as_polygon.envelope
+      end
+
+      private
+
+      def get_record(i)
+        @points[i]
+      end
+
+      # wpt => waypoint => TODO?
+      # rte(pt) => route
+      # trk(pt) => track /
+      def parse_file(with_z, with_m)
+        data = @gpx.read
+        @file_mode = data =~ /trkpt/ ? '//trkpt' : (data =~ /wpt/ ? '//wpt' : '//rtept')
+        Nokogiri.HTML(data).search(@file_mode).each do |tp|
+          z = z.inner_text.to_f if with_z && z = tp.at('ele')
+          m = m.inner_text if with_m && m = tp.at('time')
+          @points << GeoRuby::SimpleFeatures::Point.from_coordinates([tp['lon'].to_f, tp['lat'].to_f, z, m], 4326, with_z, with_m)
+        end
+        close
+        @record_count = @points.length
+        envelope
+      rescue => e
+        raise MalformedGpxException.new("Bad GPX. Error: #{e}")
+        # trackpoint.at("gpxdata:hr").nil? # heartrate
+      end
+    end
+
+    class MalformedGpxException < StandardError
+    end
+  end
+end

data/lib/geo_ruby/kml.rb

@@ -3,16 +3,18 @@ module GeoRuby
   class KmlParser
     ELEMENT_MAP = {
       # "Point" => SimpleFeatures::Point, # we don't need to map points.  they are done automatically by the coordinate parsing
-      "LineString" => SimpleFeatures::LineString,
-      "LinearRing" => SimpleFeatures::LinearRing,
-      "Polygon" => SimpleFeatures::Polygon,
-      "MultiGeometry" => SimpleFeatures::GeometryCollection
+      'LineString' => SimpleFeatures::LineString,
+      'LinearRing' => SimpleFeatures::LinearRing,
+      'Polygon' => SimpleFeatures::Polygon,
+      'MultiGeometry' => SimpleFeatures::GeometryCollection
     }
+
     def initialize(factory)
       @factory = factory
-      @buffer = ""
+      @buffer = ''
       @with_z = false
     end
+
     # argument should be a valid kml geometry fragment ie. <Point> .... </Point>
     # returns the GeoRuby geometry object back
     def parse(kml)
@@ -22,24 +24,24 @@ module GeoRuby
       while @parser.has_next?
         e = @parser.pull
         if e.start_element?
-          if(type = ELEMENT_MAP[e[0]])
+          if (type = ELEMENT_MAP[e[0]])
             @factory.begin_geometry(type)
           else
-            @buffer = "" if(e[0] == "coordinates") # clear the buffer
+            @buffer = '' if (e[0] == 'coordinates') # clear the buffer
             accumulate_start(e)
           end
         elsif e.end_element?
-          if(ELEMENT_MAP[e[0]])
+          if ELEMENT_MAP[e[0]]
             @factory.end_geometry(@with_z)
-            @buffer = "" # clear the buffer
+            @buffer = '' # clear the buffer
           else
             accumulate_end(e)
-            if(e[0] == "coordinates")
+            if (e[0] == 'coordinates')
               parse_coordinates(@buffer)
-              @buffer = "" # clear the buffer
+              @buffer = '' # clear the buffer
             end
           end
-        elsif e.text? 
+        elsif e.text?
           accumulate_text(e)
         elsif e.cdata?
           accumulate_cdata(e)
@@ -47,38 +49,48 @@ module GeoRuby
       end
       @factory.geometry.dup
     end
-    
-    private      
-    def accumulate_text(e); @buffer << e[0]; end
-    def accumulate_cdata(e); @buffer << "<![CDATA[#{e[0]}]]>"; end
+
+    private
+
+    def accumulate_text(e)
+      @buffer << e[0]
+    end
+
+    def accumulate_cdata(e)
+      @buffer << "<![CDATA[#{e[0]}]]>"
+    end
+
     def accumulate_start(e)
       @buffer << "<#{e[0]}"
-      if(e[1].class == Hash)
-        e[1].each_pair {|k,v| @buffer << " #{k}='#{v}'" }
+      if (e[1].class == Hash)
+        e[1].each_pair { |k, v| @buffer << " #{k}='#{v}'" }
       end
-      @buffer << ">"
+      @buffer << '>'
+    end
+
+    def accumulate_end(e)
+      @buffer << "</#{e[0]}>"
     end
-    def accumulate_end(e); @buffer << "</#{e[0]}>"; end
-    
+
     def parse_coordinates(buffer)
-      if(buffer =~ /<coordinates>(.+)<\/coordinates>/m)
-        $1.gsub(/\n/, " ").strip.split(/\s+/).each do |coord|
-          x,y,z = coord.split(',')
-          if(x.nil? || y.nil?) 
-            raise StandardError, "coordinates must have at least x and y elements"
+      if buffer =~ /<coordinates>(.+)<\/coordinates>/m
+        Regexp.last_match[1].gsub(/\n/, ' ').strip.split(/\s+/).each do |coord|
+          x, y, z = coord.split(',')
+          if x.nil? || y.nil?
+            fail StandardError, 'coordinates must have at least x and y elements'
           end
           @factory.begin_geometry(SimpleFeatures::Point)
-          if(z.nil?)
-            @factory.add_point_x_y(x,y)
+          if z.nil?
+            @factory.add_point_x_y(x, y)
           else
-            @factory.add_point_x_y_z(x,y,z)
+            @factory.add_point_x_y_z(x, y, z)
             @with_z = true unless @with_z # is the conditional even necessary
           end
           @factory.end_geometry(@with_z)
         end
       end
     rescue
-      raise StandardError, "error parsing coordinates: check your kml for errors"
+      raise StandardError, 'error parsing coordinates: check your kml for errors'
     end
   end
-end
+end