GeoRuby 0.0.4 → 0.1.1

data/README

@@ -1,5 +1,5 @@
 =GeoRuby
-This is GeoRuby 0.0.4. It 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 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.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). 
 
 ===Available data types
 The following geometric data types are provided :
@@ -12,16 +12,21 @@ The following geometric data types are provided :
 - Multi polygon
 - Geometry collection
 
+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). Since EWKB and HexEWKB are respectively the canonical binary and ASCII representations of geometries in PostGIS, this functionality can prove useful.
+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.
 
 ===Installation
-Just type :
+To install the latest version, just type :
       gem install GeoRuby
 
 ===Changes since the last version
-Change of the default SRID when not specified
-Correction of a bug in the EWKT parsing for negative SRIDs
+- 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+.
 
 ===License
 GeoRuby is released under the MIT license.

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -9,6 +9,10 @@ require 'geo_ruby/simple_features/geometry_collection'
 
 module GeoRuby
   module SimpleFeatures
+
+    class EWKBFormatError < StandardError
+    end
+
     #Parses EWKB strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
     #
     #=Example
@@ -35,36 +39,41 @@ module GeoRuby
       def parse(ewkb)
         @factory.reset
         @unpack_structure=UnpackStructure::new(ewkb)
+        @with_z = false
+        @with_m = false
         parse_geometry
         @unpack_structure.done
         @srid=nil
       end
+      
       private
       def parse_geometry
         @unpack_structure.endianness=@unpack_structure.read_byte
         @geometry_type = @unpack_structure.read_uint
-        @dimension=2
-        
+                
         if (@geometry_type & Z_MASK) != 0
-          @dimension=3
+          @with_z=true
           @geometry_type = @geometry_type & ~Z_MASK
         end
         if (@geometry_type & M_MASK) != 0
-          raise StandardError::new("For next version")
+          @with_m=true
+          @geometry_type = @geometry_type & ~M_MASK
         end
         if (@geometry_type & SRID_MASK) != 0
           @srid = @unpack_structure.read_uint
           @geometry_type = @geometry_type & ~SRID_MASK
         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 parent, we take the default srid
+          #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
         end
+        
         if @parse_options.has_key? @geometry_type
           @parse_options[@geometry_type].call
         else
-          raise StandardError::new("Unknown geometry type")
+          raise EWKBFormatError::new("Unknown geometry type")
         end
       end
+      
       def parse_geometry_collection
         parse_multi_geometries(GeometryCollection)
       end
@@ -80,42 +89,56 @@ module GeoRuby
       def parse_multi_point
         parse_multi_geometries(MultiPoint)
       end
+      
       def parse_multi_geometries(geometry_type)
         @factory.begin_geometry(geometry_type,@srid)
         num_geometries = @unpack_structure.read_uint
         1.upto(num_geometries) { parse_geometry }
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
+      
       def parse_polygon
         @factory.begin_geometry(Polygon,@srid)
         num_linear_rings = @unpack_structure.read_uint
         1.upto(num_linear_rings) {parse_linear_ring}
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
+      
       def parse_linear_ring
         parse_point_list(LinearRing)
       end
+      
       def parse_line_string
         parse_point_list(LineString)
       end
+      
       #used to parse line_strings and linear_rings
       def parse_point_list(geometry_type)
         @factory.begin_geometry(geometry_type,@srid)
         num_points = @unpack_structure.read_uint
         1.upto(num_points) {parse_point}
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
+      
       def parse_point
         @factory.begin_geometry(Point,@srid)
         x = @unpack_structure.read_double
         y = @unpack_structure.read_double
-        if @dimension == 3
+        if ! (@with_z or @with_m) #most common case probably
+          @factory.add_point_x_y(x,y)
+        elsif @with_m and @with_z
+          z = @unpack_structure.read_double
+          m = @unpack_structure.read_double
+          @factory.add_point_x_y_z_m(x,y,z,m)
+        elsif @with_z
           z = @unpack_structure.read_double
           @factory.add_point_x_y_z(x,y,z)
         else
-          @factory.add_point_x_y(x,y)
+          m = @unpack_structure.read_double
+          @factory.add_point_x_y_m(x,y,m)
         end
-        @factory.end_geometry
+                
+        @factory.end_geometry(@with_z,@with_m)
       end
     end
 
@@ -149,27 +172,27 @@ module GeoRuby
         @ewkb=ewkb
       end
       def done
-        raise StandardError::new("Trailing data") if @position != @ewkb.length
+        raise EWKBFormatError::new("Trailing data") if @position != @ewkb.length
       end
       def read_double
         i=@position
         @position += 8
         packed_double = @ewkb[i...@position]
-        raise StandardError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
+        raise EWKBFormatError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
         packed_double.unpack(@double_mark)[0]
       end
       def read_uint
         i=@position
         @position += 4
         packed_uint = @ewkb[i...@position]
-        raise StandardError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
+        raise EWKBFormatError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
         packed_uint.unpack(@uint_mark)[0]
       end
       def read_byte
         i = @position
         @position += 1
         packed_byte = @ewkb[i...@position]
-        raise StandardError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
+        raise EWKBFormatError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
         packed_byte.unpack("C")[0]
       end
       def endianness=(byte_order)

data/lib/geo_ruby/simple_features/ewkt_parser.rb

@@ -11,6 +11,10 @@ require 'strscan'
 
 module GeoRuby
   module SimpleFeatures
+
+    class EWKTFormatError < StandardError
+    end
+
     #Parses EWKT strings and notifies of events (such as the beginning of the definition of geometry, the value of the SRID...) the factory passed as argument to the constructor.
     #
     #=Example
@@ -36,6 +40,8 @@ module GeoRuby
       #Parses the ewkt string passed as argument and notifies the factory of events
       def parse(ewkt)
         @factory.reset
+        @with_z=false
+        @with_m=false
         parse_geometry(ewkt)
         @srid=nil
       end
@@ -44,61 +50,70 @@ module GeoRuby
       def parse_geometry(ewkt)
         scanner = StringScanner.new(ewkt)
         if scanner.scan(/SRID=(-?\d+);/) 
-          @srid = scanner[1].to_i
+          if @srid.nil?
+            @srid = scanner[1].to_i
+          else
+            #not the root geometry and repeat of the SRID : shouldn't happen
+            raise EWKTFormatError.new("SRID in internal geometry")
+          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 parent, we take the default srid
+          #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
         end
         
-        if scanner.scan(/(\w+)/) and @parse_options.has_key? scanner[1]
-          to_call = scanner[1]
-          if scanner.scan(/\((.*)\)/)
-            @parse_options[to_call].call(scanner[1])
+        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 StandardError::new("Bad token : " + scanner.rest)
+            raise EWKTFormatError.new("Bad token")
           end
-        else
-          raise StandardError::new("Unknown geometry type")
         end
+        
       end
       def parse_geometry_collection(string)
         @factory.begin_geometry(GeometryCollection,@srid)
         scanner = StringScanner.new(string)
-        while(scanner.scan(/(.*?),(?=[A-Z])/))
+        while(scanner.scan(/\s*(.*?),\s*(?=[A-Z])/))
           parse_geometry(scanner[1])
         end
         parse_geometry(scanner.rest)
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
       
       def parse_multi_polygon(string)
         @factory.begin_geometry(MultiPolygon,@srid)
         scanner = StringScanner.new(string)
-        while(scanner.scan(/\((\((.*?)\))\),?/))
+        while(scanner.scan(/\s*\(\s*(\((.*?)\))\s*\)\s*,?/)) #beeeh
           parse_polygon(scanner[1])
         end
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
                  
       def parse_multi_line_string(string)
         @factory.begin_geometry(MultiLineString,@srid)
         scanner = StringScanner.new(string)
-        while(scanner.scan(/\(([^\)]*)\),?/))
+
+        while(scanner.scan(/\s*\(([^\)]*)\)\s*,?/))
           parse_line_string(scanner[1])
         end
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
 
       def parse_polygon(string)
         @factory.begin_geometry(Polygon,@srid)
         scanner = StringScanner.new(string)
-        while(scanner.scan(/\(([^\)]*)\),?/))
+        while(scanner.scan(/\s*\(([^\)]*)\)\s*,?/))
           parse_linear_ring(scanner[1])
         end
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
-      
-      
+            
       def parse_multi_point(string)
         parse_point_list(MultiPoint,string)
       end
@@ -108,14 +123,14 @@ module GeoRuby
       def parse_line_string(string)
         parse_point_list(LineString,string)
       end
-      #used to parse line_strings and linear_rings
+      #used to parse line_strings and linear_rings and multi_points
       def parse_point_list(geometry_type,string)
         @factory.begin_geometry(geometry_type,@srid)
         scanner = StringScanner.new(string)
         while(scanner.scan(/([^,]*),?/))
           parse_point(scanner[1])
         end
-        @factory.end_geometry
+        @factory.end_geometry(@with_z,@with_m)
       end
       
       def parse_point(string)
@@ -125,12 +140,23 @@ module GeoRuby
         while scanner.scan(/\s*([-+]?[\d.]+)\s*/)
           coords << scanner[1].to_f
         end
-        if(coords.length == 2)
+        
+        if coords.length == 2
           @factory.add_point_x_y(*coords)
+        elsif coords.length == 3
+          if @with_m
+            @factory.add_point_x_y_m(*coords)
+          else
+            @with_z=true #we know if it is 3dz only when reading the first point
+            @factory.add_point_x_y_z(*coords)
+          end
         else
-          @factory.add_point_x_y_z(*coords)
+          @with_m=true
+          @with_z=true
+          @factory.add_point_x_y_z_m(*coords)
         end
-        @factory.end_geometry
+        
+        @factory.end_geometry(@with_z,@with_m)
       end
     end
     

data/lib/geo_ruby/simple_features/geometry.rb

@@ -4,7 +4,7 @@ module GeoRuby#:nodoc:
     DEFAULT_SRID=-1
     #indicates the presence of Z coordinates in EWKB strings
     Z_MASK=0x80000000
-    #indicates the presence of M coordinates in EWKB strings. It is not supported at present.
+    #indicates the presence of M coordinates in EWKB strings.
     M_MASK=0x40000000
     #indicate the presence of a SRID in EWKB strings.
     SRID_MASK=0x20000000
@@ -15,74 +15,89 @@ module GeoRuby#:nodoc:
     class Geometry
       #SRID of the geometry
       attr_accessor :srid
+      #Flag indicating if the z ordinate of the geometry is meaningful
+      attr_accessor :with_z
+      #Flag indicating if the m ordinate of the geometry is meaningful
+      attr_accessor :with_m
       
-      def initialize(srid=DEFAULT_SRID)
+      def initialize(srid=DEFAULT_SRID,with_z=false,with_m=false)
         @srid=srid
+        @with_z=with_z
+        @with_m=with_m
       end
             
       #Outputs the geometry as an EWKB string.
-      #
-      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
-      #
-      #WKB output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
-      def as_binary(dimension=2,with_srid=true)
+      #The +allow_srid+, +allow_z+ and +allow_m+ arguments allow the output to include srid, z and m respectively if they are present in the geometry. If these arguments are set to false, srid, z and m are not included, even if they are present in the geometry. By default, the output string contains all the information in the object.
+      def as_ewkb(allow_srid=true,allow_z=true,allow_m=true)
         ewkb="";
        
         ewkb << 1.chr #little_endian by default
         
         type= binary_geometry_type
-        if dimension == 3
+        if @with_z and allow_z
           type = type | Z_MASK
         end
-        if(with_srid)
+        if @with_m and allow_m
+          type = type | M_MASK
+        end
+        if @srid != DEFAULT_SRID and allow_srid
           type = type | SRID_MASK
           ewkb << [type,@srid].pack("VV")
         else
           ewkb << [type].pack("V")
         end
-        ewkb << binary_representation(dimension)
+        
+        ewkb << binary_representation(allow_z,allow_m)
+      end
+      
+      #Outputs the geometry as a strict WKB string.
+      def as_wkb
+        as_ewkb(false,false,false)
       end
+
       #Outputs the geometry as a HexEWKB string. It is almost the same as a WKB string, except that each byte of a WKB string is replaced by its hexadecimal 2-character representation in a HexEWKB string.
-      #
-      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
-      #
-      #HexWKB output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
-      def as_hex_binary(dimension=2,with_srid=true)
+      def as_hex_ewkb(allow_srid=true,allow_z=true,allow_m=true)
         str = ""
-        as_binary(dimension,with_srid).each_byte {|char| str << sprintf("%02x",char).upcase}
+        as_ewkb(allow_srid,allow_z,allow_m).each_byte {|char| str << sprintf("%02x",char).upcase}
         str
       end
+      #Outputs the geometry as a strict HexWKB string
+      def as_hex_wkb
+        as_hex_ewkb(false,false,false)
+      end
 
-      #Outputs the geometry as a EWKT string.
-      #
-      #
-      #The argument +dimension+ forces the dimension of the output. The argument +with_srid+ indicates if the output must contain the SRID.
-      #
-      #WKT output can be obtained for any geometry by passing a +dimension+ of 2 and +with_srid+ set to false.
-      def as_text(dimension=2,with_srid=true)
-        if with_srid
+      #Outputs the geometry as an EWKT string.
+      def as_ewkt(allow_srid=true,allow_z=true,allow_m=true)
+        if @srid!=DEFAULT_SRID and allow_srid #the default SRID is not output like in PostGIS
           ewkt="SRID=#{@srid};"
         else
           ewkt=""
         end
-        ewkt << text_geometry_type << "("
-        ewkt << text_representation(dimension) << ")"        
+        ewkt << text_geometry_type 
+        ewkt << "M" if @with_m and allow_m and (!@with_z or !allow_z) #to distinguish the M from the Z when there is actually no Z... 
+        ewkt << "(" << text_representation(allow_z,allow_m) << ")"        
       end
-
+      
+      #Outputs the geometry as strict WKT string.
+      def as_wkt
+        as_ewkt(false,false,false)
+      end
+      
+      #Creates a geometry based on a EWKB string. The actual class returned depends of the content of the string passed as argument. Since WKB strings are a subset of EWKB, they are also valid.
       def self.from_ewkb(ewkb)
         factory = GeometryFactory::new
         ewkb_parser= EWKBParser::new(factory)
         ewkb_parser.parse(ewkb)
         factory.geometry
       end
-
-      def self.from_hexewkb(hexewkb)
+      #Creates a geometry based on a HexEWKB string
+      def self.from_hex_ewkb(hexewkb)
         factory = GeometryFactory::new
         hexewkb_parser= HexEWKBParser::new(factory)
         hexewkb_parser.parse(hexewkb)
         factory.geometry
       end
-
+      #Creates a geometry based on a EWKT string. Since WKT strings are a subset of EWKT, they are also valid.
       def self.from_ewkt(ewkt)
         factory = GeometryFactory::new
         ewkt_parser= EWKTParser::new(factory)

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -6,8 +6,8 @@ module GeoRuby
     class GeometryCollection < Geometry
       attr_reader :geometries
 
-      def initialize(srid = DEFAULT_SRID)
-        super(srid)
+      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
         @geometries = []
       end
       #add a geometry to the collection
@@ -65,27 +65,33 @@ module GeoRuby
           true
         end
       end
+      
       #Binary representation of the collection
-      def binary_representation(dimension=2)
+      def binary_representation(allow_z=true,allow_m=true)
         rep = [length].pack("V")
-        each {|geometry| rep << geometry.as_binary(dimension,false) }
+        #output the list of geometries without outputting the SRID first and with the same setting regarding Z and M
+        each {|geometry| rep << geometry.as_ewkb(false,allow_z,allow_m) }
         rep
       end
+      
       #WKB geometry type of the collection
       def binary_geometry_type
         7
       end
+
       #Text representation of a geometry collection
-      def text_representation(dimension=2)
-        @geometries.collect{|geometry| geometry.as_text(dimension,false)}.join(",")
+      def text_representation(allow_z=true,allow_m=true)
+        @geometries.collect{|geometry| geometry.as_ewkt(false,allow_z,allow_m)}.join(",")
       end
+      
       #WKT geometry type
       def text_geometry_type
         "GEOMETRYCOLLECTION"
       end
+      
       #creates a new GeometryCollection from an array of geometries
-      def self.from_geometries(geometries,srid=DEFAULT_SRID)
-        geometry_collection = GeometryCollection::new(srid)
+      def self.from_geometries(geometries,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        geometry_collection = GeometryCollection::new(srid,with_z,with_m)
         geometry_collection.concat(geometries)
         geometry_collection
       end

data/lib/geo_ruby/simple_features/geometry_factory.rb

@@ -30,6 +30,16 @@ module GeoRuby
       def add_point_x_y_z(x,y,z)
         @geometry_stack.last.set_x_y_z(x,y,z)
       end
+      #add a 2D point with M to the current geometry
+      def add_point_x_y_m(x,y,m)
+        @geometry_stack.last.set_x_y(x,y)
+        @geometry_stack.last.m=m
+      end
+      #add a 3D point with M to the current geometry
+      def add_point_x_y_z_m(x,y,z,m)
+        @geometry_stack.last.set_x_y_z(x,y,z)
+        @geometry_stack.last.m=m
+      end
       #begin a geometry of type +geometry_type+
       def begin_geometry(geometry_type,srid=DEFAULT_SRID)
         geometry= geometry_type::new(srid)
@@ -37,8 +47,10 @@ module GeoRuby
         @geometry_stack << geometry
       end
       #terminates the current geometry
-      def end_geometry
-        geometry=@geometry_stack.pop
+      def end_geometry(with_z=false,with_m=false)
+        @geometry=@geometry_stack.pop
+        @geometry.with_z=with_z
+        @geometry.with_m=with_m
         #add the newly defined geometry to its parent if there is one
         @geometry_stack.last << geometry if !@geometry_stack.empty?
       end

data/lib/geo_ruby/simple_features/line_string.rb

@@ -7,8 +7,8 @@ module GeoRuby
       #the list of points forming the line string
       attr_reader :points
 
-      def initialize(srid= DEFAULT_SRID )
-        super(srid)
+      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
         @points=[]
       end
       #tests if the line string is closed
@@ -56,6 +56,7 @@ module GeoRuby
       def remove(*slice)
         @points.slice(*slice)
       end
+      
       #Tests the equality of line strings
       def ==(other_line_string)
         if(other_line_string.class != self.class or 
@@ -70,20 +71,22 @@ module GeoRuby
           true
         end
       end
-      
+
       #Binary representation of a line string
-      def binary_representation(dimension=2)
+      def binary_representation(allow_z=true,allow_m=true)
         rep = [length].pack("V")
-        each {|point| rep << point.binary_representation(dimension) }
+        each {|point| rep << point.binary_representation(allow_z,allow_m) }
         rep
       end
+      
       #WKB geometry type
       def binary_geometry_type
         2
       end
+
       #Text representation of a line string
-      def text_representation(dimension=2)
-        @points.collect{|point| point.text_representation(dimension) }.join(",") 
+      def text_representation(allow_z=true,allow_m=true)
+        @points.collect{|point| point.text_representation(allow_z,allow_m) }.join(",") 
       end
       #WKT geometry type
       def text_geometry_type
@@ -91,16 +94,16 @@ module GeoRuby
       end
       
       #Creates a new line string. Accept an array of points as argument
-      def self.from_points(points,srid=DEFAULT_SRID)
-        line_string = LineString::new(srid)
+      def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        line_string = LineString::new(srid,with_z,with_m)
         line_string.concat(points)
         line_string
       end
 
       #Creates a new line string. Accept a sequence of points as argument : ((x,y)...(x,y))
-      def self.from_raw_point_sequence(points,srid=DEFAULT_SRID)
-        line_string = LineString::new(srid)
-        line_string.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid)  } )
+      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        line_string = LineString::new(srid,with_z,with_m)
+        line_string.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid,with_z,with_m)  } )
         line_string
       end
 

data/lib/geo_ruby/simple_features/linear_ring.rb

@@ -4,21 +4,21 @@ module GeoRuby
   module SimpleFeatures
     #Represents a linear ring, which is a closed line string (see LineString). No check is performed to verify if the linear ring is really closed.
     class LinearRing < LineString
-      def initialize(srid= DEFAULT_SRID)
-        super(srid)
+      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
+        super(srid,with_z,with_m)
       end
 
       #creates a new linear ring from an array of points. The first and last points should be equal, although no check is performed here.
-      def self.from_points(points,srid=DEFAULT_SRID)
-        linear_ring = LinearRing::new(srid)
+      def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        linear_ring = LinearRing::new(srid,with_z,with_m)
         linear_ring.concat(points)
         linear_ring
       end
 
       #creates a new linear ring from a sequence of points : ((x,y)...(x,y)).
-      def self.from_raw_point_sequence(points,srid=DEFAULT_SRID)
-        linear_ring = LinearRing::new(srid)
-        linear_ring.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid)  } ) 
+      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
+        linear_ring = LinearRing::new(srid,with_z,with_m)
+        linear_ring.concat( points.collect{|point_coords| Point.from_coordinates(point_coords,srid,with_z,with_m) } )
         linear_ring
       end