nofxx-georuby 1.3.9 → 1.6.0

data/README.txt

@@ -1,8 +1,10 @@
-=GeoRuby
+= GeoRuby
 
 This is a fork of GeoRuby. It is intended as a holder for data returned from PostGIS and the Spatial Extensions of MySql. The data model roughly follows the OGC "Simple Features for SQL" specification (see http://www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections). It also supports various output and input formats (GeoRSS, KML, Shapefile).
 
-===Available data types
+
+=== Available data types
+
 The following geometric data types are provided :
 - Point
 - Line string
@@ -17,17 +19,24 @@ They can be in 2D, 3DZ, 3DM, and 4D.
 
 On top of this an Envelope class is available, to contain the bounding box of a geometry.
 
-===Input and output
+
+=== Input and output
+
 These geometries can be input and output in WKB/EWKB/WKT/EWKT format (as well as the related HexWKB and HexEWKB formats). HexEWKB and WKB are the default form under which geometric data is returned respectively from PostGIS and MySql.
 
 GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be input and output. Note that they will not output valid RSS, but just the part strictly concerning the geometry as outlined in http://www.georss.org/1/ . Since the model does not allow multiple geometries, for geometry collections, only the first geometry will be output. Similarly, for polygons, the GeoRSS output will only contain the outer ring. As for W3CGeo output, only points can be output, so the first point of the geometry is chosen. By default the Simple format is output. Envelope can also be output in these formats: The box geometric type is chosen (except for W3CGeo, where the center of the envelope is chose). These formats can also be input and a GeoRuby geometry will be created. Note that it will not read a valid RSS file, only a geometry string.
 
 On top of that, there is now support for KML output and input. As for GeoRSS, a valid KML file will not be output, but only the geometric data. Options <tt>:id</tt>, <tt>:extrude</tt>, <tt>:tesselate</tt> and <tt>:altitude_mode</tt> can be given. Note that if the <tt>:altitude_mode</tt> option is not passed or set to <tt>clampToGround</tt>, the altitude data will not be output even if present. Envelopes output a LatLonAltBox instead of a geometry. For the output, the following geometric types are supported : Point, LineString, Polygon.
 
-===SHP reading et writing
+
+=== SHP reading et writing
+
 Georuby has support for reading ESRI shapefiles (http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf). A tool called <tt>shp2sql.rb</tt> is also provided : it shows how to use the SHP reading functionality together with the spatial adapter plugin for Rails to import spatial features into MySQL and PostGIS.
 
 Here is an example of Shapefile reading, that goes through all the geometries in a file and disaply the values of the attributes :
+
+        require 'geo_ruby/shp'
+
         ShpFile.open(shpfile) do |shp|
                 shp.each do |shape|
                         geom = shape.geometry #a GeoRuby SimpleFeature
@@ -41,10 +50,13 @@ Here is an example of Shapefile reading, that goes through all the geometries in
 Support for ESRI shapefile creation and modification has been added as well. New shapefiles can be created given a geometry type and specifications for the DBF fields. Data can be added and removed from an existing shapefile. An update operation is also provided for convenience : it just performs a 'delete' and an 'add', which means the index of the modified record will change. Note that once a shapefile has been created, GeoRuby does not allow the modification of the schema (it will probably be done in a subsequent version).
 
 Here is an example of how to create a new Shapefile with 2 fields :
+
         shpfile = ShpFile.create('hello.shp',ShpType::POINT,[Dbf::Field.new("Hoyoyo","C",10),Dbf::Field.new("Boyoul","N",10,0)])
+
 The file is then open for reading and writing.
 
 Here is an example of how to write to a shapefile (created or not with GeoRuby) :
+
         shpfile = ShpFile.open('places.shp')
         shpfile.transaction do |tr|
                 tr.add(ShpRecord.new(Point.from_x_y(123.4,123.4),'Hoyoyo' => "AEZ",'Bouyoul' => 45))
@@ -57,27 +69,50 @@ Note the transaction is just there so the operations on the files can be buffere
 
 Also currently, error reporting is minimal and it has not been tested that thoroughly so caveat emptor and backup before performing any destructive operation.
 
-===Installation
+
+=== GPX Reading
+
+You can read and convert GPX Files to LineString/Polygon:
+
+     gpxfile = GpxFile.open(tour.gpx')
+     gpxfile.as_line_string
+     => GeoRuby::SimpleFeatures::LineString..
+
+
+=== Installation
+
 To install the latest version, just type :
-      gem install GeoRuby
 
-===Changes since the last version
+      gem install nofxx-georuby
+
+
+=== Changes since the last version
+
 - Writing of ESRI shapefiles
 - Reading of ESRI shapefiles
 - Addition of a small tool to import spatial features in MySQL and PostGIS from a SHP file
 
-===Coming in the next versions
+
+=== Coming in the next versions
+
 - Schema modification of existing shapefiles
 - More error reporting when writing shapefiles
 - More tests on writing shapefiles ; tests on real-world shapefiles
 - Better shp2sql import tool
 - Documentation
 
-===Acknowledgement
-The SHP reading part uses a modified version of the DBF library (http://rubyforge.org/projects/dbf/) by Keith Morrison (http://infused.org). Thanks also to Pramukta Kumar and Pete Schwamb for their contributions.
 
-===License
+=== Acknowledgement
+
+The SHP reading part uses the DBF library (http://rubyforge.org/projects/dbf/) by Keith Morrison (http://infused.org).
+Thanks also to Pramukta Kumar and Pete Schwamb for their contributions.
+
+
+=== License
+
 GeoRuby is released under the MIT license.
 
-===Support
-Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut@gmail.com.
+=== Support
+
+Any questions, enhancement proposals, bug notifications or corrections
+can be sent to mailto:guilhem.vellut@gmail.com.

data/VERSION

@@ -0,0 +1 @@
+1.6.0

data/georuby.gemspec

@@ -1,12 +1,15 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{georuby}
-  s.version = "1.3.9"
+  s.version = "1.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guilhem Vellut", "Marcos Augusto"]
-  s.date = %q{2009-05-07}
+  s.date = %q{2009-08-16}
   s.description = %q{GeoRuby provides geometric data types from the OGC 'Simple Features' specification.}
   s.email = %q{x@nofxx.com}
   s.extra_rdoc_files = [
@@ -19,9 +22,12 @@ Gem::Specification.new do |s|
      "LICENSE",
      "README.txt",
      "Rakefile",
-     "VERSION.yml",
+     "VERSION",
      "georuby.gemspec",
      "lib/geo_ruby.rb",
+     "lib/geo_ruby/gpx.rb",
+     "lib/geo_ruby/gpx4r/gpx.rb",
+     "lib/geo_ruby/shp.rb",
      "lib/geo_ruby/shp4r/dbf.rb",
      "lib/geo_ruby/shp4r/shp.rb",
      "lib/geo_ruby/simple_features/envelope.rb",
@@ -43,6 +49,11 @@ Gem::Specification.new do |s|
      "script/destroy",
      "script/generate",
      "script/txt2html",
+     "spec/data/gpx/long.gpx",
+     "spec/data/gpx/long.kml",
+     "spec/data/gpx/long.nmea",
+     "spec/data/gpx/short.gpx",
+     "spec/data/gpx/short.kml",
      "spec/data/multipoint.dbf",
      "spec/data/multipoint.shp",
      "spec/data/multipoint.shx",
@@ -55,6 +66,7 @@ Gem::Specification.new do |s|
      "spec/data/polyline.dbf",
      "spec/data/polyline.shp",
      "spec/data/polyline.shx",
+     "spec/geo_ruby/gpx4r/gpx_spec.rb",
      "spec/geo_ruby/shp4r/shp_spec.rb",
      "spec/geo_ruby/simple_features/envelope_spec.rb",
      "spec/geo_ruby/simple_features/ewkb_parser_spec.rb",
@@ -74,30 +86,30 @@ Gem::Specification.new do |s|
      "spec/spec.opts",
      "spec/spec_helper.rb"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/nofxx/georuby}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.2}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{Ruby data holder for OGC Simple Features}
   s.test_files = [
-    "spec/geo_ruby/shp4r/shp_spec.rb",
-     "spec/geo_ruby/simple_features/polygon_spec.rb",
-     "spec/geo_ruby/simple_features/linear_ring_spec.rb",
+    "spec/geo_ruby_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/geo_ruby/gpx4r/gpx_spec.rb",
+     "spec/geo_ruby/shp4r/shp_spec.rb",
+     "spec/geo_ruby/simple_features/point_spec.rb",
      "spec/geo_ruby/simple_features/geometry_factory_spec.rb",
-     "spec/geo_ruby/simple_features/geometry_spec.rb",
-     "spec/geo_ruby/simple_features/georss_parser_spec.rb",
-     "spec/geo_ruby/simple_features/multi_point_spec.rb",
-     "spec/geo_ruby/simple_features/ewkt_parser_spec.rb",
+     "spec/geo_ruby/simple_features/envelope_spec.rb",
+     "spec/geo_ruby/simple_features/polygon_spec.rb",
      "spec/geo_ruby/simple_features/line_string_spec.rb",
      "spec/geo_ruby/simple_features/multi_line_string_spec.rb",
-     "spec/geo_ruby/simple_features/geometry_collection_spec.rb",
+     "spec/geo_ruby/simple_features/ewkt_parser_spec.rb",
      "spec/geo_ruby/simple_features/ewkb_parser_spec.rb",
+     "spec/geo_ruby/simple_features/linear_ring_spec.rb",
+     "spec/geo_ruby/simple_features/geometry_collection_spec.rb",
      "spec/geo_ruby/simple_features/multi_polygon_spec.rb",
-     "spec/geo_ruby/simple_features/point_spec.rb",
-     "spec/geo_ruby/simple_features/envelope_spec.rb",
-     "spec/geo_ruby_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/geo_ruby/simple_features/multi_point_spec.rb",
+     "spec/geo_ruby/simple_features/georss_parser_spec.rb",
+     "spec/geo_ruby/simple_features/geometry_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/geo_ruby.rb

@@ -16,4 +16,7 @@ require 'geo_ruby/simple_features/geometry_collection'
 require 'geo_ruby/simple_features/envelope'
 require 'geo_ruby/simple_features/geometry_factory'
 require 'geo_ruby/simple_features/georss_parser'
-require 'geo_ruby/shp4r/shp'
+
+# Include if you need
+# require 'geo_ruby/shp4r/shp'
+# require 'geo_ruby/gpx4r/gpx'

data/lib/geo_ruby/gpx.rb

@@ -0,0 +1 @@
+require 'geo_ruby/gpx4r/gpx'

data/lib/geo_ruby/gpx4r/gpx.rb

@@ -0,0 +1,109 @@
+require "rubygems"
+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, with_z = true, with_m = true)
+        @file_root = file.gsub(/\.gpx$/i,"")
+        raise MalformedGpxException.new("Missing GPX File") unless
+          File.exists? @file_root + ".gpx"
+        @points, @envelope = [], nil
+        @gpx = File.open(@file_root + ".gpx", "rb")
+        parse_file
+      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)
+        gpxfile = GpxFile.new(file)
+        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 :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
+        LineString.from_points(@points)
+      end
+      alias :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
+        Polygon.from_points([@points << @points[-1]])
+      end
+
+      # Return GPX Envelope
+      def envelope
+        @envelope ||= as_polygon.envelope
+      end
+
+      private
+
+      def get_record(i)
+        @points[i]
+      end
+
+      def parse_file
+        Nokogiri.HTML(@gpx.read).search("//trkpt").each do |tp|
+          @points << Point.from_x_y_z_m(tp["lon"].to_f, tp["lat"].to_f, tp.at("ele").inner_text.to_i, tp.at("time").inner_text)
+        end
+        close
+        @record_count = @points.length
+      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/shp.rb

@@ -0,0 +1 @@
+require 'geo_ruby/shp4r/shp'

data/lib/geo_ruby/shp4r/dbf.rb

@@ -1,180 +1,37 @@
-# Copyright 2006 Keith Morrison (http://infused.org)
-# Modified version of his DBF library (http://rubyforge.org/projects/dbf/)
+# Uses the dbf lib, Copyright 2006 Keith Morrison (http://infused.org)
+# Modified to work as external gem now
+require 'rubygems'
+require 'dbf'
 
 module GeoRuby
   module Shp4r
-    module Dbf
-
-      DBF_HEADER_SIZE = 32
-      DATE_REGEXP = /([\d]{4})([\d]{2})([\d]{2})/
-      VERSION_DESCRIPTIONS = {
-        "02" => "FoxBase",
-        "03" => "dBase III without memo file",
-        "04" => "dBase IV without memo file",
-        "05" => "dBase V without memo file",
-        "30" => "Visual FoxPro",
-        "31" => "Visual FoxPro with AutoIncrement field",
-        "7b" => "dBase IV with memo file",
-        "83" => "dBase III with memo file",
-        "8b" => "dBase IV with memo file",
-        "8e" => "dBase IV with SQL table",
-        "f5" => "FoxPro with memo file",
-        "fb" => "FoxPro without memo file"
-      }
-
-      class DBFError < StandardError; end
-      class UnpackError < DBFError; end
-
-      class Reader
-        attr_reader :field_count
-        attr_reader :fields
-        attr_reader :record_count
-        attr_reader :version
-        attr_reader :last_updated
-        attr_reader :header_length
-        attr_reader :record_length
-
-        def initialize(file)
-          @data_file = File.open(file, 'rb')
-          reload!
-        end
-
-        def self.open(file)
-          reader = Reader.new(file)
-          if block_given?
-            yield reader
-            reader.close
-          else
-            reader
-          end
-        end
-
-        def close
-          @data_file.close
-        end
-
-        def reload!
-          get_header_info
-          get_field_descriptors
-        end
-
-        def field(field_name)
-          @fields.detect {|f| f.name == field_name.to_s}
-        end
-
-        # An array of all the records contained in the database file
-        def records
-          seek_to_record(0)
-          @records ||= Array.new(@record_count) do |i|
-            if active_record?
-              build_record
-            else
-              seek_to_record(i + 1)
-              nil
-            end
-          end
-        end
-        alias_method :rows, :records
-
-        # Jump to record
-        def record(index)
-          seek_to_record(index)
-          active_record? ? build_record : nil
-        end
-
-        alias_method :row, :record
-
-        def version_description
-          VERSION_DESCRIPTIONS[version]
-        end
-
-        private
-
-        def active_record?
-          @data_file.read(1).unpack('H2').to_s == '20' rescue false
-        end
+    Dbf = DBF
 
-        def build_record
-          record = DbfRecord.new
-          @fields.each do |field|
-            case field.type
-            when 'N'
-              record[field.name] = unpack_integer(field) rescue nil
-            when 'F'
-              record[field.name] = unpack_float(field) rescue nil
-            when 'D'
-              raw = unpack_string(field).to_s.strip
-              unless raw.empty?
-                begin
-                  record[field.name] = Time.gm(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i})
-                rescue
-                  record[field.name] = Date.new(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i}) rescue nil
-                end
-              end
-            when 'L'
-              record[field.name] = unpack_string(field) =~ /^(y|t)$/i ? true : false rescue false
-            when 'C'
-              record[field.name] = unpack_string(field).strip
-            else
-              record[field.name] = unpack_string(field)
-            end
-          end
-          record
-        end
-
-        def get_header_info
-          @data_file.rewind
-          @version, @record_count, @header_length, @record_length = @data_file.read(DBF_HEADER_SIZE).unpack('H2xxxVvv')
-          @field_count = (@header_length - DBF_HEADER_SIZE + 1) / DBF_HEADER_SIZE
-        end
-
-        def get_field_descriptors
-          @fields = Array.new(@field_count) {|i| Field.new(*@data_file.read(32).unpack('a10xax4CC'))}
-        end
-
-        def seek(offset)
-          @data_file.seek(@header_length + offset)
-        end
-
-        def seek_to_record(index)
-          seek(@record_length * index)
-        end
-
-        def unpack_field(field)
-          @data_file.read(field.length).unpack("a#{field.length}")
-        end
-
-        def unpack_string(field)
-          unpack_field(field).to_s
-        end
-
-        def unpack_integer(field)
-          unpack_string(field).to_i
+    module Dbf
+      class Record
+        def [](v)
+          attributes[v.downcase]
         end
+      end
 
-        def unpack_float(field)
-          unpack_string(field).to_f
+      class Field < Column
+        def initialize(name, type, length, decimal = 0)
+          super(name, type, length, decimal)
         end
-
       end
 
-      class FieldError < StandardError; end
-
-      class Field
-        attr_reader :name, :type, :length, :decimal
+      class Reader < Table
+        alias_method :fields, :columns
+        def header_length
+          @columns_count
+        end
 
-        def initialize(name, type, length, decimal = 0)
-          raise FieldError, "field length must be greater than 0" unless length > 0
-          if type == 'N' and decimal != 0
-            type = 'F'
-          end
-          @name, @type, @length, @decimal = name.strip, type,length, decimal
+        def self.open(f)
+          new(f)
         end
-      end
 
-      class DbfRecord < Hash
+        def close(); nil;  end
       end
-
     end
   end
 end