rgeo 0.3.1 → 0.3.2

data/History.rdoc

@@ -1,3 +1,12 @@
+=== 0.3.2 / 2011-08-11
+
+* Some objects can now be serialized and deserialized via Marshal or YAML. Supported objects include OGC coordinate systems, Proj4 coordinate systems, and WKRep parsers/generators. Factories and geometries will be supported shortly.
+* The GEOS CAPI implementation can now use prepared geometries to speed up certain operations. The GEOS FFI implementation will do the same shortly.
+* Calling dup on a Proj4 object caused a segfault. Fixed.
+* Fixed an exception in RGeo::Cartesian::BoundingBox#to_geometry. (Thanks to Travis Dempsey.)
+* WKTGenerator generated incorrect tag names for subtypes of LineString. Fixed.
+* Installation automatically finds the KyngChaos GEOS and Proj4 frameworks for Mac OS X. (Thanks to benchi.)
+
 === 0.3.1 / 2011-05-24
 
 * Running a == operator comparison between a geometry and a non-geometry caused an exception for some implementations. Fixed. (Reported by Daniel Hackney.)

data/README.rdoc

@@ -39,15 +39,18 @@ Several optional modules are currently available:
   * <b>activerecord-postgis-adapter</b>
 * and more to come...
 
+Need help? Join the rgeo-users google group at:
+http://groups.google.com/group/rgeo-users
+
 === Dependencies
 
 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 or not yet stable because GEOS and Proj integration is not
-  yet stable in JRuby. This is high-priority ongoing work.
+* Partial support for JRuby 1.6.3 or later. The FFI implementation of
+  GEOS is available (ffi-geos gem is required) but CAPI is not.
+  Proj4 support is expected in the future.
 
 Some features also require the following:
 
@@ -71,7 +74,10 @@ Install RGeo as a gem:
 
 Note: By default, the gem installation looks for the GEOS library in the
 following locations: <tt>/usr/local</tt>, <tt>/usr/local/geos</tt>,
-<tt>/opt/local</tt>, <tt>/opt/geos</tt>, <tt>/opt</tt>, <tt>/usr</tt>.
+<tt>/opt/local</tt>, <tt>/opt/geos</tt>, <tt>/opt</tt>, <tt>/usr</tt>,
+and <tt>/Library/Frameworks/GEOS.framework/unix</tt>. In other words,
+MacPorts, Homebrew, the Kyngchaos port, and building from source to
+/usr/local are supported out of the box.
 
 If GEOS has been installed in a different location, you must provide its
 installation prefix directory using the "--with-geos-dir" option. This
@@ -83,7 +89,8 @@ switch, from the switches interpreted by the gem command. For example:
 Similarly, the gem installation looks for the Proj4 library in the
 following locations by default: <tt>/usr/local</tt>,
 <tt>/usr/local/proj</tt>, <tt>/usr/local/proj4</tt>, <tt>/opt/local</tt>,
-<tt>/opt/proj</tt>, <tt>/opt/proj4</tt>, <tt>/opt</tt>, <tt>/usr</tt>.
+<tt>/opt/proj</tt>, <tt>/opt/proj4</tt>, <tt>/opt</tt>, <tt>/usr</tt>,
+and <tt>/Library/Frameworks/PROJ.framework/unix</tt>.
 
 If Proj4 is installed in a different location, you must provide its
 installation prefix directory using the "--with-proj-dir" option.
@@ -93,7 +100,7 @@ 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:
 
-* YAML and Marshal serialization support.
+* YAML and Marshal serialization support across all major entities.
 * Better JRuby support.
 * Ellipsoidal geography implementation, possibly utilizing geographiclib.
 * Windows build support.
@@ -102,7 +109,7 @@ Each of the current add-on modules also has its own feature roadmap, and
 we are planning on introducing more add-on modules, including:
 
 * GeoRSS and KML format support.
-* Integration with the SimpleGeo API.
+* Integration with third-party APIs.
 * Possible additional ActiveRecord adapters.
 
 === Development and support
@@ -115,6 +122,8 @@ Contributions are welcome. Fork the project on Github.
 
 Report bugs on Github issues at http://github.org/dazuma/rgeo/issues
 
+Support available on the rgeo-users google group at http://groups.google.com/group/rgeo-users
+
 Contact the author at dazuma at gmail dot com.
 
 === Acknowledgments
@@ -129,6 +138,9 @@ transformations. These libraries are maintained by the Open Source
 Geospatial Foundation; more information is available on OSGeo's web site
 (http://www.osgeo.org).
 
+JRuby support is made possible by the ffi-geos (and upcoming ffi-proj4)
+gems, by J Smith (http://github.com/dark-panda).
+
 === License
 
 Copyright 2010-2011 Daniel Azuma

data/Version

@@ -1 +1 @@
-0.3.1
+0.3.2

data/ext/geos_c_impl/extconf.rb

@@ -49,6 +49,7 @@ else
      '/opt/local/include',
      '/opt/geos/include',
      '/opt/include',
+     '/Library/Frameworks/GEOS.framework/unix/include',
      ::Config::CONFIG['includedir'],
      '/usr/include',
     ]
@@ -59,6 +60,7 @@ else
      '/opt/local/lib',
      '/opt/geos/lib',
      '/opt/lib',
+     '/Library/Frameworks/GEOS.framework/unix/lib',
      ::Config::CONFIG['libdir'],
      '/usr/lib',
     ]
@@ -74,6 +76,8 @@ else
     else
       $libs.gsub!(' -lgeos -lgeos_c', '')
     end
+    have_func('GEOSPreparedContains_r', 'geos_c.h')
+    have_func('GEOSPreparedDisjoint_r', 'geos_c.h')
   end
   unless found_geos_
     puts "**** WARNING: Unable to find GEOS headers or GEOS version is too old."

data/ext/geos_c_impl/factory.c

@@ -95,6 +95,12 @@ static void destroy_geometry_func(RGeo_GeometryData* data)
   if (data->geom) {
     GEOSGeom_destroy_r(data->geos_context, data->geom);
   }
+  const GEOSPreparedGeometry* prep = data->prep;
+  if (prep && prep != (const GEOSPreparedGeometry*)1 && prep != (const GEOSPreparedGeometry*)2 &&
+    prep != (const GEOSPreparedGeometry*)3)
+  {
+    GEOSPreparedGeom_destroy_r(data->geos_context, prep);
+  }
   free(data);
 }
 
@@ -323,8 +329,10 @@ VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass)
       if (geom) {
         GEOSSetSRID_r(factory_context, geom, factory_data->srid);
       }
-      data->geom = geom;
       data->geos_context = factory_context;
+      data->geom = geom;
+      data->prep = factory_data && ((factory_data->flags & RGEO_FACTORYFLAGS_PREPARE_HEURISTIC) != 0) ?
+        (GEOSPreparedGeometry*)1 : NULL;
       data->factory = factory;
       data->klasses = klasses;
       result = Data_Wrap_Struct(klass, mark_geometry_func, destroy_geometry_func, data);
@@ -380,8 +388,13 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
         *klasses = CLASS_OF(object);
       }
     }
-    object_data->geom = NULL;
+    const GEOSPreparedGeometry* prep = object_data->prep;
+    if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+      GEOSPreparedGeom_destroy_r(object_data->geos_context, prep);
+    }
     object_data->geos_context = NULL;
+    object_data->geom = NULL;
+    object_data->prep = NULL;
     object_data->factory = Qnil;
     object_data->klasses = Qnil;
   }

data/ext/geos_c_impl/factory.h

@@ -101,6 +101,7 @@ typedef struct {
 #define RGEO_FACTORYFLAGS_SUPPORTS_Z 2
 #define RGEO_FACTORYFLAGS_SUPPORTS_M 4
 #define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M 6
+#define RGEO_FACTORYFLAGS_PREPARE_HEURISTIC 8
 
 
 /*
@@ -125,8 +126,9 @@ typedef struct {
   here so the destroy_geometry_func can get to it.
 */
 typedef struct {
-  GEOSGeometry* geom;
   GEOSContextHandle_t geos_context;
+  GEOSGeometry* geom;
+  const GEOSPreparedGeometry* prep;
   VALUE factory;
   VALUE klasses;
 } RGeo_GeometryData;

data/ext/geos_c_impl/geometry.c

@@ -101,6 +101,36 @@ static int compute_dimension(GEOSContextHandle_t context, const GEOSGeometry* ge
 }
 
 
+// Returns a prepared geometry, honoring the preparation policy.
+
+static const GEOSPreparedGeometry* rgeo_request_prepared_geometry(RGeo_GeometryData* object_data)
+{
+  const GEOSPreparedGeometry* prep = object_data->prep;
+  if (prep == (const GEOSPreparedGeometry*)1) {
+    object_data->prep = (GEOSPreparedGeometry*)2;
+    prep = NULL;
+  }
+  else if (prep == (const GEOSPreparedGeometry*)2) {
+    if (object_data->geom) {
+      prep = GEOSPrepare_r(object_data->geos_context, object_data->geom);
+    }
+    else {
+      prep = NULL;
+    }
+    if (prep) {
+      object_data->prep = prep;
+    }
+    else {
+      object_data->prep = (const GEOSPreparedGeometry*)3;
+    }
+  }
+  else if (prep == (const GEOSPreparedGeometry*)3) {
+    prep = NULL;
+  }
+  return prep;
+}
+
+
 /**** RUBY METHOD DEFINITIONS ****/
 
 
@@ -123,6 +153,34 @@ static VALUE method_geometry_set_factory(VALUE self, VALUE factory)
 }
 
 
+static VALUE method_geometry_prepared_p(VALUE self)
+{
+  const GEOSPreparedGeometry* prep = RGEO_GEOMETRY_DATA_PTR(self)->prep;
+  return (prep && prep != (const GEOSPreparedGeometry*)1 &&
+    prep != (const GEOSPreparedGeometry*)2 &&
+    prep != (GEOSPreparedGeometry*)3) ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_geometry_prepare(VALUE self)
+{
+  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  if (self_data->geom) {
+    const GEOSPreparedGeometry* prep = self_data->prep;
+    if (!prep || prep == (const GEOSPreparedGeometry*)1 || prep == (const GEOSPreparedGeometry*)2) {
+      const GEOSPreparedGeometry* prep = GEOSPrepare_r(self_data->geos_context, self_data->geom);
+      if (prep) {
+        self_data->prep = prep;
+      }
+      else {
+        self_data->prep = (const GEOSPreparedGeometry*)3;
+      }
+    }
+  }
+  return self;
+}
+
+
 static VALUE method_geometry_dimension(VALUE self)
 {
   VALUE result = Qnil;
@@ -339,7 +397,14 @@ static VALUE method_geometry_disjoint(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSDisjoint_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedDisjoint_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSDisjoint_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -360,7 +425,14 @@ static VALUE method_geometry_intersects(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSIntersects_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedIntersects_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSIntersects_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -381,7 +453,14 @@ static VALUE method_geometry_touches(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSTouches_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedTouches_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSTouches_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -402,7 +481,14 @@ static VALUE method_geometry_crosses(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSCrosses_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedCrosses_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSCrosses_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -423,7 +509,14 @@ static VALUE method_geometry_within(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSWithin_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedWithin_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSWithin_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -444,7 +537,14 @@ static VALUE method_geometry_contains(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSContains_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedContains_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSContains_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -465,7 +565,14 @@ static VALUE method_geometry_overlaps(VALUE self, VALUE rhs)
   if (self_geom) {
     const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSOverlaps_r(self_data->geos_context, self_geom, rhs_geom);
+      char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      if (prep)
+        val = GEOSPreparedOverlaps_r(self_data->geos_context, prep, rhs_geom);
+      else
+#endif
+        val = GEOSOverlaps_r(self_data->geos_context, self_geom, rhs_geom);
       if (val == 0) {
         result = Qfalse;
       }
@@ -617,14 +724,18 @@ static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
 {
   // Clear out any existing value
   RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  GEOSGeometry* self_geom = self_data->geom;
-  if (self_geom) {
-    GEOSGeom_destroy_r(self_data->geos_context, self_geom);
+  if (self_data->geom) {
+    GEOSGeom_destroy_r(self_data->geos_context, self_data->geom);
     self_data->geom = NULL;
-    self_data->geos_context = NULL;
-    self_data->factory = Qnil;
-    self_data->klasses = Qnil;
   }
+  const GEOSPreparedGeometry* prep = self_data->prep;
+  if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+    GEOSPreparedGeom_destroy_r(self_data->geos_context, prep);
+  }
+  self_data->prep = NULL;
+  self_data->geos_context = NULL;
+  self_data->factory = Qnil;
+  self_data->klasses = Qnil;
   
   // Copy value from orig
   const GEOSGeometry* geom = rgeo_get_geos_geometry_safe(orig);
@@ -633,9 +744,12 @@ static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
     GEOSContextHandle_t orig_context = orig_data->geos_context;
     GEOSGeometry* clone_geom = GEOSGeom_clone_r(orig_context, geom);
     if (clone_geom) {
+      RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(orig_data->factory);
       GEOSSetSRID_r(orig_context, clone_geom, GEOSGetSRID_r(orig_context, geom));
       self_data->geom = clone_geom;
       self_data->geos_context = orig_context;
+      self_data->prep = factory_data && (factory_data->flags & RGEO_FACTORYFLAGS_PREPARE_HEURISTIC != 0) ?
+        (GEOSPreparedGeometry*)1 : NULL;
       self_data->factory = orig_data->factory;
       self_data->klasses = orig_data->klasses;
     }
@@ -660,6 +774,8 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
   rb_define_method(geos_geometry_class, "initialized?", method_geometry_initialized_p, 0);
   rb_define_method(geos_geometry_class, "factory", method_geometry_factory, 0);
+  rb_define_method(geos_geometry_class, "prepared?", method_geometry_prepared_p, 0);
+  rb_define_method(geos_geometry_class, "prepare!", method_geometry_prepare, 0);
   rb_define_method(geos_geometry_class, "dimension", method_geometry_dimension, 0);
   rb_define_method(geos_geometry_class, "geometry_type", method_geometry_geometry_type, 0);
   rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);

data/ext/geos_c_impl/preface.h

@@ -41,6 +41,13 @@
 #endif
 #endif
 
+#ifdef HAVE_GEOSPREPAREDCONTAINS_R
+#define RGEO_GEOS_SUPPORTS_PREPARED1
+#endif
+#ifdef HAVE_GEOSPREPAREDDISJOINT_R
+#define RGEO_GEOS_SUPPORTS_PREPARED2
+#endif
+
 #ifdef __cplusplus
 #define RGEO_BEGIN_C extern "C" {
 #define RGEO_END_C }

data/ext/proj4_c_impl/extconf.rb

@@ -51,6 +51,7 @@ else
      '/opt/proj/include',
      '/opt/proj4/include',
      '/opt/include',
+     '/Library/Frameworks/PROJ.framework/unix/include',
      ::Config::CONFIG['includedir'],
      '/usr/include',
     ]
@@ -63,6 +64,7 @@ else
      '/opt/proj/lib',
      '/opt/proj4/lib',
      '/opt/lib',
+     '/Library/Frameworks/PROJ.framework/unix/lib',
      ::Config::CONFIG['libdir'],
      '/usr/lib',
     ]

data/ext/proj4_c_impl/main.c

@@ -120,7 +120,14 @@ static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
   
   // Copy value from orig
   RGeo_Proj4Data* orig_data = RGEO_PROJ4_DATA_PTR(orig);
-  self_data->pj = orig_data->pj;
+  if (!NIL_P(orig_data->original_str)) {
+    self_data->pj = pj_init_plus(RSTRING_PTR(orig_data->original_str));
+  }
+  else {
+    char* str = pj_get_def(orig_data->pj, 0);
+    self_data->pj = pj_init_plus(str);
+    pj_dalloc(str);
+  }
   self_data->original_str = orig_data->original_str;
   self_data->uses_radians = orig_data->uses_radians;
   
@@ -128,6 +135,28 @@ static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
 }
 
 
+static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
+{
+  Check_Type(str, T_STRING);
+  
+  // Clear out any existing value
+  RGeo_Proj4Data* self_data = RGEO_PROJ4_DATA_PTR(self);
+  projPJ pj = self_data->pj;
+  if (pj) {
+    pj_free(pj);
+    self_data->pj = NULL;
+    self_data->original_str = Qnil;
+  }
+  
+  // Set new data
+  self_data->pj = pj_init_plus(RSTRING_PTR(str));
+  self_data->original_str = str;
+  self_data->uses_radians = RTEST(uses_radians) ? 1 : 0;
+  
+  return self;
+}
+
+
 static VALUE method_proj4_get_geographic(VALUE self)
 {
   VALUE result = Qnil;
@@ -244,8 +273,11 @@ static void rgeo_init_proj4()
   VALUE rgeo_module = rb_define_module("RGeo");
   VALUE coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
   VALUE proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
+
+  rb_define_alloc_func(proj4_class, alloc_proj4);
   rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 2);
   rb_define_method(proj4_class, "initialize_copy", method_proj4_initialize_copy, 1);
+  rb_define_method(proj4_class, "_set_value", method_proj4_set_value, 2);
   rb_define_method(proj4_class, "_original_str", method_proj4_original_str, 0);
   rb_define_method(proj4_class, "_canonical_str", method_proj4_canonical_str, 0);
   rb_define_method(proj4_class, "_valid?", method_proj4_is_valid, 0);

data/lib/rgeo.rb

@@ -113,6 +113,7 @@ end
 
 
 # Core modules
+require 'rgeo/yaml'
 require 'rgeo/version'
 require 'rgeo/error'
 require 'rgeo/feature'

data/lib/rgeo/cartesian/bounding_box.rb

@@ -242,7 +242,9 @@ module RGeo
             if @min_x == @max_x || @min_y == @max_y
               @factory.line(point_min_, point_max_)
             else
-              @factory.polygon(@factory.linear_ring(point_min_, @factory.point(@max_x, @min_y, *extras_), point_max_, @factory.point(@min_x, @max_y, *extras_), point_min_))
+              @factory.polygon(@factory.linear_ring([point_min_,
+                @factory.point(@max_x, @min_y, *extras_), point_max_,
+                @factory.point(@min_x, @max_y, *extras_), point_min_]))
             end
           end
         else
@@ -256,10 +258,10 @@ module RGeo
       # 
       # Supports these options:
       # 
-      # <tt>:ignore_z</tt>
+      # [<tt>:ignore_z</tt>]
       #   Ignore the Z coordinate when testing, even if both objects
       #   have Z. Default is false.
-      # <tt>:ignore_m</tt>
+      # [<tt>:ignore_m</tt>]
       #   Ignore the M coordinate when testing, even if both objects
       #   have M. Default is false.
       

data/lib/rgeo/cartesian/factory.rb

@@ -116,6 +116,95 @@ module RGeo
       alias_method :==, :eql?
       
       
+      # Marshal support
+      
+      def marshal_dump  # :nodoc:
+        hash_ = {
+          'hasz' => @has_z,
+          'hasm' => @has_m,
+          'srid' => @srid,
+          'wktg' => @wkt_generator._properties,
+          'wkbg' => @wkb_generator._properties,
+          'wktp' => @wkt_parser._properties,
+          'wkbp' => @wkb_parser._properties,
+        }
+        hash_['proj4'] = @proj4.marshal_dump if @proj4
+        hash_['cs'] = @coord_sys.to_wkt if @coord_sys
+        hash_
+      end
+      
+      def marshal_load(data_)  # :nodoc:
+        if CoordSys::Proj4.supported? && (proj4_data_ = data_['proj4'])
+          proj4_ = CoordSys::Proj4.allocate
+          proj4_.marshal_load(proj4_data_)
+        else
+          proj4_ = nil
+        end
+        if (coord_sys_data_ = data_['cs'])
+          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_)
+        else
+          coord_sys_ = nil
+        end
+        initialize({
+          :has_z_coordinate => data_['hasz'],
+          :has_m_coordinate => data_['hasm'],
+          :srid => data_['srid'],
+          :wkt_generator => data_['wktg'],
+          :wkb_generator => data_['wkbg'],
+          :wkt_parser => data_['wktp'],
+          :wkb_parser => data_['wkbp'],
+          :proj4 => proj4_,
+          :coord_sys => coord_sys_,
+        })
+      end
+      
+      
+      # Psych support
+      
+      def init_with(coder_)  # :nodoc:
+        if (proj4_data_ = coder_['proj4'])
+          if proj4_data_.is_a?(::Hash)
+            proj4_ = CoordSys::Proj4.create(proj4_data_['proj4'], :radians => proj4_data_['radians'])
+          else
+            proj4_ = CoordSys::Proj4.create(proj4_data_.to_s)
+          end
+        else
+          proj4_ = nil
+        end
+        if (coord_sys_data_ = data_['cs'])
+          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
+        else
+          coord_sys_ = nil
+        end
+        initialize({
+          :has_z_coordinate => data_['has_z_coordinate'],
+          :has_m_coordinate => data_['has_m_coordinate'],
+          :srid => data_['srid'],
+          :wkt_generator => data_['wkt_generator'],
+          :wkb_generator => data_['wkb_generator'],
+          :wkt_parser => data_['wkt_parser'],
+          :wkb_parser => data_['wkb_parser'],
+          :proj4 => proj4_,
+          :coord_sys => coord_sys_,
+        })
+      end
+      
+      def encode_with(coder_)  # :nodoc:
+        coder_['has_z_coordinate'] = @has_z
+        coder_['has_m_coordinate'] = @has_m
+        coder_['srid'] = @srid
+        coder_['wkt_generator'] = @wkt_generator._properties
+        coder_['wkb_generator'] = @wkb_generator._properties
+        coder_['wkt_parser'] = @wkt_parser._properties
+        coder_['wkb_parser'] = @wkb_parser._properties
+        if @proj4
+          str_ = @proj4.original_str || @proj4.canonical_str
+          coder_['proj4'] = @proj4.radians? ? {'proj4' => str_, 'radians' => true} : str_
+        end
+        coder_['coord_sys'] = @coord_sys.to_wkt if @coord_sys
+      end
+      
+      
       # Returns the SRID.
       
       def srid

data/lib/rgeo/coord_sys/cs/entities.rb

@@ -222,6 +222,43 @@ module RGeo
         end
         
         
+        # Marshal support
+        
+        def marshal_dump  # :nodoc:
+          to_wkt
+        end
+        
+        def marshal_load(data_)  # :nodoc:
+          data_ = data_['wkt'] if data_.is_a?(::Hash)
+          temp_ = CS.create_from_wkt(data_)
+          if temp_.class == self.class
+            temp_.instance_variables.each do |iv_|
+              instance_variable_set(iv_, temp_.instance_variable_get(iv_))
+            end
+          else
+            raise ::TypeError, 'Bad Marshal data'
+          end
+        end
+        
+        
+        # Psych support
+        
+        def init_with(coder_)  # :nodoc:
+          temp_ = CS.create_from_wkt(coder_.type == :scalar ? coder_.scalar : coder_['wkt'] )
+          if temp_.class == self.class
+            temp_.instance_variables.each do |iv_|
+              instance_variable_set(iv_, temp_.instance_variable_get(iv_))
+            end
+          else
+            raise ::TypeError, 'Bad YAML data'
+          end
+        end
+        
+        def encode_with(coder_)  # :nodoc:
+          coder_['wkt'] = to_wkt
+        end
+        
+        
         class << self
           
           private :new

data/lib/rgeo/coord_sys/proj4.rb

@@ -83,6 +83,33 @@ module RGeo
       alias_method :==, :eql?
       
       
+      # Marshal support
+      
+      def marshal_dump  # :nodoc:
+        {'rad' => radians?, 'str' => original_str || canonical_str}
+      end
+      
+      def marshal_load(data_)  # :nodoc:
+        _set_value(data_['str'], data_['rad'])
+      end
+      
+      
+      # Psych support
+      
+      def init_with(coder_)  # :nodoc:
+        if coder_.type == :scalar
+          _set_value(coder_.scalar, false)
+        else
+          _set_value(coder_['proj4'], coder_['radians'])
+        end
+      end
+      
+      def encode_with(coder_)  # :nodoc:
+        coder_['proj4'] = original_str || canonical_str
+        coder_['radians'] = radians?
+      end
+      
+      
       # Returns the "canonical" string definition for this coordinate
       # system, as reported by Proj4. This may be slightly different
       # from the definition used to construct this object.
@@ -202,6 +229,19 @@ module RGeo
         # Create a new Proj4 object, given a definition, which may be
         # either a string or a hash. Raises Error::UnsupportedOperation
         # if the given definition is invalid or Proj4 is not supported.
+        # 
+        # Recognized options include:
+        # 
+        # [<tt>:radians</tt>]
+        #   If set to true, then this proj4 will represent geographic
+        #   (latitude/longitude) coordinates in radians rather than
+        #   degrees. If this is a geographic coordinate system, then its
+        #   units will be in radians. If this is a projected coordinate
+        #   system, then its units will be unchanged, but any geographic
+        #   coordinate system obtained using get_geographic will use
+        #   radians as its units. If this is a geocentric or other type of
+        #   coordinate system, this has no effect. Default is false.
+        #   (That is all coordinates are in degrees by default.)
         
         def new(defn_, opts_={})
           result_ = create(defn_, opts_)

data/lib/rgeo/geos/factory.rb

@@ -67,6 +67,7 @@ module RGeo
           if flags_ & 6 == 6
             raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
           end
+          flags_ |= 8 unless opts_[:auto_prepare] == :disabled
           
           # Buffer resolution
           buffer_resolution_ = opts_[:buffer_resolution].to_i
@@ -206,6 +207,8 @@ module RGeo
           _flags & 0x1 != 0
         when :buffer_resolution
           _buffer_resolution
+        when :auto_prepare
+          _flags & 0x8 != 0 ? :simple : :disabled
         else
           nil
         end

data/lib/rgeo/geos/interface.rb

@@ -64,7 +64,7 @@ module RGeo
       
       
       # Returns true if the given feature is a CAPI GEOS feature, or if
-      # the given factory is a native GEOS factory.
+      # the given factory is a CAPI GEOS factory.
       
       def is_capi_geos?(object_)
         Factory === object_ || GeometryImpl === object_ ||
@@ -84,7 +84,7 @@ module RGeo
       
       
       # Returns true if the given feature is a GEOS feature, or if the given
-      # factory is a GEOS factory.
+      # factory is a GEOS factory. Does not distinguish between CAPI and FFI.
       
       def is_geos?(object_)
         Factory === object_ || GeometryImpl === object_ ||
@@ -188,6 +188,15 @@ module RGeo
       #   default configuration for WKRep::WKBGenerator.
       #   Note that the special <tt>:geos</tt> value is not supported for
       #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:auto_prepare</tt>]
+      #   Request an auto-prepare strategy. Supported values are
+      #   <tt>:simple</tt> and <tt>:disabled</tt>. The former (which is
+      #   the default) generates a prepared geometry the second time an
+      #   operation that would benefit from it is called. The latter
+      #   never automatically generates a prepared geometry (unless you
+      #   generate on explicitly using the <tt>prepare!</tt> method).
+      #   Currently, prepared geometries are supported under CAPI but
+      #   not FFI.
       
       def factory(opts_={})
         if supported?

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -123,6 +123,16 @@ module RGeo
       end
       
       
+      def _properties  # :nodoc:
+        {
+          :type_format => @type_format,
+          :emit_ewkb_srid => @emit_ewkb_srid,
+          :hex_format => @hex_format,
+          :little_endian => @little_endian,
+        }
+      end
+      
+      
       # Generate and return the WKB format for the given geometry object,
       # according to the current settings.
       

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -127,10 +127,14 @@ module RGeo
         @ignore_extra_bytes
       end
       
-      # Returns true if this parser can auto-detect hex.
-      # See WKBParser for details.
-      def auto_detect_hex?
-        @auto_detect_hex
+      
+      def _properties  # :nodoc:
+        {
+          :support_ewkb => @support_ewkb,
+          :support_wkb12 => @support_wkb12,
+          :ignore_extra_bytes => @ignore_extra_bytes,
+          :default_srid => @default_srid,
+        }
       end
       
       

data/lib/rgeo/wkrep/wkt_generator.rb

@@ -114,6 +114,16 @@ module RGeo
       end
       
       
+      def _properties  # :nodoc:
+        {
+          :tag_format => @tag_format,
+          :emit_ewkt_srid => @emit_ewkt_srid,
+          :square_brackets => @square_brackets,
+          :convert_case => @convert_case,
+        }
+      end
+      
+      
       # Generate and return the WKT format for the given geometry object,
       # according to the current settings.
       
@@ -141,6 +151,7 @@ module RGeo
       
       def _generate_feature(obj_, toplevel_=false)  # :nodoc:
         type_ = obj_.geometry_type
+        type_ = Feature::LineString if type_.subtype_of?(Feature::LineString)
         tag_ = type_.type_name
         if @tag_format == :ewkt
           if @cur_support_m && !@cur_support_z
@@ -162,7 +173,7 @@ module RGeo
         end
         if type_ == Feature::Point
           "#{tag_} #{_generate_point(obj_)}"
-        elsif type_.subtype_of?(Feature::LineString)
+        elsif type_ == Feature::LineString
           "#{tag_} #{_generate_line_string(obj_)}"
         elsif type_ == Feature::Polygon
           "#{tag_} #{_generate_polygon(obj_)}"

data/lib/rgeo/wkrep/wkt_parser.rb

@@ -142,6 +142,17 @@ module RGeo
       end
       
       
+      def _properties  # :nodoc:
+        {
+          :support_ewkt => @support_ewkt,
+          :support_wkt12 => @support_wkt12,
+          :strict_wkt11 => @strict_wkt11,
+          :ignore_extra_tokens => @ignore_extra_tokens,
+          :default_srid => @default_srid,
+        }
+      end
+      
+      
       # Parse the given string, and return a geometry object.
       
       def parse(str_)

data/lib/rgeo/yaml.rb

@@ -0,0 +1,59 @@
+# -----------------------------------------------------------------------------
+# 
+# RGeo yaml support
+# 
+# -----------------------------------------------------------------------------
+# 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.
+# -----------------------------------------------------------------------------
+;
+
+
+begin
+  require 'psych'
+rescue ::LoadError
+end
+
+
+module RGeo
+  
+  
+  # :stopdoc:
+  PSYCH_AVAILABLE = defined?(::Psych)
+  # :startdoc:
+  
+  
+  # Returns true if YAML serialization and deserialization is supported.
+  # YAML support requires the Psych library/gem.
+  
+  def self.yaml_supported?
+    PSYCH_AVAILABLE
+  end
+  
+  
+end

data/test/coord_sys/tc_ogc_cs.rb

@@ -360,6 +360,34 @@ module RGeo
         end
         
         
+        def test_marshal_roundtrip
+          input_ = 'COMPD_CS["OSGB36 / British National Grid + ODN",PROJCS["OSGB 1936 / British National Grid",GEOGCS["OSGB 1936",DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]],TOWGS84[446.448,-125.157,542.06,0.15,0.247,0.842,-4.2261596151967575],AUTHORITY["EPSG","6277"]],PRIMEM["Greenwich",0.0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.017453292519943295],AXIS["Geodetic latitude",NORTH],AXIS["Geodetic longitude",EAST],AUTHORITY["EPSG","4277"]],PROJECTION["Transverse Mercator",AUTHORITY["EPSG","9807"]],PARAMETER["central_meridian",-2.0],PARAMETER["latitude_of_origin",49.0],PARAMETER["scale_factor",0.9996012717],PARAMETER["false_easting",400000.0],PARAMETER["false_northing",-100000.0],UNIT["m",1.0],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","27700"]],VERT_CS["Newlyn",VERT_DATUM["Ordnance Datum Newlyn",2005,AUTHORITY["EPSG","5101"]],UNIT["m",1.0],AXIS["Gravity-related height",UP],AUTHORITY["EPSG","5701"]],AUTHORITY["EPSG","7405"]]'
+          obj1_ = ::RGeo::CoordSys::CS.create_from_wkt(input_)
+          dump_ = ::Marshal.dump(obj1_)
+          obj2_ = ::Marshal.load(dump_)
+          assert_equal(obj1_, obj2_)
+        end
+        
+        
+        if ::RGeo.yaml_supported?
+          
+          
+          def test_yaml_roundtrip
+            input_ = 'COMPD_CS["OSGB36 / British National Grid + ODN",PROJCS["OSGB 1936 / British National Grid",GEOGCS["OSGB 1936",DATUM["OSGB 1936",SPHEROID["Airy 1830",6377563.396,299.3249646,AUTHORITY["EPSG","7001"]],TOWGS84[446.448,-125.157,542.06,0.15,0.247,0.842,-4.2261596151967575],AUTHORITY["EPSG","6277"]],PRIMEM["Greenwich",0.0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.017453292519943295],AXIS["Geodetic latitude",NORTH],AXIS["Geodetic longitude",EAST],AUTHORITY["EPSG","4277"]],PROJECTION["Transverse Mercator",AUTHORITY["EPSG","9807"]],PARAMETER["central_meridian",-2.0],PARAMETER["latitude_of_origin",49.0],PARAMETER["scale_factor",0.9996012717],PARAMETER["false_easting",400000.0],PARAMETER["false_northing",-100000.0],UNIT["m",1.0],AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","27700"]],VERT_CS["Newlyn",VERT_DATUM["Ordnance Datum Newlyn",2005,AUTHORITY["EPSG","5101"]],UNIT["m",1.0],AXIS["Gravity-related height",UP],AUTHORITY["EPSG","5701"]],AUTHORITY["EPSG","7405"]]'
+            obj1_ = ::RGeo::CoordSys::CS.create_from_wkt(input_)
+            dump_ = ::Psych.dump(obj1_)
+            obj2_ = ::Psych.load(dump_)
+            assert_equal(obj1_, obj2_)
+          end
+          
+          
+        else
+          
+          puts "WARNING: Psych not installed. Skipping YAML tests."
+          
+        end
+        
+        
       end
       
     end

data/test/coord_sys/tc_proj4.rb

@@ -46,7 +46,7 @@ module RGeo
         
         
         def test_create_wgs84
-          proj_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          proj_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
           assert_equal(true, proj_.geographic?)
           assert_equal('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', proj_.original_str)
           assert_equal(' +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs +towgs84=0,0,0', proj_.canonical_str)
@@ -54,19 +54,19 @@ module RGeo
         
         
         def test_get_wgs84_geographic
-          proj_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          proj_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
           proj2_ = proj_.get_geographic
           assert_nil(proj2_.original_str)
           assert_equal(true, proj2_.geographic?)
-          coords_ = RGeo::CoordSys::Proj4.transform_coords(proj_, proj2_, 1, 2, 0)
+          coords_ = ::RGeo::CoordSys::Proj4.transform_coords(proj_, proj2_, 1, 2, 0)
           assert_equal([1, 2, 0], coords_)
         end
         
         
         def test_identity_transform
-          proj_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
-          assert_equal([1, 2, 0], RGeo::CoordSys::Proj4.transform_coords(proj_, proj_, 1, 2, 0))
-          assert_equal([1, 2], RGeo::CoordSys::Proj4.transform_coords(proj_, proj_, 1, 2, nil))
+          proj_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          assert_equal([1, 2, 0], ::RGeo::CoordSys::Proj4.transform_coords(proj_, proj_, 1, 2, 0))
+          assert_equal([1, 2], ::RGeo::CoordSys::Proj4.transform_coords(proj_, proj_, 1, 2, nil))
         end
         
         
@@ -92,45 +92,100 @@ module RGeo
         
         
         def test_simple_mercator_transform
-          geography_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :radians => true)
-          projection_ = RGeo::CoordSys::Proj4.create('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs')
-          _assert_xy_close(_project_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0, 0, nil))
-          _assert_xy_close(_project_merc(0.01, 0.01), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0.01, 0.01, nil))
-          _assert_xy_close(_project_merc(1, 1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 1, 1, nil))
-          _assert_xy_close(_project_merc(-1, -1), RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, -1, -1, nil))
-          _assert_xy_close(_unproject_merc(0, 0), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 0, 0, nil))
-          _assert_xy_close(_unproject_merc(10000, 10000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 10000, 10000, nil))
-          _assert_xy_close(_unproject_merc(-20000000, -20000000), RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, -20000000, -20000000, nil))
+          geography_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :radians => true)
+          projection_ = ::RGeo::CoordSys::Proj4.create('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs')
+          _assert_xy_close(_project_merc(0, 0), ::RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0, 0, nil))
+          _assert_xy_close(_project_merc(0.01, 0.01), ::RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 0.01, 0.01, nil))
+          _assert_xy_close(_project_merc(1, 1), ::RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, 1, 1, nil))
+          _assert_xy_close(_project_merc(-1, -1), ::RGeo::CoordSys::Proj4.transform_coords(geography_, projection_, -1, -1, nil))
+          _assert_xy_close(_unproject_merc(0, 0), ::RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 0, 0, nil))
+          _assert_xy_close(_unproject_merc(10000, 10000), ::RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, 10000, 10000, nil))
+          _assert_xy_close(_unproject_merc(-20000000, -20000000), ::RGeo::CoordSys::Proj4.transform_coords(projection_, geography_, -20000000, -20000000, nil))
         end
         
         
         def test_equivalence
-          proj1_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
-          proj2_ = RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          proj1_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          proj2_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
           assert_equal(proj1_, proj2_)
         end
         
         
         def test_point_projection_cast
-          geography_ = RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
-          projection_ = RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
+          geography_ = ::RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
+          projection_ = ::RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
           proj_point_ = projection_.parse_wkt('POINT(473600.5000000000000000 186659.7999999999883585)')
-          geo_point_ = RGeo::Feature.cast(proj_point_, :project => true, :factory => geography_)
+          geo_point_ = ::RGeo::Feature.cast(proj_point_, :project => true, :factory => geography_)
           _assert_close_enough(-0.9393598527244420, geo_point_.x)
           _assert_close_enough(51.5740106527552697, geo_point_.y)
         end
         
         
         def test_point_transform_lowlevel
-          geography_ = RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
-          projection_ = RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
+          geography_ = ::RGeo::Geos.factory(:proj4 => '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs', :srid =>4326)
+          projection_ = ::RGeo::Geos.factory(:proj4 => '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 +ellps=airy +datum=OSGB36 +units=m +no_defs', :srid => 27700)
           proj_point_ = projection_.parse_wkt('POINT(473600.5000000000000000 186659.7999999999883585)')
-          geo_point_ = RGeo::CoordSys::Proj4.transform(projection_.proj4, proj_point_, geography_.proj4, geography_)
+          geo_point_ = ::RGeo::CoordSys::Proj4.transform(projection_.proj4, proj_point_, geography_.proj4, geography_)
           _assert_close_enough(-0.9393598527244420, geo_point_.x)
           _assert_close_enough(51.5740106527552697, geo_point_.y)
         end
         
         
+        def test_geocentric
+          obj1_ = ::RGeo::CoordSys::Proj4.create('+proj=geocent +ellps=WGS84')
+          assert_equal(true, obj1_.geocentric?)
+        end
+        
+        
+        def test_get_geographic
+          projection_ = ::RGeo::CoordSys::Proj4.create('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs')
+          geographic_ = projection_.get_geographic
+          expected_ = ::RGeo::CoordSys::Proj4.create('+proj=latlong +a=6378137 +b=6378137 +nadgrids=@null')
+          assert_equal(expected_, geographic_)
+        end
+        
+        
+        def test_marshal_roundtrip
+          obj1_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          dump_ = ::Marshal.dump(obj1_)
+          obj2_ = ::Marshal.load(dump_)
+          assert_equal(obj1_, obj2_)
+        end
+        
+        
+        def test_dup
+          obj1_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+          obj2_ = obj1_.dup
+          assert_equal(obj1_, obj2_)
+        end
+        
+        
+        def test_dup_of_get_geographic
+          obj1_ = ::RGeo::CoordSys::Proj4.create('+proj=latlong +datum=WGS84 +ellps=WGS84')
+          obj2_ = obj1_.get_geographic
+          obj3_ = obj2_.dup
+          assert_equal(obj1_, obj3_)
+        end
+        
+        
+        if ::RGeo.yaml_supported?
+          
+          
+          def test_yaml_roundtrip
+            obj1_ = ::RGeo::CoordSys::Proj4.create('+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs')
+            dump_ = ::Psych.dump(obj1_)
+            obj2_ = ::Psych.load(dump_)
+            assert_equal(obj1_, obj2_)
+          end
+          
+          
+        else
+          
+          puts "WARNING: Psych not installed. Skipping YAML tests."
+          
+        end
+        
+        
       end
       
     end

data/test/geos_capi/tc_misc.rb

@@ -65,6 +65,39 @@ module RGeo
         end
         
         
+        def test_prepare
+          p1_ = @factory.point(1, 2)
+          p2_ = @factory.point(3, 4)
+          p3_ = @factory.point(5, 2)
+          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon_.prepared?)
+          polygon_.prepare!
+          assert_equal(true, polygon_.prepared?)
+        end
+        
+        
+        def test_auto_prepare
+          p1_ = @factory.point(1, 2)
+          p2_ = @factory.point(3, 4)
+          p3_ = @factory.point(5, 2)
+          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon_.prepared?)
+          polygon_.intersects?(p1_)
+          assert_equal(false, polygon_.prepared?)
+          polygon_.intersects?(p2_)
+          assert_equal(true, polygon_.prepared?)
+          
+          factory_no_auto_prepare_ = ::RGeo::Geos.factory(:srid => 4326, :auto_prepare => :disabled)
+          polygon2_ = factory_no_auto_prepare_.polygon(
+            factory_no_auto_prepare_.linear_ring([p1_, p2_, p3_, p1_]))
+          assert_equal(false, polygon2_.prepared?)
+          polygon2_.intersects?(p1_)
+          assert_equal(false, polygon2_.prepared?)
+          polygon2_.intersects?(p2_)
+          assert_equal(false, polygon2_.prepared?)
+        end
+        
+        
       end
       
     end

metadata

@@ -1,30 +1,31 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rgeo
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.3.2
   prerelease: 
-  version: 0.3.1
 platform: ruby
-authors: 
+authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-24 00:00:00 Z
+date: 2011-08-12 00:00:00.000000000 Z
 dependencies: []
-
-description: RGeo is a geospatial data library for Ruby. It provides an implementation of the Open Geospatial Consortium's Simple Features Specification, used by most standard spatial/geographic data storage systems such as PostGIS. A number of add-on modules are also available to help with writing location-based applications using Ruby-based frameworks such as Ruby On Rails.
+description: RGeo is a geospatial data library for Ruby. It provides an implementation
+  of the Open Geospatial Consortium's Simple Features Specification, used by most
+  standard spatial/geographic data storage systems such as PostGIS. A number of add-on
+  modules are also available to help with writing location-based applications using
+  Ruby-based frameworks such as Ruby On Rails.
 email: dazuma@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/geos_c_impl/extconf.rb
 - ext/proj4_c_impl/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.rdoc
 - README.rdoc
 - Spatial_Programming_With_RGeo.rdoc
-files: 
+files:
 - lib/rgeo/cartesian/analysis.rb
 - lib/rgeo/cartesian/bounding_box.rb
 - lib/rgeo/cartesian/calculations.rb
@@ -95,6 +96,7 @@ files:
 - lib/rgeo/wkrep/wkt_generator.rb
 - lib/rgeo/wkrep/wkt_parser.rb
 - lib/rgeo/wkrep.rb
+- lib/rgeo/yaml.rb
 - lib/rgeo.rb
 - ext/geos_c_impl/extconf.rb
 - ext/proj4_c_impl/extconf.rb
@@ -193,32 +195,29 @@ files:
 - Version
 homepage: http://virtuoso.rubyforge.org/rgeo
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-
 rubyforge_project: virtuoso
-rubygems_version: 1.8.2
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: RGeo is a geospatial data library for Ruby.
-test_files: 
+test_files:
 - test/coord_sys/tc_active_record_table.rb
 - test/coord_sys/tc_ogc_cs.rb
 - test/coord_sys/tc_proj4.rb