rgeo 2.4.0 → 3.0.0.pre.rc.1

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -19,7 +19,7 @@ module RGeo
       end
 
       def envelope
-        factory.unproject(projection.envelope)
+        factory.unproject(projection.unsafe_envelope)
       end
 
       def empty?
@@ -40,8 +40,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 +63,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 +167,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 +177,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 +222,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

@@ -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
@@ -128,6 +129,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:

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,9 +6,11 @@
 #
 # -----------------------------------------------------------------------------
 
+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
@@ -83,21 +85,29 @@ module RGeo
       include Enumerable
     end
 
-    class CAPIGeometryImpl # :nodoc:
+    class CAPIGeometryImpl
+      include Feature::Geometry
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
     end
 
-    class CAPIPointImpl # :nodoc:
+    class CAPIPointImpl
+      include Feature::Point
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIPointMethods
     end
 
-    class CAPILineStringImpl  # :nodoc:
+    class CAPILineStringImpl
+      include Feature::LineString
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
     end
 
-    class CAPILinearRingImpl  # :nodoc:
+    class CAPILinearRingImpl
+      include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILinearRingMethods
@@ -107,38 +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