rgeo 2.3.1 → 3.0.0.pre.rc.2

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -45,6 +45,14 @@ module RGeo
         @zgeometry.dimension
       end
 
+      def coordinate_dimension
+        4
+      end
+
+      def spatial_dimension
+        3
+      end
+
       def geometry_type
         @zgeometry.geometry_type
       end
@@ -83,6 +91,14 @@ module RGeo
         simple?
       end
 
+      def is_3d?
+        true
+      end
+
+      def measured?
+        true
+      end
+
       def boundary
         @factory.create_feature(nil, @zgeometry.boundary, @mgeometry.boundary)
       end

data/lib/rgeo/geos.rb

@@ -33,9 +33,6 @@ module RGeo
       require_relative "geos/capi_feature_classes"
       require_relative "geos/capi_factory"
     end
-    require_relative "geos/ffi_feature_methods"
-    require_relative "geos/ffi_feature_classes"
-    require_relative "geos/ffi_factory"
     require_relative "geos/zm_feature_methods"
     require_relative "geos/zm_feature_classes"
     require_relative "geos/zm_factory"
@@ -56,6 +53,12 @@ module RGeo
       FFI_SUPPORT_EXCEPTION = ex
     end
 
+    if FFI_SUPPORTED
+      require_relative "geos/ffi_feature_methods"
+      require_relative "geos/ffi_feature_classes"
+      require_relative "geos/ffi_factory"
+    end
+
     # Default preferred native interface
     if CAPI_SUPPORTED
       self.preferred_native_interface = :capi

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -20,7 +20,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def num_geometries
@@ -91,7 +91,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type
@@ -152,7 +152,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type
@@ -176,7 +176,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -52,7 +52,7 @@ module RGeo
         @factory = obj.factory
       end
 
-      def validate_geometry
+      def init_geometry
       end
     end
   end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -16,7 +16,13 @@ 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.
+        if @points.size == 1
+          raise Error::InvalidGeometry, "LineString Cannot Have 1 Point"
+        end
+        init_geometry
       end
 
       def num_points
@@ -143,12 +149,6 @@ 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:
@@ -161,7 +161,7 @@ module RGeo
         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 +171,16 @@ 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"
+        unless @points.size >= 4 || @points.size == 0
+          raise Error::InvalidGeometry, "LinearRings must have 0 or >= 4 points"
         end
       end
-    end
 
-    module BasicLinearRingMethods # :nodoc:
       def geometry_type
         Feature::LinearRing
       end
@@ -193,14 +191,12 @@ 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
       end
     end

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -18,7 +18,7 @@ module RGeo
         if extra.size > 0
           raise ArgumentError, "Too many arguments for point initializer"
         end
-        validate_geometry
+        init_geometry
       end
 
       def x

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -22,7 +22,7 @@ module RGeo
           end
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def exterior_ring

data/lib/rgeo/impl_helper/valid_op.rb

@@ -0,0 +1,354 @@
+# 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 pt [RGeo::Feature::Point]
+      #
+      # @return [String] invalid_reason
+      def check_invalid_coordinate(pt)
+        x = pt.x
+        y = pt.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
+          unless shell.contains?(test_pt) || poly.exterior_ring.contains?(test_pt)
+            return Error::HOLE_OUTSIDE_SHELL
+          end
+        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 mp [RGeo::Feature::MultiPolygon]
+      #
+      # @return [String] invalid_reason
+      def check_consistent_area_mp(mp)
+        mp.geometries.combination(2) do |p1, p2|
+          if p1.exterior_ring.crosses?(p2.exterior_ring)
+            return Error::SELF_INTERSECTION
+          end
+        end
+        nil
+      end
+
+      # Checks that individual polygons within a multipolygon are not nested.
+      #
+      # @param mp [RGeo::Feature::MultiPolygon]
+      #
+      # @return [String] invalid_reason
+      def check_shells_not_nested(mp)
+        # Since we've passed the consistent area test, we can just check
+        # that one point lies in the other.
+        mp.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

data/lib/rgeo/impl_helper/validity_check.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RGeo
+  module ImplHelper
+    # This helper enforces valid geometry computation, avoiding results such
+    # as a 0 area for a bowtie shaped polygon. Implementations that are part
+    # of RGeo core should all include this.
+    #
+    # You can play around validity checks if needed:
+    #
+    # - {check_validity!} is the method that will raise if your geometry is
+    #   not valid. Its message will be the same as {invalid_reason}.
+    # - {make_valid} is the method you can call to get a valid copy of the
+    #   current geometry.
+    # - finally, you can bypass any checked method by prepending `unsafe_` to
+    #   it. At your own risk.
+    module ValidityCheck
+      # Every method that should not be overriden by the validity check.
+      # Those methods are either accessors or very basic methods not related
+      # to validity checks, or are used to check validity, in which case the
+      # `true/false` gives a correct information, no need to raise).
+      UNCHECKED_METHODS = [
+        # Basic methods
+        :factory, :geometry_type, :as_text, :as_binary, :srid,
+        :dimension, :coordinate_dimension, :spatial_dimension,
+        # Tests
+        :simple?, :closed?, :empty?, :is_3d?, :measured?,
+        # Accessors
+        :exterior_ring, :interior_rings, :[], :num_geometries, :num_interior_rings,
+        :geometry_n, :each, :points, :point_n, :start_point, :end_point, :x, :y, :z, :m,
+        # Trivial methods
+        :num_points, :locate_along, :locate_between,
+        # Comparison
+        :equals?, :rep_equals?, :eql?, :==, :'!='
+      ].freeze
+      private_constant :UNCHECKED_METHODS
+
+      # Since methods have their unsafe_ counter part, it means that the `+`
+      # method would lead to having an `unsafe_+` method that is not simply
+      # callable. Here's a simple fallback:
+      SYMBOL2NAME = {
+        :+ => "add",
+        :- => "remove",
+        :* => "multiply"
+      }.tap { |h| h.default_proc = ->(_, key) { key.to_s } }.freeze
+      private_constant :SYMBOL2NAME
+
+      class << self
+        # Note for contributors: this should be called after all methods
+        # are loaded for a given feature classe. No worries though, this
+        # is tested.
+        def override_classes # :nodoc:
+          # Using pop here to be thread safe.
+          while (klass = classes.pop)
+            override(klass)
+          end
+        end
+
+        def included(klass) # :nodoc:
+          classes << klass
+        end
+
+        private
+
+        def classes
+          @classes ||= []
+        end
+
+        def override(klass)
+          methods_to_check = feature_methods(klass)
+
+          klass.class_eval do
+            methods_to_check.each do |method_sym|
+              copy = "unsafe_#{SYMBOL2NAME[method_sym]}".to_sym
+              alias_method copy, method_sym
+              undef_method method_sym
+              define_method(method_sym) do |*args|
+                check_validity!
+                args.each do |arg|
+                  arg.check_validity! if RGeo::Feature::Geometry.check_type(arg)
+                end
+                method(copy).call(*args)
+              end
+            end
+          end
+        end
+
+        def feature_methods(klass)
+          feature_defs = Set.new
+          klass
+            .ancestors
+            .select { |ancestor| ancestor <= RGeo::Feature::Geometry }
+            .each { |ancestor| feature_defs.merge(ancestor.instance_methods(false)) }
+          feature_defs & klass.instance_methods - UNCHECKED_METHODS
+        end
+      end
+
+      # Raises {invalid_reason} if the polygon is not valid, does nothing
+      # otherwise.
+      def check_validity!
+        # This method will use a cached invalid_reason for performance purposes.
+        # DO NOT MUTATE GEOMETRIES.
+        return unless invalid_reason_memo
+
+        raise Error::InvalidGeometry, invalid_reason_memo
+      end
+
+      # Tell why the geometry is not valid, `nil` means it is valid.
+      def invalid_reason
+        if defined?(super) == "super"
+          raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
+            "definition of #{self.class}##{__method__}."
+        end
+
+        raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."
+      end
+
+      # Try and make the geometry valid, this may change its shape.
+      # Returns a valid copy of the geometry.
+      def make_valid
+        if defined?(super) == "super"
+          raise Error::RGeoError, "ValidityCheck MUST be loaded before " \
+            "definition of #{self.class}##{__method__}."
+        end
+
+        raise Error::UnsupportedOperation, "Method #{self.class}##{__method__} not defined."
+      end
+
+      private
+
+      def invalid_reason_memo
+        # `defined?` is a bit faster than `instance_variable_defined?`.
+        return @invalid_reason_memo if defined?(@invalid_reason_memo)
+
+        @invalid_reason_memo = invalid_reason
+      end
+    end
+  end
+end

data/lib/rgeo/impl_helper.rb

@@ -7,3 +7,4 @@ require_relative "impl_helper/basic_geometry_collection_methods"
 require_relative "impl_helper/basic_point_methods"
 require_relative "impl_helper/basic_line_string_methods"
 require_relative "impl_helper/basic_polygon_methods"
+require_relative "impl_helper/valid_op"

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "2.3.1"
+  VERSION = "3.0.0-rc.2"
 end