rgeo 0.3.5 → 0.3.6

data/lib/rgeo/coord_sys/srs_database/active_record_table.rb

@@ -127,8 +127,10 @@ module RGeo
             @ar_class = ::Class.new(ar_base_class_)
             self.class.const_set("Klass#{@@class_counter}", @ar_class)
             @@class_counter += 1
-            @ar_class.class_eval do
-              establish_connection(opts_[:database_config]) if opts_[:database_config]
+            if opts_[:database_config]
+              @ar_class.class_eval do
+                establish_connection(opts_[:database_config])
+              end
             end
           end
           connection_ = @ar_class.connection
@@ -137,7 +139,7 @@ module RGeo
           end
           unless opts_[:ar_class]
             @ar_class.class_eval do
-              set_table_name(opts_[:table_name] || 'spatial_ref_sys')
+              self.table_name = opts_[:table_name] || 'spatial_ref_sys'
             end
           end
           @srid_column = opts_[:srid_column] || 'srid'

data/lib/rgeo/feature/geometry.rb

@@ -452,11 +452,18 @@ module RGeo
       # this geometry, strictly speaking, the result of comparing objects
       # from different factories is undefined.
 
-      def relate(another_geometry_, intersection_pattern_matrix_)
+      def relate?(another_geometry_, intersection_pattern_matrix_)
         raise Error::UnsupportedOperation, "Method Geometry#relate not defined."
       end
 
 
+      # Deprecated alias of Geometry#relate?
+
+      def relate(another_geometry_, intersection_pattern_matrix_)
+        relate?(another_geometry_, intersection_pattern_matrix_)
+      end
+
+
       # === SFS 1.1 Description
       #
       # Returns the shortest distance between any two Points in the two

data/lib/rgeo/geographic/factory.rb

@@ -61,7 +61,7 @@ module RGeo
         @multi_polygon_class = Geographic.const_get("#{impl_prefix_}MultiPolygonImpl")
         @support_z = opts_[:has_z_coordinate] ? true : false
         @support_m = opts_[:has_m_coordinate] ? true : false
-        @srid = opts_[:srid] || 4326
+        @srid = (opts_[:srid] || 4326).to_i
         @proj4 = opts_[:proj4]
         if CoordSys::Proj4.supported?
           if @proj4.kind_of?(::String) || @proj4.kind_of?(::Hash)
@@ -74,6 +74,7 @@ module RGeo
         if @coord_sys.kind_of?(::String)
           @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys) rescue nil
         end
+        @lenient_assertions = opts_[:uses_lenient_assertions] ? true : false
 
         wkt_generator_ = opts_[:wkt_generator]
         case wkt_generator_
@@ -103,6 +104,7 @@ module RGeo
         else
           @wkb_parser = WKRep::WKBParser.new(self)
         end
+        @projector = nil
       end
 
 
@@ -123,6 +125,125 @@ module RGeo
       alias_method :==, :eql?
 
 
+      # Marshal support
+
+      def marshal_dump  # :nodoc:
+        hash_ = {
+          'pref' => @impl_prefix,
+          'hasz' => @support_z,
+          'hasm' => @support_m,
+          'srid' => @srid,
+          'wktg' => @wkt_generator._properties,
+          '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
+        if @projector
+          hash_['prjc'] = @projector.class.name.sub(/.*::/, '')
+          hash_['prjf'] = @projector.projection_factory
+        end
+        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(data_['pref'],
+          :has_z_coordinate => data_['hasz'],
+          :has_m_coordinate => data_['hasm'],
+          :srid => data_['srid'],
+          :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_
+        )
+        if (projklass_ = data_['prjc']) && (projfactory_ = data_['prjf'])
+          klass_ = ::RGeo::Geographic.const_get(projklass_) rescue nil
+          if klass_
+            projector_ = klass_.allocate
+            projector_._set_factories(self, projfactory_)
+            _set_projector(projector_)
+          end
+        end
+      end
+
+
+      # Psych support
+
+      def encode_with(coder_)  # :nodoc:
+        coder_['impl_prefix'] = @impl_prefix
+        coder_['has_z_coordinate'] = @support_z
+        coder_['has_m_coordinate'] = @support_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
+        coder_['lenient_assertions'] = @lenient_assertions
+        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
+        if @projector
+          coder_['projector_class'] = @projector.class.name.sub(/.*::/, '')
+          coder_['projection_factory'] = @projector.projection_factory
+        end
+      end
+
+      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_ = coder_['cs'])
+          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
+        else
+          coord_sys_ = nil
+        end
+        initialize(coder_['impl_prefix'],
+          :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_
+        )
+        if (projklass_ = coder_['projector_class']) && (projfactory_ = coder_['projection_factory'])
+          klass_ = ::RGeo::Geographic.const_get(projklass_) rescue nil
+          if klass_
+            projector_ = klass_.allocate
+            projector_._set_factories(self, projfactory_)
+            _set_projector(projector_)
+          end
+        end
+      end
+
+
       # Returns the srid reported by this factory.
 
       def srid
@@ -210,6 +331,8 @@ module RGeo
           @support_z
         when :has_m_coordinate
           @support_m
+        when :uses_lenient_assertions
+          @lenient_assertions
         when :is_geographic
           true
         else

data/lib/rgeo/geographic/interface.rb

@@ -86,6 +86,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>:proj4</tt>]
       #   Provide the coordinate system in Proj4 format. You may pass
       #   either an RGeo::CoordSys::Proj4 object, or a string or hash

data/lib/rgeo/geographic/proj4_projector.rb

@@ -48,6 +48,12 @@ module RGeo
       end
 
 
+      def _set_factories(geography_factory_, projection_factory_)  # :nodoc:
+        @geography_factory = geography_factory_
+        @projection_factory = projection_factory_
+      end
+
+
       def project(geometry_)
         Feature.cast(geometry_, @projection_factory, :project)
       end

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -56,6 +56,12 @@ module RGeo
       end
 
 
+      def _set_factories(geography_factory_, projection_factory_)  # :nodoc:
+        @geography_factory = geography_factory_
+        @projection_factory = projection_factory_
+      end
+
+
       def projection_factory
         @projection_factory
       end

data/lib/rgeo/geos/factory.rb

@@ -117,7 +117,8 @@ module RGeo
           srid_ ||= coord_sys_.authority_code if coord_sys_
 
           # Create the factory and set instance variables
-          result_ = _create(flags_, srid_.to_i, buffer_resolution_, wkt_generator_, wkb_generator_)
+          result_ = _create(flags_, srid_.to_i, buffer_resolution_,
+            wkt_generator_, wkb_generator_, proj4_, coord_sys_)
 
           # Interpret parser options
           wkt_parser_ = opts_[:wkt_parser]
@@ -138,14 +139,7 @@ module RGeo
           else
             wkb_parser_ = WKRep::WKBParser.new(result_)
           end
-
-          # Set instance variables
-          result_.instance_variable_set(:@proj4, proj4_)
-          result_.instance_variable_set(:@coord_sys, coord_sys_)
-          result_.instance_variable_set(:@wkt_parser, wkt_parser_)
-          result_.instance_variable_set(:@wkb_parser, wkb_parser_)
-          result_.instance_variable_set(:@wkt_generator, wkt_generator_)
-          result_.instance_variable_set(:@wkb_generator, wkb_generator_)
+          result_._set_wkrep_parsers(wkt_parser_, wkb_parser_)
 
           # Return the result
           result_
@@ -166,11 +160,118 @@ module RGeo
       def eql?(rhs_)
         rhs_.is_a?(Factory) && rhs_.srid == _srid &&
           rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags &&
-          rhs_.proj4 == @proj4
+          rhs_.proj4 == _proj4
       end
       alias_method :==, :eql?
 
 
+      # Marshal support
+
+      def marshal_dump  # :nodoc:
+        hash_ = {
+          'hasz' => (_flags & 0x2 != 0),
+          'hasm' => (_flags & 0x4 != 0),
+          'srid' => _srid,
+          'bufr' => _buffer_resolution,
+          'wktg' => _wkt_generator._properties,
+          'wkbg' => _wkb_generator._properties,
+          'wktp' => _wkt_parser._properties,
+          'wkbp' => _wkb_parser._properties,
+          'lmpa' => (_flags & 0x1 != 0),
+          'apre' => ((_flags & 0x8) >> 3),
+        }
+        if (proj4_ = self._proj4)
+          hash_['proj4'] = proj4_.marshal_dump
+        end
+        if (coord_sys_ = self._coord_sys)
+          hash_['cs'] = coord_sys_.to_wkt
+        end
+        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_copy(Factory.create(
+          :has_z_coordinate => data_['hasz'],
+          :has_m_coordinate => data_['hasm'],
+          :srid => data_['srid'],
+          :buffer_resolution => data_['bufr'],
+          :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_multi_polygon_assertions => data_['lmpa'],
+          :auto_prepare => (data_['apre'] == 0 ? :disabled : :simple),
+          :proj4 => proj4_,
+          :coord_sys => coord_sys_
+        ))
+      end
+
+
+      # Psych support
+
+      def encode_with(coder_)  # :nodoc:
+        coder_['has_z_coordinate'] = (_flags & 0x2 != 0)
+        coder_['has_m_coordinate'] = (_flags & 0x4 != 0)
+        coder_['srid'] = _srid
+        coder_['buffer_resolution'] = _buffer_resolution
+        coder_['lenient_multi_polygon_assertions'] = (_flags & 0x1 != 0)
+        coder_['wkt_generator'] = _wkt_generator._properties
+        coder_['wkb_generator'] = _wkb_generator._properties
+        coder_['wkt_parser'] = _wkt_parser._properties
+        coder_['wkb_parser'] = _wkb_parser._properties
+        coder_['auto_prepare'] = ((_flags & 0x8) == 0 ? 'disabled' : 'simple')
+        if (proj4_ = self._proj4)
+          str_ = proj4_.original_str || proj4_.canonical_str
+          coder_['proj4'] = proj4_.radians? ? {'proj4' => str_, 'radians' => true} : str_
+        end
+        if (coord_sys_ = self._coord_sys)
+          coder_['coord_sys'] = coord_sys_.to_wkt
+        end
+      end
+
+      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_ = coder_['cs'])
+          coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_data_.to_s)
+        else
+          coord_sys_ = nil
+        end
+        initialize_copy(Factory.create(
+          :has_z_coordinate => coder_['has_z_coordinate'],
+          :has_m_coordinate => coder_['has_m_coordinate'],
+          :srid => coder_['srid'],
+          :buffer_resolution => coder_['buffer_resolution'],
+          :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']),
+          :auto_prepare => coder_['auto_prepare'] == 'disabled' ? :disabled : :simple,
+          :uses_lenient_multi_polygon_assertions => coder_['lenient_multi_polygon_assertions'],
+          :proj4 => proj4_,
+          :coord_sys => coord_sys_
+        ))
+      end
+
+
       # Returns the SRID of geometries created by this factory.
 
       def srid
@@ -218,8 +319,8 @@ module RGeo
       # See ::RGeo::Feature::Factory#parse_wkt
 
       def parse_wkt(str_)
-        if @wkt_parser
-          @wkt_parser.parse(str_)
+        if (wkt_parser_ = self._wkt_parser)
+          wkt_parser_.parse(str_)
         else
           _parse_wkt_impl(str_)
         end
@@ -229,8 +330,8 @@ module RGeo
       # See ::RGeo::Feature::Factory#parse_wkb
 
       def parse_wkb(str_)
-        if @wkb_parser
-          @wkb_parser.parse(str_)
+        if (wkb_parser_ = self._wkb_parser)
+          wkb_parser_.parse(str_)
         else
           _parse_wkb_impl(str_)
         end
@@ -314,14 +415,14 @@ module RGeo
       # See ::RGeo::Feature::Factory#proj4
 
       def proj4
-        @proj4
+        _proj4
       end
 
 
       # See ::RGeo::Feature::Factory#coord_sys
 
       def coord_sys
-        @coord_sys
+        _coord_sys
       end
 
 
@@ -340,7 +441,7 @@ module RGeo
           # factories are zm-compatible and proj4-compatible.
           if original_.factory != self && ntype_ == type_ &&
               original_.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project_ || original_.factory.proj4 == @proj4)
+              (!project_ || original_.factory.proj4 == _proj4)
           then
             result_ = original_.dup
             result_._set_factory(self)
@@ -349,7 +450,7 @@ module RGeo
           # LineString conversion optimization.
           if (original_.factory != self || ntype_ != type_) &&
               original_.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project_ || original_.factory.proj4 == @proj4) &&
+              (!project_ || original_.factory.proj4 == _proj4) &&
               type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
           then
             return IMPL_CLASSES[ntype_]._copy_from(self, original_)

data/lib/rgeo/geos/ffi_classes.rb

@@ -96,7 +96,6 @@ module RGeo
 
       end
 
-
     end
 
 
@@ -298,10 +297,11 @@ module RGeo
       end
 
 
-      def relate(rhs_, pattern_)
+      def relate?(rhs_, pattern_)
         fg_ = factory._convert_to_fg_geometry(rhs_)
         fg_ ? @fg_geom.relate_pattern(fg_, pattern_) : nil
       end
+      alias_method :relate, :relate?  # DEPRECATED
 
 
       def distance(rhs_)
@@ -651,9 +651,14 @@ module RGeo
 
 
       def each
-        @fg_geom.num_geometries.times do |n_|
-          yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n_),
-            @_klasses ? @_klasses[n_] : nil)
+        if block_given?
+          @fg_geom.num_geometries.times do |n_|
+            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n_),
+              @_klasses ? @_klasses[n_] : nil)
+          end
+          self
+        else
+          enum_for
         end
       end