GeoRuby 0.1.1 → 0.2.1

data/README

@@ -1,5 +1,5 @@
 =GeoRuby
-This is GeoRuby 0.1.1. 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 0.2.1. 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). 
 
 ===Available data types
 The following geometric data types are provided :
@@ -15,18 +15,16 @@ The following geometric data types are provided :
 They can be in 2D, 3DZ, 3DM, and 4D.
 
 ===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 EWKB are the default form under which geometric data is returned respectively from PostGIS and MySql.
+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.
 
 ===Installation
 To install the latest version, just type :
       gem install GeoRuby
 
 ===Changes since the last version
-- Addition of support for M and Z dimension in the data types, as well as in the EWKB and EWKT parsers.
-- When creating a geometry, the presence of a Z or M dimension must be indicated. By default, the geometry is created in 2D and with a SRID of -1.
-- Suppression of +as_binary+, +as_hex_binary+ and +as_text+. They have been replaced with +as_ewkb+, +as_wkb+, +as_hex_ewkb+, +as_hex_wkb+, +as_ewkt+ and +as_wkt+.
-- Suppression of the static creation methods +from_raw_point_sequence+ (for some geometric types) and +from_raw_point_sequences+ (for other), to build a geometry from a list of point coordinates. They have been replaced by a +from_coordinates+ for all types.
-- The static geometry construction method +from_hexewkb+ has been replaced with +from_hex_ewkb+.
+- Correction of the output of the MultiPoint EWKT string to follow the specification, instead of what is shown in the examples (of the specification) and output by PostGIS. For example, the string previously output as MULTIPOINT(123.4 123.5,456.7 678.887) will now be output as MULTIPOINT((123.4 123.5),(456.7 678.887))
+- Modification of the EWKT input to support the correct MultiPoint EWKT format, on top of the previous one. So both MULTIPOINT(123.4 123.5,456.7 678.887) and MULTIPOINT((123.4 123.5),(456.7 678.887)) would be accepted as valid MultiPoint strings.
+- Addition of a +bounding_box+ method on geometries. Return an array of 2 points representing the 2 corners of the box.
 
 ===License
 GeoRuby is released under the MIT license.

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -10,6 +10,7 @@ require 'geo_ruby/simple_features/geometry_collection'
 module GeoRuby
   module SimpleFeatures
 
+    #Raised when an error in the EWKB string is detected
     class EWKBFormatError < StandardError
     end
 
@@ -20,6 +21,8 @@ module GeoRuby
     # ewkb_parser = EWKBParser::new(factory)
     # ewkb_parser.parse(<EWKB String>)
     # geometry = @factory.geometry
+    #
+    #You can also use directly the static method Geometry.from_ewkb
     class EWKBParser
   
       def initialize(factory)

data/lib/geo_ruby/simple_features/ewkt_parser.rb

@@ -12,6 +12,7 @@ require 'strscan'
 module GeoRuby
   module SimpleFeatures
 
+    #Raised when an error in the EWKT string is detected
     class EWKTFormatError < StandardError
     end
 
@@ -22,6 +23,8 @@ module GeoRuby
     # ewkt_parser = EWKTParser::new(factory)
     # ewkt_parser.parse(<EWKT String>)
     # geometry = @factory.geometry
+    #
+    #You can also use directly the static method Geometry.from_ewkt
     class EWKTParser
   
       def initialize(factory)
@@ -40,125 +43,294 @@ module GeoRuby
       #Parses the ewkt string passed as argument and notifies the factory of events
       def parse(ewkt)
         @factory.reset
+        @tokenizer_structure = TokenizerStructure.new(ewkt)
         @with_z=false
         @with_m=false
-        parse_geometry(ewkt)
+        @is_3dm = false
+        parse_geometry(true)
         @srid=nil
       end
       
       private
-      def parse_geometry(ewkt)
-        scanner = StringScanner.new(ewkt)
-        if scanner.scan(/SRID=(-?\d+);/) 
-          if @srid.nil?
-            @srid = scanner[1].to_i
+      def parse_geometry(srid_allowed)
+        
+        token = @tokenizer_structure.get_next_token
+        if token == 'SRID'
+          #SRID present
+          raise  EWKTFormatError.new("SRID not allowed at this position") if(!srid_allowed)
+          if @tokenizer_structure.get_next_token != '='
+            raise EWKTFormatError.new("Invalid SRID expression")
           else
-            #not the root geometry and repeat of the SRID : shouldn't happen
-            raise EWKTFormatError.new("SRID in internal geometry")
+            @srid = @tokenizer_structure.get_next_token.to_i
+            raise EWKTFormatError.new("Invalid SRID separator") if @tokenizer_structure.get_next_token != ';'
+            geom_type = @tokenizer_structure.get_next_token
           end
+          
         else
           #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
           @srid= @srid || DEFAULT_SRID
+          geom_type = token
         end
         
-        if scanner.scan(/(\w+)/)
-          geom_type = scanner[1]
-          if geom_type[-1] == ?M
-            @with_m=true
-            geom_type.chop! #remove the M
-          end
-          #change the parsing method : this one really is ugly...
-          if @parse_options.has_key?(geom_type) and scanner.scan(/^\((.*)\)$/)
-            @parse_options[geom_type].call(scanner[1])
-          else
-            raise EWKTFormatError.new("Bad token")
-          end
+        if geom_type[-1] == ?M
+          @is_3dm=true
+          @with_m=true
+          geom_type.chop! #remove the M
         end
         
+        if @parse_options.has_key?(geom_type)
+          @parse_options[geom_type].call
+        else
+          raise EWKTFormatError.new("Urecognized geometry type: #{geom_type}")
+        end
       end
-      def parse_geometry_collection(string)
+      
+      def parse_geometry_collection
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid GeometryCollection')
+        end
+        
         @factory.begin_geometry(GeometryCollection,@srid)
-        scanner = StringScanner.new(string)
-        while(scanner.scan(/\s*(.*?),\s*(?=[A-Z])/))
-          parse_geometry(scanner[1])
+        
+        token = ''
+        while token != ')'
+          parse_geometry(false)
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
         end
-        parse_geometry(scanner.rest)
+        
         @factory.end_geometry(@with_z,@with_m)
       end
       
-      def parse_multi_polygon(string)
+      def parse_multi_polygon
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiLineString')
+        end
+        
         @factory.begin_geometry(MultiPolygon,@srid)
-        scanner = StringScanner.new(string)
-        while(scanner.scan(/\s*\(\s*(\((.*?)\))\s*\)\s*,?/)) #beeeh
-          parse_polygon(scanner[1])
+        token = ''
+        while token != ')'
+          parse_polygon
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
         end
+        
         @factory.end_geometry(@with_z,@with_m)
       end
                  
-      def parse_multi_line_string(string)
+      def parse_multi_line_string
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiLineString')
+        end
+        
         @factory.begin_geometry(MultiLineString,@srid)
-        scanner = StringScanner.new(string)
 
-        while(scanner.scan(/\s*\(([^\)]*)\)\s*,?/))
-          parse_line_string(scanner[1])
+        token = ''
+        while token != ')'
+          parse_line_string
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
         end
+        
         @factory.end_geometry(@with_z,@with_m)
       end
 
-      def parse_polygon(string)
+      def parse_polygon
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Polygon')
+        end
+        
         @factory.begin_geometry(Polygon,@srid)
-        scanner = StringScanner.new(string)
-        while(scanner.scan(/\s*\(([^\)]*)\)\s*,?/))
-          parse_linear_ring(scanner[1])
+        
+        token = ''
+        while token != ')'
+          parse_linear_ring
+          token = @tokenizer_structure.get_next_token
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
         end
+
         @factory.end_geometry(@with_z,@with_m)
       end
-            
-      def parse_multi_point(string)
-        parse_point_list(MultiPoint,string)
+           
+      #must support the PostGIS form and the one in the specification
+      def parse_multi_point
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid MultiPoint')
+        end
+        
+        token = @tokenizer_structure.check_next_token
+        if token == '('
+          #specification
+          @factory.begin_geometry(MultiPoint,@srid)
+                    
+          token = ''
+          while token != ')'
+            parse_point
+            token = @tokenizer_structure.get_next_token
+            if token.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+          end
+                    
+          @factory.end_geometry(@with_z,@with_m)
+        else
+          #postgis
+          parse_point_list(MultiPoint)
+        end
       end
-      def parse_linear_ring(string)
-        parse_point_list(LinearRing,string)
+      
+      def parse_linear_ring
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Linear ring')
+        end
+        
+        parse_point_list(LinearRing)
       end
-      def parse_line_string(string)
-        parse_point_list(LineString,string)
+      
+      def parse_line_string
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Line string')
+        end
+        
+        parse_point_list(LineString)
       end
-      #used to parse line_strings and linear_rings and multi_points
-      def parse_point_list(geometry_type,string)
+      
+      #used to parse line_strings and linear_rings and the PostGIS form of multi_points
+      def parse_point_list(geometry_type)
         @factory.begin_geometry(geometry_type,@srid)
-        scanner = StringScanner.new(string)
-        while(scanner.scan(/([^,]*),?/))
-          parse_point(scanner[1])
+               
+        token = ''
+        while token != ')'
+          @factory.begin_geometry(Point,@srid)
+          token = parse_coords
+          if token.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+          @factory.end_geometry(@with_z,@with_m)
         end
+        
         @factory.end_geometry(@with_z,@with_m)
       end
       
-      def parse_point(string)
+      def parse_point
+        if @tokenizer_structure.get_next_token !='('
+          raise EWKTFormatError.new('Invalid Point')
+        end
+        
         @factory.begin_geometry(Point,@srid)
-        scanner = StringScanner.new(string)
+                
+        token = parse_coords
+        
+        if token != ')'
+          raise EWKTFormatError.new("EWKT string not correctly terminated")
+        end
+
+        @factory.end_geometry(@with_z,@with_m)
+      end
+
+      def parse_coords
         coords = Array.new
-        while scanner.scan(/\s*([-+]?[\d.]+)\s*/)
-          coords << scanner[1].to_f
+        x = @tokenizer_structure.get_next_token
+        y = @tokenizer_structure.get_next_token
+
+        if x.nil? or y.nil?
+          raise EWKTFormatError.new("Bad Point format")
         end
         
-        if coords.length == 2
-          @factory.add_point_x_y(*coords)
-        elsif coords.length == 3
-          if @with_m
-            @factory.add_point_x_y_m(*coords)
+        if @is_3dm
+          m = @tokenizer_structure.get_next_token
+
+          if m.nil? or m == ',' or m == ')'
+            raise EWKTFormatError.new("No M dimension found")
           else
-            @with_z=true #we know if it is 3dz only when reading the first point
-            @factory.add_point_x_y_z(*coords)
+            @factory.add_point_x_y_m(x.to_f,y.to_f,m.to_f)
+            @tokenizer_structure.get_next_token
           end
         else
-          @with_m=true
-          @with_z=true
-          @factory.add_point_x_y_z_m(*coords)
+          z = @tokenizer_structure.get_next_token
+          
+          if z.nil?
+            raise EWKTFormatError.new("EWKT string not correctly terminated")
+          end
+          
+          if z == ',' or z == ')'
+            #2D : no z no m
+            @factory.add_point_x_y(x.to_f,y.to_f)
+            z
+          else
+            m = @tokenizer_structure.get_next_token
+            if m.nil?
+              raise EWKTFormatError.new("EWKT string not correctly terminated")
+            end
+            
+            if m == ',' or m ==')'
+              #3Dz : no m
+              @with_z = true
+              @factory.add_point_x_y_z(x.to_f,y.to_f,z.to_f)
+              m
+            else
+              #4D
+              @with_z = true
+              @with_m = true
+              @factory.add_point_x_y_z_m(x.to_f,y.to_f,z.to_f,m.to_f)
+              @tokenizer_structure.get_next_token
+            end
+          end
         end
-        
-        @factory.end_geometry(@with_z,@with_m)
       end
     end
     
+    class TokenizerStructure
+      
+      def initialize(ewkt)
+        @ewkt = ewkt
+        @scanner = StringScanner.new(ewkt)
+        @regex = /\s*([\w.-]+)s*/
+      end
+
+      def get_next_token
+        if @scanner.scan(@regex).nil?
+          if @scanner.eos?
+            nil
+          else
+            ch = @scanner.getch
+            while ch == ' '
+              ch = @scanner.getch
+            end
+            ch
+          end
+        else
+          @scanner[1]
+        end
+      end
+      
+      
+      def check_next_token
+        check = @scanner.check(@regex)
+        if check.nil?
+          if @scanner.eos?
+            nil
+          else
+            pos = @scanner.pos
+            while @ewkt[pos].chr == ' '
+              pos+=1
+            end
+            @ewkt[pos].chr
+          end
+        else
+          check
+        end
+      end
+
+    end
+
   end
 end

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -10,46 +10,27 @@ module GeoRuby
         super(srid,with_z,with_m)
         @geometries = []
       end
-      #add a geometry to the collection
-      def <<(geometry)
-        @geometries << geometry
-      end
-      #add geometries to the collection
-      def concat(geometries)
-        @geometries.concat geometries
-      end
-      #number of geometries in the collection
-      def length
-        @geometries.length
-      end
-      #gets the nth geometry
-      def [](n)
-        @geometries[n]
-      end
-      #replaces the nth geometry
-      def []=(n,geometry)
-        @geometries[n]=geometry
-      end
-      #iterates over all the geometries
-      def each(&proc)
-        @geometries.each(&proc)
-      end
-      #iterates over all the geometries, passing the index to the bloc
-      def each_index(&proc)
-        @geometries.each_index(&proc)
-      end
-      #inserts geometries at the nth position
-      def insert(n,*geometry)
-        @geometries.insert(n,*geometry)
-      end
-      #index of the geometry
-      def index(geometry)
-        @geometries.index(geometry)
+      
+      #Delegate the unknown methods to the geometries array
+      def method_missing(method_name,*args,&b)
+        @geometries.send(method_name,*args,&b)
       end
-      #remove a slice of the collection
-      def remove(*slice)
-        @geometries.slice(*slice)
+
+      #Bounding box in 2D. Returns an array of 2 points
+      def bounding_box
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
+        each do |geometry|
+          bbox = geometry.bounding_box
+          sw = bbox[0]
+          ne = bbox[1]
+          max_y = ne.y if ne.y > max_y
+          min_y = sw.y if sw.y < min_y
+          max_x = ne.x if ne.x > max_x
+          min_x = sw.x if sw.x < min_x 
+        end
+        [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
       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

@@ -11,50 +11,28 @@ module GeoRuby
         super(srid,with_z,with_m)
         @points=[]
       end
+      
+      #Delegate the unknown methods to the points array
+      def method_missing(method_name,*args,&b)
+        @points.send(method_name,*args,&b)
+      end
+      
       #tests if the line string is closed
       def is_closed
         #a bit naive...
         @points.first == @points.last
       end
-      #add a point to the end of the line string
-      def <<(point)
-        @points << point
-      end
-      #add points to the end of the line string
-      def concat(points)
-        @points.concat points
-      end
-      #number of points of the line string
-      def length
-        @points.length
-      end
-      #accesses the nth point in the line string
-      def [](n)
-        @points[n]
-      end
-      #replaces the nth point in the line string
-      def []=(n,point)
-        @points[n]=point
-      end
-      #iterates over the points in the line string
-      def each(&proc)
-        @points.each(&proc)
-      end
-      #iterates over the points, passing their indices to the bloc
-      def each_index(&proc)
-        @points.each_index(&proc)
-      end
-      #inserts points at the nth position
-      def insert(n,*point)
-        @points.insert(n,*point)
-      end
-      #gets the indices of point
-      def index(point)
-        @points.index(point)
-      end
-      #Removes a slice of points
-      def remove(*slice)
-        @points.slice(*slice)
+
+      #Bounding box in 2D. Returns an array of 2 points
+      def bounding_box
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
+        each do |point|
+          max_y = point.y if point.y > max_y
+          min_y = point.y if point.y < min_y
+          max_x = point.x if point.x > max_x
+          min_x = point.x if point.x < min_x 
+        end
+        [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
       end
       
       #Tests the equality of line strings

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -15,7 +15,7 @@ module GeoRuby
 
       #Text representation of a MultiPoint
       def text_representation(allow_z=true,allow_m=true)
-        @geometries.collect{|point| point.text_representation(allow_z,allow_m)}.join(",")
+        "(" + @geometries.collect{|point| point.text_representation(allow_z,allow_m)}.join("),(") + ")"
       end
       #WKT geoemtry type
       def text_geometry_type

data/lib/geo_ruby/simple_features/point.rb

@@ -25,6 +25,12 @@ module GeoRuby
         @x=x
         @y=y
       end
+      
+      #Bounding box in 2D. Returns an array of 2 points
+      def bounding_box
+        [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)] #not too difficult...
+      end
+      
       #tests the equality of the position of points + m
       def ==(other_point)
         if other_point.class != self.class

data/lib/geo_ruby/simple_features/polygon.rb

@@ -11,46 +11,17 @@ module GeoRuby
         super(srid,with_z,with_m)
         @rings = []
       end
-      #add one to the polygon
-      def <<(ring)
-        @rings << ring
-      end
-      #add one or more rings to the polygon
-      def concat(rings)
-        @rings.concat rings
-      end
-      #number of linear rings in the polygon
-      def length
-        @rings.length
-      end
-      #access the nth linear ring
-      def [](n)
-        @rings[n]
-      end
-      #modifies the value of the nth linear ring
-      def []=(n,ring)
-        @rings[n]=ring
-      end
-      #iterates over the linear rings
-      def each(&proc)
-        @rings.each(&proc)
-      end
-      #iterates over the linear rings, passing their indices to the bloc
-      def each_index(&proc)
-        @rings.each_index(&proc)
-      end
-      #insert linear rings at the nth position
-      def insert(n,*ring)
-        @rings.insert(n,*ring)
-      end
-      #index of the linear_ring
-      def index(ring)
-        @rings.index(ring)
+      
+      #Delegate the unknown methods to the rings array
+      def method_missing(method_name,*args,&b)
+        @rings.send(method_name,*args,&b)
       end
-      #remove linear rings. Arguments can be of the same type as Array#slice
-      def remove(*slice)
-        @rings.slice(*slice)
+      
+      #Bounding box in 2D. Returns an array of 2 points
+      def bounding_box
+        @rings[0].bounding_box
       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

@@ -13,7 +13,7 @@ end
 
 desc "Generate the documentation"
 Rake::RDocTask::new do |rdoc|
-  rdoc.rdoc_dir = 'doc/'
+  rdoc.rdoc_dir = 'georuby-doc/'
   rdoc.title    = "GeoRuby Documentation"
   rdoc.options << '--line-numbers' << '--inline-source'
   rdoc.rdoc_files.include('README')
@@ -24,10 +24,10 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'GeoRuby'
-  s.version = "0.1.1"
+  s.version = "0.2.1"
   s.summary = "Ruby data holder for OGC Simple Features"
   s.description = <<EOF
-GeoRuby is intended as a holder for data returned from PostGIS queries. Therefore, 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)
+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)
 EOF
   s.author = 'Guilhem Vellut'
   s.email = 'guilhem.vellut+georuby@gmail.com'

data/test/test_ewkt_parser.rb

@@ -92,7 +92,7 @@ class TestEWKTParser < Test::Unit::TestCase
     assert(polygon.instance_of?(Polygon))
     assert_equal(Polygon.from_coordinates([[[0,0],[4,0],[4,4],[0,4],[0,0]],[[1,1],[3,1],[3,3],[1,3],[1,1]]],256),polygon)
 
-     @ewkt_parser.parse("SRID=256;POLYGON((0 0 2,4 0 2,4 4 2,0 4 2,0 0 2),(1 1 2,3 1 2,3 3 2,1 3 2,1 1 2))")
+     @ewkt_parser.parse("SRID=256;POLYGON( ( 0 0  2,4 0 2,4 4 2,0 4 2,0 0 2),(1 1 2,3 1 2,3 3 2,1 3 2,1 1 2))")
     polygon = @factory.geometry
     assert(polygon.instance_of?(Polygon))
     assert_equal(Polygon.from_coordinates([[[0,0,2],[4,0,2],[4,4,2],[0,4,2],[0,0,2]],[[1,1,2],[3,1,2],[3,3,2],[1,3,2],[1,1,2]]],256,true),polygon)
@@ -112,6 +112,7 @@ class TestEWKTParser < Test::Unit::TestCase
    end
 
    def test_multi_point
+     #Form output by the current version of PostGIS. Future versions will output the one in the specification
     @ewkt_parser.parse("SRID=444;MULTIPOINT(12.4 -123.3,-65.1 123.4,123.55555555 123)")
     multi_point = @factory.geometry
     assert(multi_point.instance_of?(MultiPoint))
@@ -125,6 +126,14 @@ class TestEWKTParser < Test::Unit::TestCase
      assert_equal(MultiPoint.from_coordinates([[12.4,-123.3,4.5],[-65.1,123.4,6.7],[123.55555555,123,7.8]],444,true),multi_point)
      assert_equal(444,multi_point.srid)
      assert_equal(444,multi_point[0].srid)
+
+     #Form in the EWKT specification (from the OGC)
+     @ewkt_parser.parse("SRID=444;MULTIPOINT( ( 12.4   -123.3 4.5 ) , (-65.1 123.4 6.7),(123.55555555 123 7.8))")
+     multi_point = @factory.geometry
+     assert(multi_point.instance_of?(MultiPoint))
+     assert_equal(MultiPoint.from_coordinates([[12.4,-123.3,4.5],[-65.1,123.4,6.7],[123.55555555,123,7.8]],444,true),multi_point)
+     assert_equal(444,multi_point.srid)
+     assert_equal(444,multi_point[0].srid)
   end
 
    def test_multi_line_string

data/test/test_simple_features.rb

@@ -82,6 +82,11 @@ class TestSimpleFeatures < Test::Unit::TestCase
     assert_equal(-3.4,point.z)
     assert_equal(15,point.m)
     assert_equal(123,point.srid)
+
+    bbox = Point.from_x_y_z_m(-1.6,2.8,-3.4,15,123).bounding_box
+    assert_equal(2,bbox.length)
+    assert_equal(Point.from_x_y(-1.6,2.8),bbox[0])
+    assert_equal(Point.from_x_y(-1.6,2.8),bbox[1])
   end
 
   def test_point_equal
@@ -174,6 +179,11 @@ class TestSimpleFeatures < Test::Unit::TestCase
     assert_equal(3,line_string.length)
     assert_equal(Point.from_x_y_z(12.4,-45.3,123,123),line_string[0])
 
+    bbox = LineString.from_coordinates([[12.4,-45.3,123],[45.4,41.6,333],[4.456,1.0698,987]],123,true).bounding_box
+    assert_equal(2,bbox.length)
+    assert_equal(Point.from_x_y(4.456,-45.3),bbox[0])
+    assert_equal(Point.from_x_y(45.4,41.6),bbox[1])
+    
   end
   
   def test_line_string_equal
@@ -260,7 +270,11 @@ class TestSimpleFeatures < Test::Unit::TestCase
     assert_equal(linear_ring1,polygon[0])
     assert_equal(linear_ring2,polygon[1])
 
-
+    bbox = Polygon.from_coordinates([[[12.4,-45.3,15.2],[45.4,41.6,2.4],[4.456,1.0698,5.6],[12.4,-45.3,6.1]],[[2.4,5.3,4.5],[5.4,1.4263,4.2],[14.46,1.06,123.1],[2.4,5.3,4.4]]],256,true).bounding_box
+    assert_equal(2,bbox.length)
+    assert_equal(Point.from_x_y(4.456,-45.3),bbox[0])
+    assert_equal(Point.from_x_y(45.4,41.6),bbox[1])
+    
   end
   def test_polygon_equal
     polygon1 = Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]],256)
@@ -319,6 +333,11 @@ class TestSimpleFeatures < Test::Unit::TestCase
     assert_equal(256,geometry_collection.srid)
     assert_equal(2,geometry_collection.length)
     assert_equal(LineString.from_coordinates([[5.7,12.45],[67.55,54]],256),geometry_collection[1])
+
+    bbox = geometry_collection.bounding_box
+    assert_equal(2,bbox.length)
+    assert_equal(Point.from_x_y(4.67,12.45),bbox[0])
+    assert_equal(Point.from_x_y(67.55,54),bbox[1])
   end
   def test_geometry_collection_equal
     geometry_collection1 = GeometryCollection.from_geometries([Point.from_x_y(4.67,45.4,256),LineString.from_coordinates([[5.7,12.45],[67.55,54]],256)],256)
@@ -363,10 +382,10 @@ class TestSimpleFeatures < Test::Unit::TestCase
   end
   def test_multi_point_text
     multi_point = MultiPoint.from_coordinates([[12.4,-123.3],[-65.1,123.4],[123.55555555,123]],444)
-    assert_equal("SRID=444;MULTIPOINT(12.4 -123.3,-65.1 123.4,123.55555555 123)",multi_point.as_ewkt)
+    assert_equal("SRID=444;MULTIPOINT((12.4 -123.3),(-65.1 123.4),(123.55555555 123))",multi_point.as_ewkt)
 
     multi_point = MultiPoint.from_coordinates([[12.4,-123.3,4.5],[-65.1,123.4,6.7],[123.55555555,123,7.8]],444,true)
-    assert_equal("SRID=444;MULTIPOINT(12.4 -123.3 4.5,-65.1 123.4 6.7,123.55555555 123 7.8)",multi_point.as_ewkt)
+    assert_equal("SRID=444;MULTIPOINT((12.4 -123.3 4.5),(-65.1 123.4 6.7),(123.55555555 123 7.8))",multi_point.as_ewkt)
     
 
   end

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: GeoRuby
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-05-01 00:00:00 +05:00
+  version: 0.2.1
+date: 2006-06-02 00:00:00 +05:00
 summary: Ruby data holder for OGC Simple Features
 require_paths: 
 - lib
 email: guilhem.vellut+georuby@gmail.com
 homepage: http://thepochisuperstarmegashow.com
 rubyforge_project: 
-description: GeoRuby is intended as a holder for data returned from PostGIS queries. Therefore, 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)
+description: 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)
 autorequire: 
 default_executable: 
 bindir: bin