georuby 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18405683e03e3da7a272be360c5bb5c8bff05a25
-  data.tar.gz: 5ceefaf8c76fdf9f8d9b47b54ec1530b8eb485b4
+  metadata.gz: 1df3941993b62765a00e7f70707184ef283c189a
+  data.tar.gz: 14626bcff00c29e6ac59747d54501e2d0e5b4be7
 SHA512:
-  metadata.gz: c4a344a8b430b5bdf67e3f90c5f4b9327d53a69eb23ef87b3bdebfe97bf65c7ab4ebee285f970e5b1ae61896a7622f2c0deb237d268a3c54b2a4f39d1d0a7ed3
-  data.tar.gz: bbd50a644084b9f1e60cd128438cd7f33b88e9de603263553be23a47528f917b0e7d2c1de8f0d3d3588d08515a16aeeca6cd925fa03d065f06dea9ddad437730
+  metadata.gz: 98448b91aa33033dc06db092a68e72d1e04a0dcad9c895cd34953c78acc9da96c28adbb74d3c951c835a98c2f01cfaa658d1f9028f127e282f05bc89c7dc7ff5
+  data.tar.gz: 2bba7b1eed46c75f3871508f82b4015803eef2617d1d474fcfe4dd3c7830c054d9a88c9f6e5b5e5121cb43da9129d376366a0d94c1ae0dc542d72cad404c8c78

data/lib/geo_ruby/geojson.rb

@@ -37,7 +37,7 @@ module GeoRuby
       output[:geometry] = geometry
       output[:properties] = properties
       output[:id] = id unless id.nil?
-      output.to_json(options)
+      output.as_json(options)
     end
 
     def to_json(options = {})

data/lib/geo_ruby/simple_features/envelope.rb

@@ -55,7 +55,7 @@ module GeoRuby
 
       #Zoom level
       def zoom
-        distance = lower_corner.spherical_distance(upper_corner)/10000
+        distance = lower_corner.spherical_distance(upper_corner) / 10_000
         @zoom = case distance
         when 150..9000  then 5
         when 80..149    then 6
@@ -156,7 +156,7 @@ module GeoRuby
       end
 
       #Creates a new envelope. Accept a sequence of point coordinates as argument : ((x,y),(x,y))
-      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false)
+      def self.from_coordinates(points, srid = DEFAULT_SRID, with_z = false)
         e = Envelope.new(srid,with_z)
         e.lower_corner, e.upper_corner =  points.collect{|point_coords| Point.from_coordinates(point_coords,srid,with_z)}
         e

data/lib/geo_ruby/simple_features/point.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "geo_ruby/simple_features/geometry"
+require 'geo_ruby/simple_features/geometry'
 
 module GeoRuby
   module SimpleFeatures
@@ -10,7 +10,8 @@ module GeoRuby
       attr_accessor :x,:y,:z,:m
       attr_reader :r, :t # radium and theta
 
-      # if you prefer calling the coordinates lat and lon (or lng, for GeoKit compatibility)
+      # If you prefer calling the coordinates lat and lon
+      # (or lng, for GeoKit compatibility)
       alias :lon :x
       alias :lng :x
       alias :lat :y
@@ -21,10 +22,12 @@ module GeoRuby
       def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
         super(srid, with_z, with_m)
         @x = @y = 0.0
-        @z=0.0 #default value : meaningful if with_z
-        @m=0.0 #default value : meaningful if with_m
+        @z = 0.0 #default value : meaningful if with_z
+        @m = 0.0 #default value : meaningful if with_m
       end
-      #sets all coordinates in one call. Use the +m+ accessor to set the m.
+
+      # Sets all coordinates in one call.
+      # Use the +m+ accessor to set the m.
       def set_x_y_z(x, y, z)
         @x = x && !x.is_a?(Numeric) ? x.to_f : x
         @y = y && !y.is_a?(Numeric) ? y.to_f : y
@@ -33,7 +36,7 @@ module GeoRuby
       end
       alias :set_lon_lat_z :set_x_y_z
 
-      #sets all coordinates of a 2D point in one call
+      # Sets all coordinates of a 2D point in one call
       def set_x_y(x, y)
         @x = x && !x.is_a?(Numeric) ? x.to_f : x
         @y = y && !y.is_a?(Numeric) ? y.to_f : y
@@ -41,21 +44,26 @@ module GeoRuby
       end
       alias :set_lon_lat :set_x_y
 
-      # Return the distance between the 2D points (ie taking care only of the x and y coordinates), assuming
-      # the points are in projected coordinates. Euclidian distance in whatever unit the x and y ordinates are.
+      # Return the distance between the 2D points (ie taking care only
+      # of the x and y coordinates), assuming the points are in
+      # projected coordinates.
+      #
+      # Euclidian distance in whatever unit the x and y ordinates are.
       def euclidian_distance(point)
         Math.sqrt((point.x - x)**2 + (point.y - y)**2)
       end
 
       # Spherical distance in meters, using 'Haversine' formula.
       # with a radius of 6471000m
-      # Assumes x is the lon and y the lat, in degrees (Changed in version 1.1).
-      # The user has to make sure using this distance makes sense (ie she should be in latlon coordinates)
+      # Assumes x is the lon and y the lat, in degrees.
+      # The user has to make sure using this distance makes sense
+      # (ie she should be in latlon coordinates)
       def spherical_distance(point, r = 6370997.0)
         dlat = (point.lat - lat) * DEG2RAD / 2
         dlon = (point.lon - lon) * DEG2RAD / 2
 
-        a = Math.sin(dlat)**2 + Math.cos(lat * DEG2RAD) * Math.cos(point.lat * DEG2RAD) * Math.sin(dlon)**2
+        a = Math.sin(dlat)**2 + Math.cos(lat * DEG2RAD) *
+          Math.cos(point.lat * DEG2RAD) * Math.sin(dlon)**2
         c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
         r * c
       end
@@ -65,7 +73,7 @@ module GeoRuby
       # b is the semi-minor axis (polar radius) of the ellipsoid
       # Their values by default are set to the ones of the WGS84 ellipsoid
       def ellipsoidal_distance(point, a = 6378137.0, b = 6356752.3142)
-        f = (a-b) / a
+        f = (a - b) / a
         l = (point.lon - lon) * DEG2RAD
 
         u1 = Math.atan((1-f) * Math.tan(lat * DEG2RAD ))
@@ -79,33 +87,43 @@ module GeoRuby
         lambdaP = 2 * Math::PI
         iterLimit = 20
 
-        while (lambda-lambdaP).abs > 1e-12 && --iterLimit>0
+        while (lambda - lambdaP).abs > 1e-12 && --iterLimit > 0
           sinLambda = Math.sin(lambda)
           cosLambda = Math.cos(lambda)
-          sinSigma = Math.sqrt((cosU2*sinLambda) * (cosU2*sinLambda) + (cosU1*sinU2-sinU1*cosU2*cosLambda) * (cosU1*sinU2-sinU1*cosU2*cosLambda))
+          sinSigma  =\
+          Math.sqrt((cosU2 * sinLambda) * (cosU2 * sinLambda) +
+                    (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) *
+                    (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda))
 
-          return 0 if sinSigma == 0 #coincident points
+          return 0 if sinSigma == 0 # coincident points
 
-          cosSigma = sinU1*sinU2 + cosU1*cosU2*cosLambda
-          sigma = Math.atan2(sinSigma, cosSigma)
-          sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma
-          cosSqAlpha = 1 - sinAlpha*sinAlpha
-          cos2SigmaM = cosSigma - 2*sinU1*sinU2/cosSqAlpha
+          cosSigma   = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda
+          sigma      = Math.atan2(sinSigma, cosSigma)
+          sinAlpha   = cosU1 * cosU2 * sinLambda / sinSigma
+          cosSqAlpha = 1 - sinAlpha * sinAlpha
+          cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha
 
-          cos2SigmaM = 0 if (cos2SigmaM.nan?) #equatorial line: cosSqAlpha=0
+          # equatorial line: cosSqAlpha=0
+          cos2SigmaM = 0 if (cos2SigmaM.nan?)
 
-          c = f/16*cosSqAlpha*(4+f*(4-3*cosSqAlpha))
+          c = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha))
           lambdaP = lambda
-          lambda = l + (1-c) * f * sinAlpha * (sigma + c * sinSigma * (cos2SigmaM + c * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)))
+          lambda = l + (1 - c) * f * sinAlpha * (sigma + c * sinSigma *
+            (cos2SigmaM + c * cosSigma * (-1 + 2 * cos2SigmaM *
+                cos2SigmaM)))
         end
+
         return NaN if iterLimit==0 #formula failed to converge
 
         uSq = cosSqAlpha * (a*a - b*b) / (b*b)
         a_bis = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)))
-        b_bis = uSq/1024 * (256+uSq*(-128+uSq*(74-47*uSq)))
-        deltaSigma = b_bis * sinSigma*(cos2SigmaM + b_bis/4*(cosSigma*(-1+2*cos2SigmaM*cos2SigmaM)- b_bis/6*cos2SigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2SigmaM*cos2SigmaM)))
+        b_bis = uSq/1024 * (256+uSq*(-128 + uSq * (74 - 47 * uSq)))
+        deltaSigma = b_bis * sinSigma * (cos2SigmaM + b_bis / 4 *
+          (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - b_bis / 6 *
+            cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 *
+              cos2SigmaM * cos2SigmaM)))
 
-        b*a_bis*(sigma-deltaSigma)
+        b * a_bis * (sigma - deltaSigma)
       end
 
       # Orthogonal Distance
@@ -120,13 +138,14 @@ module GeoRuby
         return 0.0 if len.zero?
         res = dot / len
 
-        xx, yy = if res < 0
-                   [head.x, head.y]
-                 elsif res > 1
-                   [tail.x, tail.y]
-                 else
-                   [head.x + res * c, head.y + res * d]
-                 end
+        xx, yy =\
+        if res < 0
+          [head.x, head.y]
+        elsif res > 1
+          [tail.x, tail.y]
+        else
+          [head.x + res * c, head.y + res * d]
+        end
         # todo benchmark if worth creating an instance
         # euclidian_distance(Point.from_x_y(xx, yy))
         Math.sqrt((@x - xx) ** 2 + (@y - yy) ** 2)
@@ -158,10 +177,10 @@ module GeoRuby
 
       # Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
-        unless with_z
-          [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)]
-        else
+        if with_z
           [Point.from_x_y_z(@x,@y,@z),Point.from_x_y_z(@x,@y,@z)]
+        else
+          [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)]
         end
       end
 
@@ -172,14 +191,14 @@ module GeoRuby
       # Tests the equality of the position of points + m
       def ==(other)
         return false unless other.kind_of?(Point)
-        @x == other.x and @y == other.y and @z == other.z and @m == other.m
+        @x == other.x && @y == other.y && @z == other.z && @m == other.m
       end
 
       # Binary representation of a point. It lacks some headers to be a valid EWKB representation.
       def binary_representation(allow_z=true,allow_m=true) #:nodoc:
-        bin_rep = [@x.to_f,@y.to_f].pack("EE")
-        bin_rep += [@z.to_f].pack("E") if @with_z and allow_z #Default value so no crash
-        bin_rep += [@m.to_f].pack("E") if @with_m and allow_m #idem
+        bin_rep = [@x.to_f,@y.to_f].pack('EE')
+        bin_rep += [@z.to_f].pack('E') if @with_z && allow_z #Default value so no crash
+        bin_rep += [@m.to_f].pack('E') if @with_m && allow_m #idem
         bin_rep
       end
 
@@ -191,14 +210,14 @@ module GeoRuby
       # Text representation of a point
       def text_representation(allow_z=true,allow_m=true) #:nodoc:
         tex_rep = "#{@x} #{@y}"
-        tex_rep += " #{@z}" if @with_z and allow_z
-        tex_rep += " #{@m}" if @with_m and allow_m
+        tex_rep += " #{@z}" if @with_z && allow_z
+        tex_rep += " #{@m}" if @with_m && allow_m
         tex_rep
       end
 
       # WKT geometry type of a point
       def text_geometry_type #:nodoc:
-        "POINT"
+        'POINT'
       end
 
       # georss simple representation
@@ -223,9 +242,12 @@ module GeoRuby
         out += "</#{gml_ns}:pos>\n</#{gml_ns}:Point>\n</#{georss_ns}:where>\n"
       end
 
-      # outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
-      # <tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
-      # it won't be used by GE anyway: clampToGround is the default)
+      # outputs the geometry in kml format : options are
+      # <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
+      # <tt>:altitude_mode</tt>.
+      # If the altitude_mode option is not present, the Z (if present)
+      # will not be output (since it won't be used by GE anyway:
+      # clampToGround is the default)
       def kml_representation(options = {}) #:nodoc:
         out = "<Point#{options[:id_attr]}>\n"
         out += options[:geom_data] if options[:geom_data]
@@ -237,10 +259,10 @@ module GeoRuby
 
       def html_representation(options = {})
         options[:coord] = true if options[:coord].nil?
-        out =  "<span class='geo'>"
+        out =  '<span class=\'geo\'>'
         out += "<abbr class='latitude' title='#{x}'>#{as_lat(options)}</abbr>"
         out += "<abbr class='longitude' title='#{y}'>#{as_long(options)}</abbr>"
-        out += "</span>"
+        out += '</span>'
       end
 
       # Human representation of the geom, don't use directly, use:
@@ -249,12 +271,12 @@ module GeoRuby
         g.map do |k, v|
           deg = v.to_i.abs
           min = (60 * (v.abs - deg)).to_i
-          labs = (v * 1000000).abs / 1000000
-          sec = ((((labs - labs.to_i) * 60) - ((labs - labs.to_i) * 60).to_i) * 100000) * 60 / 100000
+          labs = (v * 1_000_000).abs / 1_000_000
+          sec = ((((labs - labs.to_i) * 60) - ((labs - labs.to_i) * 60).to_i) * 100_000) * 60 / 100_000
           str = options[:full] ? "%.i°%.2i′%05.2f″" :  "%.i°%.2i′%02.0f″"
           if options[:coord]
             out = str % [deg,min,sec]
-            out += k == :x ? v > 0 ? "N" : "S" : v > 0 ? "E" : "W"
+            out += k == :x ? v > 0 ? 'N' : 'S' : v > 0 ? 'E' : 'W'
           else
             str % [v.to_i, min, sec]
           end
@@ -277,7 +299,7 @@ module GeoRuby
       # Outputs the geometry in coordinates format:
       # 47°52′48″, -20°06′00″
       def as_latlong(options = {})
-        human_representation(options).join(", ")
+        human_representation(options).join(', ')
       end
       alias :as_ll :as_latlong
 
@@ -286,9 +308,11 @@ module GeoRuby
       # http://www.engineeringtoolbox.com/converting-cartesian-polar-coordinates-d_1347.html
       # http://rcoordinate.rubyforge.org/svn/point.rb
       # outputs radium
-      def r;      Math.sqrt(@x**2 + @y**2);      end
+      def r
+        Math.sqrt(@x**2 + @y**2)
+      end
 
-      # outputs theta
+      # Outputs theta
       def theta_rad
         if @x.zero?
           @y < 0 ? 3 * HALFPI : HALFPI
@@ -298,13 +322,17 @@ module GeoRuby
         end
       end
 
-      # outputs theta in degrees
-      def theta_deg;        theta_rad / DEG2RAD;      end
+      # Outputs theta in degrees
+      def theta_deg
+        theta_rad / DEG2RAD
+      end
 
-      # outputs an array containing polar distance and theta
-      def as_polar;        [r,t];      end
+      # Outputs an array containing polar distance and theta
+      def as_polar
+        [r, t]
+      end
 
-      # invert signal of all coordinates
+      # Invert signal of all coordinates
       def -@
         set_x_y_z(-@x, -@y, -@z)
       end
@@ -312,86 +340,95 @@ module GeoRuby
       # TODO Perhaps should support with_m analogous to from_coordinates?
       def to_coordinates
         if with_z
-          [x,y,z]
+          [x, y, z]
         else
-          [x,y]
+          [x, y]
         end
       end
 
+      # Simple helper for 2D maps
+      def to_xy
+        [x, y]
+      end
+
+      # Simple helper for 3D maps
+      def to_xyz
+        [x, y, z]
+      end
+
       def as_json(options = {})
-        {:type => 'Point',
-         :coordinates => self.to_coordinates}
+        { :type => 'Point', :coordinates => self.to_coordinates }
       end
 
-      # simple geojson representation
+      # Simple geojson representation
       # TODO add CRS / SRID support?
       def to_json(options = {})
         as_json(options).to_json(options)
       end
       alias :as_geojson :to_json
 
-      #creates a point from an array of coordinates
-      def self.from_coordinates(coords,srid=DEFAULT_SRID,with_z=false,with_m=false)
-        if ! (with_z or with_m)
-          from_x_y(coords[0],coords[1],srid)
-        elsif with_z and with_m
-          from_x_y_z_m(coords[0],coords[1],coords[2],coords[3],srid)
+      # Creates a point from an array of coordinates
+      def self.from_coordinates(coords, srid = DEFAULT_SRID, with_z = false, with_m = false)
+        if ! (with_z || with_m)
+          from_x_y(coords[0], coords[1], srid)
+        elsif with_z && with_m
+          from_x_y_z_m(coords[0], coords[1], coords[2], coords[3], srid)
         elsif with_z
-          from_x_y_z(coords[0],coords[1],coords[2],srid)
+          from_x_y_z(coords[0], coords[1], coords[2], srid)
         else
-          from_x_y_m(coords[0],coords[1],coords[2],srid)
+          from_x_y_m(coords[0], coords[1], coords[2], srid)
         end
       end
 
-      #creates a point from the X and Y coordinates
-      def self.from_x_y(x, y, srid=DEFAULT_SRID)
-        point= new(srid)
-        point.set_x_y(x,y)
+      # Creates a point from the X and Y coordinates
+      def self.from_x_y(x, y, srid = DEFAULT_SRID)
+        point = new(srid)
+        point.set_x_y(x, y)
       end
 
-      #creates a point from the X, Y and Z coordinates
-      def self.from_x_y_z(x, y, z, srid=DEFAULT_SRID)
-        point= new(srid,true)
-        point.set_x_y_z(x,y,z)
+      # Creates a point from the X, Y and Z coordinates
+      def self.from_x_y_z(x, y, z, srid = DEFAULT_SRID)
+        point = new(srid, true)
+        point.set_x_y_z(x, y, z)
       end
 
-      #creates a point from the X, Y and M coordinates
-      def self.from_x_y_m(x, y, m, srid=DEFAULT_SRID)
-        point= new(srid,false,true)
-        point.m=m
-        point.set_x_y(x,y)
+      # Creates a point from the X, Y and M coordinates
+      def self.from_x_y_m(x, y, m, srid = DEFAULT_SRID)
+        point = new(srid, false, true)
+        point.m = m
+        point.set_x_y(x, y)
       end
 
-      #creates a point from the X, Y, Z and M coordinates
-      def self.from_x_y_z_m(x, y, z, m, srid=DEFAULT_SRID)
-        point= new(srid,true,true)
-        point.m=m
-        point.set_x_y_z(x,y,z)
+      # Creates a point from the X, Y, Z and M coordinates
+      def self.from_x_y_z_m(x, y, z, m, srid = DEFAULT_SRID)
+        point = new(srid, true, true)
+        point.m = m
+        point.set_x_y_z(x, y, z)
       end
 
-      #creates a point using polar coordinates
-      #r and theta(degrees)
-      def self.from_r_t(r, t, srid=DEFAULT_SRID)
+      # Creates a point using polar coordinates
+      # r and theta(degrees)
+      def self.from_r_t(r, t, srid = DEFAULT_SRID)
         t *= DEG2RAD
         x = r * Math.cos(t)
         y = r * Math.sin(t)
-        point= new(srid)
-        point.set_x_y(x,y)
+        point = new(srid)
+        point.set_x_y(x, y)
       end
 
-      #creates a point using coordinates like 22`34 23.45N
-      def self.from_latlong(lat, lon, srid=DEFAULT_SRID)
-        p = [lat,lon].map do |l|
+      # Creates a point using coordinates like 22`34 23.45N
+      def self.from_latlong(lat, lon, srid = DEFAULT_SRID)
+        p = [lat, lon].map do |l|
           sig, deg, min, sec, cen = l.scan(/(-)?(\d{1,2})\D*(\d{2})\D*(\d{2})(\D*(\d{1,3}))?/).flatten
           sig = true if l =~ /W|S/
           dec = deg.to_i + (min.to_i * 60 + "#{sec}#{cen}".to_f) / 3600
           sig ? dec * -1 : dec
         end
-        point= new(srid)
-        point.set_x_y(p[0],p[1])
+        point = new(srid)
+        point.set_x_y(p[0], p[1])
       end
 
-      #aliasing the constructors in case you want to use lat/lon instead of y/x
+      # Aliasing the constructors in case you like lat/lon instead of y/x
       class << self
         alias :xy               :from_x_y
         alias :from_xy          :from_x_y

data/lib/geo_ruby/version.rb

@@ -1,3 +1,3 @@
 module GeoRuby
-  VERSION = '2.2.0'
+  VERSION = '2.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: georuby
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Guilhem Vellut
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-13 00:00:00.000000000 Z
 dependencies: []
 description: GeoRuby provides geometric data types from the OGC 'Simple Features'
   specification.