geometry 5 → 6

data/test/geometry/path.rb

@@ -29,7 +29,7 @@ describe Geometry::Path do
 	end
 
 	it "with Points and Arcs" do
-	    path = Geometry::Path.new [0,0], [1.0,0.0], Geometry::Arc.new([1,1], 1, -90*Math::PI/180, 0), [2.0,1.0], [1,2]
+	    path = Geometry::Path.new [0,0], [1.0,0.0], Arc.new(center:[1,1], radius:1, start:-90*Math::PI/180, end:0), [2.0,1.0], [1,2]
 	    path.elements.size.must_equal 3
 	    path.elements[0].must_be_kind_of Geometry::Edge
 	    path.elements[1].must_be_kind_of Geometry::Arc
@@ -37,7 +37,7 @@ describe Geometry::Path do
 	end
 
 	it "with Edges and Arcs" do
-	    path = Geometry::Path.new Edge.new([0,0], [1.0,0.0]), Geometry::Arc.new([1,1], 1, -90*Math::PI/180, 0), Edge.new([2.0,1.0], [1,2])
+	    path = Geometry::Path.new Edge.new([0,0], [1.0,0.0]), Arc.new(center:[1,1], radius:1, start:-90*Math::PI/180, end:0), Edge.new([2.0,1.0], [1,2])
 	    path.elements.size.must_equal 3
 	    path.elements[0].must_be_kind_of Geometry::Edge
 	    path.elements[1].must_be_kind_of Geometry::Arc
@@ -45,7 +45,7 @@ describe Geometry::Path do
 	end
 
 	it "with disjoint Edges and Arcs" do
-	    path = Geometry::Path.new Edge.new([0,0], [1,0]), Geometry::Arc.new([2,1], 1, -90*Math::PI/180, 0), Edge.new([3,1], [1,2])
+	    path = Geometry::Path.new Edge.new([0,0], [1,0]), Arc.new(center:[2,1], radius:1, start:-90*Math::PI/180, end:0), Edge.new([3,1], [1,2])
 	    path.elements.size.must_equal 4
 	    path.elements[0].must_be_kind_of Geometry::Edge
 	    path.elements[1].must_be_kind_of Geometry::Edge
@@ -54,7 +54,7 @@ describe Geometry::Path do
 	end
 
 	it "with disjoint Arcs" do
-	    path = Geometry::Path.new Geometry::Arc.new([2,1], 1, -90*Math::PI/180, 0), Geometry::Arc.new([3,1], 1, -90*Math::PI/180, 0)
+	    path = Geometry::Path.new Arc.new(center:[2,1], radius:1, start:-90*Math::PI/180, end:0), Arc.new(center:[3,1], radius:1, start:-90*Math::PI/180, end:0)
 	    path.elements.size.must_equal 3
 	    path.elements[0].must_be_kind_of Geometry::Arc
 	    path.elements[1].must_be_kind_of Geometry::Edge
@@ -62,6 +62,5 @@ describe Geometry::Path do
 
 	    path.elements[0].last.must_equal path.elements[1].first
 	end
-
     end
 end

data/test/geometry/point.rb

@@ -11,6 +11,12 @@ describe Geometry::Point do
 	    point.x.must_equal 3
 	    point.y.must_equal 4
 	end
+
+	it "must return the PointZero when constructed from a PointZero" do
+	    original_point = Geometry::PointZero.new
+	    point = Geometry::Point[original_point]
+	    point.must_be_same_as original_point
+	end
     end
 
     it "create a Point object using list syntax" do
@@ -102,12 +108,9 @@ describe Geometry::Point do
 		(left + [5,6]).must_equal Point[6,8]
 	    end
 
-	    it "must raise TypeError when adding a scalar to a Point of dimension greater than 1" do
-		lambda { left + 1 }.must_raise Geometry::DimensionMismatch
-	    end
-
-	    it "must support adding a Numeric to a Point with a size of 1" do
-		(Point[1] + 2).must_equal Point[3]
+	    it "must add a Numeric to all elements" do
+		(left + 2).must_equal Point[3,4]
+		(2 + left).must_equal Point[3,4]
 	    end
 
 	    it "must raise an exception when adding mismatched sizes" do
@@ -130,12 +133,9 @@ describe Geometry::Point do
 		(left - [5,6]).must_equal Point[-4, -4]
 	    end
 
-	    it "must raise an exception when subtracting a scalar from a Vector" do
-		lambda { left - 1 }.must_raise Geometry::DimensionMismatch
-	    end
-
-	    it "must subtract a Numeric from a Point of size 1" do
-		(Point[3] - 2).must_equal Point[1]
+	    it "must subtract a Numeric from all elements" do
+		(left - 2).must_equal Point[-1, 0]
+		(2 - left).must_equal Point[1,0]
 	    end
 
 	    it "must raise an exception when subtracting mismatched sizes" do

data/test/geometry/point_zero.rb

@@ -17,7 +17,19 @@ describe Geometry::PointZero do
 	    (-zero).must_be :eql?, 0
 	    (-zero).must_be_instance_of(Geometry::PointZero)
 	end
-	
+
+	describe "Accessors" do
+	    it "must return 0 for array access" do
+		zero[3].must_equal 0
+	    end
+
+	    it "must return 0 for named element access" do
+		zero.x.must_equal 0
+		zero.y.must_equal 0
+		zero.z.must_equal 0
+	    end
+	end
+
 	describe "when adding" do
 	    it "must return a number" do
 		(zero + 3).must_equal 3
@@ -29,10 +41,15 @@ describe Geometry::PointZero do
 		(left + zero).must_be_kind_of Point
 	    end
 	    
-	    it "must return a Point when adding an array" do
+	    it "must return an Array when adding an array" do
 		(zero + [5,6]).must_equal [5,6]
 #		([5,6] + zero).must_equal [5,6]
 	    end
+
+	    it "must return a Point when adding a Size" do
+		(zero + Size[5,6]).must_be_instance_of(Point)
+		(zero + Size[5,6]).must_equal Point[5,6]
+	    end
 	end
 	
 	describe "when subtracting" do
@@ -50,6 +67,11 @@ describe Geometry::PointZero do
 		(zero - [5,6]).must_equal [-5, -6]
 #		([5,6] - zero).must_equal [5,6]
 	    end
+
+	    it "must return a Point when subtracting a Size" do
+		(zero - Size[5,6]).must_be_instance_of(Point)
+		(zero - Size[5,6]).must_equal Point[-5,-6]
+	    end
 	end
 	
 	describe "multiplication" do
@@ -104,7 +126,7 @@ describe Geometry::PointZero do
     end
 
     describe "comparison" do
-	let(:zero) { Geometry::PointZero.new }
+	subject { Geometry::PointZero.new }
 	
 	it "must be equal to 0 and 0.0" do
 	    zero.must_be :eql?, 0
@@ -119,7 +141,9 @@ describe Geometry::PointZero do
 	it "must be equal to an Array of zeros" do
 	    zero.must_be :==, [0,0]
 	    zero.must_be :eql?, [0,0]
+	    zero.must_be :===, [0,0]
 	    [0,0].must_equal zero
+	    subject.must_equal [0,0]
 	end
 	
 	it "must not be equal to a non-zero Array" do
@@ -130,7 +154,9 @@ describe Geometry::PointZero do
 	it "must be equal to a Point at the origin" do
 	    zero.must_be :==, Point[0,0]
 	    zero.must_be :eql?, Point[0,0]
+	    zero.must_be :===, Point[0,0]
 	    Point[0,0].must_equal zero
+	    subject.must_equal Point[0,0]
 	end
 	
 	it "must not be equal to a Point not at the origin" do

data/test/geometry/polygon.rb

@@ -2,7 +2,6 @@ require 'minitest/autorun'
 require 'geometry/polygon'
 
 describe Geometry::Polygon do
-    Point = Geometry::Point
     Polygon = Geometry::Polygon
 
     let(:cw_unit_square) { Polygon.new [0,0], [0,1], [1,1], [1,0] }
@@ -59,6 +58,18 @@ describe Geometry::Polygon do
 	assert_equal(polygon.edges.first.first, polygon.edges.last.last)
     end
 
+    describe "orientation" do
+	it "must return true for clockwise" do
+	    Polygon.new([0,0], [0,1], [1,1], [1,0]).clockwise?.must_equal true
+	    Polygon.new([1,1], [1,3], [3,3], [3,1]).clockwise?.must_equal true
+	end
+
+	it "must return fale for counterclockwise" do
+	    Polygon.new([0,0], [1,0], [1,1], [0,1]).clockwise?.must_equal false
+	    Polygon.new([1,1], [3,1], [3,3], [1,3]).clockwise?.must_equal false
+	end
+    end
+
     it "must gift wrap a square polygon" do
 	polygon = Polygon.new [0,0], [1,0], [1,1], [0,1]
 	convex_hull = polygon.wrap
@@ -91,6 +102,18 @@ describe Geometry::Polygon do
 	convex_hull.vertices.must_equal [[0,0], [0,1], [2,1], [2,0], [1,-1]].map {|a| Point[*a]}
     end
 
+    describe "spaceship" do
+	it "with a Point" do
+	    (unit_square <=> Point[2,0]).must_equal -1
+	    (unit_square <=> Point[1,0]).must_equal 0
+	    (unit_square <=> Point[0.5,0.5]).must_equal 1
+	end
+
+	it "with a Point that lies on a horizontal edge" do
+	    (unit_square <=> Point[0.5,0]).must_equal 0
+	end
+    end
+
     describe "when outsetting" do
 	it "must outset a unit square" do
 	    outset_polygon = unit_square.outset(1)
@@ -129,4 +152,41 @@ describe Geometry::Polygon do
 	    polygon.outset(1).must_equal Polygon.new [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
 	end
     end
+
+    describe "set operations" do
+	describe "union" do
+	    it "must union two adjacent squares" do
+		polygonA = Polygon.new [0,0], [1,0], [1,1], [0,1]
+		polygonB = Polygon.new [1,0], [2,0], [2,1], [1,1]
+		(polygonA.union polygonB).must_equal Polygon.new [0,0], [2,0], [2,1], [0,1]
+		(polygonA + polygonB).must_equal Polygon.new [0,0], [2,0], [2,1], [0,1]
+	    end
+
+	    it "must union two overlapping squares" do
+		polygonA = Polygon.new [0,0], [2,0], [2,2], [0,2]
+		polygonB = Polygon.new [1,1], [3,1], [3,3], [1,3]
+		expected_polygon = Polygon.new [0,0], [2,0], [2,1], [3,1], [3,3], [1,3], [1,2], [0,2]
+		union = polygonA.union polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal expected_polygon
+	    end
+
+	    it "must union two overlapping clockwise squares" do
+		polygonA = Polygon.new [0,0], [0,2], [2,2], [2,0]
+		polygonB = Polygon.new [1,1], [1,3], [3,3], [3,1]
+		expected_polygon = Polygon.new [0, 0], [0, 2], [1, 2], [1, 3], [3, 3], [3, 1], [2, 1], [2, 0]
+		union = polygonA.union polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal expected_polygon
+	    end
+
+	    it "must union two overlapping squares with collinear edges" do
+		polygonA = Polygon.new [0,0], [2,0], [2,2], [0,2]
+		polygonB = Polygon.new [1,0], [3,0], [3,2], [1,2]
+		union = polygonA + polygonB
+		union.must_be_kind_of Polygon
+		union.must_equal Polygon.new [0,0], [3,0], [3,2], [0,2]
+	    end
+	end
+    end
 end

data/test/geometry/polyline.rb

@@ -2,7 +2,6 @@ require 'minitest/autorun'
 require 'geometry/polyline'
 
 describe Geometry::Polyline do
-    Point = Geometry::Point
     Polyline = Geometry::Polyline
 
     let(:unit_square) { Polyline.new [0,0], [1,0], [1,1], [0,1] }

data/test/geometry/rectangle.rb

@@ -5,54 +5,93 @@ def Rectangle(*args)
     Geometry::Rectangle.new(*args)
 end
 
-Point = Geometry::Point
-Size = Geometry::Size
-
 describe Geometry::Rectangle do
-    describe "when constructed" do
-	it "create a Rectangle object from two Points" do
-	    rectangle = Rectangle [1,2], [3,4]
-	    assert_kind_of(Geometry::Rectangle, rectangle)
+    Rectangle = Geometry::Rectangle
+
+    describe "when initializing" do
+	it "must accept two corners as Arrays" do
+	    rectangle = Rectangle.new [1,2], [2,3]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 1
+	    rectangle.width.must_equal 1
+	    rectangle.origin.must_equal Point[1,2]
 	end
 
-	it "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)
+	it "must accept two named corners as Arrays" do
+	    rectangle = Rectangle.new from:[1,2], to:[2,3]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 1
+	    rectangle.width.must_equal 1
+	    rectangle.origin.must_equal Point[1,2]
 	end
 
-	it "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)
+	it "must accept named center point and size arguments" do
+	    rectangle = Rectangle.new center:[1,2], size:[3,4]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 4
+	    rectangle.width.must_equal 3
+	    rectangle.center.must_equal Point[1,2]
 	end
 
-	it "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)
+	it "must reject a named center argument with no size argument" do
+	    -> { Rectangle.new center:[1,2] }.must_raise ArgumentError
 	end
 
-	it "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)
+	it "must accept named origin point and size arguments" do
+	    rectangle = Rectangle.new origin:[1,2], size:[3,4]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 4
+	    rectangle.width.must_equal 3
+	    rectangle.origin.must_equal Point[1,2]
+	end
+
+	it "must reject a named origin argument with no size argument" do
+	    -> { Rectangle.new origin:[1,2] }.must_raise ArgumentError
+	end
+
+	it "must accept a sole named size argument that is an Array" do
+	    rectangle = Rectangle.new size:[1,2]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.origin.must_equal Point[0,0]
+	    rectangle.height.must_equal 2
+	    rectangle.width.must_equal 1
+	end
+
+	it "must accept a sole named size argument that is a Size" do
+	    rectangle = Rectangle.new size:Size[1,2]
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.origin.must_equal Point[0,0]
+	    rectangle.height.must_equal 2
+	    rectangle.width.must_equal 1
+	end
+
+	it "must accept named width and height arguments" do
+	    rectangle = Rectangle.new width:1, height:3
+	    rectangle.must_be_kind_of Geometry::Rectangle
+	    rectangle.height.must_equal 3
+	    rectangle.width.must_equal 1
+	end
+
+	it "must reject width or height by themselves" do
+	    -> { Rectangle.new height:1 }.must_raise ArgumentError
+	    -> { Rectangle.new width:1 }.must_raise ArgumentError
+	end
+
+    end
+
+    describe "comparison" do
+	it "must compare equal" do
+	    rectangle = Rectangle [1,2], [3,4]
+	    rectangle.must_equal Rectangle([1,2], [3, 4])
 	end
     end
 
     describe "properties" do
+	subject { Rectangle.new [1,2], [3,4] }
 	let(:rectangle) { Rectangle [1,2], [3,4] }
 
 	it "have a center point property" do
-	    assert_equal(rectangle.center, [2,3])
+	    rectangle.center.must_equal Point[2,3]
 	end
 
 	it "have a width property" do
@@ -78,5 +117,21 @@ describe Geometry::Rectangle do
 	    assert_equal(4, points.size)
 	    points.each {|point| assert_kind_of(Geometry::Point, point)}
 	end
+
+	it "must have a bounds property that returns a Rectangle" do
+	    subject.bounds.must_equal Rectangle.new([1,2], [3,4])
+	end
+
+	it "must have a minmax property that returns the corners of the bounding rectangle" do
+	    subject.minmax.must_equal [Point[1,2], Point[3,4]]
+	end
+
+	it "must have a max property that returns the upper right corner of the bounding rectangle" do
+	    subject.max.must_equal Point[3,4]
+	end
+
+	it "must have a min property that returns the lower left corner of the bounding rectangle" do
+	    subject.min.must_equal Point[1,2]
+	end
     end
 end

data/test/geometry/regular_polygon.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+require 'geometry/regular_polygon'
+
+describe Geometry::RegularPolygon do
+    RegularPolygon = Geometry::RegularPolygon
+
+    describe "when constructed with named center and radius arguments" do
+	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], radius:3 }
+
+	it "must create a RegularPolygon" do
+	    polygon.must_be_instance_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must have a center point accessor" do
+	    polygon.center.must_equal Point[1,2]
+	end
+
+	it "must have a radius accessor" do
+	    polygon.radius.must_equal 3
+	end
+
+	it "must compare equal" do
+	    polygon.must_equal RegularPolygon.new(sides:4, center:[1,2], radius:3)
+	end
+    end
+
+    describe "when constructed with a center and diameter" do
+	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], diameter:4 }
+
+	it "must be a DiameterRegularPolygon" do
+	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
+	    polygon.must_be_kind_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must have a center" do
+	    polygon.center.must_equal Point[1,2]
+	end
+
+	it "must have a diameter" do
+	    polygon.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    polygon.radius.must_equal 2
+	end
+
+	it "must compare equal" do
+	    polygon.must_equal RegularPolygon.new(sides:4, center:[1,2], diameter:4)
+	end
+    end
+
+    describe "when constructed with a diameter and no center" do
+	let(:polygon) { RegularPolygon.new sides:4, diameter:4 }
+
+	it "must be a DiameterRegularPolygon" do
+	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
+	    polygon.must_be_kind_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must have a nil center" do
+	    polygon.center.must_be_nil
+	end
+
+	it "must have a diameter" do
+	    polygon.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    polygon.radius.must_equal 2
+	end
+    end
+end