rgeo 2.3.1 → 3.0.0.pre.rc.2

data/lib/rgeo/cartesian/calculations.rb

@@ -69,41 +69,78 @@ module RGeo
       end
 
       def intersects_segment?(seg)
+        !segment_intersection(seg).nil?
+      end
+
+      # If this and the other segment intersect, this method will return the coordinate
+      # at which they intersect, otherwise nil.
+      # In the case of a partial overlap (parallel segments), this will return
+      # a single point on the overlapping portion.
+      #
+      # @param seg [Segment]
+      #
+      # @return [RGeo::Feature::Point, nil]
+      def segment_intersection(seg)
         s2 = seg.s
         # Handle degenerate cases
         if seg.degenerate?
-          if @lensq == 0
-            return @s == s2
+          if @lensq == 0 && @s == s2
+            return @s
           else
-            return contains_point?(s2)
+            return contains_point?(s2) ? s2 : nil
           end
         elsif @lensq == 0
-          return seg.contains_point?(@s)
+          return seg.contains_point?(@s) ? @s : nil
         end
+
         # Both segments have nonzero length.
         sx2 = s2.x
         sy2 = s2.y
         dx2 = seg.dx
         dy2 = seg.dy
         denom = @dx * dy2 - @dy * dx2
+
         if denom == 0
           # Segments are parallel. Make sure they are collinear.
-          return false unless side(s2) == 0
-          # 1-D check.
-          ts = (@dx * (sx2 - @sx) + @dy * (sy2 - @sy)) / @lensq
-          te = (@dx * (sx2 + dx2 - @sx) + @dy * (sy2 + dy2 - @sy)) / @lensq
-          if ts < te
-            te >= 0.0 && ts <= 1.0
-          else
-            ts >= 0.0 && te <= 1.0
-          end
+          return nil unless side(s2) == 0
+
+          # return the first point it finds that intersects another line.
+          # In many cases, the intersection is actually another line
+          # segment, but for now, we will just return a single point.
+          return s2 if contains_point?(s2)
+          return seg.e if contains_point?(seg.e)
+          return @s if seg.contains_point?(@s)
+          return @e if seg.contains_point?(@e)
+          nil
         else
           # Segments are not parallel. Check the intersection of their
           # containing lines.
-          t = (dy2 * (sx2 - @sx) + dx2 * (@sy - sy2)) / denom
-          return false if t < 0.0 || t > 1.0
-          t2 = (@dy * (sx2 - @sx) + @dx * (@sy - sy2)) / denom
-          t2 >= 0.0 && t2 <= 1.0
+          num1 = dx2 * (@sy - sy2) - (dy2 * (@sx - sx2))
+          num2 = @dx * (@sy - sy2) - (@dy * (@sx - sx2))
+          cross1 = num1 / denom
+          cross2 = num2 / denom
+
+          return nil if cross1 < 0.0 || cross1 > 1.0
+          if cross2 >= 0.0 && cross2 <= 1.0
+            x = @sx + (cross1 * @dx)
+            y = @sy + (cross1 * @dy)
+
+            # Check if this segment contains the point.
+            # Sometimes round-off errors occur and intersections
+            # are recorded as off the line segments.
+            #
+            # If this is the case, return the closest point from
+            # either segment.
+            int_pt = @s.factory.point(x, y)
+            if contains_point?(int_pt)
+              int_pt
+            else
+              # find closest of @s, @e, seg.s, seg.e
+              [@e, seg.s, seg.e].reduce(@s) do |closest, pt|
+                int_pt.distance(pt) < int_pt.distance(closest) ? pt : closest
+              end
+            end
+          end
         end
       end
 

data/lib/rgeo/cartesian/factory.rb

@@ -22,6 +22,11 @@ module RGeo
       def initialize(opts = {})
         @has_z = opts[:has_z_coordinate] ? true : false
         @has_m = opts[:has_m_coordinate] ? true : false
+        @coordinate_dimension = 2
+        @coordinate_dimension += 1 if @has_z
+        @coordinate_dimension += 1 if @has_m
+        @spatial_dimension = @has_z ? 3 : 2
+
         @proj4 = opts[:proj4]
         if @proj4 && CoordSys.check!(:proj4)
           if @proj4.is_a?(String) || @proj4.is_a?(Hash)
@@ -33,16 +38,8 @@ module RGeo
         if @coord_sys.is_a?(String)
           @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
         end
-        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
         @srid = srid.to_i
-        @lenient_assertions = opts[:uses_lenient_assertions] ? true : false
         @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
 
@@ -75,6 +72,7 @@ module RGeo
           @wkb_parser = WKRep::WKBParser.new(self)
         end
       end
+      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Equivalence test.
 
@@ -103,7 +101,6 @@ module RGeo
           "wkbg" => @wkb_generator.properties,
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
-          "lena" => @lenient_assertions,
           "bufr" => @buffer_resolution
         }
         hash_["proj4"] = @proj4.marshal_dump if @proj4
@@ -131,7 +128,6 @@ module RGeo
           wkb_generator: symbolize_hash(data["wkbg"]),
           wkt_parser: symbolize_hash(data["wktp"]),
           wkb_parser: symbolize_hash(data["wkbp"]),
-          uses_lenient_assertions: data["lena"],
           buffer_resolution: data["bufr"],
           proj4: proj4,
           coord_sys: coord_sys
@@ -144,7 +140,6 @@ module RGeo
         coder["has_z_coordinate"] = @has_z
         coder["has_m_coordinate"] = @has_m
         coder["srid"] = @srid
-        coder["lenient_assertions"] = @lenient_assertions
         coder["buffer_resolution"] = @buffer_resolution
         coder["wkt_generator"] = @wkt_generator.properties
         coder["wkb_generator"] = @wkb_generator.properties
@@ -180,7 +175,6 @@ module RGeo
           wkb_generator: symbolize_hash(coder["wkb_generator"]),
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
-          uses_lenient_assertions: coder["lenient_assertions"],
           buffer_resolution: coder["buffer_resolution"],
           proj4: proj4,
           coord_sys: coord_sys
@@ -199,8 +193,6 @@ module RGeo
           @has_z
         when :has_m_coordinate
           @has_m
-        when :uses_lenient_assertions
-          @lenient_assertions
         when :buffer_resolution
           @buffer_resolution
         when :is_cartesian

data/lib/rgeo/cartesian/feature_classes.rb

@@ -6,79 +6,101 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Cartesian
     class PointImpl # :nodoc:
-      include RGeo::Feature::Point
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicPointMethods
-      include RGeo::Cartesian::GeometryMethods
-      include RGeo::Cartesian::PointMethods
+      include Feature::Point
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPointMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
+      include PointMethods
     end
 
     class LineStringImpl # :nodoc:
-      include RGeo::Feature::LineString
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicLineStringMethods
-      include RGeo::Cartesian::GeometryMethods
-      include RGeo::Cartesian::LineStringMethods
+      include Feature::LineString
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
+      include LineStringMethods
     end
 
     class LineImpl # :nodoc:
-      include RGeo::Feature::Line
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicLineStringMethods
-      include RGeo::ImplHelper::BasicLineMethods
-      include RGeo::Cartesian::GeometryMethods
-      include RGeo::Cartesian::LineStringMethods
+      include Feature::Line
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLineMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
+      include LineStringMethods
     end
 
     class LinearRingImpl # :nodoc:
-      include RGeo::Feature::LinearRing
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicLineStringMethods
-      include RGeo::ImplHelper::BasicLinearRingMethods
-      include RGeo::Cartesian::GeometryMethods
-      include RGeo::Cartesian::LineStringMethods
+      include Feature::LinearRing
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicLineStringMethods
+      include ImplHelper::BasicLinearRingMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
+      include LineStringMethods
     end
 
     class PolygonImpl # :nodoc:
-      include RGeo::Feature::Polygon
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicPolygonMethods
-      include RGeo::Cartesian::GeometryMethods
+      include Feature::Polygon
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicPolygonMethods
+      include ValidOp
+      include GeometryMethods
     end
 
     class GeometryCollectionImpl # :nodoc:
-      include RGeo::Feature::GeometryCollection
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicGeometryCollectionMethods
-      include RGeo::Cartesian::GeometryMethods
+      include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
     end
 
     class MultiPointImpl # :nodoc:
-      include RGeo::Feature::MultiPoint
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicGeometryCollectionMethods
-      include RGeo::ImplHelper::BasicMultiPointMethods
-      include RGeo::Cartesian::GeometryMethods
+      include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPointMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
     end
 
     class MultiLineStringImpl # :nodoc:
-      include RGeo::Feature::MultiLineString
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicGeometryCollectionMethods
-      include RGeo::ImplHelper::BasicMultiLineStringMethods
-      include RGeo::Cartesian::GeometryMethods
-      include RGeo::Cartesian::MultiLineStringMethods
+      include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiLineStringMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
+      include MultiLineStringMethods
     end
 
     class MultiPolygonImpl # :nodoc:
-      include RGeo::Feature::MultiPolygon
-      include RGeo::ImplHelper::BasicGeometryMethods
-      include RGeo::ImplHelper::BasicGeometryCollectionMethods
-      include RGeo::ImplHelper::BasicMultiPolygonMethods
-      include RGeo::Cartesian::GeometryMethods
+      include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
+      include ImplHelper::BasicGeometryMethods
+      include ImplHelper::BasicGeometryCollectionMethods
+      include ImplHelper::BasicMultiPolygonMethods
+      include ImplHelper::ValidOp
+      include GeometryMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/cartesian/feature_methods.rb

@@ -16,6 +16,28 @@ module RGeo
       def envelope
         BoundingBox.new(factory).add(self).to_geometry
       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
+
+      private
+
+      def graph
+        @graph ||= GeometryGraph.new(self)
+      end
     end
 
     module PointMethods # :nodoc:
@@ -50,26 +72,14 @@ module RGeo
       end
 
       def simple?
-        len = segments.length
-        return false if segments.any?(&:degenerate?)
-        return true if len == 1
-        return segments[0].s != segments[1].e if len == 2
-        segments.each_with_index do |seg, index|
-          nindex = index + 1
-          nindex = nil if nindex == len
-          return false if nindex && seg.contains_point?(segments[nindex].e)
-          pindex = index - 1
-          pindex = nil if pindex < 0
-          return false if pindex && seg.contains_point?(segments[pindex].s)
-          next unless nindex
-          oindex = nindex + 1
-          while oindex < len
-            oseg = segments[oindex]
-            return false if !(index == 0 && oindex == len - 1 && seg.s == oseg.e) && seg.intersects_segment?(oseg)
-            oindex += 1
-          end
-        end
-        true
+        # Use a SweeplineIntersector to determine if there are any self-intersections
+        # in the ring. The GeometryGraph of the ring could be used by comparing the
+        # edges to number of segments (graph.incident_edges.length == segments.length),
+        # but this adds computational and memory overhead if graph isn't already memoized.
+        # Since graph is not used elsewhere in LineStringMethods, we will just use the
+        # SweeplineIntersector for now.
+        li = SweeplineIntersector.new(segments)
+        li.proper_intersections.empty?
       end
 
       def is_simple?
@@ -80,6 +90,43 @@ module RGeo
       def length
         segments.inject(0.0) { |sum, seg| sum + seg.length }
       end
+
+      def crosses?(rhs)
+        case rhs
+        when Feature::LineString
+          crosses_line_string?(rhs)
+        else
+          super
+        end
+      end
+
+      private
+
+      # Determines if a cross occurs with another linestring.
+      # Process is to get the number of proper intersections in each geom
+      # then overlay and get the number of proper intersections from that.
+      # If the overlaid number is higher than the sum of individual self-ints
+      # then there is an intersection. Finally, we need to check the intersection
+      # to see that it is not a boundary point of either segment.
+      #
+      # @param rhs [Feature::LineString]
+      #
+      # @return [Boolean]
+      def crosses_line_string?(rhs)
+        self_ints = SweeplineIntersector.new(segments).proper_intersections
+        self_ints += SweeplineIntersector.new(rhs.segments).proper_intersections
+        overlay_ints = SweeplineIntersector.new(segments + rhs.segments).proper_intersections
+
+        (overlay_ints - self_ints).each do |int|
+          s1s = int.s1.s
+          s1e = int.s1.e
+          s2s = int.s2.s
+          s2e = int.s2.e
+          return true unless [s1s, s1e, s2s, s2e].include?(int.point)
+        end
+
+        false
+      end
     end
 
     module MultiLineStringMethods # :nodoc:

data/lib/rgeo/cartesian/interface.rb

@@ -69,21 +69,10 @@ module RGeo
       #   The coordinate system in OGC form, either as a subclass of
       #   CoordSys::CS::CoordinateSystem, or as a string in WKT format.
       #   Optional.
-      # [<tt>:srs_database</tt>]
-      #   Optional. If provided, the value should be an implementation of
-      #   CoordSys::SRSDatabase::Interface. If both this and an SRID are
-      #   provided, they are used to look up the proj4 and coord_sys
-      #   objects from a spatial reference system database.
       # [<tt>:has_z_coordinate</tt>]
       #   Support 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>:wkt_parser</tt>]
       #   Configure the parser for WKT. The value is a hash of
       #   configuration parameters for WKRep::WKTParser.new. Default is
@@ -107,31 +96,6 @@ module RGeo
       def simple_factory(opts = {})
         Cartesian::Factory.new(opts)
       end
-
-      # Returns a Feature::FactoryGenerator that creates preferred
-      # factories. The given options are used as the default options.
-      #
-      # A common case for this is to provide the <tt>:srs_database</tt>
-      # as a default. Then, the factory generator need only be passed
-      # an SRID and it will automatically fetch the appropriate Proj4
-      # and CoordSys objects.
-
-      def preferred_factory_generator(defaults = {})
-        proc { |c| preferred_factory(defaults.merge(c)) }
-      end
-      alias factory_generator preferred_factory_generator
-
-      # Returns a Feature::FactoryGenerator that creates simple factories.
-      # The given options are used as the default options.
-      #
-      # A common case for this is to provide the <tt>:srs_database</tt>
-      # as a default. Then, the factory generator need only be passed
-      # an SRID and it will automatically fetch the appropriate Proj4
-      # and CoordSys objects.
-
-      def simple_factory_generator(defaults = {})
-        proc { |c| simple_factory(defaults.merge(c)) }
-      end
     end
   end
 end