Merge branch 'release/v1.0.0'

Author: janlindblom

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

README.md

@@ -1,8 +1,6 @@
 # Quadtree
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/quadtree`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Quadtrees in Ruby. For searching spatially related nodes in some space, you know.
 
 ## Installation
 
@@ -22,7 +20,28 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Load it in your code to start building quadtrees:
+
+```ruby
+require 'quadtree'
+
+boundary = Quadtree::AxisAlignedBoundingBox.new(Quadtree::Point.new(19.8470050, 60.3747940), 8944.0)
+qt = Quadtree::Quadtree.new(boundary)
+```
+
+Then you can do lookups and such:
+
+```ruby
+getaboden = Quadtree::Point.new(19.8470050, 60.3747940, "Getaboden")
+knutnas = Quadtree::Point.new(19.8271170, 60.3505570, "Knutnäs")
+boundary = Quadtree::AxisAlignedBoundingBox.new(Quadtree::Point.new(19.8470050, 60.3747940), 8944.0)
+boundary2 = Quadtree::AxisAlignedBoundingBox.new(Quadtree::Point.new(19.8470050, 60.3747940), 4472.0)
+qt.insert! getaboden
+qt.insert! knutnas
+qt.query_range(boundary2)
+# [#<Quadtree::Point:0x00007fdcb19e0698 @data="Getaboden", @x=19.847005, @y=60.374794>,
+ #<Quadtree::Point:0x00007fdcb19ec7b8 @data="Knutnäs", @x=19.827117, @y=60.350557>]
+```
 
 ## Development
 
@@ -32,7 +51,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/quadtree. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on Bitbucket at https://bitbucket.org/janlindblom/ruby-quadtree. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

Rakefile

@@ -1,6 +1,13 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "yard"
+require "yard/rake/yardoc_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']
+  t.stats_options = ['--list-undoc']
+end
+
 task :default => :spec

bin/console

@@ -3,12 +3,5 @@
 require "bundler/setup"
 require "quadtree"
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)
+require "pry"
+Pry.start

lib/quadtree.rb

@@ -1,5 +1,13 @@
 require "quadtree/version"
 
+require "quadtree/point"
+require "quadtree/axis_aligned_bounding_box"
+require "quadtree/quadtree"
+
+# Quadtrees.
+#
+# @since 1.0.0
+# @author Jan Lindblom <janlindblom@fastmail.fm>
 module Quadtree
-  # Your code goes here...
+
 end

lib/quadtree/axis_aligned_bounding_box.rb

@@ -0,0 +1,82 @@
+module Quadtree
+  # Axis-aligned bounding box with half dimension and center.
+  class AxisAlignedBoundingBox
+
+    # @return [Point]
+    attr_accessor :center
+    # @return [Float]
+    attr_accessor :half_dimension
+
+    # @param [Point] center
+    # @param [Float] half_dimension
+    def initialize(center, half_dimension)
+      @center = center
+      @half_dimension = half_dimension.to_f
+    end
+
+    # @param [Point] point
+    # @return [Boolean]
+    def contains_point?(point)
+      if point.x >= self.center.x - self.half_dimension and point.x <= self.center.x + self.half_dimension
+        if point.y >= self.center.y - self.half_dimension and point.y <= self.center.y + self.half_dimension
+          return true
+        end
+      end
+      false
+    end
+
+    # @param [AxisAlignedBoundingBox] other
+    # @return [Boolean]
+    def intersects?(other)
+      other_lt_corner = Point.new(other.left, other.top)
+      other_rt_corner = Point.new(other.right, other.top)
+      other_lb_corner = Point.new(other.left, other.bottom)
+      other_rb_corner = Point.new(other.right, other.bottom)
+
+      [other_lt_corner, other_rt_corner, other_lb_corner, other_rb_corner].each do |corner|
+        return true if self.contains_point?(corner)
+      end
+      false
+    end
+
+    # @return [Float]
+    def left
+      @center.x - @half_dimension
+    end
+
+    # @return [Float]
+    def right
+      @center.x + @half_dimension
+    end
+
+    # Get the Y coordinate of the top edge of this AABB.
+    #
+    # @return [Float] the Y coordinate of the top edge of this AABB.
+    def top
+      @center.y + @half_dimension
+    end
+
+    # Get the Y coordinate of the bottom edge of this AABB.
+    #
+    # @return [Float] the Y coordinate of the bottom edge of this AABB.
+    def bottom
+      @center.y - @half_dimension
+    end
+
+    # @return [Float]
+    def width
+      span
+    end
+
+    # @return [Float]
+    def height
+      span
+    end
+
+    private
+
+    def span
+      @half_dimension * 2
+    end
+  end
+end

lib/quadtree/point.rb

@@ -0,0 +1,66 @@
+module Quadtree
+    # Simple coordinate object to represent points in some space.
+    class Point
+
+      # @return [Float] X coordinate
+      attr_accessor :x
+
+      # @return [Float] Y coordinate
+      attr_accessor :y
+
+      # Payload attached to this {Point}.
+      attr_accessor :data
+
+      # Create a new {Point}.
+      #
+      # @param [Float] x X coordinate
+      # @param [Float] y Y coordinate
+      def initialize(x, y, data=nil)
+        @x = x
+        @y = y
+        @data = data unless data.nil?
+      end
+
+      # This will calculate distance to another, given that they are both
+      # on the same flat two dimensional plane.
+      #
+      # @param [Point] other the other {Point}.
+      # @return [Float] the distance to the other {Point}.
+      def distance_to(other)
+        Math.sqrt((other.x - self.x) ** 2 + (other.y - self.y) ** 2)
+      end
+
+      # This will calculate distance to another point using the Haversine
+      # formula. This means that it will treat #x as longitude and #y as
+      # latitude!
+      #
+      # a = sin²(Δφ/2) + cos φ_1 ⋅ cos φ_2 ⋅ sin²(Δλ/2)
+      # c = 2 ⋅ atan2( √a, √(1−a) )
+      # d = R ⋅ c
+      #
+      # where φ is latitude, λ is longitude, R is earth’s radius (mean
+      # radius = 6 371 km);
+      # note that angles need to be in radians to pass to trig functions!
+      #
+      # @param [Point] other the other {Point}.
+      # @return [Float] the distance, in meters, to the other {Point}.
+      def haversine_distance_to(other)
+        # earth's radius
+        r = 6371 * 1000.0
+        # coverting degrees to radians
+        lat1 = self.y * (Math::PI / 180)
+        lat2 = other.y * (Math::PI / 180)
+        dlat = (other.y - self.y) * (Math::PI / 180)
+        dlon = (other.x - self.x) * (Math::PI / 180)
+
+        # a = sin²(Δφ/2) + cos φ_1 ⋅ cos φ_2 ⋅ sin²(Δλ/2)
+        a = Math.sin(dlat / 2) * Math.sin(dlat / 2) +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2) * Math.sin(dlon / 2)
+        # c = 2 ⋅ atan2( √a, √(1−a) )
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+        # d = R ⋅ c
+        return r * c
+      end
+    end
+end

lib/quadtree/quadtree.rb

@@ -0,0 +1,116 @@
+module Quadtree
+  # A Quadtree
+  class Quadtree
+
+    # Arbitrary constant to indicate how many elements can be stored in this
+    # quad tree node.
+    # @return [Integer]
+    NODE_CAPACITY = 4
+
+    # Axis-aligned bounding box stored as a center with half-dimensions to
+    # represent the boundaries of this quad tree.
+    # @return [AxisAlignedBoundingBox]
+    attr_accessor :boundary
+
+    # Points in this quad tree node.
+    # @return [Array<Point>]
+    attr_accessor :points
+
+    # Children
+
+    # @return [Quadtree]
+    attr_accessor :north_west
+    # @return [Quadtree]
+    attr_accessor :north_east
+    # @return [Quadtree]
+    attr_accessor :south_west
+    # @return [Quadtree]
+    attr_accessor :south_east
+
+    def initialize(boundary)
+      @boundary = boundary
+      @points = []
+      @north_west = nil
+      @north_east = nil
+      @south_west = nil
+      @south_east = nil
+    end
+
+    # @param [Point] point
+    # @return [Boolean]
+    def insert!(point)
+      return false unless @boundary.contains_point?(point)
+
+      if points.size < NODE_CAPACITY
+        @points << point
+        return true
+      end
+
+      subdivide! if @north_west.nil?
+      return true if @north_west.insert(point)
+      return true if @north_east.insert(point)
+      return true if @south_west.insert(point)
+      return true if @south_east.insert(point)
+
+      false
+    end
+
+    # Finds all points contained within a range.
+    #
+    # @param [AxisAlignedBoundingBox] range the range to search within.
+    # @return [Array<Point>]
+    def query_range(range)
+      # Prepare an array of results
+      points_in_range = []
+
+      # Automatically abort if the range does not intersect this quad
+      return points_in_range unless @boundary.intersects?(range)
+
+      # Check objects at this quad level
+      @points.each do |point|
+        points_in_range << point if range.contains_point?(point)
+      end
+
+      # Terminate here, if there are no children
+      return points_in_range if @north_west.nil?
+
+      # Otherwise, add the points from the children
+      points_in_range += @north_west.query_range(range)
+      points_in_range += @north_east.query_range(range)
+      points_in_range += @south_west.query_range(range)
+      points_in_range += @south_east.query_range(range)
+
+      points_in_range
+    end
+
+    private
+
+    # @return [Boolean]
+    def subdivide!
+      left_edge = @boundary.left
+      right_edge = @boundary.right
+      top_edge = @boundary.top
+      bottom_edge = @boundary.bottom
+      quad_half_dimension = @boundary.half_dimension / 2
+
+      north_west_center = Quadtree::Point.new left_edge + quad_half_dimension, top_edge - quad_half_dimension
+      north_east_center = Quadtree::Point.new right_edge - quad_half_dimension, top_edge - quad_half_dimension
+      south_east_center = Quadtree::Point.new left_edge + quad_half_dimension, bottom_edge + quad_half_dimension
+      south_west_center = Quadtree::Point.new right_edge - quad_half_dimension, bottom_edge + quad_half_dimension
+
+      north_west_boundary = Quadtree::AxisAlignedBoundingBox.new north_west_center, quad_half_dimension
+      north_east_boundary = Quadtree::AxisAlignedBoundingBox.new north_east_center, quad_half_dimension
+      south_west_boundary = Quadtree::AxisAlignedBoundingBox.new south_west_center, quad_half_dimension
+      south_east_boundary = Quadtree::AxisAlignedBoundingBox.new south_east_center, quad_half_dimension
+
+      @north_west = Quadtree::Quadtree.new north_west_boundary
+      @north_east = Quadtree::Quadtree.new north_east_boundary
+      @south_west = Quadtree::Quadtree.new south_west_boundary
+      @south_east = Quadtree::Quadtree.new south_east_boundary
+
+      true
+    rescue
+      false
+    end
+  end
+end

lib/quadtree/version.rb

@@ -1,3 +1,3 @@
 module Quadtree
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end