terraformer 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27549564ba7d079289298f08d49e921d0ed19441
-  data.tar.gz: 5d621a88f01cd1f7eff842808776a536567ac28f
+  metadata.gz: 49cfd37dcf766f5758e4ed80757e6a966622888c
+  data.tar.gz: fca64a7df1f7dfb8ed2cf00f4ff6be1c8e0ddc5f
 SHA512:
-  metadata.gz: 1629d4a4f49486fb44512a7e37505a7faea5f6ce1352696b49522fea11162ac5cffa15cf6094d1dec6310980caccbe8da8e1e4abf3c731d206f22a2ccee21273
-  data.tar.gz: c697882b6880196f71120edd5dea0eac38a273e98da9989ee9fcf39dd9f32f41b78728213653aa432b16bdc18bd9d02c273ed1af38edbf96e1d839142383a767
+  metadata.gz: 3a5c67c0d1523e77ff65c743f3e148c79387a3f67daf4c60d2a26020c0ede6498a407dce9c5a1d6f0a143966e9dbf017ecc134412c0bbef0abc5ef277fbc5a2f
+  data.tar.gz: 7fcfee079394e072071d604c8f94f58b4eac5fef14e6590546880c66ea17324a32e113c4768e2b5be042db2c7705eed6eaeae2e520acebef138e64b13df5c11f

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 gem 'rake'
 
 group :test do
+  gem 'http'
   gem 'pry'
   gem 'pry-nav'
+  gem 'ruby-prof'
 end

data/lib/ext/array.rb

@@ -0,0 +1,16 @@
+class Array
+
+  def slice_exists? slice
+    start = slice.first
+    len = slice.size
+    each_with_index do |e, i|
+      return true if e == start && self[i,len] == slice
+    end
+    false
+  end
+
+  def to_c
+    Terraformer::Coordinate.from_array self
+  end
+
+end

data/lib/ext/big_decimal.rb

@@ -0,0 +1,12 @@
+class BigDecimal
+
+  def to_deg
+    (self * Terraformer::DEGREES_PER_RADIAN).round Terraformer::PRECISION
+  end
+
+  def to_rad
+    (self * Terraformer::RADIANS_PER_DEGREE).round Terraformer::PRECISION
+  end
+
+end
+

data/lib/ext/big_math.rb

@@ -0,0 +1,36 @@
+module BigMath
+
+  N_ONE = -1.to_d
+  ZERO = 0.to_d
+  ONE = 1.to_d
+  TWO = 2.to_d
+
+  # http://en.wikipedia.org/wiki/Atan2#Definition_and_computation
+  #
+  def self.atan2 y, x, precision
+    case
+    when x > ZERO
+      BigMath.atan((y / x), precision)
+    when y >= ZERO && x < ZERO
+      BigMath.atan((y / x), precision) + Terraformer::PI
+    when y < ZERO && x < ZERO
+      BigMath.atan((y / x), precision) - Terraformer::PI
+    when x == ZERO
+      case
+      when y > ZERO
+        Terraformer::PI / TWO
+      when y < ZERO
+        -(Terraformer::PI / TWO)
+      when y == ZERO
+        BigDecimal::NAN
+      end
+    end
+  end
+
+  # http://en.wikipedia.org/wiki/Trigonometric_functions#Right-angled_triangle_definitions
+  #
+  def self.tan theta, precision
+    BigMath.sin(theta, precision) / BigMath.cos(theta, precision)
+  end
+
+end

data/lib/ext/enumerable.rb

@@ -0,0 +1,79 @@
+module Enumerable
+
+  def each_coordinate opts = {}, &block
+    iter_coordinate :each, opts, &block
+  end
+
+  def map_coordinate opts = {}, &block
+    iter_coordinate :map, opts, &block
+  end
+  alias_method :collect_coordinate, :map_coordinate
+
+  def map_coordinate! opts = {}, &block
+    iter_coordinate :map!, opts, &block
+  end
+  alias_method :collect_coordinate!, :map_coordinate!
+
+  def iter_coordinate meth, opts = {}, &block
+    opts[:recurse] = true if opts[:recurse].nil?
+
+    if Array === self and Numeric === self[0]
+      yield self
+    else
+
+      self.__send__ meth do |pair|
+        raise IndexError unless Array === pair
+        case pair[0]
+        when Numeric
+          yield pair
+        when Array
+          pair.iter_coordinate meth, opts, &block if opts[:recurse]
+        else
+          raise IndexError.new "#{pair[0]} is not a Numeric or Array type"
+        end
+      end
+    end
+  end
+
+  def rotate_until &block
+    return if block[]
+    found = false
+    length.times do
+      push shift
+      if block[]
+        found = true
+        break
+      end
+    end
+    raise IndexError unless found
+  end
+
+  def rotate_until_first_equals obj
+    rotate_until { at(0) == obj }
+  end
+
+  def polygonally_equal_to? obj
+    raise ArgumentError unless Enumerable === obj
+    return false if self.length != obj.length
+
+    equal = true
+
+    # clone so can pop/rotate
+    me = self.clone
+    obj = obj.clone
+
+    # pop to drop the duplicate, polygon-closing, coordinate
+    me.pop
+    obj.pop
+
+    begin
+      obj.rotate_until_first_equals me[0]
+      equal = me == obj
+    rescue IndexError
+      equal = false
+    end
+
+    equal
+  end
+
+end

data/lib/ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+
+  unless instance_methods.include? :only
+    # same as select_with_keys without forcing `Symbol` usage
+    #
+    def only *ks
+      ks = ks.compact.uniq
+      select {|k,v| ks.include? k}
+    end
+  end
+
+  unless instance_methods.include? :not
+    # same as select_without_keys without forcing `Symbol` usage
+    #
+    def not *ks
+      ks = ks.compact.uniq
+      select {|k,v| !ks.include? k}
+    end
+  end
+
+end

data/lib/terraformer/bounds.rb

@@ -5,7 +5,7 @@ module Terraformer
 
       def bounds obj, format = :bbox
 
-        obj = Terraformer.parse obj unless Primitive === obj
+        obj = Terraformer.parse obj unless Geometry === obj
 
         bbox = case obj.type
                when 'Point'
@@ -33,6 +33,8 @@ module Terraformer
 
         case format
         when :bbox
+          # yikes!
+          bbox.extend BBox
           bbox
         when :polygon
           Polygon.new [[bbox[0], bbox[1]],
@@ -51,7 +53,7 @@ module Terraformer
             bounds_for_array a, (nesting - 1), b
           end
         else
-          array.reduce box do |b, lonlat|
+          bbox = array.reduce box do |b, lonlat|
             lon, lat = *lonlat
             set = ->(d, i, t){ b[i] = d if b[i].nil? or d.send(t, b[i]) }
             set[lon, X1, :<]
@@ -60,6 +62,9 @@ module Terraformer
             set[lat, Y2, :>]
             b
           end
+          # yikes!
+          bbox.extend BBox
+          bbox
         end
       end
 

data/lib/terraformer/circle.rb

@@ -0,0 +1,50 @@
+module Terraformer
+  class Circle
+    extend Forwardable
+
+    attr_accessor :polygon
+    attr_reader :center, :radius, :resolution
+    def_delegators :@polygon, :contains?, :within?, :intersects?, :to_feature, :to_json
+
+    def initialize c, r, res = DEFAULT_BUFFER_RESOLUTION
+      self.center = c
+      self.radius = r
+      self.resolution = res
+      recalculate
+    end
+
+    def recalculate
+      @polygon = @center.buffer @radius, @resolution
+      @dirty = false
+      self
+    end
+
+    def center= c
+      c = Coordinate.from_array c if Array === c and Numeric === c[0]
+      c = c.coordinates if Point === c
+      raise ArgumentError unless Coordinate === c
+      @center = c
+      @dirty = true
+      self
+    end
+
+    def radius= r
+      raise ArgumentError unless Numeric === r
+      @radius = r
+      @dirty = true
+      self
+    end
+
+    def resolution= res
+      raise ArgumentError unless Fixnum === res
+      @resolution = res
+      @dirty = true
+      self
+    end
+
+    def dirty?
+      @dirty
+    end
+
+  end
+end

data/lib/terraformer/convex_hull.rb

@@ -0,0 +1,92 @@
+module Terraformer
+  module ConvexHull
+
+    DEFAULT_IMPL = :monotone
+
+    class << self
+
+      attr_accessor :impl
+
+      def test
+        require 'ruby-prof'
+        wc = Terraformer.parse 'test/examples/waldocanyon.geojson'
+        RubyProf.start
+        wc.convex_hull
+        result = RubyProf.stop
+        printer = RubyProf::FlatPrinter.new(result)
+        printer.print(STDOUT)
+        # printer = RubyProf::GraphPrinter.new(result)
+        # printer.print(STDOUT, {})
+      end
+
+      def for points
+        hull = __send__ @impl || DEFAULT_IMPL, flatten_coordinates_from(points)
+        if hull.length == 1
+          Point.new hull[0]
+        else
+          Polygon.new hull
+        end
+      end
+
+      private
+
+      def flatten_coordinates_from points
+        cs = []
+        points.each_coordinate {|c| cs << c}
+        cs.sort!.uniq!
+        cs
+      end
+
+      # http://tixxit.wordpress.com/2009/12/09/jarvis-march/
+      #
+      def turn p, q, r
+        ((q[0] - p[0]) * (r[1] - p[1]) - (r[0] - p[0]) * (q[1] - p[1])) <=> BigMath::ZERO
+      end
+
+      def next_point points, p
+        q = p
+        points.each do |r|
+          t = turn p, q, r
+          q = r if t == BigMath::N_ONE or t == BigMath::ZERO &&
+            p.squared_euclidean_distance_to(r) > p.squared_euclidean_distance_to(q)
+        end
+        q
+      end
+
+      def jarvis_march points
+        return points if points.length < 3
+        hull = [points.sort[0]]
+        hull.each do |p|
+          q = next_point points, p
+          hull << q if q != hull[0]
+        end
+        hull << hull[0]
+        hull
+      end
+
+      # http://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain#Ruby
+      #
+      def cross o, a, b
+        (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0])
+      end
+
+      def monotone points
+        return points if points.length < 3
+        lower = Array.new
+        points.each{|p|
+          while lower.length > 1 and cross(lower[-2], lower[-1], p) <= 0 do lower.pop end
+          lower.push(p)
+        }
+        upper = Array.new
+        points.reverse_each{|p|
+          while upper.length > 1 and cross(upper[-2], upper[-1], p) <= 0 do upper.pop end
+          upper.push(p)
+        }
+        hull = lower[0...-1] + upper[0...-1]
+        hull << hull[0]
+      end
+
+    end
+  end
+end
+

data/lib/terraformer/coordinate.rb

@@ -2,6 +2,10 @@ module Terraformer
 
   class Coordinate < ::Array
 
+    # http://en.wikipedia.org/wiki/Earth_radius#Mean_radius
+    #
+    EARTH_MEAN_RADIUS = 6371009.to_d
+
     attr_accessor :crs
 
     class << self
@@ -17,24 +21,26 @@ module Terraformer
       def big_decimal n
         case n
         when String
-          BigDecimal.new n
+          BigDecimal(n)
         when BigDecimal
           n
         when Numeric
-          n.to_d
+          BigDecimal(n.to_s)
+        else
+          raise ArgumentError
         end
       end
 
     end
 
-    def initialize _x, _y = nil, _z = nil, _m = nil
-      super 4
-      case _x
-      when Array
+    def initialize _x, _y = nil, _z = nil
+      super 3
+      case
+      when Array === _x
         raise ArgumentError if _y
         self.x = _x[0]
         self.y = _x[1]
-      when Numeric
+      when Numeric === _x || String === _x
         raise ArgumentError unless _y
         self.x = _x
         self.y = _y
@@ -63,11 +69,7 @@ module Terraformer
       self[2]
     end
 
-    def m
-      self[3]
-    end
-
-    [:z=, :m=, :<<, :+ , :-, :*, :&, :|].each do |sym|
+    [:z=, :<<, :*, :&, :|].each do |sym|
       define_method(sym){|*a| raise NotImplementedError }
     end
 
@@ -78,7 +80,7 @@ module Terraformer
         (Math::PI / 2).to_d -
         (2 * BigMath.atan(BigMath.exp(-1.0 * y / EARTH_RADIUS, PRECISION), PRECISION))
       ).to_deg
-      geog = self.class.new _x, _y
+      geog = self.class.new _x.round(PRECISION), _y.round(PRECISION)
       geog.crs = GEOGRAPHIC_CRS
       geog
     end
@@ -87,13 +89,21 @@ module Terraformer
       _x = x.to_rad * EARTH_RADIUS
       syr = BigMath.sin y.to_rad, PRECISION
       _y = (EARTH_RADIUS / 2.0) * BigMath.log((1.0 + syr) / (1.0 - syr), PRECISION)
-      merc = self.class.new _x, _y
+      merc = self.class.new _x.round(PRECISION), _y.round(PRECISION)
       merc.crs = MERCATOR_CRS
       merc
     end
 
+    def to_s
+      [x,y,z].compact.join ','
+    end
+
     def to_json *args
-      [x, y, z, m].map! {|e| e.nil? ? nil : e.to_f}.compact.to_json(*args)
+      [x, y, z].map! {|e| e.to_f if e}.compact.to_json(*args)
+    end
+
+    def to_point
+      Point.new self
     end
 
     def geographic?
@@ -115,6 +125,85 @@ module Terraformer
       Polygon.new(coordinates).to_geographic
     end
 
+    def <=> other
+      raise ArgumentError unless Coordinate === other
+      dx = x - other.x
+      dy = y - other.y
+      case
+      when dx > dy; 1
+      when dx < dy; -1
+      else;         0
+      end
+    end
+
+    def arithmetic operator, obj
+      case obj
+      when Array
+        _x = self.x.__send__ operator, obj[0] if obj[0]
+        _y = self.y.__send__ operator, obj[1] if obj[1]
+        Coordinate.new((_x || x), (_y || y))
+      else
+        raise NotImplementedError
+      end
+    end
+    private :arithmetic
+
+    def + obj
+      arithmetic :+, obj
+    end
+
+    def - obj
+      arithmetic :-, obj
+    end
+
+    def squared_euclidean_distance_to obj
+      raise ArgumentError unless Coordinate === obj
+      dx = obj.x - x
+      dy = obj.y - y
+      dx * dx + dy * dy
+    end
+
+    def euclidean_distance_to obj
+      BigMath.sqrt squared_euclidean_distance_to(obj), PRECISION
+    end
+
+    def haversine_distance_to other
+      raise ArgumentError unless Coordinate === other
+
+      d_lat = (self.y - other.y).to_rad
+      d_lon = (self.x - other.x).to_rad
+
+      lat_r = self.y.to_rad
+      other_lat_r = other.y.to_rad
+
+      a = BigMath.sin(d_lat / 2, PRECISION)**2 +
+          BigMath.sin(d_lon / 2, PRECISION)**2 *
+          BigMath.cos(lat_r, PRECISION) * BigMath.cos(other_lat_r, PRECISION)
+
+      y = BigMath.sqrt a, PRECISION
+      x = BigMath.sqrt (1 - a), PRECISION
+      c = 2 * BigMath.atan2(y, x, PRECISION)
+
+      c * EARTH_MEAN_RADIUS
+    end
+
+    def distance_and_bearing_to obj
+      raise ArgumentError unless Coordinate === obj
+      Geodesic.compute_distance_and_bearing y, x, obj.y, obj.x
+    end
+
+    def distance_to obj
+      distance_and_bearing_to(obj)[:distance]
+    end
+
+    def initial_bearing_to obj
+      distance_and_bearing_to(obj)[:bearing][:initial]
+    end
+
+    def final_bearing_to obj
+      distance_and_bearing_to(obj)[:bearing][:final]
+    end
+
   end
 
 end

data/lib/terraformer/feature.rb

@@ -1,10 +1,13 @@
 module Terraformer
 
   class Feature < Primitive
+    extend Forwardable
 
     attr_accessor :id, :geometry
     attr_writer :properties
 
+    def_delegator :@geometry, :convex_hull
+
     def initialize *args
       unless args.empty?
         super *args do |arg|
@@ -29,12 +32,24 @@ module Terraformer
       h
     end
 
+    def great_circle_distance other
+      other = other.geometry if Feature === other
+      self.geometry.great_circle_distance other
+    end
+
   end
 
   class FeatureCollection < Primitive
 
     attr_writer :features
 
+    def self.with_features *f
+      raise ArgumentError unless f.all? {|e| Feature === e}
+      fc = FeatureCollection.new
+      fc.features = f
+      fc
+    end
+
     def initialize *args
       unless args.empty?
         super *args do |arg|
@@ -47,6 +62,11 @@ module Terraformer
       @features ||= []
     end
 
+    def << feature
+      raise ArgumentError unless Feature === feature
+      features << feature
+    end
+
     def to_hash
       {
         type: type,
@@ -54,6 +74,10 @@ module Terraformer
       }
     end
 
+    def convex_hull
+      ConvexHull.for features.map(&:geometry).map(&:coordinates)
+    end
+
   end
 
 end