perfect-shape 0.1.1 → 0.3.1

data/lib/perfect_shape/polygon.rb

@@ -37,79 +37,85 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the polygon, {@code false} if the point lies outside of the
     # polygon's bounds.
-    def contain?(x_or_point, y = nil)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
-      npoints = points.count
-      xpoints = points.map(&:first)
-      ypoints = points.map(&:last)
-      return false if npoints <= 2 || !bounding_box.contain?(x, y)
-      hits = 0
-
-      lastx = xpoints[npoints - 1]
-      lasty = ypoints[npoints - 1]
-
-      # Walk the edges of the polygon
-      npoints.times do |i|
-        curx = xpoints[i]
-        cury = ypoints[i]
-
-        if cury == lasty
-          lastx = curx
-          lasty = cury
-          next
-        end
-
-        if curx < lastx
-          if x >= lastx
-            lastx = curx
-            lasty = cury
-            next
-          end
-          leftx = curx
-        else
-          if x >= curx
-            lastx = curx
-            lasty = cury
-            next
-          end
-          leftx = lastx
+      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
-
-        if cury < lasty
-          if y < cury || y >= lasty
+      else
+        npoints = points.count
+        xpoints = points.map(&:first)
+        ypoints = points.map(&:last)
+        return false if npoints <= 2 || !bounding_box.contain?(x, y)
+        hits = 0
+  
+        lastx = xpoints[npoints - 1]
+        lasty = ypoints[npoints - 1]
+  
+        # Walk the edges of the polygon
+        npoints.times do |i|
+          curx = xpoints[i]
+          cury = ypoints[i]
+  
+          if cury == lasty
             lastx = curx
             lasty = cury
             next
           end
-          if x < leftx
-            hits += 1
-            lastx = curx
-            lasty = cury
-            next
+  
+          if curx < lastx
+            if x >= lastx
+              lastx = curx
+              lasty = cury
+              next
+            end
+            leftx = curx
+          else
+            if x >= curx
+              lastx = curx
+              lasty = cury
+              next
+            end
+            leftx = lastx
           end
-          test1 = x - curx
-          test2 = y - cury
-        else
-          if y < lasty || y >= cury
-            lastx = curx
-            lasty = cury
-            next
+  
+          if cury < lasty
+            if y < cury || y >= lasty
+              lastx = curx
+              lasty = cury
+              next
+            end
+            if x < leftx
+              hits += 1
+              lastx = curx
+              lasty = cury
+              next
+            end
+            test1 = x - curx
+            test2 = y - cury
+          else
+            if y < lasty || y >= cury
+              lastx = curx
+              lasty = cury
+              next
+            end
+            if x < leftx
+              hits += 1
+              lastx = curx
+              lasty = cury
+              next
+            end
+            test1 = x - lastx
+            test2 = y - lasty
           end
-          if x < leftx
-            hits += 1
-            lastx = curx
-            lasty = cury
-            next
-          end
-          test1 = x - lastx
-          test2 = y - lasty
+  
+          hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
         end
-
-        hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
+  
+        (hits & 1) != 0
       end
-
-      (hits & 1) != 0
     end
   end
 end

data/lib/perfect_shape/quadratic_bezier_curve.rb

@@ -26,33 +26,41 @@ 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)
+      # crosses the ray extending to the right from (x,y).
+      # If the point lies on a part of the curve,
+      # then no crossings are counted for that intersection.
+      # the level parameter should be 0 at the top-level call and will count
+      # up for each recursion level to prevent infinite recursion
+      # +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(x1, y1, xc, yc, x2, y2, px, py, level = 0)
-        return BigDecimal('0') if (py <  y1 && py <  yc && py <  y2)
-        return BigDecimal('0') if (py >= y1 && py >= yc && py >= y2)
+        return 0 if (py <  y1 && py <  yc && py <  y2)
+        return 0 if (py >= y1 && py >= yc && py >= y2)
         # Note y1 could equal y2...
-        return BigDecimal('0') if (px >= x1 && px >= xc && px >= x2)
+        return 0 if (px >= x1 && px >= xc && px >= x2)
         if (px <  x1 && px <  xc && px <  x2)
           if (py >= y1)
-            return BigDecimal('1') if (py < y2)
+            return 1 if (py < y2)
           else
             # py < y1
-            return BigDecimal('-1') if (py >= y2)
+            return -1 if (py >= y2)
           end
           # py outside of y11 range, and/or y1==y2
-          return BigDecimal('0')
+          return 0
         end
         # double precision only has 52 bits of mantissa
         return PerfectShape::Line.point_crossings(x1, y1, x2, y2, px, py) if (level > 52)
-        x1c = (x1 + xc) / BigDecimal('2')
-        y1c = (y1 + yc) / BigDecimal('2')
-        xc1 = (xc + x2) / BigDecimal('2')
-        yc1 = (yc + y2) / BigDecimal('2')
-        xc = (x1c + xc1) / BigDecimal('2')
-        yc = (y1c + yc1) / BigDecimal('2')
+        x1c = BigDecimal((x1 + xc).to_s) / 2
+        y1c = BigDecimal((y1 + yc).to_s) / 2
+        xc1 = BigDecimal((xc + x2).to_s) / 2
+        yc1 = BigDecimal((yc + y2).to_s) / 2
+        xc = BigDecimal((x1c + xc1).to_s) / 2
+        yc = BigDecimal((y1c + yc1).to_s) / 2
         # [xy]c are NaN if any of [xy]0c or [xy]c1 are NaN
         # [xy]0c or [xy]c1 are NaN if any of [xy][0c1] are NaN
         # These values are also NaN if opposing infinities are added
-        return BigDecimal('0') if (xc.nan? || yc.nan?)
+        return 0 if (xc.nan? || yc.nan?)
         point_crossings(x1, y1, x1c, y1c, xc, yc, px, py, level+1) +
           point_crossings(xc, yc, xc1, yc1, x2, y2, px, py, level+1);
       end
@@ -69,7 +77,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, distance: 0)
+    def contain?(x_or_point, y = nil)
       x, y = normalize_point(x_or_point, y)
       return unless x && y
 

data/lib/perfect_shape/rectangle.rb

@@ -21,6 +21,7 @@
 
 require 'perfect_shape/shape'
 require 'perfect_shape/rectangular_shape'
+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
@@ -36,10 +37,17 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the rectangle, {@code false} if the point lies outside of the
     # rectangle'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
-      x.between?(self.x, self.x + self.width) && y.between?(self.y, self.y + self.height)
+      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)
+      else
+        x.between?(self.x, self.x + width) && y.between?(self.y, self.y + height)
+      end
     end
   end
 end

data/perfect-shape.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: perfect-shape 0.1.1 ruby lib
+# stub: perfect-shape 0.3.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.1.1"
+  s.version = "0.3.1"
 
   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 = "2021-12-22"
-  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 b\u00E9zier 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.date = "2022-01-08"
+  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 = [
     "CHANGELOG.md",
@@ -27,6 +27,8 @@ Gem::Specification.new do |s|
     "lib/perfect-shape.rb",
     "lib/perfect_shape/arc.rb",
     "lib/perfect_shape/circle.rb",
+    "lib/perfect_shape/composite_shape.rb",
+    "lib/perfect_shape/cubic_bezier_curve.rb",
     "lib/perfect_shape/ellipse.rb",
     "lib/perfect_shape/line.rb",
     "lib/perfect_shape/math.rb",
@@ -44,7 +46,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/AndyObtiva/perfect-shape".freeze
   s.licenses = ["MIT".freeze]
-  s.rubygems_version = "3.2.31".freeze
+  s.rubygems_version = "3.3.1".freeze
   s.summary = "Perfect Shape - Geometric Algorithms".freeze
 
   if s.respond_to? :specification_version then

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-22 00:00:00.000000000 Z
+date: 2022-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer
@@ -98,7 +98,7 @@ description: Perfect Shape is a collection of pure Ruby geometric algorithms tha
   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ézier curves,
-  and cubic bézier curves (including both Ray Casting Algorithm, aka Even-odd Rule,
+  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).
 email: andy.am@gmail.com
@@ -116,6 +116,8 @@ files:
 - lib/perfect-shape.rb
 - lib/perfect_shape/arc.rb
 - lib/perfect_shape/circle.rb
+- lib/perfect_shape/composite_shape.rb
+- lib/perfect_shape/cubic_bezier_curve.rb
 - lib/perfect_shape/ellipse.rb
 - lib/perfect_shape/line.rb
 - lib/perfect_shape/math.rb
@@ -149,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.31
+rubygems_version: 3.3.1
 signing_key:
 specification_version: 4
 summary: Perfect Shape - Geometric Algorithms