rgeo 2.3.1 → 3.0.1

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -16,15 +16,19 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        # LineStrings in general need to check that there's not one point
+        # GEOS doesn't allow instantiation of single point LineStrings so
+        # we should handle it.
+        raise Error::InvalidGeometry, "LineString Cannot Have 1 Point" if @points.size == 1
+        init_geometry
       end
 
       def num_points
         @points.size
       end
 
-      def point_n(n)
-        n < 0 ? nil : @points[n]
+      def point_n(idx)
+        idx < 0 ? nil : @points[idx]
       end
 
       def points
@@ -43,11 +47,6 @@ module RGeo
         @points.size == 0
       end
 
-      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 boundary
         array = []
         array << @points.first << @points.last if !empty? && !closed?
@@ -63,26 +62,15 @@ module RGeo
       end
 
       def closed?
-        unless defined?(@closed)
-          @closed = @points.size > 2 && @points.first == @points.last
-        end
-        @closed
-      end
+        return @closed if defined?(@closed)
 
-      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?
+        @closed = @points.size > 2 && @points.first == @points.last
       end
 
       def ring?
         closed? && simple?
       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)
         if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @points.size == rhs.num_points
           rhs.points.each_with_index { |p, i| return false unless @points[i].rep_equals?(p) }
@@ -92,10 +80,7 @@ module RGeo
       end
 
       def hash
-        @hash ||= begin
-          hash = [factory, geometry_type].hash
-          @points.inject(hash) { |h, p| (1_664_525 * h + p.hash).hash }
-        end
+        @hash ||= [factory, geometry_type, *@points].hash
       end
 
       def coordinates
@@ -123,15 +108,15 @@ module RGeo
       def point_intersect_segment?(point, start_point, end_point)
         return false unless point_collinear?(point, start_point, end_point)
 
-        if start_point.x != end_point.x
-          between_coordinate?(point.x, start_point.x, end_point.x)
-        else
+        if start_point.x == end_point.x
           between_coordinate?(point.y, start_point.y, end_point.y)
+        else
+          between_coordinate?(point.x, start_point.x, end_point.x)
         end
       end
 
-      def point_collinear?(a, b, c)
-        (b.x - a.x) * (c.y - a.y) == (c.x - a.x) * (b.y - a.y)
+      def point_collinear?(pt1, pt2, pt3)
+        (pt2.x - pt1.x) * (pt3.y - pt1.y) == (pt3.x - pt1.x) * (pt2.y - pt1.y)
       end
 
       def between_coordinate?(coord, start_coord, end_coord)
@@ -143,25 +128,17 @@ module RGeo
         super
         @points = obj.points
       end
-
-      def validate_geometry
-        if @points.size == 1
-          raise Error::InvalidGeometry, "LineString cannot have 1 point"
-        end
-      end
     end
 
     module BasicLineMethods # :nodoc:
       def initialize(factory, start, stop)
         self.factory = factory
         cstart = Feature.cast(start, factory, Feature::Point)
-        unless cstart
-          raise Error::InvalidGeometry, "Could not cast start: #{start}"
-        end
+        raise Error::InvalidGeometry, "Could not cast start: #{start}" unless cstart
         cstop = Feature.cast(stop, factory, Feature::Point)
         raise Error::InvalidGeometry, "Could not cast end: #{stop}" unless cstop
         @points = [cstart, cstop]
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type
@@ -171,18 +148,14 @@ module RGeo
       def coordinates
         @points.map(&:coordinates)
       end
+    end
 
-      private
-
-      def validate_geometry
+    module BasicLinearRingMethods # :nodoc:
+      def initialize(factory, points)
         super
-        if @points.size > 2
-          raise Error::InvalidGeometry, "Line must have 0 or 2 points"
-        end
+        raise Error::InvalidGeometry, "LinearRings must have 0 or >= 4 points" if @points.size.between?(1, 3)
       end
-    end
 
-    module BasicLinearRingMethods # :nodoc:
       def geometry_type
         Feature::LinearRing
       end
@@ -193,15 +166,14 @@ module RGeo
 
       private
 
-      def validate_geometry
+      # Close ring if necessary.
+      def init_geometry
         super
-        if @points.size > 0
-          @points << @points.first if @points.first != @points.last
-          @points = @points.chunk { |x| x }.map(&:first)
-          if !@factory.property(:uses_lenient_assertions) && !ring?
-            raise Error::InvalidGeometry, "LinearRing failed ring test"
-          end
-        end
+
+        return if @points.empty?
+
+        @points << @points.first if @points.first != @points.last
+        @points = @points.chunk { |x| x }.map(&:first)
       end
     end
   end

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -15,10 +15,8 @@ module RGeo
         @y = y.to_f
         @z = factory.property(:has_z_coordinate) ? extra.shift.to_f : nil
         @m = factory.property(:has_m_coordinate) ? extra.shift.to_f : nil
-        if extra.size > 0
-          raise ArgumentError, "Too many arguments for point initializer"
-        end
-        validate_geometry
+        raise ArgumentError, "Too many arguments for point initializer" unless extra.empty?
+        init_geometry
       end
 
       def x
@@ -49,20 +47,10 @@ module RGeo
         false
       end
 
-      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?
         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 envelope
         self
       end

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -12,17 +12,13 @@ module RGeo
       def initialize(factory, exterior_ring, interior_rings)
         self.factory = factory
         @exterior_ring = Feature.cast(exterior_ring, factory, Feature::LinearRing)
-        unless @exterior_ring
-          raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring}"
-        end
+        raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring}" unless @exterior_ring
         @interior_rings = (interior_rings || []).map do |elem|
           elem = Feature.cast(elem, factory, Feature::LinearRing)
-          unless elem
-            raise Error::InvalidGeometry, "Could not cast interior ring #{elem}"
-          end
+          raise Error::InvalidGeometry, "Could not cast interior ring #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def exterior_ring
@@ -33,8 +29,8 @@ module RGeo
         @interior_rings.size
       end
 
-      def interior_ring_n(n)
-        n < 0 ? nil : @interior_rings[n]
+      def interior_ring_n(idx)
+        idx < 0 ? nil : @interior_rings[idx]
       end
 
       def interior_rings
@@ -53,11 +49,6 @@ module RGeo
         @exterior_ring.empty?
       end
 
-      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 boundary
         array = []
         array << @exterior_ring unless @exterior_ring.empty?
@@ -66,18 +57,18 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @exterior_ring.rep_equals?(rhs.exterior_ring) && @interior_rings.size == rhs.num_interior_rings
-          rhs.interior_rings.each_with_index { |r, i| return false unless @interior_rings[i].rep_equals?(r) }
-        else
-          false
-        end
+        proper_match = rhs.is_a?(self.class) &&
+          rhs.factory.eql?(@factory) &&
+          @exterior_ring.rep_equals?(rhs.exterior_ring) &&
+          @interior_rings.size == rhs.num_interior_rings
+
+        return false unless proper_match
+
+        rhs.interior_rings.each_with_index { |r, i| return false unless @interior_rings[i].rep_equals?(r) }
       end
 
       def hash
-        @hash ||= begin
-          hash = [geometry_type, @exterior_ring].hash
-          @interior_rings.inject(hash) { |h, r| (1_664_525 * h + r.hash).hash }
-        end
+        @hash ||= [geometry_type, @exterior_ring, *@interior_rings].hash
       end
 
       def coordinates
@@ -88,7 +79,8 @@ module RGeo
         if Feature::Point === rhs
           contains_point?(rhs)
         else
-          raise(Error::UnsupportedOperation,
+          raise(
+            Error::UnsupportedOperation,
             "Method Polygon#contains? is only defined for Point"
           )
         end
@@ -98,7 +90,7 @@ module RGeo
 
       def contains_point?(point)
         ring_encloses_point?(@exterior_ring, point) &&
-          !@interior_rings.any? do |exclusion|
+          @interior_rings.none? do |exclusion|
             ring_encloses_point?(exclusion, point, on_border_return: true)
           end
       end
@@ -122,7 +114,6 @@ module RGeo
         encloses_point
       end
 
-
       def copy_state_from(obj)
         super
         @exterior_ring = obj.exterior_ring

data/lib/rgeo/impl_helper/utils.rb

@@ -9,6 +9,27 @@
 module RGeo
   module ImplHelper # :nodoc:
     module Utils # :nodoc:
+      # Helper function to create coord_sys from
+      # common options in most factories. Returns
+      # a hash with finalized coord sys info after processing.
+      #
+      # The reason we return the data as a hash instead of assigning
+      # instance variables is because some classes need to do this
+      # multiple times with different values and others pass the data
+      # to a CAPI or FFI.
+      def self.setup_coord_sys(srid, coord_sys, coord_sys_class)
+        coord_sys_class = CoordSys::CONFIG.default_coord_sys_class unless coord_sys_class.is_a?(Class)
+
+        coord_sys = coord_sys_class.create_from_wkt(coord_sys) if coord_sys.is_a?(String)
+
+        srid ||= coord_sys.authority_code if coord_sys
+        srid = srid.to_i
+        # Create a coord sys based on the SRID if one was not given
+        coord_sys = coord_sys_class.create(srid) if coord_sys.nil? && srid != 0
+
+        { coord_sys: coord_sys, srid: srid }
+      end
+
       private
 
       def symbolize_hash(hash)

data/lib/rgeo/impl_helper/valid_op.rb

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RGeo
+  module ImplHelper
+    # Mixin based off of the JTS/GEOS IsValidOp class.
+    # Implements #valid? and #invalid_reason on Features that include this.
+    #
+    # @see https://github.com/locationtech/jts/blob/master/modules/core/src/main/java/org/locationtech/jts/operation/valid/IsValidOp.java
+    module ValidOp
+      # Validity of geometry
+      #
+      # @return Boolean
+      def valid?
+        invalid_reason.nil?
+      end
+
+      # Reason for invalidity or nil if valid
+      #
+      # @return String
+      def invalid_reason
+        return @invalid_reason if defined?(@invalid_reason)
+        @invalid_reason = check_valid
+      end
+
+      private
+
+      def validity_helper
+        ValidOpHelpers
+      end
+
+      # Method that performs validity checking. Just checks the type of geometry
+      # and delegates to the proper validity checker.
+      #
+      # Returns a string describing the error or nil if it's a valid geometry.
+      # In some cases, "Unkown Validity" is returned if a dependent method has
+      # not been implemented.
+      #
+      # @return String
+      def check_valid
+        case self
+        when Feature::Point
+          check_valid_point
+        when Feature::LinearRing
+          check_valid_linear_ring
+        when Feature::LineString
+          check_valid_line_string
+        when Feature::Polygon
+          check_valid_polygon
+        when Feature::MultiPoint
+          check_valid_multi_point
+        when Feature::MultiPolygon
+          check_valid_multi_polygon
+        when Feature::GeometryCollection
+          check_valid_geometry_collection
+        else
+          raise NotImplementedError, "check_valid is not implemented for #{self}"
+        end
+      rescue RGeo::Error::UnsupportedOperation, NoMethodError
+        "Unkown Validity"
+      end
+
+      def check_valid_point
+        validity_helper.check_invalid_coordinate(self)
+      end
+
+      def check_valid_line_string
+        # check coordinates are all valid
+        points.each do |pt|
+          check = validity_helper.check_invalid_coordinate(pt)
+          return check unless check.nil?
+        end
+
+        # check more than 1 point
+        return Error::TOO_FEW_POINTS unless num_points > 1
+
+        nil
+      end
+
+      def check_valid_linear_ring
+        # check coordinates are all valid
+        points.each do |pt|
+          check = validity_helper.check_invalid_coordinate(pt)
+          return check unless check.nil?
+        end
+
+        # check closed
+        return Error::UNCLOSED_RING unless closed?
+
+        # check more than 3 points
+        return Error::TOO_FEW_POINTS unless num_points > 3
+
+        # check no self-intersections
+        validity_helper.check_no_self_intersections(self)
+      end
+
+      def check_valid_polygon
+        # check coordinates are all valid
+        exterior_ring.points.each do |pt|
+          check = validity_helper.check_invalid_coordinate(pt)
+          return check unless check.nil?
+        end
+        interior_rings.each do |ring|
+          ring.points.each do |pt|
+            check = validity_helper.check_invalid_coordinate(pt)
+            return check unless check.nil?
+          end
+        end
+
+        # check closed
+        return Error::UNCLOSED_RING unless exterior_ring.closed?
+        return Error::UNCLOSED_RING unless interior_rings.all?(&:closed?)
+
+        # check more than 3 points in each ring
+        return Error::TOO_FEW_POINTS unless exterior_ring.num_points > 3
+        return Error::TOO_FEW_POINTS unless interior_rings.all? { |r| r.num_points > 3 }
+
+        # can skip this check if there's no holes
+        unless interior_rings.empty?
+          check = validity_helper.check_consistent_area(self)
+          return check unless check.nil?
+        end
+
+        # check that there are no self-intersections
+        check = validity_helper.check_no_self_intersecting_rings(self)
+        return check unless check.nil?
+
+        # can skip these checks if there's no holes
+        unless interior_rings.empty?
+          check = validity_helper.check_holes_in_shell(self)
+          return check unless check.nil?
+
+          check = validity_helper.check_holes_not_nested(self)
+          return check unless check.nil?
+
+          check = validity_helper.check_connected_interiors(self)
+          return check unless check.nil?
+        end
+
+        nil
+      end
+
+      def check_valid_multi_point
+        geometries.each do |pt|
+          check = validity_helper.check_invalid_coordinate(pt)
+          return check unless check.nil?
+        end
+        nil
+      end
+
+      def check_valid_multi_polygon
+        geometries.each do |poly|
+          return poly.invalid_reason unless poly.invalid_reason.nil?
+        end
+
+        check = validity_helper.check_consistent_area_mp(self)
+        return check unless check.nil?
+
+        # check no shells are nested
+        check = validity_helper.check_shells_not_nested(self)
+        return check unless check.nil?
+
+        nil
+      end
+
+      def check_valid_geometry_collection
+        geometries.each do |geom|
+          return geom.invalid_reason unless geom.invalid_reason.nil?
+        end
+
+        nil
+      end
+    end
+
+    ##
+    # Helper functions for specific validity checks
+    ##
+    module ValidOpHelpers
+      module_function
+
+      # Checks that the given point has valid coordinates.
+      #
+      # @param point [RGeo::Feature::Point]
+      #
+      # @return [String] invalid_reason
+      def check_invalid_coordinate(point)
+        x = point.x
+        y = point.y
+        return if x.finite? && y.finite? && x.real? && y.real?
+
+        Error::INVALID_COORDINATE
+      end
+
+      # Checks that the edges in the polygon form a consistent area.
+      #
+      # Specifically, checks that there are intersections no between the
+      # holes and the shell.
+      #
+      # Also checks that there are no duplicate rings.
+      #
+      # @param poly [RGeo::Feature::Polygon]
+      #
+      # @return [String] invalid_reason
+      def check_consistent_area(poly)
+        # Holes don't cross exterior check.
+        exterior = poly.exterior_ring
+        poly.interior_rings.each do |ring|
+          return Error::SELF_INTERSECTION if ring.crosses?(exterior)
+        end
+
+        # check interiors do not cross
+        poly.interior_rings.combination(2).each do |ring1, ring2|
+          return Error::SELF_INTERSECTION if ring1.crosses?(ring2)
+        end
+
+        # Duplicate rings check
+        rings = [exterior] + poly.interior_rings
+        return Error::SELF_INTERSECTION if rings.uniq.size != rings.size
+
+        nil
+      end
+
+      # Checks that the ring does not self-intersect. This is just a simplicity
+      # check on the ring.
+      #
+      # @param ring [RGeo::Feature::LinearRing]
+      #
+      # @return [String] invalid_reason
+      def check_no_self_intersections(ring)
+        return Error::SELF_INTERSECTION unless ring.simple?
+      end
+
+      # Check that rings do not self intersect in a polygon
+      #
+      # @param poly [RGeo::Feature::Polygon]
+      #
+      # @return [String] invalid_reason
+      def check_no_self_intersecting_rings(poly)
+        exterior = poly.exterior_ring
+
+        check = check_no_self_intersections(exterior)
+        return check unless check.nil?
+
+        poly.interior_rings.each do |ring|
+          check = check_no_self_intersections(ring)
+          return check unless check.nil?
+        end
+
+        nil
+      end
+
+      # Checks holes are contained inside the exterior of a polygon.
+      # Assuming check_consistent_area has already passed on the polygon,
+      # a simple point in polygon check can be done on one of the points
+      # in each hole to verify (since we know none of them intersect).
+      #
+      # @param poly [RGeo::Feature::Polygon]
+      #
+      # @return [String] invalid_reason
+      def check_holes_in_shell(poly)
+        # get hole-less shell as test polygon
+        shell = poly.exterior_ring
+        shell = shell.factory.polygon(shell)
+
+        poly.interior_rings.each do |interior|
+          test_pt = interior.start_point
+          return Error::HOLE_OUTSIDE_SHELL unless shell.contains?(test_pt) || poly.exterior_ring.contains?(test_pt)
+        end
+
+        nil
+      end
+
+      # Checks that holes are not nested within each other.
+      #
+      # @param poly [RGeo::Feature::Polygon]
+      #
+      # @return [String] invalid_reason
+      def check_holes_not_nested(poly)
+        # convert holes from linear_rings to polygons
+        # Same logic that applies to check_holes_in_shell applies here
+        # since we've already passed the consistent area test, we just
+        # have to check if one point from each hole is contained in the other.
+        holes = poly.interior_rings
+        holes = holes.map { |v| v.factory.polygon(v) }
+        holes.combination(2).each do |p1, p2|
+          if p1.contains?(p2.exterior_ring.start_point) || p2.contains?(p1.exterior_ring.start_point)
+            return Error::NESTED_HOLES
+          end
+        end
+
+        nil
+      end
+
+      # Checks that the interior of the polygon is connected.
+      # A disconnected interior can be described by this polygon for example
+      # POLYGON((0 0, 10 0, 10 10, 0 10, 0 0), (5 0, 10 5, 5 10, 0 5, 5 0))
+      #
+      # Which is a square with a diamond inside of it.
+      #
+      # @param poly [RGeo::Feature::Polygon]
+      #
+      # @return [String] invalid_reason
+      def check_connected_interiors(poly)
+        # This is not proper and will flag valid geometries as invalid, but
+        # is an ok approximation.
+        # Idea is to check if a single hole has multiple points on the
+        # exterior ring.
+        poly.interior_rings.each do |ring|
+          touches = Set.new
+          ring.points.each do |pt|
+            touches.add(pt) if poly.exterior_ring.contains?(pt)
+          end
+
+          return Error::DISCONNECTED_INTERIOR if touches.size > 1
+        end
+
+        nil
+      end
+
+      # Checks that polygons do not intersect in a multipolygon.
+      #
+      # @param mpoly [RGeo::Feature::MultiPolygon]
+      #
+      # @return [String] invalid_reason
+      def check_consistent_area_mp(mpoly)
+        mpoly.geometries.combination(2) do |p1, p2|
+          return Error::SELF_INTERSECTION if p1.exterior_ring.crosses?(p2.exterior_ring)
+        end
+        nil
+      end
+
+      # Checks that individual polygons within a multipolygon are not nested.
+      #
+      # @param mpoly [RGeo::Feature::MultiPolygon]
+      #
+      # @return [String] invalid_reason
+      def check_shells_not_nested(mpoly)
+        # Since we've passed the consistent area test, we can just check
+        # that one point lies in the other.
+        mpoly.geometries.combination(2) do |p1, p2|
+          if p1.contains?(p2.exterior_ring.start_point) || p2.contains?(p1.exterior_ring.start_point)
+            return Error::NESTED_SHELLS
+          end
+        end
+        nil
+      end
+    end
+  end
+end