geometry-in-ruby 0.0.1

data/lib/geometry/polyline.rb

@@ -0,0 +1,318 @@
+require_relative 'edge'
+
+module Geometry
+
+=begin rdoc
+A {Polyline} is like a {Polygon} in that it only contains straight lines, but
+also like a {Path} in that it isn't necessarily closed.
+
+{http://en.wikipedia.org/wiki/Polyline}
+
+== Usage
+
+=end
+
+    class Polyline
+	attr_reader :edges, :vertices
+
+	# Construct a new Polyline from Points and/or Edges
+	# @note The constructor will try to convert all of its arguments into {Point}s and
+	#   {Edge}s. Then successive {Point}s will be collpased into {Edge}s. Successive
+	#   {Edge}s that share a common vertex will be added to the new {Polyline}. If
+	#   there's a gap between {Edge}s it will be automatically filled with a new
+	#   {Edge}.
+	# @overload initialize(Edge, Edge, ...)
+	#   @return [Polyline]
+	# @overload initialize(Point, Point, ...)
+	#   @return [Polyline]
+	def initialize(*args)
+	    args.map! {|a| (a.is_a?(Array) || a.is_a?(Vector)) ? Point[a] : a}
+	    args.each {|a| raise ArgumentError, "Unknown argument type #{a.class}" unless a.is_a?(Point) or a.is_a?(Edge) }
+
+	    @edges = [];
+	    @vertices = [];
+
+	    first = args.shift
+	    if first.is_a?(Point)
+		@vertices.push first
+	    elsif first.is_a?(Edge)
+		@edges.push first
+		@vertices.push *(first.to_a)
+	    end
+
+	    args.reduce(@vertices.last) do |previous,n|
+		if n.is_a?(Point)
+		    if n == previous	# Ignore repeated Points
+			previous
+		    else
+			if @edges.last
+			    new_edge = Edge.new(previous, n)
+			    if @edges.last.parallel?(new_edge)
+				popped_edge = @edges.pop		# Remove the previous Edge
+				@vertices.pop(@edges.size ? 1 : 2)	# Remove the now unused vertex, or vertices
+				if n == popped_edge.first
+				    popped_edge.first
+				else
+				    push_edge Edge.new(popped_edge.first, n)
+				    push_vertex popped_edge.first
+				    push_vertex n
+				    n
+				end
+			    else
+				push_edge Edge.new(previous, n)
+				push_vertex n
+				n
+			    end
+			else
+			    push_edge Edge.new(previous, n)
+			    push_vertex n
+			    n
+			end
+		    end
+		elsif n.is_a?(Edge)
+		    if previous == n.first
+			push_edge n
+			push_vertex n.last
+		    elsif previous == n.last
+			push_edge n.reverse!
+			push_vertex n.last
+		    else
+			e = Edge.new(previous, n.first)
+			push_edge e, n
+			push_vertex *(e.to_a), *(n.to_a)
+		    end
+		    n.last
+		end
+	    end
+	end
+
+	# Check the equality of two {Polyline}s. Note that if two {Polyline}s have
+	#  opposite winding, but are otherwise identical, they will be considered unequal.
+	# @return [Bool] true if both {Polyline}s have equal edges
+	def eql?(other)
+	    @vertices.zip(other.vertices).all? {|a,b| a == b}
+	end
+	alias :== :eql?
+
+	# Clone the receiver, close it, then return it
+	# @return [Polyline]	the closed clone of the receiver
+	def close
+	    clone.close!
+	end
+
+	# Close the receiver and return it
+	# @return [Polyline]	the receiver after closing
+	def close!
+	    push_edge Edge.new(@edges.last.last, @edges.first.first) unless @edges.empty? || closed?
+	    self
+	end
+
+	# Check to see if the {Polyline} is closed (ie. is it a {Polygon}?)
+	# @return [Bool] true if the {Polyline} is closed (the first vertex is equal to the last vertex)
+	def closed?
+	    @edges.last.last == @edges.first.first
+	end
+
+	# Clone the receiver, reverse it, then return it
+	# @return [Polyline]	the reversed clone
+	def reverse
+	    self.class.new *(edges.reverse.map! {|edge| edge.reverse! })
+	end
+
+	# Reverse the receiver and return it
+	# @return [Polyline]	the reversed receiver
+	def reverse!
+	    vertices.reverse!
+	    edges.reverse!.map! {|edge| edge.reverse! }
+	    self
+	end
+
+	# @group Bisectors
+
+	# Generate the angle bisector unit vectors for each vertex
+	# @note If the {Polyline} isn't closed (the normal case), then the first and
+	#   last vertices will be given bisectors that are perpendicular to themselves.
+	# @return [Array<Vector>]   the unit {Vector}s representing the angle bisector of each vertex
+	def bisectors
+	    # Multiplying each bisector by the sign of k flips any bisectors that aren't pointing towards the interior of the angle
+	    bisector_map {|b, k| k <=> 0 }
+	end
+
+	# Generate left-side angle bisector unit vectors for each vertex
+	# @note This is similar to the #bisector method, but generates vectors that always point to the left side of the {Polyline} instead of towards the inside of each corner
+	# @return [Array<Vector>]   the unit {Vector}s representing the left-side angle bisector of each vertex
+	def left_bisectors
+	    bisector_map
+	end
+
+	# Generate right-side angle bisector unit vectors for each vertex
+	# @note This is similar to the #bisector method, but generates vectors that always point to the right side of the {Polyline} instead of towards the inside of each corner
+	# @return [Array<Vector>]   the unit {Vector}s representing the ride-side angle bisector of each vertex
+	def right_bisectors
+	    bisector_map {|b, k| -1 }
+	end
+
+	# Generate the spokes for each vertex. A spoke is the same as a bisector, but in the oppostire direction (bisectors point towards the inside of each corner; spokes point towards the outside)
+	# @note If the {Polyline} isn't closed (the normal case), then the first and
+	#   last vertices will be given bisectors that are perpendicular to themselves.
+	# @return [Array<Vector>]   the unit {Vector}s representing the spoke of each vertex
+	def spokes
+	    # Multiplying each bisector by the negated sign of k flips any bisectors that aren't pointing towards the exterior of the angle
+	    bisector_map {|b, k| 0 <=> k }
+	end
+
+	# @endgroup Bisectors
+
+	# Offset the receiver by the specified distance
+	# @note A positive distance will offset to the left, and a negative distance to the right.
+	# @param [Number] distance	The distance to offset by
+	# @return [Polyline] A new {Polyline} outset by the given distance
+	def offset(distance)
+	    bisector_pairs = if closed?
+		bisector_edges = offset_bisectors(distance)
+		bisector_edges.push(bisector_edges.first).each_cons(2)
+	    else
+		offset_bisectors(distance).each_cons(2)
+	    end
+
+	    # Create the offset edges and then wrap them in Hashes so the edges
+	    #  can be altered while walking the array
+	    active_edges = edges.zip(bisector_pairs).map do |e,offset|
+		offset_edge = Edge.new(e.first+offset.first.vector, e.last+offset.last.vector)
+
+		# Skip zero-length edges
+		{:edge => (offset_edge.first == offset_edge.last) ? nil : offset_edge}
+	    end
+
+	    # Walk the array and handle any intersections
+	    for i in 0..(active_edges.count-1) do
+		e1 = active_edges[i][:edge]
+		next unless e1	# Ignore deleted edges
+
+		intersection, j = find_last_intersection(active_edges, i, e1)
+		if intersection
+		    e2 = active_edges[j][:edge]
+		    if intersection.is_a? Point
+			active_edges[i][:edge] = Edge.new(e1.first, intersection)
+			active_edges[j][:edge] = Edge.new(intersection, e2.last)
+		    else
+			# Handle the collinear case
+			active_edges[i][:edge] = Edge.new(e1.first, e2.last)
+			active_edges[j].delete(:edge)
+		    end
+
+		    # Delete everything between e1 and e2
+		    for k in i..j do
+			next if (k==i) or (k==j)    # Exclude e1 and e2
+			active_edges[k].delete(:edge)
+		    end
+
+		    redo    # Recheck the modified edges
+		end
+	    end
+	    Polyline.new *(active_edges.map {|e| e[:edge]}.compact.map {|e| [e.first, e.last]}.flatten)
+	end
+	alias :leftset :offset
+
+	# Rightset the receiver by the specified distance
+	# @param [Number] distance	The distance to offset by
+	# @return [Polyline] A new {Polyline} rightset by the given distance
+	def rightset(distance)
+	    offset(-distance)
+	end
+
+	private
+
+	# Generate bisectors and k values with an optional mapping block
+	# @note If the {Polyline} isn't closed (the normal case), then the first and
+	#   last vertices will be given bisectors that are perpendicular to themselves.
+	# @return [Array<Vector>]   the unit {Vector}s representing the angle bisector of each vertex
+	def bisector_map
+	    winding = 0
+	    tangent_loop.each_cons(2).map do |v1,v2|
+		k = v1[0]*v2[1] - v1[1]*v2[0]	# z-component of v1 x v2
+		winding += k
+		if v1 == v2			# collinear, same direction?
+		    bisector = Vector[-v1[1], v1[0]]
+		    block_given? ? (bisector * yield(bisector, 1)) : bisector
+		elsif 0 == k			# collinear, reverse direction
+		    nil
+		else
+		    bisector_y = (v2[1] - v1[1])/k
+
+		    # If v1 or v2 happens to be horizontal, then the other one must be used when calculating
+		    #  the x-component of the bisector (to avoid a divide by zero). But, comparing floats
+		    #  with zero is problematic, so use the one with the largest y-component instead checking
+		    #  for a y-component equal to zero.
+		    v = (v2[1].abs > v1[1].abs) ? v2 : v1
+
+		    bisector = Vector[(v[0]*bisector_y - 1)/v[1], bisector_y]
+		    block_given? ? (bisector * yield(bisector, k)) : bisector
+		end
+	    end
+	end
+
+	# @group Helpers for offset()
+
+	# Vertex bisectors suitable for offsetting
+	# @param [Number] length    The distance to offset by. Positive generates left offset bisectors, negative generates right offset bisectors
+	# @return [Array<Edge>]	{Edge}s representing the bisectors
+	def offset_bisectors(length)
+	    vertices.zip(left_bisectors).map {|v,b| b ? Edge.new(v, v+(b * length)) : nil}
+	end
+
+	# Generate the tangents and fake a circular buffer while accounting for closedness
+	# @return [Array<Vector>]   the tangents
+	def tangent_loop
+	    edges.map {|e| e.direction }.tap do |tangents|
+		# Generating a bisector for each vertex requires an edge on both sides of each vertex.
+		# Obviously, the first and last vertices each have only a single adjacent edge, unless the
+		# Polyline happens to be closed (like a Polygon). When not closed, duplicate the
+		# first and last direction vectors to fake the adjacent edges. This causes the first and last
+		# edges to have bisectors that are perpendicular to themselves.
+		if closed?
+		    # Prepend the last direction vector so that the last edge can be used to find the bisector for the first vertex
+		    tangents.unshift tangents.last
+		else
+		    # Duplicate the first and last direction vectors to compensate for not having edges adjacent to the first and last vertices
+		    tangents.unshift(tangents.first)
+		    tangents.push(tangents.last)
+		end
+	    end
+	end
+
+	# Find the next edge that intersects with e, starting at index i
+	def find_next_intersection(edges, i, e)
+	    for j in i..(edges.count-1)
+		e2 = edges[j][:edge]
+		next if !e2 || e.connected?(e2)
+		intersection = e.intersection(e2)
+		return [intersection, j] if intersection
+	    end
+	    nil
+	end
+
+	# Find the last edge that intersects with e, starting at index i
+	def find_last_intersection(edges, i, e)
+	    intersection, intersection_at = nil, nil
+	    for j in i..(edges.count-1)
+		e2 = edges[j][:edge]
+		next if !e2 || e.connected?(e2)
+		_intersection = e.intersection(e2)
+		intersection, intersection_at = _intersection, j if _intersection
+	    end
+	    [intersection, intersection_at]
+	end
+	# @endgroup
+
+	def push_edge(*e)
+	    @edges.push *e
+	    @edges.uniq!
+	end
+
+	def push_vertex(*v)
+	    @vertices.push *v
+	    @vertices.uniq!
+	end
+    end
+end

data/lib/geometry/rectangle.rb

@@ -0,0 +1,378 @@
+require_relative 'cluster_factory'
+require_relative 'edge'
+require_relative 'point'
+require_relative 'point_zero'
+require_relative 'size'
+
+module Geometry
+=begin
+The {Rectangle} class cluster represents your typical arrangement of 4 corners and 4 sides.
+
+== Usage
+
+=== Constructors
+    rect = Rectangle.new [1,2], [2,3]		    # Using two corners
+    rect = Rectangle.new from:[1,2], to:[2,3]	    # Using two corners
+
+    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
+	include ClusterFactory
+
+	# @return [Point]   The {Rectangle}'s center
+	attr_reader :center
+	# @return [Number]  Height of the {Rectangle}
+	attr_reader :height
+	# @return [Point]   The {Rectangle}'s origin
+	attr_reader :origin
+	# @return [Size]    The {Size} of the {Rectangle}
+	attr_reader :size
+	# @return [Number]  Width of the {Rectangle}
+	attr_reader :width
+
+	# @overload new(width, height)
+	#   Creates a {Rectangle} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredRectangle]
+	# @overload new(size)
+	#   Creates a {Rectangle} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredRectangle]
+	# @overload new(point0, point1)
+	#   Creates a {Rectangle} using the given {Point}s
+	#   @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
+	#   @param [Size]	size	Width and height
+	#   @return [SizedRectangle]
+	# @overload new(left, bottom, right, top)
+	#   Creates a {Rectangle} 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
+	def self.new(*args)
+	    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)
+	    elsif options.empty?
+		raise ArgumentError, "#{self} arguments must be named, not: #{args}"
+	    else
+		raise ArgumentError, "Bad Rectangle arguments: #{args}, #{options}"
+	    end
+	end
+
+	# Creates a {Rectangle} using the given {Point}s
+	#   @param [Point]	point0	A corner (ie. bottom-left)
+	#   @param [Point]	point1	The other corner (ie. top-right)
+	def initialize(point0, point1)
+	    point0 = Point[point0]
+	    point1 = 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 [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, (max.y+min.y)/2]
+	end
+
+	# @return [Array<Edge>]   The {Rectangle}'s four edges (counterclockwise)
+	def edges
+	    point0, point2 = *@points
+	    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 [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[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
+
+	# Create a new {Rectangle} from the receiver that's inset by the given amount
+	# @overload inset(x, y)
+	# @overload inset(top, left, bottom, right)
+	# @overload inset(x, y)
+	#   @option options [Number] :x	    Inset from the left and right sides
+	#   @option options [Number] :y	    Inset from the top and bottom
+	# @overload inset(top, left, bottom, right)
+	#   @option options [Number] :bottom	The inset from the bottom of the {Rectangle}
+	#   @option options [Number] :left	The inset from the left side of the {Rectangle}
+	#   @option options [Number] :right	The inset from the right side of the {Rectangle}
+	#   @option options [Number] :top	The inset from the top of the {Rectangle}
+	def inset(*args)
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+	    raise ArumentError, "Can't specify both arguments and options" if !args.empty? && !options.empty?
+
+	    if 1 == args.size
+		distance = args.shift
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif 2 == args.size
+		distance = Point[*args]
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif 4 == args.size
+		top, left, bottom, right = *args
+		Rectangle.new from:(min + Point[left, bottom]), to:(max - Point[right, top])
+	    elsif options[:x] && options[:y]
+		distance = Point[options[:x], options[:y]]
+		Rectangle.new from:(min + distance), to:(max - distance)
+	    elsif options[:top] && options[:left] && options[:bottom] && options[:right]
+		Rectangle.new from:(min + Point[options[:left], options[:bottom]]), to:(max - Point[options[:right], options[:top]])
+	    end
+	end
+    end
+
+    class CenteredRectangle < Rectangle
+	# @return [Point]	The {Rectangle}'s center
+	attr_accessor :center
+	# @return [Size]	The {Size} of the {Rectangle}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates a {Rectangle} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredRectangle]
+	# @overload new(size)
+	#   Creates a {Rectangle} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredRectangle]
+	# @overload new(center, size)
+	#   Creates a {Rectangle} with the given center point and size
+	#   @param [Point]	center
+	#   @param [Size]	size
+	def initialize(*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
+	    point0 = @center - @size/2.0
+	    point2 = @center + @size/2.0
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [Edge.new(point0, point1),
+	    Edge.new(point1, point2),
+	    Edge.new(point2, point3),
+	    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
+	    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 SizedRectangle < Rectangle
+	# @return [Point]	The {Rectangle}'s origin
+	attr_accessor :origin
+	# @return [Size]	The {Size} of the {Rectangle}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates a {Rectangle} of the given width and height with its origin at [0,0]
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return SizedRectangle
+	# @overload new(size)
+	#   Creates a {Rectangle} of the given {Size} with its origin at [0,0]
+	#   @param [Size]	size	Width and height
+	#   @return SizedRectangle
+	# @overload new(origin, size)
+	#   Creates a {Rectangle} with the given origin point and size
+	#   @param [Point]	origin
+	#   @param [Size]	size
+	#   @return SizedRectangle
+	def initialize(*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
+
+	# @return [Array<Edge>]   The {Rectangle}'s four edges
+	def edges
+	    point0 = @origin
+	    point2 = @origin + @size
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [Edge.new(point0, point1),
+	    Edge.new(point1, point2),
+	    Edge.new(point2, point3),
+	    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
+	    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