geom2d 0.1.0

data/test/geom2d/test_bounding_box.rb

@@ -0,0 +1,37 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/bounding_box'
+
+describe Geom2D::BoundingBox do
+  before do
+    @bbox = Geom2D::BoundingBox.new
+  end
+
+  describe "join" do
+    it "combines bounding boxes" do
+      result = @bbox + Geom2D::BoundingBox.new(5, 5, 10, 10) +
+        Geom2D::BoundingBox.new(-2, 8, 15, 9)
+      assert_equal([-2, 0, 15, 10], result.to_a)
+    end
+
+    it "adjust the bounding box to include the point" do
+      result = @bbox + Geom2D::Point(5, 10)
+      assert_equal([0, 0, 5, 10], result.to_a)
+    end
+
+    it "fails if an invalid argument is given" do
+      assert_raises(ArgumentError) { @bbox + "string" }
+    end
+  end
+
+  it "returns the width and height" do
+    @bbox += Geom2D::Point(10, 5)
+    assert_equal(10, @bbox.width)
+    assert_equal(5, @bbox.height)
+  end
+
+  it "returns a useful inspection string" do
+    assert_equal("BBox[0, 0, 0, 0]", @bbox.inspect)
+  end
+end

data/test/geom2d/test_point.rb

@@ -0,0 +1,148 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/point'
+
+describe Geom2D::Point do
+  before do
+    @point = Geom2D::Point(1, 2)
+  end
+
+  describe "Point method" do
+    it "creates a point using two numbers" do
+      point = Geom2D::Point(1, 2)
+      assert_equal([1, 2], point)
+    end
+
+    it "creates a point using an array of two numbers" do
+      point = Geom2D::Point([1, 2])
+      assert_equal([1, 2], point)
+    end
+
+    it "returns a given point object" do
+      p1 = Geom2D::Point(1, 2)
+      p2 = Geom2D::Point(p1)
+      assert_same(p1, p2)
+    end
+  end
+
+  it "returns the x coordinate" do
+    assert_equal(1, @point.x)
+  end
+
+  it "returns the y coordinate" do
+    assert_equal(2, @point.y)
+  end
+
+  it "returns a bounding box that only encompasses itself" do
+    assert_equal([@point.x, @point.y] * 2, @point.bbox.to_a)
+  end
+
+  it "returns the distance from point to point" do
+    assert_equal(5, @point.distance(Geom2D::Point(5, 5)))
+  end
+
+  describe "unary +/-" do
+    it "unary plus returns self" do
+      assert_same(@point, +@point)
+    end
+
+    it "unary minus returns the point reflected in the origin" do
+      assert_equal([-1, -2], -@point)
+    end
+  end
+
+  describe "+" do
+    it "adds a scalar number" do
+      assert_equal([3, 4], @point + 2)
+    end
+
+    it "adds a point" do
+      assert_equal([2, 4], @point + @point)
+    end
+
+    it "interpretes an array as point" do
+      assert_equal([3, 5], @point + [2, 3])
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @point + "str" }
+    end
+  end
+
+  describe "-" do
+    it "subtracts a scalar number" do
+      assert_equal([-1, 0], @point - 2)
+    end
+
+    it "subtracts a point" do
+      assert_equal([-1, -2], @point - @point * 2)
+    end
+
+    it "interprets an array as point" do
+      assert_equal([-1, -1], @point - [2, 3])
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @point - "str" }
+    end
+  end
+
+  describe "*" do
+    it "multiplies a scalar number" do
+      assert_equal([5, 10], @point * 5)
+    end
+
+    it "performs the dot product with another point" do
+      assert_equal(5, @point * @point)
+    end
+
+    it "interprets an array as point" do
+      assert_equal(8, @point * [2, 3])
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @point * "str" }
+    end
+  end
+
+  it "has a dot product which is just the multiplication" do
+    assert_equal(@point * [2, 3], @point.dot([2, 3]))
+  end
+
+  it "has a wedge product" do
+    assert_equal(-1, @point.wedge([2, 3]))
+  end
+
+  describe "/" do
+    it "divides by a scalar number" do
+      assert_equal([0.5, 1], @point / 2)
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @point / "str" }
+    end
+  end
+
+  describe "==" do
+    it "compares with a point" do
+      assert(@point == Geom2D::Point(1, 2))
+    end
+
+    it "interpretes an array as point" do
+      assert(@point == [1, 2])
+    end
+
+    it "returns false for objects with incompatible classes" do
+      refute(@point == 5)
+    end
+  end
+
+  it "destructures like an array" do
+    assert_equal(@point, Geom2D::Point(*@point))
+  end
+
+  it "returns a useful inspection string" do
+    assert_equal("(1, 2)", @point.inspect)
+  end
+end

data/test/geom2d/test_polygon.rb

@@ -0,0 +1,69 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/polygon'
+
+describe Geom2D::Polygon do
+  before do
+    @vertices = [[0, 0], [1, 0], [1, 1], [0, 1]]
+    @polygon = Geom2D::Polygon(*@vertices)
+  end
+
+  it "creates a polygon using multiple point-like objects" do
+    polygon = Geom2D::Polygon(*@vertices)
+    assert_equal(@vertices, polygon.to_a)
+  end
+
+  it "returns one for the number of contours" do
+    assert_equal(1, @polygon.nr_of_contours)
+  end
+
+  it "returns the number of vertices" do
+    assert_equal(4, @polygon.nr_of_vertices)
+  end
+
+  it "returns the i-th vertex" do
+    assert_equal([1, 1], @polygon[2])
+  end
+
+  it "enumerates the vertices" do
+    assert_equal(@vertices, @polygon.each_vertex.to_a)
+  end
+
+  it "allows adding points to the end" do
+    polygon = Geom2D::Polygon.new
+    polygon << [0, 0] << [1, 0]
+    assert_equal([[0, 0], [1, 0]], polygon.to_a)
+  end
+
+  it "allows removing the last point" do
+    @polygon.pop
+    assert_equal([[0, 0], [1, 0], [1, 1]], @polygon.to_a)
+  end
+
+  it "iterates over each segment" do
+    segments = [Geom2D::Segment([0, 0], [1, 0]), Geom2D::Segment([1, 0], [1, 1]),
+                Geom2D::Segment([1, 1], [0, 1]), Geom2D::Segment([0, 1], [0, 0])]
+    assert_equal(segments, @polygon.each_segment.to_a)
+  end
+
+  it "returns the bounding box" do
+    assert_equal([5, 5, 10, 10], Geom2D::Polygon([5, 5], [10, 5], [10, 10]).bbox.to_a)
+    assert_equal([0, 0, 0, 0], Geom2D::Polygon().bbox.to_a)
+  end
+
+  it "returns whether the polygon's vertices are counterclockwise ordered" do
+    assert(@polygon.ccw?)
+    @polygon.reverse!
+    refute(@polygon.ccw?)
+  end
+
+  it "reverses the vertex list" do
+    @polygon.reverse!
+    assert_equal([[0, 1], [1, 1], [1, 0], [0, 0]], @polygon.to_a)
+  end
+
+  it "returns a useful inspection string" do
+    assert_equal("Polygon[(0, 0), (1, 0), (1, 1), (0, 1)]", @polygon.inspect)
+  end
+end

data/test/geom2d/test_polygon_set.rb

@@ -0,0 +1,41 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/polygon_set'
+
+describe Geom2D::PolygonSet do
+  before do
+    @polygon = Geom2D::Polygon([0, 0], [1, 0], [1, 1], [0, 1])
+    @ps = Geom2D::PolygonSet(@polygon)
+    @polygon2 = Geom2D::Polygon([10, 10], [10, 15], [15, 10])
+  end
+
+  it "allows adding polygons" do
+    @ps << @polygon2
+    assert_equal(2, @ps.nr_of_contours)
+  end
+
+  it "allows joining another polygon set" do
+    other = Geom2D::PolygonSet(@polygon2)
+    result = @ps + other
+    assert_equal(2, result.nr_of_contours)
+  end
+
+  it "iterates over each segment" do
+    @ps << @polygon2
+    segments = [Geom2D::Segment([0, 0], [1, 0]), Geom2D::Segment([1, 0], [1, 1]),
+                Geom2D::Segment([1, 1], [0, 1]), Geom2D::Segment([0, 1], [0, 0]),
+                Geom2D::Segment([10, 10], [10, 15]), Geom2D::Segment([10, 15], [15, 10]),
+                Geom2D::Segment([15, 10], [10, 10])]
+    assert_equal(segments, @ps.each_segment.to_a)
+  end
+
+  it "returns the bounding box" do
+    assert_equal([0, 0, 1, 1], @polygon.bbox.to_a)
+    assert_equal([0, 0, 0, 0], Geom2D::PolygonSet.new.bbox.to_a)
+  end
+
+  it "returns a useful inspection string" do
+    assert_equal("PolygonSet[Polygon[(0, 0), (1, 0), (1, 1), (0, 1)]]", @ps.inspect)
+  end
+end

data/test/geom2d/test_segment.rb

@@ -0,0 +1,253 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/segment'
+
+describe Geom2D::Segment do
+  before do
+    @point = Geom2D::Point(1, 2)
+    @line = Geom2D::Segment(@point, [3, 4])
+  end
+
+  describe "Segment method" do
+    it "creates a line using two point-like objects" do
+      line = Geom2D::Segment(@point, [3, 4])
+      assert_equal(@point, line.start_point)
+      assert_equal([3, 4], line.end_point)
+    end
+
+    it "creates a line using a point and a vector" do
+      line = Geom2D::Segment(@point, vector: [5, 5])
+      assert_equal(@point, line.start_point)
+      assert_equal(@point + [5, 5], line.end_point)
+    end
+
+    it "fails if only one argument is given" do
+      assert_raises(ArgumentError) { Geom2D::Segment(@point) }
+    end
+  end
+
+  it "returns the start point" do
+    assert_equal(@point, @line.start_point)
+  end
+
+  it "returns the end point" do
+    assert_equal([3, 4], @line.end_point)
+  end
+
+  it "checks whether the segment is degenerate, i.e. only a point" do
+    refute(@line.degenerate?)
+    assert(Geom2D::Segment([5, 5], [5, 5]))
+  end
+
+  it "checks whether the segment is vertical" do
+    refute(@line.vertical?)
+    assert(Geom2D::Segment([5, 5], [5, 10]).vertical?)
+  end
+
+  it "checks whether the segment is horizontal" do
+    refute(@line.horizontal?)
+    assert(Geom2D::Segment([5, 5], [10, 5]).horizontal?)
+  end
+
+  it "returns the minimum (left bottom) point" do
+    assert_equal(@line.start_point, @line.min)
+    @line.reverse!
+    assert_equal(@line.end_point, @line.min)
+  end
+
+  it "returns the maximum (right top) point" do
+    assert_equal(@line.end_point, @line.max)
+    @line.reverse!
+    assert_equal(@line.start_point, @line.max)
+  end
+
+  it "returns the length" do
+    assert_equal(Math.sqrt(8), @line.length)
+  end
+
+  it "returns the direction" do
+    assert_equal([2, 2], @line.direction)
+  end
+
+  it "returns the slope" do
+    assert_equal(1, @line.slope)
+  end
+
+  it "returns the y-axes intercept" do
+    assert_equal(1, @line.y_intercept)
+  end
+
+  describe "for vertical segments" do
+    before do
+      @line = Geom2D::Segment([0, 0], [0, 2])
+    end
+
+    it "returns infinity for the slope" do
+      assert_equal(Float::INFINITY, @line.slope)
+    end
+
+    it "returns nil for the y-axes intercept" do
+      assert_nil(@line.y_intercept)
+    end
+  end
+
+  it "reverses the direction of the segment" do
+    @line.reverse!
+    assert_equal(@point, @line.end_point)
+    assert_equal([3, 4], @line.start_point)
+  end
+
+  describe "intersect" do
+    def assert_intersection(expected, result)
+      case expected
+      when nil then assert_nil(expected)
+      when Array, Geom2D::Point then assert_equal(expected, result)
+      else
+        assert_equal(expected.min, result.start_point)
+        assert_equal(expected.max, result.end_point)
+      end
+    end
+
+    def check_intersection(result, line1, line2)
+      assert_intersection(result, line1.intersect(line2))
+      assert_intersection(result, line2.intersect(line1))
+      line2.reverse!
+      assert_intersection(result, line1.intersect(line2))
+      assert_intersection(result, line2.intersect(line1))
+      line1.reverse!
+      assert_intersection(result, line1.intersect(line2))
+      assert_intersection(result, line2.intersect(line1))
+      line2.reverse!
+      assert_intersection(result, line1.intersect(line2))
+      assert_intersection(result, line2.intersect(line1))
+    end
+
+    describe "general lines" do
+      it "returns nil for non-intersecting lines" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([3, 2], [10, 10])
+        check_intersection(nil, line1, line2)
+      end
+
+      it "returns one point for lines with a common endpoint" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([0, 0], [10, 10])
+        check_intersection([0, 0], line1, line2)
+      end
+
+      it "returns one point for lines where an endpoint lies inside the other line" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([5, 0], [10, 10])
+        check_intersection([5, 0], line1, line2)
+      end
+
+      it "returns one point for general intersection" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([5, 5], [5, -5])
+        check_intersection([5, 0], line1, line2)
+      end
+    end
+
+    describe "parallel lines" do
+      it "returns nil for non collinear lines" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([0, 2], [10, 2])
+        check_intersection(nil, line1, line2)
+      end
+
+      it "returns nil for collinear lines with no overlap" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([12, 0], [20, 0])
+        check_intersection(nil, line1, line2)
+      end
+
+      it "returns one point for collinear lines which have one common end point" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([10, 0], [20, 0])
+        check_intersection([10, 0], line1, line2)
+      end
+
+      it "returns inside segment for lines with no common end/start points" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([5, 0], [8, 0])
+        check_intersection(line2, line1, line2)
+      end
+
+      it "returns inside segment for lines with common start points" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([0, 0], [8, 0])
+        check_intersection(line2, line1, line2)
+      end
+
+      it "returns inside segment for lines with common end points" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([2, 0], [10, 0])
+        check_intersection(line2, line1, line2)
+      end
+
+      it "returns inside segment for identical lines" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        check_intersection(line1, line1, line1)
+      end
+
+      it "returns overlapping segment for lines with no common end/start points" do
+        line1 = Geom2D::Segment([0, 0], [10, 0])
+        line2 = Geom2D::Segment([5, 0], [15, 0])
+        result = Geom2D::Segment([5, 0], [10, 0])
+        check_intersection(result, line1, line2)
+      end
+    end
+  end
+
+  describe "unary +/-" do
+    it "unary plus returns self" do
+      assert_same(@line, +@line)
+    end
+
+    it "unary minus returns the line reflected in the origin" do
+      reflection = -@line
+      assert_equal(-@line.start_point, reflection.start_point)
+      assert_equal(-@line.end_point, reflection.end_point)
+    end
+  end
+
+  describe "+" do
+    it "adds a vector to translate the line" do
+      translated = @line + @point
+      assert_equal([2, 4], translated.start_point)
+      assert_equal([4, 6], translated.end_point)
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @line + 5 }
+    end
+  end
+
+  describe "-" do
+    it "subtracts a vector to translate the line" do
+      translated = @line - @point
+      assert_equal([0, 0], translated.start_point)
+      assert_equal([2, 2], translated.end_point)
+    end
+
+    it "fails if the argument class is invalid" do
+      assert_raises(ArgumentError) { @line - 5 }
+    end
+  end
+
+  describe "==" do
+    it "compares to segments by comparing their endpoints" do
+      assert_equal(Geom2D::Segment([0, 0], [0, 1]), Geom2D::Segment([0, 0], [0, 1]))
+      refute_equal(Geom2D::Segment([0, 0], [0, 1]), Geom2D::Segment([0, 1], [0, 0]))
+    end
+
+    it "returns false for objects with incompatible classes" do
+      refute_equal(@line, @point)
+    end
+  end
+
+  it "returns a useful inspection string" do
+    assert_equal("Segment[(1, 2)-(3, 4)]", @line.inspect)
+  end
+end