clipper2 0.1.0

data/lib/clipper2/api.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Clipper2
+  class << self
+    def boolean(type, subject, clip = nil, **options)
+      Operations.boolean(type, subject, clip, **options)
+    end
+
+    def union(subject, clip = nil, **options)
+      boolean(:union, subject, clip, **options).first
+    end
+
+    def intersect(subject, clip, **options)
+      boolean(:intersection, subject, clip, **options).first
+    end
+
+    def difference(subject, clip, **options)
+      boolean(:difference, subject, clip, **options).first
+    end
+
+    def xor(subject, clip, **options)
+      boolean(:xor, subject, clip, **options).first
+    end
+
+    def inflate(paths, delta, **options)
+      Operations.inflate(paths, delta, **options)
+    end
+
+    def rect_clip(paths, rect)
+      Operations.rect_clip(paths, rect)
+    end
+
+    def rect_clip_lines(paths, rect)
+      Operations.rect_clip(paths, rect, lines: true)
+    end
+
+    def minkowski_sum(pattern, path, **options)
+      Operations.minkowski_sum(pattern, path, **options)
+    end
+
+    def minkowski_difference(pattern, path, **options)
+      Operations.minkowski_difference(pattern, path, **options)
+    end
+  end
+end

data/lib/clipper2/c_paths64.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Clipper2
+  module CPaths64
+    MAX_ELEMENTS = 100_000_000
+
+    module_function
+
+    def pack(paths)
+      non_empty_paths = paths.reject(&:empty?)
+      values = [2 + non_empty_paths.sum { |path| 2 + (path.size * 2) }, non_empty_paths.size]
+      non_empty_paths.each do |path|
+        values << path.size << 0
+        values.concat(path.send(:quantized_coords))
+      end
+      values.pack("q<*")
+    end
+
+    def pack_path(path)
+      [path.size, 0, *path.send(:quantized_coords)].pack("q<*")
+    end
+
+    def unpack(bytes, scale:)
+      raise CodecError, "CPaths64 data length must be a multiple of 8" unless (bytes.bytesize % 8).zero?
+
+      decode(bytes.unpack("q<*"), scale: scale)
+    end
+
+    def read(pointer, scale:)
+      return Paths.new([], scale: scale) if pointer.nil? || pointer.null?
+
+      length = pointer.read_bytes(8).unpack1("q<")
+      validate_length(length)
+      unpack(pointer.read_bytes(length * 8), scale: scale)
+    end
+
+    def memory_pointer(bytes)
+      pointer = FFI::MemoryPointer.new(:char, bytes.bytesize)
+      pointer.put_bytes(0, bytes)
+      pointer
+    end
+
+    def decode(values, scale:)
+      raise CodecError, "CPaths64 header is missing" if values.length < 2
+
+      total_length, path_count = values.first(2)
+      validate_length(total_length)
+      unless total_length == values.length && path_count.between?(0, total_length)
+        raise CodecError, "invalid CPaths64 header"
+      end
+
+      cursor = 2
+      paths_coords = Array.new(path_count) do
+        vertex_count, reserved = values[cursor, 2]
+        unless vertex_count && vertex_count >= 0 && reserved == 0
+          raise CodecError, "invalid CPath64 header at element #{cursor}"
+        end
+
+        cursor += 2
+        coordinate_count = vertex_count * 2
+        coords = values[cursor, coordinate_count]
+        raise CodecError, "truncated CPath64 coordinates" unless coords&.length == coordinate_count
+
+        cursor += coordinate_count
+        coords
+      end
+
+      raise CodecError, "trailing CPaths64 data" unless cursor == values.length
+
+      Paths.from_coords(paths_coords, scale: scale)
+    end
+
+    def validate_length(length)
+      return if length.is_a?(Integer) && length.between?(2, MAX_ELEMENTS)
+
+      raise CodecError, "invalid CPaths64 element count: #{length.inspect}"
+    end
+    private_class_method :validate_length
+  end
+end

data/lib/clipper2/earcut/engine.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Clipper2
+  module Earcut
+    class Engine
+      include Geometry
+      include Ring
+
+      def initialize(data, hole_indices)
+        @data = data
+        @hole_indices = hole_indices
+        @triangles = []
+      end
+
+      def call
+        outer_end = @hole_indices.empty? ? @data.length / 2 : @hole_indices.first
+        outer = linked_list(0, outer_end, true)
+        return @triangles unless outer && !outer.next.equal?(outer.previous)
+
+        outer = eliminate_holes(outer) unless @hole_indices.empty?
+        earcut_linked(outer)
+        @triangles
+      end
+
+      private
+
+      def earcut_linked(ear, pass = 0)
+        return unless ear
+
+        stop = ear
+        until ear.previous.equal?(ear.next)
+          previous = ear.previous
+          following = ear.next
+          if ear?(ear)
+            @triangles.concat([previous.index, ear.index, following.index])
+            remove_node(ear)
+            ear = following.next
+            stop = following.next
+            next
+          end
+
+          ear = following
+          next unless ear.equal?(stop)
+
+          if pass.zero?
+            earcut_linked(filter_points(ear), 1)
+          elsif pass == 1
+            earcut_linked(cure_local_intersections(filter_points(ear)), 2)
+          else
+            split_earcut(ear)
+          end
+          break
+        end
+      end
+
+      def ear?(ear)
+        first = ear.previous
+        third = ear.next
+        return false if triangle_area(first, ear, third) >= 0
+
+        min_x, max_x = [first.x, ear.x, third.x].minmax
+        min_y, max_y = [first.y, ear.y, third.y].minmax
+        point = third.next
+        until point.equal?(first)
+          inside_bounds = point.x.between?(min_x, max_x) && point.y.between?(min_y, max_y)
+          if inside_bounds && point_in_triangle?(first.x, first.y, ear.x, ear.y, third.x, third.y, point.x, point.y) &&
+              triangle_area(point.previous, point, point.next) >= 0
+            return false
+          end
+          point = point.next
+        end
+        true
+      end
+
+      def cure_local_intersections(start)
+        point = start
+        loop do
+          first = point.previous
+          fourth = point.next.next
+          if !same_point?(first, fourth) && intersects?(first, point, point.next, fourth) &&
+              locally_inside?(first, fourth) && locally_inside?(fourth, first)
+            @triangles.concat([first.index, point.index, fourth.index])
+            remove_node(point)
+            remove_node(point.next)
+            point = start = fourth
+          end
+          point = point.next
+          break if point.equal?(start)
+        end
+        filter_points(point)
+      end
+
+      def split_earcut(start)
+        first = start
+        loop do
+          second = first.next.next
+          until second.equal?(first.previous)
+            if first.index != second.index && valid_diagonal?(first, second)
+              other_half = split_polygon(first, second)
+              first = filter_points(first, first.next)
+              other_half = filter_points(other_half, other_half.next)
+              earcut_linked(first)
+              earcut_linked(other_half)
+              return
+            end
+            second = second.next
+          end
+          first = first.next
+          break if first.equal?(start)
+        end
+      end
+
+      def eliminate_holes(outer)
+        holes = @hole_indices.each_with_index.map do |start_index, index|
+          end_index = @hole_indices[index + 1] || @data.length / 2
+          list = linked_list(start_index, end_index, false)
+          list.steiner = true if list.equal?(list.next)
+          leftmost(list)
+        end
+
+        holes.sort_by!(&:x)
+        holes.each { |hole| outer = eliminate_hole(hole, outer) }
+        outer
+      end
+
+      def eliminate_hole(hole, outer)
+        bridge = hole_bridge(hole, outer)
+        return outer unless bridge
+
+        reverse_bridge = split_polygon(bridge, hole)
+        filter_points(reverse_bridge, reverse_bridge.next)
+        filter_points(bridge, bridge.next)
+      end
+
+      def hole_bridge(hole, outer)
+        point = outer
+        intersection_x = -Float::INFINITY
+        bridge = nil
+        loop do
+          if hole.y <= point.y && hole.y >= point.next.y && point.next.y != point.y
+            x = point.x + ((hole.y - point.y) * (point.next.x - point.x)).fdiv(point.next.y - point.y)
+            if x <= hole.x && x > intersection_x
+              intersection_x = x
+              bridge = point.x < point.next.x ? point : point.next
+              return bridge if x == hole.x
+            end
+          end
+          point = point.next
+          break if point.equal?(outer)
+        end
+        return nil unless bridge
+
+        bridge_x = bridge.x
+        bridge_y = bridge.y
+        best_tangent = Float::INFINITY
+        start = bridge
+        point = bridge
+        loop do
+          if hole.x >= point.x && point.x >= bridge_x && hole.x != point.x &&
+              point_in_triangle?(hole.y < bridge_y ? hole.x : intersection_x, hole.y,
+                                 bridge_x, bridge_y,
+                                 hole.y < bridge_y ? intersection_x : hole.x, hole.y,
+                                 point.x, point.y)
+            tangent = (hole.y - point.y).abs.fdiv(hole.x - point.x)
+            better_tangent = tangent < best_tangent ||
+              (tangent == best_tangent && (point.x > bridge.x ||
+               (point.x == bridge.x && sector_contains_sector?(bridge, point))))
+            if locally_inside?(point, hole) && better_tangent
+              bridge = point
+              best_tangent = tangent
+            end
+          end
+          point = point.next
+          break if point.equal?(start)
+        end
+        bridge
+      end
+
+      def leftmost(start)
+        point = start
+        result = start
+        loop do
+          result = point if point.x < result.x || (point.x == result.x && point.y < result.y)
+          point = point.next
+          break if point.equal?(start)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/clipper2/earcut/geometry.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Clipper2
+  module Earcut
+    module Geometry
+      private
+
+      def triangle_area(first, second, third)
+        ((second.y - first.y) * (third.x - second.x)) -
+          ((second.x - first.x) * (third.y - second.y))
+      end
+
+      def same_point?(first, second)
+        first.x == second.x && first.y == second.y
+      end
+
+      def point_in_triangle?(ax, ay, bx, by, cx, cy, px, py)
+        ((cx - px) * (ay - py) >= (ax - px) * (cy - py)) &&
+          ((ax - px) * (by - py) >= (bx - px) * (ay - py)) &&
+          ((bx - px) * (cy - py) >= (cx - px) * (by - py))
+      end
+
+      def valid_diagonal?(first, second)
+        return false if first.next.index == second.index || first.previous.index == second.index
+        return false if intersects_polygon?(first, second)
+
+        visible = locally_inside?(first, second) && locally_inside?(second, first) && middle_inside?(first, second)
+        sectors_face_same_way = !triangle_area(first.previous, first, second.previous).zero? ||
+          !triangle_area(first, second.previous, second).zero?
+        return true if visible && sectors_face_same_way
+
+        same_point?(first, second) && triangle_area(first.previous, first, first.next).positive? &&
+          triangle_area(second.previous, second, second.next).positive?
+      end
+
+      def intersects?(first_start, first_end, second_start, second_end)
+        first_orientation = sign(triangle_area(first_start, first_end, second_start))
+        second_orientation = sign(triangle_area(first_start, first_end, second_end))
+        third_orientation = sign(triangle_area(second_start, second_end, first_start))
+        fourth_orientation = sign(triangle_area(second_start, second_end, first_end))
+        return true if first_orientation != second_orientation && third_orientation != fourth_orientation
+        return true if first_orientation.zero? && on_segment?(first_start, second_start, first_end)
+        return true if second_orientation.zero? && on_segment?(first_start, second_end, first_end)
+        return true if third_orientation.zero? && on_segment?(second_start, first_start, second_end)
+
+        fourth_orientation.zero? && on_segment?(second_start, first_end, second_end)
+      end
+
+      def on_segment?(start_point, point, end_point)
+        point.x.between?(*[start_point.x, end_point.x].minmax) &&
+          point.y.between?(*[start_point.y, end_point.y].minmax)
+      end
+
+      def sign(number)
+        number <=> 0
+      end
+
+      def intersects_polygon?(first, second)
+        point = first
+        loop do
+          unrelated_edge = point.index != first.index && point.next.index != first.index &&
+            point.index != second.index && point.next.index != second.index
+          return true if unrelated_edge && intersects?(point, point.next, first, second)
+
+          point = point.next
+          break if point.equal?(first)
+        end
+        false
+      end
+
+      def locally_inside?(first, second)
+        if triangle_area(first.previous, first, first.next).negative?
+          triangle_area(first, second, first.next) >= 0 && triangle_area(first, first.previous, second) >= 0
+        else
+          triangle_area(first, second, first.previous).negative? || triangle_area(first, first.next, second).negative?
+        end
+      end
+
+      def middle_inside?(first, second)
+        point = first
+        inside = false
+        middle_x = (first.x + second.x).fdiv(2)
+        middle_y = (first.y + second.y).fdiv(2)
+        loop do
+          crosses = (point.y > middle_y) != (point.next.y > middle_y) && point.next.y != point.y
+          edge_x = ((point.next.x - point.x) * (middle_y - point.y)).fdiv(point.next.y - point.y) + point.x if crosses
+          inside = !inside if crosses && middle_x < edge_x
+          point = point.next
+          break if point.equal?(first)
+        end
+        inside
+      end
+
+      def sector_contains_sector?(outer, inner)
+        triangle_area(outer.previous, outer, inner.previous).negative? &&
+          triangle_area(inner.next, outer, outer.next).negative?
+      end
+    end
+  end
+end

data/lib/clipper2/earcut/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Clipper2
+  module Earcut
+    class Node
+      attr_accessor :index, :x, :y, :previous, :next, :steiner
+
+      def initialize(index, x, y)
+        @index = index
+        @x = x
+        @y = y
+        @previous = nil
+        @next = nil
+        @steiner = false
+      end
+    end
+  end
+end

data/lib/clipper2/earcut/ring.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Clipper2
+  module Earcut
+    module Ring
+      private
+
+      def linked_list(start_index, end_index, clockwise)
+        last = nil
+        indices = (start_index...end_index).to_a
+        indices.reverse! unless clockwise == (signed_area(start_index, end_index).positive?)
+        indices.each do |index|
+          coordinate_index = index * 2
+          last = insert_node(index, @data[coordinate_index], @data[coordinate_index + 1], last)
+        end
+
+        if last && same_point?(last, last.next)
+          following = last.next
+          remove_node(last)
+          last = following
+        end
+        last
+      end
+
+      def filter_points(start, finish = start)
+        return start unless start
+
+        point = start
+        loop do
+          again = false
+          if !point.steiner && (same_point?(point, point.next) || triangle_area(point.previous, point, point.next).zero?)
+            remove_node(point)
+            point = finish = point.previous
+            break if point.equal?(point.next)
+
+            again = true
+          else
+            point = point.next
+          end
+          break unless again || !point.equal?(finish)
+        end
+        finish
+      end
+
+      def split_polygon(first, second)
+        first_copy = Node.new(first.index, first.x, first.y)
+        second_copy = Node.new(second.index, second.x, second.y)
+        first_next = first.next
+        second_previous = second.previous
+
+        first.next = second
+        second.previous = first
+        first_copy.next = first_next
+        first_next.previous = first_copy
+        second_copy.next = first_copy
+        first_copy.previous = second_copy
+        second_previous.next = second_copy
+        second_copy.previous = second_previous
+        second_copy
+      end
+
+      def insert_node(index, x, y, last)
+        point = Node.new(index, x, y)
+        if last
+          point.next = last.next
+          point.previous = last
+          last.next.previous = point
+          last.next = point
+        else
+          point.previous = point
+          point.next = point
+        end
+        point
+      end
+
+      def remove_node(point)
+        point.next.previous = point.previous
+        point.previous.next = point.next
+      end
+
+      def signed_area(start_index, end_index)
+        sum = 0
+        previous_index = end_index - 1
+        (start_index...end_index).each do |index|
+          previous = previous_index * 2
+          current = index * 2
+          sum += (@data[previous] - @data[current]) * (@data[current + 1] + @data[previous + 1])
+          previous_index = index
+        end
+        sum
+      end
+    end
+  end
+end

data/lib/clipper2/earcut.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# This is a dependency-free Ruby port of Mapbox Earcut 2.2.4's core algorithm.
+# See licenses/EARCUT-ISC.txt for the upstream copyright and license.
+require_relative "earcut/node"
+require_relative "earcut/geometry"
+require_relative "earcut/ring"
+require_relative "earcut/engine"
+
+module Clipper2
+  module Earcut
+    module_function
+
+    def call(vertices, hole_indices = [])
+      Engine.new(vertices, hole_indices).call
+    end
+  end
+end

data/lib/clipper2/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Clipper2
+  class Error < StandardError; end
+
+  class RangeError < Error; end
+  class ScaleError < Error; end
+  class CodecError < Error; end
+  class TriangulationError < Error; end
+
+  class NativeError < Error
+    attr_reader :code
+
+    def initialize(message, code: nil)
+      @code = code
+      super(code ? "#{message} (code: #{code})" : message)
+    end
+  end
+end

data/lib/clipper2/generated.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Generated by ext/clipper2/generate_bindings.rb. Do not edit by hand.
+module Clipper2
+  module Generated
+    UPSTREAM_VERSION = "2.0.1"
+
+    CLIP_TYPES = {
+      :no_clip => 0,
+      :intersection => 1,
+      :union => 2,
+      :difference => 3,
+      :xor => 4
+    }.freeze
+
+    FILL_RULES = {
+      :even_odd => 0,
+      :non_zero => 1,
+      :positive => 2,
+      :negative => 3
+    }.freeze
+
+    JOIN_TYPES = {
+      :square => 0,
+      :bevel => 1,
+      :round => 2,
+      :miter => 3
+    }.freeze
+
+    END_TYPES = {
+      :polygon => 0,
+      :joined => 1,
+      :butt => 2,
+      :square => 3,
+      :round => 4
+    }.freeze
+
+    NATIVE_EXPORTS = [
+      :BooleanOp64,
+      :BooleanOpD,
+      :BooleanOp_PolyTree64,
+      :BooleanOp_PolyTreeD,
+      :DisposeArray64,
+      :DisposeArrayD,
+      :InflatePath64,
+      :InflatePathD,
+      :InflatePaths64,
+      :InflatePathsD,
+      :MinkowskiDiff64,
+      :MinkowskiSum64,
+      :RectClip64,
+      :RectClipD,
+      :RectClipLines64,
+      :RectClipLinesD,
+      :SetZCallback64,
+      :SetZCallbackD,
+      :Triangulate64,
+      :TriangulateD,
+      :Version
+    ].freeze
+  end
+end

data/lib/clipper2/native.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Clipper2
+  module Native
+    extend FFI::Library
+
+    class << self
+      def extension_path
+        candidates = [__dir__, *$LOAD_PATH.map { |path| File.join(path, "clipper2") }].flat_map do |directory|
+          %w[bundle dylib so dll].map { |extension| File.join(directory, "clipper2_native.#{extension}") }
+        end
+        path = candidates.find { |candidate| File.file?(candidate) }
+        return path if path
+
+        raise LoadError, "clipper2 native library is unavailable; reinstall the gem or run `rake native:build`"
+      end
+    end
+
+    ffi_lib extension_path
+
+    attach_function :version, :Version, [], :string
+    attach_function :BooleanOp64,
+                    %i[uint8 uint8 pointer pointer pointer pointer pointer bool bool],
+                    :int,
+                    blocking: true
+    attach_function :InflatePaths64,
+                    %i[pointer double uint8 uint8 double double bool],
+                    :pointer,
+                    blocking: true
+    attach_function :RectClip64, %i[pointer pointer], :pointer, blocking: true
+    attach_function :RectClipLines64, %i[pointer pointer], :pointer, blocking: true
+    attach_function :MinkowskiSum64, %i[pointer pointer bool], :pointer, blocking: true
+    attach_function :MinkowskiDiff64, %i[pointer pointer bool], :pointer, blocking: true
+    attach_function :DisposeArray64, [:pointer], :void
+  end
+end