geom2d 0.1.0

data/lib/geom2d/utils.rb

@@ -0,0 +1,38 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+module Geom2D
+
+  # Contains utility methods and classes.
+  module Utils
+
+    autoload(:SortedLinkedList, 'geom2d/utils/sorted_linked_list')
+
+    # The precision when comparing two floats, defaults to 1e-10.
+    singleton_class.attr_accessor :precision
+    self.precision = 1e-10
+
+    private
+
+    # Compares two float whether they are equal using the set precision.
+    def float_equal(a, b)
+      (a - b).abs < Utils.precision
+    end
+
+    # Compares two floats like the <=> operator but using the set precision for detecting whether
+    # they are equal.
+    def float_compare(a, b)
+      result = a - b
+      (result.abs < Utils.precision ? 0 : a <=> b)
+    end
+
+  end
+
+end

data/lib/geom2d/utils/sorted_linked_list.rb

@@ -0,0 +1,154 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+module Geom2D
+  module Utils
+
+    # A doubly linked list that keeps its items sorted.
+    class SortedLinkedList
+
+      include Enumerable
+
+      # A node of the double linked list.
+      class Node
+
+        AnchorValue = Object.new #:nodoc:
+
+        # Creates a Node object that can be used as the anchor of the doubly linked list.
+        def self.create_anchor
+          Node.new(AnchorValue).tap {|anchor| anchor.next_node = anchor.prev_node = anchor }
+        end
+
+        # The previous node in the list. The first node points to the anchor node.
+        attr_accessor :prev_node
+
+        # The next node in the list. The last node points to the anchor node.
+        attr_accessor :next_node
+
+        # The value of the node.
+        attr_accessor :value
+
+        # Creates a new Node for the given value, with optional previous and next nodes to point to.
+        def initialize(value, prev_node = nil, next_node = nil)
+          @prev_node = prev_node
+          @next_node = next_node
+          @value = value
+        end
+
+        # Returns +true+ if this node is an anchor node, i.e. the start and end of this list.
+        def anchor?
+          @value == AnchorValue
+        end
+
+        # Inserts this node before the given node.
+        def insert_before(node)
+          @prev_node = node.prev_node
+          @next_node = node
+          node.prev_node.next_node = self
+          node.prev_node = self
+          self
+        end
+
+        # Deletes this node from the linked list.
+        def delete
+          @prev_node.next_node = @next_node
+          @next_node.prev_node = @prev_node
+          @prev_node = @next_node = nil
+          @value
+        end
+
+      end
+
+      # Creates a new SortedLinkedList using the +comparator+ or the given block as compare
+      # function.
+      #
+      # The comparator has to respond to +call(a, b)+ where +a+ is the value to be inserted and +b+
+      # is the value to which it is compared. The return value should be +true+ if the value +a+
+      # should be inserted before +b+, i.e. at the position of +b+.
+      def initialize(comparator = nil, &block)
+        @anchor = Node.create_anchor
+        @comparator = comparator || block
+      end
+
+      # Returns +true+ if the list is empty?
+      def empty?
+        @anchor.next_node == @anchor
+      end
+
+      # Returns the last value in the list.
+      def last
+        empty? ? nil : @anchor.prev_node.value
+      end
+
+      # Yields each value in sorted order.
+      #
+      # If no block is given, an enumerator is returned.
+      def each #:yield: value
+        return to_enum(__method__) unless block_given?
+        current = @anchor.next_node
+        while current != @anchor
+          yield(current.value)
+          current = current.next_node
+        end
+      end
+
+      # Returns the node with the given value, or +nil+ if no such value is found.
+      def find_node(value)
+        current = @anchor.next_node
+        while current != @anchor
+          return current if current.value == value
+          current = current.next_node
+        end
+      end
+
+      # Inserts the value and returns self.
+      def push(value)
+        insert(value)
+        self
+      end
+
+      # Inserts a new node with the given value into the list (at a position decided by the compare
+      # function) and returns it.
+      def insert(value)
+        node = Node.new(value)
+        current = @anchor.next_node
+        while current != @anchor
+          if @comparator.call(node.value, current.value)
+            return node.insert_before(current)
+          end
+          current = current.next_node
+        end
+        node.insert_before(@anchor)
+      end
+
+      # Clears the list.
+      def clear
+        @anchor = Node.create_anchor
+      end
+
+      # Removes the top node from the list and returns its value.
+      def pop
+        return nil if empty?
+        @anchor.prev_node.delete
+      end
+
+      # Deletes the node with the given value from the list and returns its value.
+      def delete(value)
+        find_node(value)&.delete
+      end
+
+      def inspect #:nodoc:
+        "#<#{self.class.name}:0x#{object_id.to_s(16).rjust(0.size * 2, '0')} #{to_a}>"
+      end
+
+    end
+
+  end
+end

data/lib/geom2d/version.rb

@@ -0,0 +1,16 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+module Geom2D
+
+  # The version of Geom2D
+  VERSION = '0.1.0'
+
+end

data/test/geom2d/algorithms/test_polygon_operation.rb

@@ -0,0 +1,229 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/algorithms/polygon_operation'
+
+describe Geom2D::Algorithms::PolygonOperation::SweepEvent do
+  before do
+    @klass = Geom2D::Algorithms::PolygonOperation::SweepEvent
+    @left = @klass.new(true, Geom2D::Point(5, 3), :subject)
+    @right = @klass.new(false, Geom2D::Point(8, 5), :subject, other_event: @left)
+    @left.other_event = @right
+  end
+
+  describe "below?/above?" do
+    before do
+      @point_above = Geom2D::Point(6, 5)
+      @point_below = Geom2D::Point(6, 3)
+    end
+
+    it "works for the left endpoint event" do
+      assert(@left.below?(@point_above))
+      assert(@left.above?(@point_below))
+    end
+
+    it "works for the right endpoint event" do
+      assert(@right.below?(@point_above))
+      assert(@right.above?(@point_below))
+    end
+  end
+
+  it "detects vertical segments" do
+    assert(@klass.new(false, Geom2D::Point(5, 8), :subject, other_event: @left).vertical?)
+  end
+end
+
+describe Geom2D::Algorithms::PolygonOperation do
+  def assert_op(result, op, subject = @ps, clipping = @qs)
+    alg_result = Geom2D::Algorithms::PolygonOperation.run(subject, clipping, op)
+    result_segments = result.each_segment.to_a
+    alg_result_segments = alg_result.each_segment.to_a
+    assert_equal(result_segments.size, alg_result_segments.size)
+    0.upto(result_segments.size - 1) do |i|
+      assert_equal(result_segments[i], alg_result_segments[i])
+    end
+  end
+
+  it "doesn't work if edges of the same polygon overlap" do
+    ps = Geom2D::PolygonSet.new([Geom2D::Polygon([0, 0], [5, 0], [5, 5], [0, 5], [0, 0], [2, 0])])
+    assert_raises(RuntimeError) { assert_op(ps, :union, ps, ps) }
+  end
+
+  describe "trivial operation" do
+    before do
+      @p = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10])
+      @set = Geom2D::PolygonSet.new([@p])
+      @empty = Geom2D::PolygonSet.new
+    end
+
+    it "subject is empty" do
+      assert_op(@set, :union, @empty, @set)
+      assert_op(@empty, :intersection, @empty, @set)
+      assert_op(@set, :xor, @empty, @set)
+      assert_op(@empty, :difference, @empty, @set)
+    end
+
+    it "clipping is empty" do
+      assert_op(@set, :union, @set, @empty)
+      assert_op(@empty, :intersection, @set, @empty)
+      assert_op(@set, :xor, @set, @empty)
+      assert_op(@set, :difference, @set, @empty)
+    end
+
+    it "bounding boxes are not intersecting" do
+      set2 = Geom2D::PolygonSet(Geom2D::Polygon([15, 15], [20, 15], [20, 20], [15, 20]))
+      assert_op(@set + set2, :union, @set, set2)
+      assert_op(@empty, :intersection, @set, set2)
+      assert_op(@set + set2, :xor, @set, set2)
+      assert_op(@set, :difference, @set, set2)
+    end
+  end
+
+  #       +-----+
+  #       |Qout |
+  #       |     |
+  #  +----+-----+-----+
+  #  |    |Qin,P|     |
+  #  |    |     |     |
+  #  |    +-----+     |
+  #  |                |
+  #  |       P        |
+  #  +----------------+
+  describe "complete overlapping edges" do
+    before do
+      @p = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10], [0, 0])
+      @ps = Geom2D::PolygonSet.new([@p])
+      @q_in = Geom2D::Polygon([3, 10], [3, 5], [8, 5], [8, 10])
+      @qs_in = Geom2D::PolygonSet.new([@q_in])
+      @q_out = Geom2D::Polygon([3, 10], [3, 15], [8, 15], [8, 10])
+      @qs_out = Geom2D::PolygonSet.new([@q_out])
+    end
+
+    it "union" do
+      @qs = @qs_in
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10])
+      assert_op(result, :union)
+
+      @qs = @qs_out
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [8, 10], [8, 15], [3, 15], [3, 10], [0, 10])
+      assert_op(result, :union)
+    end
+
+    it "intersection" do
+      @qs = @qs_in
+      result = Geom2D::Polygon([3, 5], [8, 5], [8, 10], [3, 10])
+      assert_op(result, :intersection)
+
+      @qs = @qs_out
+      result = Geom2D::Polygon()
+      assert_op(result, :intersection)
+    end
+
+    it "xor" do
+      @qs = @qs_in
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [8, 10], [8, 5], [3, 5], [3, 10], [0, 10])
+      assert_op(result, :xor)
+
+      @qs = @qs_out
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [8, 10], [8, 15], [3, 15], [3, 10], [0, 10])
+      assert_op(result, :xor)
+    end
+
+    it "difference" do
+      @qs = @qs_in
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [8, 10], [8, 5], [3, 5], [3, 10], [0, 10])
+      assert_op(result, :difference)
+
+      @qs = @qs_out
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10])
+      assert_op(result, :difference)
+    end
+  end
+
+  #    +-----+--------------+-----+
+  #     \ Q /                \ P /
+  #      \ /                  \ /
+  #       X       P,Q          X
+  #      / \                  / \
+  #     / P \                / Q \
+  #    +-----+--------------+-----+
+  describe "partial overlapping edges" do
+    before do
+      @p = Geom2D::Polygon([0, 0], [10, 0], [15, 10], [5, 10])
+      @ps = Geom2D::PolygonSet.new([@p])
+      @q = Geom2D::Polygon([0, 10], [5, 0], [15, 0], [10, 10])
+      @qs = Geom2D::PolygonSet.new([@q])
+    end
+
+    it "union" do
+      result = Geom2D::Polygon([0, 0], [15, 0], [12.5, 5], [15, 10], [0, 10], [2.5, 5])
+      assert_op(result, :union)
+    end
+
+    it "intersection" do
+      result = Geom2D::Polygon([2.5, 5], [5, 0], [10, 0], [12.5, 5], [10, 10], [5, 10])
+      assert_op(result, :intersection)
+    end
+
+    it "xor" do
+      left = Geom2D::Polygon([0, 0], [5, 0], [2.5, 5], [5, 10], [0, 10], [2.5, 5])
+      right = Geom2D::Polygon([10, 0], [15, 0], [12.5, 5], [15, 10], [10, 10], [12.5, 5])
+      assert_op(Geom2D::PolygonSet(left, right), :xor)
+    end
+
+    it "difference" do
+      left = Geom2D::Polygon([0, 0], [5, 0], [2.5, 5])
+      right = Geom2D::Polygon([10, 10], [12.5, 5], [15, 10])
+      assert_op(Geom2D::PolygonSet(left, right), :difference)
+    end
+  end
+
+  #   +------+------+
+  #   |  Q   |      |
+  #   |      |      |
+  #   +------+      |
+  #   |             |
+  #   |     P       |
+  #   +-------------+
+  describe "overlapping corner" do
+    before do
+      @p = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10])
+      @ps = Geom2D::PolygonSet.new([@p])
+      @q = Geom2D::Polygon([0, 10], [5, 10], [5, 5], [0, 5])
+      @qs = Geom2D::PolygonSet.new([@q])
+    end
+
+    it "union" do
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [0, 10])
+      assert_op(result, :union)
+    end
+
+    it "intersection" do
+      result = Geom2D::Polygon([0, 5], [5, 5], [5, 10], [0, 10])
+      assert_op(result, :intersection)
+    end
+
+    it "difference" do
+      result = Geom2D::Polygon([0, 0], [10, 0], [10, 10], [5, 10], [5, 5], [0, 5])
+      assert_op(result, :difference)
+    end
+  end
+
+  describe "self-intersecting polygon" do
+    it "intersection" do
+      p1 = Geom2D::Polygon([0, 20], [0, 2], [15, -1], [15, 18])
+      @ps = Geom2D::PolygonSet.new([p1])
+      q1 = Geom2D::Polygon([1, 11], [13, 17], [13, 11], [1, 17])
+      q2 = Geom2D::Polygon([2, 3], [11, 3], [11, 9])
+      q3 = Geom2D::Polygon([3, 8], [3, 5], [8, 5])
+      @qs = Geom2D::PolygonSet.new([q1, q2, q3])
+      result = Geom2D::PolygonSet(
+        Geom2D::Polygon([1, 11], [7, 14], [1, 17]),
+        Geom2D::Polygon([2, 3], [11, 3], [11, 9], [6.421052631578, 5.947368421052], [8, 5], [5, 5],
+                        [6.421052631578, 5.947368421052], [3, 8], [3, 5], [5, 5]),
+        Geom2D::Polygon([7, 14], [13, 11], [13, 17])
+      )
+      assert_op(result, :intersection)
+    end
+  end
+end

data/test/geom2d/test_algorithms.rb

@@ -0,0 +1,26 @@
+# -*- frozen_string_literal: true -*-
+
+require 'test_helper'
+require 'geom2d/algorithms'
+require 'geom2d/point'
+
+describe Geom2D::Algorithms do
+  describe "ccw" do
+    before do
+      @p1 = Geom2D::Point(1, 2)
+      @p2 = Geom2D::Point(3, 4)
+    end
+
+    it "returns 1 for counterclockwise turn" do
+      assert_equal(1, Geom2D::Algorithms.ccw(@p1, @p2, Geom2D::Point(0, 3)))
+    end
+
+    it "returns -1 for clockwise turn" do
+      assert_equal(-1, Geom2D::Algorithms.ccw(@p1, @p2, Geom2D::Point(2, 0)))
+    end
+
+    it "returns 0 for collinear points" do
+      assert_equal(0, Geom2D::Algorithms.ccw(@p1, @p2, @p2 + (@p2 - @p1)))
+    end
+  end
+end