geometry 6 → 6.1

data/test/geometry/edge.rb

@@ -7,6 +7,7 @@ end
 
 describe Geometry::Edge do
     Edge = Geometry::Edge
+    subject { Geometry::Edge.new [0,0], [1,1] }
 
     it "must create an Edge object" do
 	edge = Edge.new([0,0], [1,0])
@@ -14,13 +15,7 @@ describe Geometry::Edge do
 	assert_equal(Geometry::Point[0,0], edge.first)
 	assert_equal(Geometry::Point[1,0], edge.last)
     end
-    it "must create swap endpoints in place" do
-	edge = Edge.new([0,0], [1,0])
-	assert_kind_of(Edge, edge)
-	edge.reverse!
-	assert_equal(Geometry::Point[1,0], edge.first)
-	assert_equal(Geometry::Point[0,0], edge.last)
-    end
+
     it "must handle equality" do
 	edge1 = Edge.new([1,0], [0,1])
 	edge2 = Edge.new([1,0], [0,1])
@@ -58,6 +53,18 @@ describe Geometry::Edge do
 	Edge.new([0,0], [2,0]).parallel?(Edge.new([1,-1], [1,1])).must_equal false
     end
 
+    it "must clone and reverse" do
+	reversed = subject.reverse
+	reversed.to_a.must_equal subject.to_a.reverse
+	reversed.wont_be_same_as subject
+    end
+
+    it "must reverse itself" do
+	original = subject.to_a
+	subject.reverse!
+	subject.to_a.must_equal original.reverse
+    end
+
     describe "spaceship" do
 	it "ascending with a Point" do
 	    edge = Edge.new [0,0], [1,1]

data/test/geometry/line.rb

@@ -106,3 +106,27 @@ describe Geometry::Line do
 	assert_equal('Line(Point[0, 0], Point[10, 10])', line.to_s)
     end
 end
+
+describe Geometry::PointSlopeLine do
+    subject { Geometry::PointSlopeLine.new [1,2], 3 }
+
+    it "must have a slope attribute" do
+	subject.slope.must_equal 3
+    end
+end
+
+describe Geometry::SlopeInterceptLine do
+    subject { Geometry::SlopeInterceptLine.new 3, 2 }
+
+    it "must have a slope attribute" do
+	subject.slope.must_equal 3
+    end
+end
+
+describe Geometry::TwoPointLine do
+    subject { Geometry::TwoPointLine.new [1,2], [3,4] }
+
+    it "must have a slope attribute" do
+	subject.slope.must_equal 1
+    end
+end

data/test/geometry/point.rb

@@ -2,6 +2,18 @@ require 'minitest/autorun'
 require 'geometry/point'
 
 describe Geometry::Point do
+    PointZero = Geometry::PointZero
+
+    describe "class methods" do
+	it "must generate a PointZero" do
+	    Point.zero.must_be_instance_of(PointZero)
+	end
+
+	it "must generate a Point full of zeros" do
+	    Point.zero(3).must_equal Point[0,0,0]
+	end
+    end
+
     describe "constructor" do
 	it "must return the Point when constructed from a Point" do
 	    original_point = Point[3,4]
@@ -19,12 +31,6 @@ describe Geometry::Point do
 	end
     end
 
-    it "create a Point object using list syntax" do
-	point = Geometry::Point[2,1]
-	assert_equal(2, point.size)
-	assert_equal(2, point.x)
-	assert_equal(1, point.y)
-    end
     it "create a Point object from an array" do
 	point = Geometry::Point[[3,4]]
 	assert_equal(2, point.size)
@@ -44,12 +50,6 @@ describe Geometry::Point do
 	assert_equal(4, point.y)
     end
 
-    it "create a Point object from a Vector using list syntax" do
-	point = Geometry::Point[Vector[3,4]]
-	assert_equal(2, point.size)
-	assert_equal(3, point.x)
-	assert_equal(4, point.y)
-    end
     it "create a Point object from a Point using list syntax" do
 	point = Geometry::Point[Geometry::Point[13,14]]
 	assert_equal(2, point.size)
@@ -85,6 +85,16 @@ describe Geometry::Point do
 	Point[1,2][2].must_equal nil
     end
 
+    it "must clone" do
+	Point[1,2].clone.must_be_instance_of(Point)
+	Point[1,2].clone.must_equal Point[1,2]
+    end
+
+    it "must duplicate" do
+	Point[1,2].dup.must_be_instance_of(Point)
+	Point[1,2].dup.must_equal Point[1,2]
+    end
+
     describe "arithmetic" do
 	let(:left) { Point[1,2] }
 	let(:right) { Point[3,4] }
@@ -122,6 +132,13 @@ describe Geometry::Point do
 		(Vector[5,6] + right).must_equal Vector[8,10]
 	    end
 
+	    it "must return self when adding a PointZero" do
+		(left + Point.zero).must_equal left
+	    end
+
+	    it "must return self when adding a NilClass" do
+		(left + nil).must_equal left
+	    end
 	end
 
 	describe "when subtracting" do
@@ -141,16 +158,40 @@ describe Geometry::Point do
 	    it "must raise an exception when subtracting mismatched sizes" do
 		lambda { left - [1,2,3,4] }.must_raise Geometry::DimensionMismatch
 	    end
+
+	    it "must return self when subtracting a PointZero" do
+		(left - Point.zero).must_equal left
+	    end
+
+	    it "must return self when subtracting a NilClass" do
+		(left - nil).must_equal left
+	    end
+	end
+
+	describe "when multiplying" do
+	    it "must return a Point when multiplied by a Matrix" do
+		(Matrix[[1,2],[3,4]]*Point[5,6]).must_equal Point[17, 39]
+	    end
 	end
     end
 
     describe "coercion" do
+	subject { Point[1,2] }
+
 	it "must coerce Arrays into Points" do
-	    Point[1,2].coerce([3,4]).must_equal [Point[3,4], Point[1,2]]
+	    subject.coerce([3,4]).must_equal [Point[3,4], subject]
 	end
 
 	it "must coerce Vectors into Points" do
-	    Point[1,2].coerce(Vector[3,4]).must_equal [Point[3,4], Point[1,2]]
+	    subject.coerce(Vector[3,4]).must_equal [Point[3,4], subject]
+	end
+
+	it "must coerce a Numeric into a Point" do
+	    subject.coerce(42).must_equal [Point[42,42], subject]
+	end
+
+	it "must reject anything that can't be coerced" do
+	    -> { subject.coerce(NilClass) }.must_raise TypeError
 	end
     end
 

data/test/geometry/polygon.rb

@@ -6,6 +6,8 @@ describe Geometry::Polygon do
 
     let(:cw_unit_square) { Polygon.new [0,0], [0,1], [1,1], [1,0] }
     let(:unit_square) { Polygon.new [0,0], [1,0], [1,1], [0,1] }
+    let(:simple_concave) { Polygon.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2] }
+    subject { unit_square }
 
     it "must create a Polygon object with no arguments" do
 	polygon = Geometry::Polygon.new
@@ -46,8 +48,7 @@ describe Geometry::Polygon do
     end
 
     it "must create closed polygons" do
-	polygon = Geometry::Polygon.new([0,0], [1,0], [1,1], [0,1])
-	assert_equal(polygon.edges.first.first, polygon.edges.last.last)
+	subject.closed?.must_equal true
     end
 
     it "must handle already closed polygons" do
@@ -58,13 +59,20 @@ describe Geometry::Polygon do
 	assert_equal(polygon.edges.first.first, polygon.edges.last.last)
     end
 
+    it "must return itself on close" do
+	closed = subject.close
+	closed.closed?.must_equal true
+	closed.must_equal subject
+	closed.must_be_same_as subject
+    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
+	it "must return false 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
@@ -102,6 +110,12 @@ describe Geometry::Polygon do
 	convex_hull.vertices.must_equal [[0,0], [0,1], [2,1], [2,0], [1,-1]].map {|a| Point[*a]}
     end
 
+    it "must generate spokes" do
+	unit_square.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	cw_unit_square.spokes.must_equal [Vector[-1,-1], Vector[-1,1], Vector[1,1], Vector[1,-1]]
+	simple_concave.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1], Vector[-1,1], Vector[1,1], Vector[1,1], Vector[-1,1]]
+    end
+
     describe "spaceship" do
 	it "with a Point" do
 	    (unit_square <=> Point[2,0]).must_equal -1
@@ -140,10 +154,9 @@ describe Geometry::Polygon do
 	end
 
 	it "must outset a concave polygon with multiply-intersecting edges" do
-	    skip
 	    concave_polygon = Polygon.new [0,0], [5,0], [5,2], [4,2], [4,1], [3,1], [3,2], [2,2], [2,1], [1,1], [1,2], [0,2]
-	    outset_polygon = concave_polygon.outset(2)
-	    outset_polygon.must_equal Polygon.new [-2,-2], [7,-2], [7,4], [-2,4]
+	    outset_polygon = concave_polygon.outset(1)
+	    outset_polygon.must_equal Polygon.new [-1,-1], [6,-1], [6,3], [-1,3]
 	end
 
 	it "must outset a concave polygon where the first outset edge intersects with the last outset edge" do
@@ -151,6 +164,15 @@ describe Geometry::Polygon do
 	    polygon.edges.count.must_equal 8
 	    polygon.outset(1).must_equal Polygon.new [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
 	end
+
+	# Naturally, this test is very sensitive to the input coordinate values. This is a painfully contrived example that
+	#  checks for sensitivity to edges that are very close to horizontal, but not quite.
+	# When the test fails, the first point of the offset polygon is at [0,-1]
+	it "must not be sensitive to floating point rounding errors" do
+	    polygon = Polygon.new [0, 0], [0, -2], [10, -2], [10, 10], [-100, 10], [-100, -22], [-69, -22], [-69, 3.552713678800501e-15], [0,0]
+	    outset = polygon.outset(1)
+	    outset.edges.first.first.must_equal Geometry::Point[-1,-1]
+	end
     end
 
     describe "set operations" do

data/test/geometry/polyline.rb

@@ -4,7 +4,9 @@ require 'geometry/polyline'
 describe Geometry::Polyline do
     Polyline = Geometry::Polyline
 
+    let(:closed_unit_square) { Polyline.new [0,0], [1,0], [1,1], [0,1], [0,0] }
     let(:unit_square) { Polyline.new [0,0], [1,0], [1,1], [0,1] }
+    let(:reverse_unit_square)	{ Polyline.new [0,1], [1,1], [1,0], [0,0] }
 
     it "must create a Polyline object with no arguments" do
 	polyline = Geometry::Polyline.new
@@ -20,6 +22,154 @@ describe Geometry::Polyline do
 	polyline.vertices.count.must_equal 4
     end
 
+    describe "when the Polyline is closed" do
+	let(:closed_concave_polyline) { Polyline.new [-2,0], [0,0], [0,-2], [2,-2], [2,2], [-2,2], [-2,0] }
+	subject { closed_concave_polyline }
+
+	it "must be closed" do
+	    closed_unit_square.closed?.must_equal true
+	end
+
+	it "must clone and close" do
+	    closed = subject.close
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.wont_be_same_as subject
+	end
+
+	it "must be able to close itself" do
+	    subject.close!
+	    subject.closed?.must_equal true
+	    subject.must_equal subject
+	end
+
+	it "must clone and reverse" do
+	    vertices = subject.vertices
+	    vertices.push vertices.shift
+	    reversed = subject.reverse
+	    reversed.vertices.must_equal vertices.reverse
+	    reversed.wont_be_same_as subject
+	    reversed.closed?.must_equal true
+	end
+
+	it "must reverse itself" do
+	    original = subject.vertices.dup
+	    subject.reverse!
+	    subject.vertices.to_a.must_equal original.reverse
+	    subject.closed?.must_equal true
+	end
+
+	it "must generate bisectors" do
+	    closed_unit_square.bisectors.must_equal [Vector[1, 1], Vector[-1, 1], Vector[-1, -1], Vector[1, -1]]
+	end
+
+	it "must generate bisectors with an inside corner" do
+	    closed_concave_polyline.bisectors.must_equal [Vector[1,1], Vector[-1,-1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[1,-1]]
+	end
+
+	it "must generate left bisectors" do
+	    closed_unit_square.left_bisectors.must_equal [Vector[1, 1], Vector[-1, 1], Vector[-1, -1], Vector[1, -1]]
+	end
+
+	it "must generate left bisectors with an inside corner" do
+	    closed_concave_polyline.left_bisectors.must_equal [Vector[1,1], Vector[1,1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[1,-1]]
+	end
+
+	it "must generate right bisectors" do
+	    closed_unit_square.right_bisectors.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must generate right bisectors with an inside corner" do
+	    closed_concave_polyline.right_bisectors.must_equal [Vector[-1,-1], Vector[-1,-1], Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must generate spokes" do
+	    closed_unit_square.spokes.must_equal [Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[-1,1]]
+	end
+
+	it "must rightset a closed concave polyline where the first outset edge intersects with the last outset edge" do
+	    skip
+	    polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0], [0,0]
+	    polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+	end
+    end
+
+    describe "when the Polyline is open" do
+	let(:concave_polyline) { Polyline.new [-2,0], [0,0], [0,-2], [2,-2], [2,2], [-2,2] }
+	subject { concave_polyline }
+
+	it "must not be closed" do
+	    unit_square.closed?.must_equal false
+	end
+
+	it "must clone and close" do
+	    closed = subject.close
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.wont_be_same_as subject
+	end
+
+	it "must be able to close it" do
+	    closed = subject.close!
+	    closed.closed?.must_equal true
+	    closed.must_equal subject
+	    closed.must_be_same_as subject
+	end
+
+	it "must clone and reverse" do
+	    reversed = subject.reverse
+	    reversed.vertices.must_equal subject.vertices.reverse
+	    reversed.wont_be_same_as subject
+	    reversed.closed?.wont_equal true
+	end
+
+	it "must reverse itself" do
+	    original = subject.vertices.dup
+	    subject.reverse!
+	    subject.vertices.to_a.must_equal original.reverse
+	    subject.closed?.wont_equal true
+	end
+
+	it "must generate bisectors" do
+	    unit_square.bisectors.must_equal [Vector[0, 1], Vector[-1, 1], Vector[-1, -1], Vector[0, -1]]
+	end
+
+	it "must generate bisectors with an inside corner" do
+	    concave_polyline.bisectors.must_equal [Vector[0,1], Vector[-1,-1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[0,-1]]
+	end
+
+	it "must generate left bisectors" do
+	    unit_square.left_bisectors.must_equal [Vector[0, 1], Vector[-1, 1], Vector[-1, -1], Vector[0, -1]]
+	    reverse_unit_square.left_bisectors.must_equal [Vector[0, 1], Vector[1, 1], Vector[1, -1], Vector[0, -1]]
+	end
+
+	it "must generate right bisectors" do
+	    unit_square.right_bisectors.must_equal [Vector[0,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+
+	it "must generate right bisectors with an inside corner" do
+	    concave_polyline.right_bisectors.must_equal [Vector[0,-1], Vector[-1,-1], Vector[-1,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+
+	it "must generate left bisectors with an inside corner" do
+	    concave_polyline.left_bisectors.must_equal [Vector[0,1], Vector[1,1], Vector[1,1], Vector[-1,1], Vector[-1,-1], Vector[0,-1]]
+	end
+
+	it "must generate spokes" do
+	    unit_square.spokes.must_equal [Vector[0,-1], Vector[1,-1], Vector[1,1], Vector[0,1]]
+	end
+    end
+
+    describe "when checking for closedness" do
+	it "must be closed when it is closed" do
+	    closed_unit_square.closed?.must_equal true
+	end
+
+	it "must not be closed when it is not closed" do
+	    unit_square.closed?.must_equal false
+	end
+    end
+
     describe "when creating a Polyline from an array of Points" do
 	it "must ignore repeated Points" do
 	    polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [1,1], [0,1])
@@ -42,6 +192,12 @@ describe Geometry::Polyline do
 	(unit_square.eql? unit_square).must_equal true
     end
 
+    it "must rightset a closed concave polyline where the first outset edge intersects with the last outset edge" do
+	skip
+	polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0], [0,0]
+	polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+    end
+
     describe "when offsetting" do
 	describe "with a positive offset" do
 	    it "must leftset a unit square" do
@@ -85,6 +241,26 @@ describe Geometry::Polyline do
 		offset_polyline = concave_polyline.offset(-2)
 		offset_polyline.must_equal Polyline.new [0,-2], [7,-2], [7,4], [0,4]
 	    end
+
+	    it "must rightset a closed concave polyline with multiply-intersecting edges" do
+		concave_polyline = Polyline.new [0,0], [5,0], [5,2], [4,2], [4,1], [3,1], [3,2], [2,2], [2,1], [1,1], [1,2], [0,2], [0,0]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [-2,-2], [7,-2], [7,4], [-2,4]
+	    end
+
+	    it "must rightset a concave polyline where the first outset edge intersects with the last outset edge" do
+		polyline = Polyline.new [0,0], [0,1], [2,1], [2,2], [-1,2], [-1,-1], [2,-1], [2,0]
+		polyline.offset(-1).must_equal Polyline.new [1, 0], [3, 0], [3, 3], [-2, 3], [-2, -2], [3, -2]
+	    end
+
+	    # Naturally, this test is very sensitive to the input coordinate values. This is a painfully contrived example that
+	    #  checks for sensitivity to edges that are very close to horizontal, but not quite.
+	    # When the test fails, the first point of the offset polyline is at [0,-1]
+	    it "must not be sensitive to floating point rounding errors" do
+		polyline = Polyline.new [0, 0], [0, -2], [10, -2], [10, 10], [-100, 10], [-100, -22], [-69, -22], [-69, 3.552713678800501e-15], [0,0]
+		outset = polyline.offset(-1)
+		outset.edges.first.first.must_equal Geometry::Point[-1,-1]
+	    end
 	end
     end
 end