perfect-shape 0.2.0 → 0.3.3

data/lib/perfect_shape/circle.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/perfect_shape/composite_shape.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/perfect_shape/cubic_bezier_curve.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -75,6 +75,8 @@ module PerfectShape
     include MultiPoint
     include Equalizer.new(:points)
     
+    OUTLINE_MINIMUM_DISTANCE_THRESHOLD = BigDecimal('0.001')
+    
     # Checks if cubic bézier curve contains point (two-number Array or x, y args)
     #
     # @param x The X coordinate of the point to test.
@@ -83,24 +85,29 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the cubic bézier curve, {@code false} if the point lies outside of the
     # cubic bézier curve's bounds.
-    def contain?(x_or_point, y = nil)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
       
-      # Either x or y was infinite or NaN.
-      # A NaN always produces a negative response to any test
-      # and Infinity values cannot be "inside" any path so
-      # they should return false as well.
-      return false if (!(x * 0.0 + y * 0.0 == 0.0))
-      # We count the "Y" crossings to determine if the point is
-      # inside the curve bounded by its closing line.
-      x1 = points[0][0]
-      y1 = points[0][1]
-      x2 = points[3][0]
-      y2 = points[3][1]
-      line = PerfectShape::Line.new(points: [[x1, y1], [x2, y2]])
-      crossings = line.point_crossings(x, y) + point_crossings(x, y);
-      (crossings & 1) == 1
+      if outline
+        minimum_distance_threshold = OUTLINE_MINIMUM_DISTANCE_THRESHOLD + distance_tolerance
+        point_segment_distance(x, y, minimum_distance_threshold: minimum_distance_threshold) < minimum_distance_threshold
+      else
+        # Either x or y was infinite or NaN.
+        # A NaN always produces a negative response to any test
+        # and Infinity values cannot be "inside" any path so
+        # they should return false as well.
+        return false if (!(x * 0.0 + y * 0.0 == 0.0))
+        # We count the "Y" crossings to determine if the point is
+        # inside the curve bounded by its closing line.
+        x1 = points[0][0]
+        y1 = points[0][1]
+        x2 = points[3][0]
+        y2 = points[3][1]
+        line = PerfectShape::Line.new(points: [[x1, y1], [x2, y2]])
+        crossings = line.point_crossings(x, y) + point_crossings(x, y);
+        (crossings & 1) == 1
+      end
     end
     
     # Calculates the number of times the cubic bézier curve
@@ -116,5 +123,88 @@ module PerfectShape
       return unless x && y
       CubicBezierCurve.point_crossings(points[0][0], points[0][1], points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1], x, y, level)
     end
+    
+    # The center point on the outline of the curve
+    def curve_center_point
+      subdivisions.last.points[0]
+    end
+    
+    # The center point x on the outline of the curve
+    def curve_center_x
+      subdivisions.last.points[0][0]
+    end
+    
+    # The center point y on the outline of the curve
+    def curve_center_y
+      subdivisions.last.points[0][1]
+    end
+    
+    # Subdivides CubicBezierCurve exactly at its curve center
+    # returning 2 CubicBezierCurve's as a two-element Array by default
+    #
+    # Optional `level` parameter specifies the level of recursions to
+    # perform to get more subdivisions. The number of resulting
+    # subdivisions is 2 to the power of `level` (e.g. 2 subdivisions
+    # for level=1, 4 subdivisions for level=2, and 8 subdivisions for level=3)
+    def subdivisions(level = 1)
+      level -= 1 # consume 1 level
+      x1 = points[0][0]
+      y1 = points[0][1]
+      ctrlx1 = points[1][0]
+      ctrly1 = points[1][1]
+      ctrlx2 = points[2][0]
+      ctrly2 = points[2][1]
+      x2 = points[3][0]
+      y2 = points[3][1]
+      centerx = (ctrlx1 + ctrlx2) / 2.0
+      centery = (ctrly1 + ctrly2) / 2.0
+      ctrlx1 = (x1 + ctrlx1) / 2.0
+      ctrly1 = (y1 + ctrly1) / 2.0
+      ctrlx2 = (x2 + ctrlx2) / 2.0
+      ctrly2 = (y2 + ctrly2) / 2.0
+      ctrlx12 = (ctrlx1 + centerx) / 2.0
+      ctrly12 = (ctrly1 + centery) / 2.0
+      ctrlx21 = (ctrlx2 + centerx) / 2.0
+      ctrly21 = (ctrly2 + centery) / 2.0
+      centerx = (ctrlx12 + ctrlx21) / 2.0
+      centery = (ctrly12 + ctrly21) / 2.0
+      default_subdivisions = [
+        CubicBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerx, centery]),
+        CubicBezierCurve.new(points: [centerx, centery, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2])
+      ]
+      if level == 0
+        default_subdivisions
+      else
+        default_subdivisions.map { |curve| curve.subdivisions(level) }.flatten
+      end
+    end
+    
+    def point_segment_distance(x_or_point, y = nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)
+      x, y = normalize_point(x_or_point, y)
+      return unless x && y
+      
+      point = Point.new(x, y)
+      current_curve = self
+      minimum_distance = point.point_distance(curve_center_point)
+      last_minimum_distance = minimum_distance + 1 # start bigger to ensure going through loop once at least
+      while minimum_distance >= minimum_distance_threshold && minimum_distance < last_minimum_distance
+        curve1, curve2 = current_curve.subdivisions
+        distance1 = point.point_distance(curve1.curve_center_point)
+        distance2 = point.point_distance(curve2.curve_center_point)
+        last_minimum_distance = minimum_distance
+        if distance1 < distance2
+          minimum_distance = distance1
+          current_curve = curve1
+        else
+          minimum_distance = distance2
+          current_curve = curve2
+        end
+      end
+      if minimum_distance < minimum_distance_threshold
+        minimum_distance
+      else
+        last_minimum_distance
+      end
+    end
   end
 end

data/lib/perfect_shape/ellipse.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -63,17 +63,21 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the ellipse, {@code false} if the point lies outside of the
     # ellipse's bounds.
-    def contain?(x_or_point, y = nil)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       # This is implemented again even though super would have just worked to have an optimized algorithm for Ellipse.
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      ellw = self.width
-      return false if ellw <= 0.0
-      normx = (x - self.x) / ellw - 0.5
-      ellh = self.height
-      return false if ellh <= 0.0
-      normy = (y - self.y) / ellh - 0.5
-      (normx * normx + normy * normy) < 0.25
+      if outline
+        super(x, y, outline: true, distance_tolerance: distance_tolerance)
+      else
+        ellw = self.width
+        return false if ellw <= 0.0
+        normx = (x - self.x) / ellw - 0.5
+        ellh = self.height
+        return false if ellh <= 0.0
+        normy = (y - self.y) / ellh - 0.5
+        (normx * normx + normy * normy) < 0.25
+      end
     end
   end
 end

data/lib/perfect_shape/line.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -207,16 +207,16 @@ module PerfectShape
     #
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
-    # @param distance The distance from line to tolerate (0 by default)
+    # @param distance_tolerance The distance from line to tolerate (0 by default)
     #
     # @return {@code true} if the point lies within the bound of
     # the line, {@code false} if the point lies outside of the
     # line's bounds.
-    def contain?(x_or_point, y = nil, distance: 0)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      distance = BigDecimal(distance.to_s)
-      point_segment_distance(x, y) <= distance
+      distance_tolerance = BigDecimal(distance_tolerance.to_s)
+      point_segment_distance(x, y) <= distance_tolerance
     end
     
     def point_segment_distance(x_or_point, y = nil)

data/lib/perfect_shape/math.rb

@@ -1,3 +1,24 @@
+# Copyright (c) 2021-2022 Andy Maleh
+#
+# 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.
+
 module PerfectShape
   # Perfect Shape Math utility methods
   #

data/lib/perfect_shape/multi_point.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/perfect_shape/path.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/perfect_shape/point.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -63,15 +63,15 @@ module PerfectShape
     #
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
-    # @param distance The distance from point to tolerate (0 by default)
+    # @param distance_tolerance The distance from point to tolerate (0 by default)
     #
     # @return {@code true} if the point is close enough within distance tolerance,
     # {@code false} if the point is too far.
-    def contain?(x_or_point, y = nil, distance: 0)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      distance = BigDecimal(distance.to_s)
-      point_distance(x, y) <= distance
+      distance_tolerance = BigDecimal(distance_tolerance.to_s)
+      point_distance(x, y) <= distance_tolerance
     end
     
     def point_distance(x_or_point, y = nil)

data/lib/perfect_shape/point_location.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/perfect_shape/polygon.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2021 Andy Maleh
+# Copyright (c) 2021-2022 Andy Maleh
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -37,79 +37,89 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the polygon, {@code false} if the point lies outside of the
     # polygon's bounds.
-    def contain?(x_or_point, y = nil)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      npoints = points.count
-      xpoints = points.map(&:first)
-      ypoints = points.map(&:last)
-      return false if npoints <= 2 || !bounding_box.contain?(x, y)
-      hits = 0
-
-      lastx = xpoints[npoints - 1]
-      lasty = ypoints[npoints - 1]
-
-      # Walk the edges of the polygon
-      npoints.times do |i|
-        curx = xpoints[i]
-        cury = ypoints[i]
-
-        if cury == lasty
-          lastx = curx
-          lasty = cury
-          next
-        end
-
-        if curx < lastx
-          if x >= lastx
-            lastx = curx
-            lasty = cury
-            next
-          end
-          leftx = curx
-        else
-          if x >= curx
-            lastx = curx
-            lasty = cury
-            next
-          end
-          leftx = lastx
-        end
-
-        if cury < lasty
-          if y < cury || y >= lasty
+      if outline
+        edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }
+      else
+        npoints = points.count
+        xpoints = points.map(&:first)
+        ypoints = points.map(&:last)
+        return false if npoints <= 2 || !bounding_box.contain?(x, y)
+        hits = 0
+  
+        lastx = xpoints[npoints - 1]
+        lasty = ypoints[npoints - 1]
+  
+        # Walk the edges of the polygon
+        npoints.times do |i|
+          curx = xpoints[i]
+          cury = ypoints[i]
+  
+          if cury == lasty
             lastx = curx
             lasty = cury
             next
           end
-          if x < leftx
-            hits += 1
-            lastx = curx
-            lasty = cury
-            next
+  
+          if curx < lastx
+            if x >= lastx
+              lastx = curx
+              lasty = cury
+              next
+            end
+            leftx = curx
+          else
+            if x >= curx
+              lastx = curx
+              lasty = cury
+              next
+            end
+            leftx = lastx
           end
-          test1 = x - curx
-          test2 = y - cury
-        else
-          if y < lasty || y >= cury
-            lastx = curx
-            lasty = cury
-            next
+  
+          if cury < lasty
+            if y < cury || y >= lasty
+              lastx = curx
+              lasty = cury
+              next
+            end
+            if x < leftx
+              hits += 1
+              lastx = curx
+              lasty = cury
+              next
+            end
+            test1 = x - curx
+            test2 = y - cury
+          else
+            if y < lasty || y >= cury
+              lastx = curx
+              lasty = cury
+              next
+            end
+            if x < leftx
+              hits += 1
+              lastx = curx
+              lasty = cury
+              next
+            end
+            test1 = x - lastx
+            test2 = y - lasty
           end
-          if x < leftx
-            hits += 1
-            lastx = curx
-            lasty = cury
-            next
-          end
-          test1 = x - lastx
-          test2 = y - lasty
+  
+          hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
         end
-
-        hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
+  
+        (hits & 1) != 0
+      end
+    end
+    
+    def edges
+      points.zip(points.rotate(1)).map do |point1, point2|
+        Line.new(points: [[point1.first, point1.last], [point2.first, point2.last]])
       end
-
-      (hits & 1) != 0
     end
   end
 end