rgeo-dschee 0.5.4

data/lib/rgeo/feature/multi_point.rb

@@ -0,0 +1,33 @@
+# -----------------------------------------------------------------------------
+#
+# MultiPoint feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A MultiPoint is a 0-dimensional GeometryCollection. The elements of
+    # a MultiPoint are restricted to Points. The Points are not connected
+    # or ordered.
+    #
+    # A MultiPoint is simple if no two Points in the MultiPoint are equal
+    # (have identical coordinate values).
+    #
+    # The boundary of a MultiPoint is the empty set.
+    #
+    # == Notes
+    #
+    # MultiPoint is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module MultiPoint
+      include GeometryCollection
+      extend Type
+    end
+  end
+end

data/lib/rgeo/feature/multi_polygon.rb

@@ -0,0 +1,57 @@
+# -----------------------------------------------------------------------------
+#
+# MultiPolygon feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A MultiPolygon is a MultiSurface whose elements are Polygons.
+    #
+    # The assertions for MultiPolygons are as follows.
+    #
+    # a) The interiors of 2 Polygons that are elements of a MultiPolygon
+    # may not intersect.
+    #
+    # b) The boundaries of any 2 Polygons that are elements of a
+    # MultiPolygon may not "cross" and may touch at only a finite number
+    # of Points. NOTE: Crossing is prevented by assertion (a) above.
+    #
+    # c) A MultiPolygon is defined as topologically closed.
+    #
+    # d) A MultiPolygon may not have cut lines, spikes or punctures, a
+    # MultiPolygon is a regular closed Point set:
+    #
+    # e) The interior of a MultiPolygon with more than 1 Polygon is not
+    # connected, the number of connected components of the interior of a
+    # MultiPolygon is equal to the number of Polygons in the MultiPolygon.
+    #
+    # The boundary of a MultiPolygon is a set of closed Curves
+    # (LineStrings) corresponding to the boundaries of its element
+    # Polygons. Each Curve in the boundary of the MultiPolygon is in the
+    # boundary of exactly 1 element Polygon, and every Curve in the
+    # boundary of an element Polygon is in the boundary of the
+    # MultiPolygon.
+    #
+    # NOTE: The subclass of Surface named Polyhedral Surface is a faceted
+    # Surface whose facets are Polygons. A Polyhedral Surface is not a
+    # MultiPolygon because it violates the rule for MultiPolygons that the
+    # boundaries of the element Polygons intersect only at a finite number
+    # of Points.
+    #
+    # == Notes
+    #
+    # MultiPolygon is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module MultiPolygon
+      include MultiSurface
+      extend Type
+    end
+  end
+end

data/lib/rgeo/feature/multi_surface.rb

@@ -0,0 +1,73 @@
+# -----------------------------------------------------------------------------
+#
+# MultiSurface feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A MultiSurface is a 2-dimensional GeometryCollection whose elements
+    # are Surfaces. The interiors of any two Surfaces in a MultiSurface may
+    # not intersect. The boundaries of any two elements in a MultiSurface
+    # may intersect, at most, at a finite number of Points.
+    #
+    # MultiSurface is a non-instantiable class in this International
+    # Standard. It defines a set of methods for its subclasses and is
+    # included for reasons of extensibility. The instantiable subclass of
+    # MultiSurface is MultiPolygon, corresponding to a collection of
+    # Polygons.
+    #
+    # == Notes
+    #
+    # MultiSurface is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module MultiSurface
+      include GeometryCollection
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # The area of this MultiSurface, as measured in the spatial reference
+      # system of this MultiSurface.
+      #
+      # === Notes
+      #
+      # Returns a floating-point scalar value.
+
+      def area
+        raise Error::UnsupportedOperation, "Method MultiSurface#area not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # The mathematical centroid for this MultiSurface as a Point. The
+      # result is not guaranteed to be on this MultiSurface.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Point interface.
+
+      def centroid
+        raise Error::UnsupportedOperation, "Method MultiSurface#centroid not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # A Point guaranteed to be on this MultiSurface.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Point interface.
+
+      def point_on_surface
+        raise Error::UnsupportedOperation, "Method MultiSurface#point_on_surface not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/point.rb

@@ -0,0 +1,84 @@
+# -----------------------------------------------------------------------------
+#
+# Point feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A Point is a 0-dimensional geometric object and represents a single
+    # location in coordinate space. A Point has an x-coordinate value and
+    # a y-coordinate value.
+    #
+    # The boundary of a Point is the empty set.
+    #
+    # == Notes
+    #
+    # Point is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+    #
+    # Some implementations may support higher dimensional points.
+    #
+    # Some libraries, such as GEOS, support "empty" points. Such objects
+    # might be returned as, for example, the centroid of an empty
+    # MultiPolygon. The SFS does not clearly define or even acknowledge
+    # the existence of such a type, so RGeo will currently generally
+    # replace them with empty GeometryCollection objects. Therefore,
+    # currently, every RGeo Point object represents an actual location
+    # with real coordinates.
+
+    module Point
+      include Geometry
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # The x-coordinate value for this Point.
+      #
+      # === Notes
+      #
+      # Returns a floating-point scalar value.
+
+      def x
+        raise Error::UnsupportedOperation, "Method Point#x not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # The y-coordinate value for this Point.
+      #
+      # === Notes
+      #
+      # Returns a floating-point scalar value.
+
+      def y
+        raise Error::UnsupportedOperation, "Method Point#y not defined."
+      end
+
+      # Returns the z-coordinate for this Point as a floating-point
+      # scalar value.
+      #
+      # This method may not be available if the point's factory does
+      # not support Z coordinates.
+
+      def z
+        raise Error::UnsupportedOperation, "Method Point#z not defined."
+      end
+
+      # Returns the m-coordinate for this Point as a floating-point
+      # scalar value.
+      #
+      # This method may not be available if the point's factory does
+      # not support M coordinates.
+
+      def m
+        raise Error::UnsupportedOperation, "Method Point#m not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/polygon.rb

@@ -0,0 +1,97 @@
+# -----------------------------------------------------------------------------
+#
+# Polygon feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A Polygon is a planar Surface defined by 1 exterior boundary and 0 or
+    # more interior boundaries. Each interior boundary defines a hole in
+    # the Polygon.
+    #
+    # The assertions for Polygons (the rules that define valid Polygons)
+    # are as follows:
+    #
+    # (a) Polygons are topologically closed;
+    #
+    # (b) The boundary of a Polygon consists of a set of LinearRings that
+    # make up its exterior and interior boundaries;
+    #
+    # (c) No two Rings in the boundary cross and the Rings in the boundary
+    # of a Polygon may intersect at a Point but only as a tangent;
+    #
+    # (d) A Polygon may not have cut lines, spikes or punctures;
+    #
+    # (e) The interior of every Polygon is a connected point set;
+    #
+    # (f) The exterior of a Polygon with 1 or more holes is not connected.
+    # Each hole defines a connected component of the exterior.
+    #
+    # In the above assertions, interior, closure and exterior have the
+    # standard topological definitions. The combination of (a) and (c) make
+    # a Polygon a regular closed Point set.
+    #
+    # Polygons are simple geometric objects.
+    #
+    # == Notes
+    #
+    # Polygon is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+
+    module Polygon
+      include Surface
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # Returns the exterior ring of this Polygon.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the LinearRing interface.
+
+      def exterior_ring
+        raise Error::UnsupportedOperation, "Method Polygon#exterior_ring not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # Returns the number of interiorRings in this Polygon.
+      #
+      # === Notes
+      #
+      # Returns an integer.
+
+      def num_interior_rings
+        raise Error::UnsupportedOperation, "Method Polygon#num_interior_rings not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # Returns the Nth interiorRing for this Polygon as a LineString.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the LinearRing interface, or nil
+      # if the given N is out of range. N is zero-based.
+      # Does not support negative indexes.
+
+      def interior_ring_n(_n_)
+        raise Error::UnsupportedOperation, "Method Polygon#interior_ring_n not defined."
+      end
+
+      # Returns the interior rings as a (possibly empty) array of objects
+      # that support the LinearRing interface.
+
+      def interior_rings
+        raise Error::UnsupportedOperation, "Method Polygon#interior_rings not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/surface.rb

@@ -0,0 +1,79 @@
+# -----------------------------------------------------------------------------
+#
+# Surface feature interface
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # == SFS 1.1 Description
+    #
+    # A Surface is a 2-dimensional geometric object.
+    #
+    # A simple Surface consists of a single "patch" that is associated with
+    # one "exterior boundary" and 0 or more "interior" boundaries. Simple
+    # Surfaces in 3-dimensional space are isomorphic to planar Surfaces.
+    # Polyhedral Surfaces are formed by "stitching" together simple
+    # Surfaces along their boundaries, polyhedral Surfaces in 3-dimensional
+    # space may not be planar as a whole.
+    #
+    # The boundary of a simple Surface is the set of closed Curves
+    # corresponding to its "exterior" and "interior" boundaries.
+    #
+    # The only instantiable subclass of Surface defined in this
+    # specification, Polygon, is a simple Surface that is planar.
+    #
+    # == Notes
+    #
+    # Surface is defined as a module and is provided primarily
+    # for the sake of documentation. Implementations need not necessarily
+    # include this module itself. Therefore, you should not depend on the
+    # kind_of? method to check type. Instead, use the provided check_type
+    # class method (or === operator) defined in the Type module.
+    #
+    # Some implementations may support higher dimensional points.
+
+    module Surface
+      include Geometry
+      extend Type
+
+      # === SFS 1.1 Description
+      #
+      # The area of this Surface, as measured in the spatial reference
+      # system of this Surface.
+      #
+      # === Notes
+      #
+      # Returns a floating-point scalar value.
+
+      def area
+        raise Error::UnsupportedOperation, "Method Surface#area not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # The mathematical centroid for this Surface as a Point. The result
+      # is not guaranteed to be on this Surface.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Point interface.
+
+      def centroid
+        raise Error::UnsupportedOperation, "Method Surface#centroid not defined."
+      end
+
+      # === SFS 1.1 Description
+      #
+      # A Point guaranteed to be on this Surface.
+      #
+      # === Notes
+      #
+      # Returns an object that supports the Point interface.
+
+      def point_on_surface
+        raise Error::UnsupportedOperation, "Method Surface#point_on_surface not defined."
+      end
+    end
+  end
+end

data/lib/rgeo/feature/types.rb

@@ -0,0 +1,284 @@
+# -----------------------------------------------------------------------------
+#
+# Feature type management and casting
+#
+# -----------------------------------------------------------------------------
+
+module RGeo
+  module Feature
+    # All geometry implementations MUST include this submodule.
+    # This serves as a marker that may be used to test an object for
+    # feature-ness.
+
+    module Instance
+    end
+
+    # This module provides the API for geometry type objects. Technically
+    # these objects are modules (such as ::RGeo::Feature::Point), but as
+    # objects they respond to the methods documented here.
+    #
+    # For example, you may determine whether a feature object is a
+    # point by calling:
+    #
+    #   ::RGeo::Feature::Point.check_type(object)
+    #
+    # A corresponding === operator is provided so you can use the type
+    # modules in a case-when clause:
+    #
+    #   case object
+    #   when ::RGeo::Feature::Point
+    #     # do stuff here...
+    #
+    # However, a feature object may not actually include the point module
+    # itself; hence, the following will *not* work:
+    #
+    #   object.is_a?(::RGeo::Feature::Point)  # DON'T DO THIS-- DOES NOT WORK
+    #
+    # You may obtain the type of a feature object by calling its
+    # geometry_type method. You may then use the methods in this module to
+    # interrogate that type.
+    #
+    #   # supppose object is a Point
+    #   type = object.geometry_type  # ::RGeo::Feature::Point
+    #   type.type_name               # "Point"
+    #   type.supertype               # ::RGeo::Feature::Geometry
+    #
+    # You may also use the presence of this module to determine whether
+    # a particular object is a feature type:
+    #
+    #   ::RGeo::Feature::Type === object.geometry_type  # true
+
+    module Type
+      # Deprecated alias for RGeo::Feature::Instance
+      Instance = Feature::Instance
+
+      # Returns true if the given object is this type or a subtype
+      # thereof, or if it is a feature object whose geometry_type is
+      # this type or a subtype thereof.
+      #
+      # Note that feature objects need not actually include this module.
+      # Therefore, the is_a? method will generally not work.
+
+      def check_type(rhs_)
+        rhs_ = rhs_.geometry_type if rhs_.is_a?(Feature::Instance)
+        rhs_.is_a?(Type) && (rhs_ == self || rhs_.include?(self))
+      end
+      alias_method :===, :check_type
+
+      # Returns true if this type is the same type or a subtype of the
+      # given type.
+
+      def subtype_of?(type_)
+        self == type_ || self.include?(type_)
+      end
+
+      # Returns the supertype of this type. The supertype of Geometry
+      # is nil.
+
+      def supertype
+        @supertype
+      end
+
+      # Iterates over the known immediate subtypes of this type.
+
+      def each_immediate_subtype(&block_)
+        @subtypes.each(&block_) if defined?(@subtypes) && @subtypes
+      end
+
+      # Returns the OpenGIS type name of this type. For example:
+      #
+      #   ::RGeo::Feature::Point.type_name  # "Point"
+
+      def type_name
+        name.sub("RGeo::Feature::", "")
+      end
+      alias_method :to_s, :type_name
+
+      def _add_subtype(type_) # :nodoc:
+        (@subtypes ||= []) << type_
+      end
+
+      def self.extended(type_) # :nodoc:
+        supertype_ = type_.included_modules.find { |m_| m_.is_a?(self) }
+        type_.instance_variable_set(:@supertype, supertype_)
+        supertype_._add_subtype(type_) if supertype_
+      end
+    end
+
+    class << self
+      # Cast the given object according to the given parameters, if
+      # possible, and return the resulting object. If the requested cast
+      # is not possible, nil is returned.
+      #
+      # Parameters may be provided as a hash, or as separate arguments.
+      # Hash keys are as follows:
+      #
+      # [<tt>:factory</tt>]
+      #   Set the factory to the given factory. If this argument is not
+      #   given, the original object's factory is kept.
+      # [<tt>:type</tt>]
+      #   Cast to the given type, which must be a module in the
+      #   RGeo::Feature namespace. If this argument is not given, the
+      #   result keeps the same type as the original.
+      # [<tt>:project</tt>]
+      #   If this is set to true, and both the original and new factories
+      #   support proj4 projections, then the cast will also cause the
+      #   coordinates to be transformed between those two projections.
+      #   If set to false, the coordinates are not modified. Default is
+      #   false.
+      # [<tt>:keep_subtype</tt>]
+      #   Value must be a boolean indicating whether to keep the subtype
+      #   of the original. If set to false, casting to a particular type
+      #   always casts strictly to that type, even if the old type is a
+      #   subtype of the new type. If set to true, the cast retains the
+      #   subtype in that case. For example, casting a LinearRing to a
+      #   LineString will normally yield a LineString, even though
+      #   LinearRing is already a more specific subtype. If you set this
+      #   value to true, the casted object will remain a LinearRing.
+      #   Default is false.
+      # [<tt>:force_new</tt>]
+      #   Always return a newly-created object, even if neither the type
+      #   nor factory is modified. Normally, if this is set to false, and
+      #   a cast is not set to modify either the factory or type, the
+      #   original object itself is returned. Setting this flag to true
+      #   causes cast to return a clone in that case. Default is false.
+      #
+      # You may also pass the new factory, the new type, and the flags
+      # as separate arguments. In this case, the flag names must be
+      # passed as symbols, and their effect is the same as setting their
+      # values to true. You can even combine separate arguments and hash
+      # arguments. For example, the following three calls are equivalent:
+      #
+      #  RGeo::Feature.cast(geom, :type => RGeo::Feature::Point, :project => true)
+      #  RGeo::Feature.cast(geom, RGeo::Feature::Point, :project => true)
+      #  RGeo::Feature.cast(geom, RGeo::Feature::Point, :project)
+      #
+      # RGeo provides a default casting algorithm. Individual feature
+      # implementation factories may override this and customize the
+      # casting behavior by defining the override_cast method. See
+      # ::RGeo::Feature::Factory#override_cast for more details.
+
+      def cast(obj_, *params_)
+        # Interpret params
+        factory_ = obj_.factory
+        type_ = obj_.geometry_type
+        opts_ = {}
+        params_.each do |param_|
+          case param_
+          when Factory::Instance
+            opts_[:factory] = param_
+          when Type
+            opts_[:type] = param_
+          when ::Symbol
+            opts_[param_] = true
+          when ::Hash
+            opts_.merge!(param_)
+          end
+        end
+        force_new_ = opts_[:force_new]
+        keep_subtype_ = opts_[:keep_subtype]
+        project_ = opts_[:project]
+        nfactory_ = opts_.delete(:factory) || factory_
+        ntype_ = opts_.delete(:type) || type_
+
+        # Let the factory override
+        if nfactory_.respond_to?(:override_cast)
+          override_ = nfactory_.override_cast(obj_, ntype_, opts_)
+          return override_ unless override_ == false
+        end
+
+        # Default algorithm
+        ntype_ = type_ if keep_subtype_ && type_.include?(ntype_)
+        if ntype_ == type_
+          # Types are the same
+          if nfactory_ == factory_
+            force_new_ ? obj_.dup : obj_
+          else
+            if type_ == Point
+              proj_ = nproj_ = nil
+              if project_
+                proj_ = factory_.proj4
+                nproj_ = nfactory_.proj4
+              end
+              hasz_ = factory_.property(:has_z_coordinate)
+              nhasz_ = nfactory_.property(:has_z_coordinate)
+              if proj_ && nproj_
+                coords_ = CoordSys::Proj4.transform_coords(proj_, nproj_, obj_.x, obj_.y, hasz_ ? obj_.z : nil)
+                coords_ << (hasz_ ? obj_.z : 0.0) if nhasz_ && coords_.size < 3
+              else
+                coords_ = [obj_.x, obj_.y]
+                coords_ << (hasz_ ? obj_.z : 0.0) if nhasz_
+              end
+              coords_ << (factory_.property(:has_m_coordinate) ? obj_.m : 0.0) if nfactory_.property(:has_m_coordinate)
+              nfactory_.point(*coords_)
+            elsif type_ == Line
+              nfactory_.line(cast(obj_.start_point, nfactory_, opts_), cast(obj_.end_point, nfactory_, opts_))
+            elsif type_ == LinearRing
+              nfactory_.linear_ring(obj_.points.map { |p_| cast(p_, nfactory_, opts_) })
+            elsif type_ == LineString
+              nfactory_.line_string(obj_.points.map { |p_| cast(p_, nfactory_, opts_) })
+            elsif type_ == Polygon
+              nfactory_.polygon(cast(obj_.exterior_ring, nfactory_, opts_),
+                                obj_.interior_rings.map { |r_| cast(r_, nfactory_, opts_) })
+            elsif type_ == MultiPoint
+              nfactory_.multi_point(obj_.map { |g_| cast(g_, nfactory_, opts_) })
+            elsif type_ == MultiLineString
+              nfactory_.multi_line_string(obj_.map { |g_| cast(g_, nfactory_, opts_) })
+            elsif type_ == MultiPolygon
+              nfactory_.multi_polygon(obj_.map { |g_| cast(g_, nfactory_, opts_) })
+            elsif type_ == GeometryCollection
+              nfactory_.collection(obj_.map { |g_| cast(g_, nfactory_, opts_) })
+            end
+          end
+        else
+          # Types are different
+          if ntype_ == Point && (type_ == MultiPoint || type_ == GeometryCollection) ||
+              (ntype_ == Line || ntype_ == LineString || ntype_ == LinearRing) && (type_ == MultiLineString || type_ == GeometryCollection) ||
+              ntype_ == Polygon && (type_ == MultiPolygon || type_ == GeometryCollection)
+            if obj_.num_geometries == 1
+              cast(obj_.geometry_n(0), nfactory_, ntype_, opts_)
+            end
+          elsif ntype_ == Point
+            nil
+          elsif ntype_ == Line
+            if type_ == LineString && obj_.num_points == 2
+              nfactory_.line(cast(obj_.point_n(0), nfactory_, opts_), cast(obj_.point_n(1), nfactory_, opts_))
+            end
+          elsif ntype_ == LinearRing
+            if type_ == LineString
+              nfactory_.linear_ring(obj_.points.map { |p_| cast(p_, nfactory_, opts_) })
+            end
+          elsif ntype_ == LineString
+            if type_ == Line || type_ == LinearRing
+              nfactory_.line_string(obj_.points.map { |p_| cast(p_, nfactory_, opts_) })
+            end
+          elsif ntype_ == MultiPoint
+            if type_ == Point
+              nfactory_.multi_point([cast(obj_, nfactory_, opts_)])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_point(obj_.map { |p_| cast(p_, nfactory_, opts_) })
+            end
+          elsif ntype_ == MultiLineString
+            if type_ == Line || type_ == LinearRing || type_ == LineString
+              nfactory_.multi_line_string([cast(obj_, nfactory_, opts_)])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_line_string(obj_.map { |p_| cast(p_, nfactory_, opts_) })
+            end
+          elsif ntype_ == MultiPolygon
+            if type_ == Polygon
+              nfactory_.multi_polygon([cast(obj_, nfactory_, opts_)])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_polygon(obj_.map { |p_| cast(p_, nfactory_, opts_) })
+            end
+          elsif ntype_ == GeometryCollection
+            if type_ == MultiPoint || type_ == MultiLineString || type_ == MultiPolygon
+              nfactory_.collection(obj_.map { |p_| cast(p_, nfactory_, opts_) })
+            else
+              nfactory_.collection([cast(obj_, nfactory_, opts_)])
+            end
+          end
+        end
+      end
+    end
+  end
+end