rgeo 2.3.0 → 3.0.0.pre.rc.1

data/lib/rgeo/cartesian/factory.rb

@@ -42,7 +42,6 @@ module RGeo
         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
 
@@ -103,7 +102,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 +129,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 +141,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 +176,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 +194,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

@@ -9,76 +9,96 @@
 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,12 @@ module RGeo
       def envelope
         BoundingBox.new(factory).add(self).to_geometry
       end
+
+      private
+
+      def graph
+        @graph ||= GeometryGraph.new(self)
+      end
     end
 
     module PointMethods # :nodoc:
@@ -49,32 +55,62 @@ module RGeo
         end
       end
 
+      def simple?
+        # 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?
-        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
+        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
         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

@@ -78,12 +78,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>:wkt_parser</tt>]
       #   Configure the parser for WKT. The value is a hash of
       #   configuration parameters for WKRep::WKTParser.new. Default is

data/lib/rgeo/cartesian/planar_graph.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+module RGeo
+  module Cartesian
+    # A Doubly Connected Edge List (DCEL) implementation of a Planar Graph.
+    # It represents geometries as vertices and half-edges.
+    #
+    # It includes an incident_edges hash that maps vertices to an array
+    # of half-edges whose origins are that vertex.
+    #
+    # Upon instantiation, the graph will compute the intersections using
+    # the SweeplineIntersector, populate the incident_edges map, and
+    # link all cyclic edges.
+    class PlanarGraph
+      # HalfEdge represents an edge as 2 directed edges.
+      # One half-edge will have it's origin at edge.s, the other
+      # at edge.e. Both half-edges will be linked as each other's twins.
+      #
+      # HalfEdges also contain references to the next and prev half-edges,
+      # where next's origin is this half-edges destination. Prev's destination
+      # is this half-edge's origin.
+      class HalfEdge
+        include Comparable
+
+        # Creates 2 half edges from an edge.
+        # They will be assigned as each other's twins.
+        # The Half Edges will be returned in the order of points
+        # of the edge (start, end).
+        #
+        # @param edge [RGeo::Cartesian::Segment]
+        #
+        # @return [Array]
+        def self.from_edge(edge)
+          e1 = new(edge.s)
+          e2 = new(edge.e)
+
+          e1.twin = e2
+          e2.twin = e1
+          [e1, e2]
+        end
+
+        def initialize(origin)
+          @origin = origin
+          @twin = nil
+          @next = nil
+          @prev = nil
+        end
+        attr_reader :origin
+        attr_accessor :twin, :next, :prev
+
+        # HalfEdges will be sorted around their shared vertex
+        # in a CW fashion. This means that face interiors will be
+        # a CCW.
+        def <=>(other)
+          angle <=> other.angle
+        end
+
+        # Will find attempt to find a cycle starting at this
+        # HalfEdge. Will end upon finding the first repeated HalfEdge
+        # or a HalfEdge where +next+ is nil.
+        #
+        # If a block is given, each HalfEdge seen will be yielded to the block.
+        #
+        # @return [Enumerator]
+        def and_connected
+          return to_enum(__method__) unless block_given?
+
+          hedges = Set.new
+          yield(self)
+          hedges << self
+
+          n = self.next
+          until hedges.include?(n) || n.nil?
+            yield(n)
+            hedges << n
+            n = n.next
+          end
+        end
+
+        # Return the destination of the half edge
+        #
+        # @return [RGeo::Feature::Point]
+        def destination
+          twin&.origin
+        end
+
+        # Compute the angle from the positive x-axis.
+        # Used for sorting at each node.
+        #
+        # @return [Float]
+        def angle
+          @angle ||= Math.atan2(destination.y - origin.y, destination.x - origin.x)
+        end
+
+        def inspect
+          "#<#{self.class}:0x#{object_id.to_s(16)} #{self}>"
+        end
+
+        def to_s
+          dst = destination
+          pr = prev&.origin
+          n = @next&.origin
+          "HalfEdge(#{origin}, #{dst}), Prev: #{pr},  Next: #{n}"
+        end
+      end
+
+      # Create a new PlanarGraph
+      #
+      # @param edges [Array<RGeo::Cartesian::Segment>] of Segments
+      def initialize(edges = [])
+        @edges = []
+        @incident_edges = {}
+
+        add_edges(edges)
+      end
+      attr_reader :edges, :incident_edges
+
+      # Insert an edge into the graph. This will automatically
+      # calculate intersections and add new vertices if necessary.
+      #
+      # @param edge [RGeo::Cartesian::Segment]
+      def add_edge(edge)
+        @edges << edge
+        create_half_edge(edge)
+
+        # Check if a new intersection was made and handle it.
+        intersection_map.each do |seg, ints|
+          compute_split_edges(seg, ints)
+        end
+
+        link_half_edges
+      end
+
+      # Insert multiple edges into the graph. Like +add_edge+, this automatically
+      # calculates intersections and adds new vertices.
+      #
+      # @param new_edges [Array<RGeo::Cartesian::Segment>]
+      def add_edges(new_edges)
+        @edges.concat(new_edges)
+        new_edges.each do |edge|
+          create_half_edge(edge)
+        end
+
+        intersection_map.each do |seg, ints|
+          compute_split_edges(seg, ints)
+        end
+
+        link_half_edges
+      end
+
+      private
+
+      # Creates a map of +proper_intersections+ for each segment
+      # from a sweepline intersector.
+      #
+      # Can be used to determine which edges need to be split
+      # after adding edges.
+      def intersection_map
+        intersector = SweeplineIntersector.new(edges)
+        intersections = intersector.proper_intersections
+
+        intersection_map = {}
+        intersections.each do |int|
+          # check the int_point against each edge.
+          # if it is not on the boundary of the edge, add it to the
+          # list of intersections for that edge.
+          s1_intersects = int.point != int.s1.s && int.point != int.s1.e
+          if s1_intersects
+            unless intersection_map[int.s1]
+              intersection_map[int.s1] = []
+            end
+            intersection_map[int.s1] << int.point
+          end
+
+          s2_intersects = int.point != int.s2.s && int.point != int.s2.e
+          next unless s2_intersects
+          unless intersection_map[int.s2]
+            intersection_map[int.s2] = []
+          end
+          intersection_map[int.s2] << int.point
+        end
+        intersection_map
+      end
+
+      def create_half_edges
+        @edges.each do |edge|
+          create_half_edge(edge)
+        end
+      end
+
+      def create_half_edge(edge)
+        e1, e2 = HalfEdge.from_edge(edge)
+        insert_half_edge(e1)
+        insert_half_edge(e2)
+      end
+
+      def insert_half_edge(he)
+        unless incident_edges[he.origin.coordinates]
+          @incident_edges[he.origin.coordinates] = []
+        end
+        @incident_edges[he.origin.coordinates] << he
+      end
+
+      # Links all half-edges where possible.
+      # Defines +next+ and +prev+ for every half-edge by rotating
+      # through all half-edges originating at a vertex.
+      #
+      # Assuming half-edges are sorted CCW, every sequential pair of
+      # half-edges (e1, e2) can be linked by saying e1.prev = e2.twin
+      # and e2.twin.next = e1.
+      def link_half_edges
+        incident_edges.each_value do |hedges|
+          hedges.sort!
+          [*hedges, hedges.first].each_cons(2) do |e1, e2|
+            e1.prev = e2.twin
+            e2.twin.next = e1
+          end
+        end
+      end
+
+      # It is possible that intersections occur when new edges are added.
+      # This will split those edges into more half-edges while preserving
+      # the existing half-edges when possible since geometries may reference
+      # them.
+      def compute_split_edges(seg, ints)
+        points = ints.uniq.sort do |a, b|
+          a.distance(seg.s) <=> b.distance(seg.s)
+        end
+        points = [seg.s] + points + [seg.e]
+
+        he_start = incident_edges[points.first.coordinates].find { |he| he.destination == points.last }
+        he_end = incident_edges[points.last.coordinates].find { |he| he.destination == points.first }
+
+        points.each_cons(2) do |s, e|
+          edge = Segment.new(s, e)
+          if s == he_start.origin
+            he = HalfEdge.new(e)
+            he_start.twin = he
+            he.twin = he_start
+            insert_half_edge(he)
+          elsif e == he_end.origin
+            he = HalfEdge.new(s)
+            he_end.twin = he
+            he.twin = he_end
+            insert_half_edge(he)
+          else
+            create_half_edge(edge)
+          end
+          @edges << edge
+        end
+        @edges.delete(seg)
+      end
+    end
+
+    # GeometryGraph is a PlanarGraph that is built by adding
+    # geometries instead of edges. The GeometryGraph will
+    # hold a reference to an arbitrary HalfEdge on the
+    # interior of the geometry for every boundary in the geometry.
+    # For example, a polygon will have a reference to a HalfEdge for its
+    # exterior shell and one for every hole.
+    class GeometryGraph < PlanarGraph
+      # GeomEdge will be used to store the references to the HalfEdges
+      GeomEdge = Struct.new(:exterior_edge, :interior_edges)
+
+      def initialize(geom)
+        super()
+        @parent_geometry = geom
+        @geom_edges = []
+        add_geometry(geom)
+      end
+      attr_reader :parent_geometry, :geom_edges
+
+      private
+
+      # Adds a geometry to the graph and finds its
+      # reference HalfEdge(s).
+      #
+      # @param geom [RGeo::Feature::Instance]
+      def add_geometry(geom)
+        case geom
+        when Feature::Point
+          # Can't handle points yet, so just add an empty entry for them
+          @geom_edges << GeomEdge.new
+        when Feature::LineString, Feature::LinearRing
+          add_line_string(geom)
+        when Feature::Polygon
+          add_polygon(geom)
+        when Feature::GeometryCollection
+          add_collection(geom)
+        else
+          raise Error::RGeoError, "Invalid Geometry Type: #{geom.class}"
+        end
+      end
+
+      # Adds a LineString or LinearRing
+      # to the graph.
+      #
+      # @param geom [RGeo::Feature::LineString]
+      def add_line_string(geom)
+        add_edges(geom.segments)
+
+        hedge = unless geom.empty?
+                  @incident_edges[geom.start_point.coordinates].first
+                end
+
+        @geom_edges << GeomEdge.new(hedge, nil)
+      end
+
+      # Adds a Polygon to the graph.
+      #
+      # Will add each shell seperately and find a CCW half-edge
+      # for the exterior ring and a CW half-edge for interior rings
+      # since these are designated as being on the interior of the polygon.
+      #
+      # It is possible that the half-edge will be nil if a suitable one cannot
+      # be found. This indicates the polygon is likely invalid.
+      #
+      # @param geom [RGeo::Feature::Polygon]
+      def add_polygon(geom)
+        exterior = geom.exterior_ring
+        add_edges(exterior.segments)
+
+        hedge = find_hedge(exterior)
+
+        interior_hedges = []
+        geom.interior_rings.each do |interior|
+          add_edges(interior.segments)
+          interior_hedges << find_hedge(interior, ccw: false)
+        end
+
+        @geom_edges << GeomEdge.new(hedge, interior_hedges)
+      end
+
+      # Adds a GeometryCollection to the graph.
+      #
+      # @param col [RGeo::Feature::GeometryCollection]
+      def add_collection(col)
+        col.each do |geom|
+          add_geometry(geom)
+        end
+      end
+
+      # Finds a Half-Edge that is part of a CCW or CW rotation
+      # from the input ring. Returns nil if none found.
+      #
+      # Will only consider half-edges that are colinear with
+      # the first or last segments of the ring.
+      #
+      # @param ring [RGeo::Feature::LinearRing]
+      # @param ccw [Boolean] true for CCW, false for CW
+      # @return [HalfEdge, nil]
+      def find_hedge(ring, ccw: true)
+        return nil if ring.num_points.zero?
+        ccw_target = ccw ? 1 : -1
+
+        coords = ring.start_point.coordinates
+        hedges = incident_edges[coords]
+
+        # find half-edges that are colinear to the start or end
+        # segment of the ring.
+        start_seg = Segment.new(ring.start_point, ring.point_n(1))
+        end_seg = Segment.new(ring.point_n(ring.num_points - 2), ring.end_point)
+        colinear_hedges = hedges.select do |he|
+          start_seg.side(he.destination).zero? || end_seg.side(he.destination).zero?
+        end
+
+        colinear_hedges.find do |hedge|
+          pts = []
+          hedge.and_connected do |he|
+            pts << he.origin
+          end
+          pts << hedge.origin
+          lr = parent_geometry.factory.line_string(pts)
+          Analysis.ring_direction(lr) == ccw_target
+        end
+      end
+    end
+  end
+end