geom2d 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3edb20280c7781756b3e384e9882aea7c3a98ef0803a33c801cf6580a9d4e3ef
+  data.tar.gz: f1f8dc432c32de394ef313536b1faac5e7719f88ef68d1138c2abc7aec56309a
+SHA512:
+  metadata.gz: 429eae46087970b5624c6cefad3f907a44d812093be921f831675cb92cb17901f7efc1c825d844137684156b16e7d9479957d4edd9310242394a448415f21e66
+  data.tar.gz: 3302aa1ebe48790c07c72d6c8882bd6fae780596bf641e0ad4b82852ed76370f6f0599d93ab92155033ed657548fa837539a3d74a3df4a28ccca8cbd314f9ae8

data/CONTRIBUTERS

@@ -0,0 +1,3 @@
+  Count Name
+======= ====
+      8 Thomas Leitner <t_leitner@gmx.at>

data/LICENSE

@@ -0,0 +1,21 @@
+geom2d - 2D Geometry Objects and Algorithms
+Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# Geom2D - Objects and Algorithms for 2D Geometry in Ruby
+
+This library implements objects for 2D geometry, like points, lines, line segments, arcs, curves and
+so on, as well as algorithms for these objects, like line-line intersections and arc approximation
+by Bézier curves.
+
+
+## License
+
+Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>, licensed under the MIT - see the **LICENSE**
+file.
+
+
+## Features
+
+* Objects
+  * Point
+  * Segment
+  * Polygon
+  * PolygonSet
+  * Polyline (TODO)
+  * Rectangle (TODO)
+  * QuadraticCurve (TODO)
+  * QubicCurve (TODO)
+  * Arc (TODO)
+  * Circle (TODO)
+  * Path (TODO)
+* Algorithms
+  * Segment-Segment Intersection
+  * Boolean Operations on PolygonSets
+
+## Usage
+
+~~~ ruby
+require 'geom2d'
+
+# Point, can also be interpreted as vector
+point1 = Geom2D::Point(2, 2)
+point2 = Geom2D::Point([2, 2])   # arrays are fine but not as efficient
+point3 = Geom2D::Point(point2)   # copy constructor
+
+# Segment defined by two points or a point and a vector
+line1 = Geom2D::Segment(point1, point2)
+line2 = Geom2D::Segment(point1, vector: point2)
+line3 = Geom2D::Segment([3, 4], [9, 6])   # arrays are also possible
+
+# Segment intersection
+line1.intersect(line3)  # => intersection_point
+~~~

data/Rakefile

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+require 'rake/clean'
+require 'rubygems/package_task'
+
+$:.unshift('lib')
+require 'geom2d/version'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*.rb']
+  t.verbose = false
+  t.warning = true
+end
+
+namespace :dev do
+  PKG_FILES = FileList.new(
+    [
+      'README.md',
+      'lib/**/*.rb',
+      'test/**/*',
+      'Rakefile',
+      'LICENSE',
+      'VERSION',
+      'CONTRIBUTERS',
+    ]
+  )
+
+  CLOBBER << "VERSION"
+  file 'VERSION' do
+    puts "Generating VERSION file"
+    File.open('VERSION', 'w+') {|file| file.write(Geom2D::VERSION + "\n") }
+  end
+
+  CLOBBER << 'CONTRIBUTERS'
+  file 'CONTRIBUTERS' do
+    puts "Generating CONTRIBUTERS file"
+    `echo "  Count Name" > CONTRIBUTERS`
+    `echo "======= ====" >> CONTRIBUTERS`
+    `git log | grep ^Author: | sed 's/^Author: //' | sort | uniq -c | sort -nr >> CONTRIBUTERS`
+  end
+
+  spec = Gem::Specification.new do |s|
+    s.name = 'geom2d'
+    s.version = Geom2D::VERSION
+    s.summary = "Objects and Algorithms for 2D Geometry"
+    s.license = 'MIT'
+
+    s.files = PKG_FILES.to_a
+
+    s.require_path = 'lib'
+    s.required_ruby_version = '>= 2.4'
+
+    s.author = 'Thomas Leitner'
+    s.email = 't_leitner@gmx.at'
+    s.homepage = "https://geom2d.gettalong.org"
+  end
+
+  Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+  end
+
+  desc "Upload the release to Rubygems"
+  task publish_files: [:package] do
+    sh "gem push pkg/geom2d-#{Geom2D::VERSION}.gem"
+    puts 'done'
+  end
+
+  desc 'Release Geom2D version ' + Geom2D::VERSION
+  task release: [:clobber, :package, :publish_files]
+
+  desc "Insert/Update copyright notice"
+  task :update_copyright do
+    statement = <<~STATEMENT
+      #--
+      # 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.
+      #++
+    STATEMENT
+    state_re = /\A(#.*\n)*#{Regexp.escape(statement)}/
+    inserted = false
+    Dir["lib/**/*.rb"].each do |file|
+      unless File.read(file).match?(state_re)
+        inserted = true
+        puts "Updating file #{file}"
+        old = File.read(file)
+        old.sub!(/^#--.*?\n#\+\+\n|\A/m, statement)
+        File.write(file, old)
+      end
+    end
+    puts "Look through the above mentioned files and correct all problems" if inserted
+  end
+end
+
+task clobber: 'dev:clobber'
+task default: 'test'

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/geom2d.rb

@@ -0,0 +1,70 @@
+# -*- 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.
+#++
+
+# = Geom2D - Objects and Algorithms for 2D Geometry in Ruby
+#
+# This library implements objects for 2D geometry, like points, line segments, arcs, curves and so
+# on, as well as algorithms for these objects, like line-line intersections and arc approximation by
+# Bezier curves.
+module Geom2D
+
+  autoload(:Point, 'geom2d/point')
+  autoload(:Segment, 'geom2d/segment')
+  autoload(:Polygon, 'geom2d/polygon')
+  autoload(:PolygonSet, 'geom2d/polygon_set')
+
+  autoload(:BoundingBox, 'geom2d/bounding_box')
+  autoload(:Algorithms, 'geom2d/algorithms')
+
+  autoload(:Utils, 'geom2d/utils')
+  autoload(:VERSION, 'geom2d/version')
+
+  # Creates a new Point object from the given coordinates.
+  #
+  # See: Point.new
+  def self::Point(x, y = nil)
+    if x.kind_of?(Point)
+      x
+    elsif y
+      Point.new(x, y)
+    else
+      Point.new(*x)
+    end
+  end
+
+  # Creates a new Segment from +start_point+ to +end_point+ or, if +vector+ is given, from
+  # +start_point+ to +start_point+ + +vector+.
+  #
+  # See: Segment.new
+  def self::Segment(start_point, end_point = nil, vector: nil)
+    if end_point
+      Segment.new(start_point, end_point)
+    elsif vector
+      Segment.new(start_point, start_point + vector)
+    else
+      raise ArgumentError, "Either end_point or a vector must be given"
+    end
+  end
+
+  # Creates a new Polygon object from the given vertices.
+  #
+  # See: Polygon.new
+  def self::Polygon(*vertices)
+    Polygon.new(vertices)
+  end
+
+  # Creates a PolygonSet from the given array of Polygon instances.
+  #
+  # See: PolygonSet.new
+  def self::PolygonSet(*polygons)
+    PolygonSet.new(polygons)
+  end
+
+end

data/lib/geom2d/algorithms.rb

@@ -0,0 +1,35 @@
+# -*- 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.
+#++
+
+require 'geom2d/utils'
+
+module Geom2D
+
+  # This module contains helper functions as well as classes implementing algorithms.
+  module Algorithms
+
+    autoload(:PolygonOperation, 'geom2d/algorithms/polygon_operation')
+
+    extend Utils
+
+    # Determines whether the three points form a counterclockwise turn.
+    #
+    # Returns
+    #
+    # * +1 if the points a -> b -> c form a counterclockwise angle,
+    # * -1 if the points a -> b -> c from a clockwise angle, and
+    # *  0 if the points are collinear.
+    def self.ccw(a, b, c)
+      float_compare((b.x - a.x) * (c.y - a.y), (c.x - a.x) * (b.y - a.y))
+    end
+
+  end
+
+end

data/lib/geom2d/algorithms/polygon_operation.rb

@@ -0,0 +1,435 @@
+# -*- 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.
+#++
+
+require 'geom2d/algorithms'
+require 'geom2d/utils'
+require 'geom2d/polygon_set'
+
+module Geom2D
+  module Algorithms
+
+    # Performs intersection, union, difference and xor operations on Geom2D::PolygonSet objects.
+    #
+    # The entry method is PolygonOperation.run.
+    #
+    # The algorithm is described in the paper "A simple algorithm for Boolean operations on
+    # polygons" by Martinez et al (see http://dl.acm.org/citation.cfm?id=2494701). This
+    # implementation is based on the public domain code from
+    # http://www4.ujaen.es/~fmartin/bool_op.html, which is the original implementation from the
+    # authors of the paper.
+    class PolygonOperation
+
+      include Utils
+
+      # Represents one event of the sweep line phase, i.e. a (left or right) endpoint of a segment
+      # together with processing information.
+      class SweepEvent
+
+        include Utils
+
+        # +True+ if the #point is the left endpoint of the segment.
+        attr_accessor :left
+
+        # The point of this event, a Geom2D::Point instance.
+        attr_reader :point
+
+        # The type of polygon, either :clipping or :subject.
+        attr_reader :polygon_type
+
+        # The other event. This event together with the other event represents a segment.
+        attr_accessor :other_event
+
+        # The edge type of the event's segment, either :normal, :non_contributing, :same_transition
+        # or :different_transition.
+        attr_accessor :edge_type
+
+        # +True+ if the segment represents an inside-outside transition from (point.x, -infinity)
+        # into the polygon set to which the segment belongs.
+        attr_accessor :in_out
+
+        # +True+ if the closest segment downwards from this segment that belongs to the other
+        # polygon set represents an inside-outside transition from (point.x, -infinity).
+        attr_accessor :other_in_out
+
+        # +True+ if this event's segment is part of the result polygon set.
+        attr_accessor :in_result
+
+        # The previous event/segment downwards from this segment that is part of the result polygon
+        # set.
+        attr_accessor :prev_in_result
+
+        # Creates a new SweepEvent.
+        def initialize(left, point, polygon_type, other_event: nil, edge_type: :normal)
+          @left = left
+          @point = point
+          @other_event = other_event
+          @polygon_type = polygon_type
+          @edge_type = edge_type
+        end
+
+        # Returns +true+ if this event's line #segment is below the point +p+.
+        def below?(p)
+          if left
+            Algorithms.ccw(@point, @other_event.point, p) > 0
+          else
+            Algorithms.ccw(@other_event.point, @point, p) > 0
+          end
+        end
+
+        # Returns +true+ if this event's line #segment is above the point +p+.
+        def above?(point)
+          !below?(point)
+        end
+
+        # Returns +true+ if this event's line segment is vertical.
+        def vertical?
+          float_equal(@point.x, other_event.point.x)
+        end
+
+        # Returns +true+ if this event should be *processed after the given event*.
+        #
+        # This method is used for sorting events in the event queue of the main algorithm.
+        def process_after?(event)
+          if (cmp = float_compare(point.x, event.point.x)) != 0
+            cmp > 0 # different x-coordinates, true if point.x is greater
+          elsif (cmp = float_compare(point.y, event.point.y)) != 0
+            cmp > 0 # same x-, different y-coordinates, true if point.y is greater
+          elsif left != event.left
+            left # same point; one is left, one is right endpoint; true if left endpoint
+          elsif Algorithms.ccw(point, other_event.point, event.other_event.point) != 0
+            above?(event.other_event.point) # both left or right; not collinear; true if top segment
+          else
+            polygon_type < event.polygon_type # true if clipping polygon
+          end
+        end
+
+        # Returns +true+ it this event's segment is below the segment of the other event.
+        #
+        # This method is used for sorting events in the sweep line status data structure of the main
+        # algorithm.
+        #
+        # This method is intended to be used only on left events!
+        def segment_below?(event)
+          if self == event
+            false
+          elsif Algorithms.ccw(point, other_event.point, event.point) != 0 ||
+              Algorithms.ccw(point, other_event.point, event.other_event.point) != 0
+            # segments are not collinear
+            if point == event.point
+              below?(event.other_event.point)
+            elsif float_compare(point.x, event.point.x) == 0
+              float_compare(point.y, event.point.y) < 0
+            elsif process_after?(event)
+              event.above?(point)
+            else
+              below?(event.point)
+            end
+          elsif polygon_type != event.polygon_type
+            polygon_type > event.polygon_type
+          elsif point == event.point
+            object_id < event.object_id # just need any consistency criterion
+          else
+            process_after?(event)
+          end
+        end
+
+        # Returns +true+ if this event's segment should be in the result based on the boolean
+        # operation.
+        def in_result?(operation)
+          case edge_type
+          when :normal
+            case operation
+            when :intersection then !other_in_out
+            when :union then other_in_out
+            when :difference then polygon_type == :subject ? other_in_out : !other_in_out
+            when :xor then true
+            end
+          when :same_transition
+            operation == :intersection || operation == :union
+          when :different_transition
+            operation == :difference
+          when :non_contributing
+            false
+          end
+        end
+
+        # Returns this event's line segment (point, other_event.point).
+        def segment
+          Geom2D::Segment(point, other_event.point)
+        end
+
+      end
+
+      # Performs the given operation (:union, :intersection, :difference, :xor) on the subject and
+      # clipping polygon sets.
+      def self.run(subject, clipping, operation)
+        new(subject, clipping, operation).run.result
+      end
+
+      # The result of the operation, a Geom2D::PolygonSet.
+      attr_reader :result
+
+      # Creates a new boolean operation object, performing the +operation+ (either :intersection,
+      # :union, :difference or :xor) on the subject and clipping Geom2D::PolygonSet objects.
+      def initialize(subject, clipping, operation)
+        @subject = subject
+        @clipping = clipping
+        @operation = operation
+
+        @result = PolygonSet.new
+        @event_queue = Utils::SortedLinkedList.new {|a, b| a.process_after?(b) }
+        # @sweep_line should really be a sorted data structure with O(log(n)) for insert/search!
+        @sweep_line = Utils::SortedLinkedList.new {|a, b| a.segment_below?(b) }
+        @sorted_events = []
+      end
+
+      # Performs the boolean polygon operation.
+      def run
+        subject_bb = @subject.bbox
+        clipping_bb = @clipping.bbox
+        min_of_max_x = [subject_bb.max_x, clipping_bb.max_x].min
+
+        return self if trivial_operation(subject_bb, clipping_bb)
+
+        @subject.each_segment {|segment| process_segment(segment, :subject) }
+        @clipping.each_segment {|segment| process_segment(segment, :clipping) }
+
+        until @event_queue.empty?
+          event = @event_queue.last
+          if (@operation == :intersection && event.point.x > min_of_max_x) ||
+              (@operation == :difference && event.point.x > subject_bb.max_x)
+            connect_edges
+            return self
+          end
+          @sorted_events.push(event)
+
+          @event_queue.pop
+          if event.left # the segment hast to be inserted into status line
+            node = @sweep_line.insert(event)
+            prev_event = (node.prev_node.anchor? ? nil : node.prev_node.value)
+            next_event = (node.next_node.anchor? ? nil : node.next_node.value)
+
+            compute_event_fields(event, prev_event)
+            if next_event && possible_intersection(event, next_event) == 2
+              compute_event_fields(event, prev_event)
+              compute_event_fields(next_event, event)
+            end
+            if prev_event && possible_intersection(prev_event, event) == 2
+              prevprev_ev = (node.prev_node.prev_node.anchor? ? nil : node.prev_node.prev_node.value)
+              compute_event_fields(prev_event, prevprev_ev)
+              compute_event_fields(event, prev_event)
+            end
+          else # the segment has to be removed from the status line
+            event = event.other_event # use left event
+            node = @sweep_line.find_node(event)
+
+            next_node = node.next_node
+            prev_node = node.prev_node
+            node.delete
+            unless prev_node.anchor? || next_node.anchor?
+              possible_intersection(prev_node.value, next_node.value)
+            end
+          end
+        end
+        connect_edges
+        self
+      end
+
+      private
+
+      # Returns +true+ if the operation is a trivial one, e.g. if one polygon set is empty.
+      def trivial_operation(subject_bb, clipping_bb)
+        if @subject.nr_of_contours * @clipping.nr_of_contours == 0
+          if @operation == :difference
+            @result = @subject
+          elsif @operation == :union || @operation == :xor
+            @result = (@subject.nr_of_contours == 0 ? @clipping : @subject)
+          end
+          true
+        elsif subject_bb.min_x > clipping_bb.max_x || clipping_bb.min_x > subject_bb.max_x ||
+            subject_bb.min_y > clipping_bb.max_y || clipping_bb.min_y > subject_bb.max_y
+          if @operation == :difference
+            @result = @subject
+          elsif @operation == :union || @operation == :xor
+            @result = @subject + @clipping
+          end
+          true
+        else
+          false
+        end
+      end
+
+      # Processes the segment by adding the needed SweepEvent objects into the event queue.
+      def process_segment(segment, polygon_type)
+        return if segment.degenerate?
+        start_point_is_left = (segment.start_point == segment.min)
+        e1 = SweepEvent.new(start_point_is_left, segment.start_point, polygon_type)
+        e2 = SweepEvent.new(!start_point_is_left, segment.end_point, polygon_type, other_event: e1)
+        e1.other_event = e2
+        @event_queue.push(e1).push(e2)
+      end
+
+      # Computes the fields of the sweep event, using information from the previous event.
+      #
+      # The argument +prev+ is either the previous event or +nil+ if there is no previous event.
+      def compute_event_fields(event, prev)
+        if prev.nil?
+          event.in_out = false
+          event.other_in_out = true
+        elsif event.polygon_type == prev.polygon_type
+          event.in_out = !prev.in_out
+          event.other_in_out = prev.other_in_out
+        else
+          event.in_out = !prev.other_in_out
+          event.other_in_out = (prev.vertical? ? !prev.in_out : prev.in_out)
+        end
+
+        if prev
+          event.prev_in_result = if !prev.in_result?(@operation) || prev.vertical?
+                                   prev.prev_in_result
+                                 else
+                                   prev
+                                 end
+        end
+        event.in_result = event.in_result?(@operation)
+      end
+
+      # Checks for possible intersections of the segments of the two events and returns 0 for no
+      # intersections, 1 for intersection in one point, 2 if the segments are equal or have the same
+      # left endpoint, and 3 for all other cases.
+      def possible_intersection(ev1, ev2)
+        result = ev1.segment.intersect(ev2.segment)
+
+        result_is_point = result.kind_of?(Geom2D::Point)
+        if result.nil? ||
+            (result_is_point &&
+             (ev1.point == ev2.point || ev1.other_event.point == ev2.other_event.point))
+          return 0
+        elsif !result_is_point && ev1.polygon_type == ev2.polygon_type
+          raise "Edges of the same polygon overlap - not supported"
+        end
+
+        if result_is_point
+          divide_segment(ev1, result) if ev1.point != result && ev1.other_event.point != result
+          divide_segment(ev2, result) if ev2.point != result && ev2.other_event.point != result
+          return 1
+        end
+
+        events = []
+        if ev1.point == ev2.point
+          events.push(nil)
+        elsif ev1.process_after?(ev2)
+          events.push(ev2, ev1)
+        else
+          events.push(ev1, ev2)
+        end
+        if ev1.other_event.point == ev2.other_event.point
+          events.push(nil)
+        elsif ev1.other_event.process_after?(ev2.other_event)
+          events.push(ev2.other_event, ev1.other_event)
+        else
+          events.push(ev1.other_event, ev2.other_event)
+        end
+
+        if events.size == 2 || (events.size == 3 && events[2])
+          # segments are equal or have the same left endpoint
+          ev1.edge_type = :non_contributing
+          ev2.edge_type = (ev1.in_out == ev2.in_out ? :same_transition : :different_transition)
+          if events.size == 3
+            divide_segment(events[2].other_event, events[1].point)
+          end
+          2
+        elsif events.size == 3 # segments have the same right endpoint
+          divide_segment(events[0], events[1].point)
+          3
+        elsif events[0] != events[3].other_event # partial segment overlap
+          divide_segment(events[0], events[1].point)
+          divide_segment(events[1], events[2].point)
+          3
+        else # one segments includes the other
+          divide_segment(events[0], events[1].point)
+          divide_segment(events[3].other_event, events[2].point)
+          3
+        end
+      end
+
+      # Divides the event's segment at the given point (which has to be inside the segment) and adds
+      # the resulting events to the event queue.
+      def divide_segment(event, point)
+        right = SweepEvent.new(false, point, event.polygon_type, other_event: event)
+        left = SweepEvent.new(true, point, event.polygon_type, other_event: event.other_event)
+        event.other_event.other_event = left
+        event.other_event = right
+        @event_queue.push(left).push(right)
+      end
+
+      # Connects the edges of the segments that are in the result.
+      def connect_edges
+        events = @sorted_events.select do |ev|
+          (ev.left && ev.in_result) || (!ev.left && ev.other_event.in_result)
+        end
+
+        # events may not be fully sorted due to overlapping edges
+        events.sort! {|a, b| a.process_after?(b) ? 1 : -1 }
+        event_pos = {}
+        events.each_with_index do |event, index|
+          event_pos[event] = index
+          unless event.left
+            event_pos[event], event_pos[event.other_event] =
+              event_pos[event.other_event], event_pos[event]
+          end
+        end
+
+        processed = {}
+        events.each do |event|
+          next if processed[event]
+
+          initial_point = event.point
+          polygon = Geom2D::Polygon.new
+          @result << polygon
+          polygon << initial_point
+          while event.other_event.point != initial_point
+            processed[event] = true
+            processed[event.other_event] = true
+            if polygon.nr_of_vertices > 1 &&
+                Algorithms.ccw(polygon[-2], polygon[-1], event.other_event.point) == 0
+              polygon.pop
+            end
+            polygon << event.other_event.point
+            event = next_event(events, event_pos, processed, event)
+          end
+
+          if Algorithms.ccw(polygon[-2], polygon[-1], polygon[0]) == 0
+            polygon.pop
+          end
+          processed[event] = processed[event.other_event] = true
+        end
+      end
+
+      # Chooses the next event based on the argument.
+      def next_event(events, event_pos, processed, event)
+        pos = event_pos[event] + 1
+        while pos < events.size && events[pos].point == event.other_event.point
+          if processed[events[pos]]
+            pos += 1
+          else
+            return events[pos]
+          end
+        end
+
+        pos = event_pos[event] - 1
+        pos -= 1 while processed[events[pos]]
+        events[pos]
+      end
+
+    end
+
+  end
+end