GeoRuby 1.2.4 → 1.3.0

data/README

@@ -1,6 +1,6 @@
 =GeoRuby
 
-This is GeoRuby 1.2.3 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). 
+This is GeoRuby 1.3.0 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 :
@@ -24,22 +24,54 @@ GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be input and output. Note that
 
 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
-Support for reading ESRI shapefiles (http://www.esri.com/library/whitepapers/pdfs/shapefile.pdf) has been added. 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.
+===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 :
+	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.
 
 ===Installation
 To install the latest version, just type :
       gem install 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
-- Writing of SHP files
+- 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
-- Geometric operators
 
 ===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. 

data/lib/geo_ruby/shp4r/dbf.rb

@@ -6,8 +6,6 @@ module GeoRuby
     module Dbf
       
       DBF_HEADER_SIZE = 32
-      FPT_HEADER_SIZE = 512
-      FPT_BLOCK_HEADER_SIZE = 8
       DATE_REGEXP = /([\d]{4})([\d]{2})([\d]{2})/
       VERSION_DESCRIPTIONS = {
         "02" => "FoxBase",
@@ -33,10 +31,11 @@ module GeoRuby
         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')
-          @memo_file = open_memo(file)
           reload!
         end
 
@@ -56,52 +55,13 @@ module GeoRuby
         
         def reload!
           get_header_info
-          get_memo_header_info if @memo_file
           get_field_descriptors
         end
         
-        def has_memo_file?
-          @memo_file ? true : false
-        end
-        
-        def open_memo(file)
-          %w(fpt FPT dbt DBT).each do |extension|
-            filename = file.sub(/dbf$/i, extension)
-            if File.exists?(filename)
-              @memo_file_format = extension.downcase.to_sym
-              return File.open(filename, 'rb')
-            end
-          end
-          nil
-        end
-        
         def field(field_name)
           @fields.detect {|f| f.name == field_name.to_s}
         end
-        
-        def memo(start_block)
-          @memo_file.rewind
-          @memo_file.seek(start_block * @memo_block_size)
-          if @memo_file_format == :fpt
-            memo_type, memo_size, memo_string = @memo_file.read(@memo_block_size).unpack("NNa56")
-            if memo_size > @memo_block_size - FPT_BLOCK_HEADER_SIZE
-              memo_string << @memo_file.read(memo_size - @memo_block_size + FPT_BLOCK_HEADER_SIZE)
-            end
-          else
-            if version == "83" # dbase iii
-              memo_string = ""
-              loop do
-                memo_string << block = @memo_file.read(512)
-                break if block.strip.size < 512
-              end
-            elsif version == "8b" # dbase iv
-              memo_type, memo_size = @memo_file.read(8).unpack("LL")
-              memo_string = @memo_file.read(memo_size)
-            end
-          end
-          memo_string
-        end
-        
+         
         # An array of all the records contained in the database file
         def records
           seek_to_record(0)
@@ -114,7 +74,6 @@ module GeoRuby
             end
           end
         end
-        
         alias_method :rows, :records
         
         # Jump to record
@@ -152,9 +111,6 @@ module GeoRuby
                   record[field.name] = Date.new(*raw.match(DATE_REGEXP).to_a.slice(1,3).map {|n| n.to_i}) rescue nil
                 end
               end
-            when 'M'
-              starting_block = unpack_integer(field)
-              record[field.name] = starting_block == 0 ? nil : memo(starting_block) rescue nil
             when 'L'
               record[field.name] = unpack_string(field) =~ /^(y|t)$/i ? true : false rescue false
             when 'C'
@@ -175,17 +131,7 @@ module GeoRuby
         def get_field_descriptors
           @fields = Array.new(@field_count) {|i| Field.new(*@data_file.read(32).unpack('a10xax4CC'))}
         end
-        
-        def get_memo_header_info
-          @memo_file.rewind
-          if @memo_file_format == :fpt
-            @memo_next_available_block, @memo_block_size = @memo_file.read(FPT_HEADER_SIZE).unpack('Nxxn')
-          else
-            @memo_block_size = 512
-            @memo_next_available_block = File.size(@memo_file.path) / @memo_block_size
-          end
-        end
-        
+         
         def seek(offset)
           @data_file.seek(@header_length + offset)
         end
@@ -217,7 +163,7 @@ module GeoRuby
       class Field
         attr_reader :name, :type, :length, :decimal
 
-        def initialize(name, type, length, decimal)
+        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'

data/lib/geo_ruby/shp4r/shp.rb

@@ -1,50 +1,57 @@
+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 GeoRuby.
     module ShpType
       NULL_SHAPE = 0
-      POINT = 1
-      POLYLINE = 3
-      POLYGON = 5
+      POINT = 1 
+      POLYLINE = 3 
+      POLYGON = 5 
       MULTIPOINT = 8
-      POINTZ = 11
+      POINTZ = 11 
       POLYLINEZ = 13
-      POLYGONZ = 15
+      POLYGONZ = 15 
       MULTIPOINTZ = 18
-      POINTM = 21
+      POINTM = 21 
       POLYLINEM = 23
-      POLYGONM = 25
-      MULTIPOINTM = 28
-      MULTIPATCH = 31 #not supported here
+      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
+      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, access = "r")
+      def initialize(file)
         #strip the shp out of the file if present
-        file = file.gsub(/.shp$/i,"")
+        @file_root = file.gsub(/.shp$/i,"")
         #check existence of shp, dbf and shx files       
-        unless File.exists?(file + ".shp") and File.exists?(file + ".dbf") and File.exists?(file + ".shx")
-          raise MalformedShpException.new("Missing one of shp, dbf or shx for: #{file}")
+        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 + ".dbf")
-        @shx = File.open(file + ".shx","rb")
-        @shp = File.open(file + ".shp","rb")
+        @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,access = "r")
-        shpfile = ShpFile.new(file,access)
+      def self.open(file)
+        shpfile = ShpFile.new(file)
         if block_given?
           yield shpfile
           shpfile.close
@@ -52,6 +59,30 @@ module GeoRuby
           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
@@ -59,6 +90,21 @@ module GeoRuby
         @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
@@ -92,8 +138,12 @@ module GeoRuby
 
       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
+        @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
@@ -112,27 +162,19 @@ module GeoRuby
         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
@@ -149,8 +191,6 @@ module GeoRuby
             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]
@@ -289,15 +329,373 @@ module GeoRuby
         @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'
+                    if data
+                      "T" 
+                    else
+                      "F"
+                    end
+                  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

data/lib/geo_ruby/simple_features/geometry.rb

@@ -32,6 +32,10 @@ module GeoRuby#:nodoc:
       #to be implemented in subclasses
       def bounding_box
       end
+
+      #to be implemented in subclasses
+      def m_range
+      end
       
       #Returns an Envelope object for the geometry
       def envelope

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -49,6 +49,20 @@ module GeoRuby
         end
       end
 
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |lr|
+            lrmr = lr.m_range
+            max_m = lrmr[1] if lrmr[1] > max_m
+            min_m = lrmr[0] if lrmr[0] < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
+
       #tests the equality of geometry collections
       def ==(other_collection)
         if(other_collection.class != self.class)

data/lib/geo_ruby/simple_features/line_string.rb

@@ -47,6 +47,19 @@ module GeoRuby
           [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
         end
       end
+
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |point|
+            max_m = point.m if point.m > max_m
+            min_m = point.m if point.m < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
       
       #Tests the equality of line strings
       def ==(other_line_string)

data/lib/geo_ruby/simple_features/point.rb

@@ -114,6 +114,10 @@ module GeoRuby
           [Point.from_x_y_z(@x,@y,@z),Point.from_x_y_z(@x,@y,@z)]
         end
       end
+
+      def m_range
+        [@m,@m]
+      end
       
       #tests the equality of the position of points + m
       def ==(other_point)

data/lib/geo_ruby/simple_features/polygon.rb

@@ -36,6 +36,20 @@ module GeoRuby
         end
       end
       
+      def m_range
+        if with_m
+          max_m, min_m = -Float::MAX, Float::MAX
+          each do |lr|
+            lrmr = lr.m_range
+            max_m = lrmr[1] if lrmr[1] > max_m
+            min_m = lrmr[0] if lrmr[0] < min_m
+          end
+          [min_m,max_m]
+        else
+          [0,0]
+        end
+      end
+
       #tests for other equality. The SRID is not taken into account.
       def ==(other_polygon)
         if other_polygon.class != self.class or

data/rakefile.rb

@@ -24,7 +24,7 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'GeoRuby'
-  s.version = "1.2.4"
+  s.version = "1.3.0"
   s.summary = "Ruby data holder for OGC Simple Features"
   s.description = <<EOF
 GeoRuby is intended as a holder for data returned from PostGIS and MySQL Spatial queries. The data model roughly follows the OGC "Simple Features for SQL" specification (see www.opengis.org/docs/99-049.pdf), although without any kind of advanced functionalities (such as geometric operators or reprojections)

data/test/test_shp_write.rb

@@ -0,0 +1,150 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'geo_ruby'
+require 'test/unit'
+
+include GeoRuby::SimpleFeatures
+include GeoRuby::Shp4r
+
+class TestShp < Test::Unit::TestCase
+  
+  def cp_all_shp(file1,file2)
+    FileUtils.copy(file1 + ".shp",file2 + ".shp")
+    FileUtils.copy(file1 + ".shx",file2 + ".shx")
+    FileUtils.copy(file1 + ".dbf",file2 + ".dbf")
+  end
+
+  def rm_all_shp(file)
+    FileUtils.rm(file + ".shp")
+    FileUtils.rm(file + ".shx")
+    FileUtils.rm(file + ".dbf")
+  end
+  
+  def test_point
+    cp_all_shp(File.dirname(__FILE__) + '/data/point',
+               File.dirname(__FILE__) + '/data/point2')
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/point2.shp')
+    
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.add(ShpRecord.new(Point.from_x_y(123.4,123.4),'Hoyoyo' => 5))
+      tr.add(ShpRecord.new(Point.from_x_y(-16.67,16.41),'Hoyoyo' => -7))
+      tr.delete(1)
+    end
+    
+    assert_equal(3,shpfile.record_count)
+    
+    shpfile.close
+    rm_all_shp(File.dirname(__FILE__) + '/data/point2')
+  end
+
+  def test_linestring
+    cp_all_shp(File.dirname(__FILE__) + '/data/polyline',
+               File.dirname(__FILE__) + '/data/polyline2')
+    
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/polyline2.shp')
+    
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.add(ShpRecord.new(LineString.from_coordinates([[123.4,123.4],[45.6,12.3]]),'Chipoto' => 5.6778))
+      tr.add(ShpRecord.new(LineString.from_coordinates([[23.4,13.4],[45.6,12.3],[12,-67]]),'Chipoto' => -7.1))
+      tr.delete(0)
+    end
+    
+    assert_equal(2,shpfile.record_count)
+    shpfile.close
+    #rm_all_shp(File.dirname(__FILE__) + '/data/polyline2')
+  end
+
+  def test_polygon
+    cp_all_shp(File.dirname(__FILE__) + '/data/polygon',
+               File.dirname(__FILE__) + '/data/polygon2')
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/polygon2.shp')
+
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.delete(0)
+      tr.add(ShpRecord.new(Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]]),'Hello' => "oook"))
+    end
+        
+    assert_equal(1,shpfile.record_count)
+    
+    shpfile.close
+    rm_all_shp(File.dirname(__FILE__) + '/data/polygon2')
+  end
+
+  def test_multipoint
+    cp_all_shp(File.dirname(__FILE__) + '/data/multipoint',
+               File.dirname(__FILE__) + '/data/multipoint2')
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/multipoint2.shp')
+
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.add(ShpRecord.new(MultiPoint.from_coordinates([[45.6,-45.1],[12.4,98.2],[51.2,-0.12],[156.12345,56.109]]),'Hello' => 5,"Hoyoyo" => "AEZAE"))
+    end
+        
+    assert_equal(2,shpfile.record_count)
+    
+    shpfile.close
+    rm_all_shp(File.dirname(__FILE__) + '/data/multipoint2')
+  end
+
+  def test_multi_polygon
+    cp_all_shp(File.dirname(__FILE__) + '/data/polygon',
+               File.dirname(__FILE__) + '/data/polygon4')
+
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/polygon4.shp')
+
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.add(ShpRecord.new(MultiPolygon.from_polygons([Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]])]),'Hello' => "oook"))
+    end
+        
+    assert_equal(2,shpfile.record_count)
+    
+    shpfile.close
+    
+    rm_all_shp(File.dirname(__FILE__) + '/data/polygon4')
+  end
+  
+  def test_rollback
+    cp_all_shp(File.dirname(__FILE__) + '/data/polygon',
+               File.dirname(__FILE__) + '/data/polygon5')
+
+    shpfile = ShpFile.open(File.dirname(__FILE__) + '/data/polygon5.shp')
+
+    shpfile.transaction do |tr|
+      assert(tr.instance_of?(ShpTransaction))
+      tr.add(ShpRecord.new(MultiPolygon.from_polygons([Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]])]),'Hello' => "oook"))
+      tr.rollback
+    end
+    assert_equal(1,shpfile.record_count)
+    
+    shpfile.close
+    
+    rm_all_shp(File.dirname(__FILE__) + '/data/polygon5')
+
+  end
+
+  def test_creation
+    shpfile = ShpFile.create(File.dirname(__FILE__) + '/data/point3.shp',ShpType::POINT,[Dbf::Field.new("Hoyoyo","C",10,0)])
+    shpfile.transaction do |tr|
+      tr.add(ShpRecord.new(Point.from_x_y(123,123.4),'Hoyoyo' => "HJHJJ"))
+    end
+    assert(1,shpfile.record_count)
+    shpfile.close
+    rm_all_shp(File.dirname(__FILE__) + '/data/point3')
+  end
+
+  def test_creation_multipoint
+    shpfile = ShpFile.create(File.dirname(__FILE__) + '/data/multipoint3.shp',ShpType::MULTIPOINT,[Dbf::Field.new("Hoyoyo","C",10),Dbf::Field.new("Hello","N",10)])
+    shpfile.transaction do |tr|
+      tr.add(ShpRecord.new(MultiPoint.from_coordinates([[123,123.4],[345,12.2]]),'Hoyoyo' => "HJHJJ","Hello" => 5))
+    end
+    assert(1,shpfile.record_count)
+    shpfile.close
+    rm_all_shp(File.dirname(__FILE__) + '/data/multipoint3')
+  end
+  
+
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: GeoRuby
 version: !ruby/object:Gem::Version 
-  version: 1.2.4
-date: 2007-07-20 00:00:00 +02:00
+  version: 1.3.0
+date: 2007-08-26 00:00:00 +02:00
 summary: Ruby data holder for OGC Simple Features
 require_paths: 
 - lib
@@ -51,19 +51,26 @@ files:
 - test/test_ewkt_parser.rb
 - test/test_georss_kml.rb
 - test/test_shp.rb
+- test/test_shp_write.rb
 - test/test_simple_features.rb
 - README
 - MIT-LICENSE
 - rakefile.rb
+- test/data/multipoint.shp
 - test/data/point.shp
 - test/data/polygon.shp
 - test/data/polyline.shp
+- test/data/polyline2.shp
+- test/data/multipoint.dbf
 - test/data/point.dbf
 - test/data/polygon.dbf
 - test/data/polyline.dbf
+- test/data/polyline2.dbf
+- test/data/multipoint.shx
 - test/data/point.shx
 - test/data/polygon.shx
 - test/data/polyline.shx
+- test/data/polyline2.shx
 - tools/db.yml
 - tools/lib/spatial_adapter/test/db/database_mysql.yml
 - tools/lib/spatial_adapter/test/db/database_postgis.yml
@@ -99,6 +106,7 @@ test_files:
 - test/test_ewkt_parser.rb
 - test/test_georss_kml.rb
 - test/test_shp.rb
+- test/test_shp_write.rb
 - test/test_simple_features.rb
 rdoc_options: 
 - --main