perfect-shape 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f9bd6a8a2c7c3d3ec4ec3fd3e5b311a9eec08fa63e35666547534a2e19273c6
-  data.tar.gz: 4dbcd6b139e118c555d50681efe4e770cf796774a904459994a64c2bb19d5140
+  metadata.gz: 42bff3742b2697349882d865b7c5da9c06ce4a259850996bb92f291e8a74130e
+  data.tar.gz: 5a2f007129f1e0f483a48ea607a7ee3e44cbdf01b400a656f406b412dc8e9524
 SHA512:
-  metadata.gz: e30baa5bb362e5e540af6f67ba9c99ff0f5f0469f48a724823a76522111d6ea86e1bce6cb6b273b056cc9bf7e8f92bd667103aa348abbc237e4ffec082154434
-  data.tar.gz: 7627cabd6ee3ef671ed802d6846ad1c192065cc4a5bf6d00062a7d8da7d3376c3d84b836664413a5033644dfa839d19a8634badf851e4aa050e6f03cdef031bc
+  metadata.gz: 9bf87bebe682dfbab8a4b082caa321ac0b7051510d86e946e3f214337e818a18da7cee51bc12432510567deaa68f65a69cb3c7da10b7c9153045803e1d25f0b7
+  data.tar.gz: fa32aa79d500055b81b572e17ded38429503a3757430bba1c0fea021853e4377d7e025071cf52ed8c2f965c8bc8ecd35601276f2a1bcda847202c6f49c8422a0

data/CHANGELOG.md

@@ -1,10 +1,21 @@
 # Change Log
 
+## 0.3.3
+
+- Check point containment in quadratic bezier curve outline with distance tolerance (new method signature: `PerfectShape::QuadraticBezierCurve#contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)`)
+- `PerfectShape::QuadraticBezierCurve#curve_center_point`, `PerfectShape::QuadraticBezierCurve#curve_center_x`, `PerfectShape::QuadraticBezierCurve#curve_center_y`
+- `PerfectShape::QuadraticBezierCurve#subdivisions(level=1)`
+- `PerfectShape::QuadraticBezierCurve#point_segment_distance(x_or_point, y = nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)`
+- `PerfectShape::Polygon#edges` returns edges of polygon as `PerfectShape::Line` objects
+- `PerfectShape::Rectangle#edges` returns edges of rectangle as `PerfectShape::Line` objects
+- `PerfectShape::Square#edges` returns edges of square as `PerfectShape::Line` objects
+- Rename `number` arg to `level` in `CubicBezierCurve#subdivisions(level=1)`, making it signify the level of subdivision recursion to perform.
+
 ## 0.3.2
 
 - Check point containment in cubic bezier curve outline with distance tolerance (new method signature: `PerfectShape::CubicBezierCurve#contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)`)
 - `PerfectShape::CubicBezierCurve#curve_center_point`, `PerfectShape::CubicBezierCurve#curve_center_x`, `PerfectShape::CubicBezierCurve#curve_center_y`
-- `PerfectShape::CubicBezierCurve#subdivisions(number=2)`
+- `PerfectShape::CubicBezierCurve#subdivisions(level=1)`
 - `PerfectShape::CubicBezierCurve#point_segment_distance(x_or_point, y = nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)`
 
 ## 0.3.1

data/LICENSE.txt

@@ -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/README.md

@@ -1,4 +1,4 @@
-# Perfect Shape 0.3.2
+# Perfect Shape 0.3.3
 ## Geometric Algorithms
 [![Gem Version](https://badge.fury.io/rb/perfect-shape.svg)](http://badge.fury.io/rb/perfect-shape)
 [![Test](https://github.com/AndyObtiva/perfect-shape/actions/workflows/ruby.yml/badge.svg)](https://github.com/AndyObtiva/perfect-shape/actions/workflows/ruby.yml)
@@ -14,13 +14,13 @@ To ensure high accuracy, this library does all its mathematical operations with
 Run:
 
 ```
-gem install perfect-shape -v 0.3.2
+gem install perfect-shape -v 0.3.3
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.3.2'
+gem 'perfect-shape', '~> 0.3.3'
 ```
 
 And, run:
@@ -38,7 +38,7 @@ Module
 - `::degrees_to_radians(angle)`: converts degrees to radians
 - `::radians_to_degrees(angle)`: converts radians to degrees
 - `::normalize_degrees(angle)`: normalizes the specified angle into the range -180 to 180.
-- `::ieee_remainder(x, y)` (alias: `ieee754_remainder`): [IEEE 754-1985 Remainder](https://en.wikipedia.org/wiki/IEEE_754-1985) (different from standard % modulo operator as it operates on floats and could return a negative result)
+- `::ieee_remainder(x, y)` (alias: `ieee754_remainder`): [IEEE 754-1985 Remainder](https://en.wikipedia.org/wiki/IEEE_754-1985) (different from standard `%` modulo operator as it operates on floats and could return a negative result)
 
 ### `PerfectShape::Shape`
 
@@ -195,7 +195,12 @@ Includes `PerfectShape::MultiPoint`
 - `#center_y`: center y
 - `#bounding_box`: bounding box is a rectangle with x = min x, y = min y, and width/height of shape (bounding box only guarantees that the shape is within it, but it might be bigger than the shape)
 - `#==(other)`: Returns `true` if equal to `other` or `false` otherwise
-- `#contain?(x_or_point, y=nil)`: checks if point is inside
+- `#contain?(x_or_point, y=nil, outline: false, distance_tolerance: 0)`: checks if point is inside when `outline` is `false` or if point is on the outline when `outline` is `true`. `distance_tolerance` can be used as a fuzz factor when `outline` is `true`, for example, to help GUI users mouse-click-select a quadratic bezier curve shape from its outline more successfully
+- `#curve_center_point`: point at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
+- `#curve_center_x`: point x coordinate at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
+- `#curve_center_y`: point y coordinate at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
+- `#subdivisions(level=1)`: subdivides quadratic bezier curve at its center into into 2 quadratic bezier curves by default, or more if `level` of recursion is specified. The resulting number of subdivisions is `2` to the power of `level`.
+- `#point_segment_distance(x_or_point, y=nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)`: calculates distance from point to curve segment. It does so by subdividing curve into smaller curves and checking against the curve center points until the distance is less than `minimum_distance_threshold`, to avoid being an overly costly operation.
 
 Example:
 
@@ -206,6 +211,14 @@ shape = PerfectShape::QuadraticBezierCurve.new(points: [[200, 150], [270, 320],
 
 shape.contain?(270, 220) # => true
 shape.contain?([270, 220]) # => true
+shape.contain?(270, 220, outline: true) # => false
+shape.contain?([270, 220], outline: true) # => false
+shape.contain?(280, 235, outline: true) # => true
+shape.contain?([280, 235], outline: true) # => true
+shape.contain?(281, 235, outline: true) # => false
+shape.contain?([281, 235], outline: true) # => false
+shape.contain?(281, 235, outline: true, distance_tolerance: 1) # => true
+shape.contain?([281, 235], outline: true, distance_tolerance: 1) # => true
 ```
 
 ### `PerfectShape::CubicBezierCurve`
@@ -234,7 +247,7 @@ Includes `PerfectShape::MultiPoint`
 - `#curve_center_point`: point at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
 - `#curve_center_x`: point x coordinate at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
 - `#curve_center_y`: point y coordinate at the center of the curve (not the center of the bounding box area like `center_x` and `center_y`)
-- `#subdivisions(number=2)`: subdivides cubic bezier curve at its center into into 2 cubic bezier curves by default, or more if `number` is specified. `number` must be an even number, or it will be rounded up to the closest even number.
+- `#subdivisions(level=1)`: subdivides cubic bezier curve at its center into into 2 cubic bezier curves by default, or more if `level` of recursion is specified. The resulting number of subdivisions is `2` to the power of `level`.
 - `#point_segment_distance(x_or_point, y=nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)`: calculates distance from point to curve segment. It does so by subdividing curve into smaller curves and checking against the curve center points until the distance is less than `minimum_distance_threshold`, to avoid being an overly costly operation.
 
 Example:
@@ -280,6 +293,7 @@ Includes `PerfectShape::RectangularShape`
 - `#bounding_box`: bounding box is a rectangle with x = min x, y = min y, and width/height of shape
 - `#==(other)`: Returns `true` if equal to `other` or `false` otherwise
 - `#contain?(x_or_point, y=nil, outline: false, distance_tolerance: 0)`: checks if point is inside when `outline` is `false` or if point is on the outline when `outline` is `true`. `distance_tolerance` can be used as a fuzz factor when `outline` is `true`, for example, to help GUI users mouse-click-select a rectangle shape from its outline more successfully
+- `#edges`: edges of rectangle as `PerfectShape::Line` objects
 
 Example:
 
@@ -323,6 +337,7 @@ Extends `PerfectShape::Rectangle`
 - `#bounding_box`: bounding box is a rectangle with x = min x, y = min y, and width/height of shape
 - `#==(other)`: Returns `true` if equal to `other` or `false` otherwise
 - `#contain?(x_or_point, y=nil, outline: false, distance_tolerance: 0)`: checks if point is inside when `outline` is `false` or if point is on the outline when `outline` is `true`. `distance_tolerance` can be used as a fuzz factor when `outline` is `true`, for example, to help GUI users mouse-click-select a square shape from its outline more successfully
+- `#edges`: edges of square as `PerfectShape::Line` objects
 
 Example:
 
@@ -613,6 +628,7 @@ A polygon can be thought of as a special case of [path](#perfectshapepath) that
 - `#bounding_box`: bounding box is a rectangle with x = min x, y = min y, and width/height of shape
 - `#==(other)`: Returns `true` if equal to `other` or `false` otherwise
 - `#contain?(x_or_point, y=nil, outline: false, distance_tolerance: 0)`: When `outline` is `false`, it checks if point is inside using the [Ray Casting Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon) (aka [Even-Odd Rule](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule)). Otherwise, when `outline` is `true`, it checks if point is on the outline. `distance_tolerance` can be used as a fuzz factor when `outline` is `true`, for example, to help GUI users mouse-click-select a polygon shape from its outline more successfully
+- `#edges`: edges of polygon as `PerfectShape::Line` objects
 
 Example:
 
@@ -756,5 +772,5 @@ shape.contain?([170, 190]) # => true
 
 [MIT](LICENSE.txt)
 
-Copyright (c) 2021 Andy Maleh. See
+Copyright (c) 2021-2022 Andy Maleh. See
 [LICENSE.txt](LICENSE.txt) for further details.

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.3.3

data/lib/perfect-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/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

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
@@ -141,11 +141,13 @@ module PerfectShape
     
     # Subdivides CubicBezierCurve exactly at its curve center
     # returning 2 CubicBezierCurve's as a two-element Array by default
-    # `number` parameter may be specified as an even number in case more
-    # subdivisions are needed. If an odd number is given, it is rounded
-    # up to the closest even number above it (e.g. 3 becomes 4).
-    def subdivisions(number = 2)
-      number = (number.to_i / 2.0).ceil*2
+    #
+    # 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]
@@ -170,10 +172,10 @@ module PerfectShape
         CubicBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerx, centery]),
         CubicBezierCurve.new(points: [centerx, centery, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2])
       ]
-      if number > 2
-        default_subdivisions.map { |curve| curve.subdivisions(number - 2) }.flatten
-      else
+      if level == 0
         default_subdivisions
+      else
+        default_subdivisions.map { |curve| curve.subdivisions(level) }.flatten
       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

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

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

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

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
@@ -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,7 +79,7 @@ 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)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
 
@@ -87,90 +89,95 @@ 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
+        minimum_distance_threshold = OUTLINE_MINIMUM_DISTANCE_THRESHOLD + distance_tolerance
+        point_segment_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
@@ -186,5 +193,84 @@ module PerfectShape
       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
+    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 = (x1 + ctrlx) / 2.0
+      ctrly1 = (y1 + ctrly) / 2.0
+      ctrlx2 = (x2 + ctrlx) / 2.0
+      ctrly2 = (y2 + ctrly) / 2.0
+      centerx = (ctrlx1 + ctrlx2) / 2.0
+      centery = (ctrly1 + ctrly2) / 2.0
+      
+      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_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/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
@@ -41,13 +41,19 @@ module PerfectShape
       x, y = 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

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

data/perfect-shape.gemspec

@@ -2,11 +2,11 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: perfect-shape 0.3.2 ruby lib
+# stub: perfect-shape 0.3.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.3.2"
+  s.version = "0.3.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Andy Maleh