rgeo 2.3.0 → 3.0.0.pre.rc.1

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -79,7 +79,8 @@ module RGeo
 
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         if @x < -180.0 || @x > 180.0
           @x = @x % 360.0
           @x -= 360.0 if @x > 180.0
@@ -97,7 +98,7 @@ module RGeo
         end
       end
 
-      def is_simple?
+      def simple?
         len = arcs.length
         return false if arcs.any?(&:degenerate?)
         return true if len == 1
@@ -120,9 +121,74 @@ 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
+
+      def intersects?(rhs)
+        case rhs
+        when Feature::LineString
+          intersects_line_string?(rhs)
+        else
+          super
+        end
+      end
+
+      def crosses?(rhs)
+        case rhs
+        when Feature::LineString
+          crosses_line_string?(rhs)
+        else
+          super
+        end
+      end
+
+      private
+
+      # TODO: replace with better algorithm (https://github.com/rgeo/rgeo/issues/274)
+      # Very simple algorithm to determine if 2 LineStrings intersect.
+      # Uses a nested for loop to look at each arc in the LineStrings and
+      # check if each arc intersects.
+      #
+      # @param [RGeo::Geographic::SphericalLineStringImpl] rhs
+      #
+      # @return [Boolean]
+      def intersects_line_string?(rhs)
+        arcs.each do |arc|
+          rhs.arcs.each do |rhs_arc|
+            return true if arc.intersects_arc?(rhs_arc)
+          end
+        end
+
+        false
+      end
+
+      # TODO: replace with better algorithm (https://github.com/rgeo/rgeo/issues/274)
+      # Very simple algorithm to determine if 2 LineStrings cross.
+      # Uses a nested for loop to look at each arc in the LineStrings and
+      # check if each arc crosses.
+      #
+      # @param [RGeo::Geographic::SphericalLineStringImpl] rhs
+      #
+      # @return [Boolean]
+      def crosses_line_string?(rhs)
+        arcs.each do |arc|
+          rhs.arcs.each do |rhs_arc|
+            next unless arc.intersects_arc?(rhs_arc)
+
+            # check that endpoints aren't the intersection point
+            is_endpoint = arc.contains_point?(rhs_arc.s) || arc.contains_point?(rhs_arc.e) || rhs_arc.contains_point?(arc.s) || rhs_arc.contains_point?(arc.e)
+            return true unless is_endpoint
+          end
+        end
+
+        false
+      end
     end
 
     module SphericalMultiLineStringMethods # :nodoc:

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
@@ -137,16 +136,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 +177,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 +187,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 +232,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 +251,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 +293,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 +384,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 +392,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 +400,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,23 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Geos
-    module CAPIGeometryMethods # :nodoc:
+    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?
+      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?
+      end
+
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)} #{as_text.inspect}>"
       end
@@ -50,25 +62,52 @@ 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
 
-    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
@@ -78,38 +117,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,9 +20,6 @@ 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
@@ -145,7 +142,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 +170,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 +183,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 +221,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 +235,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 +246,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 +400,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:
@@ -95,11 +97,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
@@ -113,14 +113,42 @@ module RGeo
         @factory.generate_wkb(self)
       end
 
-      def is_empty?
+      def empty?
         @fg_geom.empty?
       end
 
-      def is_simple?
+      def is_empty?
+        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
+        empty?
+      end
+
+      def simple?
         @fg_geom.simple?
       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 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)
@@ -367,14 +395,24 @@ module RGeo
         end
       end
 
-      def is_closed?
+      def closed?
         @fg_geom.closed?
       end
 
-      def is_ring?
+      def is_closed?
+        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 ring?
         @fg_geom.ring?
       end
 
+      def is_ring?
+        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
+        ring?
+      end
+
       def rep_equals?(rhs)
         rhs.class == self.class && rhs.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
@@ -553,7 +591,7 @@ module RGeo
         @fg_geom.length
       end
 
-      def is_closed?
+      def closed?
         size = num_geometries
         size.times do |n|
           return false unless @fg_geom.get_geometry_n(n).closed?
@@ -561,6 +599,11 @@ module RGeo
         true
       end
 
+      def is_closed?
+        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 coordinates
         each.map(&:coordinates)
       end