rgeo 2.3.1 → 3.0.0.pre.rc.2

data/lib/rgeo/geos/capi_factory.rb

@@ -26,7 +26,6 @@ module RGeo
 
           # 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
@@ -72,13 +71,6 @@ module RGeo
           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_
 
           # Create the factory and set instance variables
@@ -137,16 +129,15 @@ module RGeo
 
       def marshal_dump # :nodoc:
         hash_ = {
-          "hasz" => (_flags & 0x2 != 0),
-          "hasm" => (_flags & 0x4 != 0),
+          "hasz" => supports_z?,
+          "hasm" => supports_m?,
           "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 : {},
-          "lmpa" => (_flags & 0x1 != 0),
-          "apre" => ((_flags & 0x8) >> 3)
+          "apre" => auto_prepare
         }
         if (proj4_ = _proj4)
           hash_["proj4"] = proj4_.marshal_dump
@@ -179,8 +170,7 @@ module RGeo
             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),
+            auto_prepare: data_["apre"],
             proj4: proj4_,
             coord_sys: coord_sys_
           )
@@ -190,16 +180,15 @@ module RGeo
       # Psych support
 
       def encode_with(coder_) # :nodoc:
-        coder_["has_z_coordinate"] = (_flags & 0x2 != 0)
-        coder_["has_m_coordinate"] = (_flags & 0x4 != 0)
+        coder_["has_z_coordinate"] = supports_z?
+        coder_["has_m_coordinate"] = supports_m?
         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_["auto_prepare"] = ((_flags & 0x8) == 0 ? "disabled" : "simple")
+        coder_["auto_prepare"] = auto_prepare
         if (proj4_ = _proj4)
           str_ = proj4_.original_str || proj4_.canonical_str
           coder_["proj4"] = proj4_.radians? ? { "proj4" => str_, "radians" => true } : str_
@@ -236,7 +225,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,
-            uses_lenient_multi_polygon_assertions: coder_["lenient_multi_polygon_assertions"],
             proj4: proj4_,
             coord_sys: coord_sys_
           )
@@ -256,28 +244,19 @@ module RGeo
         _buffer_resolution
       end
 
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        _flags & 0x1 != 0
-      end
-
       # See RGeo::Feature::Factory#property
-
       def property(name_)
         case name_
         when :has_z_coordinate
-          _flags & 0x2 != 0
+          supports_z?
         when :has_m_coordinate
-          _flags & 0x4 != 0
+          supports_m?
         when :is_cartesian
           true
-        when :uses_lenient_multi_polygon_assertions
-          _flags & 0x1 != 0
         when :buffer_resolution
           _buffer_resolution
         when :auto_prepare
-          _flags & 0x8 != 0 ? :simple : :disabled
+          prepare_heuristic? ? :simple : :disabled
         end
       end
 
@@ -307,11 +286,11 @@ module RGeo
 
       # See RGeo::Feature::Factory#point
 
-      def point(x_, y_, *extra_)
-        if extra_.length > (_flags & 6 == 0 ? 0 : 1)
+      def point(x, y, *extra)
+        if extra.length > (supports_z_or_m? ? 1 : 0)
           raise(RGeo::Error::InvalidGeometry, "Parse error")
         else
-          CAPIPointImpl.create(self, x_, y_, extra_[0].to_f)
+          CAPIPointImpl.create(self, x, y, extra[0].to_f)
         end
       end
 
@@ -398,7 +377,7 @@ module RGeo
           # 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 &&
+              original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
               (!project || original.factory.proj4 == _proj4)
             result = original.dup
             result.factory = self
@@ -406,7 +385,7 @@ module RGeo
           end
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
-              original.factory._flags & 0x6 == _flags & 0x6 &&
+              original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
               (!project || original.factory.proj4 == _proj4) &&
               type.subtype_of?(Feature::LineString) && ntype.subtype_of?(Feature::LineString)
             return IMPL_CLASSES[ntype]._copy_from(self, original)
@@ -414,15 +393,19 @@ module RGeo
         when ZMGeometryMethods
           # Optimization for just removing a coordinate from an otherwise
           # compatible factory
-          if _flags & 0x6 == 0x2 && self == original.factory.z_factory
+          if supports_z? && !supports_m? && self == original.factory.z_factory
             return Feature.cast(original.z_geometry, ntype, flags)
-          elsif _flags & 0x6 == 0x4 && self == original.factory.m_factory
+          elsif supports_m? && !supports_z? && self == original.factory.m_factory
             return Feature.cast(original.m_geometry, ntype, flags)
           end
         end
         false
       end
 
+      def auto_prepare # :nodoc:
+        prepare_heuristic? ? :simple : :disabled
+      end
+
       # :stopdoc:
 
       IMPL_CLASSES = {

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -6,11 +6,24 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Geos
-    module CAPIGeometryMethods # :nodoc:
+    module CAPIGeometryMethods
       include Feature::Instance
 
+      def coordinate_dimension
+        dim = 2
+        dim += 1 if factory.supports_z?
+        dim += 1 if factory.supports_m?
+        dim
+      end
+
+      def spatial_dimension
+        factory.supports_z? ? 3 : 2
+      end
+
       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?
@@ -21,6 +34,14 @@ module RGeo
         simple?
       end
 
+      def is_3d?
+        factory.supports_z?
+      end
+
+      def measured?
+        factory.supports_m?
+      end
+
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
@@ -83,21 +104,29 @@ module RGeo
       include Enumerable
     end
 
-    class CAPIGeometryImpl # :nodoc:
+    class CAPIGeometryImpl
+      include Feature::Geometry
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
     end
 
-    class CAPIPointImpl # :nodoc:
+    class CAPIPointImpl
+      include Feature::Point
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIPointMethods
     end
 
-    class CAPILineStringImpl  # :nodoc:
+    class CAPILineStringImpl
+      include Feature::LineString
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
     end
 
-    class CAPILinearRingImpl  # :nodoc:
+    class CAPILinearRingImpl
+      include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILinearRingMethods
@@ -107,38 +136,52 @@ module RGeo
       end
     end
 
-    class CAPILineImpl # :nodoc:
+    class CAPILineImpl
+      include Feature::Line
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILineMethods
     end
 
-    class CAPIPolygonImpl # :nodoc:
+    class CAPIPolygonImpl
+      include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIPolygonMethods
     end
 
-    class CAPIGeometryCollectionImpl # :nodoc:
+    class CAPIGeometryCollectionImpl
+      include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
     end
 
-    class CAPIMultiPointImpl # :nodoc:
+    class CAPIMultiPointImpl
+      include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPointMethods
     end
 
-    class CAPIMultiLineStringImpl # :nodoc:
+    class CAPIMultiLineStringImpl
+      include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiLineStringMethods
     end
 
-    class CAPIMultiPolygonImpl # :nodoc:
+    class CAPIMultiPolygonImpl
+      include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPolygonMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/geos/ffi_factory.rb

@@ -20,14 +20,16 @@ module RGeo
       # See RGeo::Geos.factory for a list of supported options.
 
       def initialize(opts = {})
-        # Main flags
-        @uses_lenient_multi_polygon_assertions = opts[:uses_lenient_assertions] ||
-          opts[:lenient_multi_polygon_assertions] || opts[:uses_lenient_multi_polygon_assertions]
         @has_z = opts[:has_z_coordinate] ? true : false
         @has_m = opts[:has_m_coordinate] ? true : false
         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
@@ -73,13 +75,6 @@ module RGeo
         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
 
@@ -109,6 +104,7 @@ module RGeo
           @wkb_reader = nil
         end
       end
+      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Standard object inspection output
 
@@ -145,7 +141,6 @@ module RGeo
           "wkbg" => @wkb_generator.properties,
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
-          "lmpa" => @uses_lenient_multi_polygon_assertions,
           "apre" => @_auto_prepare
         }
         hash["proj4"] = @proj4.marshal_dump if @proj4
@@ -174,7 +169,6 @@ module RGeo
           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"] ? :simple : :disabled),
           proj4: proj4,
           coord_sys: coord_sys
@@ -188,7 +182,6 @@ module RGeo
         coder["has_m_coordinate"] = @has_m
         coder["srid"] = @srid
         coder["buffer_resolution"] = @buffer_resolution
-        coder["lenient_multi_polygon_assertions"] = @uses_lenient_multi_polygon_assertions
         coder["wkt_generator"] = @wkt_generator.properties
         coder["wkb_generator"] = @wkb_generator.properties
         coder["wkt_parser"] = @wkt_parser.properties
@@ -227,7 +220,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,
-          uses_lenient_multi_polygon_assertions: coder["lenient_multi_polygon_assertions"],
           proj4: proj4,
           coord_sys: coord_sys
         )
@@ -242,14 +234,7 @@ module RGeo
 
       attr_reader :buffer_resolution
 
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        @uses_lenient_multi_polygon_assertions
-      end
-
       # See RGeo::Feature::Factory#property
-
       def property(name_)
         case name_
         when :has_z_coordinate
@@ -260,15 +245,12 @@ module RGeo
           true
         when :buffer_resolution
           @buffer_resolution
-        when :uses_lenient_multi_polygon_assertions
-          @uses_lenient_multi_polygon_assertions
         when :auto_prepare
           @_auto_prepare ? :simple : :disabled
         end
       end
 
       # See RGeo::Feature::Factory#parse_wkt
-
       def parse_wkt(str)
         if @wkt_reader
           wrap_fg_geom(@wkt_reader.read(str), nil)
@@ -417,17 +399,6 @@ module RGeo
           raise(RGeo::Error::InvalidGeometry, "Could not cast to polygon: #{elem}") unless elem
           elem.detach_fg_geom
         end
-        unless @uses_lenient_multi_polygon_assertions
-          (1...elems.size).each do |i|
-            (0...i).each do |j|
-              igeom = elems[i]
-              jgeom = elems[j]
-              if igeom.relate_pattern(jgeom, "2********") || igeom.relate_pattern(jgeom, "****1****")
-                raise(RGeo::Error::InvalidGeometry, "Invalid relate pattern: #{jgeom}")
-              end
-            end
-          end
-        end
         klasses = Array.new(elems.size, FFIPolygonImpl)
         fg_geom = ::Geos::Utils.create_collection(::Geos::GeomTypes::GEOS_MULTIPOLYGON, elems)
         FFIMultiPolygonImpl.new(self, fg_geom, klasses)

data/lib/rgeo/geos/ffi_feature_classes.rb

@@ -6,60 +6,84 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Geos
-    class FFIGeometryImpl # :nodoc:
+    class FFIGeometryImpl
+      include Feature::Geometry
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
     end
 
-    class FFIPointImpl # :nodoc:
+    class FFIPointImpl
+      include Feature::Point
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIPointMethods
     end
 
-    class FFILineStringImpl  # :nodoc:
+    class FFILineStringImpl
+      include Feature::LineString
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFILineStringMethods
     end
 
-    class FFILinearRingImpl  # :nodoc:
+    class FFILinearRingImpl
+      include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFILineStringMethods
       include FFILinearRingMethods
     end
 
-    class FFILineImpl # :nodoc:
+    class FFILineImpl
+      include Feature::Line
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFILineStringMethods
       include FFILineMethods
     end
 
-    class FFIPolygonImpl # :nodoc:
+    class FFIPolygonImpl
+      include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIPolygonMethods
     end
 
-    class FFIGeometryCollectionImpl # :nodoc:
+    class FFIGeometryCollectionImpl
+      include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
     end
 
-    class FFIMultiPointImpl # :nodoc:
+    class FFIMultiPointImpl
+      include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiPointMethods
     end
 
-    class FFIMultiLineStringImpl # :nodoc:
+    class FFIMultiLineStringImpl
+      include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiLineStringMethods
     end
 
-    class FFIMultiPolygonImpl # :nodoc:
+    class FFIMultiPolygonImpl
+      include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include FFIGeometryMethods
       include FFIGeometryCollectionMethods
       include FFIMultiPolygonMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -6,6 +6,8 @@
 #
 # -----------------------------------------------------------------------------
 
+require "ffi-geos"
+
 module RGeo
   module Geos
     module FFIGeometryMethods # :nodoc:
@@ -75,6 +77,14 @@ module RGeo
         Utils.ffi_compute_dimension(@fg_geom)
       end
 
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
       def geometry_type
         Feature::Geometry
       end
@@ -95,11 +105,9 @@ module RGeo
       end
 
       def boundary
-        if self.class == FFIGeometryCollectionImpl
-          nil
-        else
-          @factory.wrap_fg_geom(@fg_geom.boundary, nil)
-        end
+        @factory.wrap_fg_geom(@fg_geom.boundary, nil)
+      rescue ::Geos::GEOSException
+        raise Error::InvalidGeometry, "Operation not supported by GeometryCollection"
       end
 
       def as_text
@@ -131,6 +139,32 @@ module RGeo
         simple?
       end
 
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
+
+      def valid?
+        @fg_geom.valid?
+      end
+
+      def invalid_reason
+        # valid_detail gives solely the reason, or nil if valid, which is
+        # what we want.
+        fg_geom.valid_detail&.dig(:detail)&.force_encoding(Encoding::UTF_8)
+      end
+
+      # (see RGeo::ImplHelper::ValidityCheck#make_valid)
+      # Only available since GEOS 3.8+
+      def make_valid
+        @factory.wrap_fg_geom(@fg_geom.make_valid, nil)
+      rescue ::Geos::GEOSException
+        raise Error::UnsupportedOperation
+      end if ::Geos::FFIGeos.respond_to?(:GEOSMakeValid_r)
+
       def equals?(rhs)
         return false unless rhs.is_a?(RGeo::Feature::Instance)
         fg = factory.convert_to_fg_geometry(rhs)

data/lib/rgeo/geos/interface.rb

@@ -116,13 +116,6 @@ module RGeo
       #   Specifies which native interface to use. Possible values are
       #   <tt>:capi</tt> and <tt>:ffi</tt>. The default is the value
       #   of the preferred_native_interface.
-      # [<tt>:uses_lenient_multi_polygon_assertions</tt>]
-      #   If set to true, assertion checking on MultiPolygon is disabled.
-      #   This may speed up creation of MultiPolygon objects, at the
-      #   expense of not doing the proper checking for OGC MultiPolygon
-      #   compliance. See RGeo::Feature::MultiPolygon for details on
-      #   the MultiPolygon assertions. Default is false. Also called
-      #   <tt>:lenient_multi_polygon_assertions</tt>.
       # [<tt>:buffer_resolution</tt>]
       #   The resolution of buffers around geometries created by this
       #   factory. This controls the number of line segments used to
@@ -142,11 +135,6 @@ module RGeo
       #   The coordinate system in OGC form, either as a subclass of
       #   CoordSys::CS::CoordinateSystem, or as a string in WKT format.
       #   Optional.
-      # [<tt>:srs_database</tt>]
-      #   Optional. If provided, the object should respond to #get and
-      #   #clear_cache. If both this and an SRID are
-      #   provided, they are used to look up the proj4 and coord_sys
-      #   objects from a spatial reference system database.
       # [<tt>:has_z_coordinate</tt>]
       #   Support <tt>z_coordinate</tt>. Default is false.
       # [<tt>:has_m_coordinate</tt>]
@@ -201,18 +189,6 @@ module RGeo
           end
         end
       end
-
-      # Returns a Feature::FactoryGenerator that creates Geos-backed
-      # factories. The given options are used as the default options.
-      #
-      # A common case for this is to provide the <tt>:srs_database</tt>
-      # as a default. Then, the factory generator need only be passed
-      # an SRID and it will automatically fetch the appropriate Proj4
-      # and CoordSys objects.
-
-      def factory_generator(defaults = {})
-        proc { |c| factory(defaults.merge(c)) }
-      end
     end
   end
 end

data/lib/rgeo/geos/zm_factory.rb

@@ -44,17 +44,8 @@ module RGeo
         proj4 = opts[:proj4]
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
-        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
         config = {
-          uses_lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions] ||
-            opts[:uses_lenient_multi_polygon_assertions],
           buffer_resolution: opts[:buffer_resolution], auto_prepare: opts[:auto_prepare],
           wkt_generator: opts[:wkt_generator], wkt_parser: opts[:wkt_parser],
           wkb_generator: opts[:wkb_generator], wkb_parser: opts[:wkb_parser],
@@ -109,7 +100,6 @@ module RGeo
           "wkbg" => @wkb_generator.properties,
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
-          "lmpa" => @zfactory.lenient_multi_polygon_assertions?,
           "apre" => @zfactory.property(:auto_prepare) == :simple,
           "nffi" => @zfactory.is_a?(FFIFactory)
         }
@@ -142,7 +132,6 @@ module RGeo
           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"] ? :simple : :disabled),
           proj4: proj4,
           coord_sys: coord_sys
@@ -154,7 +143,6 @@ module RGeo
       def encode_with(coder) # :nodoc:
         coder["srid"] = @zfactory.srid
         coder["buffer_resolution"] = @zfactory.buffer_resolution
-        coder["lenient_multi_polygon_assertions"] = @zfactory.lenient_multi_polygon_assertions?
         coder["wkt_generator"] = @wkt_generator.properties
         coder["wkb_generator"] = @wkb_generator.properties
         coder["wkt_parser"] = @wkt_parser.properties
@@ -197,7 +185,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,
-          uses_lenient_multi_polygon_assertions: coder["lenient_multi_polygon_assertions"],
           proj4: proj4,
           coord_sys: coord_sys
         )
@@ -216,12 +203,6 @@ module RGeo
         @zfactory.buffer_resolution
       end
 
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        @zfactory.lenient_multi_polygon_assertions?
-      end
-
       # Returns the z-only factory corresponding to this factory.
 
       def z_factory