aurora-geometry 0.0.2

data/test/geometry/polyline.rb

@@ -0,0 +1,266 @@
+require 'minitest/autorun'
+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
+	polyline.must_be_kind_of Polyline
+	polyline.edges.count.must_equal 0
+	polyline.vertices.count.must_equal 0
+    end
+
+    it "must create a Polyline object from array arguments" do
+	polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	polyline.must_be_kind_of Polyline
+	polyline.edges.count.must_equal 3
+	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])
+	    polyline.must_be_kind_of Geometry::Polyline
+	    polyline.must_equal Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse collinear Edges" do
+	    polyline = Geometry::Polyline.new([0,0], [1,0], [1,1], [0.5,1], [0,1])
+	    polyline.must_equal Geometry::Polyline.new([0,0], [1,0], [1,1], [0,1])
+	end
+
+	it "must collapse backtracking Edges" do
+	    polyline = Geometry::Polyline.new [0,0], [2,0], [2,2], [1,2], [1,1], [1,2], [0,2]
+	    polyline.must_equal Geometry::Polyline.new([0,0], [2,0], [2,2], [0,2])
+	end
+    end
+
+    it "must compare identical polylines as equal" 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
+		expected_polyline = Polyline.new [0,0.1], [0.9,0.1], [0.9,0.9], [0,0.9]
+		unit_square.offset(0.1).must_equal expected_polyline
+	    end
+
+	    it "must leftset a simple concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,4], [3,4], [3,3], [1,3], [1,4], [0,4]
+		offset_polyline = concave_polyline.offset(1)
+		offset_polyline.must_equal Polyline.new [0,1], [3,1], [3,2], [0,2], [0,3]
+	    end
+	end
+
+	describe "with a negative offset" do
+	    it "must rightset a unit square" do
+		expected_polyline = Polyline.new [0,-1.0], [2.0,-1.0], [2.0,2.0], [0,2.0]
+		unit_square.offset(-1).must_equal expected_polyline
+	    end
+
+	    it "must rightset a simple concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-1)
+		offset_polyline.must_equal Polyline.new [0,-1], [5,-1], [5,3], [0,3]
+	    end
+
+	    it "must rightset a concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,2], [3,2], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [0,-2], [6,-2], [6,4], [0,4]
+	    end
+
+	    it "must rightset an asymetric concave polyline" do
+		concave_polyline = Polyline.new [0,0], [4,0], [4,3], [3,3], [3,1], [1,1], [1,2], [0,2]
+		offset_polyline = concave_polyline.offset(-2)
+		offset_polyline.must_equal Polyline.new [0,-2], [6,-2], [6,5], [1,5], [1,4], [0,4]
+	    end
+
+	    it "must rightset a 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]
+		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

data/test/geometry/rectangle.rb

@@ -0,0 +1,154 @@
+require 'minitest/autorun'
+require 'geometry/rectangle'
+
+def Rectangle(*args)
+    Geometry::Rectangle.new(*args)
+end
+
+describe Geometry::Rectangle do
+    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 "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 "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 "must reject a named center argument with no size argument" do
+	    -> { Rectangle.new center:[1,2] }.must_raise ArgumentError
+	end
+
+	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 "inset" do
+	subject { Rectangle.new [0,0], [10,10] }
+
+	it "must inset equally" do
+	    subject.inset(1).must_equal Rectangle.new [1,1], [9,9]
+	end
+
+	it "must inset vertically and horizontally" do
+	    subject.inset(1,2).must_equal Rectangle.new [1,2], [9,8]
+	    subject.inset(x:1, y:2).must_equal Rectangle.new [1,2], [9,8]
+	end
+
+	it "must inset from individual sides" do
+	    subject.inset(1,2,3,4).must_equal Rectangle.new [2,3], [6,9]
+	    subject.inset(top:1, left:2, bottom:3, right:4).must_equal Rectangle.new [2,3], [6,9]
+	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
+	    rectangle.center.must_equal Point[2,3]
+	end
+
+	it "have a width property" do
+	    assert_equal(2, rectangle.width)
+	end
+
+	it "have a height property" do
+	    assert_equal(2, rectangle.height)
+	end
+
+	it "have an origin property" do
+	    assert_equal(Point[1,2], rectangle.origin)
+	end
+
+	it "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
+
+	it "have a points property that returns 4 points" do
+	    points = rectangle.points
+	    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,120 @@
+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 }
+	subject { 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
+
+	describe "properties" do
+	    it "must have vertices" do
+		subject.vertices.must_equal [Point[4.0, 2.0], Point[1.0000000000000002, 5.0], Point[-2.0, 2.0000000000000004], Point[0.9999999999999994, -1.0]]
+	    end
+	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 be at the origin" do
+	    polygon.center.must_equal Point.zero
+	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
+
+    describe "properties" do
+	subject { RegularPolygon.new sides:6, diameter:4 }
+
+	it "must have edges" do
+	    expected_edges = [Edge(Point[2, 0], Point[1, 1.732]), Edge(Point[1, 1.732], Point[-1, 1.732]), Edge(Point[-1, 1.732], Point[-2, 0]), Edge(Point[-2, 0], Point[-1, -1.732]), Edge(Point[-1, -1.732], Point[1, -1.732]), Edge(Point[1, -1.732], Point[2, 0])]
+	    subject.edges.zip(expected_edges) do |edge1, edge2|
+		edge1.to_a.zip(edge2.to_a) do |point1, point2|
+		    point1.to_a.zip(point2.to_a) {|a, b| a.must_be_close_to b }
+		end
+	    end
+	end
+
+	it "must have a bounds property that returns a Rectangle" do
+	    subject.bounds.must_equal Rectangle.new([-2,-2], [2,2])
+	end
+
+	it "must have a minmax property that returns the corners of the bounding rectangle" do
+	    subject.minmax.must_equal [Point[-2,-2], Point[2,2]]
+	end
+
+	it "must have a max property that returns the upper right corner of the bounding rectangle" do
+	    subject.max.must_equal Point[2,2]
+	end
+
+	it "must have a min property that returns the lower left corner of the bounding rectangle" do
+	    subject.min.must_equal Point[-2,-2]
+	end
+    end
+end