bounding_boxes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab6c2d3842feb74dd9f4f1e4ec7532b115e7fbbc
+  data.tar.gz: 6bad38f93433df5758fcb78262b20966faa35a17
+SHA512:
+  metadata.gz: 4a412ca4f2918b55f504eb708c0ea471d760699469d4bf82a5f2f351561436ad736008f6f38c1dc3117d63b37742333d5c778971fdb7a503b7d06c4b0acabb10
+  data.tar.gz: 96d975c4535ff44c0fca9558e6bce1c6e620c375a47495cc3477d4dc718f604d5a789eb449cee77c8afdcf3d9797e6bc4e1fcea0dcf763b7d3811a9335860576

data/lib/bounding_boxes/base_bounding_box.rb

@@ -0,0 +1,71 @@
+module BB
+  class BaseBoundingBox
+    attr_accessor :max, :min, :preferred_units
+
+    def initialize(lat1, long1, lat2, long2, units)
+      @min = {latitude: lat1, longitude: long1}
+      @max = {latitude: lat2, longitude: long2}
+      @preferred_units = units
+    end
+
+    def side_length
+      self.send("side_length_#{preferred_units}".to_sym)
+    end
+
+    def width(units = @preferred_units)
+      BB.send("distance_#{units}".to_sym, {latitude: @max[:latitude], 
+                         longitude: @max[:longitude]},
+                        {latitude: @max[:latitude], 
+                         longitude: @min[:longitude]})
+    end
+
+    def height(units = @preferred_units)
+      BB.send("distance_#{units}".to_sym, {latitude: @max[:latitude],
+                                           longitude: @max[:longitude]},
+                                           {latitude: @min[:latitude],
+                                           longitude: @max[:longitude]})
+    end
+
+    def min_lat
+      @min[:latitude]
+    end
+
+    def min_long
+      @min[:longitude]
+    end
+
+    def max_lat
+      @max[:latitude]
+    end
+
+    def max_long
+      @max[:longitude]
+    end
+
+    def fetch(property)
+      raise KeyError unless self.respond_to?(property)
+      self.send(property)
+    end
+
+    def method_missing(name, *args)
+      attribute = name.to_s
+      if attribute =~ /(width_)(km|kilometers)/
+        width(:kilometers)
+      elsif attribute =~ /(width_)(mi|mil|miles)/
+        width(:miles)
+      elsif attribute =~ /(height_)(km|kilometers)/
+        height(:kilometers)
+      elsif attribute =~ /(height_)(mi|mil|miles)/
+        height(:miles)
+      elsif attribute =~ /(min|minimum)_(lat|latitude)/
+        min_lat
+      elsif attribute =~ /(min|minimum)_(lon|long|longitude)/
+        min_long
+      elsif attribute =~ /(max|maximum)_(lat|latitude)/
+        max_lat
+      elsif attribute =~ /(max|maximum)_(lon|long|longitude)/
+        max_long
+      end
+    end
+  end
+end

data/lib/bounding_boxes/bounding_box.rb

@@ -0,0 +1,73 @@
+module BB
+  #can create any type of bounding box and
+  #will be able to split it into an array of bounding boxes
+  class BoundingBox < BaseBoundingBox
+    attr_accessor :box
+    def initialize(options = {})
+      if options.has_key?(:radius)
+        build_point_bounding_box(options)
+      elsif options.has_key?(:side_length)
+        build_square_bounding_box(options)
+      elsif options.size == 5 && options.key_present?(:units)
+        build_base_bounding_box(options)
+      end
+    end
+
+    def split_geo(max_size)
+      raise "split size greater than width or height" unless self.width > max_size && self.height > max_size
+      rows = (self.height / max_size).to_i
+      columns = (self.width / max_size).to_i
+
+      split_width = self.width / columns
+      split_height = self.height / rows
+
+      temp_array = []
+      temp_lat = self.min_lat
+      temp_long = self.min_long
+
+      (rows - 1).times do |row_num| 
+        (columns - 1).times do |column_num| 
+          temp_array << BB::SquareBoundingBox.new(temp_lat,
+                                                  temp_long,
+                                                  "#{split_width}#{self.preferred_units}" )
+          temp_long = temp_array.last.max_long
+        end
+        temp_lat = temp_array.last.max_lat
+        temp_long = self.min_long
+      end
+      temp_array
+    end
+
+    private
+    def set_max_min
+      @max = @box.max
+      @min = @box.min
+      @preferred_units = @box.preferred_units
+    end
+
+    def build_point_bounding_box(options)
+      @box = BB::PointBoundingBox.new(options.fetch(:latitude), 
+                                     options.fetch(:longitude), 
+                                     options.fetch(:radius))
+      set_max_min
+    end
+
+    def build_square_bounding_box(options)
+      @box = BB::SquareBoundingBox.new(options.fetch(:latitude),
+                                       options.fetch(:longitude),
+                                       options.fetch(:side_length))
+      set_max_min
+    end
+
+    def build_base_bounding_box(options)
+      @box = BB::BaseBoundingBox.new(options.fetch(:lat1),
+                                     options.fetch(:long1),
+                                     options.fetch(:lat2),
+                                     options.fetch(:long2),
+                                     options.fetch(:units))
+      set_max_min
+    end
+
+
+  end
+end

data/lib/bounding_boxes/distance.rb

@@ -0,0 +1,38 @@
+module BB
+  def self.distance_kilometers(point1, point2)
+    lat1 = BB::degrees_to_radians(point1.fetch(:latitude))
+    long1 = BB::degrees_to_radians(point1.fetch(:longitude))
+    lat2 = BB::degrees_to_radians(point2.fetch(:latitude))
+    long2 = BB::degrees_to_radians(point2.fetch(:longitude))
+
+    (Math.acos(Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) * Math.cos(long1 - long2)) * 6371)
+  end
+
+  def self.distance_km(point1, point2)
+    BB.distance_kilometers(point1, point2)
+  end
+
+  def self.distance_miles(point1, point2)
+    BB.kilometers_to_miles(BB.distance_kilometers(point1, point2))
+  end
+
+  def self.distance_mi(point1, point2)
+    BB.distance_miles(point1, point2)
+  end
+
+  def self.degrees_to_radians(number)
+    number * Math::PI / 180
+  end
+
+  def self.radians_to_degrees(number)
+    number * 180 / Math::PI
+  end
+
+  def self.kilometers_to_miles(number)
+    number * 0.621371
+  end
+
+  def self.miles_to_kilometers(number)
+    number * 1.60934
+  end
+end

data/lib/bounding_boxes/point_bounding_box.rb

@@ -0,0 +1,48 @@
+module BB
+  #creates a bounding box that contains a circle
+  #with center of lat, long and radius of radius
+  #should be called as PointBoundingBox.new(lat, long, "radius<km || mi>")
+  class PointBoundingBox < BaseBoundingBox
+    def initialize(lat, long, radius)
+      @input = {latitude: lat, longitude: long, radius: radius}
+      @input_radius = parse_radius
+      @input_lat = parse_lat
+      @input_long = parse_long
+      @max = fetch_max
+      @min = fetch_min
+    end
+
+    private
+    def parse_radius
+      parsed = @input.fetch(:radius).scan(/\d+\.?\d*|km|mi/)
+      @preferred_units = parsed[1] || "mi"
+      if @units == "km" then parsed[0].to_f else BB.miles_to_kilometers(parsed[0].to_f) end
+    end
+
+    def parse_lat
+      BB.degrees_to_radians(@input.fetch(:latitude))
+    end
+
+    def parse_long
+      BB.degrees_to_radians(@input.fetch(:longitude))
+    end
+
+    def fetch_max
+      {latitude: BB.radians_to_degrees(@input_lat + delta_lat), 
+       longitude: BB.radians_to_degrees(@input_long + delta_long)}
+    end
+
+    def fetch_min
+      {latitude: BB.radians_to_degrees(@input_lat - delta_lat), 
+       longitude: BB.radians_to_degrees(@input_long - delta_long)}
+    end
+
+    def delta_lat
+      @input_radius / 6371
+    end
+
+    def delta_long
+      Math.asin(Math.sin(delta_lat)/Math.cos(@input_lat))
+    end
+  end
+end

data/lib/bounding_boxes/split_box.rb

@@ -0,0 +1,10 @@
+module BB
+  def self.split_box(box, length_of_side)
+    parsed = length_of_side.to_s.scan(/\d+|km|mi/)
+    split_length = parsed[0].to_f
+    units = parsed[1]
+    raise "box width smaller than split" unless box.send("side_length_#{units}".to_sym) > split_length
+
+
+  end
+end

data/lib/bounding_boxes/square_bounding_box.rb

@@ -0,0 +1,28 @@
+module BB
+  #creates a square bounding box sides equal to side_length
+  #and southwest corner equal to lat/long
+  class SquareBoundingBox < BaseBoundingBox
+    def initialize(lat, long, side_length)
+      @side_length = parse_side_length(side_length)
+      @lat = lat
+      @long = long
+      @min = fetch_min
+      @max = fetch_max
+    end
+
+    private
+    def parse_side_length(side_length)
+      parsed = side_length.scan(/\d+|mi|km/)
+      @preferred_units = parsed[1] || "mi"
+      parsed[0].to_f
+    end
+
+    def fetch_min
+      {latitude: @lat, longitude: @long}
+    end
+
+    def fetch_max
+      BB::PointBoundingBox.new(@lat, @long, "#{@side_length}#{@preferred_units}").max
+    end
+  end
+end

data/lib/bounding_boxes/version.rb

@@ -0,0 +1,3 @@
+module BB
+  VERSION = "0.1.0"
+end

data/lib/bounding_boxes.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + "/bounding_boxes/*.rb"].each do |file| 
+  require file
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: bounding_boxes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tyler Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-23 00:00:00.000000000 Z
+dependencies: []
+description: a gem to convert point_radius geolocations to bounding boxes and split
+  them into smaller boxes
+email:
+- tylermorgan86@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bounding_boxes.rb
+- lib/bounding_boxes/base_bounding_box.rb
+- lib/bounding_boxes/bounding_box.rb
+- lib/bounding_boxes/distance.rb
+- lib/bounding_boxes/point_bounding_box.rb
+- lib/bounding_boxes/split_box.rb
+- lib/bounding_boxes/square_bounding_box.rb
+- lib/bounding_boxes/version.rb
+homepage: https://github.com/tylermorgan86/bounding_boxes
+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.1
+signing_key: 
+specification_version: 4
+summary: geolocation bounding boxes
+test_files: []