perfect-shape 0.5.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f32696a2e0ecd7c1aceb16d9211b38e977b4dd15c7ba57acb8ac99a769d75036
-  data.tar.gz: 50c458cfcf134ce86bc11e0b22f1650b2faf2146c79c288d7b2501a2d7d9264c
+  metadata.gz: c200dfc203347661cd329e24cebc75ae038b0b69f6874832cfe8793ae2cbf6e5
+  data.tar.gz: 55cac9b991125bfcf15493eb5e05fecaea618d5d415e9c2b2c9d593efba98be4
 SHA512:
-  metadata.gz: 1e15378328df2eaad3769ce087118f7990fcb834963cbc56b738ea1cc292a92df0f86d77506e1a2f94985bc03211b5436b9965e8b6b5c97c80f9d7ad59f6cb20
-  data.tar.gz: cb64f0b3951ca4628f96e265070a88684060be6ffa38b5a45deea611bce0b2d20b72e43ef6c5d70b969925a31fe0017f4ec84407927f23a1b7824e0352bc9732
+  metadata.gz: 6cd01a66d882fa6af01e3e52e5c37bdc05c8217ae550e1b2e212bce588c7812059af7ff476ede2bd7c873f9e55738aace0386d46d6f06839ee9e50f52bd29d1c
+  data.tar.gz: f69e3ea514b1cf4f071e04fc943ddb814fef3e7d4594e2ffde34d3d570868feb9f642d4705e0639100b23b81202b67cc5c88eab8ef769df91c7acddf60da46e9

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 1.0.0
+
+- `PerfectShape::Path#intersect?(rectangle)`
+- `PerfectShape::Polygon#intersect?(rectangle)`
+- `PerfectShape::CompositeShape#intersect?(rectangle)`
+- [API Breaking] Change `Path` default `winding_rule` to `:wind_even_odd`
+- Make `PerfectShape::Polygon` support `:wind_non_zero` `winding_rule` (not just default `:wind_even_odd`)
+
 ## 0.5.5
 
 - `PerfectShape::Arc#intersect?(rectangle)`

data/README.md

@@ -1,4 +1,4 @@
-# Perfect Shape 0.5.5
+# Perfect Shape 1.0.0
 ## 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.5.5
+gem install perfect-shape -v 1.0.0
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.5.5'
+gem 'perfect-shape', '~> 1.0.0'
 ```
 
 And, run:
@@ -275,6 +275,7 @@ Includes `PerfectShape::MultiPoint`
 - `#curve_center_y`: point y coordinate at the center of the curve outline (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_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.
+- `#rect_crossings(rxmin, rymin, rxmax, rymax, level, crossings = 0)`: rectangle crossings (adds to crossings arg)
 
 Example:
 
@@ -704,11 +705,11 @@ Extends `PerfectShape::Shape`
 
 Includes `PerfectShape::MultiPoint`
 
-A polygon can be thought of as a special case of [path](#perfectshapepath) that is closed, has the [Even-Odd](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule) winding rule, and consists of lines only.
+A polygon can be thought of as a special case of [path](#perfectshapepath), consisting of lines only, is closed, and has the [Even-Odd](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule) winding rule by default.
 
 ![polygon](https://raw.githubusercontent.com/AndyObtiva/perfect-shape/master/images/polygon.png)
 
-- `::new(points: [])`: constructs a polygon with `points` as `Array` of `Array`s of `[x,y]` pairs or flattened `Array` of alternating x and y coordinates
+- `::new(points: [], winding_rule: :wind_even_odd)`: constructs a polygon with `points` as `Array` of `Array`s of `[x,y]` pairs or flattened `Array` of alternating x and y coordinates and specified winding rule (`:wind_even_odd` or `:wind_non_zero`)
 - `#min_x`: min x
 - `#min_y`: min y
 - `#max_x`: max x
@@ -720,7 +721,8 @@ A polygon can be thought of as a special case of [path](#perfectshapepath) that
 - `#center_y`: center y
 - `#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
+- `#contain?(x_or_point, y=nil, outline: false, distance_tolerance: 0)`: When `outline` is `false`, it checks if point is inside using either 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)) or [Winding Number Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Winding_number_algorithm) (aka [Nonzero-Rule](https://en.wikipedia.org/wiki/Nonzero-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
+- `#intersect?(rectangle)`: Returns `true` if intersecting with interior of rectangle or `false` otherwise. This is useful for GUI optimization checks of whether a shape appears in a GUI viewport rectangle and needs redrawing
 - `#edges`: edges of polygon as `PerfectShape::Line` objects
 
 Example:
@@ -769,6 +771,7 @@ Includes `PerfectShape::MultiPoint`
 - `#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, outline: false, distance_tolerance: 0)`: When `outline` is `false`, it checks if point is inside path utilizing the configured winding rule, which can be the [Nonzero-Rule](https://en.wikipedia.org/wiki/Nonzero-rule) (aka [Winding Number Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Winding_number_algorithm)) or the [Even-Odd Rule](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule) (aka [Ray Casting Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Ray_casting_algorithm)). 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 path shape from its outline more successfully
+- `#intersect?(rectangle)`: Returns `true` if intersecting with interior of rectangle or `false` otherwise. This is useful for GUI optimization checks of whether a shape appears in a GUI viewport rectangle and needs redrawing
 - `#point_crossings(x_or_point, y=nil)`: calculates the number of times the given path crosses the ray extending to the right from (x,y)
 - `#disconnected_shapes`: 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
 
@@ -821,6 +824,7 @@ A composite shape is simply an aggregate of multiple shapes (e.g. square and pol
 - `#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, outline: false, distance_tolerance: 0)`: When `outline` is `false`, it checks if point is inside any of the shapes owned by the composite shape. Otherwise, when `outline` is `true`, it checks if point is on the outline of any of the shapes owned by the composite shape. `distance_tolerance` can be used as a fuzz factor when `outline` is `true`, for example, to help GUI users mouse-click-select a composite shape from its outline more successfully
+- `#intersect?(rectangle)`: Returns `true` if intersecting with interior of rectangle or `false` otherwise. This is useful for GUI optimization checks of whether a shape appears in a GUI viewport rectangle and needs redrawing
 
 Example:
 

data/VERSION

@@ -1 +1 @@
-0.5.5
+1.0.0

data/lib/perfect_shape/composite_shape.rb

@@ -69,5 +69,9 @@ module PerfectShape
       
       shapes.any? { |shape| shape.contain?(x, y, outline: outline, distance_tolerance: distance_tolerance) }
     end
+    
+    def intersect?(rectangle)
+      shapes.any? { |shape| shape.intersect?(rectangle) }
+    end
   end
 end

data/lib/perfect_shape/cubic_bezier_curve.rb

@@ -223,7 +223,7 @@ module PerfectShape
 
       num_crossings = rectangle_crossings(rectangle)
       # the intended return value is
-      # num_crossings != 0 || num_crossings == Rectangle::RECT_INTERSECTS
+      # num_crossings != 0 || num_crossings == PerfectShape::Rectangle::RECT_INTERSECTS
       # but if (num_crossings != 0) num_crossings == INTERSECTS won't matter
       # and if !(num_crossings != 0) then num_crossings == 0, so
       # num_crossings != RECT_INTERSECT
@@ -244,7 +244,7 @@ module PerfectShape
       if !(x1 == x2 && y1 == y2)
         line = PerfectShape::Line.new(points: [[x1, y1], [x2, y2]])
         crossings = line.rect_crossings(x, y, x+w, y+h, crossings)
-        return crossings if crossings == Rectangle::RECT_INTERSECTS
+        return crossings if crossings == PerfectShape::Rectangle::RECT_INTERSECTS
       end
       # we call this with the curve's direction reversed, because we wanted
       # to call rectCrossingsForLine first, because it's cheaper.
@@ -294,7 +294,7 @@ module PerfectShape
       # The intersection of ranges is more complicated
       # First do trivial INTERSECTS rejection of the cases
       # where one of the endpoints is inside the rectangle.
-      return Rectangle::RECT_INTERSECTS if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) ||
+      return PerfectShape::Rectangle::RECT_INTERSECTS if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) ||
         (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax))
           
       # Otherwise, subdivide and look for one of the cases above.
@@ -318,7 +318,7 @@ module PerfectShape
       return 0 if xmid.nan? || ymid.nan?
       cubic1 = CubicBezierCurve.new(points: [[x0, y0], [xc0, yc0], [xc0m, yc0m], [xmid, ymid]])
       crossings = cubic1.rect_crossings(rxmin, rymin, rxmax, rymax, level + 1, crossings)
-      if crossings != Rectangle::RECT_INTERSECTS
+      if crossings != PerfectShape::Rectangle::RECT_INTERSECTS
         cubic2 = CubicBezierCurve.new(points: [[xmid, ymid], [xmc1, ymc1], [xc1, yc1], [x1, y1]])
         crossings = cubic2.rect_crossings(rxmin, rymin, rxmax, rymax, level + 1, crossings)
       end

data/lib/perfect_shape/line.rb

@@ -244,7 +244,7 @@ module PerfectShape
     
     # Accumulate the number of times the line crosses the shadow
     # extending to the right of the rectangle.  See the comment
-    # for the Rectangle::RECT_INTERSECTS constant for more complete details.
+    # for the PerfectShape::Rectangle::RECT_INTERSECTS constant for more complete details.
     #
     # crossings arg is the initial crossings value to add to (useful
     # in cases where you want to accumulate crossings from multiple
@@ -280,7 +280,7 @@ module PerfectShape
       # Both x and y ranges overlap by a non-empty amount
       # First do trivial INTERSECTS rejection of the cases
       # where one of the endpoints is inside the rectangle.
-      return Rectangle::RECT_INTERSECTS if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) ||
+      return PerfectShape::Rectangle::RECT_INTERSECTS if ((x0 > rxmin && x0 < rxmax && y0 > rymin && y0 < rymax) ||
         (x1 > rxmin && x1 < rxmax && y1 > rymin && y1 < rymax))
       # Otherwise calculate the y intercepts and see where
       # they fall with respect to the rectangle
@@ -311,7 +311,7 @@ module PerfectShape
         end
         return crossings
       end
-      Rectangle::RECT_INTERSECTS
+      PerfectShape::Rectangle::RECT_INTERSECTS
     end
     
     def intersect?(rectangle)

data/lib/perfect_shape/path.rb

@@ -35,7 +35,7 @@ module PerfectShape
     SHAPE_TYPES = [Array, PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, PerfectShape::CubicBezierCurve]
     
     # Available winding rules
-    WINDING_RULES = [:wind_non_zero, :wind_even_odd]
+    WINDING_RULES = [:wind_even_odd, :wind_non_zero]
     
     attr_reader :winding_rule
     attr_accessor :shapes, :closed
@@ -45,7 +45,7 @@ module PerfectShape
     # Shape class types can be any of SHAPE_TYPES: Array (x,y coordinates), PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, or PerfectShape::CubicBezierCurve
     # winding_rule can be any of WINDING_RULES: :wind_non_zero (default) or :wind_even_odd
     # closed can be true or false
-    def initialize(shapes: [], closed: false, winding_rule: :wind_non_zero)
+    def initialize(shapes: [], closed: false, winding_rule: :wind_even_odd)
       self.closed = closed
       self.winding_rule = winding_rule
       self.shapes = shapes
@@ -99,7 +99,7 @@ module PerfectShape
     end
     
     def winding_rule=(value)
-      raise "Invalid winding rule: #{value}" unless WINDING_RULES.include?(value.to_s.to_sym)
+      raise "Invalid winding rule: #{value} (must be one of #{WINDING_RULES})" unless WINDING_RULES.include?(value.to_s.to_sym)
       @winding_rule = value
     end
     
@@ -175,8 +175,8 @@ module PerfectShape
           ci += 1
           line = PerfectShape::Line.new(points: [[curx, cury], [endx, endy]])
           crossings += line.point_crossings(x, y)
-          curx = endx;
-          cury = endy;
+          curx = endx
+          cury = endy
         when :quad_to
           quad_ctrlx = coords[ci]
           ci += 1
@@ -188,8 +188,8 @@ module PerfectShape
           ci += 1
           quad = PerfectShape::QuadraticBezierCurve.new(points: [[curx, cury], [quad_ctrlx, quad_ctrly], [endx, endy]])
           crossings += quad.point_crossings(x, y)
-          curx = endx;
-          cury = endy;
+          curx = endx
+          cury = endy
         when :cubic_to
           cubic_ctrl1x = coords[ci]
           ci += 1
@@ -205,8 +205,8 @@ module PerfectShape
           ci += 1
           cubic = PerfectShape::CubicBezierCurve.new(points: [[curx, cury], [cubic_ctrl1x, cubic_ctrl1y], [cubic_ctrl2x, cubic_ctrl2y], [endx, endy]])
           crossings += cubic.point_crossings(x, y)
-          curx = endx;
-          cury = endy;
+          curx = endx
+          cury = endy
         when :close
           if cury != movy
             line = PerfectShape::Line.new(points: [[curx, cury], [movx, movy]])
@@ -267,5 +267,110 @@ module PerfectShape
       the_disconnected_shapes << Line.new(points: [final_point, initial_point]) if closed?
       the_disconnected_shapes.compact
     end
+    
+    def intersect?(rectangle)
+      x = rectangle.x
+      y = rectangle.y
+      w = rectangle.width
+      h = rectangle.height
+      # [xy]+[wh] is NaN if any of those values are NaN,
+      # or if adding the two together would produce NaN
+      # by virtue of adding opposing Infinte values.
+      # Since we need to add them below, their sum must
+      # not be NaN.
+      # We return false because NaN always produces a
+      # negative response to tests
+      return false if (x+w).nan? || (y+h).nan?
+      return false if w <= 0 || h <= 0
+      mask = winding_rule == :wind_non_zero ? -1 : 2
+      crossings = rect_crossings(x, y, x+w, y+h)
+      crossings == PerfectShape::Rectangle::RECT_INTERSECTS ||
+        (crossings & mask) != 0
+    end
+    
+    def rect_crossings(rxmin, rymin, rxmax, rymax)
+      numTypes = drawing_types.count
+      return 0 if numTypes == 0
+      coords = points.flatten
+      curx = cury = movx = movy = endx = endy = nil
+      curx = movx = coords[0]
+      cury = movy = coords[1]
+      crossings = 0
+      ci = 2
+      i = 1
+      
+      while crossings != PerfectShape::Rectangle::RECT_INTERSECTS && i < numTypes
+        case drawing_types[i]
+        when :move_to
+          if curx != movx || cury != movy
+            line = PerfectShape::Line.new(points: [curx, cury, movx, movy])
+            crossings = line.rect_crossings(rxmin, rymin, rxmax, rymax, crossings)
+          end
+          # Count should always be a multiple of 2 here.
+          # assert((crossings & 1) != 0)
+          movx = curx = coords[ci]
+          ci += 1
+          movy = cury = coords[ci]
+          ci += 1
+        when :line_to
+          endx = coords[ci]
+          ci += 1
+          endy = coords[ci]
+          ci += 1
+          line = PerfectShape::Line.new(points: [curx, cury, endx, endy])
+          crossings = line.rect_crossings(rxmin, rymin, rxmax, rymax, crossings)
+          curx = endx
+          cury = endy
+        when :quad_to
+          cx = coords[ci]
+          ci += 1
+          cy = coords[ci]
+          ci += 1
+          endx = coords[ci]
+          ci += 1
+          endy = coords[ci]
+          ci += 1
+          quadratic_bezier_curve = PerfectShape::QuadraticBezierCurve.new(points: [curx, cury, cx, cy, endx, endy])
+          crossings = quadratic_bezier_curve.rect_crossings(rxmin, rymin, rxmax, rymax, 0, crossings)
+          curx = endx
+          cury = endy
+        when :cubic_to
+          c1x = coords[ci]
+          ci += 1
+          c1y = coords[ci]
+          ci += 1
+          c2x = coords[ci]
+          ci += 1
+          c2y = coords[ci]
+          ci += 1
+          endx = coords[ci]
+          ci += 1
+          endy = coords[ci]
+          ci += 1
+          cubic_bezier_curve = PerfectShape::CubicBezierCurve.new(points: [curx, cury, c1x, c1y, c2x, c2y, endx, endy])
+          crossings = cubic_bezier_curve.rect_crossings(rxmin, rymin, rxmax, rymax, 0, crossings)
+          curx = endx
+          cury = endy
+        when :close
+          if curx != movx || cury != movy
+            line = PerfectShape::Line.new(points: [curx, cury, movx, movy])
+            crossings = line.rect_crossings(rxmin, rymin, rxmax, rymax, crossings)
+          end
+          curx = movx
+          cury = movy
+          # Count should always be a multiple of 2 here.
+          # assert((crossings & 1) != 0)
+        end
+        i += 1
+      end
+      if crossings != PerfectShape::Rectangle::RECT_INTERSECTS &&
+        (curx != movx || cury != movy)
+        line = PerfectShape::Line.new(points: [curx, cury, movx, movy])
+        crossings = line.rect_crossings(rxmin, rymin, rxmax, rymax, crossings)
+      end
+      # Count should always be a multiple of 2 here.
+      # assert((crossings & 1) != 0)
+      crossings
+    end
   end
 end

data/lib/perfect_shape/polygon.rb

@@ -22,14 +22,31 @@
 require 'perfect_shape/shape'
 require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
+require 'perfect_shape/path'
 
 module PerfectShape
   class Polygon < Shape
     include MultiPoint
     include Equalizer.new(:points)
     
+    WINDING_RULES = PerfectShape::Path::WINDING_RULES
+    
+    attr_reader :winding_rule
+    
+    def initialize(points: [], winding_rule: :wind_even_odd)
+      super(points: points)
+      self.winding_rule = winding_rule
+    end
+    
+    def winding_rule=(value)
+      raise "Invalid winding rule: #{value} (must be one of #{WINDING_RULES})" unless WINDING_RULES.include?(value.to_s.to_sym)
+      @winding_rule = value
+    end
+    
     # Checks if polygon contains point (two-number Array or x, y args)
-    # using the Ray Casting Algorithm (aka Even-Odd Rule): https://en.wikipedia.org/wiki/Point_in_polygon
+    # using the Ray Casting Algorithm (aka Even-Odd Rule)
+    # or Winding Number Algorithm (aka Nonzero Rule)
+    # Details: https://en.wikipedia.org/wiki/Point_in_polygon
     #
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
@@ -43,76 +60,11 @@ module PerfectShape
       if outline
         edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }
       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 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
-  
-          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
-  
-          hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
+        if winding_rule == :wind_even_odd
+          wind_even_odd_contain?(x, y)
+        else
+          path.contain?(x, y)
         end
-  
-        (hits & 1) != 0
       end
     end
     
@@ -121,5 +73,92 @@ module PerfectShape
         Line.new(points: [[point1.first, point1.last], [point2.first, point2.last]])
       end
     end
+    
+    def path
+      path_shapes = []
+      path_shapes << PerfectShape::Point.new(points[0])
+      path_shapes += points[1..-1].map { |point| PerfectShape::Line.new(points: [point]) }
+      PerfectShape::Path.new(shapes: path_shapes, closed: true, winding_rule: winding_rule)
+    end
+    
+    def intersect?(rectangle)
+      path.intersect?(rectangle)
+    end
+    
+    private
+    
+    # optimized even-odd rule point in polygon algorithm (uses less memory than PerfectShape::Path algorithms)
+    def wind_even_odd_contain?(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
+        end
+
+        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
+
+        hits += 1 if (test1 < (test2 / (lasty - cury) * (lastx - curx)))
+      end
+
+      (hits & 1) != 0
+    end
   end
 end

data/lib/perfect_shape/quadratic_bezier_curve.rb

@@ -545,5 +545,72 @@ module PerfectShape
       # overlap the Y range of the rectangle.
       c1tag * c2tag <= 0
     end
+    
+    # Accumulate the number of times the quad crosses the shadow
+    # extending to the right of the rectangle.  See the comment
+    # for the RECT_INTERSECTS constant for more complete details.
+    #
+    # crossings arg is the initial crossings value to add to (useful
+    # in cases where you want to accumulate crossings from multiple
+    # shapes)
+    def rect_crossings(rxmin, rymin, rxmax, rymax, level, crossings = 0)
+      x0 = points[0][0]
+      y0 = points[0][1]
+      xc = points[1][0]
+      yc = points[1][1]
+      x1 = points[2][0]
+      y1 = points[2][1]
+      return crossings if y0 >= rymax && yc >= rymax && y1 >= rymax
+      return crossings if y0 <= rymin && yc <= rymin && y1 <= rymin
+      return crossings if x0 <= rxmin && xc <= rxmin && x1 <= rxmin
+      if x0 >= rxmax && xc >= rxmax && x1 >= rxmax
+        # Quad is entirely to the right of the rect
+        # and the vertical range of the 3 Y coordinates of the quad
+        # overlaps the vertical range of the rect by a non-empty amount
+        # We now judge the crossings solely based on the line segment
+        # connecting the endpoints of the quad.
+        # Note that we may have 0, 1, or 2 crossings as the control
+        # point may be causing the Y range intersection while the
+        # two endpoints are entirely above or below.
+        if y0 < y1
+          # y-increasing line segment...
+          crossings += 1 if y0 <= rymin && y1 >  rymin
+          crossings += 1 if y0 <  rymax && y1 >= rymax
+        elsif y1 < y0
+          # y-decreasing line segment...
+          crossings -= 1 if y1 <= rymin && y0 >  rymin
+          crossings -= 1 if y1 <  rymax && y0 >= rymax
+        end
+        return crossings
+      end
+      # The intersection of ranges is more complicated
+      # First do trivial INTERSECTS rejection of the cases
+      # where one of the endpoints is inside the rectangle.
+      return PerfectShape::Rectangle::RECT_INTERSECTS if (x0 < rxmax && x0 > rxmin && y0 < rymax && y0 > rymin) ||
+        (x1 < rxmax && x1 > rxmin && y1 < rymax && y1 > rymin)
+      # Otherwise, subdivide and look for one of the cases above.
+      # double precision only has 52 bits of mantissa
+      if level > 52
+        line = PerfectShape::Line.new(points: [x0, y0, x1, y1])
+        return line.rect_crossings(rxmin, rymin, rxmax, rymax, crossings)
+      end
+      x0c = BigDecimal((x0 + xc).to_s) / 2
+      y0c = BigDecimal((y0 + yc).to_s) / 2
+      xc1 = BigDecimal((xc + x1).to_s) / 2
+      yc1 = BigDecimal((yc + y1).to_s) / 2
+      xc = BigDecimal((x0c + xc1).to_s) / 2
+      yc = BigDecimal((y0c + 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 0 if xc.nan? || yc.nan?
+      quad1 = QuadraticBezierCurve.new(points: [x0, y0, x0c, y0c, xc, yc])
+      crossings = quad1.rect_crossings(rxmin, rymin, rxmax, rymax, level+1, crossings)
+      if crossings != PerfectShape::Rectangle::RECT_INTERSECTS
+        quad2 = QuadraticBezierCurve.new(points: [xc, yc, xc1, yc1, x1, y1])
+        crossings = quad2.rect_crossings(rxmin, rymin, rxmax, rymax, level+1, crossings)
+      end
+      crossings
+    end
   end
 end

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.5.5 ruby lib
+# stub: perfect-shape 1.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.5.5"
+  s.version = "1.0.0"
 
   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-22"
+  s.date = "2022-01-23"
   s.description = "Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking viewport rectangle intersection or 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, potentially with affine transforms applied like translation, scale, rotation, shear/skew, and inversion (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.5.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-22 00:00:00.000000000 Z
+date: 2022-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer