cacheable_kdtree 1.1.0 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjBjMDhmMThmNWNhODE5MWYxOTVjM2FmYThkZDE0MzU4M2NmMTAyNw==
+    ODNiNGI4ZTY3NmQ2ZDNkZTNlYTlmNzBlY2Y2ZWE5ZjI4ZmIzOWZiMg==
   data.tar.gz: !binary |-
-    ZDU2YjQwOTU5NTRhOTI4MDYzZTRmMjAwMTY2YTM4N2VjNjYzZTk4NA==
+    M2JhZGZkODZiYzMwZDk2ZjVlMDNhMmIxYzFhMzc3Yzc3MjBhNmMwYg==
 SHA512:
   metadata.gz: !binary |-
-    ZGNkNTA5MzFmMWFhZWQwZjEyYmZjMmVmOTk4MWMwOGZlMmRmMjE1MWRiNzI2
-    NjZjM2UyNDgxMDdhMjE4ZjU1MzcwYTI1MTlmMDhjZmFhYjAxYjlhZDIyODZm
-    OWUzMGFjYjIwZDNmZWIwOTZkZjJmZWFkNDA0NjM3NjQ2MDhhZGY=
+    MTllMDlkYzJiNjU4NzNjNzQxMzNiMWU0ZmQxZDQ3YzYwMWU1MzMwNzAyMDlk
+    YmU0YmVlODE2YTJhODc3Y2RlYzAxOTk3NDNkY2Q2YWZjMjhmOTk1NTQxZjcz
+    NjM1NDFiOTE5NmEzNmQ4ZDczMDJkOWRmNzRlZmNkYzlmODU4YTA=
   data.tar.gz: !binary |-
-    ZTk2OGRkYTdmZTJmZTdiNjcwZDU4YTRhNTA4NjVlYjgzYTc1YjkxNWY5YmY2
-    MDU4MmI2YWU2MWZhOWUwYjE1ZjYxNzcxMWNmZTEwOTM1NDhmZTM5NzBkMGI1
-    YzAwZDI1MmMxNmJjMTllNWY4YWRhNzBkMzQ3YjgwYmVmYzFmNTk=
+    YTFmOTAxNTc0NjQyNDYyZjUxOTk1ZGM2MmFhZTNhNDVhYzlkYmU3ODEyODEz
+    ZmQ3YzVkMWRhMmE2OWM0YmY5MGZhNmM5MzJmMWRlOWU1ODc1MTJkMGU4MTJm
+    NThhMzI5Y2JkNWE5Zjg3MDMzYTdkNzc2NzEyNzhkMmY0YWZjMzU=

data/README.md

@@ -32,6 +32,10 @@ You can query your tree and return the closest nodes:
 ```ruby
 # The 4th parameter may be :miles or :kilometers
 all_my_nodes = my_tree.closest(my_lat, my_long, distance, :kilometers)
+# You may then sort the nodes by their distance to a point (using the Law of Cosines)
+sorted_nodes = CacheableKdtree::LatitudeLongitudeNode.sort_by_distance_between(my_lat, my_long, all_my_nodes)
+# To get your filtered, sorted data, you may run:
+my_data_list = sorted_nodes.map(:&data)
 ```
 
 ## Contributing

data/lib/cacheable_kdtree/latitude_longitude_node.rb

@@ -11,6 +11,12 @@ class CacheableKdtree::LatitudeLongitudeNode
     "region: #{region ? region.to_s : region}"
   end
 
+  def self.sort_by_distance_between(lat, long, node_list)
+    node_list.sort_by do |node|
+      CacheableKdtree::Util.distance_miles(lat, long, node.latitude, node.longitude)
+    end
+  end
+
   def self.create_or_merge_regions(n1, n2)
     return CacheableKdtree::LatitudeLongitudeRegion.new(n1.latitude, n1.longitude, n2.latitude, n2.longitude) if n1.region.nil? && n2.region.nil?
     return n1.region.merge_point(n2.latitude, n2.longitude) if n1.region && n2.region.nil?

data/lib/cacheable_kdtree/latitude_longitude_tree.rb

@@ -21,7 +21,7 @@ class CacheableKdtree::LatitudeLongitudeTree
 
   def nearest_nodes(bounding_box, node = @root, result = [])
     return result if node.nil?
-    result << node.data if bounding_box.point_in_region?(node.latitude, node.longitude)
+    result << node if bounding_box.point_in_region?(node.latitude, node.longitude)
     nearest_nodes(bounding_box, node.left, result) if search_child?(node.left, bounding_box)
     nearest_nodes(bounding_box, node.right, result) if search_child?(node.right, bounding_box)
     result

data/lib/cacheable_kdtree/util.rb

@@ -1,16 +1,16 @@
 class CacheableKdtree::Util
-  EARTH_MILES = 3959.0
+  KILOMETERS_IN_A_MILE = 0.621371192
   EARTH_KILOMETERS = 6371.0
 
   # I pulled the algorithm for the bounding_box calculation from here:
   # http://stackoverflow.com/questions/1689096/calculating-bounding-box-a-certain-distance-away-from-a-lat-long-coordinate-in-j
 
   def self.bounding_box_miles(lat, long, distance_in_miles)
-    bounding_box(lat, long, distance_in_miles, EARTH_MILES)
+    bounding_box(lat, long, distance_in_miles, earth_miles)
   end
 
-  def self.bounding_box_kilometers(lat, long, distance_in_miles)
-    bounding_box(lat, long, distance_in_miles, EARTH_MILES)
+  def self.bounding_box_kilometers(lat, long, distance_in_kilometers)
+    bounding_box(lat, long, distance_in_kilometers, EARTH_KILOMETERS)
   end
 
   def self.bounding_box(lat, long, radius_distance, sphere_radius)
@@ -23,11 +23,33 @@ class CacheableKdtree::Util
     CacheableKdtree::LatitudeLongitudeRegion.new(lat1, long1, lat2, long2)
   end
 
+  def self.distance_kilometers(p1_lat, p1_long, p2_lat, p2_long)
+    distance_law_of_cosines(p1_lat, p1_long, p2_lat, p2_long, EARTH_KILOMETERS)
+  end
+
+  def self.distance_miles(p1_lat, p1_long, p2_lat, p2_long)
+    distance_law_of_cosines(p1_lat, p1_long, p2_lat, p2_long, earth_miles)
+  end
+
+  # I am using the law of cosines because it is faster than Haversine...
+  def self.distance_law_of_cosines(p1_lat, p1_long, p2_lat, p2_long, sphere_radius)
+    p1_lat = degrees_to_radians(p1_lat)
+    p1_long = degrees_to_radians(p1_long)
+    p2_lat = degrees_to_radians(p2_lat)
+    p2_long = degrees_to_radians(p2_long)
+    Math.acos(Math.sin(p1_lat) * Math.sin(p2_lat) +
+              Math.cos(p1_lat) * Math.cos(p2_lat) * Math.cos(p2_long - p1_long)) * sphere_radius
+  end
+
   def self.degrees_to_radians(degrees)
-    degrees * 3.1416 / 180
+    degrees * Math::PI / 180
   end
 
   def self.radians_to_degrees(radians)
-    radians * 180 / 3.1416
+    radians * 180 / Math::PI
+  end
+
+  def self.earth_miles
+    KILOMETERS_IN_A_MILE * EARTH_KILOMETERS
   end
 end

data/lib/cacheable_kdtree/version.rb

@@ -1,3 +1,3 @@
 module CacheableKdtree
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cacheable_kdtree
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Aaron Franssell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-02 00:00:00.000000000 Z
+date: 2016-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler