rgeo 2.4.0 → 3.0.0.pre.rc.1

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,138 @@
+# 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,
+        # Tests
+        :simple?, :closed?, :empty?,
+        # 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,
+        # 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.4.0"
+  VERSION = "3.0.0-rc.1"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 3.0.0.pre.rc.1
 platform: ruby
 authors:
 - Daniel Azuma
 - Tee Parham
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-19 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-geos
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +81,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: RGeo is a geospatial data library for Ruby. It provides an implementation
   of the Open Geospatial Consortium's Simple Features Specification, used by most
   standard spatial/geographic data storage systems such as PostGIS. A number of add-on
@@ -90,11 +104,13 @@ email:
 - dazuma@gmail.com
 - parhameter@gmail.com
 - kfdoggett@gmail.com
+- buonomo.ulysse@gmail.com
 executables: []
 extensions:
 - ext/geos_c_impl/extconf.rb
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE.txt
 - README.md
 - ext/geos_c_impl/analysis.c
@@ -129,6 +145,9 @@ files:
 - lib/rgeo/cartesian/feature_classes.rb
 - lib/rgeo/cartesian/feature_methods.rb
 - lib/rgeo/cartesian/interface.rb
+- lib/rgeo/cartesian/planar_graph.rb
+- lib/rgeo/cartesian/sweepline_intersector.rb
+- lib/rgeo/cartesian/valid_op.rb
 - lib/rgeo/coord_sys.rb
 - lib/rgeo/coord_sys/cs/entities.rb
 - lib/rgeo/coord_sys/cs/factories.rb
@@ -185,6 +204,8 @@ files:
 - lib/rgeo/impl_helper/basic_polygon_methods.rb
 - lib/rgeo/impl_helper/math.rb
 - lib/rgeo/impl_helper/utils.rb
+- lib/rgeo/impl_helper/valid_op.rb
+- lib/rgeo/impl_helper/validity_check.rb
 - lib/rgeo/version.rb
 - lib/rgeo/wkrep.rb
 - lib/rgeo/wkrep/wkb_generator.rb
@@ -195,7 +216,7 @@ homepage: https://github.com/rgeo/rgeo
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -206,12 +227,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: RGeo is a geospatial data library for Ruby.
 test_files: []