perfect-shape 0.3.0 → 0.3.4

data/lib/perfect_shape/arc.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
@@ -30,6 +30,7 @@ module PerfectShape
     include Equalizer.new(:type, :x, :y, :width, :height, :start, :extent)
     
     TYPES = [:open, :chord, :pie]
+    DEFAULT_OUTLINE_RADIUS = BigDecimal('0.001')
     attr_accessor :type
     attr_reader :start, :extent
     
@@ -143,44 +144,58 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the arc, {@code false} if the point lies outside of the
     # arc'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
-      # Normalize the coordinates compared to the ellipse
-      # having a center at 0,0 and a radius of 0.5.
-      ellw = width
-      return false if (ellw <= 0.0)
-      normx = (x - self.x) / ellw - 0.5
-      ellh = height
-      return false if (ellh <= 0.0)
-      normy = (y - self.y) / ellh - 0.5
-      dist_sq = (normx * normx) + (normy * normy)
-      return false if (dist_sq >= 0.25)
-      ang_ext = self.extent.abs
-      return true if (ang_ext >= 360.0)
-      inarc = contain_angle?(-1*Math.radians_to_degrees(Math.atan2(normy, normx)))
-      
-      return inarc if type == :pie
-      # CHORD and OPEN behave the same way
-      if inarc
-        return true if ang_ext >= 180.0
-        # point must be outside the "pie triangle"
+      if outline
+        if type == :pie && x == center_x && y == center_y
+          true
+        else
+          distance_tolerance = BigDecimal(distance_tolerance.to_s)
+          outside_inside_radius_difference = DEFAULT_OUTLINE_RADIUS + distance_tolerance * 2
+          outside_radius_difference = inside_radius_difference = outside_inside_radius_difference / 2
+          outside_shape = Arc.new(type: type, center_x: center_x, center_y: center_y, radius_x: radius_x + outside_radius_difference, radius_y: radius_y + outside_radius_difference, start: start, extent: extent)
+          inside_shape = Arc.new(type: type, center_x: center_x, center_y: center_y, radius_x: radius_x - inside_radius_difference, radius_y: radius_y - inside_radius_difference, start: start, extent: extent)
+          outside_shape.contain?(x, y, outline: false) and
+            !inside_shape.contain?(x, y, outline: false)
+        end
       else
-        return false if ang_ext <= 180.0
-        # point must be inside the "pie triangle"
+        # Normalize the coordinates compared to the ellipse
+        # having a center at 0,0 and a radius of 0.5.
+        ellw = width
+        return false if (ellw <= 0.0)
+        normx = (x - self.x) / ellw - 0.5
+        ellh = height
+        return false if (ellh <= 0.0)
+        normy = (y - self.y) / ellh - 0.5
+        dist_sq = (normx * normx) + (normy * normy)
+        return false if (dist_sq >= 0.25)
+        ang_ext = self.extent.abs
+        return true if (ang_ext >= 360.0)
+        inarc = contain_angle?(-1*Math.radians_to_degrees(Math.atan2(normy, normx)))
+        
+        return inarc if type == :pie
+        # CHORD and OPEN behave the same way
+        if inarc
+          return true if ang_ext >= 180.0
+          # point must be outside the "pie triangle"
+        else
+          return false if ang_ext <= 180.0
+          # point must be inside the "pie triangle"
+        end
+        
+        # The point is inside the pie triangle iff it is on the same
+        # side of the line connecting the ends of the arc as the center.
+        angle = Math.degrees_to_radians(-start)
+        x1 = Math.cos(angle)
+        y1 = Math.sin(angle)
+        angle += Math.degrees_to_radians(-extent)
+        x2 = Math.cos(angle)
+        y2 = Math.sin(angle)
+        inside = (Line.relative_counterclockwise(x1, y1, x2, y2, 2*normx, 2*normy) *
+                          Line.relative_counterclockwise(x1, y1, x2, y2, 0, 0) >= 0)
+        inarc ? !inside : inside
       end
-      
-      # The point is inside the pie triangle iff it is on the same
-      # side of the line connecting the ends of the arc as the center.
-      angle = Math.degrees_to_radians(-start)
-      x1 = Math.cos(angle)
-      y1 = Math.sin(angle)
-      angle += Math.degrees_to_radians(-extent)
-      x2 = Math.cos(angle)
-      y2 = Math.sin(angle)
-      inside = (Line.relative_counterclockwise(x1, y1, x2, y2, 2*normx, 2*normy) *
-                        Line.relative_counterclockwise(x1, y1, x2, y2, 0, 0) >= 0)
-      inarc ? !inside : inside
     end
     
     # Determines whether or not the specified angle is within the

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
@@ -51,18 +51,18 @@ module PerfectShape
         end
         # double precision only has 52 bits of mantissa
         return PerfectShape::Line.point_crossings(x1, y1, x2, y2, px, py) if (level > 52)
-        xmid = BigDecimal((xc1 + xc2).to_s) / 2;
-        ymid = BigDecimal((yc1 + yc2).to_s) / 2;
-        xc1 = BigDecimal((x1 + xc1).to_s) / 2;
-        yc1 = BigDecimal((y1 + yc1).to_s) / 2;
-        xc2 = BigDecimal((xc2 + x2).to_s) / 2;
-        yc2 = BigDecimal((yc2 + y2).to_s) / 2;
-        xc1m = BigDecimal((xc1 + xmid).to_s) / 2;
-        yc1m = BigDecimal((yc1 + ymid).to_s) / 2;
-        xmc1 = BigDecimal((xmid + xc2).to_s) / 2;
-        ymc1 = BigDecimal((ymid + yc2).to_s) / 2;
-        xmid = BigDecimal((xc1m + xmc1).to_s) / 2;
-        ymid = BigDecimal((yc1m + ymc1).to_s) / 2;
+        xmid = BigDecimal((xc1 + xc2).to_s) / 2
+        ymid = BigDecimal((yc1 + yc2).to_s) / 2
+        xc1 = BigDecimal((x1 + xc1).to_s) / 2
+        yc1 = BigDecimal((y1 + yc1).to_s) / 2
+        xc2 = BigDecimal((xc2 + x2).to_s) / 2
+        yc2 = BigDecimal((yc2 + y2).to_s) / 2
+        xc1m = BigDecimal((xc1 + xmid).to_s) / 2
+        yc1m = BigDecimal((yc1 + ymid).to_s) / 2
+        xmc1 = BigDecimal((xmid + xc2).to_s) / 2
+        ymc1 = BigDecimal((ymid + yc2).to_s) / 2
+        xmid = BigDecimal((xc1m + xmc1).to_s) / 2
+        ymid = BigDecimal((yc1m + ymc1).to_s) / 2
         # [xy]mid are NaN if any of [xy]c0m or [xy]mc1 are NaN
         # [xy]c0m or [xy]mc1 are NaN if any of [xy][c][01] are NaN
         # These values are also NaN if opposing infinities are added
@@ -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,30 @@ 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
+        distance_tolerance = BigDecimal(distance_tolerance.to_s)
+        minimum_distance_threshold = OUTLINE_MINIMUM_DISTANCE_THRESHOLD + distance_tolerance
+        point_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 +124,92 @@ 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 = BigDecimal((ctrlx1 + ctrlx2).to_s) / 2
+      centery = BigDecimal((ctrly1 + ctrly2).to_s) / 2
+      ctrlx1 = BigDecimal((x1 + ctrlx1).to_s) / 2
+      ctrly1 = BigDecimal((y1 + ctrly1).to_s) / 2
+      ctrlx2 = BigDecimal((x2 + ctrlx2).to_s) / 2
+      ctrly2 = BigDecimal((y2 + ctrly2).to_s) / 2
+      ctrlx12 = BigDecimal((ctrlx1 + centerx).to_s) / 2
+      ctrly12 = BigDecimal((ctrly1 + centery).to_s) / 2
+      ctrlx21 = BigDecimal((ctrlx2 + centerx).to_s) / 2
+      ctrly21 = BigDecimal((ctrly2 + centery).to_s) / 2
+      centerx = BigDecimal((ctrlx12 + ctrlx21).to_s) / 2
+      centery = BigDecimal((ctrly12 + ctrly21).to_s) / 2
+      
+      first_curve = CubicBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerx, centery])
+      second_curve = CubicBezierCurve.new(points: [centerx, centery, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2])
+      default_subdivisions = [first_curve, second_curve]
+      
+      if level == 0
+        default_subdivisions
+      else
+        default_subdivisions.map { |curve| curve.subdivisions(level) }.flatten
+      end
+    end
+    
+    def point_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
+        curve1_center_point = curve1.curve_center_point
+        distance1 = point.point_distance(curve1_center_point)
+        curve2_center_point = curve2.curve_center_point
+        distance2 = point.point_distance(curve2_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
@@ -104,7 +104,7 @@ module PerfectShape
       #           measured against the specified line segment
       # @return a double value that is the square of the distance from the
       #                  specified point to the specified line segment.
-      def point_segment_distance_square(x1, y1,
+      def point_distance_square(x1, y1,
                                        x2, y2,
                                        px, py)
         x1 = BigDecimal(x1.to_s)
@@ -177,10 +177,10 @@ module PerfectShape
       #           measured against the specified line segment
       # @return a double value that is the distance from the specified point
       #                          to the specified line segment.
-      def point_segment_distance(x1, y1,
+      def point_distance(x1, y1,
                                  x2, y2,
                                  px, py)
-        BigDecimal(::Math.sqrt(point_segment_distance_square(x1, y1, x2, y2, px, py)).to_s)
+        BigDecimal(::Math.sqrt(point_distance_square(x1, y1, x2, y2, px, py)).to_s)
       end
       
       # Calculates the number of times the line from (x1,y1) to (x2,y2)
@@ -212,17 +212,17 @@ module PerfectShape
     # @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, outline: false, distance_tolerance: 0)
+    def contain?(x_or_point, y = nil, outline: true, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
       distance_tolerance = BigDecimal(distance_tolerance.to_s)
-      point_segment_distance(x, y) <= distance_tolerance
+      point_distance(x, y) <= distance_tolerance
     end
     
-    def point_segment_distance(x_or_point, y = nil)
+    def point_distance(x_or_point, y = nil)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      Line.point_segment_distance(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
+      Line.point_distance(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
     end
     
     def relative_counterclockwise(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
@@ -37,7 +37,13 @@ module PerfectShape
         ys = the_points.each_with_index.select {|n, i| i.odd?}.map(&:first)
         the_points = xs.zip(ys)
       end
-      @points = the_points.map {|pair| [BigDecimal(pair.first.to_s), BigDecimal(pair.last.to_s)]}
+      @points = the_points.map do |pair|
+        [
+          pair.first.is_a?(BigDecimal) ? pair.first : BigDecimal(pair.first.to_s),
+          pair.last.is_a?(BigDecimal) ? pair.last : BigDecimal(pair.last.to_s)
+        ]
+      end
+      @points
     end
     
     def min_x

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
@@ -114,21 +114,26 @@ module PerfectShape
     # @return true if the point lies within the bound of
     # the path or false if the point lies outside of the
     # path'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
-      if (x * 0.0 + y * 0.0) == 0.0
-        # N * 0.0 is 0.0 only if N is finite.
-        # Here we know that both x and y are finite.
-        return false if shapes.count < 2
-        mask = winding_rule == :wind_non_zero ? -1 : 1
-        (point_crossings(x, y) & mask) != 0
+      
+      if outline
+        disconnected_shapes.any? {|shape| shape.contain?(x, y, outline: true, distance_tolerance: distance_tolerance) }
       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.
-        false
+        if (x * 0.0 + y * 0.0) == 0.0
+          # N * 0.0 is 0.0 only if N is finite.
+          # Here we know that both x and y are finite.
+          return false if shapes.count < 2
+          mask = winding_rule == :wind_non_zero ? -1 : 1
+          (point_crossings(x, y) & mask) != 0
+        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.
+          false
+        end
       end
     end
     
@@ -218,5 +223,50 @@ module PerfectShape
       end
       crossings
     end
+    
+    # Disconnected shapes have their start point filled in
+    # so that each shape does not depend on the previous shape
+    # to determine its start point.
+    #
+    # Also, if a point is followed by a non-point shape, it is removed
+    # since it is augmented to the following shape as its start point.
+    #
+    # Lastly, if the path is closed, an extra shape is
+    # added to represent the line connecting the last point to the first
+    def disconnected_shapes
+      initial_point = start_point = @shapes.first.to_a.map {|n| BigDecimal(n.to_s)}
+      final_point = nil
+      the_disconnected_shapes = @shapes.drop(1).map do |shape|
+        case shape
+        when Point
+          disconnected_shape = Point.new(*shape.to_a)
+          start_point = shape.to_a
+          final_point = disconnected_shape.to_a
+          nil
+        when Array
+          disconnected_shape = Point.new(*shape.map {|n| BigDecimal(n.to_s)})
+          start_point = shape.map {|n| BigDecimal(n.to_s)}
+          final_point = disconnected_shape.to_a
+          nil
+        when Line
+          disconnected_shape = Line.new(points: [start_point.to_a, shape.points.last])
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        when QuadraticBezierCurve
+          disconnected_shape = QuadraticBezierCurve.new(points: [start_point.to_a] + shape.points)
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        when CubicBezierCurve
+          disconnected_shape = CubicBezierCurve.new(points: [start_point.to_a] + shape.points)
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        end
+      end
+      the_disconnected_shapes << Line.new(points: [final_point, initial_point]) if closed?
+      the_disconnected_shapes.compact
+    end
   end
 end

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
@@ -27,10 +27,10 @@ module PerfectShape
   class Point < Shape
     class << self
       def point_distance(x, y, px, py)
-        x = BigDecimal(x.to_s)
-        y = BigDecimal(y.to_s)
-        px = BigDecimal(px.to_s)
-        py = BigDecimal(py.to_s)
+        x = x.is_a?(BigDecimal) ? x : BigDecimal(x.to_s)
+        y = y.is_a?(BigDecimal) ? y : BigDecimal(y.to_s)
+        px = px.is_a?(BigDecimal) ? px : BigDecimal(px.to_s)
+        py = py.is_a?(BigDecimal) ? py : BigDecimal(py.to_s)
         BigDecimal(Math.sqrt((px - x)**2 + (py - y)**2).to_s)
       end
     end
@@ -67,7 +67,7 @@ module PerfectShape
     #
     # @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, outline: false, distance_tolerance: 0)
+    def contain?(x_or_point, y = nil, outline: true, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
       distance_tolerance = BigDecimal(distance_tolerance.to_s)
@@ -77,6 +77,7 @@ module PerfectShape
     def point_distance(x_or_point, y = nil)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
+      
       Point.point_distance(self.x, self.y, x, y)
     end
     

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
@@ -41,9 +41,7 @@ module PerfectShape
       x, y = normalize_point(x_or_point, y)
       return unless x && y
       if outline
-        points.zip(points.rotate(1)).any? do |point1, point2|
-          Line.new(points: [[point1.first, point1.last], [point2.first, point2.last]]).contain?(x, y, distance_tolerance: distance_tolerance)
-        end
+        edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }
       else
         npoints = points.count
         xpoints = points.map(&:first)
@@ -117,5 +115,11 @@ module PerfectShape
         (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
+    end
   end
 end