GeoRuby 1.0.0 → 1.1.0

data/README

@@ -1,5 +1,5 @@
 =GeoRuby
-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). 
+This is GeoRuby 1.1.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). 
 
 ===Available data types
 The following geometric data types are provided :
@@ -14,18 +14,30 @@ The following geometric data types are provided :
 
 They can be in 2D, 3DZ, 3DM, and 4D.
 
+On top of this an Envelope class is available, to contain the bounding box of a geometry.
+
 ===Input and output
 These geometries can be input and output in WKB/EWKB/WKT/EWKT format (as well as the related HexWKB and HexEWKB formats). HexEWKB and WKB are the default form under which geometric data is returned respectively from PostGIS and MySql.
 
+GeoRSS Simple, GeoRSS W3CGeo, GeoRSS GML can also be output. Note that they will not output valid RSS, but just the part strictly concerning the geometry as outlined in http://www.georss.org/1/ . Since the model does not allow multiple geometries, for geometry collections, only the first geometry will be output. Similarly, for polygons, the GeoRSS output will only contain the outer ring. As for W3CGeo output, only points can be output, so the first point of the geometry is chosen. By default the Simple format is output. Envelope can also be output in these formats: The box geometric type is chosen (except for W3CGeo, where the center of the envelope is chose). 
+
+On top of that, there is now support for KML output. 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>clampedToGround</tt>, the altitude data will not be output even if present. Envelopes output a LatLonAltBox instead of a geometry.
+
 ===Installation
 To install the latest version, just type :
       gem install GeoRuby
 
 ===Changes since the last version
-- 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.
-- Geometries that are aggregation of other geometries (line strings, polygons, multi points, multi line strings, multi polygons and geometry collections) can now behave exactly like arrays.
+- Addition of the Vincenty ellipsoidal distance calculation method
+- The spherical distance now assumes the x and y are in degrees not radians
+- Addition of aliases to the +x+ and +y+ accessors, as well as the <tt>from_x_y_...</tt> constructors so the +x+ can be replaced by +lon+ and +y+ by +lat+.
+- Output of GeoRSS Simple, W3CGeo and GML formats
+- Output of KML format
+
+===For version 1.2.0
+- Reading (and writing?) of SHP files
+- Parsing of GeoRSS data
+- Update of the tutorials to show the GeoRSS and KML output, as well as the reading of SHP files
 
 ===License
 GeoRuby is released under the MIT license.

data/lib/geo_ruby.rb

@@ -7,6 +7,7 @@ require 'geo_ruby/simple_features/multi_point'
 require 'geo_ruby/simple_features/multi_line_string'
 require 'geo_ruby/simple_features/multi_polygon'
 require 'geo_ruby/simple_features/geometry_collection'
+require 'geo_ruby/simple_features/envelope'
 require 'geo_ruby/simple_features/ewkb_parser'
 require 'geo_ruby/simple_features/ewkt_parser'
 require 'geo_ruby/simple_features/geometry_factory'

data/lib/geo_ruby/simple_features/envelope.rb

@@ -0,0 +1,110 @@
+module GeoRuby
+  module SimpleFeatures
+    
+    class Envelope 
+      attr_accessor :lower_corner, :upper_corner
+      attr_accessor :srid, :with_z
+      
+      #Creates a enw Envelope with +lower_corner+ as the first element of the corners array and +upper_corner+ as the second element
+      def initialize(corners, srid = DEFAULT_SRID, with_z = false)
+        @lower_corner,@upper_corner = corners
+        @srid = srid
+        @with_z = with_z
+      end
+
+      #Merges the argument with the current evelope
+      def extend!(envelope)
+        lower_corner.x = [lower_corner.x,envelope.lower_corner.x].min
+        lower_corner.y = [lower_corner.y,envelope.lower_corner.y].min
+        upper_corner.x = [upper_corner.x,envelope.upper_corner.x].max
+        upper_corner.y = [upper_corner.y,envelope.upper_corner.y].max
+        self
+      end
+      
+      #Merges the argument with the current evelope and sends back a new
+      #envelope without changing the current one
+      def extend(envelope)
+        e = Envelope.new([Point.from_x_y(lower_corner.x,lower_corner.y),
+                          Point.from_x_y(upper_corner.x,upper_corner.y)])
+        e.extend!(envelope)
+        e
+      end
+      
+      #Sends back the center of the envelope
+      def center
+        Point.from_x_y((lower_corner.x + upper_corner.x)/2,(lower_corner.y + upper_corner.y)/2)
+      end
+
+      #georss serialization: Dialect can be passed as option <tt>:dialect</tt> and set to <tt>:simple</tt> (default)
+      #<tt>:w3cgeo</tt> or <tt>:gml</tt>. Options <tt>:featuretypetag
+      def as_georss(options)
+        dialect= options[:dialect] || :simple
+        case(dialect)
+        when :simple
+          geom_attr = ""
+          geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\"" if options[:featuretypetag]
+          geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\"" if options[:relationshiptag]
+          geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
+          geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
+          geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
+          
+          georss_simple_representation(options.merge(:geom_attr => geom_attr))
+        when :w3cgeo
+          georss_w3cgeo_representation(options)
+        when :gml
+          georss_gml_representation(options)
+        end
+      end
+      
+       #georss simple representation
+      def georss_simple_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:box#{geom_attr}>#{lower_corner.y} #{lower_corner.x} #{upper_corner.y} #{upper_corner.x}</#{georss_ns}:box>\n"
+      end
+
+      #georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        point = self.center
+        "<#{w3cgeo_ns}:lat>#{point.y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{point.x}</#{w3cgeo_ns}:long>\n"
+      end
+
+      #georss gml representation
+      def georss_gml_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:Envelope>\n"
+        result += "<#{gml_ns}:LowerCorner>" + "#{lower_corner.y} #{lower_corner.x}" + "</#{gml_ns}:LowerCorner>"
+        result += "<#{gml_ns}:UpperCorner>" + "#{upper_corner.y} #{upper_corner.x}" + "</#{gml_ns}:UpperCorner>"
+        result += "</#{gml_ns}:Envelope>\n</#{georss_ns}:where>\n"
+      end
+
+      #Sends back a latlonaltbox
+      def as_kml(options = {})
+        geom_data = ""
+        geom_data = "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+        
+        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        
+        kml_representation(options.merge(:geom_data => geom_data,:allow_z => allow_z))
+      end
+      
+      def kml_representation(options = {})#:nodoc:
+        result = "<LatLonAltBox>\n"
+        result += options[:geom_data]
+        result += "<north>#{upper_corner.y}</north>\n"
+        result += "<south>#{lower_corner.y}</south>\n"
+        result += "<east>#{upper_corner.x}</east>\n"
+        result += "<west>#{lower_corner.x}</west>\n"
+        
+        if with_z
+          result += "<minAltitude>#{lower_corner.z}</minAltitude>"
+          result += "<maxAltitude>#{upper_corner.z}</maxAltitude>"
+        end
+        
+        result += "</LatLonAltBox>\n"
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/geometry.rb

@@ -25,6 +25,16 @@ module GeoRuby#:nodoc:
         @with_z=with_z
         @with_m=with_m
       end
+
+      
+      #to be implemented in subclasses
+      def bounding_box
+      end
+      
+      #Returns an Envelope object for the geometry
+      def envelope
+        Envelope.new(bounding_box,srid,with_z)
+      end
             
       #Outputs the geometry as an EWKB string.
       #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.
@@ -82,6 +92,43 @@ module GeoRuby#:nodoc:
       def as_wkt
         as_ewkt(false,false,false)
       end
+
+      #Outputs the geometry in georss format. 
+      #Assumes the geometries are in latlon format, with x as lon and y as lat.
+      def as_georss(options = {})
+        dialect= options[:dialect] || :simple
+        case(dialect)
+        when :simple
+          geom_attr = ""
+          geom_attr += " featuretypetag=\"#{options[:featuretypetag]}\"" if options[:featuretypetag]
+          geom_attr += " relationshiptag=\"#{options[:relationshiptag]}\"" if options[:relationshiptag]
+          geom_attr += " floor=\"#{options[:floor]}\"" if options[:floor]
+          geom_attr += " radius=\"#{options[:radius]}\"" if options[:radius]
+          geom_attr += " elev=\"#{options[:elev]}\"" if options[:elev]
+          georss_simple_representation(options.merge(:geom_attr => geom_attr))
+        when :w3cgeo
+          georss_w3cgeo_representation(options)
+        when :gml
+          georss_gml_representation(options)
+        end
+      end
+
+      #Iutputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def as_kml(options = {})
+        id_attr = ""
+        id_attr = " id=\"#{options[:id]}\"" if options[:id]
+
+        geom_data = ""
+        geom_data += "<extrude>#{options[:extrude]}</extrude>\n" if options[:extrude]
+        geom_data += "<tesselate>#{options[:tesselate]}</tesselate>\n" if options[:tesselate]
+        geom_data += "<altitudeMode>#{options[:altitude_mode]}</altitudeMode>\n" if options[:altitude_mode]
+        
+        allow_z = with_z && (!options[:altitude_mode].nil?) && options[:atitude_mode] != "clampToGround"
+        
+        kml_representation(options.merge(:id_attr => id_attr, :geom_data => geom_data, :allow_z => allow_z))
+      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)

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -16,19 +16,37 @@ module GeoRuby
         @geometries.send(method_name,*args,&b)
       end
 
-      #Bounding box in 2D. Returns an array of 2 points
+      #Bounding box in 2D/3D. 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 
+        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX, -Float::MAX, Float::MAX 
+        if with_z
+          max_z, min_z = -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 
+            max_z = ne.z if ne.z > max_z
+            min_z = sw.z if sw.z < min_z 
+          end
+          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+        else
+          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
-        [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
       end
 
       #tests the equality of geometry collections
@@ -48,7 +66,7 @@ module GeoRuby
       end
       
       #Binary representation of the collection
-      def binary_representation(allow_z=true,allow_m=true)
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
         rep = [length].pack("V")
         #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) }
@@ -56,19 +74,42 @@ module GeoRuby
       end
       
       #WKB geometry type of the collection
-      def binary_geometry_type
+      def binary_geometry_type #:nodoc:
         7
       end
 
       #Text representation of a geometry collection
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
         @geometries.collect{|geometry| geometry.as_ewkt(false,allow_z,allow_m)}.join(",")
       end
       
       #WKT geometry type
-      def text_geometry_type
+      def text_geometry_type #:nodoc:
         "GEOMETRYCOLLECTION"
       end
+
+      #georss simple representation : outputs only the first geometry of the collection
+      def georss_simple_representation(options)#:nodoc: 
+        self[0].georss_simple_representation(options)
+      end
+      #georss w3c representation : outputs the first point of the outer ring
+      def georss_w3cgeo_representation(options)#:nodoc: 
+        self[0].georss_w3cgeo_representation(options)
+      end
+      #georss gml representation : outputs only the first geometry of the collection
+      def georss_gml_representation(options)#:nodoc: 
+        self[0].georss_gml_representation(options)
+      end
+
+      #outputs the geometry in kml format
+      def kml_representation(options = {}) #:nodoc: 
+        result = "<MultiGeometry#{options[:id_attr]}>\n"
+        options[:id_attr] = "" #the subgeometries do not have an ID
+        each do |geometry|
+          result += geometry.kml_representation(options)
+        end
+        result += "</MultiGeometry>\n"
+      end
       
       #creates a new GeometryCollection from an array of geometries
       def self.from_geometries(geometries,srid=DEFAULT_SRID,with_z=false,with_m=false)

data/lib/geo_ruby/simple_features/line_string.rb

@@ -23,16 +23,29 @@ module GeoRuby
         @points.first == @points.last
       end
 
-      #Bounding box in 2D. Returns an array of 2 points
+      #Bounding box in 2D/3D. 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 
+        if(with_z)
+          max_z, min_z = -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 
+            max_z = point.z if point.z > max_z
+            min_z = point.z if point.z < min_z 
+          end
+          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+        else
+          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
-        [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
       end
       
       #Tests the equality of line strings
@@ -51,25 +64,70 @@ module GeoRuby
       end
 
       #Binary representation of a line string
-      def binary_representation(allow_z=true,allow_m=true)
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc: 
         rep = [length].pack("V")
         each {|point| rep << point.binary_representation(allow_z,allow_m) }
         rep
       end
       
       #WKB geometry type
-      def binary_geometry_type
+      def binary_geometry_type #:nodoc: 
         2
       end
 
       #Text representation of a line string
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc: 
         @points.collect{|point| point.text_representation(allow_z,allow_m) }.join(",") 
       end
       #WKT geometry type
-      def text_geometry_type
+      def text_geometry_type #:nodoc: 
         "LINESTRING"
       end
+
+      #georss simple representation
+      def georss_simple_representation(options) #:nodoc: 
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:line#{geom_attr}>" + georss_poslist + "</#{georss_ns}:line>\n"
+      end
+      #georss w3c representation : outputs the first point of the line
+      def georss_w3cgeo_representation(options) #:nodoc: 
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        "<#{w3cgeo_ns}:lat>#{self[0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0].x}</#{w3cgeo_ns}:long>\n"
+      end
+      #georss gml representation
+      def georss_gml_representation(options) #:nodoc: 
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+        
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:LineString>\n<#{gml_ns}:posList>\n"
+        result += georss_poslist
+        result += "\n</#{gml_ns}:posList>\n</#{gml_ns}:LineString>\n</#{georss_ns}:where>\n"
+      end
+
+      def georss_poslist #:nodoc: 
+        map {|point| "#{point.y} #{point.x}"}.join(" ")
+      end
+
+      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def kml_representation(options = {}) #:nodoc: 
+        result = "<LineString#{options[:id_attr]}>\n"
+        result += options[:geom_data]
+        result += "<coordinates>"
+        result += kml_poslist(options[:allow_z])
+        result += "</coordinates>\n"
+        result += "</LineString>\n"
+      end
+      
+      def kml_poslist(allow_z) #:nodoc: 
+        if allow_z
+          map {|point| "#{point.x},#{point.y},#{point.z || 0}" }.join(" ")
+        else
+          map {|point| "#{point.x},#{point.y}" }.join(" ")
+        end
+      end
       
       #Creates a new line string. Accept an array of points as argument
       def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)

data/lib/geo_ruby/simple_features/multi_line_string.rb

@@ -7,16 +7,17 @@ module GeoRuby
       def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
         super(srid)
       end
-      def binary_geometry_type
+
+      def binary_geometry_type #:nodoc:
         5
       end
       
       #Text representation of a multi line string
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
         @geometries.collect{|line_string| "(" + line_string.text_representation(allow_z,allow_m) + ")" }.join(",")
       end
       #WKT geometry type
-      def text_geometry_type
+      def text_geometry_type #:nodoc:
         "MULTILINESTRING"
       end
       

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -9,16 +9,16 @@ module GeoRuby
         super(srid,with_z,with_m)
       end
             
-      def binary_geometry_type
+      def binary_geometry_type #:nodoc:
         4
       end
 
       #Text representation of a MultiPoint
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
         "(" + @geometries.collect{|point| point.text_representation(allow_z,allow_m)}.join("),(") + ")"
       end
       #WKT geoemtry type
-      def text_geometry_type
+      def text_geometry_type #:nodoc:
         "MULTIPOINT"
       end
 

data/lib/geo_ruby/simple_features/multi_polygon.rb

@@ -8,15 +8,16 @@ module GeoRuby
       def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
         super(srid)
       end
-      def binary_geometry_type
+
+      def binary_geometry_type #:nodoc:
         6
       end
       #Text representation of a MultiPolygon
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
         @geometries.collect{|polygon| "(" + polygon.text_representation(allow_z,allow_m) + ")"}.join(",")
       end
       #WKT geometry type
-      def text_geometry_type
+      def text_geometry_type #:nodoc:
         "MULTIPOLYGON"
       end
       

data/lib/geo_ruby/simple_features/point.rb

@@ -5,7 +5,11 @@ module GeoRuby
     #Represents a point. It is in 3D if the Z coordinate is not +nil+.
     class Point < Geometry
       
+      
       attr_accessor :x,:y,:z,:m
+      #if you prefer calling the coordinates lat and lon
+      alias :lon :x
+      alias :lat :y
       
       def initialize(srid=DEFAULT_SRID,with_z=false,with_m=false)
         super(srid,with_z,with_m)
@@ -20,34 +24,93 @@ module GeoRuby
         @y=y
         @z=z
       end
+      alias :set_lon_lat_z :set_x_y_z
+      
       #sets all coordinates of a 2D point in one call
       def set_x_y(x,y)
         @x=x
         @y=y
       end
+      alias :set_lon_lat :set_x_y
       
       #Return the distance between the 2D points (ie taking care only of the x and y coordinates), assuming the points are in projected coordinates. Euclidian distance in whatever unit the x and y ordinates are.
       def euclidian_distance(point)
         Math.sqrt((point.x - x)**2 + (point.y - y)**2)
       end
 
-      #Returns the sperical distance, with a radius of 6471000m, with the haversine law. Assumes x is the lon and y the lat, in radians. Returns the distance in meters by default, although by passing a value to the radius argument, this can be changed.
-      def spherical_distance(point,radius=6371000)
-        dlat = point.y - y
-        dlon = point.x - x
-        a = Math.sin(dlat/2)**2 + Math.cos(point.y) * Math.cos(y) * (Math.sin(dlon/2)**2)
+      #Returns the sperical distance in m, with a radius of 6471000m, with the haversine law. Assumes x is the lon and y the lat, in degrees (Changed in version 1.1). The user has to make sure using this distance makes sense (ie she should be in latlon coordinates)
+      def spherical_distance(point,radius=6370997.0)
+        deg_to_rad = 0.0174532925199433
+        
+        radlat_from = lat * deg_to_rad
+        radlat_to = point.lat * deg_to_rad
+        
+        dlat = (point.lat - lat) * deg_to_rad
+        dlon = (point.lon - lon) * deg_to_rad
+ 
+        a = Math.sin(dlat/2)**2 + Math.cos(radlat_from) * Math.cos(radlat_to) * Math.sin(dlon/2)**2
         c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
         radius * c
       end
 
-      #Ellipsoidal distance? Not implemented yet. Complicated and don't feel like it today. Check out http://www.movable-type.co.uk/scripts/LatLongVincenty.html for more info. I accept patches...
-      def ellipsoidal_distance(point)
-      end
-      
+      #Ellipsoidal distance in m using Vincenty's formula. Lifted entirely from Chris Veness's code at http://www.movable-type.co.uk/scripts/LatLongVincenty.html and adapted for Ruby. Assumes the x and y are the lon and lat in degrees.
+      #a is the semi-major axis (equatorial radius) of the ellipsoid
+      #b is the semi-minor axis (polar radius) of the ellipsoid
+      #Their values by default are set to the ones of the WGS84 ellipsoid
+      def ellipsoidal_distance(point, a = 6378137.0, b = 6356752.3142)
+        deg_to_rad = 0.0174532925199433
+        
+        f = (a-b) / a
+        l = (point.lon - lon) * deg_to_rad
+        
+        u1 = Math.atan((1-f) * Math.tan(lat * deg_to_rad ))
+        u2 = Math.atan((1-f) * Math.tan(point.lat * deg_to_rad))
+        sinU1 = Math.sin(u1)
+        cosU1 = Math.cos(u1)
+        sinU2 = Math.sin(u2)
+        cosU2 = Math.cos(u2)
+  
+        lambda = l
+        lambdaP = 2 * Math::PI
+        iterLimit = 20
+        
+        while (lambda-lambdaP).abs > 1e-12 && --iterLimit>0
+          sinLambda = Math.sin(lambda)
+          cosLambda = Math.cos(lambda)
+          sinSigma = Math.sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda))
+          
+          return 0 if sinSigma == 0 #coincident points
+          
+          cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda
+          sigma = Math.atan2(sinSigma, cosSigma)
+          sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma
+          cosSqAlpha = 1 - sinAlpha*sinAlpha
+          cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha
+          
+          cos2SigmaM = 0 if (cos2SigmaM.nan?) #equatorial line: cosSqAlpha=0
+
+          c = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha))
+          lambdaP = lambda
+          lambda = l + (1-c) * f * sinAlpha * (sigma + c * sinSigma * (cos2SigmaM + c * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)))
+        end
+        return NaN if iterLimit==0 #formula failed to converge
+
+        uSq = cosSqAlpha * (a*a - b*b) / (b*b)
+        a_bis = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)))
+        b_bis = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)))
+        deltaSigma = b_bis * sinSigma*(cos2SigmaM + b_bis/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)- b_bis/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)))
       
-      #Bounding box in 2D. Returns an array of 2 points
+        b*a_bis*(sigma-deltaSigma)
+      end
+
+            
+      #Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
-        [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)] #not too difficult...
+        unless with_z
+          [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)]
+        else
+          [Point.from_x_y_z(@x,@y,@z),Point.from_x_y_z(@x,@y,@z)]
+        end
       end
       
       #tests the equality of the position of points + m
@@ -58,29 +121,62 @@ module GeoRuby
           @x == other_point.x and @y == other_point.y and @z == other_point.z and @m == other_point.m
         end
       end
+      
       #binary representation of a point. It lacks some headers to be a valid EWKB representation.
-      def binary_representation(allow_z=true,allow_m=true)
+      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
         bin_rep = [@x,@y].pack("EE")
         bin_rep += [@z].pack("E") if @with_z and allow_z #Default value so no crash
         bin_rep += [@m].pack("E") if @with_m and allow_m #idem
         bin_rep
       end
       #WKB geometry type of a point
-      def binary_geometry_type
+      def binary_geometry_type#:nodoc:
         1
       end
       
       #text representation of a point
-      def text_representation(allow_z=true,allow_m=true)
+      def text_representation(allow_z=true,allow_m=true) #:nodoc:
         tex_rep = "#{@x} #{@y}"
         tex_rep += " #{@z}" if @with_z and allow_z
         tex_rep += " #{@m}" if @with_m and allow_m
         tex_rep
       end
       #WKT geometry type of a point
-      def text_geometry_type
+      def text_geometry_type #:nodoc:
         "POINT"
       end
+
+      #georss simple representation
+      def georss_simple_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:point#{geom_attr}>#{y} #{x}</#{georss_ns}:point>\n"
+      end
+      #georss w3c representation
+      def georss_w3cgeo_representation(options) #:nodoc:
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        "<#{w3cgeo_ns}:lat>#{y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{x}</#{w3cgeo_ns}:long>\n"
+      end
+      #georss gml representation
+      def georss_gml_representation(options) #:nodoc:
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:Point>\n<#{gml_ns}:pos>"
+        result += "#{y} #{x}"
+        result += "</#{gml_ns}:pos>\n</#{gml_ns}:Point>\n</#{georss_ns}:where>\n"
+      end
+
+      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def kml_representation(options = {}) #:nodoc: 
+        result = "<Point#{options[:id_attr]}>\n"
+        result += options[:geom_data]
+        result += "<coordinates>#{x},#{y}"
+        result += ",#{z || 0}" if options[:allow_z]
+        result += "</coordinates>\n"
+        result += "</Point>\n"
+      end
       
       #creates a point from an array of coordinates
       def self.from_coordinates(coords,srid=DEFAULT_SRID,with_z=false,with_m=false)
@@ -94,18 +190,22 @@ module GeoRuby
           from_x_y_m(coords[0],coords[1],coords[2],srid) 
         end
       end
+
       #creates a point from the X and Y coordinates
       def self.from_x_y(x,y,srid=DEFAULT_SRID)
         point= Point::new(srid)
         point.set_x_y(x,y)
         point
       end
+      
       #creates a point from the X, Y and Z coordinates
       def self.from_x_y_z(x,y,z,srid=DEFAULT_SRID)
         point= Point::new(srid,true)
         point.set_x_y_z(x,y,z)
         point
       end
+      
+
       #creates a point from the X, Y and M coordinates
       def self.from_x_y_m(x,y,m,srid=DEFAULT_SRID)
         point= Point::new(srid,false,true)
@@ -113,6 +213,7 @@ module GeoRuby
         point.m=m
         point
       end
+      
       #creates a point from the X, Y, Z and M coordinates
       def self.from_x_y_z_m(x,y,z,m,srid=DEFAULT_SRID)
         point= Point::new(srid,true,true)
@@ -120,6 +221,14 @@ module GeoRuby
         point.m=m
         point
       end
+      
+      #aliasing the constructors in case you want to use lat/lon instead of y/x
+      class << self
+        alias :from_lon_lat :from_x_y
+        alias :from_lon_lat_z :from_x_y_z
+        alias :from_lon_lat_m :from_x_y_m
+        alias :from_lon_lat_z_m :from_x_y_z_m
+      end
     end
   end
 end

data/lib/geo_ruby/simple_features/polygon.rb

@@ -17,9 +17,23 @@ module GeoRuby
         @rings.send(method_name,*args,&b)
       end
       
-      #Bounding box in 2D. Returns an array of 2 points
+      #Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
-        @rings[0].bounding_box
+        unless with_z
+          @rings[0].bounding_box
+        else
+          result = @rings[0].bounding_box #valid for x and y
+          max_z, min_z = result[1].z, result[0].z
+          1.upto(size - 1) do |index|
+            bbox = @rings[index].bounding_box
+            sw = bbox[0]
+            ne = bbox[1]
+            max_z = ne.z if ne.z > max_z
+            min_z = sw.z if sw.z < min_z 
+          end
+          result[1].z, result[0].z = max_z, min_z
+          result
+        end
       end
       
       #tests for other equality. The SRID is not taken into account.
@@ -56,6 +70,45 @@ module GeoRuby
         "POLYGON"
       end
 
+      #georss simple representation : outputs only the outer ring
+      def georss_simple_representation(options)
+        georss_ns = options[:georss_ns] || "georss"
+        geom_attr = options[:geom_attr]
+        "<#{georss_ns}:polygon#{geom_attr}>" + self[0].georss_poslist + "</#{georss_ns}:polygon>\n"
+      end
+      #georss w3c representation : outputs the first point of the outer ring
+      def georss_w3cgeo_representation(options)
+        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        
+        "<#{w3cgeo_ns}:lat>#{self[0][0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0][0].x}</#{w3cgeo_ns}:long>\n"
+      end
+      #georss gml representation
+      def georss_gml_representation(options)
+        georss_ns = options[:georss_ns] || "georss"
+        gml_ns = options[:gml_ns] || "gml"
+       
+        result = "<#{georss_ns}:where>\n<#{gml_ns}:Polygon>\n<#{gml_ns}:exterior>\n<#{gml_ns}:LinearRing>\n<#{gml_ns}:posList>\n" + self[0].georss_poslist + "\n</#{gml_ns}:posList>\n</#{gml_ns}:LinearRing>\n</#{gml_ns}:exterior>\n</#{gml_ns}:Polygon>\n</#{georss_ns}:where>\n"
+      end
+
+      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
+      #it won't be used by GE anyway: clampToGround is the default)
+      def kml_representation(options = {})
+        result = "<Polygon#{options[:id_attr]}>\n"
+        result += options[:geom_data]
+        rings.each_with_index do |ring, i|
+          if i == 0
+            boundary = "outerBoundaryIs"
+          else
+            boundary = "innerBoundaryIs"
+          end
+          result += "<#{boundary}><LinearRing><coordinates>\n"
+          result += ring.kml_poslist(options[:allow_z])
+          result += "\n</coordinates></LinearRing></#{boundary}>\n"
+        end
+        result += "</Polygon>\n"
+      end
+    
       #creates a new polygon. Accepts an array of linear strings as argument
       def self.from_linear_rings(linear_rings,srid = DEFAULT_SRID,with_z=false,with_m=false)
         polygon = Polygon::new(srid,with_z,with_m)
@@ -70,7 +123,6 @@ module GeoRuby
         polygon
       end
 
-
     end
   end
 end

data/rakefile.rb

@@ -24,14 +24,14 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'GeoRuby'
-  s.version = "1.0.0"
+  s.version = "1.1.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)
 EOF
   s.author = 'Guilhem Vellut'
   s.email = 'guilhem.vellut+georuby@gmail.com'
-  s.homepage = "http://thepochisuperstarmegashow.com"
+  s.homepage = "http://thepochisuperstarmegashow.com/projects"
   
   s.requirements << 'none'
   s.require_path = 'lib'

data/test/test_georss_kml.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'geo_ruby'
+require 'test/unit'
+
+include GeoRuby::SimpleFeatures
+
+class TestGeorssKml < Test::Unit::TestCase
+
+  def test_geometry_creation
+    point = Point.from_x_y(3,4)
+    
+    assert_equal("<georss:point featuretypetag=\"hoyoyo\" elev=\"45.7\">4 3</georss:point>", point.as_georss(:dialect => :simple, :elev => 45.7, :featuretypetag => "hoyoyo").gsub("\n",""))
+    assert_equal("<geo:lat>4</geo:lat><geo:long>3</geo:long>",point.as_georss(:dialect => :w3cgeo).gsub("\n",""))
+    assert_equal("<georss:where><gml:Point><gml:pos>4 3</gml:pos></gml:Point></georss:where>",point.as_georss(:dialect => :gml).gsub("\n",""))
+
+    assert_equal("<Point id=\"HOYOYO-42\"><coordinates>3,4</coordinates></Point>",point.as_kml(:id => "HOYOYO-42").gsub("\n",""))
+  end
+
+  def test_line_string
+    ls = LineString.from_points([Point.from_lon_lat_z(12.4,-45.3,56),Point.from_lon_lat_z(45.4,41.6,45)],123,true)
+
+    assert_equal("<georss:line>-45.3 12.4 41.6 45.4</georss:line>",ls.as_georss.gsub("\n",""))
+    assert_equal("<geo:lat>-45.3</geo:lat><geo:long>12.4</geo:long>",ls.as_georss(:dialect => :w3cgeo).gsub("\n",""))
+    assert_equal("<georss:where><gml:LineString><gml:posList>-45.3 12.4 41.6 45.4</gml:posList></gml:LineString></georss:where>",ls.as_georss(:dialect => :gml).gsub("\n",""))
+
+    assert_equal("<LineString><extrude>1</extrude><altitudeMode>absolute</altitudeMode><coordinates>12.4,-45.3,56 45.4,41.6,45</coordinates></LineString>",ls.as_kml(:extrude => 1, :altitude_mode => "absolute").gsub("\n",""))
+  end 
+
+  def test_polygon
+     linear_ring1 = LinearRing.from_coordinates([[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],256) 
+    linear_ring2 = LinearRing.from_coordinates([[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]],256) 
+    polygon = Polygon.from_linear_rings([linear_ring1,linear_ring2],256)
+
+    assert_equal("<hoyoyo:polygon>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</hoyoyo:polygon>",polygon.as_georss(:georss_ns => "hoyoyo").gsub("\n",""))
+    assert_equal("<bouyoul:lat>-45.3</bouyoul:lat><bouyoul:long>12.4</bouyoul:long>",polygon.as_georss(:dialect => :w3cgeo, :w3cgeo_ns => "bouyoul").gsub("\n",""))
+    assert_equal("<georss:where><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></georss:where>",polygon.as_georss(:dialect => :gml).gsub("\n",""))
+
+    assert_equal("<Polygon><outerBoundaryIs><LinearRing><coordinates>12.4,-45.3 45.4,41.6 4.456,1.0698 12.4,-45.3</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>2.4,5.3 5.4,1.4263 14.46,1.06 2.4,5.3</coordinates></LinearRing></innerBoundaryIs></Polygon>",polygon.as_kml.gsub("\n",""))
+  end
+
+  def test_geometry_collection
+    gc = GeometryCollection.from_geometries([Point.from_x_y(4.67,45.4,256),LineString.from_coordinates([[5.7,12.45],[67.55,54]],256)],256)
+    
+    #only the first geometry is output
+    assert_equal("<georss:point floor=\"4\">45.4 4.67</georss:point>",gc.as_georss(:dialect => :simple,:floor => 4).gsub("\n",""))
+    assert_equal("<geo:lat>45.4</geo:lat><geo:long>4.67</geo:long>",gc.as_georss(:dialect => :w3cgeo).gsub("\n",""))
+    assert_equal("<georss:where><gml:Point><gml:pos>45.4 4.67</gml:pos></gml:Point></georss:where>",gc.as_georss(:dialect => :gml).gsub("\n",""))
+    
+    assert_equal("<MultiGeometry id=\"HOYOYO-42\"><Point><coordinates>4.67,45.4</coordinates></Point><LineString><coordinates>5.7,12.45 67.55,54</coordinates></LineString></MultiGeometry>",gc.as_kml(:id => "HOYOYO-42").gsub("\n",""))
+  end
+
+  def test_envelope
+    linear_ring1 = LinearRing.from_coordinates([[12.4,-45.3,5],[45.4,41.6,6],[4.456,1.0698,8],[12.4,-45.3,3.5]],256,true) 
+    linear_ring2 = LinearRing.from_coordinates([[2.4,5.3,9.0],[5.4,1.4263,-5.4],[14.46,1.06,34],[2.4,5.3,3.14]],256,true) 
+    polygon = Polygon.from_linear_rings([linear_ring1,linear_ring2],256,true)
+    
+    e = polygon.envelope
+    
+    assert_equal("<georss:box>-45.3 4.456 41.6 45.4</georss:box>",e.as_georss(:dialect => :simple).gsub("\n",""))
+    #center
+    assert_equal("<geo:lat>-1.85</geo:lat><geo:long>24.928</geo:long>",e.as_georss(:dialect => :w3cgeo).gsub("\n",""))
+    assert_equal("<georss:where><gml:Envelope><gml:LowerCorner>-45.3 4.456</gml:LowerCorner><gml:UpperCorner>41.6 45.4</gml:UpperCorner></gml:Envelope></georss:where>",e.as_georss(:dialect => :gml).gsub("\n",""))
+    
+    assert_equal("<LatLonAltBox><north>41.6</north><south>-45.3</south><east>45.4</east><west>4.456</west><minAltitude>-5.4</minAltitude><maxAltitude>34</maxAltitude></LatLonAltBox>",e.as_kml.gsub("\n",""))
+  end
+
+end

data/test/test_simple_features.rb

@@ -85,8 +85,8 @@ class TestSimpleFeatures < Test::Unit::TestCase
 
     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])
+    assert_equal(Point.from_x_y_z(-1.6,2.8,-3.4),bbox[0])
+    assert_equal(Point.from_x_y_z(-1.6,2.8,-3.4),bbox[1])
   end
 
   def test_point_equal
@@ -140,10 +140,11 @@ class TestSimpleFeatures < Test::Unit::TestCase
   def test_point_distance
     point1 = Point.from_x_y(0,0)
     point2 = Point.from_x_y(3,4)
-    assert_equal(point1.euclidian_distance(point2),5)
-
-    point2 = Point.from_x_y(Math::PI,0)
-    assert_in_delta(point1.spherical_distance(point2),20015086,1)
+    assert_equal(5,point1.euclidian_distance(point2))
+    
+    assert_in_delta(554058.924,point1.ellipsoidal_distance(point2),0.001)
+         
+    assert_in_delta(555811.68,point1.spherical_distance(point2),0.01)
     
     
   end
@@ -192,8 +193,8 @@ class TestSimpleFeatures < Test::Unit::TestCase
 
     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])
+    assert_equal(Point.from_x_y_z(4.456,-45.3,123),bbox[0])
+    assert_equal(Point.from_x_y_z(45.4,41.6,987),bbox[1])
     
   end
   
@@ -283,8 +284,8 @@ class TestSimpleFeatures < Test::Unit::TestCase
 
     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])
+    assert_equal(Point.from_x_y_z(4.456,-45.3,2.4),bbox[0])
+    assert_equal(Point.from_x_y_z(45.4,41.6,123.1),bbox[1])
     
   end
   def test_polygon_equal
@@ -461,4 +462,27 @@ class TestSimpleFeatures < Test::Unit::TestCase
     
   end
   
+  def test_envelope
+    linear_ring = LinearRing.from_coordinates([[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],256) 
+    polygon = Polygon.from_linear_rings([linear_ring],256)
+    e = polygon.envelope
+    
+    assert_equal(e.lower_corner.class, Point)
+    assert_equal(e.upper_corner.class, Point)
+
+    assert_equal(e.lower_corner.x,4.456)
+    assert_equal(e.lower_corner.y,-45.3)
+    assert_equal(e.upper_corner.x,45.4)
+    assert_equal(e.upper_corner.y,41.6)
+
+    line_string = LineString.from_coordinates([[13.6,-49.3],[45.4,44.6],[14.2,1.09],[13.6,-49.3]],256) 
+    e2 = line_string.envelope
+
+    e3 = e.extend(e2)
+    
+    assert_equal(e3.lower_corner.x,4.456)
+    assert_equal(e3.lower_corner.y,-49.3)
+    assert_equal(e3.upper_corner.x,45.4)
+    assert_equal(e3.upper_corner.y,44.6)
+  end
 end

metadata

@@ -3,13 +3,13 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: GeoRuby
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-08-23 00:00:00 +01:00
+  version: 1.1.0
+date: 2006-12-31 00:00:00 +01:00
 summary: Ruby data holder for OGC Simple Features
 require_paths: 
 - lib
 email: guilhem.vellut+georuby@gmail.com
-homepage: http://thepochisuperstarmegashow.com
+homepage: http://thepochisuperstarmegashow.com/projects
 rubyforge_project: 
 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: 
@@ -30,6 +30,7 @@ authors:
 - Guilhem Vellut
 files: 
 - lib/geo_ruby.rb
+- lib/geo_ruby/simple_features/envelope.rb
 - lib/geo_ruby/simple_features/ewkb_parser.rb
 - lib/geo_ruby/simple_features/ewkt_parser.rb
 - lib/geo_ruby/simple_features/geometry.rb
@@ -44,6 +45,7 @@ files:
 - lib/geo_ruby/simple_features/polygon.rb
 - test/test_ewkb_parser.rb
 - test/test_ewkt_parser.rb
+- test/test_georss_kml.rb
 - test/test_simple_features.rb
 - README
 - MIT-LICENSE
@@ -51,6 +53,7 @@ files:
 test_files: 
 - test/test_ewkb_parser.rb
 - test/test_ewkt_parser.rb
+- test/test_georss_kml.rb
 - test/test_simple_features.rb
 rdoc_options: 
 - --main