route_boxer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c13179907ea808fe1843c087608df116f773eb6d
+  data.tar.gz: 4c138435eff6ced2d30ac2fd235242fc487fb3ae
+SHA512:
+  metadata.gz: 23a097f08acd1fe0553b0ee4ccda115300a95c0800678c99d2144cb0cab8c442a5d4b3b13e3dff1c37c487b9d826003c8684b28537a2bd51e6959db052e527e4
+  data.tar.gz: 2bb58a402165025c47c5cecc0a28beaf6f68f1757c7c8fd6b6f28cc014dbd724fa0d0b225a7428b6b533dd86a0ef3f7ad31a75258faa0c060121fb45f3a93aaf

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in route_boxer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sebastian Badura
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# RouteBoxer
+
+Ruby implementation of Google RouteBoxer
+
+http://google-maps-utility-library-v3.googlecode.com/svn/trunk/routeboxer/src/RouteBoxer.js
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'route_boxer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install route_boxer
+
+## Usage
+
+1. Get route with Google Directions API:
+```ruby
+    results = JSON.parse(open("http://maps.googleapis.com/maps/api/directions/json?alternative=true&destination=Warsaw&language=en&mode=driving&origin=Cracow&sensor=false").read)
+```
+2. Decode response to LatLng points with 'polylines' gem:
+```ruby    
+    points = Polylines::Decoder.decode_polyline(result["routes"][0]["overview_polyline"]["points"])
+```
+3. Parse points to RouteBoxer::LatLng objects:
+```ruby
+   points = points.map { |p| RouteBoxer::LatLng.new(p[0], p[1])}
+```
+4. Use RouteBoxer to get 'boxed' route:
+```ruby
+   RouteBoxer::Core.new.box(points, 10)
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/route_boxer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/route_boxer.rb

@@ -0,0 +1,16 @@
+require "route_boxer/version"
+
+require "route_boxer/lat_lng"
+require "route_boxer/lat_lng_collection"
+require "route_boxer/lat_lng_bounds"
+require "route_boxer/core"
+
+module RouteBoxer
+  def deg2rad(deg)
+    deg * Math::PI / 180
+  end
+
+  def rad2deg(rad)
+    rad * 180 / Math::PI
+  end
+end

data/lib/route_boxer/core.rb

@@ -0,0 +1,312 @@
+module RouteBoxer
+  class Core
+    include RouteBoxer
+    R = 6371
+
+    attr_accessor :grid, :lat_grid, :lng_grid, :boxes_x, :boxes_y
+
+    def initialize
+      @lat_grid = []
+      @lng_grid = []
+      @boxes_x = []
+      @boxes_y = []
+    end
+
+    def box(collection, range)
+      vertices = collection.to_a
+      @grid = build_grid(vertices, range)
+
+      find_intersecting_cells(vertices)
+      merge_intersecting_cells
+
+      return (@boxes_x.length <= @boxes_y.length ? @boxes_x : @boxes_y)
+    end
+
+  private
+
+    def build_grid(vertices, range)
+      route_bounds = RouteBoxer::LatLngBounds.new
+      vertices.each do |v|
+        route_bounds.extend(v)
+      end
+
+      route_bounds_center = route_bounds.get_center
+      @lat_grid << route_bounds_center.lat
+      @lat_grid << route_bounds_center.rhumb_destination_point(0, range, R).lat
+
+      i = 2
+      while @lat_grid[i - 2] < route_bounds.get_north_east.lat
+        @lat_grid << route_bounds_center.rhumb_destination_point(0, range * i, R).lat
+        i += 1
+      end
+
+      i = 1
+      while @lat_grid[1] > route_bounds.get_south_west.lat
+        @lat_grid.unshift(route_bounds_center.rhumb_destination_point(180, range * i, R).lat)
+        i += 1
+      end
+
+      @lng_grid << route_bounds_center.lng
+      @lng_grid << route_bounds_center.rhumb_destination_point(90, range, R).lng
+
+      i = 2
+      while @lng_grid[i - 2] < route_bounds.get_north_east.lng
+        @lng_grid << route_bounds_center.rhumb_destination_point(90, range * i, R).lng
+        i += 1
+      end
+
+      i = 1
+      while @lng_grid[1] > route_bounds.get_south_west.lng
+        @lng_grid.unshift(route_bounds_center.rhumb_destination_point(270, range * i, R).lng)
+        i += 1
+      end
+
+      lng_grid_length = @lng_grid.length
+      lat_grid_length = @lat_grid.length
+
+      grid = create_empty_array(lng_grid_length)
+
+      i = 0
+      while i < grid.length
+        grid[i] = create_empty_array(lat_grid_length)
+        i += 1
+      end
+
+      grid
+    end
+
+    def create_empty_array(length)
+      [nil] * length
+    end
+
+    def find_intersecting_cells(vertices)
+      hint_xy = get_cell_coords(vertices[0])
+      mark_cell(hint_xy)
+
+      i = 1
+      while i < vertices.length
+        grid_xy = get_grid_coords_from_hint(vertices[i], vertices[i - 1], hint_xy)
+
+        if grid_xy[0] == hint_xy[0] && grid_xy[1] == hint_xy[1]
+          i += 1
+          next
+        elsif (((hint_xy[0] - grid_xy[0]).abs == 1 && hint_xy[1] == grid_xy[1]) || (hint_xy[0] == grid_xy[0] && (hint_xy[1] - grid_xy[1]).abs == 1))
+          mark_cell(grid_xy)
+        else
+          get_grid_intersects(vertices[i - 1], vertices[i], hint_xy, grid_xy)
+        end
+
+        hint_xy = grid_xy
+        i += 1
+      end
+    end
+
+    def get_cell_coords(latlng)
+      x = 0
+      while @lng_grid[x] < latlng.lng
+        x += 1
+      end
+
+      y = 0
+      while @lat_grid[y] < latlng.lat
+        y += 1
+      end
+
+      [x - 1, y - 1]
+    end
+
+    def get_grid_coords_from_hint(latlng, hint_latlng, hint)
+      x = nil
+      y = nil
+
+      if latlng.lng > hint_latlng.lng
+        x = hint[0]
+        while @lng_grid[x + 1] < latlng.lng
+          x += 1
+        end
+      else
+        x = hint[0]
+        while @lng_grid[x] > latlng.lng
+          x -= 1
+        end
+      end
+
+      if latlng.lat > hint_latlng.lat
+        y = hint[1]
+        while @lat_grid[y + 1] < latlng.lat
+          y += 1
+        end
+      else
+        y = hint[1]
+        while @lat_grid[y] > latlng.lat
+          y -= 1
+        end
+      end
+
+      [x, y]
+    end
+
+    def get_grid_intersects(start, stop, start_xy, stop_xy)
+      brng = start.rhumb_bearing_to(stop)
+      hint = start
+      hint_xy = start_xy
+
+      if stop.lat > start.lat
+        i = start_xy[1] + 1
+        while i <= stop_xy[1]
+          edge_point = get_grid_intersect(start, brng, @lat_grid[i])
+          edge_xy = get_grid_coords_from_hint(edge_point, hint, hint_xy)
+          fill_in_grid_squares(hint_xy[0], edge_xy[0], i - 1)
+          hint = edge_point
+          hint_xy = edge_xy
+          i += 1
+        end
+
+        fill_in_grid_squares(hint_xy[0], stop_xy[0], i - 1)
+      else
+        i = start_xy[1]
+        while i > stop_xy[1]
+          edge_point = get_grid_intersect(start, brng, @lat_grid[i])
+          edge_xy = get_grid_coords_from_hint(edge_point, hint, hint_xy)
+          fill_in_grid_squares(hint_xy[0], edge_xy[0], i)
+          hint = edge_point
+          hint_xy = edge_xy
+          i -= 1
+        end
+
+        fill_in_grid_squares(hint_xy[0], stop_xy[0], i)
+      end
+    end
+
+    def get_grid_intersect(start, brng, grid_line_lat)
+      d = R * ((deg2rad(grid_line_lat) - deg2rad(start.lat))) / Math.cos(deg2rad(brng))
+      start.rhumb_destination_point(brng, d)
+    end
+
+    def fill_in_grid_squares(start_x, stop_x, y)
+      if start_x < stop_x
+        x = start_x
+        while x <= stop_x
+          mark_cell([x, y])
+          x += 1
+        end
+      else
+        x = start_x
+        while x >= stop_x
+          mark_cell([x, y])
+          x -= 1
+        end
+      end
+    end
+
+    def mark_cell(cell)
+      x = cell[0]
+      y = cell[1]
+      @grid[x - 1][y - 1] = 1
+      @grid[x][y - 1] = 1
+      @grid[x + 1][y - 1] = 1
+      @grid[x - 1][y] = 1
+      @grid[x][y] = 1
+      @grid[x + 1][y] = 1
+      @grid[x - 1][y + 1] = 1
+      @grid[x][y + 1] = 1
+      @grid[x + 1][y + 1] = 1
+      @grid
+    end
+
+    def merge_intersecting_cells
+      current_box = nil
+
+      y = 0
+      while y < @grid[0].length
+        x = 0
+        while x < @grid.length
+          if @grid[x][y]
+            box = get_cell_bounds([x, y])
+            if current_box
+              current_box.extend(box.get_north_east)
+            else
+              current_box = box
+            end
+          else
+            merge_boxes_y(current_box)
+            current_box = nil
+          end
+
+          x += 1
+        end
+
+        merge_boxes_y(current_box)
+        current_box = nil
+
+        y += 1
+      end
+
+      x = 0
+
+      while x < @grid.length
+        y = 0
+        while y < @grid[0].length
+          if @grid[x][y]
+            if current_box
+              box = get_cell_bounds([x, y])
+              current_box.extend(box.get_north_east)
+            else
+              current_box = get_cell_bounds([x, y])
+            end
+          else
+            merge_boxes_x(current_box)
+            current_box = nil
+          end
+          y += 1
+        end
+
+        merge_boxes_x(current_box)
+        current_box = nil
+
+        x += 1
+      end
+    end
+
+    def merge_boxes_x(box)
+      if box != nil
+        i = 0
+        while i < @boxes_x.length
+          if @boxes_x[i].get_north_east.lng == box.get_south_west.lng &&
+              @boxes_x[i].south_west.lat == box.south_west.lat &&
+              @boxes_x[i].get_north_east.lat == box.get_north_east.lat
+
+            @boxes_x[i].extend(box.get_north_east)
+            return
+          end
+          i += 1
+        end
+        @boxes_x << box
+      end
+    end
+
+    def merge_boxes_y(box)
+      if box != nil
+        i = 0
+        while i < @boxes_y.length
+          if @boxes_y[i].get_north_east.lat == box.get_south_west.lat &&
+              @boxes_y[i].get_south_west.lng == box.get_south_west.lng &&
+              @boxes_y[i].get_north_east.lng == box.get_north_east.lng
+
+            @boxes_y[i].extend(box.get_north_east)
+            return
+          end
+
+          i += 1
+        end
+        @boxes_y << box
+      end
+    end
+
+    def get_cell_bounds(cell)
+      south_west = RouteBoxer::LatLng.new(@lat_grid[cell[1]], @lng_grid[cell[0]])
+      north_east = RouteBoxer::LatLng.new(@lat_grid[cell[1] + 1], @lng_grid[cell[0] + 1])
+      return RouteBoxer::LatLngBounds.new(south_west, north_east)
+    end
+  end
+end

data/lib/route_boxer/lat_lng.rb

@@ -0,0 +1,81 @@
+module RouteBoxer
+  class LatLng
+    include RouteBoxer
+    attr_accessor :lat, :lng
+
+    alias_method :latitude, :lat
+    alias_method :latitude=, :lat=
+
+    alias_method :longitude, :lng
+    alias_method :longitude=, :lng=
+
+    def initialize(lat = nil, lng = nil)
+      lat = lat.to_f if lat && !lat.is_a?(Numeric)
+      lng = lng.to_f if lng && !lng.is_a?(Numeric)
+      @lat = lat
+      @lng = lng
+    end
+
+    def lat=(lat)
+      @lat = lat.to_f if lat
+    end
+
+    def lng=(lng)
+      @lng = lng.to_f if lng
+    end
+
+    def ll
+      "#{lat},#{lng}"
+    end
+
+    def to_a
+      [lat, lng]
+    end
+
+    def equals(other)
+      lat == other.lat && lng == other.lng
+    end
+
+    def rhumb_destination_point(brng, dist, r = 6378137)
+      d = dist / r.to_f
+
+      brng = deg2rad(brng)
+      lat1 = deg2rad(lat)
+      lng1 = deg2rad(lng)
+
+      dLat = d * Math.cos(brng)
+      dLat = 0 if dLat.abs < 1e-10
+
+      lat2 = lat1 + dLat
+      dPhi = Math.log(Math.tan(lat2 / 2.0 + Math::PI / 4.0) / Math.tan(lat1 / 2.0 + Math::PI / 4.0))
+      q = (dPhi != 0) ? dLat / dPhi.to_f : Math.cos(lat1)
+      dLon = d * Math.sin(brng) / q
+
+      if lat2.abs > (Math::PI / 2.0)
+        lat2 = lat2 > 0 ? Math::PI - lat2 : -Math::PI - lat2
+      end
+
+      lng2 = (lng1 + dLon + 3 * Math::PI) % (2 * Math::PI) - Math::PI
+      lat2 = rad2deg(lat2)
+      lng2 = rad2deg(lng2)
+
+      LatLng.new(lat2, lng2)
+    end
+
+    def rhumb_bearing_to(dest)
+      dLon = deg2rad(dest.lng - lng)
+      dPhi = Math.log(Math.tan(deg2rad(dest.lat) / 2 + Math::PI / 4) / Math.tan(deg2rad(lat) / 2 + Math::PI / 4))
+
+      if dLon.abs > Math::PI
+        dLon = dLon > 0 ? - (2 * Math::PI - dLon) : (2 * Math::PI + dLon)
+      end
+
+      to_brng(Math.atan2(dLon, dPhi))
+    end
+
+    def to_brng(number)
+      (rad2deg(number) + 360) % 360
+    end
+
+  end
+end

data/lib/route_boxer/lat_lng_bounds.rb

@@ -0,0 +1,105 @@
+module RouteBoxer
+  class LatLngBounds
+    attr_accessor :south_west, :north_east
+
+    def initialize(south_west = nil, north_east = nil)
+      @south_west = south_west
+      @north_east = north_east
+    end
+
+    def contains(point)
+      if @south_west.lat > point.lat || point.lat > @north_east.lat
+        return false
+      end
+
+      return contains_lng(point.lng)
+    end
+
+    def contains_lng(lng)
+      if crosses_antimeridian
+        return lng <= @north_east.lng || lng >= @south_west.lng
+      else
+        return @south_west.lng <= lng && lng <= @north_east.lng
+      end
+    end
+
+    def equals(other)
+      south_west.equals(other.south_west) && north_east.equals(other.north_east)
+    end
+
+    def extend(point)
+      if @north_east != nil
+        new_south = [@south_west.lat, point.lat].min
+        new_north = [@north_east.lat, point.lat].max
+        new_west = @south_west.lng
+        new_east = @north_east.lng
+
+        if ! contains_lng(point.lng)
+          extend_east_lng_span = lng_span(new_west, point.lng)
+          extend_west_lng_span = lng_span(point.lng, new_east)
+
+          if extend_east_lng_span <= extend_west_lng_span
+            new_east = point.lng
+          else
+            new_west = point.lng
+          end
+        end
+
+        @south_west = RouteBoxer::LatLng.new(new_south, new_west)
+        @north_east = RouteBoxer::LatLng.new(new_north, new_east)
+      else
+        @south_west = @north_east = point
+      end
+
+      self
+    end
+
+    def lng_span(west, east)
+      (west > east) ? (east + 360 - west) : (east - west)
+    end
+
+    def get_center
+      if crosses_antimeridian
+        span = lng_span(@south_west.lng, @north_east.lng)
+        lng = normalize_lng(@south_west.lng + span / 2)
+      else
+        lng = (@south_west.lng + @north_east.lng) / 2
+      end
+
+      RouteBoxer::LatLng.new((@south_west.lat + @north_east.lat) / 2, lng)
+    end
+
+    def crosses_antimeridian
+      @south_west.lng > @north_east.lng
+    end
+
+    def get_north_east
+      @north_east
+    end
+
+    def get_south_west
+      @south_west
+    end
+
+    def union(bounds)
+      extend_by_lat_lng(bounds.get_south_west)
+      extend_by_lat_lng(bounds.get_north_east)
+      self
+    end
+
+    def to_span
+      RouteBoxer::LatLng.new(@north_east.lat - @south_west.lat, lng_span(@south_west.lng, @north_east.lng))
+    end
+
+    def normalize_lng(lng)
+      mod = lng % 360
+
+      if mod == 180
+        return 180
+      end
+
+      return mod < -180 ? mod + 360 : (mod > 180 ? mod - 360 : mod)
+    end
+
+  end
+end

data/lib/route_boxer/lat_lng_collection.rb

@@ -0,0 +1,24 @@
+module RouteBoxer
+  class LatLngCollection
+    attr_accessor :points
+
+    def initialize(points)
+      @points = points
+    end
+
+    def to_a
+      collection = []
+
+      @points.each do |point|
+        unless point.is_a?(RouteBoxer::LatLng)
+          point = RouteBoxer::LatLng.new(point[0], point[1])
+        end
+
+        collection << point
+      end
+
+      collection
+    end
+
+  end
+end

data/lib/route_boxer/version.rb

@@ -0,0 +1,3 @@
+module RouteBoxer
+  VERSION = "0.0.1"
+end

data/route_boxer.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'route_boxer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "route_boxer"
+  spec.version       = RouteBoxer::VERSION
+  spec.authors       = ["Sebastian Badura"]
+  spec.email         = ["badura.sebastian@gmail.com"]
+  spec.summary       = %q{Ruby implementation of RouteBoxer}
+  spec.description   = %q{Extend google maps route with extra boxes}
+  spec.homepage      = "http://www.github.com/sbadura/route_boxer"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", '~> 0'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: route_boxer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sebastian Badura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extend google maps route with extra boxes
+email:
+- badura.sebastian@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/route_boxer.rb
+- lib/route_boxer/core.rb
+- lib/route_boxer/lat_lng.rb
+- lib/route_boxer/lat_lng_bounds.rb
+- lib/route_boxer/lat_lng_collection.rb
+- lib/route_boxer/version.rb
+- route_boxer.gemspec
+homepage: http://www.github.com/sbadura/route_boxer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of RouteBoxer
+test_files: []