rgeo 2.3.1 → 3.0.0.pre.rc.2

data/lib/rgeo/geographic/interface.rb

@@ -54,12 +54,6 @@ module RGeo
       #   Support a Z coordinate. Default is false.
       # [<tt>:has_m_coordinate</tt>]
       #   Support an M coordinate. Default is false.
-      # [<tt>:uses_lenient_assertions</tt>]
-      #   If set to true, assertion checking is disabled. This includes
-      #   simplicity checking on LinearRing, and validity checks on
-      #   Polygon and MultiPolygon. This may speed up creation of certain
-      #   objects, at the expense of not doing the proper checking for
-      #   OGC compliance. Default is false.
       # [<tt>:buffer_resolution</tt>]
       #   The resolution of buffers around geometries created by this
       #   factory. This controls the number of line segments used to
@@ -89,11 +83,6 @@ module RGeo
       #   visualization crs". You may alternatively wish to set the srid
       #   to 4326, indicating the WGS84 crs, but note that that value
       #   implies an ellipsoidal datum, not a spherical datum.
-      # [<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>:wkt_parser</tt>]
       #   Configure the parser for WKT. The value is a hash of
       #   configuration parameters for WKRep::WKTParser.new. Default is
@@ -118,20 +107,12 @@ 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
         Geographic::Factory.new("Spherical",
           has_z_coordinate: opts[:has_z_coordinate],
           has_m_coordinate: opts[:has_m_coordinate],
           proj4: proj4 || proj_4055,
           coord_sys: coord_sys || coord_sys_4055,
-          uses_lenient_assertions: opts[:uses_lenient_assertions],
           buffer_resolution: opts[:buffer_resolution],
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
@@ -207,10 +188,8 @@ module RGeo
       #
       # You may also provide options understood by the underlying
       # projected Cartesian factory. For example, if GEOS is used for the
-      # projected factory, you may also set the
-      # <tt>:lenient_multi_polygon_assertions</tt> and
-      # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
-      # more details.
+      # projected factory, you may also set the <tt>:buffer_resolution</tt>
+      # options. See RGeo::Geos.factory for more details.
 
       def simple_mercator_factory(opts = {})
         factory = Geographic::Factory.new("Projected",
@@ -222,12 +201,9 @@ module RGeo
           wkt_generator: opts[:wkt_generator],
           wkb_generator: opts[:wkb_generator],
           has_z_coordinate: opts[:has_z_coordinate],
-          has_m_coordinate: opts[:has_m_coordinate],
-          uses_lenient_assertions: opts[:uses_lenient_assertions])
+          has_m_coordinate: opts[:has_m_coordinate])
         projector = Geographic::SimpleMercatorProjector.new(factory,
           buffer_resolution: opts[:buffer_resolution],
-          lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-          uses_lenient_assertions: opts[:uses_lenient_assertions],
           has_z_coordinate: opts[:has_z_coordinate],
           has_m_coordinate: opts[:has_m_coordinate])
         factory.projector = projector
@@ -259,9 +235,7 @@ module RGeo
       # and let this method construct a projection factory for you (which
       # it will do using the preferred Cartesian factory generator).
       # If you choose this second method, you may provide the proj4
-      # directly via the <tt>:projection_proj4</tt> option, or indirectly
-      # by providing both an <tt>:srid</tt> and a <tt>:srs_database</tt>
-      # to use to look up the coordinate system.
+      # via the <tt>:projection_proj4</tt> option.
       #
       # Following are detailed descriptions of the various options you can
       # pass to this method.
@@ -304,11 +278,6 @@ module RGeo
       #   The SRID value to use for the main geographic factory. Defaults
       #   to the given geographic coordinate system's authority code, or
       #   to 0 if no geographic coordinate system is known.
-      # [<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 a Z coordinate. Default is false.
       #   Note: this is ignored if a <tt>:projection_factory</tt> is
@@ -342,13 +311,11 @@ module RGeo
       # If a <tt>:projection_factory</tt> is _not_ provided, you may also
       # provide options for configuring the projected Cartesian factory.
       # For example, if GEOS is used for the projected factory, you may
-      # also set the <tt>:lenient_multi_polygon_assertions</tt> and
-      # <tt>:buffer_resolution</tt> options. See RGeo::Geos.factory for
-      # more details.
+      # also set the <tt>:buffer_resolution</tt> option. See RGeo::Geos.factory
+      # for more details.
 
       def projected_factory(opts = {})
         CoordSys.check!(:proj4)
-        db_ = opts[:srs_database]
         if (projection_factory = opts[:projection_factory])
           # Get the projection coordinate systems from the given factory
           projection_proj4 = projection_factory.proj4
@@ -363,14 +330,6 @@ module RGeo
           proj4 = opts[:proj4]
           coord_sys = opts[:coord_sys]
           srid = opts[:srid]
-          # Lookup srid from srs database if needed
-          if (!proj4 || !coord_sys) && srid && db_
-            entry_ = db_.get(srid.to_i)
-            if entry_
-              proj4 ||= entry_.proj4
-              coord_sys ||= entry_.coord_sys
-            end
-          end
           # Fall back to getting the values from the projection.
           proj4 ||= projection_proj4.get_geographic || _proj_4326
           coord_sys ||= projection_coord_sys.geographic_coordinate_system if projection_coord_sys
@@ -447,8 +406,6 @@ module RGeo
             srid: projection_srid,
             coord_sys: projection_coord_sys,
             buffer_resolution: opts[:buffer_resolution],
-            lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-            uses_lenient_assertions: opts[:uses_lenient_assertions],
             has_z_coordinate: opts[:has_z_coordinate],
             has_m_coordinate: opts[:has_m_coordinate],
             wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],

data/lib/rgeo/geographic/proj4_projector.rb

@@ -48,8 +48,6 @@ module RGeo
               proj4: proj4,
               coord_sys: opts[:coord_sys], srid: opts[:srid],
               buffer_resolution: opts[:buffer_resolution],
-              lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-              uses_lenient_assertions: opts[:uses_lenient_assertions],
               has_z_coordinate: opts[:has_z_coordinate],
               has_m_coordinate: opts[:has_m_coordinate],
               wkt_parser: opts[:wkt_parser], wkt_generator: opts[:wkt_generator],

data/lib/rgeo/geographic/projected_feature_classes.rb

@@ -8,16 +8,18 @@
 
 module RGeo
   module Geographic
-    class ProjectedPointImpl # :nodoc:
+    class ProjectedPointImpl
       include Feature::Point
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPointMethods
       include ProjectedGeometryMethods
       include ProjectedPointMethods
     end
 
-    class ProjectedLineStringImpl  # :nodoc:
+    class ProjectedLineStringImpl
       include Feature::LineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ProjectedGeometryMethods
@@ -25,18 +27,21 @@ module RGeo
       include ProjectedLineStringMethods
     end
 
-    class ProjectedLinearRingImpl  # :nodoc:
+    class ProjectedLinearRingImpl
       include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLinearRingMethods
       include ProjectedGeometryMethods
       include ProjectedNCurveMethods
       include ProjectedLineStringMethods
+      include ProjectedLinearRingMethods
     end
 
-    class ProjectedLineImpl # :nodoc:
+    class ProjectedLineImpl
       include Feature::Line
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLineMethods
@@ -45,8 +50,9 @@ module RGeo
       include ProjectedLineStringMethods
     end
 
-    class ProjectedPolygonImpl # :nodoc:
+    class ProjectedPolygonImpl
       include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
       include ProjectedGeometryMethods
@@ -54,23 +60,26 @@ module RGeo
       include ProjectedPolygonMethods
     end
 
-    class ProjectedGeometryCollectionImpl # :nodoc:
+    class ProjectedGeometryCollectionImpl
       include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ProjectedGeometryMethods
     end
 
-    class ProjectedMultiPointImpl # :nodoc:
+    class ProjectedMultiPointImpl
       include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
       include ProjectedGeometryMethods
     end
 
-    class ProjectedMultiLineStringImpl # :nodoc:
+    class ProjectedMultiLineStringImpl
       include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiLineStringMethods
@@ -78,8 +87,9 @@ module RGeo
       include ProjectedNCurveMethods
     end
 
-    class ProjectedMultiPolygonImpl # :nodoc:
+    class ProjectedMultiPolygonImpl
       include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPolygonMethods
@@ -87,5 +97,7 @@ module RGeo
       include ProjectedNSurfaceMethods
       include ProjectedMultiPolygonMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -19,7 +19,23 @@ module RGeo
       end
 
       def envelope
-        factory.unproject(projection.envelope)
+        factory.unproject(projection.unsafe_envelope)
+      end
+
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
       end
 
       def empty?
@@ -40,8 +56,21 @@ module RGeo
         simple?
       end
 
+      def valid?
+        projection.valid?
+      end
+
+      def invalid_reason
+        projection.invalid_reason
+      end
+
+      # (see RGeo::ImplHelper::ValidityCheck#make_valid)
+      def make_valid
+        factory.unproject projection.make_valid
+      end
+
       def boundary
-        boundary = projection.boundary
+        boundary = projection.unsafe_boundary
         boundary ? factory.unproject(boundary) : nil
       end
 
@@ -50,79 +79,79 @@ module RGeo
       end
 
       def disjoint?(rhs)
-        projection.disjoint?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_disjoint?(Feature.cast(rhs, factory).projection)
       end
 
       def intersects?(rhs)
-        projection.intersects?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_intersects?(Feature.cast(rhs, factory).projection)
       end
 
       def touches?(rhs)
-        projection.touches?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_touches?(Feature.cast(rhs, factory).projection)
       end
 
       def crosses?(rhs)
-        projection.crosses?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_crosses?(Feature.cast(rhs, factory).projection)
       end
 
       def within?(rhs)
-        projection.within?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_within?(Feature.cast(rhs, factory).projection)
       end
 
       def contains?(rhs)
-        projection.contains?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_contains?(Feature.cast(rhs, factory).projection)
       end
 
       def overlaps?(rhs)
-        projection.overlaps?(Feature.cast(rhs, factory).projection)
+        projection.unsafe_overlaps?(Feature.cast(rhs, factory).projection)
       end
 
       def relate(rhs, pattern_)
-        projection.relate(Feature.cast(rhs, factory).projection, pattern_)
+        projection.unsafe_relate(Feature.cast(rhs, factory).projection, pattern_)
       end
 
       def distance(rhs)
-        projection.distance(Feature.cast(rhs, factory).projection)
+        projection.unsafe_distance(Feature.cast(rhs, factory).projection)
       end
 
       def buffer(distance)
-        factory.unproject(projection.buffer(distance))
+        factory.unproject(projection.unsafe_buffer(distance))
       end
 
       def buffer_with_style(distance, end_cap_style, join_style, mitre_limit)
-        factory.unproject(projection.buffer_with_style(distance, end_cap_style, join_style, mitre_limit))
+        factory.unproject(projection.unsafe_buffer_with_style(distance, end_cap_style, join_style, mitre_limit))
       end
 
       def simplify(tolerance)
-        factory.unproject(projection.simplify(tolerance))
+        factory.unproject(projection.unsafe_simplify(tolerance))
       end
 
       def simplify_preserve_topology(tolerance)
-        factory.unproject(projection.simplify_preserve_topology(tolerance))
+        factory.unproject(projection.unsafe_simplify_preserve_topology(tolerance))
       end
 
       def convex_hull
-        factory.unproject(projection.convex_hull)
+        factory.unproject(projection.unsafe_convex_hull)
       end
 
       def intersection(rhs)
-        factory.unproject(projection.intersection(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_intersection(Feature.cast(rhs, factory).projection))
       end
 
       def union(rhs)
-        factory.unproject(projection.union(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_union(Feature.cast(rhs, factory).projection))
       end
 
       def difference(rhs)
-        factory.unproject(projection.difference(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_difference(Feature.cast(rhs, factory).projection))
       end
 
       def sym_difference(rhs)
-        factory.unproject(projection.sym_difference(Feature.cast(rhs, factory).projection))
+        factory.unproject(projection.unsafe_sym_difference(Feature.cast(rhs, factory).projection))
       end
 
       def point_on_surface
-        factory.unproject(projection.point_on_surface)
+        factory.unproject(projection.unsafe_point_on_surface)
       end
     end
 
@@ -154,7 +183,8 @@ module RGeo
 
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         @y = 85.0511287 if @y > 85.0511287
         @y = -85.0511287 if @y < -85.0511287
         super
@@ -163,33 +193,41 @@ module RGeo
 
     module ProjectedNCurveMethods # :nodoc:
       def length
-        projection.length
+        projection.unsafe_length
       end
     end
 
     module ProjectedLineStringMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         @points = @points.map(&:canonical_point)
         super
       end
     end
 
+    module ProjectedLinearRingMethods # :nodoc:
+      def simple?
+        projection.valid?
+      end
+    end
+
     module ProjectedNSurfaceMethods # :nodoc:
       def area
-        projection.area
+        projection.unsafe_area
       end
 
       def centroid
-        factory.unproject(projection.centroid)
+        factory.unproject(projection.unsafe_centroid)
       end
     end
 
     module ProjectedPolygonMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure projection is available.
+      def init_geometry
         super
         unless projection
           raise Error::InvalidGeometry, "Polygon failed assertions"
@@ -200,7 +238,8 @@ module RGeo
     module ProjectedMultiPolygonMethods # :nodoc:
       private
 
-      def validate_geometry
+      # Ensure projection is available.
+      def init_geometry
         super
         unless projection
           raise Error::InvalidGeometry, "MultiPolygon failed assertions"

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -17,8 +17,6 @@ module RGeo
                                                           proj4: SimpleMercatorProjector._proj4_3857,
                                                           coord_sys: SimpleMercatorProjector._coordsys_3857,
                                                           buffer_resolution: opts[:buffer_resolution],
-                                                          lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
-                                                          uses_lenient_assertions: opts[:uses_lenient_assertions],
                                                           has_z_coordinate: opts[:has_z_coordinate],
                                                           has_m_coordinate: opts[:has_m_coordinate])
       end

data/lib/rgeo/geographic/spherical_feature_classes.rb

@@ -8,78 +8,98 @@
 
 module RGeo
   module Geographic
-    class SphericalPointImpl # :nodoc:
+    class SphericalPointImpl
       include Feature::Point
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPointMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalPointMethods
     end
 
-    class SphericalLineStringImpl # :nodoc:
+    class SphericalLineStringImpl
       include Feature::LineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalLineImpl # :nodoc:
+    class SphericalLineImpl
       include Feature::Line
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLineMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalLinearRingImpl # :nodoc:
+    class SphericalLinearRingImpl
       include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicLineStringMethods
       include ImplHelper::BasicLinearRingMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalLineStringMethods
     end
 
-    class SphericalPolygonImpl # :nodoc:
+    class SphericalPolygonImpl
       include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalPolygonMethods
     end
 
-    class SphericalGeometryCollectionImpl # :nodoc:
+    class SphericalGeometryCollectionImpl
       include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
 
-    class SphericalMultiPointImpl # :nodoc:
+    class SphericalMultiPointImpl
       include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
 
-    class SphericalMultiLineStringImpl # :nodoc:
+    class SphericalMultiLineStringImpl
       include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiLineStringMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
       include SphericalMultiLineStringMethods
     end
 
-    class SphericalMultiPolygonImpl # :nodoc:
+    class SphericalMultiPolygonImpl
       include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPolygonMethods
+      include ImplHelper::ValidOp
       include SphericalGeometryMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -12,6 +12,22 @@ module RGeo
       def srid
         factory.srid
       end
+
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
     end
 
     module SphericalPointMethods # :nodoc:
@@ -79,7 +95,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
@@ -128,6 +145,66 @@ module RGeo
       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:
@@ -155,7 +232,7 @@ module RGeo
         centroid_lat /= (6.0 * signed_area)
         centroid_lng /= (6.0 * signed_area)
 
-        RGeo::Geographic.spherical_factory.point(centroid_lat, centroid_lng)
+        factory.point(centroid_lat, centroid_lng)
       end
     end
   end