rgeo 0.1.11 → 0.1.12

data/History.rdoc

@@ -1,3 +1,15 @@
+=== 0.1.12 / 2010-10-23
+
+Further development and fixes in the geographic coordinate systems.
+
+Changes since 0.1.11:
+
+* API CHANGE: Factory#coerce renamed to Factory#cast. I think this should be the final name for this function.
+* Some new tests and a lot of fixes in SimpleMercator and SimpleSpherical.
+* Implemented a few more pieces of SimpleSpherical. Notably, LineString#is_simple? (which should now allow LinearRing to work).
+* Classes that included Features::Geometry had their === operator erroneously overridden. Fixed.
+* A few more documentation updates.
+
 === 0.1.11 / 2010-10-21
 
 Further development and fixing in the geographic coordinate systems.

data/Version

@@ -1 +1 @@
-0.1.11
+0.1.12

data/ext/geos_c_impl/factory.c

@@ -332,7 +332,7 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
 
 const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj)
 {
-  VALUE object = rb_funcall(factory, rb_intern("coerce"), 1, obj);
+  VALUE object = rb_funcall(factory, rb_intern("cast"), 1, obj);
   const GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GET_GEOS_GEOMETRY(object);
@@ -346,7 +346,7 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALU
   if (klasses) {
     *klasses = Qnil;
   }
-  VALUE object = rb_funcall(globals->default_factory, rb_intern("coerce"), 2, obj, Qtrue);
+  VALUE object = rb_funcall(globals->default_factory, rb_intern("cast"), 2, obj, Qtrue);
   GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;

data/lib/rgeo/features/factory.rb

@@ -144,6 +144,7 @@ module RGeo
       
       
       # Create a feature of type MultiLineString.
+      # 
       # The elems should be an Enumerable of LineString objects, or
       # collections whose contents, recursively expanded, eventually
       # include only LineString objects (or subclasses thereof).
@@ -173,12 +174,12 @@ module RGeo
       end
       
       
-      # Coerce an existing feature to a feature of the type created by
+      # Cast an existing feature to a feature of the type created by
       # this implementation.
       # If force_new is true, a new object is returned even if the original
       # is already of this implementation.
       
-      def coerce(original_, force_new_=false)
+      def cast(original_, force_new_=false)
         nil
       end
       

data/lib/rgeo/features/geometry.rb

@@ -116,7 +116,7 @@ module RGeo
         
         
         def included(mod_)  # :nodoc:
-          mod_.extend(ClassMethods)
+          mod_.extend(ClassMethods) unless mod_.kind_of?(Class)
         end
         
       end

data/lib/rgeo/geo_json/entities.rb

@@ -77,7 +77,7 @@ module RGeo
       
       # Two features are equal if their geometries, IDs, and properties
       # are all equal.
-      # This methods uses the eql? method to test geometry equality, which
+      # This method uses the eql? method to test geometry equality, which
       # may behave differently than the == operator.
       
       def eql?(rhs_)
@@ -87,7 +87,7 @@ module RGeo
       
       # Two features are equal if their geometries, IDs, and properties
       # are all equal.
-      # This methods uses the == operator to test geometry equality, which
+      # This method uses the == operator to test geometry equality, which
       # may behave differently than the eql? method.
       
       def ==(rhs_)

data/lib/rgeo/geography/common/geometry_collection_methods.rb

@@ -56,7 +56,7 @@ module RGeo
         
         
         def _setup(elements_)
-          @elements = elements_.map{ |elem_| factory.coerce(elem_) }
+          @elements = elements_.map{ |elem_| factory.cast(elem_) }
           _validate_geometry
         end
         

data/lib/rgeo/geography/common/helper.rb

@@ -69,26 +69,26 @@ module RGeo
         def self.parse_wkt(str_, factory_)
           helper_factory_ = self.factory
           obj_ = helper_factory_ ? helper_factory_.parse_wkt(str_) : nil
-          obj_ ? factory_.coerce(obj_) : nil
+          obj_ ? factory_.cast(obj_) : nil
         end
         
         
         def self.parse_wkb(str_, factory_)
           helper_factory_ = self.factory
           obj_ = helper_factory_ ? helper_factory_.parse_wkb(str_) : nil
-          obj_ ? factory_.coerce(obj_) : nil
+          obj_ ? factory_.cast(obj_) : nil
         end
         
         
         def self.unparse_wkt(obj_)
           helper_factory_ = self.factory
-          helper_factory_ ? helper_factory_.coerce(obj_).as_text : nil
+          helper_factory_ ? helper_factory_.cast(obj_).as_text : nil
         end
         
         
         def self.unparse_wkb(obj_)
           helper_factory_ = self.factory
-          helper_factory_ ? helper_factory_.coerce(obj_).as_binary : nil
+          helper_factory_ ? helper_factory_.cast(obj_).as_binary : nil
         end
         
         

data/lib/rgeo/geography/common/line_string_methods.rb

@@ -45,7 +45,12 @@ module RGeo
         
         
         def _setup(points_)
-          @points = points_.map{ |elem_| factory.coerce(elem_) }
+          @points = points_.map do |elem_|
+            unless Features::Point.check_type(elem_)
+              raise Errors::InvalidGeometry, 'Element #{elem_} is not a point'
+            end
+            factory.cast(elem_)
+          end
           _validate_geometry
         end
         
@@ -57,6 +62,15 @@ module RGeo
         end
         
         
+        def eql?(rhs_)
+          if rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @points.size == rhs_.num_points
+            rhs_.points.each_with_index{ |p_, i_| return false unless @points[i_].eql?(p_) }
+          else
+            false
+          end
+        end
+        
+        
         def cast(type_)
           if type_ == self.geometry_type
             self

data/lib/rgeo/geography/common/point_methods.rb

@@ -62,9 +62,8 @@ module RGeo
         
         
         def eql?(rhs_)
-          rhs_.is_a?(self.class) && @x == rhs_.x && @y == rhs_.y
+          rhs_.is_a?(self.class) && rhs_.factory.eql?(@factory) && @x == rhs_.x && @y == rhs_.y
         end
-        alias_method :==, :eql?
         
         
         def cast(type_)
@@ -111,9 +110,14 @@ module RGeo
         end
         
         
+        def convex_hull
+          self
+        end
+        
+        
         def equals?(rhs_)
           return false unless rhs_.factory.is_a?(Factory)
-          rhs_ = factory.coerce(rhs_)
+          rhs_ = factory.cast(rhs_)
           case rhs_
           when Features::Point
             if @y == 90

data/lib/rgeo/geography/common/polygon_methods.rb

@@ -45,8 +45,8 @@ module RGeo
         
         
         def _setup(exterior_ring_, interior_rings_)
-          @exterior_ring = exterior_ring_
-          @interior_rings = (interior_rings_ || []).map{ |elem_| factory.coerce(elem_) }
+          @exterior_ring = factory.cast(exterior_ring_)
+          @interior_rings = (interior_rings_ || []).map{ |elem_| factory.cast(elem_) }
           unless Features::LinearRing.check_type(@exterior_ring)
             raise Errors::InvalidGeometry, 'Exterior ring must be a LinearRing'
           end

data/lib/rgeo/geography/factories.rb

@@ -127,7 +127,8 @@ module RGeo
       #   If set to true, assertion checking on MultiPolygon is disabled.
       #   This may speed up creation of MultiPolygon objects, at the
       #   expense of not doing the proper checking for OGC MultiPolygon
-      #   compliance. Default is false.
+      #   compliance. See RGeo::Features::MultiPolygon for details on
+      #   the MultiPolygon assertions. Default is false.
       # <tt>:buffer_resolution</tt>::
       #   The resolution of buffers around geometries created by this
       #   factory. This controls the number of line segments used to
@@ -135,7 +136,7 @@ module RGeo
       #   example, the buffer around a point to be approximated by a
       #   4-sided polygon. A resolution of 2 would cause that buffer
       #   to be approximated by an 8-sided polygon. The exact behavior
-      #   for different kinds of buffers is not specified.
+      #   for different kinds of buffers is defined by GEOS.
       
       def simple_mercator(opts_={})
         Geography::Factory.new(Geography::SimpleMercator, :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions])

data/lib/rgeo/geography/factory.rb

@@ -213,9 +213,9 @@ module RGeo
       end
       
       
-      # See ::RGeo::Features::Factory#coerce
+      # See ::RGeo::Features::Factory#cast
       
-      def coerce(original_, force_new_=false)
+      def cast(original_, force_new_=false)
         if self == original_.factory
           force_new_ ? original_.dup : original_
         else
@@ -223,21 +223,21 @@ module RGeo
           when Features::Point
             @namespace.const_get(:PointImpl).new(self, original_.x, original_.y) rescue nil
           when Features::Line
-            @namespace.const_get(:LineImpl).new(self, coerce(original_.start_point), coerce(original_.end_point)) rescue nil
+            @namespace.const_get(:LineImpl).new(self, cast(original_.start_point), cast(original_.end_point)) rescue nil
           when Features::LinearRing
-            @namespace.const_get(:LinearRingImpl).new(self, original_.points.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:LinearRingImpl).new(self, original_.points.map{ |g_| cast(g_) }) rescue nil
           when Features::LineString
-            @namespace.const_get(:LineStringImpl).new(self, original_.points.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:LineStringImpl).new(self, original_.points.map{ |g_| cast(g_) }) rescue nil
           when Features::Polygon
-            @namespace.const_get(:PolygonImpl).new(self, coerce(original_.exterior_ring), original_.interior_rings.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:PolygonImpl).new(self, cast(original_.exterior_ring), original_.interior_rings.map{ |g_| cast(g_) }) rescue nil
           when Features::MultiPoint
-            @namespace.const_get(:MultiPointImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:MultiPointImpl).new(self, original_.to_a.map{ |g_| cast(g_) }) rescue nil
           when Features::MultiLineString
-            @namespace.const_get(:MultiLineStringImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:MultiLineStringImpl).new(self, original_.to_a.map{ |g_| cast(g_) }) rescue nil
           when Features::MultiPolygon
-            @namespace.const_get(:MultiPolygonImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:MultiPolygonImpl).new(self, original_.to_a.map{ |g_| cast(g_) }) rescue nil
           when Features::GeometryCollection
-            @namespace.const_get(:GeometryCollectionImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
+            @namespace.const_get(:GeometryCollectionImpl).new(self, original_.to_a.map{ |g_| cast(g_) }) rescue nil
           else
             nil
           end

data/lib/rgeo/geography/simple_mercator/feature_methods.rb

@@ -103,52 +103,52 @@ module RGeo
         
         
         def equals?(rhs_)
-          projection.equals?(factory.coerce(rhs_).projection)
+          projection.equals?(factory.cast(rhs_).projection)
         end
         
         
         def disjoint?(rhs_)
-          projection.disjoint?(factory.coerce(rhs_).projection)
+          projection.disjoint?(factory.cast(rhs_).projection)
         end
         
         
         def intersects?(rhs_)
-          projection.intersects?(factory.coerce(rhs_).projection)
+          projection.intersects?(factory.cast(rhs_).projection)
         end
         
         
         def touches?(rhs_)
-          projection.touches?(factory.coerce(rhs_).projection)
+          projection.touches?(factory.cast(rhs_).projection)
         end
         
         
         def crosses?(rhs_)
-          projection.crosses?(factory.coerce(rhs_).projection)
+          projection.crosses?(factory.cast(rhs_).projection)
         end
         
         
         def within?(rhs_)
-          projection.within?(factory.coerce(rhs_).projection)
+          projection.within?(factory.cast(rhs_).projection)
         end
         
         
         def contains?(rhs_)
-          projection.contains?(factory.coerce(rhs_).projection)
+          projection.contains?(factory.cast(rhs_).projection)
         end
         
         
         def overlaps?(rhs_)
-          projection.overlaps?(factory.coerce(rhs_).projection)
+          projection.overlaps?(factory.cast(rhs_).projection)
         end
         
         
         def relate(rhs_, pattern_)
-          projection.relate(factory.coerce(rhs_).projection, pattern_)
+          projection.relate(factory.cast(rhs_).projection, pattern_)
         end
         
         
         def distance(rhs_)
-          projection.distance(factory.coerce(rhs_).projection) / scaling_factor
+          projection.distance(factory.cast(rhs_).projection) / scaling_factor
         end
         
         
@@ -163,22 +163,22 @@ module RGeo
         
         
         def intersection(rhs_)
-          factory.unproject(projection.intersection(factory.coerce(rhs_).projection))
+          factory.unproject(projection.intersection(factory.cast(rhs_).projection))
         end
         
         
         def union(rhs_)
-          factory.unproject(projection.union(factory.coerce(rhs_).projection))
+          factory.unproject(projection.union(factory.cast(rhs_).projection))
         end
         
         
         def difference(rhs_)
-          factory.unproject(projection.difference(factory.coerce(rhs_).projection))
+          factory.unproject(projection.difference(factory.cast(rhs_).projection))
         end
         
         
         def sym_difference(rhs_)
-          factory.unproject(projection.sym_difference(factory.coerce(rhs_).projection))
+          factory.unproject(projection.sym_difference(factory.cast(rhs_).projection))
         end
         
         

data/lib/rgeo/geography/simple_spherical/calculations.rb

@@ -62,6 +62,12 @@ module RGeo
           @x = x_ / r_
           @y = y_ / r_
           @z = z_ / r_
+          raise "Not a number" if @x.nan? || @y.nan? || @z.nan?
+        end
+        
+        
+        def to_s
+          "(#{@x}, #{@y}, #{@z})"
         end
         
         
@@ -70,6 +76,12 @@ module RGeo
         attr_reader :z
         
         
+        def eql?(rhs_)
+          rhs_.kind_of?(PointXYZ) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z
+        end
+        alias_method :==, :eql?
+        
+        
         def latlon
           lat_rad_ = ::Math.asin(@z)
           lon_rad_ = ::Math.atan2(@y, @x) rescue 0.0
@@ -79,7 +91,10 @@ module RGeo
         
         
         def *(rhs_)
-          @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
+          val_ = @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
+          val_ = 1.0 if val_ > 1.0
+          val_ = -1.0 if val_ < -1.0
+          val_
         end
         
         
@@ -87,7 +102,20 @@ module RGeo
           rx_ = rhs_.x
           ry_ = rhs_.y
           rz_ = rhs_.z
-          PointXYZ.new(@y*rz_-@z*ry_, @z*rx_-@x*rz_, @x*ry_-@y-rx_) rescue nil
+          PointXYZ.new(@y*rz_-@z*ry_, @z*rx_-@x*rz_, @x*ry_-@y*rx_) rescue nil
+        end
+        
+        
+        def dist_to_point(rhs_)
+          rx_ = rhs_.x
+          ry_ = rhs_.y
+          rz_ = rhs_.z
+          x_ = @y*rz_-@z*ry_
+          y_ = @z*rx_-@x*rz_
+          z_ = @x*ry_-@y*rx_
+          r_ = ::Math.sqrt(x_*x_ + y_*y_ + z_*z_)
+          r_ = 1.0 if r_ > 1.0
+          ::Math.asin(r_)
         end
         
         
@@ -105,22 +133,67 @@ module RGeo
       end
       
       
-      module Calculations
+      # Represents a finite arc on the sphere.
+      
+      class ArcXYZ
         
+        def initialize(start_, end_)
+          @s = start_
+          @e = end_
+          @axis = false
+        end
         
-        def point_distance(p1_, p2_)
-          rpd_ = Common::Helper::RADIANS_PER_DEGREE
-          from_lat_rad_ = rpd_ * from_.lat
-          to_lat_rad_ = rpd_ * to_.lat
-          delta_lon_rad_ = rpd_ * (to_.lon - from_.lon)
-          val_ = ::Math.sin(from_lat_rad_) * ::Math.sin(to_lat_rad_) + 
-            ::Math.cos(from_lat_rad_) * ::Math.cos(to_lat_rad_) * ::Math.cos(delta_lon_rad_)
-          val_ = 1.0 if val_ > 1.0
-          val_ = -1.0 if val_ < -1.0
-          ::Math.acos(val_) * RADIUS
+        
+        attr_reader :s
+        attr_reader :e
+        
+        
+        def to_s
+          "#{@s} - #{@e}"
+        end
+        
+        
+        def eql?(rhs_)
+          rhs_.kind_of?(ArcXYZ) && @s == rhs_.s && @e == rhs_.e
         end
+        alias_method :==, :eql?
+        
         
+        def axis
+          if @axis == false
+            @axis = @s % @e
+          end
+          @axis
+        end
         
+        
+        def contains_point?(obj_)
+          axis_ = axis
+          saxis_ = ArcXYZ.new(@s, obj_).axis
+          eaxis_ = ArcXYZ.new(obj_, @e).axis
+          !saxis_ || !eaxis_ || obj_ * axis_ == 0.0 && saxis_ * axis_ > 0 && eaxis_ * axis_ > 0
+        end
+        
+        
+        def intersects_arc?(obj_)
+          my_axis_ = axis
+          dot1_ = my_axis_ * obj_.s
+          dot2_ = my_axis_ * obj_.e
+          if dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
+            ob_axis_ = obj_.axis
+            dot1_ = ob_axis_ * @s
+            dot2_ = ob_axis_ * @e
+            dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
+          else
+            false
+          end
+        end
+        
+        
+      end
+      
+      
+      module Calculations
       end
       
       

data/lib/rgeo/geography/simple_spherical/line_string_impl.rb

@@ -41,13 +41,56 @@ module RGeo
     module SimpleSpherical
       
       
+      module LineStringMethods
+        
+        
+        def _arcs
+          unless @arcs
+            @arcs = (0..num_points-2).map do |i_|
+              ArcXYZ.new(point_n(i_)._xyz, point_n(i_+1)._xyz)
+            end
+          end
+          @arcs
+        end
+        
+        
+        def is_simple?
+          arcs_ = _arcs
+          len_ = arcs_.length
+          return false if arcs_.any?{ |a_| a_.nil? }
+          return true if len_ == 1
+          return arcs_[0].start != arcs_[1].end if len_ == 2
+          arcs_.each_with_index do |arc_, index_|
+            nindex_ = index_ + 1
+            nindex_ = nil if nindex_ == len_
+            return false if nindex_ && arc_.contains_point?(arcs_[nindex_].e)
+            pindex_ = index_ - 1
+            pindex_ = nil if pindex_ < 0
+            return false if pindex_ && arc_.contains_point?(arcs_[pindex_].s)
+            if nindex_
+              oindex_ = nindex_ + 1
+              while oindex_ < len_
+                oarc_ = arcs_[oindex_]
+                return false if !(index_ == 0 && oindex_ == len_-1 && arc_.s == oarc_.e) && arc_.intersects_arc?(oarc_)
+                oindex_ += 1
+              end
+            end
+          end
+          true
+        end
+        
+        
+      end
+      
+      
       class LineStringImpl
         
         
         include Features::LineString
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleSpherical::GeometryMethods
         include Common::LineStringMethods
+        include SimpleSpherical::LineStringMethods
         
         
         def initialize(factory_, points_)
@@ -64,8 +107,9 @@ module RGeo
         
         include Features::Line
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleSpherical::GeometryMethods
         include Common::LineStringMethods
+        include SimpleSpherical::LineStringMethods
         include Common::LineMethods
         
         
@@ -83,8 +127,9 @@ module RGeo
         
         include Features::Line
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleSpherical::GeometryMethods
         include Common::LineStringMethods
+        include SimpleSpherical::LineStringMethods
         include Common::LinearRingMethods
         
         

data/lib/rgeo/geography/simple_spherical/point_impl.rb

@@ -46,7 +46,7 @@ module RGeo
         
         include Features::Point
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleSpherical::GeometryMethods
         include Common::PointMethods
         
         
@@ -65,15 +65,16 @@ module RGeo
         end
         
         
-        def xyz
+        def _xyz
           @xyz ||= PointXYZ.from_latlon(@y, @x)
         end
         
         
         def distance(rhs_)
+          rhs_ = @factory.cast(rhs_)
           case rhs_
-          when Features::Point
-            Calculator.point_distance(self, rhs_)
+          when PointImpl
+            _xyz.dist_to_point(rhs_._xyz) * SimpleSpherical::RADIUS
           else
             super
           end

data/lib/rgeo/geos/factory.rb

@@ -58,7 +58,8 @@ module RGeo
         #   If set to true, assertion checking on MultiPolygon is disabled.
         #   This may speed up creation of MultiPolygon objects, at the
         #   expense of not doing the proper checking for OGC MultiPolygon
-        #   compliance. Default is false.
+        #   compliance. See RGeo::Features::MultiPolygon for details on
+        #   the MultiPolygon assertions. Default is false.
         # <tt>:buffer_resolution</tt>::
         #   The resolution of buffers around geometries created by this
         #   factory. This controls the number of line segments used to
@@ -66,8 +67,7 @@ module RGeo
         #   example, the buffer around a point to be approximated by a
         #   4-sided polygon. A resolution of 2 would cause that buffer
         #   to be approximated by an 8-sided polygon. The exact behavior
-        #   for different kinds of buffers is internal to GEOS, and is not
-        #   well-specified as far as I can tell.
+        #   for different kinds of buffers is defined by GEOS.
         # <tt>:srid</tt>::
         #   Set the SRID returned by geometries created by this factory.
         #   Default is 0.
@@ -203,9 +203,9 @@ module RGeo
       end
       
       
-      # See ::RGeo::Features::Factory#coerce
+      # See ::RGeo::Features::Factory#cast
       
-      def coerce(original_, force_new_=false)
+      def cast(original_, force_new_=false)
         return nil unless Geos.supported?
         case original_
         when GeometryImpl
@@ -225,21 +225,21 @@ module RGeo
             PointImpl.create(self, original_.x, original_.y)
           end
         when Features::Line
-          LineImpl.create(self, coerce(original_.start_point), coerce(original_.end_point))
+          LineImpl.create(self, cast(original_.start_point), cast(original_.end_point))
         when Features::LinearRing
-          LinearRingImpl.create(self, original_.points.map{ |g_| coerce(g_) })
+          LinearRingImpl.create(self, original_.points.map{ |g_| cast(g_) })
         when Features::LineString
-          LineStringImpl.create(self, original_.points.map{ |g_| coerce(g_) })
+          LineStringImpl.create(self, original_.points.map{ |g_| cast(g_) })
         when Features::Polygon
-          PolygonImpl.create(self, coerce(original_.exterior_ring), original_.interior_rings.map{ |g_| coerce(g_) })
+          PolygonImpl.create(self, cast(original_.exterior_ring), original_.interior_rings.map{ |g_| cast(g_) })
         when Features::MultiPoint
-          MultiPointImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
+          MultiPointImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
         when Features::MultiLineString
-          MultiLineStringImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
+          MultiLineStringImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
         when Features::MultiPolygon
-          MultiPolygonImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
+          MultiPolygonImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
         when Features::GeometryCollection
-          GeometryCollectionImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
+          GeometryCollectionImpl.create(self, original_.to_a.map{ |g_| cast(g_) })
         else
           nil
         end

data/lib/rgeo/geos/interface.rb

@@ -61,6 +61,26 @@ module RGeo
       
       # Returns a factory for the GEOS implementation.
       # Returns nil if the GEOS implementation is not supported.
+      # 
+      # Options include:
+      # 
+      # <tt>:lenient_multi_polygon_assertions</tt>::
+      #   If set to true, assertion checking on MultiPolygon is disabled.
+      #   This may speed up creation of MultiPolygon objects, at the
+      #   expense of not doing the proper checking for OGC MultiPolygon
+      #   compliance. See RGeo::Features::MultiPolygon for details on
+      #   the MultiPolygon assertions. Default is false.
+      # <tt>:buffer_resolution</tt>::
+      #   The resolution of buffers around geometries created by this
+      #   factory. This controls the number of line segments used to
+      #   approximate curves. The default is 1, which causes, for
+      #   example, the buffer around a point to be approximated by a
+      #   4-sided polygon. A resolution of 2 would cause that buffer
+      #   to be approximated by an 8-sided polygon. The exact behavior
+      #   for different kinds of buffers is defined by GEOS.
+      # <tt>:srid</tt>::
+      #   Set the SRID returned by geometries created by this factory.
+      #   Default is 0.
       
       def factory(opts_={})
         supported? ? Factory.create(opts_) : nil

data/tests/common/line_string_tests.rb

@@ -219,10 +219,10 @@ module RGeo
           point2_ = @factory.point(0, 1)
           line1_ = @factory.line_string([point1_, point2_])
           line2_ = line1_.clone
-          assert_equal(line1_, line2_)
+          assert(line1_.eql?(line2_))
           assert_equal(2, line2_.num_points)
-          assert_equal(point1_, line2_.point_n(0))
-          assert_equal(point2_, line2_.point_n(1))
+          assert(point1_.eql?(line2_.point_n(0)))
+          assert(point2_.eql?(line2_.point_n(1)))
         end
         
         
@@ -245,7 +245,7 @@ module RGeo
           line1_ = @factory.line_string([point1_, point2_])
           text_ = line1_.as_text
           line2_ = @factory.parse_wkt(text_)
-          assert_equal(line2_, line1_)
+          assert(line2_.eql?(line1_))
         end
         
         
@@ -255,7 +255,7 @@ module RGeo
           line1_ = @factory.line_string([point1_, point2_])
           binary_ = line1_.as_binary
           line2_ = @factory.parse_wkb(binary_)
-          assert_equal(line2_, line1_)
+          assert(line2_.eql?(line1_))
         end
         
         

data/tests/common/point_tests.rb

@@ -230,7 +230,6 @@ module RGeo
           point3_ = @factory.point(12, 12)
           assert_close_enough(point1_, point1_.intersection(point2_))
           int13_ = point1_.intersection(point3_)
-          assert_equal(::RGeo::Features::GeometryCollection, int13_.geometry_type)
           assert(int13_.is_empty?)
         end
         

data/tests/simple_spherical/tc_calculations.rb

@@ -0,0 +1,203 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the internal calculations for simple spherical
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'test/unit'
+require 'rgeo'
+
+
+module RGeo
+  module Tests  # :nodoc:
+    module SimpleSpherical  # :nodoc:
+      
+      class TestCalculations < ::Test::Unit::TestCase  # :nodoc:
+        
+        
+        def assert_close_enough(v1_, v2_)
+          diff_ = (v1_ - v2_).abs
+          # denom_ = (v1_ + v2_).abs
+          # diff_ /= denom_ if denom_ > 0.01
+          assert(diff_ < 0.00000001, "#{v1_} is not close to #{v2_}")
+        end
+        
+        
+        def test_point_eql
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          assert_equal(point1_, point2_)
+        end
+        
+        
+        def test_point_from_latlng
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.from_latlon(45, -45)
+          assert_close_enough(0.5, point1_.x)
+          assert_close_enough(-0.5, point1_.y)
+          assert_close_enough(::Math.sqrt(2) * 0.5, point1_.z)
+        end
+        
+        
+        def test_point_dot_one
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 1)
+          assert_close_enough(1.0, point1_ * point2_)
+        end
+        
+        
+        def test_point_dot_minusone
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(-1, -1, -1)
+          assert_close_enough(-1.0, point1_ * point2_)
+        end
+        
+        
+        def test_point_dot_zero
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, -1, 0)
+          assert_close_enough(0.0, point1_ * point2_)
+        end
+        
+        
+        def test_point_cross
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, -1, 0)
+          assert_close_enough(-1.0, (point1_ % point2_).z)
+        end
+        
+        
+        def test_point_cross_coincident
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          assert_nil(point1_ % point2_)
+        end
+        
+        
+        def test_point_cross_opposite
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(-1, 0, 0)
+          assert_nil(point1_ % point2_)
+        end
+        
+        
+        def test_arc_axis
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 1, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, -1, 0)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          assert_close_enough(-1.0, arc1_.axis.z)
+        end
+        
+        
+        def test_arc_axis2
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000001, 0)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          assert_close_enough(1.0, arc1_.axis.z)
+        end
+        
+        
+        def test_arc_intersects_point_off
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000002, 0)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000001, 0.1)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          assert_equal(false, arc1_.contains_point?(point3_))
+        end
+        
+        
+        def test_arc_intersects_point_between
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000002, 0)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000001, 0)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          assert_equal(true, arc1_.contains_point?(point3_))
+        end
+        
+        
+        def test_arc_intersects_point_endpoint
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0, 0)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(1, 0.000002, 0)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          assert_equal(true, arc1_.contains_point?(point1_))
+        end
+        
+        
+        def test_arc_intersects_arc_true
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, 0.1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, -0.1, 1)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(-0.1, 0, 1)
+          point4_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.1, 0, 1)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          arc2_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point3_, point4_)
+          assert_equal(true, arc1_.intersects_arc?(arc2_))
+        end
+        
+        
+        def test_arc_intersects_arc_parallel
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, 0.1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, -0.1, 1)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.1, 0.1, 1)
+          point4_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.1, -0.1, 1)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          arc2_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point3_, point4_)
+          assert_equal(false, arc1_.intersects_arc?(arc2_))
+        end
+        
+        
+        def test_arc_intersects_arc_separated_tee
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, 0.1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, -0.1, 1)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.1, 0, 1)
+          point4_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.2, 0, 1)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          arc2_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point3_, point4_)
+          assert_equal(false, arc1_.intersects_arc?(arc2_))
+        end
+        
+        
+        def test_arc_intersects_arc_connected_tee
+          point1_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, 0.1, 1)
+          point2_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, -0.1, 1)
+          point3_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0, 0, 1)
+          point4_ = ::RGeo::Geography::SimpleSpherical::PointXYZ.new(0.1, 0, 1)
+          arc1_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point1_, point2_)
+          arc2_ = ::RGeo::Geography::SimpleSpherical::ArcXYZ.new(point3_, point4_)
+          assert_equal(true, arc1_.intersects_arc?(arc2_))
+        end
+        
+        
+      end
+      
+    end
+  end
+end

data/tests/simple_spherical/tc_line_string.rb

@@ -0,0 +1,231 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the simple spherical point implementation
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'test/unit'
+require 'rgeo'
+
+
+module RGeo
+  module Tests  # :nodoc:
+    module SimpleSpherical  # :nodoc:
+      
+      class TestLineString < ::Test::Unit::TestCase  # :nodoc:
+        
+        
+        def setup
+          @factory = ::RGeo::Geography.simple_spherical
+        end
+        
+        
+        def _test_creation_success
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert_not_nil(line1_)
+          assert_equal(::RGeo::Features::LineString, line1_.geometry_type)
+          assert_equal(2, line1_.num_points)
+          assert_equal(point1_, line1_.point_n(0))
+          assert_equal(point2_, line1_.point_n(1))
+          line2_ = @factory.line_string([point1_, point2_, point3_])
+          assert_not_nil(line2_)
+          assert_equal(::RGeo::Features::LineString, line2_.geometry_type)
+          assert_equal(3, line2_.num_points)
+          assert_equal(point1_, line2_.point_n(0))
+          assert_equal(point2_, line2_.point_n(1))
+          assert_equal(point3_, line2_.point_n(2))
+          line3_ = @factory.line_string([point1_, point1_])
+          assert_not_nil(line3_)
+          assert_equal(::RGeo::Features::LineString, line3_.geometry_type)
+          assert_equal(2, line3_.num_points)
+          assert_equal(point1_, line3_.point_n(0))
+          assert_equal(point1_, line3_.point_n(1))
+          line4_ = @factory.line_string([])
+          assert_not_nil(line4_)
+          assert_equal(::RGeo::Features::LineString, line4_.geometry_type)
+          assert_equal(0, line4_.num_points)
+        end
+        
+        
+        def _test_creation_line_string
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 1)
+          line1_ = @factory.line_string([point1_, point2_, point3_])
+          assert_not_nil(line1_)
+          assert(::RGeo::Features::LineString === line1_)
+          assert(!(::RGeo::Features::LinearRing === line1_))
+          assert(!(::RGeo::Features::Line === line1_))
+          assert_equal(::RGeo::Features::LineString, line1_.geometry_type)
+        end
+        
+        
+        def test_creation_linear_ring
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.linear_ring([point1_, point2_, point3_, point1_])
+          assert_not_nil(line1_)
+          assert(line1_.is_ring?)
+          assert(::RGeo::Features::LinearRing === line1_)
+          assert_equal(::RGeo::Features::LinearRing, line1_.geometry_type)
+          line2_ = @factory.linear_ring([point1_, point2_, point3_])
+          assert_not_nil(line2_)
+          assert(line2_.is_ring?)
+          assert(::RGeo::Features::LinearRing === line2_)
+          assert_equal(4, line2_.num_points)
+          assert_equal(::RGeo::Features::LinearRing, line2_.geometry_type)
+        end
+        
+        
+        def _test_creation_line
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line(point1_, point2_)
+          assert_not_nil(line1_)
+          assert(::RGeo::Features::Line === line1_)
+          assert_equal(::RGeo::Features::Line, line1_.geometry_type)
+        end
+        
+        
+        def test_creation_errors
+          point1_ = @factory.point(0, 0)
+          collection_ = point1_.boundary
+          line1_ = @factory.line_string([point1_])
+          assert_nil(line1_)
+          line2_ = @factory.line_string([point1_, collection_])
+          assert_nil(line2_)
+        end
+        
+        
+        def test_wkt_creation
+          line1_ = @factory.parse_wkt('LINESTRING(21 22, 11 12)')
+          assert_equal(@factory.point(21, 22), line1_.point_n(0))
+          assert_equal(@factory.point(11, 12), line1_.point_n(1))
+          assert_equal(2, line1_.num_points)
+          line2_ = @factory.parse_wkt('LINESTRING(-1 -1, 21 22, 11 12, -1 -1)')
+          assert_equal(@factory.point(-1, -1), line2_.point_n(0))
+          assert_equal(@factory.point(21, 22), line2_.point_n(1))
+          assert_equal(@factory.point(11, 12), line2_.point_n(2))
+          assert_equal(@factory.point(-1, -1), line2_.point_n(3))
+          assert_equal(4, line2_.num_points)
+        end
+        
+        
+        def test_clone
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          line2_ = line1_.clone
+          assert(line1_.eql?(line2_))
+          assert_equal(2, line2_.num_points)
+          assert(point1_.eql?(line2_.point_n(0)))
+          assert(point2_.eql?(line2_.point_n(1)))
+        end
+        
+        
+        def test_type_check
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line_ = @factory.line_string([point1_, point2_])
+          assert(::RGeo::Features::Geometry.check_type(line_))
+          assert(!::RGeo::Features::Point.check_type(line_))
+          assert(!::RGeo::Features::GeometryCollection.check_type(line_))
+          assert(::RGeo::Features::Curve.check_type(line_))
+          assert(::RGeo::Features::LineString.check_type(line_))
+          assert(!::RGeo::Features::LinearRing.check_type(line_))
+        end
+        
+        
+        def test_as_text_wkt_round_trip
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          text_ = line1_.as_text
+          line2_ = @factory.parse_wkt(text_)
+          assert(line2_.eql?(line1_))
+        end
+        
+        
+        def test_as_binary_wkb_round_trip
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          binary_ = line1_.as_binary
+          line2_ = @factory.parse_wkb(binary_)
+          assert(line2_.eql?(line1_))
+        end
+        
+        
+        def test_empty_as_text_wkt_round_trip
+          line1_ = @factory.line_string([])
+          text_ = line1_.as_text
+          line2_ = @factory.parse_wkt(text_)
+          assert(line2_.is_empty?)
+        end
+        
+        
+        def test_empty_as_binary_wkb_round_trip
+          line1_ = @factory.line_string([])
+          binary_ = line1_.as_binary
+          line2_ = @factory.parse_wkb(binary_)
+          assert(line2_.is_empty?)
+        end
+        
+        
+        def test_dimension
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert_equal(1, line1_.dimension)
+        end
+        
+        
+        def test_is_empty
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert(!line1_.is_empty?)
+          line2_ = @factory.line_string([])
+          assert(line2_.is_empty?)
+        end
+        
+        
+      end
+      
+    end
+  end
+end

data/tests/simple_spherical/tc_point.rb

@@ -144,7 +144,6 @@ module RGeo
         def test_boundary
           point_ = @factory.point(11, 12)
           boundary_ = point_.boundary
-          assert_equal(::RGeo::Features::GeometryCollection, boundary_.geometry_type)
           assert(boundary_.is_empty?)
         end
         
@@ -153,8 +152,40 @@ module RGeo
           point1_ = @factory.point(11, 12)
           point2_ = @factory.point(11, 12)
           point3_ = @factory.point(13, 12)
-          assert_equal(point1_, point2_)
-          assert_not_equal(point1_, point3_)
+          assert(point1_.equals?(point2_))
+          assert(point1_ == point2_)
+          assert(point1_.eql?(point2_))
+          assert(!point1_.equals?(point3_))
+          assert(point1_ != point3_)
+          assert(!point1_.eql?(point3_))
+        end
+        
+        
+        def test_convex_hull
+          point_ = @factory.point(11, 12)
+          assert_equal(point_, point_.convex_hull)
+        end
+        
+        
+        def test_latlon
+          point_ = @factory.point(21, -22)
+          assert_equal(21, point_.longitude)
+          assert_equal(-22, point_.latitude)
+        end
+        
+        
+        def test_srid
+          point_ = @factory.point(11, 12)
+          assert_equal(4326, point_.srid)
+        end
+        
+        
+        def test_distance
+          point1_ = @factory.point(0, 10)
+          point2_ = @factory.point(0, 10)
+          point3_ = @factory.point(0, 40)
+          assert_in_delta(0, point1_.distance(point2_), 0.0001)
+          assert_in_delta(::Math::PI / 6.0 * ::RGeo::Geography::SimpleSpherical::RADIUS, point1_.distance(point3_), 0.0001)
         end
         
         

data/tests/tc_oneoff.rb

@@ -46,6 +46,7 @@ module RGeo
       
       def setup
         @mercator_factory = ::RGeo::Geography.simple_mercator
+        @spherical_factory = ::RGeo::Geography.simple_spherical
         @geos_factory = ::RGeo::Geos.factory(:srid => 4326)
         @entity_factory = ::RGeo::GeoJSON::EntityFactory.instance
       end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 11
-  version: 0.1.11
+  - 12
+  version: 0.1.12
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-21 00:00:00 -07:00
+date: 2010-10-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -117,6 +117,8 @@ files:
 - tests/simple_mercator/tc_point.rb
 - tests/simple_mercator/tc_polygon.rb
 - tests/simple_mercator/tc_window.rb
+- tests/simple_spherical/tc_calculations.rb
+- tests/simple_spherical/tc_line_string.rb
 - tests/simple_spherical/tc_point.rb
 - tests/tc_geojson.rb
 - tests/tc_oneoff.rb
@@ -196,6 +198,8 @@ test_files:
 - tests/simple_mercator/tc_point.rb
 - tests/simple_mercator/tc_polygon.rb
 - tests/simple_mercator/tc_window.rb
+- tests/simple_spherical/tc_calculations.rb
+- tests/simple_spherical/tc_line_string.rb
 - tests/simple_spherical/tc_point.rb
 - tests/tc_geojson.rb
 - tests/tc_oneoff.rb