rgeo 0.4.0 → 0.5.0

data/lib/rgeo/cartesian/analysis.rb

@@ -5,18 +5,12 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Cartesian
-
-
     # This provides includes some spatial analysis algorithms supporting
     # Cartesian data.
 
     module Analysis
-
       class << self
-
-
         # Given a LineString, which must be a ring, determine whether the
         # ring proceeds clockwise or counterclockwise.
         # Returns 1 for counterclockwise, or -1 for clockwise.
@@ -33,12 +27,12 @@ module RGeo
           segs_ = []
           size_.times do |i_|
             p0_ = ring_.point_n(i_)
-            p1_ = ring_.point_n(i_+1)
+            p1_ = ring_.point_n(i_ + 1)
             x_ = p1_.x - p0_.x
             y_ = p1_.y - p0_.y
-            r_ = ::Math.sqrt(x_*x_ + y_*y_)
+            r_ = ::Math.sqrt(x_ * x_ + y_ * y_)
             if r_ > 0.0
-              segs_ << x_/r_ << y_/r_
+              segs_ << x_ / r_ << y_ / r_
             else
               size_ -= 1
             end
@@ -50,8 +44,8 @@ module RGeo
           # have to calculate any trig functions.
           angs_ = []
           size_.times do |i_|
-            x0_, y0_, x1_, y1_ = segs_[i_*2,4]
-            angs_ << x0_*x1_ + y0_*y1_ << x0_*y1_ - x1_*y0_
+            x0_, y0_, x1_, y1_ = segs_[i_ * 2, 4]
+            angs_ << x0_ * x1_ + y0_ * y1_ << x0_ * y1_ - x1_ * y0_
           end
 
           # Now add the angles and count revolutions.
@@ -62,29 +56,22 @@ module RGeo
           angs_.each_slice(2) do |(x_, y_)|
             ready_ = y_ > 0.0 && sin_ > 0.0 || y_ < 0.0 && sin_ < 0.0
             if y_ != 0.0
-              s_ = sin_*x_ + cos_*y_
-              c_ = cos_*x_ - sin_*y_
-              r_ = ::Math.sqrt(s_*s_ + c_*c_)
+              s_ = sin_ * x_ + cos_ * y_
+              c_ = cos_ * x_ - sin_ * y_
+              r_ = ::Math.sqrt(s_ * s_ + c_ * c_)
               sin_ = s_ / r_
               cos_ = c_ / r_
             end
-            if ready_
-              if y_ > 0.0 && sin_ <= 0.0
-                revolutions_ += 1
-              elsif y_ < 0.0 && sin_ >= 0.0
-                revolutions_ -= 1
-              end
+            next unless ready_
+            if y_ > 0.0 && sin_ <= 0.0
+              revolutions_ += 1
+            elsif y_ < 0.0 && sin_ >= 0.0
+              revolutions_ -= 1
             end
           end
           revolutions_
         end
-
-
       end
-
     end
-
-
   end
-
 end

data/lib/rgeo/cartesian/bounding_box.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module Cartesian
-
-
     # This is a bounding box for Cartesian data.
     # The simple cartesian implementation uses this internally to compute
     # envelopes. You may also use it directly to compute and represent
@@ -22,30 +19,26 @@ module RGeo
     # bounding boxes.
 
     class BoundingBox
-
-
       # 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
       # BoundingBox.new.
 
-      def self.create_from_points(point1_, point2_, opts_={})
+      def self.create_from_points(point1_, point2_, opts_ = {})
         factory_ = point1_.factory
         new(factory_, opts_)._add_geometry(point1_).add(point2_)
       end
 
-
       # Create a bounding box given a geometry to surround.
       # The bounding box will be given the factory of the geometry.
       # You may also provide the same options available to
       # BoundingBox.new.
 
-      def self.create_from_geometry(geom_, opts_={})
+      def self.create_from_geometry(geom_, opts_ = {})
         factory_ = geom_.factory
         new(factory_, opts_)._add_geometry(geom_)
       end
 
-
       # Create a new empty bounding box with the given factory.
       #
       # The factory defines the coordinate system for the bounding box,
@@ -63,7 +56,7 @@ module RGeo
       #   If true, ignore m coordinates even if the factory supports them.
       #   Default is false.
 
-      def initialize(factory_, opts_={})
+      def initialize(factory_, opts_ = {})
         @factory = factory_
         if (values_ = opts_[:raw])
           @has_z, @has_m, @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m = values_
@@ -74,8 +67,7 @@ module RGeo
         end
       end
 
-
-      def eql?(rhs_)  # :nodoc:
+      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 &&
@@ -84,13 +76,9 @@ module RGeo
       end
       alias_method :==, :eql?
 
-
       # Returns the bounding box's factory.
 
-      def factory
-        @factory
-      end
-
+      attr_reader :factory
 
       # Returns true if this bounding box is still empty.
 
@@ -98,7 +86,6 @@ module RGeo
         @min_x.nil?
       end
 
-
       # Returns true if this bounding box is degenerate. That is,
       # it is nonempty but contains only a single point because both
       # the X and Y spans are 0. Infinitesimal boxes are also
@@ -108,7 +95,6 @@ module RGeo
         @min_x && @min_x == @max_x && @min_y == @max_y
       end
 
-
       # Returns true if this bounding box is degenerate. That is,
       # it is nonempty but has zero area because either or both
       # of the X or Y spans are 0.
@@ -117,34 +103,21 @@ module RGeo
         @min_x && (@min_x == @max_x || @min_y == @max_y)
       end
 
-
       # Returns true if this bounding box tracks Z coordinates.
 
-      def has_z
-        @has_z
-      end
-
+      attr_reader :has_z
 
       # Returns true if this bounding box tracks M coordinates.
 
-      def has_m
-        @has_m
-      end
-
+      attr_reader :has_m
 
       # Returns the minimum X, or nil if this bounding box is empty.
 
-      def min_x
-        @min_x
-      end
-
+      attr_reader :min_x
 
       # Returns the maximum X, or nil if this bounding box is empty.
 
-      def max_x
-        @max_x
-      end
-
+      attr_reader :max_x
 
       # Returns the midpoint X, or nil if this bounding box is empty.
 
@@ -152,27 +125,19 @@ module RGeo
         @max_x ? (@max_x + @min_x) * 0.5 : nil
       end
 
-
       # Returns the X span, or 0 if this bounding box is empty.
 
       def x_span
         @max_x ? @max_x - @min_x : 0
       end
 
-
       # Returns the minimum Y, or nil if this bounding box is empty.
 
-      def min_y
-        @min_y
-      end
-
+      attr_reader :min_y
 
       # Returns the maximum Y, or nil if this bounding box is empty.
 
-      def max_y
-        @max_y
-      end
-
+      attr_reader :max_y
 
       # Returns the midpoint Y, or nil if this bounding box is empty.
 
@@ -180,27 +145,19 @@ module RGeo
         @max_y ? (@max_y + @min_y) * 0.5 : nil
       end
 
-
       # Returns the Y span, or 0 if this bounding box is empty.
 
       def y_span
         @max_y ? @max_y - @min_y : 0
       end
 
-
       # Returns the minimum Z, or nil if this bounding box is empty.
 
-      def min_z
-        @min_z
-      end
-
+      attr_reader :min_z
 
       # Returns the maximum Z, or nil if this bounding box is empty.
 
-      def max_z
-        @max_z
-      end
-
+      attr_reader :max_z
 
       # Returns the midpoint Z, or nil if this bounding box is empty or has no Z.
 
@@ -208,27 +165,19 @@ module RGeo
         @max_z ? (@max_z + @min_z) * 0.5 : nil
       end
 
-
       # 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
 
-
       # Returns the minimum M, or nil if this bounding box is empty.
 
-      def min_m
-        @min_m
-      end
-
+      attr_reader :min_m
 
       # Returns the maximum M, or nil if this bounding box is empty.
 
-      def max_m
-        @max_m
-      end
-
+      attr_reader :max_m
 
       # Returns the midpoint M, or nil if this bounding box is empty or has no M.
 
@@ -236,14 +185,12 @@ module RGeo
         @max_m ? (@max_m + @min_m) * 0.5 : nil
       end
 
-
       # 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
       end
 
-
       # Returns a point representing the minimum extent in all dimensions,
       # or nil if this bounding box is empty.
 
@@ -253,12 +200,9 @@ module RGeo
           extras_ << @min_z if @has_z
           extras_ << @min_m if @has_m
           @factory.point(@min_x, @min_y, *extras_)
-        else
-          nil
         end
       end
 
-
       # Returns a point representing the maximum extent in all dimensions,
       # or nil if this bounding box is empty.
 
@@ -268,12 +212,9 @@ module RGeo
           extras_ << @max_z if @has_z
           extras_ << @max_m if @has_m
           @factory.point(@max_x, @max_y, *extras_)
-        else
-          nil
         end
       end
 
-
       # Adjusts the extents of this bounding box to encompass the given
       # object, which may be a geometry or another bounding box.
       # Returns self.
@@ -293,7 +234,6 @@ module RGeo
         self
       end
 
-
       # Converts this bounding box to an envelope, which will be the
       # empty collection (if the bounding box is empty), a point (if the
       # bounding box is not empty but both spans are 0), a line (if only
@@ -316,8 +256,8 @@ module RGeo
               @factory.line(point_min_, point_max_)
             else
               @factory.polygon(@factory.linear_ring([point_min_,
-                @factory.point(@max_x, @min_y, *extras_), point_max_,
-                @factory.point(@min_x, @max_y, *extras_), point_min_]))
+                                                     @factory.point(@max_x, @min_y, *extras_), point_max_,
+                                                     @factory.point(@min_x, @max_y, *extras_), point_min_]))
             end
           end
         else
@@ -325,7 +265,6 @@ module RGeo
         end
       end
 
-
       # Returns true if this bounding box contains the given object,
       # which may be a geometry or another bounding box.
       #
@@ -338,7 +277,7 @@ module RGeo
       #   Ignore the M coordinate when testing, even if both objects
       #   have M. Default is false.
 
-      def contains?(rhs_, opts_={})
+      def contains?(rhs_, opts_ = {})
         if Feature::Geometry === rhs_
           contains?(BoundingBox.new(@factory).add(rhs_))
         elsif rhs_.empty?
@@ -356,7 +295,6 @@ module RGeo
         end
       end
 
-
       # Returns this bounding box subdivided, as an array of bounding boxes.
       # If this bounding box is empty, returns the empty array.
       # If this bounding box is a point, returns a one-element array
@@ -371,12 +309,12 @@ module RGeo
       #   greater than this factor, the bounding box is divided only in
       #   half instead of fourths.
 
-      def subdivide(opts_={})
+      def subdivide(opts_ = {})
         return [] if empty?
         if infinitesimal?
           return [
-            BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-              @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+            BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                            @min_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
           ]
         end
         factor_ = opts_[:bisect_factor]
@@ -384,55 +322,53 @@ module RGeo
         if factor_
           if x_span > y_span * factor_
             return [
-              BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-                @min_x, center_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
-              BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-                center_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, center_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              center_x, @max_x, @min_y, @max_y, @min_z, @max_z, @min_m, @max_m])
             ]
           elsif y_span > x_span * factor_
             return [
-              BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-                @min_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
-              BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-                @min_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+              BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                              @min_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
             ]
           end
         end
         [
-          BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-            @min_x, center_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
-          BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-            center_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
-          BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-            @min_x, center_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
-          BoundingBox.new(@factory, :raw => [@has_z, @has_m,
-            center_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          @min_x, center_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          center_x, @max_x, @min_y, center_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          @min_x, center_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m]),
+          BoundingBox.new(@factory, raw: [@has_z, @has_m,
+                                          center_x, @max_x, center_y, @max_y, @min_z, @max_z, @min_m, @max_m])
         ]
       end
 
-
-      def _add_geometry(geometry_)  # :nodoc:
+      def _add_geometry(geometry_) # :nodoc:
         case geometry_
         when Feature::Point
           _add_point(geometry_)
         when Feature::LineString
-          geometry_.points.each{ |p_| _add_point(p_) }
+          geometry_.points.each { |p_| _add_point(p_) }
         when Feature::Polygon
-          geometry_.exterior_ring.points.each{ |p_| _add_point(p_) }
+          geometry_.exterior_ring.points.each { |p_| _add_point(p_) }
         when Feature::MultiPoint
-          geometry_.each{ |p_| _add_point(p_) }
+          geometry_.each { |p_| _add_point(p_) }
         when Feature::MultiLineString
-          geometry_.each{ |line_| line_.points.each{ |p_| _add_point(p_) } }
+          geometry_.each { |line_| line_.points.each { |p_| _add_point(p_) } }
         when Feature::MultiPolygon
-          geometry_.each{ |poly_| poly_.exterior_ring.points.each{ |p_| _add_point(p_) } }
+          geometry_.each { |poly_| poly_.exterior_ring.points.each { |p_| _add_point(p_) } }
         when Feature::GeometryCollection
-          geometry_.each{ |g_| _add_geometry(g_) }
+          geometry_.each { |g_| _add_geometry(g_) }
         end
         self
       end
 
-
-      def _add_point(point_)  # :nodoc:
+      def _add_point(point_) # :nodoc:
         if @min_x
           x_ = point_.x
           @min_x = x_ if x_ < @min_x
@@ -457,11 +393,6 @@ module RGeo
           @min_m = @max_m = point_.m if @has_m
         end
       end
-
-
     end
-
-
   end
-
 end