geometry 5 → 6

data/lib/geometry/path.rb

@@ -18,38 +18,50 @@ An object representing a set of connected elements, each of which could be an
 	    @elements = []
 
 	    first = args.shift
-	    @elements.push first if first.is_a?(Edge) or first.is_a?(Arc)
+	    push first if first.is_a?(Edge) or first.is_a?(Arc)
 
 	    args.reduce(first) do |previous, n|
 		case n
 		    when Point
 			case previous
-			    when Point	    then @elements.push Edge.new(previous, n)
-			    when Arc, Edge  then @elements.push Edge.new(previous.last, n) unless previous.last == n
+			    when Point	    then push Edge.new(previous, n)
+			    when Arc, Edge  then push Edge.new(previous.last, n) unless previous.last == n
 			end
-			@elements.last
+			last
 		    when Edge
 			case previous
-			    when Point	    then @elements.push Edge.new(previous, n.first)
-			    when Arc, Edge  then @elements.push Edge.new(previous.last, n.first) unless previous.last == n.first
+			    when Point	    then push Edge.new(previous, n.first)
+			    when Arc, Edge  then push Edge.new(previous.last, n.first) unless previous.last == n.first
 			end
-			@elements.push(n).last
+			push(n).last
 		    when Arc
 			case previous
 			    when Point
 				if previous == n.first
 				    raise ArgumentError, "Duplicated point before an Arc"
 				else
-				    @elements.push Edge.new(previous, n.first)
+				    push Edge.new(previous, n.first)
 				end
 			    when Arc, Edge
-				@elements.push Edge.new(previous.last, n.first) unless previous.last == n.first
+				push Edge.new(previous.last, n.first) unless previous.last == n.first
 			end
-			@elements.push(n).last
+			push(n).last
 		    else
 			raise ArgumentError, "Unsupported argument type: #{n}"
 		end
 	    end
 	end
+
+	# @return [Geometry]	The last element in the {Path}
+	def last
+	    @elements.last
+	end
+
+	# Append a new geometry element to the {Path}
+	# @return [Path]
+	def push(arg)
+	    @elements.push arg
+	    self
+	end
     end
 end

data/lib/geometry/point.rb

@@ -1,5 +1,7 @@
 require 'matrix'
 
+require_relative 'point_zero'
+
 module Geometry
     DimensionMismatch = Class.new(StandardError)
     OperationNotDefined = Class.new(StandardError)
@@ -23,10 +25,11 @@ geometry class (x, y, z).
 	# from Vector or another Point
 	#
 	# @overload [](x,y,z,...)
+	# @overload [](Array)
 	# @overload [](Point)
 	# @overload [](Vector)
 	def self.[](*array)
-	    return array[0] if array[0].is_a? Point
+	    return array[0] if array[0].is_a?(Point) or array[0].is_a?(PointZero)
 	    array = array[0] if array[0].is_a?(Array)
 	    array = array[0].to_a if array[0].is_a?(Vector)
 	    super *array
@@ -40,14 +43,24 @@ geometry class (x, y, z).
 
 	# Allow comparison with an Array, otherwise do the normal thing
 	def eql?(other)
-	    return @elements.eql? other if other.is_a?(Array)
-	    super other
+	    if other.is_a?(Array)
+		@elements.eql? other
+	    elsif other.is_a?(PointZero)
+		@elements.all? {|e| e.eql? 0 }
+	    else
+		super other
+	    end
 	end
 
 	# Allow comparison with an Array, otherwise do the normal thing
 	def ==(other)
-	    return @elements == other if other.is_a?(Array)
-	    super other
+	    if other.is_a?(Array)
+		@elements.eql? other
+	    elsif other.is_a?(PointZero)
+		@elements.all? {|e| e.eql? 0 }
+	    else
+		super other
+	    end
 	end
 
 	# Combined comparison operator
@@ -59,6 +72,7 @@ geometry class (x, y, z).
 	def coerce(other)
 	    case other
 		when Array then [Point[*other], self]
+		when Numeric then [Point[Array.new(self.size, other)], self]
 		when Vector then [Point[*other], self]
 		else
 		    raise TypeError, "#{self.class} can't be coerced into #{other.class}"
@@ -113,8 +127,7 @@ geometry class (x, y, z).
 	def +(other)
 	    case other
 		when Numeric
-		    raise DimensionMismatch, "A scalar can't be added to a Point of dimension greater than 1" if size != 1
-		    Point[@elements.first + other]
+		    Point[@elements.map {|e| e + other}]
 		when PointZero
 		    self
 		else
@@ -127,8 +140,7 @@ geometry class (x, y, z).
 	def -(other)
 	    case other
 		when Numeric
-		    raise DimensionMismatch, "A scalar can't be subtracted from a Point of dimension greater than 1" if size != 1
-		    Point[@elements.first - other]
+		    Point[@elements.map {|e| e - other}]
 		when PointZero
 		    self
 		else

data/lib/geometry/point_zero.rb

@@ -29,6 +29,37 @@ everything else, regardless of size.
 	    end
 	end
 
+	# This is a hack to get Array#== to work properly. It works on ruby 2.0 and 1.9.3.
+	def to_ary
+	    []
+	end
+
+# @group Accessors
+	# @param [Integer]  i	Index into the {Point}'s elements
+	# @return [Numeric] Element i (starting at 0)
+	def [](i)
+	    0
+	end
+
+	# @attribute [r] x
+	# @return [Numeric] X-component
+	def x
+	    0
+	end
+
+	# @attribute [r] y
+	# @return [Numeric] Y-component
+	def y
+	    0
+	end
+
+	# @attribute [r] z
+	# @return [Numeric] Z-component
+	def z
+	    0
+	end
+# @endgroup
+
 # @group Arithmetic
 
 # @group Unary operators
@@ -42,11 +73,17 @@ everything else, regardless of size.
 # @endgroup
 
 	def +(other)
-	    other
+	    case other
+		when Array, Numeric then other
+		else
+		    Point[other]
+	    end
 	end
 
 	def -(other)
-	    if other.respond_to? :-@
+	    if other.is_a? Size
+		-Point[other]
+	    elsif other.respond_to? :-@
 		-other
 	    elsif other.respond_to? :map
 		other.map {|a| -a }

data/lib/geometry/polygon.rb

@@ -8,6 +8,9 @@ A {Polygon} is a closed path comprised entirely of lines so straight they don't
 
 {http://en.wikipedia.org/wiki/Polygon}
 
+The {Polygon} class is generally intended to represent {http://en.wikipedia.org/wiki/Simple_polygon Simple polygons},
+but there's currently nothing that enforces simplicity.
+
 == Usage
 
 =end
@@ -31,6 +34,137 @@ A {Polygon} is a closed path comprised entirely of lines so straight they don't
 	    @edges.push Edge.new(@edges.last.last, @edges.first.first) unless @edges.empty? || (@edges.last.last == @edges.first.first)
 	end
 
+	# Check the orientation of the {Polygon}
+	# @return [Boolean] True if the {Polygon} is clockwise, otherwise false
+	def clockwise?
+	    edges.map {|e| (e.last.x - e.first.x) * (e.last.y + e.first.y)}.reduce(:+) >= 0
+	end
+
+	# @return [Polygon] A new {Polygon} with orientation that's the opposite of the receiver
+	def reverse
+	    self.class.new *(self.vertices.reverse)
+	end
+
+	# @group Boolean operators
+
+	# Test a {Point} for inclusion in the receiver using a simplified winding number algorithm
+	# @param [Point] point	The {Point} to test
+	# @return [Number]	1 if the {Point} is inside the {Polygon}, -1 if it's outside, and 0 if it's on an {Edge}
+	def <=>(point)
+	    sum = edges.reduce(0) do |sum, e|
+		direction = e.last.y <=> e.first.y
+		# Ignore edges that don't cross the point's x coordinate
+		next sum unless ((point.y <=> e.last.y) + (point.y <=> e.first.y)).abs <= 1
+
+		if 0 == direction   # Special case horizontal edges
+		    return 0 if ((point.x <=> e.last.x) + (point.x <=> e.first.x)).abs <= 1
+		    next sum	    # Doesn't intersect
+		else
+		    is_left = e <=> point
+		    return 0 if 0 == is_left
+		    next sum unless is_left
+		    sum += 0 <=> (direction + is_left)
+		end
+	    end
+	    (0 == sum) ? -1 : 1
+	end
+
+	# Create a new {Polygon} that's the union of the receiver and a passed {Polygon}
+	#  This is a simplified implementation of the alogrithm outlined in the
+	#  paper {http://gvu.gatech.edu/people/official/jarek/graphics/papers/04PolygonBooleansMargalit.pdf An algorithm for computing the union, intersection or difference of two polygons}.
+	#  In particular, this method assumes the receiver and passed {Polygon}s are "island" type and that the desired output is "regular", as those terms are described in the paper.
+	# @param [Polygon] other    The {Polygon} to union with the receiver
+	# @return [Polygon] The union of the receiver and the passed {Polygon}
+	def union(other)
+	    # Table 1: Both polygons are islands and the operation is union, so both must have the same orientation
+	    # Reverse the other polygon if the orientations are different
+	    other = other.reverse if self.clockwise? != other.clockwise?
+
+	    # Receiver's vertex ring
+	    ringA = VertexRing.new
+	    self.vertices.each {|v| ringA.push v, (other <=> v)}
+
+	    # The other vertex ring
+	    ringB = VertexRing.new
+	    other.vertices.each {|v| ringB.push v, (self <=> v)}
+
+	    # Find intersections
+	    offsetA = 0
+	    edgesB = other.edges.dup
+	    self.edges.each_with_index do |a, indexA|
+		offsetB = 0
+		ringB.edges_with_index do |b, indexB|
+		    intersection = a.intersection(b)
+		    if intersection === true
+			if (a.first == b.first) and (a.last == b.last)	    # Equal edges
+			elsif (a.first == b.last) and (a.last == b.first)   # Ignore equal but opposite edges
+			else
+			    if a.vector.normalize == b.vector.normalize # Same direction?
+				offsetA += 1 if ringA.insert_boundary(indexA + 1 + offsetA, b.first)
+				offsetB += 1 if ringB.insert_boundary(indexB + 1 + offsetB, a.last)
+			    else    # Opposite direction
+				offsetA += 1 if ringA.insert_boundary(indexA + 1 + offsetA, b.last)
+				offsetB += 1 if ringB.insert_boundary(indexB + 1 + offsetB, a.first)
+			    end
+			end
+		    elsif intersection.is_a?(Point)
+			offsetA += 1 if ringA.insert_boundary(indexA + 1 + offsetA, intersection)
+			offsetB += 1 if ringB.insert_boundary(indexB + 1 + offsetB, intersection)
+		    end
+		end
+	    end
+
+	    # Table 2: Both polygons are islands and the operation is union, so select outside from both polygons
+	    edgeFragments = []
+	    [[ringA, other], [ringB, self]].each do |ring, other_polygon|
+		ring.edges do |v1,v2|
+		    if (v1[:type] == -1) or (v2[:type] == -1)
+			edgeFragments.push :first => v1[:vertex], :last => v2[:vertex]
+		    elsif (v1[:type] == 0) and (v2[:type] == 0)
+			if (other_polygon <=> Point[(v1[:vertex] + v2[:vertex])/2]) <= 0
+			    edgeFragments.push :first => v1[:vertex], :last => v2[:vertex]
+			end
+		    end
+		end
+	    end
+
+	    # Delete any duplicated edges. Array#uniq doesn't do the right thing, so using inject instead.
+	    edgeFragments = edgeFragments.inject([]) {|result,h| result << h unless result.include?(h); result}
+
+	    # Delete any equal-and-opposite edges
+	    edgeFragments = edgeFragments.reject {|f| edgeFragments.find {|f2| (f[:first] == f2[:last]) and (f[:last] == f2[:first])} }
+
+	    # Construct the output polygons
+	    output = edgeFragments.reduce([Array.new]) do |output, fragment|
+		next output if fragment.empty?
+		polygon = output.last
+		polygon.push fragment[:first], fragment[:last] if polygon.empty?
+		while 1 do
+		    adjacent_fragment = edgeFragments.find {|f| fragment[:last] == f[:first]}
+		    break unless adjacent_fragment
+
+		    polygon.push adjacent_fragment[:first], adjacent_fragment[:last]
+		    fragment = adjacent_fragment.dup
+		    adjacent_fragment.clear
+
+		    break if polygon.first == polygon.last	# closed?
+		end
+		output << Array.new
+	    end
+
+	    # If everything worked properly there should be only one output Polygon
+	    output.reject! {|a| a.empty?}
+	    output = Polygon.new *(output[0])
+
+	    # Table 4: Both input polygons are "island" type and the operation
+	    #  is union, so the output polygon's orientation should be the same
+	    #  as the input polygon's orientation
+	    (self.clockwise? != output.clockwise?) ? output.reverse : output
+	end
+	alias :+ :union
+
+	# @endgroup
+
 	# @group Convex Hull
 
 	# Returns the convex hull of the {Polygon}
@@ -179,4 +313,50 @@ A {Polygon} is a closed path comprised entirely of lines so straight they don't
 	    dx / (dx + dy)
 	end
     end
+
+    private
+
+    class VertexRing
+	attr_reader :vertices
+
+	def initialize
+	    @vertices = []
+	end
+
+	# @param [Integer] index	The index to insert the new {Point} before
+	# @param [Point] point		The {Point} to insert
+	# @param [Integer] type		The vertex type: 1 is inside, 0 is boundary, -1 is outside
+	def insert(index, point, type)
+	    if v = @vertices.find {|v| v[:vertex] == point }
+		v[:type] = type
+		false
+	    else
+		@vertices.insert(index, {:vertex => point, :type => type})
+		true
+	    end
+	end
+
+	# Insert a boundary vertex
+	# @param [Integer] index	The index to insert the new {Point} before
+	# @param [Point] point		The {Point} to insert
+	def insert_boundary(index, point)
+	    self.insert(index, point, 0)
+	end
+
+	# @param [Point] point		The {Point} to push
+	# @param [Integer] type		The vertex type: 1 is inside, 0 is boundary, -1 is outside
+	def push(point, type)
+	    @vertices << {:vertex => point, :type => type}
+	end
+
+	# Enumerate the pairs of vertices corresponding to each edge
+	def edges
+	    (@vertices + [@vertices.first]).each_cons(2) {|v1,v2| yield v1, v2}
+	end
+
+	def edges_with_index
+	    index = 0
+	    (@vertices + [@vertices.first]).each_cons(2) {|v1,v2| yield(Edge.new(v1[:vertex], v2[:vertex]), index); index += 1}
+	end
+    end
 end

data/lib/geometry/polyline.rb

@@ -48,13 +48,13 @@ also like a {Path} in that it isn't necessarily closed.
 			if @edges.last
 			    new_edge = Edge.new(previous, n)
 			    if @edges.last.parallel?(new_edge)
-				@edges.pop				# Remove the previous Edge
+				popped_edge = @edges.pop		# Remove the previous Edge
 				@vertices.pop(@edges.size ? 1 : 2)	# Remove the now unused vertex, or vertices
-				if n == @edges.last.last
-				    @edges.last.last
+				if n == popped_edge.first
+				    popped_edge.first
 				else
-				    push_edge Edge.new(@edges.last.last, n)
-				    push_vertex @edges.last.first
+				    push_edge Edge.new(popped_edge.first, n)
+				    push_vertex popped_edge.first
 				    push_vertex n
 				    n
 				end

data/lib/geometry/rectangle.rb

@@ -1,6 +1,7 @@
 require_relative 'cluster_factory'
 require_relative 'edge'
 require_relative 'point'
+require_relative 'point_zero'
 require_relative 'size'
 
 module Geometry
@@ -10,13 +11,15 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 == Usage
 
 === Constructors
-    rect = Rectangle[[1,2], [2,3]]      # Using two corners
-    rect = Rectangle[[1,2], Size[1,1]]  # Using origin and size
-    rect = Rectangle[1,2,2,3]           # Using four sides
+    rect = Rectangle.new [1,2], [2,3]		    # Using two corners
+    rect = Rectangle.new from:[1,2], to:[2,3]	    # Using two corners
 
-    rect = Rectangle[10, 20]            # origin = [0,0], size = [10, 20]
-    rect = Rectangle[Size[10, 20]]      # origin = [0,0], size = [10, 20]
+    rect = Rectangle.new center:[1,2], size:[1,1]   # Using a center point and a size
+    rect = Rectangle.new origin:[1,2], size:[1,1]   # Using an origin point and a size
 
+    rect = Rectangle.new size: [10, 20]         # origin = [0,0], size = [10, 20]
+    rect = Rectangle.new size: Size[10, 20]	# origin = [0,0], size = [10, 20]
+    rect = Rectangle.new width: 10, height: 20	# origin = [0,0], size = [10, 20]
 =end
 
     class Rectangle
@@ -44,8 +47,8 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	#   @return [CenteredRectangle]
 	# @overload new(point0, point1)
 	#   Creates a {Rectangle} using the given {Point}s
-	#   @param [Point,Array]    point0	A corner
-	#   @param [Point,Array]    point1	The other corner
+	#   @param [Point]    point0	A corner
+	#   @param [Point]    point1	The other corner
 	# @overload new(origin, size)
 	#   Creates a {Rectangle} from the given origin and size
 	#   @param [Point]	origin	Lower-left corner
@@ -58,21 +61,25 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	#   @param [Number]	right	X-coordinate of the right side
 	#   @param [Number]	top	Y-coordinate of the top edge
 	def self.new(*args)
-	    case args.size
-		when 1
-		    CenteredRectangle.new(args[0])
-		when 2
-		    if args.all? {|a| a.is_a?(Numeric) }
-			CenteredRectangle.new(Size[*args])
-		    elsif args.all? {|a| a.is_a?(Array) || a.is_a?(Point) }
-			original_new(*args)
-		    elsif args[0].is_a?(Point) and args[1].is_a?(Size)
-			SizedRectangle.new(*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])
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    if options.has_key?(:size)
+		if options.has_key?(:center)
+		    CenteredRectangle.new(center: options[:center], size: options[:size])
+		elsif options.has_key?(:origin)
+		    SizedRectangle.new(origin: options[:origin], size: options[:size])
+		else
+		    SizedRectangle.new(size: options[:size])
+		end
+	    elsif options.has_key?(:from) and options.has_key?(:to)
+		original_new(options[:from], options[:to])
+	    elsif options.has_key?(:height) and options.has_key?(:width)
+		SizedRectangle.new(height: options[:height], width: options[:width])
+	    elsif (2==args.count) and (args.all? {|a| a.is_a?(Array) || a.is_a?(Point) })
+		original_new(*args)
+	    else
+		raise ArgumentError, "Bad Rectangle arguments: #{args}, #{options}"
 	    end
 	end
 
@@ -88,40 +95,63 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    if (point0.x > point1.x) && (point0.y > point1.y)
 		point0, point1 = point1, point0
 	    else
-		if point0.x > point1.x
-		    point0.x, point1.x = point1.x, point0.x
-		end
-		if point0.y > point1.y
-		    point0.y, point1.y = point1.y, point0.y
-		end
+		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 [Rectangle]	The smallest axis-aligned {Rectangle} that bounds the receiver
+	def bounds
+	    return Rectangle.new(self.min, self.max)
+	end
+
 	# @return [Point]   The {Rectangle}'s center
 	def center
 	    min, max = @points.minmax {|a,b| a.y <=> b.y}
-	    Point[(max.x+min.x)/2.0, (max.y+min.y)/2.0]
+	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
 	end
 
-	# @return [Array<Edge>]   The {Rectangle}'s four edges
+	# @return [Array<Edge>]   The {Rectangle}'s four edges (counterclockwise)
 	def edges
 	    point0, point2 = *@points
-	    point1 = Point[point0.x,point2.y]
-	    point3 = Point[point2.x, point0.y]
+	    point1 = Point[point2.x, point0.y]
+	    point3 = Point[point0.x, point2.y]
 	    [Edge.new(point0, point1),
 	     Edge.new(point1, point2),
 	     Edge.new(point2, point3),
 	     Edge.new(point3, point0)]
 	end
 
-	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @points.last
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @points.first
+	end
+
+	# @return [Array<Point>]    The lower left and upper right corners of the bounding {Rectangle}
+	def minmax
+	    [self.min, self.max]
+	end
+
+	# @return [Array<Point>]    The {Rectangle}'s four points (counterclockwise)
 	def points
 	    point0, point2 = *@points
-	    point1 = Point[point0.x,point2.y]
-	    point3 = Point[point2.x, point0.y]
+	    point1 = Point[point2.x, point0.y]
+	    point3 = Point[point0.x, point2.y]
 	    [point0, point1, point2, point3]
 	end
 
@@ -146,7 +176,6 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
     class CenteredRectangle < Rectangle
 	# @return [Point]	The {Rectangle}'s center
 	attr_accessor :center
-	attr_reader :origin
 	# @return [Size]	The {Size} of the {Rectangle}
 	attr_accessor :size
 
@@ -164,17 +193,25 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	#   @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]
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    @center = options[:center] ? Point[options[:center]] : PointZero.new
+
+	    if options.has_key?(:size)
+		@size = Geometry::Size[options[:size]]
+	    elsif options.has_key?(:height) and options.has_key?(:width)
+		@size = Geometry::Size[options[:width], options[:height]]
+	    else
+		raise ArgumentError, "Bad arguments to CenteredRectangle#new"
 	    end
 	end
 
+	def eql?(other)
+	    (self.center == other.center) && (self.size == other.size)
+	end
+	alias :== :eql?
+
 # @group Accessors
 	# @return [Array<Edge>]   The {Rectangle}'s four edges
 	def edges
@@ -188,6 +225,16 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    Edge.new(point3, point0)]
 	end
 
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @center + @size/2.0
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @center - @size/2.0
+	end
+
 	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
 	def points
 	    point0 = @center - @size/2.0
@@ -208,8 +255,6 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
     end
 
     class SizedRectangle < Rectangle
-	# @return [Point]   The {Rectangle}'s center
-	attr_reader :center
 	# @return [Point]	The {Rectangle}'s origin
 	attr_accessor :origin
 	# @return [Size]	The {Size} of the {Rectangle}
@@ -230,19 +275,27 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	#   @param [Size]	size
 	#   @return SizedRectangle
 	def initialize(*args)
-	    if args[0].is_a?(Size)
-		@origin = Point[0,0]
-		@size = args[0]
-	    elsif args[0].is_a?(Geometry::Point) and args[1].is_a?(Geometry::Size)
-		@origin, @size = args[0], args[1]
-	    elsif (2 == args.size) and args.all? {|a| a.is_a?(Numeric)}
-		@origin = Point[0,0]
-		@size = Geometry::Size[*args]
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    @origin = options[:origin] ? Point[options[:origin]] : PointZero.new
+
+	    if options.has_key?(:size)
+		@size = Geometry::Size[options[:size]]
+	    elsif options.has_key?(:height) and options.has_key?(:width)
+		@size = Geometry::Size[options[:width], options[:height]]
+	    else
+		raise ArgumentError, "Bad arguments to SizeRectangle#new"
 	    end
 	end
 
+	def eql?(other)
+	    (self.origin == other.origin) && (self.size == other.size)
+	end
+	alias :== :eql?
 
 # @group Accessors
+	# @return [Point]   The {Rectangle}'s center
 	def center
 	    @origin + @size/2
 	end
@@ -259,6 +312,16 @@ The {Rectangle} class cluster represents your typical arrangement of 4 corners a
 	    Edge.new(point3, point0)]
 	end
 
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @origin + @size
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @origin
+	end
+
 	# @return [Array<Point>]    The {Rectangle}'s four points (clockwise)
 	def points
 	    point0 = @origin