geom2d 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3edb20280c7781756b3e384e9882aea7c3a98ef0803a33c801cf6580a9d4e3ef
-  data.tar.gz: f1f8dc432c32de394ef313536b1faac5e7719f88ef68d1138c2abc7aec56309a
+  metadata.gz: ef94841dc1fefba33e2abbd4303cea33d3d1cfd4db5727a828300b12e7e405d6
+  data.tar.gz: d65cf9ae9017e07c0faf92cccd21cc918d323c31479bfc2f3a99b0a65162d33b
 SHA512:
-  metadata.gz: 429eae46087970b5624c6cefad3f907a44d812093be921f831675cb92cb17901f7efc1c825d844137684156b16e7d9479957d4edd9310242394a448415f21e66
-  data.tar.gz: 3302aa1ebe48790c07c72d6c8882bd6fae780596bf641e0ad4b82852ed76370f6f0599d93ab92155033ed657548fa837539a3d74a3df4a28ccca8cbd314f9ae8
+  metadata.gz: 18dfb48248517e32415185c17e1bc6bf5eab076a6ae43d5302dbc972c88c1da0bb00c70ac1889dcc7d9f8b3ed3596a485e89e4ca4b4b7168b348914ee16b9143
+  data.tar.gz: 93ed02cc3c1037a04bfbe97274c0acc65f2f1ada3417f3de8b47b517664069793757df8a7e6b1ea2cd455a6b569f36ef1aabfed67c39bd07140ace59901fc2b0

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+## 0.2.0 - Unreleased
+
+### Changed
+
+* Make Segment#intersect ~1.71x faster by avoiding unnecessary object creation
+* Refactor and simplify the sorted list implementation used by the polygon
+  operations, making the latter ~1.15x faster
+
+### Fixed
+
+* Fix off-by-one error in Polygon#ccw? calculation
+
+## 0.1.0 - 2018-03-28
+
+* Initial release

data/CONTRIBUTERS

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

data/Rakefile

@@ -21,6 +21,7 @@ namespace :dev do
       'lib/**/*.rb',
       'test/**/*',
       'Rakefile',
+      'CHANGELOG.md',
       'LICENSE',
       'VERSION',
       'CONTRIBUTERS',
@@ -51,6 +52,7 @@ namespace :dev do
 
     s.require_path = 'lib'
     s.required_ruby_version = '>= 2.4'
+    s.add_development_dependency('rubocop', '~> 0.58', '>= 0.58.2')
 
     s.author = 'Thomas Leitner'
     s.email = 't_leitner@gmx.at'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/geom2d.rb

@@ -29,7 +29,7 @@ module Geom2D
   # Creates a new Point object from the given coordinates.
   #
   # See: Point.new
-  def self::Point(x, y = nil)
+  def self.Point(x, y = nil)
     if x.kind_of?(Point)
       x
     elsif y
@@ -43,7 +43,7 @@ module Geom2D
   # +start_point+ to +start_point+ + +vector+.
   #
   # See: Segment.new
-  def self::Segment(start_point, end_point = nil, vector: nil)
+  def self.Segment(start_point, end_point = nil, vector: nil)
     if end_point
       Segment.new(start_point, end_point)
     elsif vector
@@ -56,14 +56,14 @@ module Geom2D
   # Creates a new Polygon object from the given vertices.
   #
   # See: Polygon.new
-  def self::Polygon(*vertices)
+  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)
+  def self.PolygonSet(*polygons)
     PolygonSet.new(polygons)
   end
 

data/lib/geom2d/algorithms/polygon_operation.rb

@@ -66,12 +66,12 @@ module Geom2D
         attr_accessor :prev_in_result
 
         # Creates a new SweepEvent.
-        def initialize(left, point, polygon_type, other_event: nil, edge_type: :normal)
+        def initialize(left, point, polygon_type, other_event = nil)
           @left = left
           @point = point
           @other_event = other_event
           @polygon_type = polygon_type
-          @edge_type = edge_type
+          @edge_type = :normal
         end
 
         # Returns +true+ if this event's line #segment is below the point +p+.
@@ -184,9 +184,9 @@ module Geom2D
         @operation = operation
 
         @result = PolygonSet.new
-        @event_queue = Utils::SortedLinkedList.new {|a, b| a.process_after?(b) }
+        @event_queue = Utils::SortedList.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) }
+        @sweep_line = Utils::SortedList.new {|a, b| a.segment_below?(b) }
         @sorted_events = []
       end
 
@@ -212,9 +212,7 @@ module Geom2D
 
           @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)
+            prevprev_event, prev_event, next_event = @sweep_line.insert(event)
 
             compute_event_fields(event, prev_event)
             if next_event && possible_intersection(event, next_event) == 2
@@ -222,19 +220,14 @@ module Geom2D
               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(prev_event, prevprev_event)
               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)
+            prev_ev, next_ev = @sweep_line.delete(event)
+            if prev_ev && next_ev
+              possible_intersection(prev_ev, next_ev)
             end
           end
         end
@@ -271,7 +264,7 @@ module Geom2D
         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)
+        e2 = SweepEvent.new(!start_point_is_left, segment.end_point, polygon_type, e1)
         e1.other_event = e2
         @event_queue.push(e1).push(e2)
       end
@@ -363,8 +356,8 @@ module Geom2D
       # 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)
+        right = SweepEvent.new(false, point, event.polygon_type, event)
+        left = SweepEvent.new(true, point, event.polygon_type, event.other_event)
         event.other_event.other_event = left
         event.other_event = right
         @event_queue.push(left).push(right)

data/lib/geom2d/polygon.rb

@@ -64,10 +64,8 @@ module Geom2D
       return to_enum(__method__) unless block_given?
       return unless @vertices.size > 1
 
-      0.upto(@vertices.size - 2) do |i|
-        yield(Geom2D::Segment(@vertices[i], @vertices[i + 1]))
-      end
-      yield(Geom2D::Segment(@vertices[-1], @vertices[0]))
+      @vertices.each_cons(2) {|v1, v2| yield(Geom2D::Segment.new(v1, v2)) }
+      yield(Geom2D::Segment.new(@vertices[-1], @vertices[0]))
     end
 
     # Returns the BoundingBox of this polygon, or an empty BoundingBox if the polygon has no
@@ -83,7 +81,7 @@ module Geom2D
     def ccw?
       return true if @vertices.empty?
       area = @vertices[-1].wedge(@vertices[0])
-      1.upto(@vertices.size - 2) {|i| area += @vertices[i].wedge(@vertices[i + 1]) }
+      0.upto(@vertices.size - 2) {|i| area += @vertices[i].wedge(@vertices[i + 1]) }
       area >= 0
     end
 

data/lib/geom2d/segment.rb

@@ -110,27 +110,32 @@ module Geom2D
     def intersect(segment)
       p0 = start_point
       p1 = segment.start_point
-      d0 = direction
-      d1 = segment.direction
-      e = p1 - p0
+      d0x = end_point.x - start_point.x
+      d0y = end_point.y - start_point.y
+      d1x = segment.end_point.x - segment.start_point.x
+      d1y = segment.end_point.y - segment.start_point.y
+      ex = p1.x - p0.x
+      ey = p1.y - p0.y
 
-      cross = d0.wedge(d1).to_f # cross product of direction vectors
+      cross = (d0x * d1y - d1x * d0y).to_f # cross product of direction vectors
 
       if cross.abs > Utils.precision # segments are not parallel
-        s = e.wedge(d1) / cross
+        s = (ex * d1y - d1x * ey) / cross
         return nil if s < 0 || s > 1
-        t = e.wedge(d0) / cross
+        t = (ex * d0y - d0x * ey) / cross
         return nil if t < 0 || t > 1
 
-        result = p0 + [s * d0.x, s * d0.y]
-        result = start_point if result == start_point
-        result = end_point if result == end_point
-        result = segment.start_point if result == segment.start_point
-        result = segment.end_point if result == segment.end_point
-        return result
+        result = p0 + Point.new(s * d0x, s * d0y)
+        return case result
+               when start_point then start_point
+               when end_point then end_point
+               when segment.start_point then segment.start_point
+               when segment.end_point then segment.end_point
+               else result
+               end
       end
 
-      return nil if e.wedge(d0).abs > Utils.precision # non-intersecting parallel segment lines
+      return nil if (ex * d0y - d0x * ey).abs > Utils.precision # non-intersecting parallel segment lines
 
       e0 = end_point
       e1 = segment.end_point

data/lib/geom2d/utils.rb

@@ -13,7 +13,7 @@ module Geom2D
   # Contains utility methods and classes.
   module Utils
 
-    autoload(:SortedLinkedList, 'geom2d/utils/sorted_linked_list')
+    autoload(:SortedList, 'geom2d/utils/sorted_list')
 
     # The precision when comparing two floats, defaults to 1e-10.
     singleton_class.attr_accessor :precision

data/lib/geom2d/utils/sorted_list.rb

@@ -0,0 +1,86 @@
+# -*- 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 list that keeps its items sorted. Currently only used by
+    # Geom2D::Algorithms::PolygonOperation and therefore with special methods for the latter.
+    class SortedList
+
+      include Enumerable
+
+      # Creates a new SortedList 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)
+        @list = []
+        @comparator = comparator || block
+      end
+
+      # Returns +true+ if the list is empty?
+      def empty?
+        @list.empty?
+      end
+
+      # Returns the last value in the list.
+      def last
+        @list.last
+      end
+
+      # Yields each value in sorted order.
+      #
+      # If no block is given, an enumerator is returned.
+      def each(&block) #:yield: value
+        @list.each(&block)
+      end
+
+      # Inserts the value and returns self.
+      def push(value)
+        insert(value)
+        self
+      end
+
+      # Inserts a new value into the list (at a position decided by the compare function) and
+      # returns the previous-previous, previous and next values.
+      def insert(value)
+        i = @list.bsearch_index {|el| @comparator.call(value, el) } || @list.size
+        @list.insert(i, value)
+        [(i <= 1 ? nil : @list[i - 2]), (i == 0 ? nil : @list[i - 1]), @list[i + 1]]
+      end
+
+      # Deletes the given value and returns the previous and next values.
+      def delete(value)
+        i = @list.index(value)
+        result = [(i == 0 ? nil : @list[i - 1]), @list[i + 1]]
+        @list.delete_at(i)
+        result
+      end
+
+      # Clears the list.
+      def clear
+        @list.clear
+      end
+
+      # Removes the top value from the list and returns it.
+      def pop
+        @list.pop
+      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

@@ -11,6 +11,6 @@
 module Geom2D
 
   # The version of Geom2D
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 
 end

data/test/geom2d/algorithms/test_polygon_operation.rb

@@ -7,7 +7,7 @@ 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)
+    @right = @klass.new(false, Geom2D::Point(8, 5), :subject, @left)
     @left.other_event = @right
   end
 
@@ -29,7 +29,7 @@ describe Geom2D::Algorithms::PolygonOperation::SweepEvent do
   end
 
   it "detects vertical segments" do
-    assert(@klass.new(false, Geom2D::Point(5, 8), :subject, other_event: @left).vertical?)
+    assert(@klass.new(false, Geom2D::Point(5, 8), :subject, @left).vertical?)
   end
 end
 

data/test/geom2d/test_polygon.rb

@@ -56,6 +56,8 @@ describe Geom2D::Polygon do
     assert(@polygon.ccw?)
     @polygon.reverse!
     refute(@polygon.ccw?)
+    refute(Geom2D::Polygon([2, 2], [20, 5], [10, 3.0]).ccw?)
+    assert(Geom2D::Polygon([2, 2], [20, 5], [10, 3.4]).ccw?)
   end
 
   it "reverses the vertex list" do

data/test/geom2d/utils/{test_sorted_linked_list.rb → test_sorted_list.rb}

@@ -1,29 +1,38 @@
 # -*- frozen_string_literal: true -*-
 
 require 'test_helper'
-require 'geom2d/utils/sorted_linked_list'
+require 'geom2d/utils/sorted_list'
 
-describe Geom2D::Utils::SortedLinkedList do
+describe Geom2D::Utils::SortedList do
   before do
-    @list = Geom2D::Utils::SortedLinkedList.new {|a, b| a < b }
+    @list = Geom2D::Utils::SortedList.new {|a, b| a < b }
   end
 
   describe "insert" do
-    it "inserts a value and returns its associated node" do
-      node = @list.insert(1)
-      assert_equal(1, node.value)
-      assert(node.prev_node.anchor?)
-      assert(node.next_node.anchor?)
+    it "inserts a value and returns surrounding values" do
+      ppv, pv, nv = @list.insert(1)
+      assert_nil(ppv)
+      assert_nil(pv)
+      assert_nil(nv)
     end
 
     it "uses the comparator for choosing the place to insert the value" do
       @list.insert(10)
       @list.insert(5)
       @list.insert(8)
-      assert_equal([5, 8, 10], @list.to_a)
+      ppv, pv, nv = @list.insert(9)
+      assert_equal([5, 8, 10], [ppv, pv, nv])
+      assert_equal([5, 8, 9, 10], @list.to_a)
     end
   end
 
+  it "deletes a value from the list and returns the neighbouring values" do
+    @list.push(8).push(5).push(3).push(4).push(6)
+    assert_equal([6, nil], @list.delete(8))
+    assert_equal([nil, 4], @list.delete(3))
+    assert_equal([4, 6], @list.delete(5))
+  end
+
   it "returns whether it is empty" do
     assert(@list.empty?)
     @list.insert(5)
@@ -41,14 +50,6 @@ describe Geom2D::Utils::SortedLinkedList do
     assert_equal(10, @list.last)
   end
 
-  it "returns the first node found for a given value" do
-    @list.push(5).push(8)
-    node = @list.find_node(8)
-    assert_equal(8, node.value)
-    assert_equal(5, node.prev_node.value)
-    assert(node.next_node.anchor?)
-  end
-
   it "pops the top value of the list" do
     @list.push(8).push(5)
     assert_equal(8, @list.pop)
@@ -60,11 +61,6 @@ describe Geom2D::Utils::SortedLinkedList do
     assert(@list.empty?)
   end
 
-  it "deletes a value from the list" do
-    @list.push(8).push(5)
-    assert_equal(8, @list.delete(8))
-  end
-
   it "can be inspected" do
     @list.push(8).push(5)
     assert_match(/[5, 8]/, @list.inspect)

metadata

@@ -1,21 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: geom2d
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-28 00:00:00.000000000 Z
-dependencies: []
+date: 2018-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.58'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.58.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.58'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.58.2
 description: 
 email: t_leitner@gmx.at
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - CONTRIBUTERS
 - LICENSE
 - README.md
@@ -30,7 +51,7 @@ files:
 - lib/geom2d/polygon_set.rb
 - lib/geom2d/segment.rb
 - lib/geom2d/utils.rb
-- lib/geom2d/utils/sorted_linked_list.rb
+- lib/geom2d/utils/sorted_list.rb
 - lib/geom2d/version.rb
 - test/geom2d/algorithms/test_polygon_operation.rb
 - test/geom2d/test_algorithms.rb
@@ -39,7 +60,7 @@ files:
 - test/geom2d/test_polygon.rb
 - test/geom2d/test_polygon_set.rb
 - test/geom2d/test_segment.rb
-- test/geom2d/utils/test_sorted_linked_list.rb
+- test/geom2d/utils/test_sorted_list.rb
 - test/test_helper.rb
 homepage: https://geom2d.gettalong.org
 licenses:

data/lib/geom2d/utils/sorted_linked_list.rb

@@ -1,154 +0,0 @@
-# -*- 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