rgeo 2.3.1 → 3.0.1

data/lib/rgeo/cartesian/bounding_box.rb

@@ -19,8 +19,40 @@ module RGeo
     # adding the geometries to it. You may then query it for the bounds,
     # or use it to determine whether it encloses other geometries or
     # bounding boxes.
-
     class BoundingBox
+      # Returns the bounding box's factory.
+      attr_reader :factory
+
+      # Returns true if this bounding box tracks Z coordinates.
+      attr_reader :has_z
+
+      # Returns true if this bounding box tracks M coordinates.
+      attr_reader :has_m
+
+      # Returns the minimum X, or nil if this bounding box is empty.
+      attr_reader :min_x
+
+      # Returns the maximum X, or nil if this bounding box is empty.
+      attr_reader :max_x
+
+      # Returns the minimum Y, or nil if this bounding box is empty.
+      attr_reader :min_y
+
+      # Returns the maximum Y, or nil if this bounding box is empty.
+      attr_reader :max_y
+
+      # Returns the minimum Z, or nil if this bounding box is empty.
+      attr_reader :min_z
+
+      # Returns the maximum Z, or nil if this bounding box is empty.
+      attr_reader :max_z
+
+      # Returns the minimum M, or nil if this bounding box is empty.
+      attr_reader :min_m
+
+      # Returns the maximum M, or nil if this bounding box is empty.
+      attr_reader :max_m
+
       # Create a bounding box given two corner points.
       # The bounding box will be given the factory of the first point.
       # You may also provide the same options available to
@@ -69,19 +101,15 @@ module RGeo
         end
       end
 
-      def eql?(rhs) # :nodoc:
-        rhs.is_a?(BoundingBox) && @factory == rhs.factory &&
-          @min_x == rhs.min_x && @max_x == rhs.max_x &&
-          @min_y == rhs.min_y && @max_y == rhs.max_y &&
-          @min_z == rhs.min_z && @max_z == rhs.max_z &&
-          @min_m == rhs.min_m && @max_m == rhs.max_m
+      def eql?(other) # :nodoc:
+        other.is_a?(BoundingBox) && @factory == other.factory &&
+          @min_x == other.min_x && @max_x == other.max_x &&
+          @min_y == other.min_y && @max_y == other.max_y &&
+          @min_z == other.min_z && @max_z == other.max_z &&
+          @min_m == other.min_m && @max_m == other.max_m
       end
       alias == eql?
 
-      # Returns the bounding box's factory.
-
-      attr_reader :factory
-
       # Returns true if this bounding box is still empty.
 
       def empty?
@@ -105,22 +133,6 @@ module RGeo
         @min_x && (@min_x == @max_x || @min_y == @max_y)
       end
 
-      # Returns true if this bounding box tracks Z coordinates.
-
-      attr_reader :has_z
-
-      # Returns true if this bounding box tracks M coordinates.
-
-      attr_reader :has_m
-
-      # Returns the minimum X, or nil if this bounding box is empty.
-
-      attr_reader :min_x
-
-      # Returns the maximum X, or nil if this bounding box is empty.
-
-      attr_reader :max_x
-
       # Returns the midpoint X, or nil if this bounding box is empty.
 
       def center_x
@@ -133,14 +145,6 @@ module RGeo
         @max_x ? @max_x - @min_x : 0
       end
 
-      # Returns the minimum Y, or nil if this bounding box is empty.
-
-      attr_reader :min_y
-
-      # Returns the maximum Y, or nil if this bounding box is empty.
-
-      attr_reader :max_y
-
       # Returns the midpoint Y, or nil if this bounding box is empty.
 
       def center_y
@@ -153,14 +157,6 @@ module RGeo
         @max_y ? @max_y - @min_y : 0
       end
 
-      # Returns the minimum Z, or nil if this bounding box is empty.
-
-      attr_reader :min_z
-
-      # Returns the maximum Z, or nil if this bounding box is empty.
-
-      attr_reader :max_z
-
       # Returns the midpoint Z, or nil if this bounding box is empty or has no Z.
 
       def center_z
@@ -170,16 +166,12 @@ module RGeo
       # Returns the Z span, 0 if this bounding box is empty, or nil if it has no Z.
 
       def z_span
-        @has_z ? (@max_z ? @max_z - @min_z : 0) : nil
-      end
+        return unless @has_z
 
-      # Returns the minimum M, or nil if this bounding box is empty.
-
-      attr_reader :min_m
+        return 0 unless @max_z
 
-      # Returns the maximum M, or nil if this bounding box is empty.
-
-      attr_reader :max_m
+        @max_z - @min_z
+      end
 
       # Returns the midpoint M, or nil if this bounding box is empty or has no M.
 
@@ -190,31 +182,37 @@ module RGeo
       # Returns the M span, 0 if this bounding box is empty, or nil if it has no M.
 
       def m_span
-        @has_m ? (@max_m ? @max_m - @min_m : 0) : nil
+        return unless @has_m
+
+        return 0 unless @max_m
+
+        @max_m - @min_m
       end
 
       # Returns a point representing the minimum extent in all dimensions,
       # or nil if this bounding box is empty.
 
       def min_point
-        if @min_x
-          extras = []
-          extras << @min_z if @has_z
-          extras << @min_m if @has_m
-          @factory.point(@min_x, @min_y, *extras)
-        end
+        return unless @min_x
+
+        extras = []
+        extras << @min_z if @has_z
+        extras << @min_m if @has_m
+
+        @factory.point(@min_x, @min_y, *extras)
       end
 
       # Returns a point representing the maximum extent in all dimensions,
       # or nil if this bounding box is empty.
 
       def max_point
-        if @min_x
-          extras = []
-          extras << @max_z if @has_z
-          extras << @max_m if @has_m
-          @factory.point(@max_x, @max_y, *extras)
-        end
+        return unless @min_x
+
+        extras = []
+        extras << @max_z if @has_z
+        extras << @max_m if @has_m
+
+        @factory.point(@max_x, @max_y, *extras)
       end
 
       # Adjusts the extents of this bounding box to encompass the given
@@ -280,21 +278,18 @@ module RGeo
       #   have M. Default is false.
 
       def contains?(rhs, opts = {})
-        if Feature::Geometry === rhs
-          contains?(BoundingBox.new(@factory).add(rhs))
-        elsif rhs.empty?
-          true
-        elsif empty?
-          false
-        elsif @min_x > rhs.min_x || @max_x < rhs.max_x || @min_y > rhs.min_y || @max_y < rhs.max_y
-          false
-        elsif @has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)
-          false
-        elsif @has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z)
-          false
-        else
-          true
-        end
+        return contains?(BoundingBox.new(@factory).add(rhs)) if Feature::Geometry === rhs
+
+        return true if rhs.empty?
+
+        return false if empty?
+
+        cmp_xymz =
+          (@min_x > rhs.min_x || @max_x < rhs.max_x || @min_y > rhs.min_y || @max_y < rhs.max_y) ||
+          (@has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)) ||
+          (@has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z))
+
+        !cmp_xymz
       end
 
       # Returns this bounding box subdivided, as an array of bounding boxes.

data/lib/rgeo/cartesian/calculations.rb

@@ -23,17 +23,14 @@ module RGeo
         @lensq = @dx * @dx + @dy * @dy
       end
 
-      attr_reader :s
-      attr_reader :e
-      attr_reader :dx
-      attr_reader :dy
+      attr_reader :s, :e, :dx, :dy
 
       def to_s
         "#{@s} - #{@e}"
       end
 
-      def eql?(rhs)
-        rhs.is_a?(Segment) && @s == rhs.s && @e == rhs.e
+      def eql?(other)
+        other.is_a?(Segment) && @s == other.s && @e == other.e
       end
       alias == eql?
 
@@ -45,23 +42,23 @@ module RGeo
       # a positive value if the point is to the right, or
       # 0 if the point is collinear to the segment.
 
-      def side(p)
-        px = p.x
-        py = p.y
+      def side(point)
+        px = point.x
+        py = point.y
         (@sx - px) * (@ey - py) - (@sy - py) * (@ex - px)
       end
 
-      def tproj(p)
+      def tproj(point)
         if @lensq == 0
           nil
         else
-          (@dx * (p.x - @sx) + @dy * (p.y - @sy)) / @lensq
+          (@dx * (point.x - @sx) + @dy * (point.y - @sy)) / @lensq
         end
       end
 
-      def contains_point?(p)
-        if side(p) == 0
-          t = tproj(p)
+      def contains_point?(point)
+        if side(point) == 0
+          t = tproj(point)
           t && t >= 0.0 && t <= 1.0
         else
           false
@@ -69,41 +66,75 @@ 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
-          else
-            return contains_point?(s2)
-          end
+          return @s if @lensq == 0 && @s == s2
+
+          return contains_point?(s2) ? s2 : nil
         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)
+
+            return int_pt if contains_point?(int_pt)
+
+            # 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
 

data/lib/rgeo/cartesian/factory.rb

@@ -10,11 +10,18 @@ module RGeo
   module Cartesian
     # This class implements the factory for the simple cartesian
     # implementation.
-
     class Factory
       include Feature::Factory::Instance
       include ImplHelper::Utils
 
+      attr_reader :coordinate_dimension, :spatial_dimension
+
+      # Returns the SRID.
+      attr_reader :srid
+
+      # See RGeo::Feature::Factory#coord_sys
+      attr_reader :coord_sys
+
       # Create a new simple cartesian factory.
       #
       # See RGeo::Cartesian.simple_factory for a list of supported options.
@@ -22,74 +29,66 @@ module RGeo
       def initialize(opts = {})
         @has_z = opts[:has_z_coordinate] ? true : false
         @has_m = opts[:has_m_coordinate] ? true : false
-        @proj4 = opts[:proj4]
-        if @proj4 && CoordSys.check!(:proj4)
-          if @proj4.is_a?(String) || @proj4.is_a?(Hash)
-            @proj4 = CoordSys::Proj4.create(@proj4)
-          end
-        end
-        srid = opts[:srid]
-        @coord_sys = opts[:coord_sys]
-        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
+        @coordinate_dimension = 2
+        @coordinate_dimension += 1 if @has_z
+        @coordinate_dimension += 1 if @has_m
+        @spatial_dimension = @has_z ? 3 : 2
+
+        coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
+        @coord_sys = coord_sys_info[:coord_sys]
+        @srid = coord_sys_info[:srid]
+
         @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
 
         wkt_generator = opts[:wkt_generator]
-        case wkt_generator
-        when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
-        else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-        end
+        @wkt_generator =
+          case wkt_generator
+          when Hash
+            WKRep::WKTGenerator.new(wkt_generator)
+          else
+            WKRep::WKTGenerator.new(convert_case: :upper)
+          end
         wkb_generator = opts[:wkb_generator]
-        case wkb_generator
-        when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
-        else
-          @wkb_generator = WKRep::WKBGenerator.new
-        end
+        @wkb_generator =
+          case wkb_generator
+          when Hash
+            WKRep::WKBGenerator.new(wkb_generator)
+          else
+            WKRep::WKBGenerator.new
+          end
         wkt_parser = opts[:wkt_parser]
-        case wkt_parser
-        when Hash
-          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
-        else
-          @wkt_parser = WKRep::WKTParser.new(self)
-        end
+        @wkt_parser =
+          case wkt_parser
+          when Hash
+            WKRep::WKTParser.new(self, wkt_parser)
+          else
+            WKRep::WKTParser.new(self)
+          end
         wkb_parser = opts[:wkb_parser]
-        case wkb_parser
-        when Hash
-          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
-        else
-          @wkb_parser = WKRep::WKBParser.new(self)
-        end
+        @wkb_parser =
+          case wkb_parser
+          when Hash
+            WKRep::WKBParser.new(self, wkb_parser)
+          else
+            WKRep::WKBParser.new(self)
+          end
       end
 
       # Equivalence test.
 
-      def eql?(rhs)
-        rhs.is_a?(self.class) && @srid == rhs.srid &&
-          @has_z == rhs.property(:has_z_coordinate) &&
-          @has_m == rhs.property(:has_m_coordinate) &&
-          @proj4.eql?(rhs.proj4)
+      def eql?(other)
+        other.is_a?(self.class) && @srid == other.srid &&
+          @has_z == other.property(:has_z_coordinate) &&
+          @has_m == other.property(:has_m_coordinate) &&
+          @coord_sys == other.instance_variable_get(:@coord_sys)
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [@srid, @has_z, @has_m, @proj4].hash
+        @hash ||= [@srid, @has_z, @has_m, @coord_sys].hash
       end
 
       # Marshal support
@@ -103,26 +102,16 @@ 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
         hash_["cs"] = @coord_sys.to_wkt if @coord_sys
         hash_
       end
 
       def marshal_load(data) # :nodoc:
-        if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
-          proj4 = CoordSys::Proj4.allocate
-          proj4.marshal_load(proj4_data)
-        else
-          proj4 = nil
-        end
-        if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = data["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           has_z_coordinate: data["hasz"],
           has_m_coordinate: data["hasm"],
@@ -131,9 +120,7 @@ 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
         )
       end
@@ -144,34 +131,18 @@ 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
         coder["wkt_parser"] = @wkt_parser.properties
         coder["wkb_parser"] = @wkb_parser.properties
-        if @proj4
-          str = @proj4.original_str || @proj4.canonical_str
-          coder["proj4"] = @proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
         coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
       end
 
       def init_with(coder) # :nodoc:
-        if (proj4_data = coder["proj4"]) && CoordSys.check!(:proj4)
-          if proj4_data.is_a?(Hash)
-            proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
-          else
-            proj4 = CoordSys::Proj4.create(proj4_data.to_s)
-          end
-        else
-          proj4 = nil
-        end
-        if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CS.create_from_wkt(coord_sys_data.to_s)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = coder["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           has_z_coordinate: coder["has_z_coordinate"],
           has_m_coordinate: coder["has_m_coordinate"],
@@ -180,17 +151,11 @@ 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
         )
       end
 
-      # Returns the SRID.
-
-      attr_reader :srid
-
       # See RGeo::Feature::Factory#property
 
       def property(name)
@@ -199,8 +164,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
@@ -274,14 +237,6 @@ module RGeo
         MultiPolygonImpl.new(self, elems)
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      attr_reader :proj4
-
-      # See RGeo::Feature::Factory#coord_sys
-
-      attr_reader :coord_sys
-
       def generate_wkt(obj)
         @wkt_generator.generate(obj)
       end