rgeo 0.3.6 → 0.3.7

data/History.rdoc

@@ -1,3 +1,10 @@
+=== 0.3.7 / 2012-03-12
+
+* Marshal and YAML serialization now fully implemented for geometries.
+* The spatial predicates for objects using the 4D (ZM) Geos factory almost always returned false because they weren't casting correctly. Fixed.
+* Proj#canonical_str and the Geos implementations of Geometry#as_text were returning strings encoded as "ASCII-8BIT", which was causing strange binary output in YAML serialization, among other things. Now fixed. These strings are now encoded as "US-ASCII".
+* YAML serialization for 4D (ZM) Geos factories didn't preserve coordinate systems. Fixed.
+
 === 0.3.6 / 2012-03-06
 
 * Geometry#relate? was incorrectly spelled "Geometry#relate" in the Feature::Geometry module and in some (but not all) implementations, leading to various types of method not found errors. Fixed. We'll keep #relate as a deprecated alias for the time being.

data/README.rdoc

@@ -99,18 +99,20 @@ 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 across all major entities.
-* Full JRuby support.
 * Better error handling and reporting.
+* JRuby support for Proj4
 * Ellipsoidal geography implementation, possibly utilizing geographiclib.
 * Windows build support.
+* GDAL integration including coordinate system interpretation.
 
 Each of the current add-on modules also has its own feature roadmap, and
 we are planning on introducing more add-on modules, including:
 
+* Raster support via GDAL.
 * GeoRSS and KML format support.
-* Integration with third-party APIs.
+* Custom spatial indexes.
 * Possible additional ActiveRecord adapters (esp. JDBC adapters)
+* Integration with third-party APIs.
 
 === Development and support
 

data/Version

@@ -1 +1 @@
-0.3.6
+0.3.7

data/ext/geos_c_impl/factory.c

@@ -84,6 +84,18 @@ static void destroy_factory_func(RGeo_FactoryData* data)
   if (data->wkb_writer) {
     GEOSWKBWriter_destroy_r(context, data->wkb_writer);
   }
+  if (data->psych_wkt_reader) {
+    GEOSWKTReader_destroy_r(context, data->psych_wkt_reader);
+  }
+  if (data->marshal_wkb_reader) {
+    GEOSWKBReader_destroy_r(context, data->marshal_wkb_reader);
+  }
+  if (data->psych_wkt_writer) {
+    GEOSWKTWriter_destroy_r(context, data->psych_wkt_writer);
+  }
+  if (data->marshal_wkb_writer) {
+    GEOSWKBWriter_destroy_r(context, data->marshal_wkb_writer);
+  }
   finishGEOS_r(context);
   free(data);
 }
@@ -241,6 +253,130 @@ static VALUE method_factory_parse_wkb(VALUE self, VALUE str)
 }
 
 
+static VALUE method_factory_read_for_marshal(VALUE self, VALUE str)
+{
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKBReader* wkb_reader;
+  VALUE result;
+  GEOSGeometry* geom;
+
+  Check_Type(str, T_STRING);
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkb_reader = self_data->marshal_wkb_reader;
+  if (!wkb_reader) {
+    wkb_reader = GEOSWKBReader_create_r(self_context);
+    self_data->marshal_wkb_reader = wkb_reader;
+  }
+  result = Qnil;
+  if (wkb_reader) {
+    geom = GEOSWKBReader_read_r(self_context, wkb_reader, (unsigned char*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
+    if (geom) {
+      result = rgeo_wrap_geos_geometry(self, geom, Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_factory_read_for_psych(VALUE self, VALUE str)
+{
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKTReader* wkt_reader;
+  VALUE result;
+  GEOSGeometry* geom;
+
+  Check_Type(str, T_STRING);
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkt_reader = self_data->psych_wkt_reader;
+  if (!wkt_reader) {
+    wkt_reader = GEOSWKTReader_create_r(self_context);
+    self_data->psych_wkt_reader = wkt_reader;
+  }
+  result = Qnil;
+  if (wkt_reader) {
+    geom = GEOSWKTReader_read_r(self_context, wkt_reader, RSTRING_PTR(str));
+    if (geom) {
+      result = rgeo_wrap_geos_geometry(self, geom, Qnil);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_factory_write_for_marshal(VALUE self, VALUE obj)
+{
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKBWriter* wkb_writer;
+  const GEOSGeometry* geom;
+  VALUE result;
+  char* str;
+  size_t size;
+
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkb_writer = self_data->marshal_wkb_writer;
+  if (!wkb_writer) {
+    wkb_writer = GEOSWKBWriter_create_r(self_context);
+    if (self_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M) {
+      GEOSWKBWriter_setOutputDimension_r(self_context, wkb_writer, 3);
+    }
+    self_data->marshal_wkb_writer = wkb_writer;
+  }
+  result = Qnil;
+  if (wkb_writer) {
+    geom = rgeo_get_geos_geometry_safe(obj);
+    if (geom) {
+      str = (char*)GEOSWKBWriter_write_r(self_context, wkb_writer, geom, &size);
+      if (str) {
+        result = rb_str_new(str, size);
+        GEOSFree_r(self_context, str);
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_factory_write_for_psych(VALUE self, VALUE obj)
+{
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKTWriter* wkt_writer;
+  const GEOSGeometry* geom;
+  VALUE result;
+  char* str;
+  size_t size;
+
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkt_writer = self_data->psych_wkt_writer;
+  if (!wkt_writer) {
+    wkt_writer = GEOSWKTWriter_create_r(self_context);
+    if (self_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M) {
+      GEOSWKTWriter_setOutputDimension_r(self_context, wkt_writer, 3);
+    }
+    self_data->psych_wkt_writer = wkt_writer;
+  }
+  result = Qnil;
+  if (wkt_writer) {
+    geom = rgeo_get_geos_geometry_safe(obj);
+    if (geom) {
+      str = GEOSWKTWriter_write_r(self_context, wkt_writer, geom);
+      if (str) {
+        result = rb_str_new2(str);
+        GEOSFree_r(self_context, str);
+      }
+    }
+  }
+  return result;
+}
+
+
 static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE buffer_resolution,
   VALUE wkt_generator, VALUE wkb_generator, VALUE proj4_obj, VALUE coord_sys_obj)
 {
@@ -264,6 +400,10 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
       data->wkb_reader = NULL;
       data->wkt_writer = NULL;
       data->wkb_writer = NULL;
+      data->psych_wkt_reader = NULL;
+      data->marshal_wkb_reader = NULL;
+      data->psych_wkt_writer = NULL;
+      data->marshal_wkb_writer = NULL;
       data->wkrep_wkt_generator = wkt_generator;
       data->wkrep_wkb_generator = wkb_generator;
       data->wkrep_wkt_parser = Qnil;
@@ -311,6 +451,22 @@ static VALUE method_factory_initialize_copy(VALUE self, VALUE orig)
     GEOSWKBWriter_destroy_r(context, self_data->wkb_writer);
     self_data->wkb_writer = NULL;
   }
+  if (self_data->psych_wkt_reader) {
+    GEOSWKTReader_destroy_r(context, self_data->psych_wkt_reader);
+    self_data->psych_wkt_reader = NULL;
+  }
+  if (self_data->marshal_wkb_reader) {
+    GEOSWKBReader_destroy_r(context, self_data->marshal_wkb_reader);
+    self_data->marshal_wkb_reader = NULL;
+  }
+  if (self_data->psych_wkt_writer) {
+    GEOSWKTWriter_destroy_r(context, self_data->psych_wkt_writer);
+    self_data->psych_wkt_writer = NULL;
+  }
+  if (self_data->marshal_wkb_writer) {
+    GEOSWKBWriter_destroy_r(context, self_data->marshal_wkb_writer);
+    self_data->marshal_wkb_writer = NULL;
+  }
   self_data->wkrep_wkt_generator = Qnil;
   self_data->wkrep_wkb_generator = Qnil;
   self_data->wkrep_wkt_parser = Qnil;
@@ -422,6 +578,10 @@ RGeo_Globals* rgeo_init_geos_factory()
   rb_define_method(geos_factory_class, "_wkb_generator", method_get_wkb_generator, 0);
   rb_define_method(geos_factory_class, "_wkt_parser", method_get_wkt_parser, 0);
   rb_define_method(geos_factory_class, "_wkb_parser", method_get_wkb_parser, 0);
+  rb_define_method(geos_factory_class, "_read_for_marshal", method_factory_read_for_marshal, 1);
+  rb_define_method(geos_factory_class, "_write_for_marshal", method_factory_write_for_marshal, 1);
+  rb_define_method(geos_factory_class, "_read_for_psych", method_factory_read_for_psych, 1);
+  rb_define_method(geos_factory_class, "_write_for_psych", method_factory_write_for_psych, 1);
   rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 7);
 
   // Wrap the globals in a Ruby object and store it off so we have access

data/ext/geos_c_impl/factory.h

@@ -101,6 +101,10 @@ typedef struct {
   VALUE wkrep_wkb_generator;
   VALUE wkrep_wkt_parser;
   VALUE wkrep_wkb_parser;
+  GEOSWKTReader* psych_wkt_reader;
+  GEOSWKBReader* marshal_wkb_reader;
+  GEOSWKTWriter* psych_wkt_writer;
+  GEOSWKBWriter* marshal_wkb_writer;
   VALUE proj4_obj;
   VALUE coord_sys_obj;
   int flags;

data/ext/geos_c_impl/geometry.c

@@ -937,6 +937,44 @@ static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
 }
 
 
+static VALUE method_geometry_steal(VALUE self, VALUE orig)
+{
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+  const GEOSGeometry* geom;
+  RGeo_GeometryData* orig_data;
+
+  geom = rgeo_get_geos_geometry_safe(orig);
+  if (geom) {
+    // Clear out any existing value
+    self_data = RGEO_GEOMETRY_DATA_PTR(self);
+    if (self_data->geom) {
+      GEOSGeom_destroy_r(self_data->geos_context, self_data->geom);
+    }
+    prep = self_data->prep;
+    if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+      GEOSPreparedGeom_destroy_r(self_data->geos_context, prep);
+    }
+
+    // Steal value from orig
+    orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
+    self_data->geom = orig_data->geom;
+    self_data->prep = orig_data->prep;
+    self_data->geos_context = orig_data->geos_context;
+    self_data->factory = orig_data->factory;
+    self_data->klasses = orig_data->klasses;
+
+    // Clear out orig
+    orig_data->geom = NULL;
+    orig_data->prep = NULL;
+    orig_data->geos_context = NULL;
+    orig_data->factory = Qnil;
+    orig_data->klasses = Qnil;
+  }
+  return self;
+}
+
+
 /**** INITIALIZATION FUNCTION ****/
 
 
@@ -953,6 +991,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_alloc_func(geos_geometry_class, alloc_geometry);
   rb_define_method(geos_geometry_class, "_set_factory", method_geometry_set_factory, 1);
   rb_define_method(geos_geometry_class, "initialize_copy", method_geometry_initialize_copy, 1);
+  rb_define_method(geos_geometry_class, "_steal", method_geometry_steal, 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);
@@ -962,8 +1001,7 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_class, "srid", method_geometry_srid, 0);
   rb_define_method(geos_geometry_class, "envelope", method_geometry_envelope, 0);
   rb_define_method(geos_geometry_class, "boundary", method_geometry_boundary, 0);
-  rb_define_method(geos_geometry_class, "as_text", method_geometry_as_text, 0);
-  rb_define_method(geos_geometry_class, "to_s", method_geometry_as_text, 0);
+  rb_define_method(geos_geometry_class, "_as_text", method_geometry_as_text, 0);
   rb_define_method(geos_geometry_class, "as_binary", method_geometry_as_binary, 0);
   rb_define_method(geos_geometry_class, "is_empty?", method_geometry_is_empty, 0);
   rb_define_method(geos_geometry_class, "is_simple?", method_geometry_is_simple, 0);

data/lib/rgeo/cartesian/factory.rb

@@ -326,6 +326,52 @@ module RGeo
       end
 
 
+      def _generate_wkt(obj_)  # :nodoc:
+        @wkt_generator.generate(obj_)
+      end
+
+
+      def _generate_wkb(obj_)  # :nodoc:
+        @wkb_generator.generate(obj_)
+      end
+
+
+      def _marshal_wkb_generator  # :nodoc:
+        unless defined?(@marshal_wkb_generator)
+          @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(
+            :type_format => :wkb12)
+        end
+        @marshal_wkb_generator
+      end
+
+
+      def _marshal_wkb_parser  # :nodoc:
+        unless defined?(@marshal_wkb_parser)
+          @marshal_wkb_parser = ::RGeo::WKRep::WKBParser.new(self,
+            :support_wkb12 => true)
+        end
+        @marshal_wkb_parser
+      end
+
+
+      def _psych_wkt_generator  # :nodoc:
+        unless defined?(@psych_wkt_generator)
+          @psych_wkt_generator = ::RGeo::WKRep::WKTGenerator.new(
+            :tag_format => :wkt12)
+        end
+        @psych_wkt_generator
+      end
+
+
+      def _psych_wkt_parser  # :nodoc:
+        unless defined?(@psych_wkt_parser)
+          @psych_wkt_parser = ::RGeo::WKRep::WKTParser.new(self,
+            :support_wkt12 => true, :support_ewkt => true)
+        end
+        @psych_wkt_parser
+      end
+
+
     end
 
 

data/lib/rgeo/coord_sys/proj4.rb

@@ -117,6 +117,9 @@ module RGeo
       def canonical_str
         unless defined?(@canonical_str)
           @canonical_str = _canonical_str
+          if @canonical_str.respond_to?(:force_encoding)
+            @canonical_str.force_encoding('US-ASCII')
+          end
         end
         @canonical_str
       end

data/lib/rgeo/geographic/factory.rb

@@ -432,6 +432,52 @@ module RGeo
       end
 
 
+      def _generate_wkt(obj_)  # :nodoc:
+        @wkt_generator.generate(obj_)
+      end
+
+
+      def _generate_wkb(obj_)  # :nodoc:
+        @wkb_generator.generate(obj_)
+      end
+
+
+      def _marshal_wkb_generator  # :nodoc:
+        unless defined?(@marshal_wkb_generator)
+          @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(
+            :type_format => :wkb12)
+        end
+        @marshal_wkb_generator
+      end
+
+
+      def _marshal_wkb_parser  # :nodoc:
+        unless defined?(@marshal_wkb_parser)
+          @marshal_wkb_parser = ::RGeo::WKRep::WKBParser.new(self,
+            :support_wkb12 => true)
+        end
+        @marshal_wkb_parser
+      end
+
+
+      def _psych_wkt_generator  # :nodoc:
+        unless defined?(@psych_wkt_generator)
+          @psych_wkt_generator = ::RGeo::WKRep::WKTGenerator.new(
+            :tag_format => :wkt12)
+        end
+        @psych_wkt_generator
+      end
+
+
+      def _psych_wkt_parser  # :nodoc:
+        unless defined?(@psych_wkt_parser)
+          @psych_wkt_parser = ::RGeo::WKRep::WKTParser.new(self,
+            :support_wkt12 => true, :support_ewkt => true)
+        end
+        @psych_wkt_parser
+      end
+
+
     end
 
   end

data/lib/rgeo/geos/ffi_classes.rb

@@ -120,6 +120,39 @@ module RGeo
       end
 
 
+      # Marshal support
+
+      def marshal_dump  # :nodoc:
+        [@factory, @factory._write_for_marshal(@fg_geom)]
+      end
+
+      def marshal_load(data_)  # :nodoc:
+        @factory = data_[0]
+        @fg_geom = @factory._read_for_marshal(data_[1])
+        @fg_geom.srid = @factory.srid
+        @_fg_prep = @factory._auto_prepare ? 1 : 0
+        @_klasses = nil
+      end
+
+
+      # Psych support
+
+      def encode_with(coder_)  # :nodoc:
+        coder_['factory'] = @factory
+        str_ = @factory._write_for_psych(@fg_geom)
+        str_ = str_.encode('US-ASCII') if str_.respond_to?(:encode)
+        coder_['wkt'] = str_
+      end
+
+      def init_with(coder_)  # :nodoc:
+        @factory = coder_['factory']
+        @fg_geom = @factory._read_for_psych(coder_['wkt'])
+        @fg_geom.srid = @factory.srid
+        @_fg_prep = @factory._auto_prepare ? 1 : 0
+        @_klasses = nil
+      end
+
+
       attr_reader :factory
       attr_reader :fg_geom
 
@@ -184,7 +217,9 @@ module RGeo
 
 
       def as_text
-        @factory._generate_wkt(self)
+        str_ = @factory._generate_wkt(self)
+        str_.force_encoding('US-ASCII') if str_.respond_to?(:force_encoding)
+        str_
       end
       alias_method :to_s, :as_text
 

data/lib/rgeo/geos/ffi_factory.rb

@@ -600,6 +600,40 @@ module RGeo
       end
 
 
+      def _write_for_marshal(obj_)  # :nodoc:
+        unless defined?(@marshal_wkb_writer)
+          @marshal_wkb_writer = ::Geos::WkbWriter.new
+          @marshal_wkb_writer.output_dimensions = (@_has_3d ? 3 : 2)
+        end
+        @marshal_wkb_writer.write(obj_)
+      end
+
+
+      def _read_for_marshal(str_)  # :nodoc:
+        unless defined?(@marshal_wkb_reader)
+          @marshal_wkb_reader = ::Geos::WkbReader.new
+        end
+        @marshal_wkb_reader.read(str_)
+      end
+
+
+      def _write_for_psych(obj_)  # :nodoc:
+        unless defined?(@psych_wkt_writer)
+          @psych_wkt_writer = ::Geos::WktWriter.new
+          @psych_wkt_writer.output_dimensions = (@_has_3d ? 3 : 2)
+        end
+        @psych_wkt_writer.write(obj_)
+      end
+
+
+      def _read_for_psych(str_)  # :nodoc:
+        unless defined?(@psych_wkt_reader)
+          @psych_wkt_reader = ::Geos::WktReader.new
+        end
+        @psych_wkt_reader.read(str_)
+      end
+
+
     end
 
 

data/lib/rgeo/geos/impl_additions.rb

@@ -46,6 +46,44 @@ module RGeo
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
 
+
+      # Marshal support
+
+      def marshal_dump  # :nodoc:
+        factory_ = self.factory
+        [factory_, factory_._write_for_marshal(self)]
+      end
+
+      def marshal_load(data_)  # :nodoc:
+        obj_ = data_[0]._read_for_marshal(data_[1])
+        _steal(obj_)
+      end
+
+
+      # Psych support
+
+      def encode_with(coder_)  # :nodoc:
+        factory_ = self.factory
+        coder_['factory'] = factory_
+        str_ = factory_._write_for_psych(self)
+        str_ = str_.encode('US-ASCII') if str_.respond_to?(:encode)
+        coder_['wkt'] = str_
+      end
+
+      def init_with(coder_)  # :nodoc:
+        obj_ = coder_['factory']._read_for_psych(coder_['wkt'])
+        _steal(obj_)
+      end
+
+
+      def as_text
+        str_ = _as_text
+        str_.force_encoding('US-ASCII') if str_.respond_to?(:force_encoding)
+        str_
+      end
+      alias_method :to_s, :as_text
+
+
     end
 
 

data/lib/rgeo/geos/zm_factory.rb

@@ -184,11 +184,13 @@ module RGeo
         coder_['wkb_parser'] = @wkb_parser._properties
         coder_['auto_prepare'] = @zfactory.property(:auto_prepare).to_s
         coder_['native_interface'] = @zfactory.is_a?(FFIFactory) ? 'ffi' : 'capi'
-        if @proj4
-          str_ = @proj4.original_str || @proj4.canonical_str
-          coder_['proj4'] = @proj4.radians? ? {'proj4' => str_, 'radians' => true} : str_
+        if (proj4_ = @zfactory.proj4)
+          str_ = proj4_.original_str || proj4_.canonical_str
+          coder_['proj4'] = proj4_.radians? ? {'proj4' => str_, 'radians' => true} : str_
+        end
+        if (coord_sys_ = @zfactory.coord_sys)
+          coder_['coord_sys'] = coord_sys_.to_wkt
         end
-        coder_['coord_sys'] = @coord_sys.to_wkt if @coord_sys
       end
 
       def init_with(coder_)  # :nodoc:
@@ -408,6 +410,42 @@ module RGeo
       end
 
 
+      def _marshal_wkb_generator  # :nodoc:
+        unless defined?(@marshal_wkb_generator)
+          @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(
+            :type_format => :wkb12)
+        end
+        @marshal_wkb_generator
+      end
+
+
+      def _marshal_wkb_parser  # :nodoc:
+        unless defined?(@marshal_wkb_parser)
+          @marshal_wkb_parser = ::RGeo::WKRep::WKBParser.new(self,
+            :support_wkb12 => true)
+        end
+        @marshal_wkb_parser
+      end
+
+
+      def _psych_wkt_generator  # :nodoc:
+        unless defined?(@psych_wkt_generator)
+          @psych_wkt_generator = ::RGeo::WKRep::WKTGenerator.new(
+            :tag_format => :wkt12)
+        end
+        @psych_wkt_generator
+      end
+
+
+      def _psych_wkt_parser  # :nodoc:
+        unless defined?(@psych_wkt_parser)
+          @psych_wkt_parser = ::RGeo::WKRep::WKTParser.new(self,
+            :support_wkt12 => true, :support_ewkt => true)
+        end
+        @psych_wkt_parser
+      end
+
+
     end
 
 

data/lib/rgeo/geos/zm_impl.rb

@@ -121,53 +121,53 @@ module RGeo
 
 
       def equals?(rhs_)
-        @zgeometry.equals?(rhs_)
+        @zgeometry.equals?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def disjoint?(rhs_)
-        @zgeometry.disjoint?(rhs_)
+        @zgeometry.disjoint?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def intersects?(rhs_)
-        @zgeometry.intersects?(rhs_)
+        @zgeometry.intersects?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def touches?(rhs_)
-        @zgeometry.touches?(rhs_)
+        @zgeometry.touches?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def crosses?(rhs_)
-        @zgeometry.crosses?(rhs_)
+        @zgeometry.crosses?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def within?(rhs_)
-        @zgeometry.within?(rhs_)
+        @zgeometry.within?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def contains?(rhs_)
-        @zgeometry.contains?(rhs_)
+        @zgeometry.contains?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def overlaps?(rhs_)
-        @zgeometry.overlaps?(rhs_)
+        @zgeometry.overlaps?(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
       def relate?(rhs_, pattern_)
-        @zgeometry.relate?(rhs_, pattern_)
+        @zgeometry.relate?(::RGeo::Feature.cast(rhs_, self).z_geometry, pattern_)
       end
       alias_method :relate, :relate?  # DEPRECATED
 
 
       def distance(rhs_)
-        @zgeometry.distance(rhs_)
+        @zgeometry.distance(::RGeo::Feature.cast(rhs_, self).z_geometry)
       end
 
 
@@ -182,26 +182,31 @@ module RGeo
 
 
       def intersection(rhs_)
-        ZMGeometryImpl.create(@factory, @zgeometry.intersection(rhs_), @mgeometry.intersection(rhs_))
+        rhs_ = ::RGeo::Feature.cast(rhs_, self)
+        ZMGeometryImpl.create(@factory, @zgeometry.intersection(rhs_.z_geometry), @mgeometry.intersection(rhs_.m_geometry))
       end
 
 
       def union(rhs_)
-        ZMGeometryImpl.create(@factory, @zgeometry.union(rhs_), @mgeometry.union(rhs_))
+        rhs_ = ::RGeo::Feature.cast(rhs_, self)
+        ZMGeometryImpl.create(@factory, @zgeometry.union(rhs_.z_geometry), @mgeometry.union(rhs_.m_geometry))
       end
 
 
       def difference(rhs_)
-        ZMGeometryImpl.create(@factory, @zgeometry.difference(rhs_), @mgeometry.difference(rhs_))
+        rhs_ = ::RGeo::Feature.cast(rhs_, self)
+        ZMGeometryImpl.create(@factory, @zgeometry.difference(rhs_.z_geometry), @mgeometry.difference(rhs_.m_geometry))
       end
 
 
       def sym_difference(rhs_)
-        ZMGeometryImpl.create(@factory, @zgeometry.sym_difference(rhs_), @mgeometry.sym_difference(rhs_))
+        rhs_ = ::RGeo::Feature.cast(rhs_, self)
+        ZMGeometryImpl.create(@factory, @zgeometry.sym_difference(rhs_.z_geometry), @mgeometry.sym_difference(rhs_.m_geometry))
       end
 
 
       def rep_equals?(rhs_)
+        rhs_ = ::RGeo::Feature.cast(rhs_, self)
         rhs_.is_a?(self.class) && @factory.eql?(rhs_.factory) && @zgeometry.rep_equals?(rhs_.z_geometry) && @mgeometry.rep_equals?(rhs_.m_geometry)
       end
 
@@ -213,6 +218,33 @@ module RGeo
       alias_method :+, :union
       alias_method :*, :intersection
 
+
+      def _copy_state_from(obj_)  # :nodoc:
+        @factory = obj_.factory
+        @zgeometry = obj_.z_geometry
+        @mgeometry = obj_.m_geometry
+      end
+
+
+      def marshal_dump  # :nodoc:
+        [@factory, @factory._marshal_wkb_generator.generate(self)]
+      end
+
+      def marshal_load(data_)  # :nodoc:
+        obj_ = data_[0]._marshal_wkb_parser.parse(data_[1])
+        _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
+      end
+
+
+      def encode_with(coder_)  # :nodoc:
+        coder_['factory'] = @factory
+        coder_['wkt'] = @factory._psych_wkt_generator.generate(self)
+      end
+
+      def init_with(coder_)  # :nodoc:
+        _copy_state_from(coder_['factory']._psych_wkt_parser.parse(coder_['wkt']))
+      end
+
     end
 
 

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -106,6 +106,17 @@ module RGeo
       end
 
 
+      def _copy_state_from(obj_)  # :nodoc:
+        super
+        @elements = obj_._elements
+      end
+
+
+      def _elements  # :nodoc:
+        @elements
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -68,12 +68,37 @@ module RGeo
 
 
       def as_text
-        @factory.instance_variable_get(:@wkt_generator).generate(self)
+        @factory._generate_wkt(self)
       end
 
 
       def as_binary
-        @factory.instance_variable_get(:@wkb_generator).generate(self)
+        @factory._generate_wkb(self)
+      end
+
+
+      def _copy_state_from(obj_)  # :nodoc:
+        @factory = obj_.factory
+      end
+
+
+      def marshal_dump  # :nodoc:
+        [@factory, @factory._marshal_wkb_generator.generate(self)]
+      end
+
+      def marshal_load(data_)  # :nodoc:
+        obj_ = data_[0]._marshal_wkb_parser.parse(data_[1])
+        _copy_state_from(data_[0]._marshal_wkb_parser.parse(data_[1]))
+      end
+
+
+      def encode_with(coder_)  # :nodoc:
+        coder_['factory'] = @factory
+        coder_['wkt'] = @factory._psych_wkt_generator.generate(self)
+      end
+
+      def init_with(coder_)  # :nodoc:
+        _copy_state_from(coder_['factory']._psych_wkt_parser.parse(coder_['wkt']))
       end
 
 

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -133,6 +133,12 @@ module RGeo
       end
 
 
+      def _copy_state_from(obj_)  # :nodoc:
+        super
+        @points = obj_.points
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -130,6 +130,15 @@ module RGeo
       end
 
 
+      def _copy_state_from(obj_)  # :nodoc:
+        super
+        @x = obj_.x
+        @y = obj_.y
+        @z = obj_.z
+        @m = obj_.m
+      end
+
+
     end
 
 

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -113,6 +113,13 @@ module RGeo
       end
 
 
+      def _copy_state_from(obj_)  # :nodoc:
+        super
+        @exterior_ring = obj_.exterior_ring
+        @interior_rings = obj_.interior_rings
+      end
+
+
     end
 
 

data/test/common/line_string_tests.rb

@@ -333,6 +333,30 @@ module RGeo
         end
 
 
+        def test_marshal_roundtrip
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          data_ = ::Marshal.dump(line1_)
+          line2_ = ::Marshal.load(data_)
+          assert_equal(line1_, line2_)
+        end
+
+
+        if ::RGeo.yaml_supported?
+
+          def test_psych_roundtrip
+            point1_ = @factory.point(0, 0)
+            point2_ = @factory.point(0, 1)
+            line1_ = @factory.line_string([point1_, point2_])
+            data_ = ::Psych.dump(line1_)
+            line2_ = ::Psych.load(data_)
+            assert_equal(line1_, line2_)
+          end
+
+        end
+
+
       end
 
     end

data/test/common/point_tests.rb

@@ -334,6 +334,58 @@ module RGeo
         end
 
 
+        def test_marshal_roundtrip
+          point_ = @factory.point(11, 12)
+          data_ = ::Marshal.dump(point_)
+          point2_ = ::Marshal.load(data_)
+          assert_equal(point_, point2_)
+        end
+
+
+        def test_marshal_roundtrip_3d
+          point_ = @zfactory.point(11, 12, 13)
+          data_ = ::Marshal.dump(point_)
+          point2_ = ::Marshal.load(data_)
+          assert_equal(point_, point2_)
+        end
+
+
+        def test_marshal_roundtrip_4d
+          point_ = @zmfactory.point(11, 12, 13, 14)
+          data_ = ::Marshal.dump(point_)
+          point2_ = ::Marshal.load(data_)
+          assert_equal(point_, point2_)
+        end
+
+
+        if ::RGeo.yaml_supported?
+
+          def test_psych_roundtrip
+            point_ = @factory.point(11, 12)
+            data_ = ::Psych.dump(point_)
+            point2_ = ::Psych.load(data_)
+            assert_equal(point_, point2_)
+          end
+
+
+          def test_psych_roundtrip_3d
+            point_ = @zfactory.point(11, 12, 13)
+            data_ = ::Psych.dump(point_)
+            point2_ = ::Psych.load(data_)
+            assert_equal(point_, point2_)
+          end
+
+
+          def test_psych_roundtrip_4d
+            point_ = @zmfactory.point(11, 12, 13, 14)
+            data_ = ::Psych.dump(point_)
+            point2_ = ::Psych.load(data_)
+            assert_equal(point_, point2_)
+          end
+
+        end
+
+
       end
 
     end

data/test/geos_capi/tc_point.rb

@@ -79,6 +79,24 @@ module RGeo
         end
 
 
+        if defined?(::Encoding)
+
+          def test_as_text_encoding
+            factory_ = ::RGeo::Geos.factory(:wkt_generator => :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::US_ASCII, point_.as_text.encoding)
+          end
+
+
+          def test_as_binary_encoding
+            factory_ = ::RGeo::Geos.factory(:wkb_generator => :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::ASCII_8BIT, point_.as_binary.encoding)
+          end
+
+        end
+
+
       end
 
     end

data/test/geos_ffi/tc_point.rb

@@ -80,6 +80,24 @@ module RGeo
         end
 
 
+        if defined?(::Encoding)
+
+          def test_as_text_encoding
+            factory_ = ::RGeo::Geos.factory(:native_interface => :ffi, :wkt_generator => :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::US_ASCII, point_.as_text.encoding)
+          end
+
+
+          def test_as_binary_encoding
+            factory_ = ::RGeo::Geos.factory(:native_interface => :ffi, :wkb_generator => :geos)
+            point_ = factory_.point(11, 12)
+            assert_equal(::Encoding::ASCII_8BIT, point_.as_binary.encoding)
+          end
+
+        end
+
+
       end
 
     end

data/test/tc_oneoff.rb

@@ -53,7 +53,7 @@ module RGeo
       end
 
 
-      def test_dummy
+      def test_dummy1
       end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000 Z
+date: 2012-03-13 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