geometry 2 → 3

data/README.markdown

@@ -21,6 +21,7 @@ Primitives
 - Point
 - Line
 - Circle
+- Rectangle
 
 Examples
 --------
@@ -63,5 +64,5 @@ Examples
 ### Circle
 ```ruby
     # A circle at Point[1,2] with a radius of 3
-    circle = Geometry::Circle [1,2], 3
+    circle = Geometry::Circle.new [1,2], 3
 ```

data/geometry.gemspec

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

data/lib/geometry.rb

@@ -2,6 +2,8 @@ require_relative 'geometry/circle'
 require_relative 'geometry/point'
 require_relative 'geometry/line'
 require_relative 'geometry/polygon'
+require_relative 'geometry/rectangle'
+require_relative 'geometry/size'
 
 module Geometry
     # @overload Line(array0, array1)

data/lib/geometry/circle.rb

@@ -4,14 +4,18 @@ module Geometry
 
 =begin rdoc
 Circles come in all shapes and sizes, but they're usually round.
- 
+
 == Usage
-    circle = Geometry::Circle [1,1], 2
+    circle = Geometry::Circle.new [1,1], 2
 =end
-    
+
     class Circle
-	attr_reader :center, :radius
-	
+	# @return [Point]   The Circle's center point
+	attr_reader :center
+
+	# @return [Number]  The Circle's radius
+	attr_reader :radius
+
 	# Construct a new {Circle} from a centerpoint and radius
 	# @param    [Point]	center  The center point of the Circle
 	# @param    [Number]	radius  The radius of the Circle

data/lib/geometry/point.rb

@@ -55,5 +55,20 @@ geometry class (x, y, z).
 	def z
 	    @elements[2]
 	end
+
+# @group Arithmetic
+#  Override the arithmetic operators to force them to return {Point}s instead
+#  of {Vector}s
+
+	def +(other)
+	    Point[super]
+	end
+
+	def -(other)
+	    Point[super]
+	end
+
+# @endgroup
+
     end
 end

data/lib/geometry/rectangle.rb

@@ -0,0 +1,261 @@
+require_relative 'edge'
+require_relative 'point'
+require_relative 'size'
+
+module Geometry
+=begin
+The {Rectangle} class cluster represents your typical arrangement of 4 corners and 4 sides.
+
+== 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[10, 20]		# origin = [0,0], size = [10, 20]
+    rect = Rectangle[Size[10, 20]]	# origin = [0,0], size = [10, 20]
+
+=end
+
+    class Rectangle
+	# @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
+
+	class << self
+	    alias :original_new :new
+	end
+
+	# @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,Array]    point0	A corner
+	#   @param [Point,Array]    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)
+	    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])
+	    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 = point0.is_a?(Point) ? point0 : Point[point0]
+	    point1 = point1.is_a?(Point) ? 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
+		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
+	    end
+	    @points = [point0, point1]
+	end
+
+# @group Accessors
+	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
+	def edges
+	    point0, point2 = *@points
+	    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
+
+	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 CenteredRectangle < Rectangle
+	# @return [Point]	The {Rectangle}'s center
+	attr_accessor :center
+	attr_reader :origin
+	# @return [Size]	The {Size} of the {Rectangle}
+	attr_accessor :size
+
+	def self.new(*args)
+	    original_new(*args)
+	end
+
+	# @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)
+	    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
+
+# @group Accessors
+	# @return [Array<Edge>]   The {Rectangle}'s four edges
+	def edges
+	    point0 = @center - @size/2
+	    point2 = @center + @size/2
+	    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
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    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}
+	attr_accessor :size
+
+	def self.new(*args)
+	    original_new(*args)
+	end
+
+	# @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)
+	    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]
+	    end
+	end
+
+
+# @group Accessors
+	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
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    end
+end

data/lib/geometry/size.rb

@@ -0,0 +1,75 @@
+require 'matrix'
+
+module Geometry
+=begin
+An object representing the size of something.
+ 
+Supports all of the familiar {Vector} methods as well as a few convenience 
+methods (width, height and depth).
+ 
+== Usage
+ 
+=== Constructor
+   size = Geometry::Size[x,y,z]
+=end
+
+    class Size < Vector
+	attr_reader :x, :y, :z
+	
+	# Allow vector-style initialization, but override to support copy-init
+	# from Vector, Point or another Size
+	#
+	# @overload [](x,y,z,...)
+	# @overload [](Point)
+	# @overload [](Size)
+	# @overload [](Vector)
+	# @return [Size]    A new {Size} object
+	def self.[](*array)
+	    array = array[0].to_a unless array[0].is_a?(Numeric)
+	    super *array
+	end
+	
+	# Allow comparison with an Array, otherwise do the normal thing
+	def ==(other)
+	    return @elements == other if other.is_a?(Array)
+	    super other
+	end
+
+	def inspect
+	    'Size' + @elements.inspect
+	end
+	def to_s
+	    'Size' + @elements.to_s
+	end
+
+	# @return [Number]  The size along the Z axis
+	def depth
+	    z
+	end
+
+	# @return [Number]  The size along the Y axis
+	def height
+	    y
+	end
+
+	# @return [Number]  The size along the X axis
+	def width
+	    x
+	end
+
+	# @return [Number] X-component (width)
+	def x
+	    @elements[0]
+	end
+
+	# @return [Number] Y-component (height)
+	def y
+	    @elements[1]
+	end
+
+	# @return [Number] Z-component (depth)
+	def z
+	    @elements[2]
+	end
+    end
+end

data/test/geometry/point.rb

@@ -1,9 +1,9 @@
-require_relative 'helper'
-require_relative '../lib/geometry/point'
+require_relative '../helper'
+require_relative '../../lib/geometry/point'
 
-class PointTest < Test::Unit::TestCase
-    Point = Geometry::Point
+Point = Geometry::Point
 
+class PointTest < Test::Unit::TestCase
     must "create a Point object using list syntax" do
 	point = Geometry::Point[2,1]
 	assert_equal(2, point.size)
@@ -86,3 +86,18 @@ class PointTest < Test::Unit::TestCase
 	assert_equal('Point[10, 11]', point.to_s)
     end
 end
+
+class PointArithmeticTest < Test::Unit::TestCase
+    def setup
+	@left = Point[1,2]
+	@right = Point[3,4]
+    end
+
+    must "return a Point when adding two Points" do
+	assert_kind_of(Point, @left+@right)
+    end
+
+    must "return a Point when subtracting two Points" do
+	assert_kind_of(Point, @left-@right)
+    end
+end

data/test/geometry/rectangle.rb

@@ -0,0 +1,77 @@
+require_relative '../helper'
+require_relative '../../lib/geometry/rectangle'
+
+def Rectangle(*args)
+    Geometry::Rectangle.new(*args)
+end
+
+Point = Geometry::Point
+Size = Geometry::Size
+
+class RectangleConstructorTest < Test::Unit::TestCase
+
+    must "create a Rectangle object from two Points" do
+	rectangle = Rectangle [1,2], [3,4]
+	assert_kind_of(Geometry::Rectangle, rectangle)
+    end
+
+    must "create a Rectangle from a width and height" do
+	rectangle = Rectangle 2, 3
+	assert_kind_of(Geometry::Rectangle, rectangle)
+	assert_equal(2, rectangle.width)
+	assert_equal(3, rectangle.height)
+	assert_equal(Point[0,0], rectangle.center)
+    end
+
+    must "create a Rectangle from a Size" do
+	rectangle = Rectangle Size[2, 3]
+	assert_kind_of(Geometry::Rectangle, rectangle)
+	assert_equal(2, rectangle.width)
+	assert_equal(3, rectangle.height)
+	assert_equal(Point[0,0], rectangle.center)
+    end
+
+    must "create a Rectangle from an origin Point and Size" do
+	rectangle = Rectangle Point[1,2], Size[2, 3]
+	assert_kind_of(Geometry::Rectangle, rectangle)
+	assert_equal(2, rectangle.width)
+	assert_equal(3, rectangle.height)
+	assert_equal(Point[1,2], rectangle.origin)
+    end
+
+    must "create a Rectangle from sides" do
+	rectangle = Rectangle 1,2,3,4
+	assert_kind_of(Geometry::Rectangle, rectangle)
+	assert_equal(2, rectangle.width)
+	assert_equal(2, rectangle.height)
+	assert_equal(Point[1,2], rectangle.origin)
+    end
+end
+
+class RectangleTest < Test::Unit::TestCase
+    def setup
+	@rectangle = Rectangle [1,2], [3,4]
+    end
+
+    must "have a center point property" do
+	assert_equal(@rectangle.center, [2,3])
+    end
+
+    must "have a width property" do
+	assert_equal(2, @rectangle.width)
+    end
+
+    must "have a height property" do
+	assert_equal(2, @rectangle.height)
+    end
+
+    must "have an origin property" do
+	assert_equal(Point[1,2], @rectangle.origin)
+    end
+
+    must "have an edges property that returns 4 edges" do
+	edges = @rectangle.edges
+	assert_equal(4, edges.size)
+	edges.each {|edge| assert_kind_of(Geometry::Edge, edge)}
+    end
+end

data/test/geometry/size.rb

@@ -0,0 +1,97 @@
+require_relative '../helper'
+require_relative '../../lib/geometry/size'
+
+class SizeTest < Test::Unit::TestCase
+    Size = Geometry::Size
+
+    must "create a Size object using list syntax" do
+	size = Geometry::Size[2,1]
+	assert_equal(2, size.size)
+	assert_equal(2, size.x)
+	assert_equal(1, size.y)
+    end
+
+    must "create a Size object from an array" do
+	size = Geometry::Size[[3,4]]
+	assert_equal(2, size.size)
+	assert_equal(3, size.x)
+	assert_equal(4, size.y)
+    end
+
+    must "create a Size object from individual parameters" do
+	size = Geometry::Size[3,4]
+	assert_equal(2, size.size)
+	assert_equal(3, size.x)
+	assert_equal(4, size.y)
+    end
+
+    must "create a Size object from a Size" do
+	size = Geometry::Size[Geometry::Size[3,4]]
+	assert_equal(2, size.size)
+	assert_equal(3, size.x)
+	assert_equal(4, size.y)
+    end
+
+    must "create a Size object from a Vector" do
+	size = Geometry::Size[Vector[3,4]]
+	assert_equal(2, size.size)
+	assert_equal(3, size.x)
+	assert_equal(4, size.y)
+    end
+
+    must "allow indexed element access" do
+	size = Geometry::Size[5,6]
+	assert_equal(2, size.size)
+	assert_equal(5, size[0])
+	assert_equal(6, size[1])
+    end
+    must "allow named element access" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(3, size.size)
+	assert_equal(5, size.x)
+	assert_equal(6, size.y)
+	assert_equal(7, size.z)
+    end
+
+    must "have a width accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(5, size.width)
+    end
+
+    must "have a height accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(6, size.height)
+    end
+
+    must "have a depth accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(7, size.depth)
+    end
+
+    must "compare equal" do
+	size1 = Geometry::Size[1,2]
+	size2 = Geometry::Size[1,2]
+	size3 = Geometry::Size[3,4]
+	assert_equal(size1, size2)
+	assert_not_equal(size2, size3)
+    end
+
+    must "compare equal to an array with equal elements" do
+	size1 = Size[1,2]
+	assert_equal(size1, [1,2])
+    end
+
+    must "not compare equal to an array with unequal elements" do
+	size1 = Size[1,2]
+	assert_not_equal(size1, [3,2])
+    end
+
+    must "implement inspect" do
+	size = Geometry::Size[8,9]
+	assert_equal('Size[8, 9]', size.inspect)
+    end
+    must "implement to_s" do
+	size = Geometry::Size[10,11]
+	assert_equal('Size[10, 11]', size.to_s)
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: geometry
 version: !ruby/object:Gem::Version
-  version: '2'
+  version: '3'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-22 00:00:00.000000000 Z
+date: 2012-05-04 00:00:00.000000000 Z
 dependencies: []
 description: Geometric primitives and algorithms for Ruby
 email:
@@ -30,10 +30,14 @@ files:
 - lib/geometry/line.rb
 - lib/geometry/point.rb
 - lib/geometry/polygon.rb
+- lib/geometry/rectangle.rb
+- lib/geometry/size.rb
 - test/geometry/circle.rb
 - test/geometry/edge.rb
 - test/geometry/point.rb
 - test/geometry/polygon.rb
+- test/geometry/rectangle.rb
+- test/geometry/size.rb
 - test/helper.rb
 - test/test_geometry.rb
 - test/test_line.rb
@@ -58,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: geometry
-rubygems_version: 1.8.17
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Geometric primitives and algoritms
@@ -67,6 +71,8 @@ test_files:
 - test/geometry/edge.rb
 - test/geometry/point.rb
 - test/geometry/polygon.rb
+- test/geometry/rectangle.rb
+- test/geometry/size.rb
 - test/helper.rb
 - test/test_geometry.rb
 - test/test_line.rb