geometry 5 → 6

data/Gemfile

@@ -1,4 +1,7 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in geometry.gemspec
 gemspec
+
+group :test do
+    gem 'rake'
+end

data/README.markdown

@@ -1,6 +1,8 @@
 Geometry for Ruby
 =================
 
+[![Build Status](https://travis-ci.org/bfoz/geometry.png)](https://travis-ci.org/bfoz/geometry)
+
 Classes and methods for the handling of all of the basic geometry that you 
 learned in high school (and then forgot).
 
@@ -12,8 +14,7 @@ that don't work in higher dimensions and I'll do my best to fix them.
 License
 -------
 
-Copyright 2012 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD 
-license.
+Copyright 2012-2013 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
 
 Primitives
 ----------
@@ -22,9 +23,9 @@ Primitives
 - Size
 - Line
 - Edge
-- Circle
+- [Arc](http://en.wikipedia.org/wiki/Arc_(geometry)), Circle
 - Rectangle, Square
-- Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon)
+- Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon), [RegularPolygon](http://en.wikipedia.org/wiki/Regular_polygon)
 - Transformation
 - [Triangle](http://en.wikipedia.org/wiki/Triangle)
 - [Obround](http://en.wiktionary.org/wiki/obround)
@@ -66,10 +67,25 @@ Examples
     Geometry::Line.vertical(x=0)
 ```
 
+### Rectangle
+```ruby
+    # A Rectangle made from two corner points
+    Geometry::Rectangle.new [1,2], [2,3]
+    Geometry::Rectangle.new from:[1,2], to:[2,3]
+
+    Geometry::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
+    Geometry::Rectangle.new origin:[1,2], size:[1,1]	# Using an origin point and a size
+
+    # A Rectangle with its origin at [0, 0] and a size of [10, 20]
+    Geometry::Rectangle.new size: [10, 20]
+    Geometry::Rectangle.new size: Size[10, 20]
+    Geometry::Rectangle.new width: 10, height: 20
+```
+
 ### Circle
 ```ruby
     # A circle at Point[1,2] with a radius of 3
-    circle = Geometry::Circle.new [1,2], 3
+    circle = Geometry::Circle.new center:[1,2], radius:3
 ```
 
 ### Polygon
@@ -77,3 +93,8 @@ Examples
     # A polygon that looks a lot like a square
     polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
 ```
+### Regular Polygon
+```ruby
+    # Everyone loves a good hexagon
+    hexagon = Geometry::RegularPolygon.new 6, :diameter => 3
+```

data/Rakefile

@@ -1,8 +1,11 @@
 require "bundler/gem_tasks"
 require 'rake/testtask'
 
+task :default => :test
+
 Rake::TestTask.new do |t|
     t.libs.push "lib"
+#    t.test_files = FileList['test/**/rectangle.rb']
     t.test_files = FileList['test/**/*.rb']
     t.verbose = true
 end

data/geometry.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "geometry"
-  s.version     = '5'
+  s.version     = '6'
   s.authors     = ["Brandon Fosdick"]
   s.email       = ["bfoz@bfoz.net"]
   s.homepage    = "http://github.com/bfoz/geometry"

data/lib/geometry.rb

@@ -1,12 +1,14 @@
 require_relative 'geometry/arc'
 require_relative 'geometry/circle'
 require_relative 'geometry/line'
+require_relative 'geometry/obround'
 require_relative 'geometry/path'
 require_relative 'geometry/point'
 require_relative 'geometry/point_zero'
 require_relative 'geometry/polygon'
 require_relative 'geometry/polyline'
 require_relative 'geometry/rectangle'
+require_relative 'geometry/regular_polygon'
 require_relative 'geometry/rotation'
 require_relative 'geometry/size'
 require_relative 'geometry/size_zero'
@@ -16,37 +18,4 @@ require_relative 'geometry/triangle'
 require_relative 'geometry/vector'
 
 module Geometry
-    # @overload Line(array0, array1)
-    #   @param [Array] array0 First endpoint
-    #   @param [Array] array1 Second endpoint
-    #   @return [TwoPointLine]
-    # @overload Line(point0, point1)
-    #   @param [Point] point0 First endpoint
-    #   @param [Point] point1 Second endpoint
-    #   @return [TwoPointLine]
-    # @overload Line(vector0, vector1)
-    #   @param [Vector] vector0 First endpoint
-    #   @param [Vector] vector1 Second endpoint
-    #   @return [TwoPointLine]
-    # @overload Line(y_intercept, slope)
-    #   @param [Numeric] y_intercept Y-intercept
-    #   @param [Numeric] slope Slope
-    #   @return [SlopeInterceptLine]
-    # @overload Line(point, slope)
-    #   @param [Point] point Starting point
-    #   @param [Numeric] slope Slope
-    #   @return [PointSlopeLine]
-    def self.line(*args)
-	Line[*args]
-    end
-
-    # @overload Point(x,y,z,...)
-    #   @return [Point]
-    # @overload Point(Point)
-    #   @return [Point]
-    # @overload Point(Vector)
-    #   @return [Point]
-    def self.point(*args)
-	Point[*args]
-    end
 end

data/lib/geometry/arc.rb

@@ -6,11 +6,11 @@ require_relative 'point'
 module Geometry
 
 =begin rdoc
-Arcs are Circles that don't quite go all the way around
+{http://en.wikipedia.org/wiki/Arc_(geometry) Arcs} are Circles that don't quite go all the way around
 
 == Usage
 An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis and goes to the Y-axis (counter-clockwise)
-    arc = Geometry::Arc.new [1,1], 2, 0, 90
+    arc = Geometry::Arc.new center:[1,1], radius:2, start:0, end:90
 =end
 
     class Arc
@@ -20,22 +20,26 @@ An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis an
 	attr_reader :radius
 	attr_reader :start_angle, :end_angle
 
-	# @overload new(center_point, start_point, end_point)
+	# @overload new(center, start, end)
 	#  Create a new {Arc} given center, start and end {Point}s
-	# @param [Point]    center_point    The {Point} at the center
-	# @param [Point]    start_point	    The {Arc} starts at the start {Point}
-	# @param [Point]    end_point	    The {Point} where it all ends
-	# @overload initialize(center, radius, start_angle, end_angle)
-	#  Create a new {Arc} given a center, a radius and start and end angles
-	# @param [Point]    center	The {Point} at the center of it all
-	# @param [Numeric]  radius	Radius
-	# @param [Numeric]  start_angle	Starting angle
-	# @param [Numeric]  end_angle	Ending angle
-	def self.new(*args)
-	    if 4 == args.size
-		original_new(*args)
-	    elsif 3 == args.size
-		ThreePointArc.new(*args)
+	# @option options [Point] :center (PointZero)   The {Point} at the center
+	# @option options [Point] :start    The {Arc} starts at the start {Point}
+	# @option options [Point] :end	    The {Point} where it all ends
+	# @return [Arc]
+	# @overload new(center, radius, start, end)
+	#  Create a new {Arc} given a center {Point}, a radius and start and end angles
+	# @option options [Point]   :center (PointZero)	The {Point} at the center of it all
+	# @option options [Numeric] :radius	Radius
+	# @option options [Numeric] :start	Starting angle
+	# @option options [Numeric] :end	Ending angle
+	# @return [ThreePointArc]
+	def self.new(options={})
+	    center = options.delete(:center) || PointZero.new
+
+	    if options.has_key?(:radius)
+		original_new(center, options[:radius], options[:start], options[:end])
+	    else
+		ThreePointArc.new(center, options[:start], options[:end])
 	    end
 	end
 

data/lib/geometry/circle.rb

@@ -8,9 +8,9 @@ Circles come in all shapes and sizes, but they're usually round.
 
 == Usage
     circle = Geometry::Circle.new [1,2], 3
-    circle = Geometry::Circle.new [1,2], :radius => 3
-    circle = Geometry::Circle.new [1,2], :diameter => 6
-    circle = Geometry::Circle.new :center => [1,2], :diameter => 6
+    circle = Geometry::Circle.new center:[1,2], radius:3
+    circle = Geometry::Circle.new center:[1,2], diameter:6
+    circle = Geometry::Circle.new diameter:6
 =end
 
     class Circle
@@ -22,26 +22,24 @@ Circles come in all shapes and sizes, but they're usually round.
 	# @return [Number]  The {Circle}'s radius
 	attr_reader :radius
 
-	# @overload new(circle, radius)
+	# @overload new(center, radius)
 	#   Construct a {Circle} using a centerpoint and radius
 	#   @param [Point]	center  The center point of the {Circle}
 	#   @param [Number]	radius	The radius of the {Circle}
-	# @overload new(options)
+	# @overload new(center, radius)
 	#   Construct a circle using named center and radius parameters
-	#   @option options [Point]	:center
+	#   @option options [Point]	:center (PointZero)
 	#   @option options [Number]	:radius
-	# @overload new(options)
+	# @overload new(center, diameter)
 	#   Construct a circle using named center and diameter parameters
-	#   @option options [Point]	:center
+	#   @option options [Point]	:center (PointZero)
 	#   @option options [Number]	:diameter
 	def self.new(*args, &block)
 	    options, args = args.partition {|a| a.is_a? Hash}
 	    options = options.reduce({}, :merge)
 	    center, radius = args[0..1]
 
-	    center = Point[center || options[:center]]
-	    raise ArgumentError, "Circle.new requires a center" unless center
-
+	    center ||= (options[:center] || PointZero.new)
 	    radius ||= options[:radius]
 
 	    if radius
@@ -62,12 +60,37 @@ Circles come in all shapes and sizes, but they're usually round.
 	    @radius = radius
 	end
 
+	def eql?(other)
+	    (self.center == other.center) && (self.radius == other.radius)
+	end
+	alias :== :eql?
+
 # @!group Accessors
+	# @return [Rectangle]	The smallest axis-aligned {Rectangle} that bounds the receiver
+	def bounds
+	    return Rectangle.new(self.min, self.max)
+	end
+
 	# @!attribute [r] diameter
 	#   @return [Numeric] The diameter of the {Circle}
 	def diameter
 	    @radius*2
 	end
+
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @center+radius
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @center-radius
+	end
+
+	# @return [Array<Point>]    The lower left and upper right corners of the bounding {Rectangle}
+	def minmax
+	    [self.min, self.max]
+	end
 # @!endgroup
     end
 
@@ -84,8 +107,13 @@ Circles come in all shapes and sizes, but they're usually round.
 	    @diameter = diameter
 	end
 
+	def eql?(other)
+	    (self.center == other.center) && (self.diameter == other.diameter)
+	end
+	alias :== :eql?
+
 # @!group Accessors
-	# @return The {Circle}'s radius
+	# @return [Number] The {Circle}'s radius
 	def radius
 	    @diameter/2
 	end

data/lib/geometry/edge.rb

@@ -1,3 +1,5 @@
+require 'mathn'
+
 require_relative 'point'
 
 module Geometry
@@ -24,6 +26,22 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	    (@first == other.first) && (@last == other.last)
 	end
 
+	# @param [Point] point	A {Point} to spaceship with
+	# @return [Boolean]	Returns 1 if the {Point} is strictly to the left of the receiver, -1 to the right, and 0 if the point is on the receiver
+	def <=>(point)
+	    case point
+		when Point
+		    k = (@last.x - @first.x) * (point.y - @first.y) - (point.x - @first.x) * (@last.y - @first.y)
+		    if 0 == k
+			(((@first.x <=> point.x) + (@last.x <=> point.x)).abs <= 1) && (((@first.y <=> point.y) + (@last.y <=> point.y)).abs <= 1) ? 0 : nil
+		    else
+			k <=> 0
+		    end
+		else
+		    raise ArgumentError, "Can't spaceship with #{point.class}"
+	    end
+	end
+
 	# Return a new {Edge} with swapped endpoints
 	def reverse
 	    Edge.new(@last, @first)
@@ -77,8 +95,12 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	end
 
 	# Find the intersection of two {Edge}s (http://bloggingmath.wordpress.com/2009/05/29/line-segment-intersection/)
+	# @param [Edge] other	The other {Edge}
 	# @return [Point] The intersection of the two {Edge}s, nil if they don't intersect, true if they're collinear and overlapping, and false if they're collinear and non-overlapping
 	def intersection(other)
+	    return self.first if (self.first == other.first) or (self.first == other.last)
+	    return self.last if (self.last == other.first) or (self.last == other.last)
+
 	    p0, p1 = self.first, self.last
 	    p2, p3 = other.first, other.last
 	    v1, v2 = self.vector, other.vector

data/lib/geometry/line.rb

@@ -1,3 +1,4 @@
+require_relative 'cluster_factory'
 require_relative 'point'
 
 module Geometry
@@ -28,6 +29,7 @@ Supports two-point, slope-intercept, and point-slope initializer forms
 =end
 
     class Line
+	include ClusterFactory
 
 	# @overload [](Array, Array)
 	#   @return [TwoPointLine]
@@ -56,6 +58,25 @@ Supports two-point, slope-intercept, and point-slope initializer forms
 	    end
 	end
 
+	# @overload new(from, to)
+	# @option options [Point] :from	A starting {Point}
+	# @option options [Point] :to	An end {Point}
+	# @return [TwoPointLine]
+	# @overload new(start, end)
+	# @option options [Point] :start	A starting {Point}
+	# @option options [Point] :end	An end {Point}
+	# @return [TwoPointLine]
+	def self.new(options={})
+	    from = options[:from] || options[:start]
+	    to = options[:end] || options[:to]
+
+	    if from and to
+		TwoPointLine.new(from, to)
+	    else
+		raise ArgumentError, "Start and end Points must be provided"
+	    end
+	end
+
 	def self.horizontal(y_intercept=0)
 	    SlopeInterceptLine.new(0, y_intercept)
 	end

data/lib/geometry/obround.rb

@@ -0,0 +1,238 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin
+The {Obround} class cluster represents a rectangle with semicircular end caps
+
+{http://en.wiktionary.org/wiki/obround}
+=end
+
+    class Obround
+	include ClusterFactory
+
+	# @overload new(width, height)
+	#   Creates a {Obround} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredObround]
+	# @overload new(size)
+	#   Creates a {Obround} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredObround]
+	# @overload new(point0, point1)
+	#   Creates a {Obround} using the given {Point}s
+	#   @param [Point]    point0	A corner
+	#   @param [Point]    point1	The other corner
+	# @overload new(origin, size)
+	#   Creates a {Obround} from the given origin and size
+	#   @param [Point]	origin	Lower-left corner
+	#   @param [Size]	size	Width and height
+	#   @return [SizedObround]
+	# @overload new(left, bottom, right, top)
+	#   Creates a {Obround} from the locations of each side
+	#   @param [Number]	left	X-coordinate of the left side
+	#   @param [Number]	bottom	Y-coordinate of the bottom edge
+	#   @param [Number]	right	X-coordinate of the right side
+	#   @param [Number]	top	Y-coordinate of the top edge
+	#   @return [Obround]
+	def self.new(*args)
+	    case args.size
+		when 1
+		    CenteredObround.new(args[0])
+		when 2
+		    if args.all? {|a| a.is_a?(Numeric) }
+			CenteredObround.new(Size[*args])
+		    elsif args.all? {|a| a.is_a?(Array) || a.is_a?(Point) }
+			original_new(*args)
+		    elsif (args[0].is_a?(Point) or args[0].is_a?(Array))and args[1].is_a?(Size)
+			SizedObround.new(*args)
+		    else
+			raise ArgumentError, "Invalid arguments #{args}"
+		    end
+		when 4
+		    raise ArgumentError unless args.all? {|a| a.is_a?(Numeric)}
+		    left, bottom, right, top = *args
+		    original_new(Point[left, bottom], Point[right, top])
+	    end
+	end
+
+	# Create a {Obround} using the given {Point}s
+	#  @param [Point0]  point0  The bottom-left corner (closest to the origin)
+	#  @param [Point1]  point1  The top-right corner (farthest from the origin)
+	def initialize(point0, point1)
+	    point0, point1 = Point[point0], Point[point1]
+	    raise(ArgumentError, "Point sizes must match") unless point0.size == point1.size
+
+	    # Reorder the points to get lower-left and upper-right
+	    if (point0.x > point1.x) && (point0.y > point1.y)
+		point0, point1 = point1, point0
+	    else
+		p0x, p1x = [point0.x, point1.x].minmax
+		p0y, p1y = [point0.y, point1.y].minmax
+		point0 = Point[p0x, p0y]
+		point1 = Point[p1x, p1y]
+	    end
+	    @points = [point0, point1]
+	end
+
+	def eql?(other)
+	    self.points == other.points
+	end
+	alias :== :eql?
+
+# @group Accessors
+
+	# @return [Point]   The {Obround}'s center
+	def center
+	    min, max = @points.minmax {|a,b| a.y <=> b.y}
+	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
+	end
+
+	# @return [Array<Point>]    The {Obround}'s four points (counterclockwise)
+	def points
+	    point0, point2 = *@points
+	    point1 = Point[point2.x, point0.y]
+	    point3 = Point[point0.x, point2.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def origin
+	    minx = @points.min {|a,b| a.x <=> b.x}
+	    miny = @points.min {|a,b| a.y <=> b.y}
+	    Point[minx.x, miny.y]
+	end
+
+	def height
+	    min, max = @points.minmax {|a,b| a.y <=> b.y}
+	    max.y - min.y
+	end
+
+	def width
+	    min, max = @points.minmax {|a,b| a.x <=> b.x}
+	    max.x - min.x
+	end
+# @endgroup
+    end
+
+    class CenteredObround < Obround
+	# @return [Point]	The {Obround}'s center
+	attr_accessor :center
+	attr_reader :origin
+	# @return [Size]	The {Size} of the {Obround}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates a {Obround} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredObround]
+	# @overload new(size)
+	#   Creates a {Obround} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredObround]
+	# @overload new(center, size)
+	#   Creates a {Obround} with the given center point and size
+	#   @param [Point]	center
+	#   @param [Size]	size
+	def initialize(*args)
+	    if args[0].is_a?(Size)
+		@center = Point[0,0]
+		@size = args[0]
+	    elsif args[0].is_a?(Geometry::Point) and args[1].is_a?(Geometry::Size)
+		@center, @size = args[0,1]
+	    elsif (2 == args.size) and args.all? {|a| a.is_a?(Numeric)}
+		@center = Point[0,0]
+		@size = Geometry::Size[*args]
+	    end
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.size == other.size)
+	end
+	alias :== :eql?
+
+# @group Accessors
+	# @return [Array<Point>]    The {Obround}'s four points (clockwise)
+	def points
+	    point0 = @center - @size/2.0
+	    point2 = @center + @size/2.0
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    end
+
+    class SizedObround < Obround
+	# @return [Point]   The {Obround}'s center
+	attr_reader :center
+	# @return [Point]	The {Obround}'s origin
+	attr_accessor :origin
+	# @return [Size]	The {Size} of the {Obround}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates an {Obround} of the given width and height with its origin at [0,0]
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return SizedObround
+	# @overload new(size)
+	#   Creates an {Obround} of the given {Size} with its origin at [0,0]
+	#   @param [Size]	size	Width and height
+	#   @return SizedObround
+	# @overload new(origin, size)
+	#   Creates an {Obround} with the given origin point and size
+	#   @param [Point]	origin
+	#   @param [Size]	size
+	#   @return SizedObround
+	def initialize(*args)
+	    if args[0].is_a?(Size)
+		@origin = Point[0,0]
+		@size = args[0]
+	    elsif (args[0].is_a?(Point) or args[0].is_a?(Array)) and args[1].is_a?(Geometry::Size)
+		@origin, @size = Point[args[0]], args[1]
+	    elsif (2 == args.size) and args.all? {|a| a.is_a?(Numeric)}
+		@origin = Point[0,0]
+		@size = Geometry::Size[*args]
+	    end
+	end
+
+	def eql?(other)
+	    (self.origin == other.origin) && (self.size == other.size)
+	end
+	alias :== :eql?
+
+# @group Accessors
+	def center
+	    @origin + @size/2
+	end
+
+	# @return [Array<Point>]    The {Obround}'s four points (clockwise)
+	def points
+	    point0 = @origin
+	    point2 = @origin + @size
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    end
+end