rgeo 1.1.2 → 2.0.0

data/lib/rgeo/geographic/projected_feature_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Projected geographic common method definitions
@@ -29,94 +31,88 @@ module RGeo
       end
 
       def boundary
-        boundary_ = projection.boundary
-        boundary_ ? factory.unproject(boundary_) : nil
+        boundary = projection.boundary
+        boundary ? factory.unproject(boundary) : nil
       end
 
-      def equals?(rhs_)
-        projection.equals?(Feature.cast(rhs_, factory).projection)
+      def equals?(rhs)
+        projection.equals?(Feature.cast(rhs, factory).projection)
       end
 
-      def disjoint?(rhs_)
-        projection.disjoint?(Feature.cast(rhs_, factory).projection)
+      def disjoint?(rhs)
+        projection.disjoint?(Feature.cast(rhs, factory).projection)
       end
 
-      def intersects?(rhs_)
-        projection.intersects?(Feature.cast(rhs_, factory).projection)
+      def intersects?(rhs)
+        projection.intersects?(Feature.cast(rhs, factory).projection)
       end
 
-      def touches?(rhs_)
-        projection.touches?(Feature.cast(rhs_, factory).projection)
+      def touches?(rhs)
+        projection.touches?(Feature.cast(rhs, factory).projection)
       end
 
-      def crosses?(rhs_)
-        projection.crosses?(Feature.cast(rhs_, factory).projection)
+      def crosses?(rhs)
+        projection.crosses?(Feature.cast(rhs, factory).projection)
       end
 
-      def within?(rhs_)
-        projection.within?(Feature.cast(rhs_, factory).projection)
+      def within?(rhs)
+        projection.within?(Feature.cast(rhs, factory).projection)
       end
 
-      def contains?(rhs_)
-        projection.contains?(Feature.cast(rhs_, factory).projection)
+      def contains?(rhs)
+        projection.contains?(Feature.cast(rhs, factory).projection)
       end
 
-      def overlaps?(rhs_)
-        projection.overlaps?(Feature.cast(rhs_, factory).projection)
+      def overlaps?(rhs)
+        projection.overlaps?(Feature.cast(rhs, factory).projection)
       end
 
-      def relate(rhs_, pattern_)
-        projection.relate(Feature.cast(rhs_, factory).projection, pattern_)
+      def relate(rhs, pattern_)
+        projection.relate(Feature.cast(rhs, factory).projection, pattern_)
       end
 
-      def distance(rhs_)
-        projection.distance(Feature.cast(rhs_, factory).projection)
+      def distance(rhs)
+        projection.distance(Feature.cast(rhs, factory).projection)
       end
 
-      def buffer(distance_)
-        factory.unproject(projection.buffer(distance_))
+      def buffer(distance)
+        factory.unproject(projection.buffer(distance))
       end
 
-      def buffer_with_style(distance_, endCapStyle_, joinStyle_, mitreLimit_)
-        factory.unproject(projection.buffer_with_style(distance_, endCapStyle_, joinStyle_, mitreLimit_))
+      def buffer_with_style(distance, end_cap_style, join_style, mitre_limit)
+        factory.unproject(projection.buffer_with_style(distance, end_cap_style, join_style, mitre_limit))
       end
 
-      def simplify(tolerance_)
-        factory.unproject(projection.simplify(tolerance_))
+      def simplify(tolerance)
+        factory.unproject(projection.simplify(tolerance))
       end
 
-      def simplify_preserve_topology(tolerance_)
-        factory.unproject(projection.simplify_preserve_topology(tolerance_))
+      def simplify_preserve_topology(tolerance)
+        factory.unproject(projection.simplify_preserve_topology(tolerance))
       end
 
       def convex_hull
         factory.unproject(projection.convex_hull)
       end
 
-      def intersection(rhs_)
-        factory.unproject(projection.intersection(Feature.cast(rhs_, factory).projection))
+      def intersection(rhs)
+        factory.unproject(projection.intersection(Feature.cast(rhs, factory).projection))
       end
 
-      def union(rhs_)
-        factory.unproject(projection.union(Feature.cast(rhs_, factory).projection))
+      def union(rhs)
+        factory.unproject(projection.union(Feature.cast(rhs, factory).projection))
       end
 
-      def difference(rhs_)
-        factory.unproject(projection.difference(Feature.cast(rhs_, factory).projection))
+      def difference(rhs)
+        factory.unproject(projection.difference(Feature.cast(rhs, factory).projection))
       end
 
-      def sym_difference(rhs_)
-        factory.unproject(projection.sym_difference(Feature.cast(rhs_, factory).projection))
+      def sym_difference(rhs)
+        factory.unproject(projection.sym_difference(Feature.cast(rhs, factory).projection))
       end
     end
 
     module ProjectedPointMethods # :nodoc:
-      def _validate_geometry
-        @y = 85.0511287 if @y > 85.0511287
-        @y = -85.0511287 if @y < -85.0511287
-        super
-      end
-
       def canonical_x
         x_ = @x % 360.0
         x_ -= 360.0 if x_ > 180.0
@@ -133,14 +129,22 @@ module RGeo
         end
       end
 
-      def self.included(klass_)
-        klass_.module_eval do
+      def self.included(klass)
+        klass.module_eval do
           alias_method :longitude, :x
           alias_method :lon, :x
           alias_method :latitude, :y
           alias_method :lat, :y
         end
       end
+
+      private
+
+      def validate_geometry
+        @y = 85.0511287 if @y > 85.0511287
+        @y = -85.0511287 if @y < -85.0511287
+        super
+      end
     end
 
     module ProjectedNCurveMethods # :nodoc:
@@ -150,7 +154,9 @@ module RGeo
     end
 
     module ProjectedLineStringMethods # :nodoc:
-      def _validate_geometry
+      private
+
+      def validate_geometry
         @points = @points.map(&:canonical_point)
         super
       end
@@ -171,7 +177,9 @@ module RGeo
     end
 
     module ProjectedPolygonMethods # :nodoc:
-      def _validate_geometry
+      private
+
+      def validate_geometry
         super
         unless projection
           raise Error::InvalidGeometry, "Polygon failed assertions"
@@ -180,7 +188,9 @@ module RGeo
     end
 
     module ProjectedMultiPolygonMethods # :nodoc:
-      def _validate_geometry
+      private
+
+      def validate_geometry
         super
         unless projection
           raise Error::InvalidGeometry, "MultiPolygon failed assertions"

data/lib/rgeo/geographic/projected_window.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # A projected window in a geography implementation
@@ -212,7 +214,7 @@ module RGeo
       # this window.
 
       def contains_window?(window_)
-        return nil if window_.factory != @factory
+        return if window_.factory != @factory
         if window_.y_max <= @y_max && window_.y_min >= @y_min
           if (@x_max < @x_min) == window_.crosses_seam?
             window_.x_max <= @x_max && window_.x_min >= @x_min
@@ -354,7 +356,7 @@ module RGeo
             y_max_ = y_ if !y_max_ || y_max_ < y_
             y_min_ = y_ if !y_min_ || y_min_ > y_
           end
-          return nil unless factory_
+          return unless factory_
           if x_array_
             x_array_.sort!
             largest_span_ = nil

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Simple mercator projection
@@ -9,76 +11,76 @@ module RGeo
     class SimpleMercatorProjector # :nodoc:
       EQUATORIAL_RADIUS = 6_378_137.0
 
-      def initialize(geography_factory_, opts_ = {})
-        @geography_factory = geography_factory_
+      def initialize(geography_factory, opts = {})
+        @geography_factory = geography_factory
         @projection_factory = Cartesian.preferred_factory(srid: 3857,
                                                           proj4: SimpleMercatorProjector._proj4_3857,
                                                           coord_sys: SimpleMercatorProjector._coordsys_3857,
-                                                          buffer_resolution: opts_[:buffer_resolution],
-                                                          lenient_multi_polygon_assertions: opts_[:lenient_multi_polygon_assertions],
-                                                          uses_lenient_assertions: opts_[:uses_lenient_assertions],
-                                                          has_z_coordinate: opts_[:has_z_coordinate],
-                                                          has_m_coordinate: opts_[:has_m_coordinate])
+                                                          buffer_resolution: opts[:buffer_resolution],
+                                                          lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions],
+                                                          uses_lenient_assertions: opts[:uses_lenient_assertions],
+                                                          has_z_coordinate: opts[:has_z_coordinate],
+                                                          has_m_coordinate: opts[:has_m_coordinate])
       end
 
-      def _set_factories(geography_factory_, projection_factory_) # :nodoc:
-        @geography_factory = geography_factory_
-        @projection_factory = projection_factory_
+      def set_factories(geography_factory, projection_factory)
+        @geography_factory = geography_factory
+        @projection_factory = projection_factory
       end
 
       attr_reader :projection_factory
 
-      def project(geometry_)
-        case geometry_
+      def project(geometry)
+        case geometry
         when Feature::Point
           rpd_ = ImplHelper::Math::RADIANS_PER_DEGREE
-          radius_ = EQUATORIAL_RADIUS
-          @projection_factory.point(geometry_.x * rpd_ * radius_,
-            ::Math.log(::Math.tan(::Math::PI / 4.0 + geometry_.y * rpd_ / 2.0)) * radius_)
+          radius = EQUATORIAL_RADIUS
+          @projection_factory.point(geometry.x * rpd_ * radius,
+            Math.log(Math.tan(Math::PI / 4.0 + geometry.y * rpd_ / 2.0)) * radius)
         when Feature::Line
-          @projection_factory.line(project(geometry_.start_point), project(geometry_.end_point))
+          @projection_factory.line(project(geometry.start_point), project(geometry.end_point))
         when Feature::LinearRing
-          @projection_factory.linear_ring(geometry_.points.map { |p_| project(p_) })
+          @projection_factory.linear_ring(geometry.points.map { |p| project(p) })
         when Feature::LineString
-          @projection_factory.line_string(geometry_.points.map { |p_| project(p_) })
+          @projection_factory.line_string(geometry.points.map { |p| project(p) })
         when Feature::Polygon
-          @projection_factory.polygon(project(geometry_.exterior_ring),
-                                      geometry_.interior_rings.map { |p_| project(p_) })
+          @projection_factory.polygon(project(geometry.exterior_ring),
+                                      geometry.interior_rings.map { |p| project(p) })
         when Feature::MultiPoint
-          @projection_factory.multi_point(geometry_.map { |p_| project(p_) })
+          @projection_factory.multi_point(geometry.map { |p| project(p) })
         when Feature::MultiLineString
-          @projection_factory.multi_line_string(geometry_.map { |p_| project(p_) })
+          @projection_factory.multi_line_string(geometry.map { |p| project(p) })
         when Feature::MultiPolygon
-          @projection_factory.multi_polygon(geometry_.map { |p_| project(p_) })
+          @projection_factory.multi_polygon(geometry.map { |p| project(p) })
         when Feature::GeometryCollection
-          @projection_factory.collection(geometry_.map { |p_| project(p_) })
+          @projection_factory.collection(geometry.map { |p| project(p) })
         end
       end
 
-      def unproject(geometry_)
-        case geometry_
+      def unproject(geometry)
+        case geometry
         when Feature::Point
-          dpr_ = ImplHelper::Math::DEGREES_PER_RADIAN
-          radius_ = EQUATORIAL_RADIUS
-          @geography_factory.point(geometry_.x / radius_ * dpr_,
-            (2.0 * ::Math.atan(::Math.exp(geometry_.y / radius_)) - ::Math::PI / 2.0) * dpr_)
+          dpr = ImplHelper::Math::DEGREES_PER_RADIAN
+          radius = EQUATORIAL_RADIUS
+          @geography_factory.point(geometry.x / radius * dpr,
+            (2.0 * Math.atan(Math.exp(geometry.y / radius)) - Math::PI / 2.0) * dpr)
         when Feature::Line
-          @geography_factory.line(unproject(geometry_.start_point), unproject(geometry_.end_point))
+          @geography_factory.line(unproject(geometry.start_point), unproject(geometry.end_point))
         when Feature::LinearRing
-          @geography_factory.linear_ring(geometry_.points.map { |p_| unproject(p_) })
+          @geography_factory.linear_ring(geometry.points.map { |p| unproject(p) })
         when Feature::LineString
-          @geography_factory.line_string(geometry_.points.map { |p_| unproject(p_) })
+          @geography_factory.line_string(geometry.points.map { |p| unproject(p) })
         when Feature::Polygon
-          @geography_factory.polygon(unproject(geometry_.exterior_ring),
-            geometry_.interior_rings.map { |p_| unproject(p_) })
+          @geography_factory.polygon(unproject(geometry.exterior_ring),
+            geometry.interior_rings.map { |p| unproject(p) })
         when Feature::MultiPoint
-          @geography_factory.multi_point(geometry_.map { |p_| unproject(p_) })
+          @geography_factory.multi_point(geometry.map { |p| unproject(p) })
         when Feature::MultiLineString
-          @geography_factory.multi_line_string(geometry_.map { |p_| unproject(p_) })
+          @geography_factory.multi_line_string(geometry.map { |p| unproject(p) })
         when Feature::MultiPolygon
-          @geography_factory.multi_polygon(geometry_.map { |p_| unproject(p_) })
+          @geography_factory.multi_polygon(geometry.map { |p| unproject(p) })
         when Feature::GeometryCollection
-          @geography_factory.collection(geometry_.map { |p_| unproject(p_) })
+          @geography_factory.collection(geometry.map { |p| unproject(p) })
         end
       end
 

data/lib/rgeo/geographic/spherical_feature_classes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Spherical geographic feature classes
@@ -12,8 +14,6 @@ module RGeo
       include ImplHelper::BasicPointMethods
       include SphericalGeometryMethods
       include SphericalPointMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Point).include_in_class(self, true)
     end
 
     class SphericalLineStringImpl # :nodoc:
@@ -22,8 +22,6 @@ module RGeo
       include ImplHelper::BasicLineStringMethods
       include SphericalGeometryMethods
       include SphericalLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LineString).include_in_class(self, true)
     end
 
     class SphericalLineImpl # :nodoc:
@@ -33,8 +31,6 @@ module RGeo
       include ImplHelper::BasicLineMethods
       include SphericalGeometryMethods
       include SphericalLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Line).include_in_class(self, true)
     end
 
     class SphericalLinearRingImpl # :nodoc:
@@ -44,8 +40,6 @@ module RGeo
       include ImplHelper::BasicLinearRingMethods
       include SphericalGeometryMethods
       include SphericalLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::LinearRing).include_in_class(self, true)
     end
 
     class SphericalPolygonImpl # :nodoc:
@@ -53,8 +47,6 @@ module RGeo
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicPolygonMethods
       include SphericalGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::Polygon).include_in_class(self, true)
     end
 
     class SphericalGeometryCollectionImpl # :nodoc:
@@ -62,8 +54,6 @@ module RGeo
       include ImplHelper::BasicGeometryMethods
       include ImplHelper::BasicGeometryCollectionMethods
       include SphericalGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::GeometryCollection).include_in_class(self, true)
     end
 
     class SphericalMultiPointImpl # :nodoc:
@@ -72,8 +62,6 @@ module RGeo
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPointMethods
       include SphericalGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPoint).include_in_class(self, true)
     end
 
     class SphericalMultiLineStringImpl # :nodoc:
@@ -83,8 +71,6 @@ module RGeo
       include ImplHelper::BasicMultiLineStringMethods
       include SphericalGeometryMethods
       include SphericalMultiLineStringMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiLineString).include_in_class(self, true)
     end
 
     class SphericalMultiPolygonImpl # :nodoc:
@@ -93,8 +79,6 @@ module RGeo
       include ImplHelper::BasicGeometryCollectionMethods
       include ImplHelper::BasicMultiPolygonMethods
       include SphericalGeometryMethods
-
-      Feature::MixinCollection::GLOBAL.for_type(Feature::MultiPolygon).include_in_class(self, true)
     end
   end
 end

data/lib/rgeo/geographic/spherical_feature_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Spherical geographic common methods
@@ -13,121 +15,119 @@ module RGeo
     end
 
     module SphericalPointMethods # :nodoc:
-      def _validate_geometry
-        if @x < -180.0 || @x > 180.0
-          @x = @x % 360.0
-          @x -= 360.0 if @x > 180.0
-        end
-        @y = 90.0 if @y > 90.0
-        @y = -90.0 if @y < -90.0
-        super
-      end
-
-      def _xyz
+      def xyz
         @xyz ||= SphericalMath::PointXYZ.from_latlon(@y, @x)
       end
 
-      def distance(rhs_)
-        rhs_ = Feature.cast(rhs_, @factory)
-        case rhs_
+      def distance(rhs)
+        rhs = Feature.cast(rhs, @factory)
+        case rhs
         when SphericalPointImpl
-          _xyz.dist_to_point(rhs_._xyz) * SphericalMath::RADIUS
+          xyz.dist_to_point(rhs.xyz) * SphericalMath::RADIUS
         else
           super
         end
       end
 
-      def equals?(rhs_)
-        return false unless rhs_.is_a?(self.class) && rhs_.factory == factory
-        case rhs_
+      def equals?(rhs)
+        return false unless rhs.is_a?(self.class) && rhs.factory == factory
+        case rhs
         when Feature::Point
           if @y == 90
-            rhs_.y == 90
+            rhs.y == 90
           elsif @y == -90
-            rhs_.y == -90
+            rhs.y == -90
           else
-            rhs_.x == @x && rhs_.y == @y
+            rhs.x == @x && rhs.y == @y
           end
         when Feature::LineString
-          rhs_.num_points > 0 && rhs_.points.all? { |elem_| equals?(elem_) }
+          rhs.num_points > 0 && rhs.points.all? { |elem| equals?(elem) }
         when Feature::GeometryCollection
-          rhs_.num_geometries > 0 && rhs_.all? { |elem_| equals?(elem_) }
+          rhs.num_geometries > 0 && rhs.all? { |elem| equals?(elem) }
         else
           false
         end
       end
 
-      def buffer(distance_)
-        radius_ = distance_ / SphericalMath::RADIUS
-        radius_ = 1.5 if radius_ > 1.5
-        cos_ = ::Math.cos(radius_)
-        sin_ = ::Math.sin(radius_)
-        point_count_ = factory.property(:buffer_resolution) * 4
-        p0_ = _xyz
-        p1_ = p0_.create_perpendicular
-        p2_ = p1_ % p0_
-        angle_ = ::Math::PI * 2.0 / point_count_
-        points_ = (0...point_count_).map do |i_|
-          r_ = angle_ * i_
-          pi_ = SphericalMath::PointXYZ.weighted_combination(p1_, ::Math.cos(r_), p2_, ::Math.sin(r_))
-          p_ = SphericalMath::PointXYZ.weighted_combination(p0_, cos_, pi_, sin_)
-          factory.point(*p_.lonlat)
+      def buffer(distance)
+        radius = distance / SphericalMath::RADIUS
+        radius = 1.5 if radius > 1.5
+        cos = Math.cos(radius)
+        sin = Math.sin(radius)
+        point_count = factory.property(:buffer_resolution) * 4
+        p0 = xyz
+        p1 = p0.create_perpendicular
+        p2 = p1 % p0
+        angle = Math::PI * 2.0 / point_count
+        points = (0...point_count).map do |i|
+          r = angle * i
+          pi = SphericalMath::PointXYZ.weighted_combination(p1, Math.cos(r), p2, Math.sin(r))
+          p = SphericalMath::PointXYZ.weighted_combination(p0, cos, pi, sin)
+          factory.point(*p.lonlat)
         end
-        factory.polygon(factory.linear_ring(points_))
+        factory.polygon(factory.linear_ring(points))
       end
 
-      def self.included(klass_)
-        klass_.module_eval do
+      def self.included(klass)
+        klass.module_eval do
           alias_method :longitude, :x
           alias_method :lon, :x
           alias_method :latitude, :y
           alias_method :lat, :y
         end
       end
+
+      private
+
+      def validate_geometry
+        if @x < -180.0 || @x > 180.0
+          @x = @x % 360.0
+          @x -= 360.0 if @x > 180.0
+        end
+        @y = 90.0 if @y > 90.0
+        @y = -90.0 if @y < -90.0
+        super
+      end
     end
 
     module SphericalLineStringMethods # :nodoc:
-      def _arcs
-        unless defined?(@arcs)
-          @arcs = (0..num_points - 2).map do |i_|
-            SphericalMath::ArcXYZ.new(point_n(i_)._xyz, point_n(i_ + 1)._xyz)
-          end
+      def arcs
+        @arcs ||= (0..num_points - 2).map do |i|
+          SphericalMath::ArcXYZ.new(point_n(i).xyz, point_n(i + 1).xyz)
         end
-        @arcs
       end
 
       def is_simple?
-        arcs_ = _arcs
-        len_ = arcs_.length
-        return false if arcs_.any?(&:degenerate?)
-        return true if len_ == 1
-        return arcs_[0].s != arcs_[1].e if len_ == 2
-        arcs_.each_with_index do |arc_, index_|
-          nindex_ = index_ + 1
-          nindex_ = nil if nindex_ == len_
-          return false if nindex_ && arc_.contains_point?(arcs_[nindex_].e)
-          pindex_ = index_ - 1
-          pindex_ = nil if pindex_ < 0
-          return false if pindex_ && arc_.contains_point?(arcs_[pindex_].s)
-          next unless nindex_
-          oindex_ = nindex_ + 1
-          while oindex_ < len_
-            oarc_ = arcs_[oindex_]
-            return false if !(index_ == 0 && oindex_ == len_ - 1 && arc_.s == oarc_.e) && arc_.intersects_arc?(oarc_)
-            oindex_ += 1
+        len = arcs.length
+        return false if arcs.any?(&:degenerate?)
+        return true if len == 1
+        return arcs[0].s != arcs[1].e if len == 2
+        arcs.each_with_index do |arc, index|
+          nindex = index + 1
+          nindex = nil if nindex == len
+          return false if nindex && arc.contains_point?(arcs[nindex].e)
+          pindex = index - 1
+          pindex = nil if pindex < 0
+          return false if pindex && arc.contains_point?(arcs[pindex].s)
+          next unless nindex
+          oindex = nindex + 1
+          while oindex < len
+            oarc = arcs[oindex]
+            return false if !(index == 0 && oindex == len - 1 && arc.s == oarc.e) && arc.intersects_arc?(oarc)
+            oindex += 1
           end
         end
         true
       end
 
       def length
-        _arcs.inject(0.0) { |sum_, arc_| sum_ + arc_.length } * SphericalMath::RADIUS
+        arcs.inject(0.0) { |sum, arc| sum + arc.length } * SphericalMath::RADIUS
       end
     end
 
     module SphericalMultiLineStringMethods # :nodoc:
       def length
-        inject(0.0) { |sum_, geom_| sum_ + geom_.length }
+        inject(0.0) { |sum, geom| sum + geom.length }
       end
     end
   end