perfect-shape 0.3.0 → 0.3.4

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,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
@@ -186,5 +194,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
+    # 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 = 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
@@ -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
@@ -79,11 +85,15 @@ module PerfectShape
     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 = x.is_a?(BigDecimal) ? x : BigDecimal(x.to_s)
+      y = y.is_a?(BigDecimal) ? y : BigDecimal(y.to_s)
       [x, y]
     end
     
+    # Subclasses must implement
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
+    end
+    
     # Subclasses must implement
     def ==(other)
     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

data/perfect-shape.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: perfect-shape 0.3.0 ruby lib
+# stub: perfect-shape 0.3.4 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.3.0"
+  s.version = "0.3.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Andy Maleh".freeze]
-  s.date = "2022-01-08"
+  s.date = "2022-01-11"
   s.description = "Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking containment of a mouse click point in popular geometry shapes such as rectangle, square, arc (open, chord, and pie), ellipse, circle, polygon, and paths containing lines, quadratic b\u00E9zier curves, and cubic bezier curves (including both Ray Casting Algorithm, aka Even-odd Rule, and Winding Number Algorithm, aka Nonzero Rule). Additionally, it contains some purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).".freeze
   s.email = "andy.am@gmail.com".freeze
   s.extra_rdoc_files = [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.4
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-08 00:00:00.000000000 Z
+date: 2022-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer