rgeo 1.1.2 → 2.2.0

data/lib/rgeo/geographic/spherical_math.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Core calculations on the sphere
@@ -21,11 +23,11 @@ module RGeo
       # of rotation.
 
       class PointXYZ # :nodoc:
-        def initialize(x_, y_, z_)
-          r_ = ::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_)
-          @x = (x_ / r_).to_f
-          @y = (y_ / r_).to_f
-          @z = (z_ / r_).to_f
+        def initialize(x, y, z)
+          r = Math.sqrt(x * x + y * y + z * z)
+          @x = (x / r).to_f
+          @y = (y / r).to_f
+          @z = (z / r).to_f
           raise "Not a number" if @x.nan? || @y.nan? || @z.nan?
         end
 
@@ -37,90 +39,82 @@ module RGeo
         attr_reader :y
         attr_reader :z
 
-        def eql?(rhs_)
-          rhs_.is_a?(PointXYZ) && @x == rhs_.x && @y == rhs_.y && @z == rhs_.z
+        def eql?(rhs)
+          rhs.is_a?(PointXYZ) && @x == rhs.x && @y == rhs.y && @z == rhs.z
         end
         alias == eql?
 
         def latlon
-          lat_rad_ = ::Math.asin(@z)
-          lon_rad_ = begin
-                       ::Math.atan2(@y, @x)
-                     rescue
-                       0.0
-                     end
-          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
-          [lat_rad_ / rpd_, lon_rad_ / rpd_]
+          lat_rad = Math.asin(@z)
+          lon_rad = Math.atan2(@y, @x)
+          rpd = ImplHelper::Math::RADIANS_PER_DEGREE
+          [lat_rad / rpd, lon_rad / rpd]
         end
 
         def lonlat
-          lat_rad_ = ::Math.asin(@z)
-          lon_rad_ = begin
-                       ::Math.atan2(@y, @x)
-                     rescue
-                       0.0
-                     end
-          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
-          [lon_rad_ / rpd_, lat_rad_ / rpd_]
-        end
-
-        def *(rhs_)
-          val_ = @x * rhs_.x + @y * rhs_.y + @z * rhs_.z
-          val_ = 1.0 if val_ > 1.0
-          val_ = -1.0 if val_ < -1.0
-          val_
-        end
-
-        def %(rhs_)
-          rx_ = rhs_.x
-          ry_ = rhs_.y
-          rz_ = rhs_.z
+          lat_rad = Math.asin(@z)
+          lon_rad = Math.atan2(@y, @x)
+          rpd = ImplHelper::Math::RADIANS_PER_DEGREE
+          [lon_rad / rpd, lat_rad / rpd]
+        end
+
+        def *(rhs)
+          val = @x * rhs.x + @y * rhs.y + @z * rhs.z
+          val = 1.0 if val > 1.0
+          val = -1.0 if val < -1.0
+          val
+        end
+
+        def %(rhs)
+          rx = rhs.x
+          ry = rhs.y
+          rz = rhs.z
           begin
-            PointXYZ.new(@y * rz_ - @z * ry_, @z * rx_ - @x * rz_, @x * ry_ - @y * rx_)
-          rescue
+            PointXYZ.new(@y * rz - @z * ry, @z * rx - @x * rz, @x * ry - @y * rx)
+          rescue StandardError
             nil
           end
         end
 
-        def dist_to_point(rhs_)
-          rx_ = rhs_.x
-          ry_ = rhs_.y
-          rz_ = rhs_.z
-          dot_ = @x * rx_ + @y * ry_ + @z * rz_
-          if dot_ > -0.8 && dot_ < 0.8
-            ::Math.acos(dot_)
+        def dist_to_point(rhs)
+          rx = rhs.x
+          ry = rhs.y
+          rz = rhs.z
+          dot = @x * rx + @y * ry + @z * rz
+          if dot > -0.8 && dot < 0.8
+            Math.acos(dot)
           else
-            x_ = @y * rz_ - @z * ry_
-            y_ = @z * rx_ - @x * rz_
-            z_ = @x * ry_ - @y * rx_
-            as_ = ::Math.asin(::Math.sqrt(x_ * x_ + y_ * y_ + z_ * z_))
-            dot_ > 0.0 ? as_ : ::Math::PI - as_
+            x = @y * rz - @z * ry
+            y = @z * rx - @x * rz
+            z = @x * ry - @y * rx
+            as = Math.asin(Math.sqrt(x * x + y * y + z * z))
+            dot > 0.0 ? as : Math::PI - as
           end
         end
 
         # Creates some point that is perpendicular to this point
 
         def create_perpendicular
-          p1dot_ = self * P1
-          p2dot_ = self * P2
-          p1dot_ = -p1dot_ if p1dot_ < 0
-          p2dot_ = -p2dot_ if p2dot_ < 0
-          p1dot_ < p2dot_ ? (self % P1) : (self % P2)
+          p1dot = self * P1
+          p2dot = self * P2
+          p1dot = -p1dot if p1dot < 0
+          p2dot = -p2dot if p2dot < 0
+          p1dot < p2dot ? (self % P1) : (self % P2)
         end
 
-        def self.from_latlon(lat_, lon_)
-          rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
-          lat_rad_ = rpd_ * lat_
-          lon_rad_ = rpd_ * lon_
-          z_ = ::Math.sin(lat_rad_)
-          r_ = ::Math.cos(lat_rad_)
-          x_ = ::Math.cos(lon_rad_) * r_
-          y_ = ::Math.sin(lon_rad_) * r_
-          new(x_, y_, z_)
+        def self.from_latlon(lat, lon)
+          rpd = ImplHelper::Math::RADIANS_PER_DEGREE
+          lat_rad = rpd * lat
+          lon_rad = rpd * lon
+          z = Math.sin(lat_rad)
+          r = Math.cos(lat_rad)
+          x = Math.cos(lon_rad) * r
+          y = Math.sin(lon_rad) * r
+          new(x, y, z)
         end
 
-        def self.weighted_combination(p1_, w1_, p2_, w2_)
-          new(p1_.x * w1_ + p2_.x * w2_, p1_.y * w1_ + p2_.y * w2_, p1_.z * w1_ + p2_.z * w2_)
+        def self.weighted_combination(p1, w1, p2, w2)
+          new(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2, p1.z * w1 + p2.z * w2)
         end
 
         P1 = new(1, 0, 0)
@@ -130,9 +124,9 @@ module RGeo
       # Represents a finite arc on the sphere.
 
       class ArcXYZ # :nodoc:
-        def initialize(start_, end_)
-          @s = start_
-          @e = end_
+        def initialize(start, stop)
+          @s = start
+          @e = stop
           @axis = false
         end
 
@@ -143,14 +137,14 @@ module RGeo
           "#{@s} - #{@e}"
         end
 
-        def eql?(rhs_)
-          rhs_.is_a?(ArcXYZ) && @s == rhs_.s && @e == rhs_.e
+        def eql?(rhs)
+          rhs.is_a?(ArcXYZ) && @s == rhs.s && @e == rhs.e
         end
         alias == eql?
 
         def degenerate?
-          axis_ = axis
-          axis_.x == 0 && axis_.y == 0 && axis_.z == 0
+          my_axis = axis
+          my_axis.x == 0 && my_axis.y == 0 && my_axis.z == 0
         end
 
         def axis
@@ -158,22 +152,22 @@ module RGeo
           @axis
         end
 
-        def contains_point?(obj_)
-          axis_ = axis
-          saxis_ = ArcXYZ.new(@s, obj_).axis
-          eaxis_ = ArcXYZ.new(obj_, @e).axis
-          !saxis_ || !eaxis_ || obj_ * axis_ == 0.0 && saxis_ * axis_ > 0 && eaxis_ * axis_ > 0
+        def contains_point?(obj)
+          my_axis = axis
+          s_axis = ArcXYZ.new(@s, obj).axis
+          e_axis = ArcXYZ.new(obj, @e).axis
+          !s_axis || !e_axis || obj * my_axis == 0.0 && s_axis * my_axis > 0 && e_axis * my_axis > 0
         end
 
-        def intersects_arc?(obj_)
-          my_axis_ = axis
-          dot1_ = my_axis_ * obj_.s
-          dot2_ = my_axis_ * obj_.e
-          if dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
-            ob_axis_ = obj_.axis
-            dot1_ = ob_axis_ * @s
-            dot2_ = ob_axis_ * @e
-            dot1_ >= 0.0 && dot2_ <= 0.0 || dot1_ <= 0.0 && dot2_ >= 0.0
+        def intersects_arc?(obj)
+          my_axis = axis
+          dot1 = my_axis * obj.s
+          dot2 = my_axis * obj.e
+          if dot1 >= 0.0 && dot2 <= 0.0 || dot1 <= 0.0 && dot2 >= 0.0
+            ob_axis = obj.axis
+            dot1 = ob_axis * @s
+            dot2 = ob_axis * @e
+            dot1 >= 0.0 && dot2 <= 0.0 || dot1 <= 0.0 && dot2 >= 0.0
           else
             false
           end

data/lib/rgeo/geos.rb

@@ -1,52 +1,44 @@
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
+
+# The Geos module provides general tools for creating and manipulating
+# a GEOS-backed implementation of the SFS. This is a full implementation
+# of the SFS using a Cartesian coordinate system. It uses the GEOS C++
+# library to perform most operations, and hence is available only if
+# GEOS version 3.2 or later is installed and accessible when the rgeo
+# gem is installed. RGeo feature calls are translated into appropriate
+# GEOS calls and directed to the library's C api. RGeo also corrects a
+# few cases of missing or non-standard behavior in GEOS.
 #
-# GEOS wrapper for RGeo
+# This module also provides a namespace for the implementation classes
+# themselves; however, those classes are meant to be opaque and are
+# therefore not documented.
 #
-# -----------------------------------------------------------------------------
-
-module RGeo
-  # The Geos module provides general tools for creating and manipulating
-  # a GEOS-backed implementation of the SFS. This is a full implementation
-  # of the SFS using a Cartesian coordinate system. It uses the GEOS C++
-  # library to perform most operations, and hence is available only if
-  # GEOS version 3.2 or later is installed and accessible when the rgeo
-  # gem is installed. RGeo feature calls are translated into appropriate
-  # GEOS calls and directed to the library's C api. RGeo also corrects a
-  # few cases of missing or non-standard behavior in GEOS.
-  #
-  # This module also provides a namespace for the implementation classes
-  # themselves; however, those classes are meant to be opaque and are
-  # therefore not documented.
-  #
-  # To use the Geos implementation, first obtain a factory using the
-  # RGeo::Geos.factory method. You may then call any of the standard
-  # factory methods on the resulting object.
-
-  module Geos
-  end
-end
+# To use the Geos implementation, first obtain a factory using the
+# RGeo::Geos.factory method. You may then call any of the standard
+# factory methods on the resulting object.
 
 # :stopdoc:
 
 module RGeo
   module Geos
-    # Implementation files
-    require "rgeo/geos/utils"
-    require "rgeo/geos/interface"
+    require_relative "geos/utils"
+    require_relative "geos/interface"
     begin
-      require "rgeo/geos/geos_c_impl"
-    rescue ::LoadError; end
+      require_relative "geos/geos_c_impl"
+    rescue LoadError
+      # continue
+    end
     CAPI_SUPPORTED = RGeo::Geos.const_defined?(:CAPIGeometryMethods)
     if CAPI_SUPPORTED
-      require "rgeo/geos/capi_feature_classes"
-      require "rgeo/geos/capi_factory"
+      require_relative "geos/capi_feature_classes"
+      require_relative "geos/capi_factory"
     end
-    require "rgeo/geos/ffi_feature_methods"
-    require "rgeo/geos/ffi_feature_classes"
-    require "rgeo/geos/ffi_factory"
-    require "rgeo/geos/zm_feature_methods"
-    require "rgeo/geos/zm_feature_classes"
-    require "rgeo/geos/zm_factory"
+    require_relative "geos/ffi_feature_methods"
+    require_relative "geos/ffi_feature_classes"
+    require_relative "geos/ffi_factory"
+    require_relative "geos/zm_feature_methods"
+    require_relative "geos/zm_feature_classes"
+    require_relative "geos/zm_factory"
 
     # Determine ffi support.
     begin
@@ -56,12 +48,12 @@ module RGeo
       raise "Problem loading FFI" unless ::FFI::AutoPointer
       FFI_SUPPORTED = true
       FFI_SUPPORT_EXCEPTION = nil
-    rescue ::LoadError => ex_
+    rescue LoadError => ex
       FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex_
-    rescue => ex_
+      FFI_SUPPORT_EXCEPTION = ex
+    rescue StandardError => ex
       FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex_
+      FFI_SUPPORT_EXCEPTION = ex
     end
 
     # Default preferred native interface
@@ -71,18 +63,13 @@ module RGeo
       self.preferred_native_interface = :ffi
     end
 
-    # There is some trouble with END_CAP in GEOS
-    # In docs CAP_ROUND = 1, but it's work properly with 0
-    CAP_ROUND  = 0
-    CAP_FLAT   = 1
-    CAP_SQUARE = 2
-
-    JOIN_ROUND = 0
-    JOIN_MITRE = 1
-    JOIN_BEVEL = 2
+    CAP_ROUND  = 1
+    CAP_FLAT   = 2
+    CAP_SQUARE = 3
 
-    # Init internal utilities
-    Utils._init
+    JOIN_ROUND = 1
+    JOIN_MITRE = 2
+    JOIN_BEVEL = 3
   end
 end
 

data/lib/rgeo/geos/capi_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # GEOS factory implementation
@@ -10,6 +12,7 @@ module RGeo
 
     class CAPIFactory
       include Feature::Factory::Instance
+      include ImplHelper::Utils
 
       class << self
         # Create a new factory. Returns nil if the GEOS CAPI implementation
@@ -19,17 +22,17 @@ module RGeo
 
         def create(opts_ = {})
           # Make sure GEOS is available
-          return nil unless respond_to?(:_create)
+          return unless respond_to?(:_create)
 
           # Get flags to pass to the C extension
-          flags_ = 0
-          flags_ |= 1 if opts_[:uses_lenient_assertions] || opts_[:lenient_multi_polygon_assertions] || opts_[:uses_lenient_multi_polygon_assertions]
-          flags_ |= 2 if opts_[:has_z_coordinate]
-          flags_ |= 4 if opts_[:has_m_coordinate]
-          if flags_ & 6 == 6
+          flags = 0
+          flags |= 1 if opts_[:uses_lenient_assertions] || opts_[:lenient_multi_polygon_assertions] || opts_[:uses_lenient_multi_polygon_assertions]
+          flags |= 2 if opts_[:has_z_coordinate]
+          flags |= 4 if opts_[:has_m_coordinate]
+          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
+          flags |= 8 unless opts_[:auto_prepare] == :disabled
 
           # Buffer resolution
           buffer_resolution_ = opts_[:buffer_resolution].to_i
@@ -40,7 +43,7 @@ module RGeo
           case wkt_generator_
           when :geos
             wkt_generator_ = nil
-          when ::Hash
+          when Hash
             wkt_generator_ = WKRep::WKTGenerator.new(wkt_generator_)
           else
             wkt_generator_ = WKRep::WKTGenerator.new(convert_case: :upper)
@@ -49,7 +52,7 @@ module RGeo
           case wkb_generator_
           when :geos
             wkb_generator_ = nil
-          when ::Hash
+          when Hash
             wkb_generator_ = WKRep::WKBGenerator.new(wkb_generator_)
           else
             wkb_generator_ = WKRep::WKBGenerator.new
@@ -59,19 +62,15 @@ module RGeo
           srid_ = opts_[:srid]
           proj4_ = opts_[:proj4]
           if proj4_ && CoordSys.check!(:proj4)
-            if proj4_.is_a?(::String) || proj4_.is_a?(::Hash)
+            if proj4_.is_a?(String) || proj4_.is_a?(Hash)
               proj4_ = CoordSys::Proj4.create(proj4_)
             end
           else
             proj4_ = nil
           end
           coord_sys_ = opts_[:coord_sys]
-          if coord_sys_.is_a?(::String)
-            coord_sys_ = begin
-                           CoordSys::CS.create_from_wkt(coord_sys_)
-                         rescue
-                           nil
-                         end
+          if coord_sys_.is_a?(String)
+            coord_sys_ = CoordSys::CS.create_from_wkt(coord_sys_)
           end
           if (!proj4_ || !coord_sys_) && srid_ && (db_ = opts_[:srs_database])
             entry_ = db_.get(srid_.to_i)
@@ -83,7 +82,7 @@ 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_,
+          result = _create(flags, srid_.to_i, buffer_resolution_,
             wkt_generator_, wkb_generator_, proj4_, coord_sys_)
 
           # Interpret parser options
@@ -91,24 +90,24 @@ module RGeo
           case wkt_parser_
           when :geos
             wkt_parser_ = nil
-          when ::Hash
-            wkt_parser_ = WKRep::WKTParser.new(result_, wkt_parser_)
+          when Hash
+            wkt_parser_ = WKRep::WKTParser.new(result, wkt_parser_)
           else
-            wkt_parser_ = WKRep::WKTParser.new(result_)
+            wkt_parser_ = WKRep::WKTParser.new(result)
           end
           wkb_parser_ = opts_[:wkb_parser]
           case wkb_parser_
           when :geos
             wkb_parser_ = nil
-          when ::Hash
-            wkb_parser_ = WKRep::WKBParser.new(result_, wkb_parser_)
+          when Hash
+            wkb_parser_ = WKRep::WKBParser.new(result, wkb_parser_)
           else
-            wkb_parser_ = WKRep::WKBParser.new(result_)
+            wkb_parser_ = WKRep::WKBParser.new(result)
           end
-          result_._set_wkrep_parsers(wkt_parser_, wkb_parser_)
+          result._set_wkrep_parsers(wkt_parser_, wkb_parser_)
 
           # Return the result
-          result_
+          result
         end
         alias new create
       end
@@ -142,10 +141,10 @@ module RGeo
           "hasm" => (_flags & 0x4 != 0),
           "srid" => _srid,
           "bufr" => _buffer_resolution,
-          "wktg" => _wkt_generator ? _wkt_generator._properties : {},
-          "wkbg" => _wkb_generator ? _wkb_generator._properties : {},
-          "wktp" => _wkt_parser ? _wkt_parser._properties : {},
-          "wkbp" => _wkb_parser ? _wkb_parser._properties : {},
+          "wktg" => _wkt_generator ? _wkt_generator.properties : {},
+          "wkbg" => _wkb_generator ? _wkb_generator.properties : {},
+          "wktp" => _wkt_parser ? _wkt_parser.properties : {},
+          "wkbp" => _wkb_parser ? _wkb_parser.properties : {},
           "lmpa" => (_flags & 0x1 != 0),
           "apre" => ((_flags & 0x8) >> 3)
         }
@@ -170,20 +169,22 @@ module RGeo
         else
           coord_sys_ = nil
         end
-        initialize_copy(CAPIFactory.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_
-        ))
+        initialize_copy(
+          CAPIFactory.create(
+            has_z_coordinate: data_["hasz"],
+            has_m_coordinate: data_["hasm"],
+            srid: data_["srid"],
+            buffer_resolution: data_["bufr"],
+            wkt_generator: symbolize_hash(data_["wktg"]),
+            wkb_generator: symbolize_hash(data_["wkbg"]),
+            wkt_parser: symbolize_hash(data_["wktp"]),
+            wkb_parser: 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
@@ -194,10 +195,10 @@ module RGeo
         coder_["srid"] = _srid
         coder_["buffer_resolution"] = _buffer_resolution
         coder_["lenient_multi_polygon_assertions"] = (_flags & 0x1 != 0)
-        coder_["wkt_generator"] = _wkt_generator ? _wkt_generator._properties : {}
-        coder_["wkb_generator"] = _wkb_generator ? _wkb_generator._properties : {}
-        coder_["wkt_parser"] = _wkt_parser ? _wkt_parser._properties : {}
-        coder_["wkb_parser"] = _wkb_parser ? _wkb_parser._properties : {}
+        coder_["wkt_generator"] = _wkt_generator ? _wkt_generator.properties : {}
+        coder_["wkb_generator"] = _wkb_generator ? _wkb_generator.properties : {}
+        coder_["wkt_parser"] = _wkt_parser ? _wkt_parser.properties : {}
+        coder_["wkb_parser"] = _wkb_parser ? _wkb_parser.properties : {}
         coder_["auto_prepare"] = ((_flags & 0x8) == 0 ? "disabled" : "simple")
         if (proj4_ = _proj4)
           str_ = proj4_.original_str || proj4_.canonical_str
@@ -211,7 +212,7 @@ module RGeo
       def init_with(coder_) # :nodoc:
         if (proj4_data_ = coder_["proj4"])
           CoordSys.check!(:proj4)
-          if proj4_data_.is_a?(::Hash)
+          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)
@@ -224,20 +225,22 @@ module RGeo
         else
           coord_sys_ = nil
         end
-        initialize_copy(CAPIFactory.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_
-        ))
+        initialize_copy(
+          CAPIFactory.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: symbolize_hash(coder_["wkt_generator"]),
+            wkb_generator: symbolize_hash(coder_["wkb_generator"]),
+            wkt_parser: symbolize_hash(coder_["wkt_parser"]),
+            wkb_parser: 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.
@@ -294,7 +297,11 @@ module RGeo
         if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
-          _parse_wkb_impl(str_)
+          if str_[0] == "\x00" || str_[0] == "\x01"
+            _parse_wkb_impl(str_)
+          else
+            _parse_wkb_impl([str_].pack('H*'))
+          end
         end
       end
 
@@ -302,99 +309,67 @@ module RGeo
 
       def point(x_, y_, *extra_)
         if extra_.length > (_flags & 6 == 0 ? 0 : 1)
-          nil
+          raise(RGeo::Error::InvalidGeometry, "Parse error")
         else
-          begin
-            CAPIPointImpl.create(self, x_, y_, extra_[0].to_f)
-          rescue
-            nil
-          end
+          CAPIPointImpl.create(self, x_, y_, extra_[0].to_f)
         end
       end
 
       # See RGeo::Feature::Factory#line_string
 
       def line_string(points_)
-        points_ = points_.to_a unless points_.is_a?(::Array)
-        begin
-          CAPILineStringImpl.create(self, points_)
-        rescue
-          nil
-        end
+        points_ = points_.to_a unless points_.is_a?(Array)
+        CAPILineStringImpl.create(self, points_) ||
+          raise(RGeo::Error::InvalidGeometry, "Parse error")
       end
 
       # See RGeo::Feature::Factory#line
 
       def line(start_, end_)
         CAPILineImpl.create(self, start_, end_)
-      rescue
-        nil
       end
 
       # See RGeo::Feature::Factory#linear_ring
 
       def linear_ring(points_)
-        points_ = points_.to_a unless points_.is_a?(::Array)
-        begin
-          CAPILinearRingImpl.create(self, points_)
-        rescue
-          nil
-        end
+        points_ = points_.to_a unless points_.is_a?(Array)
+        CAPILinearRingImpl.create(self, points_)
       end
 
       # See RGeo::Feature::Factory#polygon
 
       def polygon(outer_ring_, inner_rings_ = nil)
-        inner_rings_ = inner_rings_.to_a unless inner_rings_.is_a?(::Array)
-        begin
-          CAPIPolygonImpl.create(self, outer_ring_, inner_rings_)
-        rescue
-          nil
-        end
+        inner_rings_ = inner_rings_.to_a unless inner_rings_.is_a?(Array)
+        CAPIPolygonImpl.create(self, outer_ring_, inner_rings_)
       end
 
       # See RGeo::Feature::Factory#collection
 
       def collection(elems_)
-        elems_ = elems_.to_a unless elems_.is_a?(::Array)
-        begin
-          CAPIGeometryCollectionImpl.create(self, elems_)
-        rescue
-          nil
-        end
+        elems_ = elems_.to_a unless elems_.is_a?(Array)
+        CAPIGeometryCollectionImpl.create(self, elems_)
       end
 
       # See RGeo::Feature::Factory#multi_point
 
       def multi_point(elems_)
-        elems_ = elems_.to_a unless elems_.is_a?(::Array)
-        begin
-          CAPIMultiPointImpl.create(self, elems_)
-        rescue
-          nil
-        end
+        elems_ = elems_.to_a unless elems_.is_a?(Array)
+        CAPIMultiPointImpl.create(self, elems_)
       end
 
       # See RGeo::Feature::Factory#multi_line_string
 
       def multi_line_string(elems_)
-        elems_ = elems_.to_a unless elems_.is_a?(::Array)
-        begin
-          CAPIMultiLineStringImpl.create(self, elems_)
-        rescue
-          nil
-        end
+        elems_ = elems_.to_a unless elems_.is_a?(Array)
+        CAPIMultiLineStringImpl.create(self, elems_)
       end
 
       # See RGeo::Feature::Factory#multi_polygon
 
       def multi_polygon(elems_)
-        elems_ = elems_.to_a unless elems_.is_a?(::Array)
-        begin
-          CAPIMultiPolygonImpl.create(self, elems_)
-        rescue
-          nil
-        end
+        elems_ = elems_.to_a unless elems_.is_a?(Array)
+        CAPIMultiPolygonImpl.create(self, elems_) ||
+          raise(RGeo::Error::InvalidGeometry, "Parse error")
       end
 
       # See RGeo::Feature::Factory#proj4
@@ -411,38 +386,38 @@ module RGeo
 
       # See RGeo::Feature::Factory#override_cast
 
-      def override_cast(original_, ntype_, flags_)
-        return nil unless Geos.supported?
-        keep_subtype_ = flags_[:keep_subtype]
-        # force_new_ = flags_[:force_new]
-        project_ = flags_[:project]
-        type_ = original_.geometry_type
-        ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
-        case original_
+      def override_cast(original, ntype, flags)
+        return unless Geos.supported?
+        keep_subtype = flags[:keep_subtype]
+        # force_new_ = flags[:force_new]
+        project = flags[:project]
+        type = original.geometry_type
+        ntype = type if keep_subtype && type.include?(ntype)
+        case original
         when CAPIGeometryMethods
           # Optimization if we're just changing factories, but the
           # factories are zm-compatible and proj4-compatible.
-          if original_.factory != self && ntype_ == type_ &&
-              original_.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project_ || original_.factory.proj4 == _proj4)
-            result_ = original_.dup
-            result_._set_factory(self)
-            return result_
+          if original.factory != self && ntype == type &&
+              original.factory._flags & 0x6 == _flags & 0x6 &&
+              (!project || original.factory.proj4 == _proj4)
+            result = original.dup
+            result.factory = self
+            return result
           end
           # LineString conversion optimization.
-          if (original_.factory != self || ntype_ != type_) &&
-              original_.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project_ || original_.factory.proj4 == _proj4) &&
-              type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
-            return IMPL_CLASSES[ntype_]._copy_from(self, original_)
+          if (original.factory != self || ntype != type) &&
+              original.factory._flags & 0x6 == _flags & 0x6 &&
+              (!project || original.factory.proj4 == _proj4) &&
+              type.subtype_of?(Feature::LineString) && ntype.subtype_of?(Feature::LineString)
+            return IMPL_CLASSES[ntype]._copy_from(self, original)
           end
         when ZMGeometryMethods
           # Optimization for just removing a coordinate from an otherwise
           # compatible factory
-          if _flags & 0x6 == 0x2 && self == original_.factory.z_factory
-            return Feature.cast(original_.z_geometry, ntype_, flags_)
-          elsif _flags & 0x6 == 0x4 && self == original_.factory.m_factory
-            return Feature.cast(original_.m_geometry, ntype_, flags_)
+          if _flags & 0x6 == 0x2 && self == original.factory.z_factory
+            return Feature.cast(original.z_geometry, ntype, flags)
+          elsif _flags & 0x6 == 0x4 && self == original.factory.m_factory
+            return Feature.cast(original.m_geometry, ntype, flags)
           end
         end
         false