rgeo 3.0.0.pre.rc.1 → 3.0.0.pre.rc.3

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -12,6 +12,22 @@ module RGeo
       def srid
         factory.srid
       end
+
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
     end
 
     module SphericalPointMethods # :nodoc:
@@ -121,11 +137,6 @@ module RGeo
         true
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
-      end
-
       def length
         arcs.inject(0.0) { |sum, arc| sum + arc.length } * SphericalMath::RADIUS
       end
@@ -216,7 +227,7 @@ module RGeo
         centroid_lat /= (6.0 * signed_area)
         centroid_lng /= (6.0 * signed_area)
 
-        RGeo::Geographic.spherical_factory.point(centroid_lat, centroid_lng)
+        factory.point(centroid_lat, centroid_lng)
       end
     end
   end

data/lib/rgeo/geographic.rb

@@ -24,7 +24,7 @@ require_relative "geographic/interface"
 require_relative "geographic/spherical_math"
 require_relative "geographic/spherical_feature_methods"
 require_relative "geographic/spherical_feature_classes"
-require_relative "geographic/proj4_projector"
+require_relative "geographic/projector"
 require_relative "geographic/simple_mercator_projector"
 require_relative "geographic/projected_feature_methods"
 require_relative "geographic/projected_feature_classes"

data/lib/rgeo/geos/capi_factory.rb

@@ -20,90 +20,64 @@ module RGeo
         #
         # See RGeo::Geos.factory for a list of supported options.
 
-        def create(opts_ = {})
+        def create(opts = {})
           # Make sure GEOS is available
           return unless respond_to?(:_create)
 
           # Get flags to pass to the C extension
           flags = 0
-          flags |= 2 if opts_[:has_z_coordinate]
-          flags |= 4 if opts_[:has_m_coordinate]
+          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
-          buffer_resolution_ = 1 if buffer_resolution_ < 1
+          buffer_resolution = opts[:buffer_resolution].to_i
+          buffer_resolution = 1 if buffer_resolution < 1
 
           # Interpret the generator options
-          wkt_generator_ = opts_[:wkt_generator]
-          case wkt_generator_
-          when :geos
-            wkt_generator_ = nil
+          wkt_generator = opts[:wkt_generator]
+          case wkt_generator
           when Hash
-            wkt_generator_ = WKRep::WKTGenerator.new(wkt_generator_)
+            wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
           else
-            wkt_generator_ = WKRep::WKTGenerator.new(convert_case: :upper)
+            wkt_generator = nil
           end
-          wkb_generator_ = opts_[:wkb_generator]
-          case wkb_generator_
-          when :geos
-            wkb_generator_ = nil
+          wkb_generator = opts[:wkb_generator]
+          case wkb_generator
           when Hash
-            wkb_generator_ = WKRep::WKBGenerator.new(wkb_generator_)
+            wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
           else
-            wkb_generator_ = WKRep::WKBGenerator.new
+            wkb_generator = nil
           end
 
-          # Coordinate system (srid, proj4, and coord_sys)
-          srid_ = opts_[:srid]
-          proj4_ = opts_[:proj4]
-          if proj4_ && CoordSys.check!(:proj4)
-            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_ = CoordSys::CS.create_from_wkt(coord_sys_)
-          end
-          if (!proj4_ || !coord_sys_) && srid_ && (db_ = opts_[:srs_database])
-            entry_ = db_.get(srid_.to_i)
-            if entry_
-              proj4_ ||= entry_.proj4
-              coord_sys_ ||= entry_.coord_sys
-            end
-          end
-          srid_ ||= coord_sys_.authority_code if coord_sys_
+          # Coordinate system (srid and coord_sys)
+          coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
+          srid = coord_sys_info[:srid]
+          coord_sys = coord_sys_info[:coord_sys]
 
           # Create the factory and set instance variables
-          result = _create(flags, srid_.to_i, buffer_resolution_,
-            wkt_generator_, wkb_generator_, proj4_, coord_sys_)
+          result = _create(flags, srid.to_i, buffer_resolution,
+            wkt_generator, wkb_generator, coord_sys)
 
           # Interpret parser options
-          wkt_parser_ = opts_[:wkt_parser]
-          case wkt_parser_
-          when :geos
-            wkt_parser_ = nil
+          wkt_parser = opts[:wkt_parser]
+          case wkt_parser
           when Hash
-            wkt_parser_ = WKRep::WKTParser.new(result, wkt_parser_)
+            wkt_parser = WKRep::WKTParser.new(result, wkt_parser)
           else
-            wkt_parser_ = WKRep::WKTParser.new(result)
+            wkt_parser = nil
           end
-          wkb_parser_ = opts_[:wkb_parser]
-          case wkb_parser_
-          when :geos
-            wkb_parser_ = nil
+          wkb_parser = opts[:wkb_parser]
+          case wkb_parser
           when Hash
-            wkb_parser_ = WKRep::WKBParser.new(result, wkb_parser_)
+            wkb_parser = WKRep::WKBParser.new(result, wkb_parser)
           else
-            wkb_parser_ = WKRep::WKBParser.new(result)
+            wkb_parser = nil
           end
-          result._set_wkrep_parsers(wkt_parser_, wkb_parser_)
+          result._set_wkrep_parsers(wkt_parser, wkb_parser)
 
           # Return the result
           result
@@ -122,14 +96,14 @@ module RGeo
       def eql?(rhs_)
         rhs_.is_a?(CAPIFactory) && rhs_.srid == _srid &&
           rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags &&
-          rhs_.proj4 == _proj4
+          rhs_.coord_sys == coord_sys
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [_srid, _buffer_resolution, _flags, _proj4].hash
+        @hash ||= [_srid, _buffer_resolution, _flags].hash
       end
 
       # Marshal support
@@ -146,9 +120,6 @@ module RGeo
           "wkbp" => _wkb_parser ? _wkb_parser.properties : {},
           "apre" => auto_prepare
         }
-        if (proj4_ = _proj4)
-          hash_["proj4"] = proj4_.marshal_dump
-        end
         if (coord_sys_ = _coord_sys)
           hash_["cs"] = coord_sys_.to_wkt
         end
@@ -156,14 +127,8 @@ module RGeo
       end
 
       def marshal_load(data_) # :nodoc:
-        if (proj4_data_ = data_["proj4"]) && CoordSys.check!(: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_)
+          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_)
         else
           coord_sys_ = nil
         end
@@ -178,7 +143,6 @@ module RGeo
             wkt_parser: symbolize_hash(data_["wktp"]),
             wkb_parser: symbolize_hash(data_["wkbp"]),
             auto_prepare: data_["apre"],
-            proj4: proj4_,
             coord_sys: coord_sys_
           )
         )
@@ -196,28 +160,14 @@ module RGeo
         coder_["wkt_parser"] = _wkt_parser ? _wkt_parser.properties : {}
         coder_["wkb_parser"] = _wkb_parser ? _wkb_parser.properties : {}
         coder_["auto_prepare"] = auto_prepare
-        if (proj4_ = _proj4)
-          str_ = proj4_.original_str || proj4_.canonical_str
-          coder_["proj4"] = proj4_.radians? ? { "proj4" => str_, "radians" => true } : str_
-        end
         if (coord_sys_ = _coord_sys)
           coder_["coord_sys"] = coord_sys_.to_wkt
         end
       end
 
       def init_with(coder_) # :nodoc:
-        if (proj4_data_ = coder_["proj4"])
-          CoordSys.check!(: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)
+          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_.to_s)
         else
           coord_sys_ = nil
         end
@@ -232,7 +182,6 @@ module RGeo
             wkt_parser: symbolize_hash(coder_["wkt_parser"]),
             wkb_parser: symbolize_hash(coder_["wkb_parser"]),
             auto_prepare: coder_["auto_prepare"] == "disabled" ? :disabled : :simple,
-            proj4: proj4_,
             coord_sys: coord_sys_
           )
         )
@@ -283,11 +232,7 @@ module RGeo
         if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
-          if str_[0] == "\x00" || str_[0] == "\x01"
-            _parse_wkb_impl(str_)
-          else
-            _parse_wkb_impl([str_].pack('H*'))
-          end
+          _parse_wkb_impl(str_)
         end
       end
 
@@ -358,12 +303,6 @@ module RGeo
           raise(RGeo::Error::InvalidGeometry, "Parse error")
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        _proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
@@ -382,10 +321,10 @@ module RGeo
         case original
         when CAPIGeometryMethods
           # Optimization if we're just changing factories, but the
-          # factories are zm-compatible and proj4-compatible.
+          # factories are zm-compatible and coord_sys-compatible.
           if original.factory != self && ntype == type &&
               original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
-              (!project || original.factory.proj4 == _proj4)
+              (!project || original.factory.coord_sys == coord_sys)
             result = original.dup
             result.factory = self
             return result
@@ -393,7 +332,7 @@ module RGeo
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
               original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
-              (!project || original.factory.proj4 == _proj4) &&
+              (!project || original.factory.coord_sys == coord_sys) &&
               type.subtype_of?(Feature::LineString) && ntype.subtype_of?(Feature::LineString)
             return IMPL_CLASSES[ntype]._copy_from(self, original)
           end

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -13,14 +13,23 @@ module RGeo
     module CAPIGeometryMethods
       include Feature::Instance
 
-      def is_empty? # rubocop:disable Naming/PredicateName
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
+      def coordinate_dimension
+        dim = 2
+        dim += 1 if factory.supports_z?
+        dim += 1 if factory.supports_m?
+        dim
       end
 
-      def is_simple? # rubocop:disable Naming/PredicateName
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
+      def spatial_dimension
+        factory.supports_z? ? 3 : 2
+      end
+
+      def is_3d?
+        factory.supports_z?
+      end
+
+      def measured?
+        factory.supports_m?
       end
 
       def inspect
@@ -62,25 +71,6 @@ module RGeo
       alias to_s as_text
     end
 
-    module CAPIMultiLineStringMethods # :nodoc:
-      def is_closed? # rubocop:disable Naming/PredicateName
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-    end
-
-    module CAPILineStringMethods # :nodoc:
-      def is_closed? # rubocop:disable Naming/PredicateName
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
-      def is_ring? # rubocop:disable Naming/PredicateName
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      end
-    end
-
     module CAPIGeometryCollectionMethods # :nodoc:
       include Enumerable
     end

data/lib/rgeo/geos/ffi_factory.rb

@@ -25,87 +25,63 @@ module RGeo
         if @has_z && @has_m
           raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
         end
+        @coordinate_dimension = 2
+        @coordinate_dimension += 1 if @has_z
+        @coordinate_dimension += 1 if @has_m
+        @spatial_dimension = @has_z ? 3 : 2
+
         @_has_3d = @has_z || @has_m
         @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
-        @_auto_prepare = opts[:auto_prepare] == :disabled ? false : true
+        @_auto_prepare = opts[:auto_prepare] != :disabled
 
         # Interpret the generator options
-        wkt_generator_ = opts[:wkt_generator]
-        case wkt_generator_
-        when :geos
-          @wkt_writer = ::Geos::WktWriter.new
-          @wkt_generator = nil
+        wkt_generator = opts[:wkt_generator]
+        case wkt_generator
         when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
           @wkt_writer = nil
         else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-          @wkt_writer = nil
+          @wkt_writer = ::Geos::WktWriter.new
+          @wkt_writer.trim = true
+          @wkt_generator = nil
         end
-        wkb_generator_ = opts[:wkb_generator]
-        case wkb_generator_
-        when :geos
-          @wkb_writer = ::Geos::WkbWriter.new
-          @wkb_generator = nil
+        wkb_generator = opts[:wkb_generator]
+        case wkb_generator
         when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
           @wkb_writer = nil
         else
-          @wkb_generator = WKRep::WKBGenerator.new
-          @wkb_writer = nil
+          @wkb_writer = ::Geos::WkbWriter.new
+          @wkb_generator = nil
         end
 
-        # Coordinate system (srid, proj4, and coord_sys)
-        @srid = opts[:srid]
-        @proj4 = opts[:proj4]
-        if @proj4 && CoordSys.check!(:proj4)
-          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 = CoordSys::CS.create_from_wkt(@coord_sys)
-        end
-        if (!@proj4 || !@coord_sys) && @srid && (db = opts[:srs_database])
-          entry = db.get(@srid.to_i)
-          if entry
-            @proj4 ||= entry.proj4
-            @coord_sys ||= entry.coord_sys
-          end
-        end
-        @srid ||= @coord_sys.authority_code if @coord_sys
-        @srid = @srid.to_i
+        # Coordinate system (srid and coord_sys)
+        coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
+        @srid = coord_sys_info[:srid]
+        @coord_sys = coord_sys_info[:coord_sys]
 
         # Interpret parser options
         wkt_parser = opts[:wkt_parser]
         case wkt_parser
-        when :geos
-          @wkt_reader = ::Geos::WktReader.new
-          @wkt_parser = nil
         when Hash
           @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
           @wkt_reader = nil
         else
-          @wkt_parser = WKRep::WKTParser.new(self)
-          @wkt_reader = nil
+          @wkt_reader = ::Geos::WktReader.new
+          @wkt_parser = nil
         end
         wkb_parser = opts[:wkb_parser]
         case wkb_parser
-        when :geos
-          @wkb_reader = ::Geos::WkbReader.new
-          @wkb_parser = nil
         when Hash
           @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
           @wkb_reader = nil
         else
-          @wkb_parser = WKRep::WKBParser.new(self)
-          @wkb_reader = nil
+          @wkb_reader = ::Geos::WkbReader.new
+          @wkb_parser = nil
         end
       end
+      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Standard object inspection output
 
@@ -120,14 +96,14 @@ module RGeo
           @has_z == rhs.property(:has_z_coordinate) &&
           @has_m == rhs.property(:has_m_coordinate) &&
           @buffer_resolution == rhs.property(:buffer_resolution) &&
-          @proj4.eql?(rhs.proj4)
+          @coord_sys.eql?(rhs.coord_sys)
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @proj4].hash
+        @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @coord_sys].hash
       end
 
       # Marshal support
@@ -138,26 +114,19 @@ module RGeo
           "hasm" => @has_m,
           "srid" => @srid,
           "bufr" => @buffer_resolution,
-          "wktg" => @wkt_generator.properties,
-          "wkbg" => @wkb_generator.properties,
-          "wktp" => @wkt_parser.properties,
-          "wkbp" => @wkb_parser.properties,
+          "wktg" => @wkt_generator&.properties,
+          "wkbg" => @wkb_generator&.properties,
+          "wktp" => @wkt_parser&.properties,
+          "wkbp" => @wkb_parser&.properties,
           "apre" => @_auto_prepare
         }
-        hash["proj4"] = @proj4.marshal_dump if @proj4
         hash["cs"] = @coord_sys.to_wkt if @coord_sys
         hash
       end
 
       def marshal_load(data) # :nodoc:
-        if (proj4_data = data["proj4"]) && CoordSys.check!(: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)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
         else
           coord_sys = nil
         end
@@ -166,12 +135,11 @@ module RGeo
           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"]),
+          wkt_generator: data["wktg"] && symbolize_hash(data["wktg"]),
+          wkb_generator: data["wkbg"] && symbolize_hash(data["wkbg"]),
+          wkt_parser: data["wktp"] && symbolize_hash(data["wktp"]),
+          wkb_parser: data["wkbp"] && symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -183,31 +151,17 @@ module RGeo
         coder["has_m_coordinate"] = @has_m
         coder["srid"] = @srid
         coder["buffer_resolution"] = @buffer_resolution
-        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["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"] = @_auto_prepare ? "simple" : "disabled"
-        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"])
-          CoordSys.check!(: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)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
         else
           coord_sys = nil
         end
@@ -216,12 +170,11 @@ module RGeo
           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"]),
+          wkt_generator: coder["wkt_generator"] && symbolize_hash(coder["wkt_generator"]),
+          wkb_generator: coder["wkb_generator"] && symbolize_hash(coder["wkb_generator"]),
+          wkt_parser: coder["wkt_parser"] && symbolize_hash(coder["wkt_parser"]),
+          wkb_parser: coder["wkb_parser"] && symbolize_hash(coder["wkb_parser"]),
           auto_prepare: coder["auto_prepare"] == "disabled" ? :disabled : :simple,
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -254,7 +207,11 @@ module RGeo
       # See RGeo::Feature::Factory#parse_wkt
       def parse_wkt(str)
         if @wkt_reader
-          wrap_fg_geom(@wkt_reader.read(str), nil)
+          begin
+            wrap_fg_geom(@wkt_reader.read(str), nil)
+          rescue ::Geos::WktReader::ParseError => e
+            raise RGeo::Error::ParseError, e.message.partition(":").last
+          end
         else
           @wkt_parser.parse(str)
         end
@@ -264,7 +221,12 @@ module RGeo
 
       def parse_wkb(str)
         if @wkb_reader
-          wrap_fg_geom(@wkb_reader.read(str), nil)
+          begin
+            meth = str[0].match?(/[0-9a-fA-F]/) ? :read_hex : :read
+            wrap_fg_geom(@wkb_reader.public_send(meth, str), nil)
+          rescue ::Geos::WkbReader::ParseError => e
+            raise RGeo::Error::ParseError, e.message.partition(":").last
+          end
         else
           @wkb_parser.parse(str)
         end
@@ -405,10 +367,6 @@ module RGeo
         FFIMultiPolygonImpl.new(self, fg_geom, klasses)
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      attr_reader :proj4
-
       # See RGeo::Feature::Factory#coord_sys
 
       attr_reader :coord_sys
@@ -506,6 +464,7 @@ module RGeo
       def write_for_psych(geom)
         if Utils.ffi_supports_set_output_dimension || !@_has_3d
           wkt_writer = ::Geos::WktWriter.new
+          wkt_writer.trim = true
           wkt_writer.output_dimensions = 3 if @_has_3d
           wkt_writer.write(geom.fg_geom)
         else