rgeo 0.2.9 → 0.3.0

data/History.rdoc

@@ -1,3 +1,14 @@
+=== 0.3.0 / 2011-05-23
+
+* RGeo can now use GEOS via the ffi-geos gem, in addition to RGeo's built-in C integration. The ffi-geos integration is experimental right now, since ffi-geos is still in early beta. In particular, I do not recommend using it in JRuby yet (as of JRuby 1.6.1), because an apparent JRuby bug (JRUBY-5813) causes intermittent segfaults. However, once the issue is resolved (soon, I hope, since I've already submitted a patch to the JRuby team), we should have GEOS functional on JRuby.
+* It is now possible to add methods to geometry objects "globally". This was not possible previously because there is no global base class; however, there is now a mechanism to specify mixins that all implementations are expected to include.
+* Added RGeo::Feature::Type.supertype and each_immediate_subtype.
+* POSSIBLE INCOMPATIBLE CHANGE: Taking the boundary of a GEOS GeometryCollection now returns nil. It used to return an empty GeometryCollection, regardless of the contents of the original collection. GeometryCollection subclasses like MultiPoint, however, do have proper boundaries.
+* Renamed the lenient_multi_polygon_assertions GEOS factory parameter to uses_lenient_multi_polygon_assertions. The older name will continue to work.
+* The GEOS buffer_resolution and uses_lenient_multi_polygon_assertions options are now exposed via properties.
+* The RGeo::Feature::Polygon module incorrectly included Enumerable. Fixed.
+* Several of the implementations included some extraneous (and nonfunctional) methods because they included the wrong modules. Fixed.
+
 === 0.2.9 / 2011-04-25
 
 * INCOMPATIBLE CHANGE: mutator methods for the configurations of the WKRep parsers and generators have been removed. Create a new parser/generator if you need to change behavior.

data/README.rdoc

@@ -46,8 +46,8 @@ RGeo is known to work with the following Ruby implementations:
 * Standard "MRI" Ruby 1.8.7 or later. (1.9.2 or later preferred.)
 * Rubinius 1.1 or later.
 * Partial support for JRuby 1.5 or later, but a bunch of features are
-  missing because GEOS and Proj are not available from Java. We plan on
-  integrating with JTS or possibly ffi-geos in the future.
+  missing or not yet stable because GEOS and Proj integration is not
+  yet stable in JRuby. This is high-priority ongoing work.
 
 Some features also require the following:
 
@@ -93,8 +93,8 @@ installation prefix directory using the "--with-proj-dir" option.
 The RGeo suite of tools is evolving rapidly. The current to-do list for
 the core library includes:
 
+* Better JRuby support.
 * Ellipsoidal geography implementation, possibly utilizing geographiclib.
-* JRuby support via the JTS library, or possibly via ffi-geos.
 * Windows build support.
 
 Each of the current add-on modules also has its own feature roadmap, and

data/Spatial_Programming_With_RGeo.rdoc

@@ -1,7 +1,7 @@
 = An Introduction to Spatial Programming With RGeo
 
 * by Daniel Azuma
-* version 0.3 (17 Feb 2011)
+* version 0.4 (23 May 2011)
 
 == Introduction
 
@@ -38,7 +38,7 @@ Fortunately, a number of software libraries and organizations now exist to promo
 
 Visualization tools have advanced considerably in recent years. Mapping services such as {Google Maps}[http://maps.google.com/] and {Bing Maps}[http://www.bing.com/maps/] now have extensive API support for developing mapping applications. An open mapping service, {OpenStreetMap}[http://www.openstreetmap.org/], has also been launched and is gaining momentum. In addition, tools which let you serve your own map data, such as {OpenLayers}[http://openlayers.org/] and {PolyMaps}[http://polymaps.org/], have also appeared.
 
-Most major relational databases now support spatial extensions. The {MySQL}[http://mysql.com/] database provides basic spatial column support out of the box. Third-party add-on libraries exist for {Sqlite3}[http://www.sqlite.org/] and {PostgreSQL}[http://www.postgresql.org/] in the form of {SpatiaLite}[http://www.gaia-gis.it/spatialite/] and {PostGIS}[http://www.postgis.org/], respectively. Commercial databases such as Oracle and Microsoft SQL Server also provide facilities for storing and querying spatial data. Spatial features are also appearing in non-relational data stores. {MongoDB}[http://www.mongodb.org/] recently introduced geospatial indexing, {Solr}[http://lucene.apache.org/solr/] is expected to support spatial queries in the next release of its Lucene-based search engine, and {Sphinx}[http://sphinxsearch.com/] also provides limited spatial search capabilities.
+Most major relational databases now support spatial extensions. The {MySQL}[http://mysql.com/] database provides basic spatial column support out of the box. Third-party add-on libraries exist for {Sqlite3}[http://www.sqlite.org/] and {PostgreSQL}[http://www.postgresql.org/] in the form of {SpatiaLite}[http://www.gaia-gis.it/spatialite/] and {PostGIS}[http://www.postgis.org/], respectively. Commercial databases such as Oracle and Microsoft SQL Server also provide facilities for storing and querying spatial data. Spatial features are also appearing in non-relational data stores. {MongoDB}[http://www.mongodb.org/] recently introduced geospatial indexing, {Solr}[http://lucene.apache.org/solr/] supports spatial queries in the latest release of its Lucene-based search engine, and {Sphinx}[http://sphinxsearch.com/] also provides limited spatial search capabilities.
 
 A variety of data services have also appeared. Geocoding, the process approximating a latitude/longitude coordinate from a street address, is now offered by most major mapping service vendors such as {Google}[http://code.google.com/apis/maps/documentation/geocoding/], {Microsoft}[http://www.microsoft.com/maps/developers/], and {Yahoo}[http://developer.yahoo.com/geo/placefinder/]. Place databases with geocoded business and major location listings are now also available from a variety of vendors. Several services, notably {SimpleGeo}[http://www.simplegeo.com/], have recently appeared for cloud-based storage and querying of custom location data.
 
@@ -48,9 +48,9 @@ Perhaps most important of all, however, are the organizations that have appeared
 
 === 1.3. Ruby Libraries and \RGeo
 
-Ruby developers have had access to a fair number of spatial tools, primarily integration libraries for external services. {Geokit}[http://geokit.rubyforge.org/] provides a common interface for querying geocoding services, and a basic ActiveRecord extension for simple spatial queries. {YM4R}[http://ym4r.rubyforge.org/] provides a simple interface for integrating the Google and Yahoo map visualization tools in a Ruby application. Finally, {GeoRuby}[http://georuby.rubyforge.org/] provides classes for basic spatial data types such as points, lines, and polygons, and the add-on library {spatial_adapter}[http://github.com/fragility/spatial_adapter] hacks a few of the popular ActiveRecord database adapters to support spatial columns in the database.
+Ruby developers have had access to a fair number of spatial tools, primarily integration libraries for external services. {Geokit}[http://geokit.rubyforge.org/] and {Geocoder}[http://www.rubygeocoder.com/] provide a common interfaces for querying geocoding services, and basic ActiveRecord extensions for simple spatial queries. {YM4R}[http://ym4r.rubyforge.org/] provides a simple interface for integrating the Google and Yahoo map visualization tools in a Ruby application. Finally, {GeoRuby}[http://georuby.rubyforge.org/] provides classes for basic spatial data types such as points, lines, and polygons, and the add-on library {spatial_adapter}[http://github.com/fragility/spatial_adapter] hacks a few of the popular ActiveRecord database adapters to support spatial columns in the database.
 
-In this document, we will cover {RGeo}[http://github.com/dazuma/rgeo], a new spatial data library for Ruby that provides a complete and robust implementation of the standard OGC spatial data types and operations. It covers some of the same functionality as GeoRuby and spatial_adapter. However, where GeoRuby implements only a minimal subset of the OGC feature interfaces, \RGeo supports the entire specification, as well as providing many features and extensions not available with the older libraries.
+In this document, we will cover {RGeo}[http://github.com/dazuma/rgeo], a recent spatial data library for Ruby that provides a complete and robust implementation of the standard OGC spatial data types and operations. It covers some of the same functionality as GeoRuby and spatial_adapter. However, where GeoRuby implements only a minimal subset of the OGC feature interfaces, \RGeo supports the entire specification, as well as providing many features and extensions not available with the older libraries.
 
 \RGeo comprises several libraries, distributed as gems: a core library, and a suite of optional add-on modules. The core library, distributed as the {rgeo}[http://github.com/dazuma/rgeo] gem, includes the spatial data implementation itself. Currently available add-on modules include {rgeo-geojson}[http://github.com/dazuma/rgeo-geojson], which reads and writes the {GeoJSON}[http://www.geojson.org/] format, and {rgeo-shapefile}[http://github.com/dazuma/rgeo-shapefile], which reads ESRI shapefiles. A number of ActiveRecord adapters also utilize \RGeo to communicate with spatial databases; these include {mysqlspatial}[http://github.com/dazuma/activerecord-mysqlspatial-adapter], {mysql2spatial}[http://github.com/dazuma/activerecord-mysql2spatial-adapter], {spatialite}[http://github.com/dazuma/activerecord-spatialite-adapter], and {postgis}[http://github.com/dazuma/activerecord-postgis-adapter].
 
@@ -62,7 +62,7 @@ This section will cover the standard types of spatial data used in geospatial ap
 
 The Open Geospatial Consortium (OGC) defines and publishes a specification entitled "{Geographic information -- Simple feature access}[http://www.opengeospatial.org/standards/sfa]", which defines, among other things, a set of spatial data types and operations that can be done on them. This standard, which we will refer to as the Simple Features Specification (SFS), defines the core types and interfaces used by most spatial applications and databases. Although more recent versions of the spec are now available, most current implementations, including \RGeo, follow version 1.1 of the SFS, and this is the specification we will cover here.
 
-A "feature" in the SFS is a geometric object in 2 or 3 dimensional space. These objects can be points, lines, curves, surfaces, and polygons-- in general, most 0, 1, or 2 dimensional objects are supported. Each of these objects is identified by coordinates (X, Y, and sometimes Z), and has an object-oriented interface associated with it, defining a set of operations that can be done. In \RGeo, these interfaces exist as modules in the RGeo::Feature namespace.
+A "feature" in the SFS is a geometric object in 2 or 3 dimensional space. These objects can be points, lines, curves, surfaces, and polygons-- in general, most 0, 1, or 2 dimensional objects are supported. Each of these objects is identified by coordinates (X, Y, and sometimes Z), and has an object-oriented interface associated with it, defining a set of operations that can be performed. In \RGeo, these interfaces exist as modules in the RGeo::Feature namespace.
 
 We will quickly cover the types of geometric objects supported, and then discuss how to use \RGeo to create and manipulate spatial data as Ruby objects.
 
@@ -242,10 +242,10 @@ Several size and distance calculations are available. You can compute the distan
 The SFS defines two serialization schemes for geometric objects, known as the WKT (well-known text) and WKB (well-known binary) formats. The WKT is often used for textual display and transmission of a geometric object, while the WKB is sometimes used as an internal data format by spatial databases. Geometric objects in \RGeo define the <tt>as_text</tt> and <tt>as_binary</tt> methods to serialize the object into a data string, while \RGeo factories provide <tt>parse_wkt</tt> and <tt>parse_wkb</tt> methods to reconstruct geometric objects from their serialized form.
 
  p00 = factory.point(0, 0)
- p00.as_text                     # returns "Point (0.0 0.0)"
+ p00.as_text                     # returns "POINT (0.0 0.0)"
  p10 = factory.point(1, 0)
  line = factory.line(p00, p10)
- line.as_text                    # returns "LineString (0.0 0.0, 1.0 0.0)"
+ line.as_text                    # returns "LINESTRING (0.0 0.0, 1.0 0.0)"
  p = factory.parse_wkt('POINT (3 4)')
  p.x                             # returns 3.0
 
@@ -329,7 +329,7 @@ Under most circumstances, when you're working with geographic data in \RGeo, you
 
 === 4.5. Spatial Reference Systems and the EPSG Dataset
 
-The OGC also defines a syntax for specifying coordinate systems, the {Coordinate Transformation Services Specification}[http://www.opengeospatial.org/standards/ct]. This specification defines both an object model and a well-known text representation for coordinate systems and transformations. \RGeo also provides basic support for this specification; you can attach an OGC coordinate system specification to a factory to indicate the coordinate system. However, if you want \RGeo to automatically convert spatial data between coordinate systems, you must use Proj4 syntax.
+The OGC also defines a syntax for specifying coordinate systems, the {Coordinate Transformation Services Specification}[http://www.opengeospatial.org/standards/ct]. This specification defines both an object model and a well-known text representation for coordinate systems and transformations. \RGeo also provides basic support for this specification; you can attach an OGC coordinate system specification to a factory to indicate the coordinate system. However, if you want \RGeo to convert spatial data between coordinate systems, you must use Proj4 syntax.
 
 Finally, there also exists a <i>de facto</i> standard database of coordinate systems and related parameters, published by EPSG (now the OGP Geomatics Committee). This is a set of coordinate systems, each tagged with a well-known ID number, including geographic and projected systems. You can browse this database, including both OGC and Proj4 representations, at http://www.spatialreference.org/. This database is also included as a table in many popular spatial databases including PostGIS and SpatiaLite. Typically, the EPSG number is used as the SRID identifying the coordinate system for geometric objects stored in the database.
 
@@ -411,6 +411,16 @@ PostGIS uses as its internal format a variant of WKB known as EWKB. This variant
 * *spatialite*: Subclasses the sqlite3 adapter and adds support for the SpatiaLite extension. Available as the <b>activerecord-spatialite-adapter</b> gem.
 * *postgis*: Subclasses the postgresql adapter and adds support for the PostGIS extension. Available as the <b>activerecord-postgis-adapter</b> gem.
 
+=== 5.6. Commercial SQL Databases and Non-SQL Databases
+
+Major commercial relational databases also include various levels of support for the OGC SQL specification. Recent versions of the venerable Oracle database include {Oracle Spatial}[http://www.oracle.com/technetwork/database/options/spatial/index.html], and Microsoft's latest SQL Server also includes {spatial data tools}[http://www.microsoft.com/sqlserver/2008/en/us/spatial-data.aspx]. I have not had a chance to evaluate the spatial tools in these commercial databases, though I have heard them described as "powerful, but moody". \RGeo does not yet have direct ActiveRecord support for Oracle or SQL Server spatial.
+
+Several "NoSQL" databases also provide various degrees of limited support for geospatial data. Because these databases intentionally eschew the SQL standard, there is no OGC-defined standard interface for these databases, and so you will need to study the individual database's documentation to get an idea of the capabilities and API. \RGeo does not yet provide direct integration support for non-relational databases, but in most cases, it should not be too difficult to write glue code yourself.
+
+{MongoDB}[http://www.mongodb.org/] provides limited support for storing and indexing point data. In the current stable release series (1.8.x), you can store a point field as a longitude-latitude pair, and perform basic proximity and bounds searches. It does not support LineString or Polygon data. As far as I can determine, MongoDB uses a simple indexing system based on geo-hashing, which also limits its ability to support non-point data.
+
+{GeoCouch}[http://github.com/couchbase/geocouch] is an addition to {CouchDB}[http://couchdb.apache.org/] that provides an r-tree-based spatial index for point data. I have not studied it much, but it also appears to be limited to point data.
+
 == 6. Location Service Integration
 
 When writing a location-aware application, you will often need to interact with external sources of data and external location-based services. \RGeo provides several tools to facilitate this data transfer.
@@ -438,3 +448,4 @@ At the time of this writing, a number of open source geospatial tools and librar
 * Version 0.1 / 5 Dec 2010: Initial draft
 * Version 0.2 / 7 Dec 2010: More code examples and other minor updates
 * Version 0.3 / 17 Feb 2011: Further minor clarifications and fixes, and coverage of features in newer \RGeo releases
+* Version 0.4 / 23 May 2011: Minor updates to keep up with new releases

data/Version

@@ -1 +1 @@
-0.2.9
+0.3.0

data/ext/geos_c_impl/factory.c

@@ -246,6 +246,7 @@ RGeo_Globals* rgeo_init_geos_factory()
   VALUE rgeo_module = rb_define_module("RGeo");
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
   globals->feature_module = rb_define_module_under(rgeo_module, "Feature");
+  globals->global_mixins = rb_const_get_at(rb_const_get_at(globals->feature_module, rb_intern("MixinCollection")), rb_intern("GLOBAL"));
   
   // Add C methods to the factory.
   VALUE geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));

data/ext/geos_c_impl/factory.h

@@ -51,6 +51,7 @@ RGEO_BEGIN_C
 */
 typedef struct {
   VALUE feature_module;
+  VALUE global_mixins;
   VALUE feature_geometry;
   VALUE feature_point;
   VALUE feature_line_string;

data/ext/geos_c_impl/geometry.c

@@ -191,12 +191,9 @@ static VALUE method_geometry_boundary(VALUE self)
   if (self_geom) {
     GEOSContextHandle_t geos_context = self_data->geos_context;
     GEOSGeometry* boundary = GEOSBoundary_r(geos_context, self_geom);
-    // GEOS returns NULL for the boundary of an empty collection.
-    // Replace that with an empty collection.
-    if (!boundary) {
-      boundary = GEOSGeom_createCollection_r(geos_context, GEOS_GEOMETRYCOLLECTION, NULL, 0);
+    if (boundary) {
+      result = rgeo_wrap_geos_geometry(self_data->factory, boundary, Qnil);
     }
-    result = rgeo_wrap_geos_geometry(self_data->factory, boundary, Qnil);
   }
   return result;
 }
@@ -655,6 +652,8 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   VALUE geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
   globals->geos_geometry = geos_geometry_class;
   globals->feature_geometry = rb_const_get_at(globals->feature_module, rb_intern("Geometry"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_geometry, geos_geometry_class);
   
   rb_define_alloc_func(geos_geometry_class, alloc_geometry);
   rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);

data/ext/geos_c_impl/geometry_collection.c

@@ -390,15 +390,30 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   VALUE geos_geometry_collection_class = rb_define_class_under(globals->geos_module, "GeometryCollectionImpl", globals->geos_geometry);
   globals->geos_geometry_collection = geos_geometry_collection_class;
   globals->feature_geometry_collection = rb_const_get_at(globals->feature_module, rb_intern("GeometryCollection"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_geometry_collection, geos_geometry_collection_class);
+  
   VALUE geos_multi_point_class = rb_define_class_under(globals->geos_module, "MultiPointImpl", geos_geometry_collection_class);
   globals->geos_multi_point = geos_multi_point_class;
   globals->feature_multi_point = rb_const_get_at(globals->feature_module, rb_intern("MultiPoint"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_multi_point, geos_multi_point_class);
+  
   VALUE geos_multi_line_string_class = rb_define_class_under(globals->geos_module, "MultiLineStringImpl", geos_geometry_collection_class);
   globals->geos_multi_line_string = geos_multi_line_string_class;
   globals->feature_multi_line_string = rb_const_get_at(globals->feature_module, rb_intern("MultiLineString"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    rb_const_get_at(globals->feature_module, rb_intern("MultiCurve")), geos_multi_line_string_class);
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_multi_line_string, geos_multi_line_string_class);
+  
   VALUE geos_multi_polygon_class = rb_define_class_under(globals->geos_module, "MultiPolygonImpl", geos_geometry_collection_class);
   globals->geos_multi_polygon = geos_multi_polygon_class;
   globals->feature_multi_polygon = rb_const_get_at(globals->feature_module, rb_intern("MultiPolygon"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    rb_const_get_at(globals->feature_module, rb_intern("MultiSurface")), geos_multi_polygon_class);
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_multi_polygon, geos_multi_polygon_class);
   
   // Methods for GeometryCollectionImpl
   rb_define_module_function(geos_geometry_collection_class, "create", cmethod_geometry_collection_create, 2);

data/ext/geos_c_impl/line_string.c

@@ -447,12 +447,22 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   VALUE geos_line_string_class = rb_define_class_under(globals->geos_module, "LineStringImpl", globals->geos_geometry);
   globals->geos_line_string = geos_line_string_class;
   globals->feature_line_string = rb_const_get_at(globals->feature_module, rb_intern("LineString"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    rb_const_get_at(globals->feature_module, rb_intern("Curve")), geos_line_string_class);
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_line_string, geos_line_string_class);
+  
   VALUE geos_linear_ring_class = rb_define_class_under(globals->geos_module, "LinearRingImpl", geos_line_string_class);
   globals->geos_linear_ring = geos_linear_ring_class;
   globals->feature_linear_ring = rb_const_get_at(globals->feature_module, rb_intern("LinearRing"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_linear_ring, geos_linear_ring_class);
+  
   VALUE geos_line_class = rb_define_class_under(globals->geos_module, "LineImpl", geos_line_string_class);
   globals->geos_line = geos_line_class;
   globals->feature_line = rb_const_get_at(globals->feature_module, rb_intern("Line"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_line, geos_line_class);
   
   rb_define_module_function(geos_line_string_class, "create", cmethod_create_line_string, 2);
   rb_define_module_function(geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);

data/ext/geos_c_impl/point.c

@@ -154,6 +154,8 @@ void rgeo_init_geos_point(RGeo_Globals* globals)
   VALUE geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", globals->geos_geometry);
   globals->geos_point = geos_point_class;
   globals->feature_point = rb_const_get_at(globals->feature_module, rb_intern("Point"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_point, geos_point_class);
   
   rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
   

data/ext/geos_c_impl/polygon.c

@@ -223,6 +223,10 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals)
   VALUE geos_polygon_class = rb_define_class_under(globals->geos_module, "PolygonImpl", globals->geos_geometry);
   globals->geos_polygon = geos_polygon_class;
   globals->feature_polygon = rb_const_get_at(globals->feature_module, rb_intern("Polygon"));
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    rb_const_get_at(globals->feature_module, rb_intern("Surface")), geos_polygon_class);
+  rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,
+    globals->feature_polygon, geos_polygon_class);
   
   rb_define_module_function(geos_polygon_class, "create", cmethod_create, 3);
   

data/lib/rgeo/cartesian/feature_classes.rb

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Spherical geography feature classes
+# Cartesian feature classes
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -46,19 +46,9 @@ module RGeo
       include ::RGeo::ImplHelper::BasicGeometryMethods
       include ::RGeo::ImplHelper::BasicPointMethods
       include ::RGeo::Cartesian::GeometryMethods
+      include ::RGeo::Cartesian::PointMethods
       
-      
-      def distance(rhs_)
-        rhs_ = ::RGeo::Feature.cast(rhs_, @factory)
-        case rhs_
-        when PointImpl
-          dx_ = @x - rhs_.x
-          dy_ = @y - rhs_.y
-          ::Math.sqrt(dx_ * dx_ + dy_ * dy_)
-        else
-          super
-        end
-      end
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
       
       
     end
@@ -73,6 +63,8 @@ module RGeo
       include ::RGeo::Cartesian::GeometryMethods
       include ::RGeo::Cartesian::LineStringMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
+      
       
     end
     
@@ -87,6 +79,8 @@ module RGeo
       include ::RGeo::Cartesian::GeometryMethods
       include ::RGeo::Cartesian::LineStringMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
+      
       
     end
     
@@ -94,13 +88,15 @@ module RGeo
     class LinearRingImpl  # :nodoc:
       
       
-      include ::RGeo::Feature::Line
+      include ::RGeo::Feature::LinearRing
       include ::RGeo::ImplHelper::BasicGeometryMethods
       include ::RGeo::ImplHelper::BasicLineStringMethods
       include ::RGeo::ImplHelper::BasicLinearRingMethods
       include ::RGeo::Cartesian::GeometryMethods
       include ::RGeo::Cartesian::LineStringMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
+      
       
     end
     
@@ -113,6 +109,8 @@ module RGeo
       include ::RGeo::ImplHelper::BasicPolygonMethods
       include ::RGeo::Cartesian::GeometryMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
+      
       
     end
     
@@ -125,6 +123,8 @@ module RGeo
       include ::RGeo::ImplHelper::BasicGeometryCollectionMethods
       include ::RGeo::Cartesian::GeometryMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
+      
       
     end
     
@@ -132,12 +132,14 @@ module RGeo
     class MultiPointImpl  # :nodoc:
       
       
-      include ::RGeo::Feature::GeometryCollection
+      include ::RGeo::Feature::MultiPoint
       include ::RGeo::ImplHelper::BasicGeometryMethods
       include ::RGeo::ImplHelper::BasicGeometryCollectionMethods
       include ::RGeo::ImplHelper::BasicMultiPointMethods
       include ::RGeo::Cartesian::GeometryMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
+      
       
     end
     
@@ -145,12 +147,14 @@ module RGeo
     class MultiLineStringImpl  # :nodoc:
       
       
-      include ::RGeo::Feature::GeometryCollection
+      include ::RGeo::Feature::MultiLineString
       include ::RGeo::ImplHelper::BasicGeometryMethods
       include ::RGeo::ImplHelper::BasicGeometryCollectionMethods
       include ::RGeo::ImplHelper::BasicMultiLineStringMethods
       include ::RGeo::Cartesian::GeometryMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
+      
       
     end
     
@@ -158,12 +162,14 @@ module RGeo
     class MultiPolygonImpl  # :nodoc:
       
       
-      include ::RGeo::Feature::GeometryCollection
+      include ::RGeo::Feature::MultiPolygon
       include ::RGeo::ImplHelper::BasicGeometryMethods
       include ::RGeo::ImplHelper::BasicGeometryCollectionMethods
       include ::RGeo::ImplHelper::BasicMultiPolygonMethods
       include ::RGeo::Cartesian::GeometryMethods
       
+      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
+      
       
     end
     

data/lib/rgeo/cartesian/feature_methods.rb

@@ -1,6 +1,6 @@
 # -----------------------------------------------------------------------------
 # 
-# Spherical geometry common methods
+# Cartesian common methods
 # 
 # -----------------------------------------------------------------------------
 # Copyright 2010 Daniel Azuma
@@ -55,6 +55,25 @@ module RGeo
     end
     
     
+    module PointMethods  # :nodoc:
+      
+      
+      def distance(rhs_)
+        rhs_ = ::RGeo::Feature.cast(rhs_, @factory)
+        case rhs_
+        when PointImpl
+          dx_ = @x - rhs_.x
+          dy_ = @y - rhs_.y
+          ::Math.sqrt(dx_ * dx_ + dy_ * dy_)
+        else
+          super
+        end
+      end
+      
+      
+    end
+    
+    
     module LineStringMethods  # :nodoc:
       
       

data/lib/rgeo/feature.rb

@@ -70,6 +70,7 @@ end
 
 # Implementation files
 require 'rgeo/feature/factory'
+require 'rgeo/feature/mixins'
 require 'rgeo/feature/types'
 require 'rgeo/feature/geometry'
 require 'rgeo/feature/point'

data/lib/rgeo/feature/curve.rb

@@ -74,9 +74,8 @@ module RGeo
     
     module Curve
       
-      extend Type
-      
       include Geometry
+      extend Type
       
       
       # === SFS 1.1 Description

data/lib/rgeo/feature/geometry_collection.rb

@@ -62,9 +62,9 @@ module RGeo
     
     module GeometryCollection
       
+      include Geometry
       extend Type
       
-      include Geometry
       include ::Enumerable
       
       

data/lib/rgeo/feature/line.rb

@@ -53,9 +53,9 @@ module RGeo
     
     module Line
       
-      extend Type
       
       include LineString
+      extend Type
       
       
     end