rgeo 2.3.1 → 3.0.1

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -12,6 +12,22 @@ module RGeo
       def srid
         factory.srid
       end
+
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
     end
 
     module SphericalPointMethods # :nodoc:
@@ -33,9 +49,10 @@ module RGeo
         return false unless rhs.is_a?(self.class) && rhs.factory == factory
         case rhs
         when Feature::Point
-          if @y == 90
+          case @y
+          when 90
             rhs.y == 90
-          elsif @y == -90
+          when -90
             rhs.y == -90
           else
             rhs.x == @x && rhs.y == @y
@@ -79,7 +96,8 @@ module RGeo
 
       private
 
-      def validate_geometry
+      # Ensure coordinates fall within a valid range.
+      def init_geometry
         if @x < -180.0 || @x > 180.0
           @x = @x % 360.0
           @x -= 360.0 if @x > 180.0
@@ -120,14 +138,73 @@ module RGeo
         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 length
         arcs.inject(0.0) { |sum, arc| sum + arc.length } * SphericalMath::RADIUS
       end
+
+      def intersects?(rhs)
+        case rhs
+        when Feature::LineString
+          intersects_line_string?(rhs)
+        else
+          super
+        end
+      end
+
+      def crosses?(rhs)
+        case rhs
+        when Feature::LineString
+          crosses_line_string?(rhs)
+        else
+          super
+        end
+      end
+
+      private
+
+      # TODO: replace with better algorithm (https://github.com/rgeo/rgeo/issues/274)
+      # Very simple algorithm to determine if 2 LineStrings intersect.
+      # Uses a nested for loop to look at each arc in the LineStrings and
+      # check if each arc intersects.
+      #
+      # @param [RGeo::Geographic::SphericalLineStringImpl] rhs
+      #
+      # @return [Boolean]
+      def intersects_line_string?(rhs)
+        arcs.each do |arc|
+          rhs.arcs.each do |rhs_arc|
+            return true if arc.intersects_arc?(rhs_arc)
+          end
+        end
+
+        false
+      end
+
+      # TODO: replace with better algorithm (https://github.com/rgeo/rgeo/issues/274)
+      # Very simple algorithm to determine if 2 LineStrings cross.
+      # Uses a nested for loop to look at each arc in the LineStrings and
+      # check if each arc crosses.
+      #
+      # @param [RGeo::Geographic::SphericalLineStringImpl] rhs
+      #
+      # @return [Boolean]
+      def crosses_line_string?(rhs)
+        arcs.each do |arc|
+          rhs.arcs.each do |rhs_arc|
+            next unless arc.intersects_arc?(rhs_arc)
+
+            # check that endpoints aren't the intersection point
+            is_endpoint = arc.contains_point?(rhs_arc.s) ||
+              arc.contains_point?(rhs_arc.e) ||
+              rhs_arc.contains_point?(arc.s) ||
+              rhs_arc.contains_point?(arc.e)
+
+            return true unless is_endpoint
+          end
+        end
+
+        false
+      end
     end
 
     module SphericalMultiLineStringMethods # :nodoc:
@@ -155,7 +232,7 @@ module RGeo
         centroid_lat /= (6.0 * signed_area)
         centroid_lng /= (6.0 * signed_area)
 
-        RGeo::Geographic.spherical_factory.point(centroid_lat, centroid_lng)
+        factory.point(centroid_lat, centroid_lng)
       end
     end
   end

data/lib/rgeo/geographic/spherical_math.rb

@@ -23,6 +23,8 @@ module RGeo
       # of rotation.
 
       class PointXYZ # :nodoc:
+        attr_reader :x, :y, :z
+
         def initialize(x, y, z)
           r = Math.sqrt(x * x + y * y + z * z)
           @x = (x / r).to_f
@@ -35,12 +37,8 @@ module RGeo
           "(#{@x}, #{@y}, #{@z})"
         end
 
-        attr_reader :x
-        attr_reader :y
-        attr_reader :z
-
-        def eql?(rhs)
-          rhs.is_a?(PointXYZ) && @x == rhs.x && @y == rhs.y && @z == rhs.z
+        def eql?(other)
+          other.is_a?(PointXYZ) && @x == other.x && @y == other.y && @z == other.z
         end
         alias == eql?
 
@@ -58,17 +56,17 @@ module RGeo
           [lon_rad / rpd, lat_rad / rpd]
         end
 
-        def *(rhs)
-          val = @x * rhs.x + @y * rhs.y + @z * rhs.z
+        def *(other)
+          val = @x * other.x + @y * other.y + @z * other.z
           val = 1.0 if val > 1.0
           val = -1.0 if val < -1.0
           val
         end
 
-        def %(rhs)
-          rx = rhs.x
-          ry = rhs.y
-          rz = rhs.z
+        def %(other)
+          rx = other.x
+          ry = other.y
+          rz = other.z
           begin
             PointXYZ.new(@y * rz - @z * ry, @z * rx - @x * rz, @x * ry - @y * rx)
           rescue StandardError
@@ -113,8 +111,8 @@ module RGeo
           new(x, y, z)
         end
 
-        def self.weighted_combination(p1, w1, p2, w2)
-          new(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2, p1.z * w1 + p2.z * w2)
+        def self.weighted_combination(pt1, wt1, pt2, wt2)
+          new(pt1.x * wt1 + pt2.x * wt2, pt1.y * wt1 + pt2.y * wt2, pt1.z * wt1 + pt2.z * wt2)
         end
 
         P1 = new(1, 0, 0)
@@ -124,21 +122,20 @@ module RGeo
       # Represents a finite arc on the sphere.
 
       class ArcXYZ # :nodoc:
+        attr_reader :s, :e
+
         def initialize(start, stop)
           @s = start
           @e = stop
           @axis = false
         end
 
-        attr_reader :s
-        attr_reader :e
-
         def to_s
           "#{@s} - #{@e}"
         end
 
-        def eql?(rhs)
-          rhs.is_a?(ArcXYZ) && @s == rhs.s && @e == rhs.e
+        def eql?(other)
+          other.is_a?(ArcXYZ) && @s == other.s && @e == other.e
         end
         alias == eql?
 
@@ -156,7 +153,7 @@ module RGeo
           my_axis = axis
           s_axis = ArcXYZ.new(@s, obj).axis
           e_axis = ArcXYZ.new(obj, @e).axis
-          !s_axis || !e_axis || obj * my_axis == 0.0 && s_axis * my_axis > 0 && e_axis * my_axis > 0
+          !s_axis || !e_axis || obj * my_axis == 0 && s_axis * my_axis > 0 && e_axis * my_axis > 0
         end
 
         def intersects_arc?(obj)

data/lib/rgeo/geographic.rb

@@ -24,7 +24,7 @@ require_relative "geographic/interface"
 require_relative "geographic/spherical_math"
 require_relative "geographic/spherical_feature_methods"
 require_relative "geographic/spherical_feature_classes"
-require_relative "geographic/proj4_projector"
+require_relative "geographic/projector"
 require_relative "geographic/simple_mercator_projector"
 require_relative "geographic/projected_feature_methods"
 require_relative "geographic/projected_feature_classes"

data/lib/rgeo/geos/capi_factory.rb

@@ -9,7 +9,6 @@
 module RGeo
   module Geos
     # This the GEOS CAPI implementation of RGeo::Feature::Factory.
-
     class CAPIFactory
       include Feature::Factory::Instance
       include ImplHelper::Utils
@@ -20,91 +19,68 @@ module RGeo
         #
         # See RGeo::Geos.factory for a list of supported options.
 
-        def create(opts_ = {})
+        def create(opts = {})
           # Make sure GEOS is available
           return unless respond_to?(:_create)
 
           # Get flags to pass to the C extension
           flags = 0
-          flags |= 1 if opts_[:uses_lenient_assertions] || opts_[:lenient_multi_polygon_assertions] || opts_[:uses_lenient_multi_polygon_assertions]
-          flags |= 2 if opts_[:has_z_coordinate]
-          flags |= 4 if opts_[:has_m_coordinate]
+          flags |= 2 if opts[:has_z_coordinate]
+          flags |= 4 if opts[:has_m_coordinate]
+
           if flags & 6 == 6
             raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
           end
-          flags |= 8 unless opts_[:auto_prepare] == :disabled
+
+          flags |= 8 unless opts[:auto_prepare] == :disabled
 
           # Buffer resolution
-          buffer_resolution_ = opts_[:buffer_resolution].to_i
-          buffer_resolution_ = 1 if buffer_resolution_ < 1
+          buffer_resolution = opts[:buffer_resolution].to_i
+          buffer_resolution = 1 if buffer_resolution < 1
 
           # Interpret the generator options
-          wkt_generator_ = opts_[:wkt_generator]
-          case wkt_generator_
-          when :geos
-            wkt_generator_ = nil
-          when Hash
-            wkt_generator_ = WKRep::WKTGenerator.new(wkt_generator_)
-          else
-            wkt_generator_ = WKRep::WKTGenerator.new(convert_case: :upper)
-          end
-          wkb_generator_ = opts_[:wkb_generator]
-          case wkb_generator_
-          when :geos
-            wkb_generator_ = nil
-          when Hash
-            wkb_generator_ = WKRep::WKBGenerator.new(wkb_generator_)
-          else
-            wkb_generator_ = WKRep::WKBGenerator.new
-          end
-
-          # Coordinate system (srid, proj4, and coord_sys)
-          srid_ = opts_[:srid]
-          proj4_ = opts_[:proj4]
-          if proj4_ && CoordSys.check!(:proj4)
-            if proj4_.is_a?(String) || proj4_.is_a?(Hash)
-              proj4_ = CoordSys::Proj4.create(proj4_)
+          wkt_generator = opts[:wkt_generator]
+          wkt_generator =
+            case wkt_generator
+            when Hash
+              WKRep::WKTGenerator.new(wkt_generator)
             end
-          else
-            proj4_ = nil
-          end
-          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
+          wkb_generator = opts[:wkb_generator]
+          wkb_generator =
+            case wkb_generator
+            when Hash
+              WKRep::WKBGenerator.new(wkb_generator)
             end
-          end
-          srid_ ||= coord_sys_.authority_code if coord_sys_
+
+          # Coordinate system (srid and coord_sys)
+          coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
+          srid = coord_sys_info[:srid]
+          coord_sys = coord_sys_info[:coord_sys]
 
           # Create the factory and set instance variables
-          result = _create(flags, srid_.to_i, buffer_resolution_,
-            wkt_generator_, wkb_generator_, proj4_, coord_sys_)
+          result = _create(
+            flags,
+            srid.to_i,
+            buffer_resolution,
+            wkt_generator,
+            wkb_generator,
+            coord_sys
+          )
 
           # Interpret parser options
-          wkt_parser_ = opts_[:wkt_parser]
-          case wkt_parser_
-          when :geos
-            wkt_parser_ = nil
-          when Hash
-            wkt_parser_ = WKRep::WKTParser.new(result, wkt_parser_)
-          else
-            wkt_parser_ = WKRep::WKTParser.new(result)
-          end
-          wkb_parser_ = opts_[:wkb_parser]
-          case wkb_parser_
-          when :geos
-            wkb_parser_ = nil
-          when Hash
-            wkb_parser_ = WKRep::WKBParser.new(result, wkb_parser_)
-          else
-            wkb_parser_ = WKRep::WKBParser.new(result)
-          end
-          result._set_wkrep_parsers(wkt_parser_, wkb_parser_)
+          wkt_parser = opts[:wkt_parser]
+          wkt_parser =
+            case wkt_parser
+            when Hash
+              WKRep::WKTParser.new(result, wkt_parser)
+            end
+          wkb_parser = opts[:wkb_parser]
+          wkb_parser =
+            case wkb_parser
+            when Hash
+              WKRep::WKBParser.new(result, wkb_parser)
+            end
+          result._set_wkrep_parsers(wkt_parser, wkb_parser)
 
           # Return the result
           result
@@ -120,37 +96,33 @@ module RGeo
 
       # Factory equivalence test.
 
-      def eql?(rhs_)
-        rhs_.is_a?(CAPIFactory) && rhs_.srid == _srid &&
-          rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags &&
-          rhs_.proj4 == _proj4
+      def eql?(other)
+        other.is_a?(CAPIFactory) && other.srid == _srid &&
+          other._buffer_resolution == _buffer_resolution && other._flags == _flags &&
+          other.coord_sys == coord_sys
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [_srid, _buffer_resolution, _flags, _proj4].hash
+        @hash ||= [_srid, _buffer_resolution, _flags].hash
       end
 
       # Marshal support
 
       def marshal_dump # :nodoc:
         hash_ = {
-          "hasz" => (_flags & 0x2 != 0),
-          "hasm" => (_flags & 0x4 != 0),
+          "hasz" => supports_z?,
+          "hasm" => supports_m?,
           "srid" => _srid,
           "bufr" => _buffer_resolution,
           "wktg" => _wkt_generator ? _wkt_generator.properties : {},
           "wkbg" => _wkb_generator ? _wkb_generator.properties : {},
           "wktp" => _wkt_parser ? _wkt_parser.properties : {},
           "wkbp" => _wkb_parser ? _wkb_parser.properties : {},
-          "lmpa" => (_flags & 0x1 != 0),
-          "apre" => ((_flags & 0x8) >> 3)
+          "apre" => auto_prepare
         }
-        if (proj4_ = _proj4)
-          hash_["proj4"] = proj4_.marshal_dump
-        end
         if (coord_sys_ = _coord_sys)
           hash_["cs"] = coord_sys_.to_wkt
         end
@@ -158,17 +130,9 @@ module RGeo
       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_copy(
           CAPIFactory.create(
             has_z_coordinate: data_["hasz"],
@@ -179,9 +143,7 @@ module RGeo
             wkb_generator: symbolize_hash(data_["wkbg"]),
             wkt_parser: symbolize_hash(data_["wktp"]),
             wkb_parser: symbolize_hash(data_["wkbp"]),
-            uses_lenient_multi_polygon_assertions: data_["lmpa"],
-            auto_prepare: (data_["apre"] == 0 ? :disabled : :simple),
-            proj4: proj4_,
+            auto_prepare: data_["apre"],
             coord_sys: coord_sys_
           )
         )
@@ -190,41 +152,25 @@ module RGeo
       # Psych support
 
       def encode_with(coder_) # :nodoc:
-        coder_["has_z_coordinate"] = (_flags & 0x2 != 0)
-        coder_["has_m_coordinate"] = (_flags & 0x4 != 0)
+        coder_["has_z_coordinate"] = supports_z?
+        coder_["has_m_coordinate"] = supports_m?
         coder_["srid"] = _srid
         coder_["buffer_resolution"] = _buffer_resolution
-        coder_["lenient_multi_polygon_assertions"] = (_flags & 0x1 != 0)
         coder_["wkt_generator"] = _wkt_generator ? _wkt_generator.properties : {}
         coder_["wkb_generator"] = _wkb_generator ? _wkb_generator.properties : {}
         coder_["wkt_parser"] = _wkt_parser ? _wkt_parser.properties : {}
         coder_["wkb_parser"] = _wkb_parser ? _wkb_parser.properties : {}
-        coder_["auto_prepare"] = ((_flags & 0x8) == 0 ? "disabled" : "simple")
-        if (proj4_ = _proj4)
-          str_ = proj4_.original_str || proj4_.canonical_str
-          coder_["proj4"] = proj4_.radians? ? { "proj4" => str_, "radians" => true } : str_
-        end
-        if (coord_sys_ = _coord_sys)
-          coder_["coord_sys"] = coord_sys_.to_wkt
-        end
+        coder_["auto_prepare"] = auto_prepare
+
+        return unless (coord_sys_ = _coord_sys)
+
+        coder_["coord_sys"] = coord_sys_.to_wkt
       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_copy(
           CAPIFactory.create(
             has_z_coordinate: coder_["has_z_coordinate"],
@@ -236,8 +182,6 @@ module RGeo
             wkt_parser: symbolize_hash(coder_["wkt_parser"]),
             wkb_parser: symbolize_hash(coder_["wkb_parser"]),
             auto_prepare: coder_["auto_prepare"] == "disabled" ? :disabled : :simple,
-            uses_lenient_multi_polygon_assertions: coder_["lenient_multi_polygon_assertions"],
-            proj4: proj4_,
             coord_sys: coord_sys_
           )
         )
@@ -256,28 +200,19 @@ module RGeo
         _buffer_resolution
       end
 
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        _flags & 0x1 != 0
-      end
-
       # See RGeo::Feature::Factory#property
-
       def property(name_)
         case name_
         when :has_z_coordinate
-          _flags & 0x2 != 0
+          supports_z?
         when :has_m_coordinate
-          _flags & 0x4 != 0
+          supports_m?
         when :is_cartesian
           true
-        when :uses_lenient_multi_polygon_assertions
-          _flags & 0x1 != 0
         when :buffer_resolution
           _buffer_resolution
         when :auto_prepare
-          _flags & 0x8 != 0 ? :simple : :disabled
+          prepare_heuristic? ? :simple : :disabled
         end
       end
 
@@ -297,22 +232,16 @@ module RGeo
         if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
-          if str_[0] == "\x00" || str_[0] == "\x01"
-            _parse_wkb_impl(str_)
-          else
-            _parse_wkb_impl([str_].pack('H*'))
-          end
+          _parse_wkb_impl(str_)
         end
       end
 
       # See RGeo::Feature::Factory#point
 
-      def point(x_, y_, *extra_)
-        if extra_.length > (_flags & 6 == 0 ? 0 : 1)
-          raise(RGeo::Error::InvalidGeometry, "Parse error")
-        else
-          CAPIPointImpl.create(self, x_, y_, extra_[0].to_f)
-        end
+      def point(x, y, *extra)
+        raise(RGeo::Error::InvalidGeometry, "Parse error") if extra.length > (supports_z_or_m? ? 1 : 0)
+
+        CAPIPointImpl.create(self, x, y, extra[0].to_f)
       end
 
       # See RGeo::Feature::Factory#line_string
@@ -372,12 +301,6 @@ module RGeo
           raise(RGeo::Error::InvalidGeometry, "Parse error")
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        _proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
@@ -396,33 +319,39 @@ module RGeo
         case original
         when CAPIGeometryMethods
           # Optimization if we're just changing factories, but the
-          # factories are zm-compatible and proj4-compatible.
+          # factories are zm-compatible and coord_sys-compatible.
           if original.factory != self && ntype == type &&
-              original.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project || original.factory.proj4 == _proj4)
+              original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
+              (!project || original.factory.coord_sys == coord_sys)
             result = original.dup
             result.factory = self
             return result
           end
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
-              original.factory._flags & 0x6 == _flags & 0x6 &&
-              (!project || original.factory.proj4 == _proj4) &&
+              original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
+              (!project || original.factory.coord_sys == coord_sys) &&
               type.subtype_of?(Feature::LineString) && ntype.subtype_of?(Feature::LineString)
             return IMPL_CLASSES[ntype]._copy_from(self, original)
           end
         when ZMGeometryMethods
           # Optimization for just removing a coordinate from an otherwise
           # compatible factory
-          if _flags & 0x6 == 0x2 && self == original.factory.z_factory
+          if supports_z? && !supports_m? && self == original.factory.z_factory
             return Feature.cast(original.z_geometry, ntype, flags)
-          elsif _flags & 0x6 == 0x4 && self == original.factory.m_factory
+          end
+
+          if supports_m? && !supports_z? && self == original.factory.m_factory
             return Feature.cast(original.m_geometry, ntype, flags)
           end
         end
         false
       end
 
+      def auto_prepare # :nodoc:
+        prepare_heuristic? ? :simple : :disabled
+      end
+
       # :stopdoc:
 
       IMPL_CLASSES = {