ppe-georuby 1.7.2

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+pkg/*.gem
+pkg/*.tgz
+pkg/**/*
+coverage/*
+doc/*

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-08-14
+
+* 1 major enhancement:
+  * Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+GeoRuby License
+
+Copyright (c) 2006 Guilhem Vellut <guilhem.vellut+georuby@gmail.com>
+
+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
+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.

data/README.txt

@@ -0,0 +1,118 @@
+= 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
+
+The following geometric data types are provided :
+- Point
+- Line string
+- Linear ring
+- Polygon
+- Multi point
+- Multi line string
+- Multi polygon
+- Geometry collection
+
+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
+
+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
+
+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
+          att_data = shape.data #a Hash
+          shp.fields.each do |field|
+            puts att_data[field.name]
+          end
+        end
+      end
+
+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))
+        tr.update(4,ShpRecord.new(Point.from_x_y(-16.67,16.41),'Hoyoyo' => "EatMe",'Bouyoul' => 42))
+        tr.delete(1)
+      end
+      shpfile.close
+																	 
+Note the transaction is just there so the operations on the files can be buffered. Nothing happens on the original files until the block has finished executing. Calling <tt>tr.rollback</tt> at anytime during the execution will prevent the modifications.
+
+Also currently, error reporting is minimal and it has not been tested that thoroughly so caveat emptor and backup before performing any destructive operation.
+
+
+=== 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 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
+
+- 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 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.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "nofxx-georuby"
+    gem.summary = "Ruby data holder for OGC Simple Features"
+    gem.description = "GeoRuby provides geometric data types from the OGC 'Simple Features' specification."
+    gem.email = "x@nofxx.com"
+    gem.homepage = "http://github.com/nofxx/georuby"
+    gem.authors = ["Guilhem Vellut", "Marcos Piccinini"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "dbf", ">= 1.1.2"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geo_ruby #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+1.7.2

data/lib/geo_ruby.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'geo_ruby/simple_features/helper'
+require 'geo_ruby/simple_features/ewkt_parser'
+require 'geo_ruby/simple_features/ewkb_parser'
+require 'geo_ruby/simple_features/geometry'
+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'
+require 'geo_ruby/simple_features/geometry_factory'
+require 'geo_ruby/simple_features/georss_parser'
+
+# 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,117 @@
+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, *opts) #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")
+        opt = opts.inject({}) { |o, h| h.merge(o) }
+        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 :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[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" : "//rtept"
+        Nokogiri.HTML(data).search(@file_mode).each do |tp|
+          z = z.inner_text.to_i if with_z && z = tp.at("ele")
+          m = m.inner_text if with_m && m = tp.at("time")
+          @points << Point.from_coordinates([tp["lon"].to_f, tp["lat"].to_f, z, m],nil,with_z, with_m)
+        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

@@ -0,0 +1,41 @@
+# Uses the dbf lib, Copyright 2006 Keith Morrison (http://infused.org)
+# Modified to work as external gem now
+require 'rubygems'
+begin
+  require 'dbf'
+rescue LoadError
+  puts "Unable to find gem 'dbf'. Please install."
+end
+
+module GeoRuby
+  module Shp4r
+    Dbf = DBF
+
+    module Dbf
+      class Record
+        def [](v)
+          attributes[v.downcase]
+        end
+      end
+
+      class Field < Column
+        def initialize(name, type, length, decimal = 0)
+          super(name, type, length, decimal)
+        end
+      end
+
+      class Reader < Table
+        alias_method :fields, :columns
+        def header_length
+          @columns_count
+        end
+
+        def self.open(f)
+          new(f)
+        end
+
+        def close(); nil;  end
+      end
+    end
+  end
+end

data/lib/geo_ruby/shp4r/shp.rb

@@ -0,0 +1,697 @@
+require 'date'
+require 'fileutils' if !defined?(FileUtils)
+require  File.dirname(__FILE__) + '/dbf'
+
+
+module GeoRuby
+  module Shp4r
+
+    #Enumerates all the types of SHP geometries. The MULTIPATCH one is the only one not currently supported by Geo_ruby.
+    module ShpType
+      NULL_SHAPE = 0
+      POINT = 1
+      POLYLINE = 3
+      POLYGON = 5
+      MULTIPOINT = 8
+      POINTZ = 11
+      POLYLINEZ = 13
+      POLYGONZ = 15
+      MULTIPOINTZ = 18
+      POINTM = 21
+      POLYLINEM = 23
+      POLYGONM = 25
+      MULTIPOINTM = 28
+    end
+
+    #An interface to an ESRI shapefile (actually 3 files : shp, shx and dbf). Currently supports only the reading of geometries.
+    class ShpFile
+      attr_reader :shp_type, :record_count, :xmin, :ymin, :xmax, :ymax, :zmin, :zmax, :mmin, :mmax, :file_root, :file_length
+
+      include Enumerable
+
+      #Opens a SHP file. Both "abc.shp" and "abc" are accepted. The files "abc.shp", "abc.shx" and "abc.dbf" must be present
+      def initialize(file)
+        #strip the shp out of the file if present
+        @file_root = file.gsub(/.shp$/i,"")
+        #check existence of shp, dbf and shx files
+        unless File.exists?(@file_root + ".shp") and File.exists?(@file_root + ".dbf") and File.exists?(@file_root + ".shx")
+          raise MalformedShpException.new("Missing one of shp, dbf or shx for: #{@file}")
+        end
+
+        @dbf = Dbf::Reader.open(@file_root + ".dbf")
+        @shx = File.open(@file_root + ".shx","rb")
+        @shp = File.open(@file_root + ".shp","rb")
+        read_index
+      end
+
+      #force the reopening of the files compsing the shp. Close before calling this.
+      def reload!
+        initialize(@file_root)
+      end
+
+      #opens a SHP "file". If a block is given, the ShpFile object is yielded to it and is closed upon return. Else a call to <tt>open</tt> is equivalent to <tt>ShpFile.new(...)</tt>.
+      def self.open(file)
+        shpfile = ShpFile.new(file)
+        if block_given?
+          yield shpfile
+          shpfile.close
+        else
+          shpfile
+        end
+      end
+
+      #create a new Shapefile of the specified shp type (see ShpType) and with the attribute specified in the +fields+ array (see Dbf::Field). If a block is given, the ShpFile object newly created is passed to it.
+      def self.create(file,shp_type,fields,&proc)
+        file_root = file.gsub(/.shp$/i,"")
+        shx_io = File.open(file_root + ".shx","wb")
+        shp_io = File.open(file_root + ".shp","wb")
+        dbf_io = File.open(file_root + ".dbf","wb")
+        str = [9994,0,0,0,0,0,50,1000,shp_type,0,0,0,0,0,0,0,0].pack("N7V2E8")
+        shp_io << str
+        shx_io << str
+        rec_length = 1 + fields.inject(0) {|s,f| s + f.length} #+1 for the prefixed space (active record marker)
+        dbf_io << [3,107,7,7,0,33 + 32 * fields.length,rec_length ].pack("c4Vv2x20") #32 bytes for first part of header
+        fields.each do |field|
+          dbf_io << [field.name,field.type,field.length,field.decimal].pack("a10xax4CCx14")
+        end
+        dbf_io << ['0d'].pack("H2")
+
+        shx_io.close
+        shp_io.close
+        dbf_io.close
+
+        open(file,&proc)
+
+      end
+
+      #Closes a shapefile
+      def close
+        @dbf.close
+        @shx.close
+        @shp.close
+      end
+
+      #starts a transaction, to buffer physical file operations on the shapefile components.
+      def transaction
+        trs = ShpTransaction.new(self,@dbf)
+        if block_given?
+          answer = yield trs
+          if answer == :rollback
+            trs.rollback
+          elsif !trs.rollbacked
+            trs.commit
+          end
+        else
+          trs
+        end
+      end
+
+      #return the description of data fields
+      def fields
+        @dbf.fields
+      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
+        Array.new(record_count) do |i|
+          get_record(i)
+        end
+      end
+
+      private
+      def read_index
+        @file_length, @shp_type, @xmin, @ymin, @xmax, @ymax, @zmin, @zmax, @mmin,@mmax = @shx.read(100).unpack("x24Nx4VE8")
+        @record_count = (@file_length - 50) / 4
+        if @record_count == 0
+          #initialize the bboxes to default values so if data added, they will be replaced
+          @xmin, @ymin, @xmax, @ymax, @zmin, @zmax, @mmin,@mmax =  Float::MAX, Float::MAX, -Float::MAX, -Float::MAX, Float::MAX, -Float::MAX, Float::MAX, -Float::MAX
+        end
+        unless @record_count == @dbf.record_count
+          raise MalformedShpException.new("Not the same number of records in SHP and DBF")
+        end
+      end
+
+      #TODO : refactor to minimize redundant code
+      def get_record(i)
+        return nil if record_count <= i or i < 0
+        dbf_record = @dbf.record(i)
+        @shx.seek(100 + 8 * i) #100 is the header length
+        offset,length = @shx.read(8).unpack("N2")
+        @shp.seek(offset * 2 + 8)
+        rec_shp_type = @shp.read(4).unpack("V")[0]
+
+        case(rec_shp_type)
+        when ShpType::POINT
+          x, y = @shp.read(16).unpack("E2")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+        when ShpType::POLYLINE #actually creates a multi_polyline
+          @shp.seek(32,IO::SEEK_CUR) #extent
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          points = Array.new(num_points) do
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])])
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings)
+        when ShpType::POLYGON
+          #TODO : TO CORRECT
+          #does not take into account the possibility that the outer loop could be after the inner loops in the SHP + more than one outer loop
+          #Still sends back a multi polygon (so the correction above won't change what gets sent back)
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          points = Array.new(num_points) do
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])])
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)])
+        when ShpType::MULTIPOINT
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          points = Array.new(num_points) do
+            x, y = @shp.read(16).unpack("E2")
+            GeoRuby::SimpleFeatures::Point.from_x_y(x,y)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points)
+
+
+        when ShpType::POINTZ
+          x, y, z, m = @shp.read(24).unpack("E4")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y_z_m(x,y,z,m)
+
+
+        when ShpType::POLYLINEZ
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            GeoRuby::SimpleFeatures::Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])],GeoRuby::SimpleFeatures::default_srid,true,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings,GeoRuby::SimpleFeatures::default_srid,true,true)
+
+
+        when ShpType::POLYGONZ
+          #TODO : CORRECT
+
+          @shp.seek(32,IO::SEEK_CUR)#extent
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)#extent
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)#extent
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])],GeoRuby::SimpleFeatures::default_srid,true,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)],GeoRuby::SimpleFeatures::default_srid,true,true)
+
+
+        when ShpType::MULTIPOINTZ
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          zs = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_z_m(xys[i][0],xys[i][1],zs[i],ms[i])
+          end
+
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points,GeoRuby::SimpleFeatures::default_srid,true,true)
+
+        when ShpType::POINTM
+          x, y, m = @shp.read(24).unpack("E3")
+          geometry = GeoRuby::SimpleFeatures::Point.from_x_y_m(x,y,m)
+
+        when ShpType::POLYLINEM
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+          line_strings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LineString.from_points(points[(parts[i])...(parts[i+1])],GeoRuby::SimpleFeatures::default_srid,false,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiLineString.from_line_strings(line_strings,GeoRuby::SimpleFeatures::default_srid,false,true)
+
+
+        when ShpType::POLYGONM
+          #TODO : CORRECT
+
+          @shp.seek(32,IO::SEEK_CUR)
+          num_parts, num_points = @shp.read(8).unpack("V2")
+          parts =  @shp.read(num_parts * 4).unpack("V" + num_parts.to_s)
+          parts << num_points #indexes for LS of idx i go to parts of idx i to idx i +1
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+          linear_rings = Array.new(num_parts) do |i|
+            GeoRuby::SimpleFeatures::LinearRing.from_points(points[(parts[i])...(parts[i+1])],GeoRuby::SimpleFeatures::default_srid,false,true)
+          end
+          geometry = GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_linear_rings(linear_rings)],GeoRuby::SimpleFeatures::default_srid,false,true)
+
+
+        when ShpType::MULTIPOINTM
+          @shp.seek(32,IO::SEEK_CUR)
+          num_points = @shp.read(4).unpack("V")[0]
+          xys = Array.new(num_points) { @shp.read(16).unpack("E2") }
+          @shp.seek(16,IO::SEEK_CUR)
+          ms = Array.new(num_points) {@shp.read(8).unpack("E")[0]}
+
+          points = Array.new(num_points) do |i|
+            Point.from_x_y_m(xys[i][0],xys[i][1],ms[i])
+          end
+
+          geometry = GeoRuby::SimpleFeatures::MultiPoint.from_points(points,GeoRuby::SimpleFeatures::default_srid,false,true)
+        else
+          geometry = nil
+        end
+
+        ShpRecord.new(geometry,dbf_record)
+      end
+    end
+
+    #A SHP record : contains both the geometry and the data fields (from the DBF)
+    class ShpRecord
+      attr_reader :geometry , :data
+
+      def initialize(geometry, data)
+        @geometry = geometry
+        @data = data
+      end
+
+      #Tests if the geometry is a NULL SHAPE
+      def has_null_shape?
+        @geometry.nil?
+      end
+    end
+
+    #An object returned from ShpFile#transaction. Buffers updates to a Shapefile
+    class ShpTransaction
+      attr_reader :rollbacked
+
+      def initialize(shp, dbf)
+        @deleted = Hash.new
+        @added = Array.new
+        @shp = shp
+        @dbf = dbf
+      end
+
+      #delete a record. Does not take into account the records added in the current transaction
+      def delete(i)
+        raise UnexistantRecordException.new("Invalid index : #{i}") if @shp.record_count <= i
+        @deleted[i] = true
+      end
+
+      #Update a record. In effect just a delete followed by an add.
+      def update(i, record)
+        delete(i)
+        add(record)
+      end
+
+      #add a ShpRecord at the end
+      def add(record)
+        record_type = to_shp_type(record.geometry)
+        raise IncompatibleGeometryException.new("Incompatible type") unless record_type==@shp.shp_type
+        @added << record
+      end
+
+      #updates the physical files
+      def commit
+        @shp.close
+        @shp_r = open(@shp.file_root + ".shp", "rb")
+        @dbf_r = open(@shp.file_root + ".dbf", "rb")
+        @shp_io = open(@shp.file_root + ".shp.tmp.shp", "wb")
+        @shx_io = open(@shp.file_root + ".shx.tmp.shx", "wb")
+        @dbf_io = open(@shp.file_root + ".dbf.tmp.dbf", "wb")
+        index = commit_delete
+        min_x,max_x,min_y,max_y,min_z,max_z,min_m,max_m = commit_add(index)
+        commit_finalize(min_x,max_x,min_y,max_y,min_z,max_z,min_m,max_m)
+        @shp_r.close
+        @dbf_r.close
+        @dbf_io.close
+        @shp_io.close
+        @shx_io.close
+        FileUtils.move(@shp.file_root + ".shp.tmp.shp", @shp.file_root + ".shp")
+        FileUtils.move(@shp.file_root + ".shx.tmp.shx", @shp.file_root + ".shx")
+        FileUtils.move(@shp.file_root + ".dbf.tmp.dbf", @shp.file_root + ".dbf")
+
+        @deleted = Hash.new
+        @added = Array.new
+
+        @shp.reload!
+       end
+
+      #prevents the udpate from taking place
+      def rollback
+        @deleted = Hash.new
+        @added = Array.new
+        @rollbacked = true
+      end
+
+      private
+
+      def to_shp_type(geom)
+        root = if geom.is_a? GeoRuby::SimpleFeatures::Point
+                 "POINT"
+               elsif geom.is_a? GeoRuby::SimpleFeatures::LineString
+                 "POLYLINE"
+               elsif geom.is_a?  GeoRuby::SimpleFeatures::Polygon
+                 "POLYGON"
+               elsif geom.is_a?  GeoRuby::SimpleFeatures::MultiPoint
+                 "MULTIPOINT"
+               elsif geom.is_a?  GeoRuby::SimpleFeatures::MultiLineString
+                 "POLYLINE"
+               elsif geom.is_a?  GeoRuby::SimpleFeatures::MultiPolygon
+                 "POLYGON"
+               else
+                 false
+               end
+        return false if !root
+
+        if geom.with_z
+          root = root + "Z"
+        elsif geom.with_m
+          root = root + "M"
+        end
+        eval "ShpType::" + root
+      end
+
+      def commit_add(index)
+        max_x, min_x, max_y, min_y,max_z,min_z,max_m,min_m = @shp.xmax,@shp.xmin,@shp.ymax,@shp.ymin,@shp.zmax,@shp.zmin,@shp.mmax,@shp.mmin
+        @added.each do |record|
+          @dbf_io << ['20'].pack('H2')
+          @dbf.fields.each do |field|
+            data = record.data[field.name]
+            str = if field.type == 'D'
+                    sprintf("%04i%02i%02i",data.year,data.month,data.mday)
+                  elsif field.type == 'L'
+                    data ? "T" :  "F"
+                  else
+                    data.to_s
+                  end
+            @dbf_io << [str].pack("A#{field.length}")
+          end
+
+          shp_str,min_xp,max_xp,min_yp,max_yp,min_zp,max_zp,min_mp,max_mp = build_shp_geometry(record.geometry)
+          max_x = max_xp if max_xp > max_x
+          min_x = min_xp if min_xp < min_x
+          max_y = max_yp if max_yp > max_y
+          min_y = min_yp if min_yp < min_y
+          max_z = max_zp if max_zp > max_z
+          min_z = min_zp if min_zp < min_z
+          max_m = max_mp if max_mp > max_m
+          min_m = min_mp if min_mp < min_m
+          length = (shp_str.length/2 + 2).to_i #num of 16-bit words; geom type is included (+2)
+          @shx_io << [(@shp_io.pos/2).to_i,length].pack("N2")
+          @shp_io << [index,length,@shp.shp_type].pack("N2V")
+          @shp_io << shp_str
+          index += 1
+        end
+        @shp_io.flush
+        @shx_io.flush
+        @dbf_io.flush
+        [min_x,max_x,min_y,max_y,min_z,max_z,min_m,max_m]
+      end
+
+      def commit_delete
+        @shp_r.rewind
+        header = @shp_r.read(100)
+        @shp_io << header
+        @shx_io << header
+        index = 1
+        while(!@shp_r.eof?)
+          icur,length = @shp_r.read(8).unpack("N2")
+          unless(@deleted[icur-1])
+            @shx_io << [(@shp_io.pos/2).to_i,length].pack("N2")
+            @shp_io << [index,length].pack("N2")
+            @shp_io << @shp_r.read(length * 2)
+            index += 1
+          else
+            @shp_r.seek(length * 2,IO::SEEK_CUR)
+          end
+        end
+        @shp_io.flush
+        @shx_io.flush
+
+        @dbf_r.rewind
+        @dbf_io << @dbf_r.read(@dbf.header_length)
+        icur = 0
+        while(!@dbf_r.eof?)
+          unless(@deleted[icur])
+            @dbf_io << @dbf_r.read(@dbf.record_length)
+          else
+            @dbf_r.seek(@dbf.record_length,IO::SEEK_CUR)
+          end
+          icur += 1
+        end
+        @dbf_io.flush
+        index
+      end
+
+      def commit_finalize(min_x,max_x,min_y,max_y,min_z,max_z,min_m,max_m)
+        #update size in shp and dbf + extent and num records in dbf
+        @shp_io.seek(0,IO::SEEK_END)
+        shp_size = @shp_io.pos / 2
+        @shx_io.seek(0,IO::SEEK_END)
+        shx_size= @shx_io.pos / 2
+        @shp_io.seek(24)
+        @shp_io.write([shp_size].pack("N"))
+        @shx_io.seek(24)
+        @shx_io.write([shx_size].pack("N"))
+        @shp_io.seek(36)
+        @shx_io.seek(36)
+        str = [min_x,min_y,max_x,max_y,min_z,max_z,min_m,max_m].pack("E8")
+        @shp_io.write(str)
+        @shx_io.write(str)
+
+        @dbf_io.seek(4)
+        @dbf_io.write([@dbf.record_count + @added.length - @deleted.length].pack("V"))
+      end
+
+      def build_shp_geometry(geometry)
+        m_range = nil
+        answer =
+        case @shp.shp_type
+        when ShpType::POINT
+          bbox = geometry.bounding_box
+          [geometry.x,geometry.y].pack("E2")
+        when ShpType::POLYLINE
+          str,bbox = create_bbox(geometry)
+          build_polyline(geometry,str)
+        when ShpType::POLYGON
+          str,bbox = create_bbox(geometry)
+          build_polygon(geometry,str)
+        when ShpType::MULTIPOINT
+          str,bbox = create_bbox(geometry)
+          build_multi_point(geometry,str)
+        when ShpType::POINTZ
+          bbox = geometry.bounding_box
+          [geometry.x,geometry.y,geometry.z,geometry.m].pack("E4")
+        when ShpType::POLYLINEZ
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_polyline(geometry,str)
+          build_polyline_zm(geometry,:@z,[bbox[0].z,bbox[1].z],str)
+          build_polyline_zm(geometry,:@m,m_range,str)
+        when ShpType::POLYGONZ
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_polygon(geometry,str)
+          build_polygon_zm(geometry,:@z,[bbox[0].z,bbox[1].z],str)
+          build_polygon_zm(geometry,:@m,m_range,str)
+        when ShpType::MULTIPOINTZ
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_multi_point(geometry,str)
+          build_multi_point_zm(geometry,:@z,[bbox[0].z,bbox[1].z],str)
+          build_multi_point_zm(geometry,:@m,m_range,str)
+        when ShpType::POINTM
+          bbox = geometry.bounding_box
+          [geometry.x,geometry.y,geometry.m].pack("E3")
+        when ShpType::POLYLINEM
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_polyline(geometry,str)
+          build_polyline_zm(geometry,:@m,m_range,str)
+        when ShpType::POLYGONM
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_polygon(geometry,str)
+          build_polygon_zm(geometry,:@m,m_range,str)
+        when ShpType::MULTIPOINTM
+          str,bbox = create_bbox(geometry)
+          m_range = geometry.m_range
+          build_multi_point(geometry,str)
+          build_multi_point_zm(geometry,:@m,m_range,str)
+        end
+        m_range ||= [0,0]
+        [answer,bbox[0].x,bbox[1].x,bbox[0].y,bbox[1].y,bbox[0].z || 0, bbox[1].z || 0, m_range[0], m_range[1]]
+      end
+
+      def create_bbox(geometry)
+        bbox = geometry.bounding_box
+        [[bbox[0].x,bbox[0].y,bbox[1].x,bbox[1].y].pack("E4"),bbox]
+      end
+
+      def build_polyline(geometry,str)
+        if geometry.is_a? GeoRuby::SimpleFeatures::LineString
+          str << [1,geometry.length,0].pack("V3")
+          geometry.each do |point|
+              str << [point.x,point.y].pack("E2")
+          end
+        else
+          #multilinestring
+          str << [geometry.length,geometry.inject(0) {|l, ls| l + ls.length}].pack("V2")
+          str << geometry.inject([0]) {|a,ls| a << (a.last + ls.length)}.pack("V#{geometry.length}") #last element of the previous array is dropped
+          geometry.each do |ls|
+            ls.each do |point|
+              str << [point.x,point.y].pack("E2")
+            end
+          end
+        end
+        str
+      end
+
+      def build_polyline_zm(geometry,zm,range,str)
+        str << range.pack("E2")
+        if geometry.is_a? GeoRuby::SimpleFeatures::LineString
+          geometry.each do |point|
+            str << [point.instance_variable_get(zm)].pack("E")
+          end
+        else
+          #multilinestring
+          geometry.each do |ls|
+            ls.each do |point|
+              str << [point.instance_variable_get(zm)].pack("E")
+            end
+          end
+        end
+        str
+      end
+
+      def build_polygon(geometry,str)
+        if geometry.is_a? GeoRuby::SimpleFeatures::Polygon
+          str << [geometry.length,geometry.inject(0) {|l, lr| l + lr.length}].pack("V2")
+          str << geometry.inject([0]) {|a,lr| a << (a.last + lr.length)}.pack("V#{geometry.length}") #last element of the previous array is dropped
+          geometry.each do |lr|
+            lr.each do |point|
+              str << [point.x,point.y].pack("E2")
+            end
+          end
+        else
+          #multipolygon
+          num_rings = geometry.inject(0) {|l, poly| l + poly.length}
+          str << [num_rings, geometry.inject(0) {|l, poly| l + poly.inject(0) {|l2,lr| l2 + lr.length} }].pack("V2")
+          str << geometry.inject([0]) {|a,poly| poly.inject(a) {|a2, lr| a2 << (a2.last + lr.length)}}.pack("V#{num_rings}") #last element of the previous array is dropped
+          geometry.each do |poly|
+            poly.each do |lr|
+              lr.each do |point|
+                str << [point.x,point.y].pack("E2")
+              end
+            end
+          end
+        end
+        str
+      end
+
+      def build_polygon_zm(geometry,zm,range,str)
+        str << range.pack("E2")
+        if geometry.is_a? GeoRuby::SimpleFeatures::Polygon
+          geometry.each do |lr|
+            lr.each do |point|
+              str << [point.instance_variable_get(zm)].pack("E")
+            end
+          end
+        else
+          geometry.each do |poly|
+            poly.each do |lr|
+              lr.each do |point|
+                str << [point.instance_variable_get(zm)].pack("E")
+              end
+            end
+          end
+        end
+        str
+      end
+
+      def build_multi_point(geometry,str)
+        str << [geometry.length].pack("V")
+        geometry.each do |point|
+          str << [point.x,point.y].pack("E2")
+        end
+        str
+      end
+
+      def build_multi_point_zm(geometry,zm,range,str)
+        str << range.pack("E2")
+        geometry.each do |point|
+          str << [point.instance_variable_get(zm)].pack("E")
+        end
+        str
+      end
+    end
+
+    class MalformedShpException < StandardError
+    end
+
+    class UnexistantRecordException < StandardError
+    end
+
+    class IncompatibleGeometryException < StandardError
+    end
+
+    class IncompatibleDataException < StandardError
+    end
+  end
+end