rgeo-dschee 0.5.4

data/lib/rgeo/geos/interface.rb

@@ -0,0 +1,202 @@
+# -----------------------------------------------------------------------------
+#
+# GEOS toplevel interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geos
+    class << self
+      # Returns true if the CAPI GEOS implementation is supported.
+
+      def capi_supported?
+        CAPI_SUPPORTED
+      end
+
+      # Returns true if the FFI GEOS implementation is supported.
+
+      def ffi_supported?
+        FFI_SUPPORTED
+      end
+
+      # Returns true if any GEOS implementation is supported.
+      # If this returns false, GEOS features are not available at all.
+
+      def supported?
+        FFI_SUPPORTED || CAPI_SUPPORTED
+      end
+
+      # Returns true if the given feature is a CAPI GEOS feature, or if
+      # the given factory is a CAPI GEOS factory.
+
+      def is_capi_geos?(object_)
+        CAPI_SUPPORTED &&
+          (CAPIFactory === object_ || CAPIGeometryMethods === object_ ||
+          ZMFactory === object_ && CAPIFactory === object_.z_factory ||
+          ZMGeometryMethods === object_ && CAPIGeometryMethods === object_.z_geometry)
+      end
+
+      # Returns true if the given feature is an FFI GEOS feature, or if
+      # the given factory is an FFI GEOS factory.
+
+      def is_ffi_geos?(object_)
+        FFI_SUPPORTED &&
+          (FFIFactory === object_ || FFIGeometryMethods === object_ ||
+          ZMFactory === object_ && FFIFactory === object_.z_factory ||
+          ZMGeometryMethods === object_ && FFIGeometryMethods === object_.z_geometry)
+      end
+
+      # Returns true if the given feature is a GEOS feature, or if the given
+      # factory is a GEOS factory. Does not distinguish between CAPI and FFI.
+
+      def is_geos?(object_)
+        CAPI_SUPPORTED && (CAPIFactory === object_ || CAPIGeometryMethods === object_) ||
+          FFI_SUPPORTED && (FFIFactory === object_ || FFIGeometryMethods === object_) ||
+          ZMFactory === object_ || ZMGeometryMethods === object_
+      end
+
+      # Returns the GEOS library version as a string of the format "x.y.z".
+      # Returns nil if GEOS is not available.
+
+      def version
+        unless defined?(@version)
+          if ::RGeo::Geos::CAPI_SUPPORTED
+            @version = ::RGeo::Geos::CAPIFactory._geos_version.freeze
+          elsif ::RGeo::Geos::FFI_SUPPORTED
+            @version = ::Geos::FFIGeos.GEOSversion.sub(/-CAPI-.*$/, "").freeze
+          else
+            @version = nil
+          end
+        end
+        @version
+      end
+
+      # The preferred native interface. This is the native interface
+      # used by default when a factory is created.
+      # Supported values are <tt>:capi</tt> and <tt>:ffi</tt>.
+      #
+      # This is set automatically when RGeo loads, to <tt>:capi</tt>
+      # if the CAPI interface is available, otheriwse to <tt>:ffi</tt>
+      # if FFI is available, otherwise to nil if no GEOS interface is
+      # available. You can override this setting if you want to prefer
+      # FFI over CAPI.
+
+      attr_accessor :preferred_native_interface
+
+      # Returns a factory for the GEOS implementation.
+      # Returns nil if the GEOS implementation is not supported.
+      #
+      # Note that GEOS does not natively support 4-dimensional data
+      # (i.e. both z and m values). However, RGeo's GEOS wrapper does
+      # provide a 4-dimensional factory that utilizes an extra native
+      # GEOS object to handle the extra coordinate. Hence, a factory
+      # configured with both Z and M support will work, but will be
+      # slower than a 2-dimensional or 3-dimensional factory.
+      #
+      # Options include:
+      #
+      # [<tt>:native_interface</tt>]
+      #   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
+      #   approximate curves. The default is 1, which causes, for
+      #   example, the buffer around a point to be approximated by a
+      #   4-sided polygon. A resolution of 2 would cause that buffer
+      #   to be approximated by an 8-sided polygon. The exact behavior
+      #   for different kinds of buffers is defined by GEOS.
+      # [<tt>:srid</tt>]
+      #   Set the SRID returned by geometries created by this factory.
+      #   Default is 0.
+      # [<tt>:proj4</tt>]
+      #   The coordinate system in Proj4 format, either as a
+      #   CoordSys::Proj4 object or as a string or hash representing the
+      #   proj4 format. Optional.
+      # [<tt>:coord_sys</tt>]
+      #   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 value should be an implementation of
+      #   CoordSys::SRSDatabase::Interface. 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>]
+      #   Support <tt>m_coordinate</tt>. Default is false.
+      # [<tt>:wkt_parser</tt>]
+      #   Configure the parser for WKT. You may either pass a hash of
+      #   configuration parameters for WKRep::WKTParser.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS parser. Default is the empty hash, indicating the default
+      #   configuration for WKRep::WKTParser.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkb_parser</tt>]
+      #   Configure the parser for WKB. You may either pass a hash of
+      #   configuration parameters for WKRep::WKBParser.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS parser. Default is the empty hash, indicating the default
+      #   configuration for WKRep::WKBParser.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkt_generator</tt>]
+      #   Configure the generator for WKT. You may either pass a hash of
+      #   configuration parameters for WKRep::WKTGenerator.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS generator. Default is <tt>{:convert_case => :upper}</tt>.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkb_generator</tt>]
+      #   Configure the generator for WKB. You may either pass a hash of
+      #   configuration parameters for WKRep::WKBGenerator.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS generator. Default is the empty hash, indicating the
+      #   default configuration for WKRep::WKBGenerator.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:auto_prepare</tt>]
+      #   Request an auto-prepare strategy. Supported values are
+      #   <tt>:simple</tt> and <tt>:disabled</tt>. The former (which is
+      #   the default) generates a prepared geometry the second time an
+      #   operation that would benefit from it is called. The latter
+      #   never automatically generates a prepared geometry (unless you
+      #   generate one explicitly using the <tt>prepare!</tt> method).
+
+      def factory(opts_ = {})
+        if supported?
+          native_interface_ = opts_[:native_interface] || Geos.preferred_native_interface
+          if opts_[:has_z_coordinate] && opts_[:has_m_coordinate]
+            ZMFactory.new(opts_)
+          elsif native_interface_ == :ffi
+            FFIFactory.new(opts_)
+          else
+            CAPIFactory.create(opts_)
+          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.new { |c_| factory(defaults_.merge(c_)) }
+      end
+    end
+  end
+end

data/lib/rgeo/geos/utils.rb

@@ -0,0 +1,74 @@
+# -----------------------------------------------------------------------------
+#
+# Various Geos-related internal utilities
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geos
+    module Utils # :nodoc:
+      class << self
+        def ffi_coord_seqs_equal?(cs1_, cs2_, check_z_)
+          len1_ = cs1_.length
+          len2_ = cs2_.length
+          if len1_ == len2_
+            (0...len1_).each do |i_|
+              return false unless cs1_.get_x(i_) == cs2_.get_x(i_) &&
+                cs1_.get_y(i_) == cs2_.get_y(i_) &&
+                (!check_z_ || cs1_.get_z(i_) == cs2_.get_z(i_))
+            end
+            true
+          else
+            false
+          end
+        end
+
+        def ffi_compute_dimension(geom_)
+          result_ = -1
+          case geom_.type_id
+          when ::Geos::GeomTypes::GEOS_POINT
+            result_ = 0
+          when ::Geos::GeomTypes::GEOS_MULTIPOINT
+            result_ = 0 unless geom_.empty?
+          when ::Geos::GeomTypes::GEOS_LINESTRING, ::Geos::GeomTypes::GEOS_LINEARRING
+            result_ = 1
+          when ::Geos::GeomTypes::GEOS_MULTILINESTRING
+            result_ = 1 unless geom_.empty?
+          when ::Geos::GeomTypes::GEOS_POLYGON
+            result_ = 2
+          when ::Geos::GeomTypes::GEOS_MULTIPOLYGON
+            result_ = 2 unless geom_.empty?
+          when ::Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
+            geom_.each do |g_|
+              dim_ = ffi_compute_dimension(g_)
+              result_ = dim_ if result_ < dim_
+            end
+          end
+          result_
+        end
+
+        def ffi_coord_seq_hash(cs_, hash_ = 0)
+          (0...cs_.length).inject(hash_) do |_h_, i_|
+            [hash_, cs_.get_x(i_), cs_.get_y(i_), cs_.get_z(i_)].hash
+          end
+        end
+
+        def _init
+          if FFI_SUPPORTED
+            @ffi_supports_prepared_level_1 = ::Geos::FFIGeos.respond_to?(:GEOSPreparedContains_r)
+            @ffi_supports_prepared_level_2 = ::Geos::FFIGeos.respond_to?(:GEOSPreparedDisjoint_r)
+            @ffi_supports_set_output_dimension = ::Geos::FFIGeos.respond_to?(:GEOSWKTWriter_setOutputDimension_r)
+          end
+          @psych_wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
+          @marshal_wkb_generator = WKRep::WKBGenerator.new
+        end
+
+        attr_reader :ffi_supports_prepared_level_1
+        attr_reader :ffi_supports_prepared_level_2
+        attr_reader :ffi_supports_set_output_dimension
+        attr_reader :psych_wkt_generator
+        attr_reader :marshal_wkb_generator
+      end
+    end
+  end
+end

data/lib/rgeo/geos/zm_factory.rb

@@ -0,0 +1,405 @@
+# -----------------------------------------------------------------------------
+#
+# GEOS zm factory implementation
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Geos
+    # A factory for Geos that handles both Z and M.
+
+    class ZMFactory
+      include Feature::Factory::Instance
+
+      # :stopdoc:
+
+      TYPE_KLASSES = {
+        Feature::Point => ZMPointImpl,
+        Feature::LineString => ZMLineStringImpl,
+        Feature::Line => ZMLineImpl,
+        Feature::LinearRing => ZMLinearRingImpl,
+        Feature::Polygon => ZMPolygonImpl,
+        Feature::GeometryCollection => ZMGeometryCollectionImpl,
+        Feature::MultiPoint => ZMMultiPointImpl,
+        Feature::MultiLineString => ZMMultiLineStringImpl,
+        Feature::MultiPolygon => ZMMultiPolygonImpl
+      }.freeze
+
+      # :startdoc:
+
+      class << self
+        # Create a new factory. Returns nil if the GEOS implementation is
+        # not supported.
+
+        def create(opts_ = {})
+          return nil unless Geos.supported?
+          new(opts_)
+        end
+      end
+
+      def initialize(opts_ = {}) # :nodoc:
+        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],
+          srid: srid_.to_i, proj4: proj4_, coord_sys: coord_sys_
+        }
+        native_interface_ = opts_[:native_interface] || Geos.preferred_native_interface
+        if native_interface_ == :ffi
+          @zfactory = FFIFactory.new(config_.merge(has_z_coordinate: true))
+          @mfactory = FFIFactory.new(config_.merge(has_m_coordinate: true))
+        else
+          @zfactory = CAPIFactory.create(config_.merge(has_z_coordinate: true))
+          @mfactory = CAPIFactory.create(config_.merge(has_m_coordinate: true))
+        end
+
+        wkt_generator_ = opts_[:wkt_generator]
+        case wkt_generator_
+        when ::Hash
+          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+        else
+          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
+        end
+        wkb_generator_ = opts_[:wkb_generator]
+        case wkb_generator_
+        when ::Hash
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+        else
+          @wkb_generator = WKRep::WKBGenerator.new
+        end
+        wkt_parser_ = opts_[:wkt_parser]
+        case wkt_parser_
+        when ::Hash
+          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser_)
+        else
+          @wkt_parser = WKRep::WKTParser.new(self)
+        end
+        wkb_parser_ = opts_[:wkb_parser]
+        case wkb_parser_
+        when ::Hash
+          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser_)
+        else
+          @wkb_parser = WKRep::WKBParser.new(self)
+        end
+      end
+
+      # Marshal support
+
+      def marshal_dump # :nodoc:
+        hash_ = {
+          "srid" => @zfactory.srid,
+          "bufr" => @zfactory.buffer_resolution,
+          "wktg" => @wkt_generator._properties,
+          "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)
+        }
+        proj4_ = @zfactory.proj4
+        coord_sys_ = @zfactory.coord_sys
+        hash_["proj4"] = proj4_.marshal_dump if proj4_
+        hash_["cs"] = coord_sys_.to_wkt if coord_sys_
+        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(
+          native_interface: (data_["nffi"] ? :ffi : :capi),
+          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"] ? :simple : :disabled),
+          proj4: proj4_,
+          coord_sys: coord_sys_
+        )
+      end
+
+      # Psych support
+
+      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
+        coder_["wkb_parser"] = @wkb_parser._properties
+        coder_["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
+        coder_["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
+        if (proj4_ = @zfactory.proj4)
+          str_ = proj4_.original_str || proj4_.canonical_str
+          coder_["proj4"] = proj4_.radians? ? { "proj4" => str_, "radians" => true } : str_
+        end
+        if (coord_sys_ = @zfactory.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(
+          native_interface: coder_["native_interface"] == "ffi" ? :ffi : :capi,
+          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
+        @zfactory.srid
+      end
+
+      # Returns the resolution used by buffer calculations on geometries
+      # created by this factory
+
+      def buffer_resolution
+        @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
+        @zfactory
+      end
+
+      # Returns the m-only factory corresponding to this factory.
+
+      def m_factory
+        @mfactory
+      end
+
+      # Factory equivalence test.
+
+      def eql?(rhs_)
+        rhs_.is_a?(ZMFactory) && rhs_.z_factory == @zfactory
+      end
+      alias_method :==, :eql?
+
+      # Standard hash code
+
+      def hash
+        @hash ||= [@zfactory, @mfactory].hash
+      end
+
+      # See ::RGeo::Feature::Factory#property
+
+      def property(name_)
+        case name_
+        when :has_z_coordinate, :has_m_coordinate, :is_cartesian
+          true
+        end
+      end
+
+      # See ::RGeo::Feature::Factory#parse_wkt
+
+      def parse_wkt(str_)
+        @wkt_parser.parse(str_)
+      end
+
+      # See ::RGeo::Feature::Factory#parse_wkb
+
+      def parse_wkb(str_)
+        @wkb_parser.parse(str_)
+      end
+
+      # See ::RGeo::Feature::Factory#point
+
+      def point(x_, y_, z_ = 0, m_ = 0)
+        _create_feature(ZMPointImpl, @zfactory.point(x_, y_, z_), @mfactory.point(x_, y_, m_))
+      end
+
+      # See ::RGeo::Feature::Factory#line_string
+
+      def line_string(points_)
+        _create_feature(ZMLineStringImpl, @zfactory.line_string(points_), @mfactory.line_string(points_))
+      end
+
+      # See ::RGeo::Feature::Factory#line
+
+      def line(start_, end_)
+        _create_feature(ZMLineImpl, @zfactory.line(start_, end_), @mfactory.line(start_, end_))
+      end
+
+      # See ::RGeo::Feature::Factory#linear_ring
+
+      def linear_ring(points_)
+        _create_feature(ZMLinearRingImpl, @zfactory.linear_ring(points_), @mfactory.linear_ring(points_))
+      end
+
+      # See ::RGeo::Feature::Factory#polygon
+
+      def polygon(outer_ring_, inner_rings_ = nil)
+        _create_feature(ZMPolygonImpl, @zfactory.polygon(outer_ring_, inner_rings_), @mfactory.polygon(outer_ring_, inner_rings_))
+      end
+
+      # See ::RGeo::Feature::Factory#collection
+
+      def collection(elems_)
+        _create_feature(ZMGeometryCollectionImpl, @zfactory.collection(elems_), @mfactory.collection(elems_))
+      end
+
+      # See ::RGeo::Feature::Factory#multi_point
+
+      def multi_point(elems_)
+        _create_feature(ZMMultiPointImpl, @zfactory.multi_point(elems_), @mfactory.multi_point(elems_))
+      end
+
+      # See ::RGeo::Feature::Factory#multi_line_string
+
+      def multi_line_string(elems_)
+        _create_feature(ZMMultiLineStringImpl, @zfactory.multi_line_string(elems_), @mfactory.multi_line_string(elems_))
+      end
+
+      # See ::RGeo::Feature::Factory#multi_polygon
+
+      def multi_polygon(elems_)
+        _create_feature(ZMMultiPolygonImpl, @zfactory.multi_polygon(elems_), @mfactory.multi_polygon(elems_))
+      end
+
+      # See ::RGeo::Feature::Factory#proj4
+
+      def proj4
+        @zfactory.proj4
+      end
+
+      # See ::RGeo::Feature::Factory#coord_sys
+
+      def coord_sys
+        @zfactory.coord_sys
+      end
+
+      # 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_
+        when ZMGeometryMethods
+          # Optimization if we're just changing factories, but to
+          # another ZM factory.
+          if original_.factory != self && ntype_ == type_ &&
+              (!project_ || original_.factory.proj4 == @proj4)
+            zresult_ = original_.z_geometry.dup
+            zresult_._set_factory(@zfactory)
+            mresult_ = original_.m_geometry.dup
+            mresult_._set_factory(@mfactory)
+            return original_.class.create(self, zresult_, mresult_)
+          end
+          # LineString conversion optimization.
+          if (original_.factory != self || ntype_ != type_) &&
+              (!project_ || original_.factory.proj4 == @proj4) &&
+              type_.subtype_of?(Feature::LineString) && ntype_.subtype_of?(Feature::LineString)
+            klass_ = Factory::IMPL_CLASSES[ntype_]
+            zresult_ = klass_._copy_from(@zfactory, original_.z_geometry)
+            mresult_ = klass_._copy_from(@mfactory, original_.m_geometry)
+            return ZMLineStringImpl.create(self, zresult_, mresult_)
+          end
+        end
+        false
+      end
+
+      def _create_feature(klass_, zgeometry_, mgeometry_) # :nodoc:
+        klass_ ||= TYPE_KLASSES[zgeometry_.geometry_type] || ZMGeometryImpl
+        zgeometry_ && mgeometry_ ? klass_.new(self, zgeometry_, mgeometry_) : nil
+      end
+
+      def _marshal_wkb_generator # :nodoc:
+        unless defined?(@marshal_wkb_generator)
+          @marshal_wkb_generator = ::RGeo::WKRep::WKBGenerator.new(
+            type_format: :wkb12)
+        end
+        @marshal_wkb_generator
+      end
+
+      def _marshal_wkb_parser # :nodoc:
+        unless defined?(@marshal_wkb_parser)
+          @marshal_wkb_parser = ::RGeo::WKRep::WKBParser.new(self,
+            support_wkb12: true)
+        end
+        @marshal_wkb_parser
+      end
+
+      def _psych_wkt_generator # :nodoc:
+        unless defined?(@psych_wkt_generator)
+          @psych_wkt_generator = ::RGeo::WKRep::WKTGenerator.new(
+            tag_format: :wkt12)
+        end
+        @psych_wkt_generator
+      end
+
+      def _psych_wkt_parser # :nodoc:
+        unless defined?(@psych_wkt_parser)
+          @psych_wkt_parser = ::RGeo::WKRep::WKTParser.new(self,
+            support_wkt12: true, support_ewkt: true)
+        end
+        @psych_wkt_parser
+      end
+    end
+  end
+end