rgeo 0.3.5 → 0.3.6

data/History.rdoc

@@ -1,3 +1,14 @@
+=== 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.
+* Cloning a Geos CAPI factory caused a segfault. Fixed.
+* Parsing a "well-known" format string using the ffi-geos implementation returned the low-level ffi-geos object rather than the RGeo feature if the generator was set to :geos. Fixed.
+* GeometryCollection#each now returns an Enumerator if no block is given.
+* Pure Ruby factories (simple_spherical, simple_cartesian) now support a :uses_lenient_assertions option, which disables assertion checking on LinearRing, Polygon, and MultiPolygon construction, since those checks can be expensive for large geometries.
+* Fixed Rails 3.2 deprecation warning in SRSDatabase::ActiveRecordTable.
+* Fixed an issue with the ActiveRecordTable tests on ActiveRecord 3.2.
+* Further work towards YAML and mashal serialization support. Factories are now done, but geometries are not. I'm working actively on geometry serialization; it should be in place in the next release.
+
 === 0.3.5 / 2012-02-27
 
 * Reworked the terminology on equivalence levels. The documentation now names the three levels "spatial", "representational", and "objective" equivalence.

data/Version

@@ -1 +1 @@
-0.3.5
+0.3.6

data/ext/geos_c_impl/factory.c

@@ -69,7 +69,9 @@ static void message_handler(const char* fmt, ...)
 
 static void destroy_factory_func(RGeo_FactoryData* data)
 {
-  GEOSContextHandle_t context = data->geos_context;
+  GEOSContextHandle_t context;
+
+  context = data->geos_context;
   if (data->wkt_reader) {
     GEOSWKTReader_destroy_r(context, data->wkt_reader);
   }
@@ -118,6 +120,18 @@ static void mark_factory_func(RGeo_FactoryData* data)
   if (!NIL_P(data->wkrep_wkb_generator)) {
     rb_gc_mark(data->wkrep_wkb_generator);
   }
+  if (!NIL_P(data->wkrep_wkt_parser)) {
+    rb_gc_mark(data->wkrep_wkt_parser);
+  }
+  if (!NIL_P(data->wkrep_wkb_parser)) {
+    rb_gc_mark(data->wkrep_wkb_parser);
+  }
+  if (!NIL_P(data->proj4_obj)) {
+    rb_gc_mark(data->proj4_obj);
+  }
+  if (!NIL_P(data->coord_sys_obj)) {
+    rb_gc_mark(data->coord_sys_obj);
+  }
 }
 
 
@@ -228,7 +242,7 @@ static VALUE method_factory_parse_wkb(VALUE self, VALUE str)
 
 
 static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE buffer_resolution,
-  VALUE wkt_generator, VALUE wkb_generator)
+  VALUE wkt_generator, VALUE wkb_generator, VALUE proj4_obj, VALUE coord_sys_obj)
 {
   VALUE result;
   RGeo_FactoryData* data;
@@ -252,6 +266,10 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
       data->wkb_writer = NULL;
       data->wkrep_wkt_generator = wkt_generator;
       data->wkrep_wkb_generator = wkb_generator;
+      data->wkrep_wkt_parser = Qnil;
+      data->wkrep_wkb_parser = Qnil;
+      data->proj4_obj = proj4_obj;
+      data->coord_sys_obj = coord_sys_obj;
       result = Data_Wrap_Struct(klass, mark_factory_func, destroy_factory_func, data);
     }
     else {
@@ -262,6 +280,109 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
 }
 
 
+static VALUE alloc_factory(VALUE klass)
+{
+  return cmethod_factory_create(klass, INT2NUM(0), INT2NUM(0), INT2NUM(0), Qnil, Qnil, Qnil, Qnil);
+}
+
+
+static VALUE method_factory_initialize_copy(VALUE self, VALUE orig)
+{
+  RGeo_FactoryData* self_data;
+  RGeo_FactoryData* orig_data;
+  GEOSContextHandle_t context;
+
+  // Clear out existing data
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  context = self_data->geos_context;
+  if (self_data->wkt_reader) {
+    GEOSWKTReader_destroy_r(context, self_data->wkt_reader);
+    self_data->wkt_reader = NULL;
+  }
+  if (self_data->wkb_reader) {
+    GEOSWKBReader_destroy_r(context, self_data->wkb_reader);
+    self_data->wkb_reader = NULL;
+  }
+  if (self_data->wkt_writer) {
+    GEOSWKTWriter_destroy_r(context, self_data->wkt_writer);
+    self_data->wkt_writer = NULL;
+  }
+  if (self_data->wkb_writer) {
+    GEOSWKBWriter_destroy_r(context, self_data->wkb_writer);
+    self_data->wkb_writer = NULL;
+  }
+  self_data->wkrep_wkt_generator = Qnil;
+  self_data->wkrep_wkb_generator = Qnil;
+  self_data->wkrep_wkt_parser = Qnil;
+  self_data->wkrep_wkb_parser = Qnil;
+  self_data->proj4_obj = Qnil;
+  self_data->coord_sys_obj = Qnil;
+
+  // Copy new data from original object
+  if (TYPE(orig) == T_DATA && RDATA(orig)->dfree == (RUBY_DATA_FUNC)destroy_factory_func) {
+    orig_data = RGEO_FACTORY_DATA_PTR(orig);
+    self_data->flags = orig_data->flags;
+    self_data->srid = orig_data->srid;
+    self_data->buffer_resolution = orig_data->buffer_resolution;
+    self_data->wkrep_wkt_generator = orig_data->wkrep_wkt_generator;
+    self_data->wkrep_wkb_generator = orig_data->wkrep_wkb_generator;
+    self_data->wkrep_wkt_parser = orig_data->wkrep_wkt_parser;
+    self_data->wkrep_wkb_parser = orig_data->wkrep_wkb_parser;
+    self_data->proj4_obj = orig_data->proj4_obj;
+    self_data->coord_sys_obj = orig_data->coord_sys_obj;
+  }
+  return self;
+}
+
+
+static VALUE method_set_wkrep_parsers(VALUE self, VALUE wkt_parser, VALUE wkb_parser)
+{
+  RGeo_FactoryData* self_data;
+
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_data->wkrep_wkt_parser = wkt_parser;
+  self_data->wkrep_wkb_parser = wkb_parser;
+
+  return self;
+}
+
+
+static VALUE method_get_proj4(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->proj4_obj;
+}
+
+
+static VALUE method_get_coord_sys(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->coord_sys_obj;
+}
+
+
+static VALUE method_get_wkt_generator(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->wkrep_wkt_generator;
+}
+
+
+static VALUE method_get_wkb_generator(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->wkrep_wkb_generator;
+}
+
+
+static VALUE method_get_wkt_parser(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->wkrep_wkt_parser;
+}
+
+
+static VALUE method_get_wkb_parser(VALUE self)
+{
+  return RGEO_FACTORY_DATA_PTR(self)->wkrep_wkb_parser;
+}
+
+
 /**** INITIALIZATION FUNCTION ****/
 
 
@@ -281,17 +402,27 @@ RGeo_Globals* rgeo_init_geos_factory()
   globals->id_cast = rb_intern("cast");
   globals->id_eql = rb_intern("eql?");
   globals->id_generate = rb_intern("generate");
+  globals->id_enum_for = rb_intern("enum_for");
   globals->sym_force_new = ID2SYM(rb_intern("force_new"));
   globals->sym_keep_subtype = ID2SYM(rb_intern("keep_subtype"));
 
   // Add C methods to the factory.
   geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
+  rb_define_alloc_func(geos_factory_class, alloc_factory);
+  rb_define_method(geos_factory_class, "initialize_copy", method_factory_initialize_copy, 1);
   rb_define_method(geos_factory_class, "_parse_wkt_impl", method_factory_parse_wkt, 1);
   rb_define_method(geos_factory_class, "_parse_wkb_impl", method_factory_parse_wkb, 1);
   rb_define_method(geos_factory_class, "_srid", method_factory_srid, 0);
   rb_define_method(geos_factory_class, "_buffer_resolution", method_factory_buffer_resolution, 0);
   rb_define_method(geos_factory_class, "_flags", method_factory_flags, 0);
-  rb_define_module_function(geos_factory_class, "_create", cmethod_factory_create, 5);
+  rb_define_method(geos_factory_class, "_set_wkrep_parsers", method_set_wkrep_parsers, 2);
+  rb_define_method(geos_factory_class, "_proj4", method_get_proj4, 0);
+  rb_define_method(geos_factory_class, "_coord_sys", method_get_coord_sys, 0);
+  rb_define_method(geos_factory_class, "_wkt_generator", method_get_wkt_generator, 0);
+  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_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
   // to it later. Each factory instance will reference it internally.

data/ext/geos_c_impl/factory.h

@@ -77,6 +77,7 @@ typedef struct {
   ID id_cast;
   ID id_eql;
   ID id_generate;
+  ID id_enum_for;
   VALUE sym_force_new;
   VALUE sym_keep_subtype;
 } RGeo_Globals;
@@ -98,6 +99,10 @@ typedef struct {
   GEOSWKBWriter* wkb_writer;
   VALUE wkrep_wkt_generator;
   VALUE wkrep_wkb_generator;
+  VALUE wkrep_wkt_parser;
+  VALUE wkrep_wkb_parser;
+  VALUE proj4_obj;
+  VALUE coord_sys_obj;
   int flags;
   int srid;
   int buffer_resolution;

data/ext/geos_c_impl/geometry_collection.c

@@ -262,22 +262,28 @@ static VALUE method_geometry_collection_each(VALUE self)
   const GEOSGeometry* elem_geom;
 
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  self_geom = self_data->geom;
-  if (self_geom) {
-    GEOSContextHandle_t self_context = self_data->geos_context;
-    len = GEOSGetNumGeometries_r(self_context, self_geom);
-    if (len > 0) {
-      klasses = self_data->klasses;
-      for (i=0; i<len; ++i) {
-        elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
-        elem = rgeo_wrap_geos_geometry_clone(self_data->factory, elem_geom, NIL_P(klasses) ? Qnil : rb_ary_entry(klasses, i));
-        if (!NIL_P(elem)) {
-          rb_yield(elem);
+
+  if (rb_block_given_p()) {
+    self_geom = self_data->geom;
+    if (self_geom) {
+      GEOSContextHandle_t self_context = self_data->geos_context;
+      len = GEOSGetNumGeometries_r(self_context, self_geom);
+      if (len > 0) {
+        klasses = self_data->klasses;
+        for (i=0; i<len; ++i) {
+          elem_geom = GEOSGetGeometryN_r(self_context, self_geom, i);
+          elem = rgeo_wrap_geos_geometry_clone(self_data->factory, elem_geom, NIL_P(klasses) ? Qnil : rb_ary_entry(klasses, i));
+          if (!NIL_P(elem)) {
+            rb_yield(elem);
+          }
         }
       }
     }
+    return self;
+  }
+  else {
+    return rb_funcall(self, RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->id_enum_for, 0);
   }
-  return self;
 }
 
 

data/lib/rgeo/cartesian/factory.rb

@@ -76,6 +76,7 @@ module RGeo
         end
         srid_ ||= @coord_sys.authority_code if @coord_sys
         @srid = srid_.to_i
+        @lenient_assertions = opts_[:uses_lenient_assertions] ? true : false
 
         wkt_generator_ = opts_[:wkt_generator]
         case wkt_generator_
@@ -127,6 +128,7 @@ module RGeo
           'wkbg' => @wkb_generator._properties,
           'wktp' => @wkt_parser._properties,
           'wkbp' => @wkb_parser._properties,
+          'lena' => @lenient_assertions,
         }
         hash_['proj4'] = @proj4.marshal_dump if @proj4
         hash_['cs'] = @coord_sys.to_wkt if @coord_sys
@@ -145,22 +147,39 @@ module RGeo
         else
           coord_sys_ = nil
         end
-        initialize({
+        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'],
+          :wkt_generator => ImplHelper::Utils.symbolize_hash(data_['wktg']),
+          :wkb_generator => ImplHelper::Utils.symbolize_hash(data_['wkbg']),
+          :wkt_parser => ImplHelper::Utils.symbolize_hash(data_['wktp']),
+          :wkb_parser => ImplHelper::Utils.symbolize_hash(data_['wkbp']),
+          :uses_lenient_assertions => data_['lena'],
           :proj4 => proj4_,
-          :coord_sys => coord_sys_,
-        })
+          :coord_sys => coord_sys_
+        )
       end
 
 
       # Psych support
 
+      def encode_with(coder_)  # :nodoc:
+        coder_['has_z_coordinate'] = @has_z
+        coder_['has_m_coordinate'] = @has_m
+        coder_['srid'] = @srid
+        coder_['lenient_assertions'] = @lenient_assertions
+        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
+
       def init_with(coder_)  # :nodoc:
         if (proj4_data_ = coder_['proj4'])
           if proj4_data_.is_a?(::Hash)
@@ -171,37 +190,23 @@ module RGeo
         else
           proj4_ = nil
         end
-        if (coord_sys_data_ = data_['cs'])
+        if (coord_sys_data_ = coder_['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'],
+        initialize(
+          :has_z_coordinate => coder_['has_z_coordinate'],
+          :has_m_coordinate => coder_['has_m_coordinate'],
+          :srid => coder_['srid'],
+          :wkt_generator => ImplHelper::Utils.symbolize_hash(coder_['wkt_generator']),
+          :wkb_generator => ImplHelper::Utils.symbolize_hash(coder_['wkb_generator']),
+          :wkt_parser => ImplHelper::Utils.symbolize_hash(coder_['wkt_parser']),
+          :wkb_parser => ImplHelper::Utils.symbolize_hash(coder_['wkb_parser']),
+          :uses_lenient_assertions => coder_['lenient_assertions'],
           :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
+          :coord_sys => coord_sys_
+        )
       end
 
 
@@ -220,6 +225,8 @@ module RGeo
           @has_z
         when :has_m_coordinate
           @has_m
+        when :uses_lenient_assertions
+          @lenient_assertions
         when :is_cartesian
           true
         else

data/lib/rgeo/cartesian/interface.rb

@@ -111,6 +111,12 @@ module RGeo
       #   Support a Z coordinate. Default is false.
       # [<tt>:has_m_coordinate</tt>]
       #   Support an M coordinate. Default is false.
+      # [<tt>:uses_lenient_assertions</tt>]
+      #   If set to true, assertion checking is disabled. This includes
+      #   simplicity checking on LinearRing, and validity checks on
+      #   Polygon and MultiPolygon. This may speed up creation of certain
+      #   objects, at the expense of not doing the proper checking for
+      #   OGC compliance. Default is false.
       # [<tt>:wkt_parser</tt>]
       #   Configure the parser for WKT. The value is a hash of
       #   configuration parameters for WKRep::WKTParser.new. Default is

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

@@ -242,6 +242,10 @@ module RGeo
 
         # Psych support
 
+        def encode_with(coder_)  # :nodoc:
+          coder_['wkt'] = to_wkt
+        end
+
         def init_with(coder_)  # :nodoc:
           temp_ = CS.create_from_wkt(coder_.type == :scalar ? coder_.scalar : coder_['wkt'] )
           if temp_.class == self.class
@@ -253,10 +257,6 @@ module RGeo
           end
         end
 
-        def encode_with(coder_)  # :nodoc:
-          coder_['wkt'] = to_wkt
-        end
-
 
         class << self
 

data/lib/rgeo/coord_sys/proj4.rb

@@ -96,6 +96,11 @@ module RGeo
 
       # Psych support
 
+      def encode_with(coder_)  # :nodoc:
+        coder_['proj4'] = original_str || canonical_str
+        coder_['radians'] = radians?
+      end
+
       def init_with(coder_)  # :nodoc:
         if coder_.type == :scalar
           _set_value(coder_.scalar, false)
@@ -104,11 +109,6 @@ module RGeo
         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