turf-ruby 0.8.1 → 1.1.0

data/lib/turf/lib/lineclip.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Turf
+  # :nodoc:
+  module Lineclip
+    # Cohen-Sutherland line clipping algorithm, adapted to efficiently
+    # handle polylines rather than just segments.
+    def self.lineclip(points, bbox, result = [])
+      len = points.length
+      code_a = bit_code(points[0], bbox)
+      part = []
+      a = nil
+      b = nil
+
+      (1...len).each do |i|
+        a = points[i - 1]
+        b = points[i]
+        code_b = last_code = bit_code(b, bbox)
+
+        loop do
+          if (code_a | code_b).zero?
+            # accept
+            part << a
+
+            if code_b != last_code
+              # segment went outside
+              part << b
+
+              if i < len - 1
+                # start a new line
+                result << part
+                part = []
+              end
+            elsif i == len - 1
+              part << b
+            end
+            break
+          elsif code_a.anybits?(code_b)
+            # trivial reject
+            break
+          elsif code_a != 0
+            # a outside, intersect with clip edge
+            a = intersect(a, b, code_a, bbox)
+            code_a = bit_code(a, bbox)
+          else
+            # b outside
+            b = intersect(a, b, code_b, bbox)
+            code_b = bit_code(b, bbox)
+          end
+        end
+
+        code_a = last_code
+      end
+
+      result << part unless part.empty?
+
+      result
+    end
+
+    # Sutherland-Hodgeman polygon clipping algorithm
+    def self.polygonclip(points, bbox)
+      result = []
+      prev = nil
+      prev_inside = nil
+
+      # clip against each side of the clip rectangle
+      [8, 4, 2, 1].each do |edge|
+        result = []
+        prev = points.last
+        prev_inside = bit_code(prev, bbox).nobits?(edge)
+
+        points.each do |p|
+          inside = bit_code(p, bbox).nobits?(edge)
+
+          # if segment goes through the clip window, add an intersection
+          result << intersect(prev, p, edge, bbox) if inside != prev_inside
+
+          result << p if inside # add a point if it's inside
+
+          prev = p
+          prev_inside = inside
+        end
+
+        points = result
+        break if points.empty?
+      end
+
+      result
+    end
+
+    # intersect a segment against one of the 4 lines that make up the bbox
+    def self.intersect(a, b, edge, bbox) # rubocop:disable Naming/MethodParameterName
+      if edge.anybits?(8)
+        [a[0] + (((b[0] - a[0]) * (bbox[3] - a[1]).to_f) / (b[1] - a[1])), bbox[3]]
+      elsif edge.anybits?(4)
+        [a[0] + (((b[0] - a[0]) * (bbox[1] - a[1]).to_f) / (b[1] - a[1])), bbox[1]]
+      elsif edge.anybits?(2)
+        [bbox[2], a[1] + (((b[1] - a[1]) * (bbox[2] - a[0]).to_f) / (b[0] - a[0]))]
+      elsif edge.anybits?(1)
+        [bbox[0], a[1] + (((b[1] - a[1]) * (bbox[0] - a[0]).to_f) / (b[0] - a[0]))]
+      end
+    end
+
+    # bit code reflects the point position relative to the bbox:
+    #         left  mid  right
+    #    top  1001  1000  1010
+    #    mid  0001  0000  0010
+    # bottom  0101  0100  0110
+    def self.bit_code(p, bbox) # rubocop:disable Naming/MethodParameterName
+      code = 0
+      code |= 1 if p[0] < bbox[0] # left
+      code |= 2 if p[0] > bbox[2] # right
+      code |= 4 if p[1] < bbox[1] # bottom
+      code |= 8 if p[1] > bbox[3] # top
+      code
+    end
+  end
+end

data/lib/turf/line_arc.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_arc(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_chunk.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_chunk(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_intersect.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_intersect(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_offset.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_offset(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_overlap.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_overlap(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_segment.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_segment(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_slice.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_slice(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_slice_along.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_slice_along(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_split.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_split(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/line_to_polygon.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def line_to_polygon(*args)
+    raise NotImplementedError
+  end
+end

data/lib/turf/mask.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Turf
+  def mask(*args)
+    raise NotImplementedError
+  end
+end