rgeo 0.1.10 → 0.1.11

data/History.rdoc

@@ -1,3 +1,16 @@
+=== 0.1.11 / 2010-10-21
+
+Further development and fixing in the geographic coordinate systems.
+
+Changes since 0.1.10:
+
+* API CHANGE: Factory#convert renamed to Factory#coerce.
+* Some implementations that inherit from RGeo::Features::Geometry (e.g. the Geography implementations) raised Unimplemented from operator implementations because they had aliased the wrong methods. Fixed.
+* Geos coercer didn't properly coerce "contained" elements in a compound geometry. Fixed.
+* The SimpleMercator and SimpleSpherical factories failed to properly check and coerce inputs into the typed collection methods. Fixed.
+* The options for the SimpleMercator factory were not documented and didn't work. Fixed.
+* A bunch of additional test cases and minor fixes for SimpleMercator and SimpleSpherical.
+
 === 0.1.10 / 2010-10-19
 
 Initial public release. This release is considered pre-alpha quality and is being released for experimentation and feedback. We are using it in production in a limited capacity at GeoPage, but we do not yet recommend general production deployment because there are a number of known bugs and incomplete areas, and many features and APIs are still in flux.

data/README.rdoc

@@ -8,6 +8,12 @@ storage systems such as PostGIS. It also provides a suite of useful tools
 for writing location-based applications using Ruby-based frameworks such
 as Ruby On Rails.
 
+IMPORTANT: RGeo is currently under development, and we consider it to be
+in a "pre-alpha" state. A number of features (such as Rails integration)
+are not yet complete, and there are numerous known bugs and holes in the
+test suite. We also expect the APIs to be in flux for a short while
+longer. Therefore, we do not yet recommend the use of RGeo in production.
+
 === Summary
 
 RGeo is a core component for writing location-based applications in the

data/Version

@@ -1 +1 @@
-0.1.10
+0.1.11

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("convert"), 1, obj);
+  VALUE object = rb_funcall(factory, rb_intern("coerce"), 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("convert"), 2, obj, Qtrue);
+  VALUE object = rb_funcall(globals->default_factory, rb_intern("coerce"), 2, obj, Qtrue);
   GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;

data/lib/rgeo/features/factory.rb

@@ -173,12 +173,12 @@ module RGeo
       end
       
       
-      # Convert an existing feature to a feature of the type created by
+      # Coerce 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 convert(original_, force_new_=false)
+      def coerce(original_, force_new_=false)
         nil
       end
       

data/lib/rgeo/features/geometry.rb

@@ -546,10 +546,32 @@ module RGeo
       end
       
       
-      alias_method :==, :equals?
-      alias_method :-, :difference
-      alias_method :+, :union
-      alias_method :*, :intersection
+      # Alias of the equals? method.
+      
+      def ==(rhs_)
+        equals?(rhs_)
+      end
+      
+      
+      # Alias of the difference method.
+      
+      def -(rhs_)
+        difference(rhs_)
+      end
+      
+      
+      # Alias of the union method.
+      
+      def +(rhs_)
+        union(rhs_)
+      end
+      
+      
+      # Alias of the intersection method.
+      
+      def *(rhs_)
+        intersection(rhs_)
+      end
       
       
     end

data/lib/rgeo/features/geometry_collection.rb

@@ -94,8 +94,18 @@ module RGeo
       end
       
       
-      alias_method :size, :num_geometries
-      alias_method :[], :geometry_n
+      # Alias of the num_geometries method.
+      
+      def size
+        num_geometries
+      end
+      
+      
+      # Alias of the geometry_n method.
+      
+      def [](n_)
+        geometry_n(n_)
+      end
       
       
       # Iterates over the geometries of this GeometryCollection.

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

@@ -44,8 +44,19 @@ module RGeo
       module GeometryCollectionMethods
         
         
+        def self._check_types(enum_, type_)
+          enum_.all? do |elem_|
+            case elem_
+            when type_ then true
+            when Features::GeometryCollection then _check_types(elem_, type_)
+            else false
+            end
+          end
+        end
+        
+        
         def _setup(elements_)
-          @elements = elements_.map{ |elem_| factory.convert(elem_) }
+          @elements = elements_.map{ |elem_| factory.coerce(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_.convert(obj_) : nil
+          obj_ ? factory_.coerce(obj_) : nil
         end
         
         
         def self.parse_wkb(str_, factory_)
           helper_factory_ = self.factory
           obj_ = helper_factory_ ? helper_factory_.parse_wkb(str_) : nil
-          obj_ ? factory_.convert(obj_) : nil
+          obj_ ? factory_.coerce(obj_) : nil
         end
         
         
         def self.unparse_wkt(obj_)
           helper_factory_ = self.factory
-          helper_factory_ ? helper_factory_.convert(obj_).as_text : nil
+          helper_factory_ ? helper_factory_.coerce(obj_).as_text : nil
         end
         
         
         def self.unparse_wkb(obj_)
           helper_factory_ = self.factory
-          helper_factory_ ? helper_factory_.convert(obj_).as_binary : nil
+          helper_factory_ ? helper_factory_.coerce(obj_).as_binary : nil
         end
         
         

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

@@ -45,7 +45,7 @@ module RGeo
         
         
         def _setup(points_)
-          @points = points_.map{ |elem_| factory.convert(elem_) }
+          @points = points_.map{ |elem_| factory.coerce(elem_) }
           _validate_geometry
         end
         

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

@@ -113,7 +113,7 @@ module RGeo
         
         def equals?(rhs_)
           return false unless rhs_.factory.is_a?(Factory)
-          rhs_ = factory.convert(rhs_)
+          rhs_ = factory.coerce(rhs_)
           case rhs_
           when Features::Point
             if @y == 90

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

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

data/lib/rgeo/geography/factories.rb

@@ -38,9 +38,6 @@ module RGeo
   
   module Geography
     
-    @simple_spherical = nil
-    @simple_mercator = nil
-    
     class << self
       
       
@@ -75,8 +72,8 @@ module RGeo
       # than those generated by, e.g., PostGIS (unless you direct PostGIS
       # to use spherical geodesics).
       
-      def simple_spherical(opts_={})  # :nodoc:
-        @simple_spherical ||= Geography::Factory.new(Geography::SimpleSpherical)
+      def simple_spherical(opts_={})
+        Geography::Factory.new(Geography::SimpleSpherical)
       end
       
       
@@ -123,9 +120,25 @@ module RGeo
       # describes the <i>actual</i> behavior of the common map
       # visualization APIs, so we've decided to fudge on this in the
       # interest of being true to our expected application use cases.
+      # 
+      # 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. 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 not specified.
       
       def simple_mercator(opts_={})
-        @simple_mercator ||= Geography::Factory.new(Geography::SimpleMercator, :buffer_resolution => opts_[:buffer_resolution])
+        Geography::Factory.new(Geography::SimpleMercator, :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions])
       end
       
       

data/lib/rgeo/geography/factory.rb

@@ -189,6 +189,8 @@ module RGeo
       # See ::RGeo::Features::Factory#multi_point
       
       def multi_point(elems_)
+        elems_ = _flatten(elems_, Features::Point)
+        return nil unless elems_
         @namespace.const_get(:MultiPointImpl).new(self, elems_) rescue nil
       end
       
@@ -196,6 +198,8 @@ module RGeo
       # See ::RGeo::Features::Factory#multi_line_string
       
       def multi_line_string(elems_)
+        elems_ = _flatten(elems_, Features::LineString)
+        return nil unless elems_
         @namespace.const_get(:MultiLineStringImpl).new(self, elems_) rescue nil
       end
       
@@ -203,13 +207,15 @@ module RGeo
       # See ::RGeo::Features::Factory#multi_polygon
       
       def multi_polygon(elems_)
+        elems_ = _flatten(elems_, Features::Polygon)
+        return nil unless elems_
         @namespace.const_get(:MultiPolygonImpl).new(self, elems_) rescue nil
       end
       
       
-      # See ::RGeo::Features::Factory#convert
+      # See ::RGeo::Features::Factory#coerce
       
-      def convert(original_, force_new_=false)
+      def coerce(original_, force_new_=false)
         if self == original_.factory
           force_new_ ? original_.dup : original_
         else
@@ -217,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, original_.start_point, original_.end_point) rescue nil
+            @namespace.const_get(:LineImpl).new(self, coerce(original_.start_point), coerce(original_.end_point)) rescue nil
           when Features::LinearRing
-            @namespace.const_get(:LinearRingImpl).new(self, original_.points) rescue nil
+            @namespace.const_get(:LinearRingImpl).new(self, original_.points.map{ |g_| coerce(g_) }) rescue nil
           when Features::LineString
-            @namespace.const_get(:LineStringImpl).new(self, original_.points) rescue nil
+            @namespace.const_get(:LineStringImpl).new(self, original_.points.map{ |g_| coerce(g_) }) rescue nil
           when Features::Polygon
-            @namespace.const_get(:PolygonImpl).new(self, original_.exterior_ring, original_.interior_rings) rescue nil
+            @namespace.const_get(:PolygonImpl).new(self, coerce(original_.exterior_ring), original_.interior_rings.map{ |g_| coerce(g_) }) rescue nil
           when Features::MultiPoint
-            @namespace.const_get(:MultiPointImpl).new(self, original_.to_a) rescue nil
+            @namespace.const_get(:MultiPointImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
           when Features::MultiLineString
-            @namespace.const_get(:MultiLineStringImpl).new(self, original_.to_a) rescue nil
+            @namespace.const_get(:MultiLineStringImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
           when Features::MultiPolygon
-            @namespace.const_get(:MultiPolygonImpl).new(self, original_.to_a) rescue nil
+            @namespace.const_get(:MultiPolygonImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
           when Features::GeometryCollection
-            @namespace.const_get(:GeometryCollectionImpl).new(self, original_.to_a) rescue nil
+            @namespace.const_get(:GeometryCollectionImpl).new(self, original_.to_a.map{ |g_| coerce(g_) }) rescue nil
           else
             nil
           end
@@ -239,6 +245,21 @@ module RGeo
       end
       
       
+      def _flatten(elems_, type_, array_=[])
+        elems_.each do |elem_|
+          case elem_
+          when type_
+            array_ << elem_
+          when Features::GeometryCollection
+            return nil unless _flatten(elem_, type_, array_)
+          else
+            return nil
+          end
+        end
+        array_
+      end
+      
+      
     end
     
   end

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

@@ -46,7 +46,7 @@ module RGeo
         
         include Features::Point
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleMercator::GeometryMethods
         include Common::PointMethods
         
         
@@ -95,11 +95,11 @@ module RGeo
         
         include Features::LineString
         include Common::GeometryMethods
-        include GeometryMethods
-        include NCurveMethods
-        include CurveMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NCurveMethods
+        include SimpleMercator::CurveMethods
         include Common::LineStringMethods
-        include LineStringMethods
+        include SimpleMercator::LineStringMethods
         
         
         def initialize(factory_, points_)
@@ -121,11 +121,11 @@ module RGeo
         
         include Features::Line
         include Common::GeometryMethods
-        include GeometryMethods
-        include NCurveMethods
-        include CurveMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NCurveMethods
+        include SimpleMercator::CurveMethods
         include Common::LineStringMethods
-        include LineStringMethods
+        include SimpleMercator::LineStringMethods
         include Common::LinearRingMethods
         
         
@@ -148,11 +148,11 @@ module RGeo
         
         include Features::Line
         include Common::GeometryMethods
-        include GeometryMethods
-        include NCurveMethods
-        include CurveMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NCurveMethods
+        include SimpleMercator::CurveMethods
         include Common::LineStringMethods
-        include LineStringMethods
+        include SimpleMercator::LineStringMethods
         include Common::LineMethods
         
         
@@ -175,9 +175,9 @@ module RGeo
         
         include Features::Polygon
         include Common::GeometryMethods
-        include GeometryMethods
-        include NSurfaceMethods
-        include SurfaceMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NSurfaceMethods
+        include SimpleMercator::SurfaceMethods
         include Common::PolygonMethods
         
         
@@ -209,9 +209,9 @@ module RGeo
         
         include Features::GeometryCollection
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleMercator::GeometryMethods
         include Common::GeometryCollectionMethods
-        include GeometryCollectionMethods
+        include SimpleMercator::GeometryCollectionMethods
         
         
         def initialize(factory_, elements_)
@@ -233,9 +233,9 @@ module RGeo
         
         include Features::GeometryCollection
         include Common::GeometryMethods
-        include GeometryMethods
+        include SimpleMercator::GeometryMethods
         include Common::GeometryCollectionMethods
-        include GeometryCollectionMethods
+        include SimpleMercator::GeometryCollectionMethods
         include Common::MultiPointMethods
         
         
@@ -258,10 +258,10 @@ module RGeo
         
         include Features::GeometryCollection
         include Common::GeometryMethods
-        include GeometryMethods
-        include NCurveMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NCurveMethods
         include Common::GeometryCollectionMethods
-        include GeometryCollectionMethods
+        include SimpleMercator::GeometryCollectionMethods
         include Common::MultiLineStringMethods
         
         
@@ -284,10 +284,10 @@ module RGeo
         
         include Features::GeometryCollection
         include Common::GeometryMethods
-        include GeometryMethods
-        include NSurfaceMethods
+        include SimpleMercator::GeometryMethods
+        include SimpleMercator::NSurfaceMethods
         include Common::GeometryCollectionMethods
-        include GeometryCollectionMethods
+        include SimpleMercator::GeometryCollectionMethods
         include Common::MultiPolygonMethods
         
         

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

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

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

@@ -49,7 +49,7 @@ module RGeo
         def initialize(geography_factory_, opts_={})
           @geography_factory = geography_factory_
           if ::RGeo.const_defined?(:Geos) && Geos.supported?
-            @projection_factory = Geos.factory(:srid => 3857, :buffer_resolution => opts_[:buffer_resolution])
+            @projection_factory = Geos.factory(:srid => 3857, :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions])
           else
             @projection_factory = nil
           end

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

@@ -44,6 +44,67 @@ module RGeo
       RADIUS = 6371007.2
       
       
+      # Represents a point on the sphere in (x,y,z) coordinates instead
+      # of lat-lon. This form is often faster, more convenient, and more
+      # numerically stable for certain computations.
+      # 
+      # The coordinate system is a right-handed system where the z-axis
+      # goes through the north pole, the x-axis goes through the prime
+      # meridian, and the y-axis goes through +90 degrees longitude.
+      # 
+      # This object is also used to represent a great circle, as its axis
+      # of rotation.
+      
+      class PointXYZ
+        
+        def initialize(x_, y_, z_)
+          r_ = ::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_)
+          @x = x_ / r_
+          @y = y_ / r_
+          @z = z_ / r_
+        end
+        
+        
+        attr_reader :x
+        attr_reader :y
+        attr_reader :z
+        
+        
+        def latlon
+          lat_rad_ = ::Math.asin(@z)
+          lon_rad_ = ::Math.atan2(@y, @x) rescue 0.0
+          rpd_ = Common::Helper::RADIANS_PER_DEGREE
+          [lat_rad_ / rpd_, lon_rad_ / rpd_]
+        end
+        
+        
+        def *(rhs_)
+          @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
+        end
+        
+        
+        def %(rhs_)
+          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
+        end
+        
+        
+        def self.from_latlon(lat_, lon_)
+          rpd_ = Common::Helper::RADIANS_PER_DEGREE
+          lat_rad_ = rpd_ * lat_
+          lon_rad_ = rpd_ * lon_
+          z_ = ::Math.sin(lat_rad_)
+          r_ = ::Math.cos(lat_rad_)
+          x_ = ::Math.cos(lon_rad_) * r_
+          y_ = ::Math.sin(lon_rad_) * r_
+          new(x_, y_, z_)
+        end
+        
+      end
+      
+      
       module Calculations
         
         

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

@@ -65,6 +65,11 @@ module RGeo
         end
         
         
+        def xyz
+          @xyz ||= PointXYZ.from_latlon(@y, @x)
+        end
+        
+        
         def distance(rhs_)
           case rhs_
           when Features::Point