quadtree 1.0.4 → 1.0.6

data/lib/quadtree/point.rb

@@ -1,71 +1,107 @@
-module Quadtree
-    # Simple coordinate object to represent points in some space.
-    class Point
-
-      # The X coordinate of this instance.
-      # @return [Float] X coordinate.
-      attr_accessor :x
-
-      # The Y coordinate of this instance.
-      # @return [Float] Y coordinate.
-      attr_accessor :y
-
-      # Optional payload attached to this instance.
-      # @return [Object] payload attached to this instance.
-      attr_accessor :data
-
-      # @param x [Float, Numeric] X coordinate.
-      # @param y [Float, Numeric] Y coordinate.
-      # @param data [Object] payload payload attached to this instance
-      #   (optional).
-      def initialize(x, y, data=nil)
-        @x = x.to_f
-        @y = y.to_f
-        @data = data unless data.nil?
-      end
-
-      # This will calculate distance to another {Point}, given that they are
-      # both in the same 2D space.
-      #
-      # @param other [Point] 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 other [Point] 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.0)
-        lat2 = other.y * (Math::PI / 180.0)
-        dlat = (other.y - self.y) * (Math::PI / 180.0)
-        dlon = (other.x - self.x) * (Math::PI / 180.0)
-
-        # a = sin²(Δφ/2) + cos φ_1 ⋅ cos φ_2 ⋅ sin²(Δλ/2)
-        a = Math.sin(dlat / 2.0) * Math.sin(dlat / 2.0) +
-            Math.cos(lat1) * Math.cos(lat2) *
-            Math.sin(dlon / 2.0) * Math.sin(dlon / 2.0)
-        # c = 2 ⋅ atan2( √a, √(1−a) )
-        c = 2.0 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
-        # d = R ⋅ c
-        return r * c
-      end
-    end
-end
+module Quadtree
+    # Simple coordinate object to represent points in some space.
+    class Point
+
+      # The X coordinate of this instance.
+      # @return [Float, Integer] X coordinate.
+      attr_accessor :x
+
+      # The Y coordinate of this instance.
+      # @return [Float, Integer] Y coordinate.
+      attr_accessor :y
+
+      # Optional payload attached to this instance.
+      # @return [Object] payload attached to this instance.
+      attr_accessor :data
+
+      # @param x [Float, Integer] X coordinate.
+      # @param y [Float, Integer] Y coordinate.
+      # @param data [Object] payload payload attached to this instance
+      #   (optional).
+      # @raise [UnknownTypeError] if one or more input parameters (+x+ and +y+)
+      #   has the wrong type.
+      def initialize(x, y, data=nil)
+
+        self.x = get_typed_numeric(x)
+        self.y = get_typed_numeric(y)
+
+        self.data = data unless data.nil?
+      end
+
+      # This will calculate distance to another {Point}, given that they are
+      # both in the same 2D space.
+      #
+      # @param other [Point] 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 other [Point] 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.0)
+        lat2 = other.y * (Math::PI / 180.0)
+        dlat = (other.y - self.y) * (Math::PI / 180.0)
+        dlon = (other.x - self.x) * (Math::PI / 180.0)
+
+        # a = sin²(Δφ/2) + cos φ_1 ⋅ cos φ_2 ⋅ sin²(Δλ/2)
+        a = Math.sin(dlat / 2.0) * Math.sin(dlat / 2.0) +
+            Math.cos(lat1) * Math.cos(lat2) *
+            Math.sin(dlon / 2.0) * Math.sin(dlon / 2.0)
+        # c = 2 ⋅ atan2( √a, √(1−a) )
+        c = 2.0 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+        # d = R ⋅ c
+        return r * c
+      end
+
+      private
+
+      def get_typed_numeric(any_input)
+        typed_output = nil
+        # Try integer first since float will parse integers too
+        return get_integer(any_input) unless get_integer(any_input).nil?
+        # Try Float next
+        return get_float(any_input) unless get_float(any_input).nil?
+
+        raise UnknownTypeError.new "Unknown type for parameter: #{any_input.class}"
+
+        #typed_output
+      end
+
+      def get_integer(any_input)
+        return Integer(any_input) if any_input.is_a? String
+        return any_input if any_input.is_a? Integer
+
+        nil
+      rescue
+        nil
+      end
+
+      def get_float(any_input)
+        return Float(any_input) if any_input.is_a? String
+        return any_input if any_input.is_a? Float
+
+        nil
+      rescue
+        nil
+      end
+    end
+end

data/lib/quadtree/quadtree.rb

@@ -1,127 +1,127 @@
-module Quadtree
-  # A Quadtree.
-  class Quadtree
-
-    # Arbitrary constant to indicate how many elements can be stored in this
-    # quad tree node.
-    # @return [Integer] number of {Point}s this {Quadtree} can hold.
-    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
-
-    # North west corner of this quad.
-    # @return [Quadtree]
-    attr_accessor :north_west
-
-    # North east corner of this quad.
-    # @return [Quadtree]
-    attr_accessor :north_east
-
-    # South west corner of this quad.
-    # @return [Quadtree]
-    attr_accessor :south_west
-
-    # South east corner of this quad.
-    # @return [Quadtree]
-    attr_accessor :south_east
-
-    # @param boundary [AxisAlignedBoundingBox] the boundary for this {Quadtree}
-    def initialize(boundary)
-      self.boundary = boundary
-      self.points = []
-      self.north_west = nil
-      self.north_east = nil
-      self.south_west = nil
-      self.south_east = nil
-    end
-
-    # Insert a {Point} in this {Quadtree}.
-    #
-    # @param point [Point] the point to insert.
-    # @return [Boolean] +true+ on success, +false+ otherwise.
-    def insert!(point)
-      return false unless self.boundary.contains_point?(point)
-
-      if self.points.size < NODE_CAPACITY
-        self.points << point
-        return true
-      end
-
-      subdivide! if self.north_west.nil?
-      return true if self.north_west.insert!(point)
-      return true if self.north_east.insert!(point)
-      return true if self.south_west.insert!(point)
-      return true if self.south_east.insert!(point)
-
-      false
-    end
-
-    # Finds all points contained within a range.
-    #
-    # @param range [AxisAlignedBoundingBox] 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 self.boundary.intersects?(range)
-
-      # Check objects at this quad level
-      self.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 self.north_west.nil?
-
-      # Otherwise, add the points from the children
-      points_in_range += self.north_west.query_range(range)
-      points_in_range += self.north_east.query_range(range)
-      points_in_range += self.south_west.query_range(range)
-      points_in_range += self.south_east.query_range(range)
-
-      points_in_range
-    end
-
-    private
-
-    # @return [Boolean]
-    def subdivide!
-      left_edge = self.boundary.left
-      right_edge = self.boundary.right
-      top_edge = self.boundary.top
-      bottom_edge = self.boundary.bottom
-      quad_half_dimension = self.boundary.half_dimension / 2
-
-      north_west_center = Point.new left_edge + quad_half_dimension, top_edge - quad_half_dimension
-      north_east_center = Point.new right_edge - quad_half_dimension, top_edge - quad_half_dimension
-      south_east_center = Point.new left_edge + quad_half_dimension, bottom_edge + quad_half_dimension
-      south_west_center = Point.new right_edge - quad_half_dimension, bottom_edge + quad_half_dimension
-
-      north_west_boundary = AxisAlignedBoundingBox.new north_west_center, quad_half_dimension
-      north_east_boundary = AxisAlignedBoundingBox.new north_east_center, quad_half_dimension
-      south_west_boundary = AxisAlignedBoundingBox.new south_west_center, quad_half_dimension
-      south_east_boundary = AxisAlignedBoundingBox.new south_east_center, quad_half_dimension
-
-      self.north_west = Quadtree.new north_west_boundary
-      self.north_east = Quadtree.new north_east_boundary
-      self.south_west = Quadtree.new south_west_boundary
-      self.south_east = Quadtree.new south_east_boundary
-
-      true
-    rescue => error
-      puts "Something went wrong: #{error}"
-      false
-    end
-  end
-end
+module Quadtree
+  # A Quadtree.
+  class Quadtree
+
+    # Arbitrary constant to indicate how many elements can be stored in this
+    # quad tree node.
+    # @return [Integer] number of {Point}s this {Quadtree} can hold.
+    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
+
+    # North west corner of this quad.
+    # @return [Quadtree]
+    attr_accessor :north_west
+
+    # North east corner of this quad.
+    # @return [Quadtree]
+    attr_accessor :north_east
+
+    # South west corner of this quad.
+    # @return [Quadtree]
+    attr_accessor :south_west
+
+    # South east corner of this quad.
+    # @return [Quadtree]
+    attr_accessor :south_east
+
+    # @param boundary [AxisAlignedBoundingBox] the boundary for this {Quadtree}
+    def initialize(boundary)
+      self.boundary = boundary
+      self.points = []
+      self.north_west = nil
+      self.north_east = nil
+      self.south_west = nil
+      self.south_east = nil
+    end
+
+    # Insert a {Point} in this {Quadtree}.
+    #
+    # @param point [Point] the point to insert.
+    # @return [Boolean] +true+ on success, +false+ otherwise.
+    def insert!(point)
+      return false unless self.boundary.contains_point?(point)
+
+      if self.points.size < NODE_CAPACITY
+        self.points << point
+        return true
+      end
+
+      subdivide! if self.north_west.nil?
+      return true if self.north_west.insert!(point)
+      return true if self.north_east.insert!(point)
+      return true if self.south_west.insert!(point)
+      return true if self.south_east.insert!(point)
+
+      false
+    end
+
+    # Finds all points contained within a range.
+    #
+    # @param range [AxisAlignedBoundingBox] 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 self.boundary.intersects?(range)
+
+      # Check objects at this quad level
+      self.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 self.north_west.nil?
+
+      # Otherwise, add the points from the children
+      points_in_range += self.north_west.query_range(range)
+      points_in_range += self.north_east.query_range(range)
+      points_in_range += self.south_west.query_range(range)
+      points_in_range += self.south_east.query_range(range)
+
+      points_in_range
+    end
+
+    private
+
+    # @return [Boolean]
+    def subdivide!
+      left_edge = self.boundary.left
+      right_edge = self.boundary.right
+      top_edge = self.boundary.top
+      bottom_edge = self.boundary.bottom
+      quad_half_dimension = self.boundary.half_dimension / 2
+
+      north_west_center = Point.new left_edge + quad_half_dimension, top_edge - quad_half_dimension
+      north_east_center = Point.new right_edge - quad_half_dimension, top_edge - quad_half_dimension
+      south_east_center = Point.new left_edge + quad_half_dimension, bottom_edge + quad_half_dimension
+      south_west_center = Point.new right_edge - quad_half_dimension, bottom_edge + quad_half_dimension
+
+      north_west_boundary = AxisAlignedBoundingBox.new north_west_center, quad_half_dimension
+      north_east_boundary = AxisAlignedBoundingBox.new north_east_center, quad_half_dimension
+      south_west_boundary = AxisAlignedBoundingBox.new south_west_center, quad_half_dimension
+      south_east_boundary = AxisAlignedBoundingBox.new south_east_center, quad_half_dimension
+
+      self.north_west = Quadtree.new north_west_boundary
+      self.north_east = Quadtree.new north_east_boundary
+      self.south_west = Quadtree.new south_west_boundary
+      self.south_east = Quadtree.new south_east_boundary
+
+      true
+    rescue => error
+      puts "Something went wrong: #{error}"
+      false
+    end
+  end
+end

data/lib/quadtree/unknown_type_error.rb

@@ -0,0 +1,7 @@
+module Quadtree
+  # An error for unknown types.
+  # @since 1.0.5
+  class UnknownTypeError < StandardError
+
+  end
+end

data/lib/quadtree/version.rb

@@ -1,4 +1,5 @@
-module Quadtree
-  # Current version
-  VERSION = "1.0.4"
-end
+require "version"
+
+module Quadtree
+  is_versioned
+end