perfect-shape 0.3.2 → 0.4.0

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
@@ -27,7 +27,6 @@ require 'perfect_shape/cubic_bezier_curve'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Path2D.html
   class Path < Shape
     include MultiPoint
     include Equalizer.new(:shapes, :closed, :winding_rule)
@@ -114,21 +113,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)
-      x, y = normalize_point(x_or_point, y)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
+      x, y = Point.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
     
@@ -144,7 +148,7 @@ module PerfectShape
     # The caller must check for NaN values.
     # The caller may also reject infinite values as well.
     def point_crossings(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       return 0 if shapes.count == 0
       movx = movy = curx = cury = endx = endy = 0
@@ -218,5 +222,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,12 +27,27 @@ 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
+      
+      # Normalizes point args whether two-number Array or x, y args returning
+      # normalized point array of two BigDecimal's
+      #
+      # @param x_or_point The point or X coordinate of the point to test.
+      # @param y The Y coordinate of the point to test.
+      #
+      # @return Array of x and y BigDecimal's representing point
+      def normalize_point(x_or_point, y = nil)
+        x = x_or_point
+        x, y = x if y.nil? && x_or_point.is_a?(Array) && x_or_point.size == 2
+        x = x.is_a?(BigDecimal) ? x : BigDecimal(x.to_s)
+        y = y.is_a?(BigDecimal) ? y : BigDecimal(y.to_s)
+        [x, y]
+      end
     end
     
     include PointLocation
@@ -67,16 +82,17 @@ 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)
-      x, y = normalize_point(x_or_point, y)
+    def contain?(x_or_point, y = nil, outline: true, distance_tolerance: 0)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       distance_tolerance = BigDecimal(distance_tolerance.to_s)
       point_distance(x, y) <= distance_tolerance
     end
     
     def point_distance(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.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
@@ -20,10 +20,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'perfect_shape/shape'
+require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/Polygon.html
   class Polygon < Shape
     include MultiPoint
     include Equalizer.new(:points)
@@ -38,12 +38,10 @@ module PerfectShape
     # the polygon, {@code false} if the point lies outside of the
     # polygon's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.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

data/lib/perfect_shape/quadratic_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
@@ -20,10 +20,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'perfect_shape/shape'
+require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/QuadCurve2D.html
   class QuadraticBezierCurve < Shape
     class << self
       # Calculates the number of times the quadratic bézier curve from (x1,y1) to (x2,y2)
@@ -69,6 +69,8 @@ module PerfectShape
     include MultiPoint
     include Equalizer.new(:points)
     
+    OUTLINE_MINIMUM_DISTANCE_THRESHOLD = BigDecimal('0.001')
+    
     # Checks if quadratic bézier curve contains point (two-number Array or x, y args)
     #
     # @param x The X coordinate of the point to test.
@@ -77,8 +79,8 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the quadratic bézier curve, {@code false} if the point lies outside of the
     # quadratic bézier curve's bounds.
-    def contain?(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
 
       x1 = points[0][0]
@@ -87,90 +89,96 @@ module PerfectShape
       yc = points[1][1]
       x2 = points[2][0]
       y2 = points[2][1]
-
-      # We have a convex shape bounded by quad curve Pc(t)
-      # and ine Pl(t).
-      #
-      #     P1 = (x1, y1) - start point of curve
-      #     P2 = (x2, y2) - end point of curve
-      #     Pc = (xc, yc) - control point
-      #
-      #     Pq(t) = P1*(1 - t)^2 + 2*Pc*t*(1 - t) + P2*t^2 =
-      #           = (P1 - 2*Pc + P2)*t^2 + 2*(Pc - P1)*t + P1
-      #     Pl(t) = P1*(1 - t) + P2*t
-      #     t = [0:1]
-      #
-      #     P = (x, y) - point of interest
-      #
-      # Let's look at second derivative of quad curve equation:
-      #
-      #     Pq''(t) = 2 * (P1 - 2 * Pc + P2) = Pq''
-      #     It's constant vector.
-      #
-      # Let's draw a line through P to be parallel to this
-      # vector and find the intersection of the quad curve
-      # and the line.
-      #
-      # Pq(t) is point of intersection if system of equations
-      # below has the solution.
-      #
-      #     L(s) = P + Pq''*s == Pq(t)
-      #     Pq''*s + (P - Pq(t)) == 0
-      #
-      #     | xq''*s + (x - xq(t)) == 0
-      #     | yq''*s + (y - yq(t)) == 0
-      #
-      # This system has the solution if rank of its matrix equals to 1.
-      # That is, determinant of the matrix should be zero.
-      #
-      #     (y - yq(t))*xq'' == (x - xq(t))*yq''
-      #
-      # Let's solve this equation with 't' variable.
-      # Also let kx = x1 - 2*xc + x2
-      #          ky = y1 - 2*yc + y2
-      #
-      #     t0q = (1/2)*((x - x1)*ky - (y - y1)*kx) /
-      #                 ((xc - x1)*ky - (yc - y1)*kx)
-      #
-      # Let's do the same for our line Pl(t):
-      #
-      #     t0l = ((x - x1)*ky - (y - y1)*kx) /
-      #           ((x2 - x1)*ky - (y2 - y1)*kx)
-      #
-      # It's easy to check that t0q == t0l. This fact means
-      # we can compute t0 only one time.
-      #
-      # In case t0 < 0 or t0 > 1, we have an intersections outside
-      # of shape bounds. So, P is definitely out of shape.
-      #
-      # In case t0 is inside [0:1], we should calculate Pq(t0)
-      # and Pl(t0). We have three points for now, and all of them
-      # lie on one line. So, we just need to detect, is our point
-      # of interest between points of intersections or not.
-      #
-      # If the denominator in the t0q and t0l equations is
-      # zero, then the points must be collinear and so the
-      # curve is degenerate and encloses no area.  Thus the
-      # result is false.
-      kx = x1 - 2 * xc + x2;
-      ky = y1 - 2 * yc + y2;
-      dx = x - x1;
-      dy = y - y1;
-      dxl = x2 - x1;
-      dyl = y2 - y1;
-
-      t0 = (dx * ky - dy * kx) / (dxl * ky - dyl * kx)
-      return false if (t0 < 0 || t0 > 1 || t0 != t0)
-
-      xb = kx * t0 * t0 + 2 * (xc - x1) * t0 + x1;
-      yb = ky * t0 * t0 + 2 * (yc - y1) * t0 + y1;
-      xl = dxl * t0 + x1;
-      yl = dyl * t0 + y1;
-
-      (x >= xb && x < xl) ||
-        (x >= xl && x < xb) ||
-        (y >= yb && y < yl) ||
-        (y >= yl && y < yb)
+      
+      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
+        # We have a convex shape bounded by quad curve Pc(t)
+        # and ine Pl(t).
+        #
+        #     P1 = (x1, y1) - start point of curve
+        #     P2 = (x2, y2) - end point of curve
+        #     Pc = (xc, yc) - control point
+        #
+        #     Pq(t) = P1*(1 - t)^2 + 2*Pc*t*(1 - t) + P2*t^2 =
+        #           = (P1 - 2*Pc + P2)*t^2 + 2*(Pc - P1)*t + P1
+        #     Pl(t) = P1*(1 - t) + P2*t
+        #     t = [0:1]
+        #
+        #     P = (x, y) - point of interest
+        #
+        # Let's look at second derivative of quad curve equation:
+        #
+        #     Pq''(t) = 2 * (P1 - 2 * Pc + P2) = Pq''
+        #     It's constant vector.
+        #
+        # Let's draw a line through P to be parallel to this
+        # vector and find the intersection of the quad curve
+        # and the line.
+        #
+        # Pq(t) is point of intersection if system of equations
+        # below has the solution.
+        #
+        #     L(s) = P + Pq''*s == Pq(t)
+        #     Pq''*s + (P - Pq(t)) == 0
+        #
+        #     | xq''*s + (x - xq(t)) == 0
+        #     | yq''*s + (y - yq(t)) == 0
+        #
+        # This system has the solution if rank of its matrix equals to 1.
+        # That is, determinant of the matrix should be zero.
+        #
+        #     (y - yq(t))*xq'' == (x - xq(t))*yq''
+        #
+        # Let's solve this equation with 't' variable.
+        # Also let kx = x1 - 2*xc + x2
+        #          ky = y1 - 2*yc + y2
+        #
+        #     t0q = (1/2)*((x - x1)*ky - (y - y1)*kx) /
+        #                 ((xc - x1)*ky - (yc - y1)*kx)
+        #
+        # Let's do the same for our line Pl(t):
+        #
+        #     t0l = ((x - x1)*ky - (y - y1)*kx) /
+        #           ((x2 - x1)*ky - (y2 - y1)*kx)
+        #
+        # It's easy to check that t0q == t0l. This fact means
+        # we can compute t0 only one time.
+        #
+        # In case t0 < 0 or t0 > 1, we have an intersections outside
+        # of shape bounds. So, P is definitely out of shape.
+        #
+        # In case t0 is inside [0:1], we should calculate Pq(t0)
+        # and Pl(t0). We have three points for now, and all of them
+        # lie on one line. So, we just need to detect, is our point
+        # of interest between points of intersections or not.
+        #
+        # If the denominator in the t0q and t0l equations is
+        # zero, then the points must be collinear and so the
+        # curve is degenerate and encloses no area.  Thus the
+        # result is false.
+        kx = x1 - 2 * xc + x2;
+        ky = y1 - 2 * yc + y2;
+        dx = x - x1;
+        dy = y - y1;
+        dxl = x2 - x1;
+        dyl = y2 - y1;
+  
+        t0 = (dx * ky - dy * kx) / (dxl * ky - dyl * kx)
+        return false if (t0 < 0 || t0 > 1 || t0 != t0)
+  
+        xb = kx * t0 * t0 + 2 * (xc - x1) * t0 + x1;
+        yb = ky * t0 * t0 + 2 * (yc - y1) * t0 + y1;
+        xl = dxl * t0 + x1;
+        yl = dyl * t0 + y1;
+  
+        (x >= xb && x < xl) ||
+          (x >= xl && x < xb) ||
+          (y >= yb && y < yl) ||
+          (y >= yl && y < yb)
+      end
     end
     
     # Calculates the number of times the quad
@@ -182,9 +190,88 @@ module PerfectShape
     # +1 is added for each crossing where the Y coordinate is increasing
     # -1 is added for each crossing where the Y coordinate is decreasing
     def point_crossings(x_or_point, y = nil, level = 0)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       QuadraticBezierCurve.point_crossings(points[0][0], points[0][1], points[1][0], points[1][1], points[2][0], points[2][1], x, y, level)
     end
+    
+    # The center point on the outline of the curve
+    # in Array format as pair of (x, y) coordinates
+    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 QuadraticBezierCurve exactly at its curve center
+    # returning 2 QuadraticBezierCurve'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]
+      ctrlx = points[1][0]
+      ctrly = points[1][1]
+      x2 = points[2][0]
+      y2 = points[2][1]
+      ctrlx1 = BigDecimal((x1 + ctrlx).to_s) / 2
+      ctrly1 = BigDecimal((y1 + ctrly).to_s) / 2
+      ctrlx2 = BigDecimal((x2 + ctrlx).to_s) / 2
+      ctrly2 = BigDecimal((y2 + ctrly).to_s) / 2
+      centerx = BigDecimal((ctrlx1 + ctrlx2).to_s) / 2
+      centery = BigDecimal((ctrly1 + ctrly2).to_s) / 2
+      
+      default_subdivisions = [
+        QuadraticBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, centerx, centery]),
+        QuadraticBezierCurve.new(points: [centerx, centery, ctrlx2, ctrly2, x2, y2])
+      ]
+      
+      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 = Point.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/rectangle.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
@@ -21,10 +21,10 @@
 
 require 'perfect_shape/shape'
 require 'perfect_shape/rectangular_shape'
+require 'perfect_shape/point'
 require 'perfect_shape/line'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Rectangle2D.html
   class Rectangle < Shape
     include RectangularShape
     include Equalizer.new(:x, :y, :width, :height)
@@ -38,16 +38,23 @@ module PerfectShape
     # the rectangle, {@code false} if the point lies outside of the
     # rectangle's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
+      
       if outline
-        Line.new(points: [[self.x, self.y], [self.x + width, self.y]]).contain?(x, y, distance_tolerance: distance_tolerance) or
-          Line.new(points: [[self.x + width, self.y], [self.x + width, self.y + height]]).contain?(x, y, distance_tolerance: distance_tolerance) or
-          Line.new(points: [[self.x + width, self.y + height], [self.x, self.y + height]]).contain?(x, y, distance_tolerance: distance_tolerance) or
-          Line.new(points: [[self.x, self.y + height], [self.x, self.y]]).contain?(x, y, distance_tolerance: distance_tolerance)
+        edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }
       else
         x.between?(self.x, self.x + width) && y.between?(self.y, self.y + height)
       end
     end
+    
+    def edges
+      [
+        Line.new(points: [[self.x, self.y], [self.x + width, self.y]]),
+        Line.new(points: [[self.x + width, self.y], [self.x + width, self.y + height]]),
+        Line.new(points: [[self.x + width, self.y + height], [self.x, self.y + height]]),
+        Line.new(points: [[self.x, self.y + height], [self.x, self.y]])
+      ]
+    end
   end
 end

data/lib/perfect_shape/rectangular_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/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
@@ -51,6 +51,12 @@ module PerfectShape
       max_y - min_y if max_y && min_y
     end
     
+    # Center point is `[center_x, center_y]`
+    # Returns `nil` if either center_x or center_y are `nil`
+    def center_point
+      [center_x, center_y] unless center_x.nil? || center_y.nil?
+    end
+    
     # center_x is min_x + width/2.0 by default
     # Returns nil if min_x or width are nil
     def center_x
@@ -69,21 +75,6 @@ module PerfectShape
       Rectangle.new(x: min_x, y: min_y, width: width, height: height)
     end
   
-    # Normalizes point args whether two-number Array or x, y args returning
-    # normalized point array of two BigDecimal's
-    #
-    # @param x_or_point The point or X coordinate of the point to test.
-    # @param y The Y coordinate of the point to test.
-    #
-    # @return Array of x and y BigDecimal's representing point
-    def normalize_point(x_or_point, y = nil)
-      x = x_or_point
-      x, y = x if y.nil? && x_or_point.is_a?(Array) && x_or_point.size == 2
-      x = BigDecimal(x.to_s)
-      y = BigDecimal(y.to_s)
-      [x, y]
-    end
-    
     # Subclasses must implement
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
     end

data/lib/perfect_shape/square.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