perfect-shape 0.5.5 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f32696a2e0ecd7c1aceb16d9211b38e977b4dd15c7ba57acb8ac99a769d75036
-  data.tar.gz: 50c458cfcf134ce86bc11e0b22f1650b2faf2146c79c288d7b2501a2d7d9264c
+  metadata.gz: 73a1e3f4816ce8829788f6ad76e83a88429301000bb49aca7bab878148d90527
+  data.tar.gz: f2628350798a4f5285f3c82941154e21a52aa72b401f3a3fdd889e720554eade
 SHA512:
-  metadata.gz: 1e15378328df2eaad3769ce087118f7990fcb834963cbc56b738ea1cc292a92df0f86d77506e1a2f94985bc03211b5436b9965e8b6b5c97c80f9d7ad59f6cb20
-  data.tar.gz: cb64f0b3951ca4628f96e265070a88684060be6ffa38b5a45deea611bce0b2d20b72e43ef6c5d70b969925a31fe0017f4ec84407927f23a1b7824e0352bc9732
+  metadata.gz: d79de0f8201d530f55792faea84bb8e9d47608a06f234d305aeb5dcf8ca8fefc612c9eebda0b449ece028a3d281f6b5d8824c41c6b7703d9e575e9cb6cabaa55
+  data.tar.gz: 861950d0dd6107a7de5f5d5f59e192770eb6255024881d67a4e67b3ca229fdc1ff29f176f40223bdb0c8ef67e38cfc46a33313c1d9adb9b37c7fb84f688dc491

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Change Log
 
+## 1.0.2
+
+- `Path` can contain an `Arc`, `Ellipse`, or `Circle` (to get affected by the winding algorithm as opposed to `CompositeShape` which has no winding algorithm)
+- `Arc`, `Ellipse`, and `Circle` `#to_path_shapes` method, which decomposes them into `Point`s, `Line`s, and `CubicBezierCurve`s to be added to a `Path`
+
+## 1.0.1
+
+- Relax `equalizer` gem version to '>= 0.0.11', '< 1.1.0' to avoid conflicts in projects that might use future versions
+- Fix issue with infinite loop upon setting `Circle#radius=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Circle#radius_x=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Circle#radius_y=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Circle#diameter=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Circle#width=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Circle#height=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Square#length=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Square#width=` to a number with very small decimals
+- Fix issue with infinite loop upon setting `Square#height=` to a number with very small decimals
+
+## 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,9 +1,9 @@
-# Perfect Shape 0.5.5
+# Perfect Shape 1.0.2
 ## 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)
 
-[`PerfectShape`](https://rubygems.org/gems/perfect-shape) is a collection of pure Ruby geometric algorithms that are mostly useful for GUI (Graphical User Interface) manipulation like checking viewport rectangle intersection or containment of a mouse click [point](#perfectshapepoint) in popular geometry shapes such as [rectangle](#perfectshaperectangle), [square](#perfectshapesquare), [arc](#perfectshapearc) (open, chord, and pie), [ellipse](#perfectshapeellipse), [circle](#perfectshapecircle), [polygon](#perfectshapepolygon), and [paths](#perfectshapepath) containing [lines](#perfectshapeline), [quadratic bézier curves](#perfectshapequadraticbeziercurve), and [cubic bezier curves](#perfectshapecubicbeziercurve), potentially with [affine transforms](#perfectshapeaffinetransform) applied like translation, scale, rotation, shear/skew, and inversion (including both [Ray Casting Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Ray_casting_algorithm), aka [Even-odd Rule](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule), and [Winding Number Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Winding_number_algorithm), aka [Nonzero Rule](https://en.wikipedia.org/wiki/Nonzero-rule)).
+[`PerfectShape`](https://rubygems.org/gems/perfect-shape) is a collection of pure Ruby geometric algorithms that are mostly useful for GUI (Graphical User Interface) manipulation like checking viewport rectangle intersection or containment of a mouse click [point](#perfectshapepoint) in popular geometry shapes such as [rectangle](#perfectshaperectangle), [square](#perfectshapesquare), [arc](#perfectshapearc) (open, chord, and pie), [ellipse](#perfectshapeellipse), [circle](#perfectshapecircle), [polygon](#perfectshapepolygon), and [paths](#perfectshapepath) containing [lines](#perfectshapeline), [quadratic bézier curves](#perfectshapequadraticbeziercurve), and [cubic bezier curves](#perfectshapecubicbeziercurve), potentially with [affine transforms](#perfectshapeaffinetransform) applied like translation, scale, rotation, shear/skew, and inversion (including both the [Ray Casting Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Ray_casting_algorithm), aka [Even-odd Rule](https://en.wikipedia.org/wiki/Even%E2%80%93odd_rule), and the [Winding Number Algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Winding_number_algorithm), aka [Nonzero Rule](https://en.wikipedia.org/wiki/Nonzero-rule)).
 
 Additionally, [`PerfectShape::Math`](#perfectshapemath) contains some purely mathematical algorithms, like [IEEE 754-1985 Remainder](https://en.wikipedia.org/wiki/IEEE_754-1985).
 
@@ -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.2
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.5.5'
+gem 'perfect-shape', '~> 1.0.2'
 ```
 
 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:
 
@@ -466,6 +467,8 @@ Open Arc | Chord Arc | Pie Arc
 - `#start`: start angle in degrees
 - `#extent`: extent angle in degrees
 - `#center_point`: center point as `Array` of `[center_x, center_y]` coordinates
+- `#start_point`: start point as `Array` of (x,y) coordinates
+- `#end_point`: end point as `Array` of (x,y) coordinates
 - `#center_x`: center x
 - `#center_y`: center y
 - `#radius_x`: radius along the x-axis
@@ -479,6 +482,8 @@ Open Arc | Chord Arc | Pie Arc
 - `#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 an arc 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
 - `#contain_angle?(angle)`: returns `true` if the angle is within the angular extents of the arc and `false` otherwise
+- `#to_path_shapes`: Converts `Arc` into basic `Path` shapes made up of `Point`s, `Line`s, and `CubicBezierCurve`s. Used by `Path` when adding an `Arc` to `Path` `shapes`
+- `#btan(increment)`: btan computes the length (k) of the control segments at the beginning and end of a cubic bezier that approximates a segment of an arc with extent less than or equal to 90 degrees.  This length (k) will be used to generate the 2 bezier control points for such a segment.
 
 Example:
 
@@ -603,6 +608,7 @@ Extends `PerfectShape::Arc`
 - `#==(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 an ellipse 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
+- `#to_path_shapes`: Converts `Ellipse` into basic `Path` shapes made up of `Point`s, `Line`s, and `CubicBezierCurve`s. Used by `Path` when adding an `Ellipse` to `Path` `shapes`
 
 Example:
 
@@ -665,6 +671,7 @@ Extends `PerfectShape::Ellipse`
 - `#==(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 circle 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
+- `#to_path_shapes`: Converts `Circle` into basic `Path` shapes made up of `Point`s, `Line`s, and `CubicBezierCurve`s. Used by `Path` when adding a `Circle` to `Path` `shapes`
 
 Example:
 
@@ -704,11 +711,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 +727,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:
@@ -752,8 +760,9 @@ Includes `PerfectShape::MultiPoint`
 
 ![path](https://raw.githubusercontent.com/AndyObtiva/perfect-shape/master/images/path.png)
 
-- `::new(shapes: [], closed: false, winding_rule: :wind_non_zero)`: constructs a path with `shapes` as `Array` of shape objects, which can be `PerfectShape::Point` (or `Array` of `[x, y]` coordinates), `PerfectShape::Line`, `PerfectShape::QuadraticBezierCurve`, or `PerfectShape::CubicBezierCurve`. If a path is closed, its last point is automatically connected to its first point with a line segment. The winding rule can be `:wind_non_zero` (default) or `:wind_even_odd`.
-- `#shapes`: the shapes that the path is composed of (must always start with `PerfectShape::Point` or Array of [x,y] coordinates representing start point)
+- `::new(shapes: [], closed: false, winding_rule: :wind_even_odd, line_to_complex_shapes: false)`: constructs a path with `shapes` as `Array` of shape objects, which can be `PerfectShape::Point` (or `Array` of `[x, y]` coordinates), `PerfectShape::Line`, `PerfectShape::QuadraticBezierCurve`, `PerfectShape::CubicBezierCurve`, or complex shapes that decompose into the aforementioned basic path shapes, like `PerfectShape::Arc`, `PerfectShape::Ellipse`, and `PerfectShape::Circle`. If a path is closed, its last point is automatically connected to its first point with a line segment. The winding rule can be `:wind_non_zero` (default) or `:wind_even_odd`. `line_to_complex_shapes` can be `true` or `false` (default), indicating whether to connect to complex shapes, meaning `Arc`, `Ellipse`, and `Circle`, with a line, or otherwise move to their start point instead.
+- `#shapes`: the shapes that the path is composed of (must always start with `PerfectShape::Point` or Array of `[x,y]` coordinates representing start point)
+- `#basic_shapes`: the basic shapes that the path is composed of, meaning only `Point`, `Line`, `QuadraticBezierCurve`, and `CubicBezierCurve` shapes (decomposing complex shapes like `Arc`, `Ellipse`, and `Circle` using their `#to_path_shapes` method)
 - `#closed?`: returns `true` if closed and `false` otherwise
 - `#winding_rule`: returns winding rule (`:wind_non_zero` or `:wind_even_odd`)
 - `#points`: path points calculated (derived) from shapes
@@ -769,6 +778,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
 
@@ -783,7 +793,7 @@ path_shapes << PerfectShape::Line.new(points: [250, 170]) # no need for start po
 path_shapes << PerfectShape::QuadraticBezierCurve.new(points: [[300, 185], [350, 150]]) # no need for start point, just control point and end point
 path_shapes << PerfectShape::CubicBezierCurve.new(points: [[370, 50], [430, 220], [480, 170]]) # no need for start point, just two control points and end point
 
-shape = PerfectShape::Path.new(shapes: path_shapes, closed: false, winding_rule: :wind_even_odd)
+shape = PerfectShape::Path.new(shapes: path_shapes, closed: false, winding_rule: :wind_non_zero)
 
 shape.contain?(275, 165) # => true
 shape.contain?([275, 165]) # => true
@@ -821,6 +831,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.2

data/lib/perfect_shape/arc.rb

@@ -312,5 +312,165 @@ module PerfectShape
       y = self.y + (Math.sin(angle) * 0.5 + 0.5) * self.height
       [x, y]
     end
+    
+    # Converts Arc into basic Path shapes made up of Points, Lines, and CubicBezierCurves
+    # Used by Path when adding an Arc to Path shapes
+    def to_path_shapes
+      w = BigDecimal(self.width.to_s) / 2
+      h = BigDecimal(self.height.to_s) / 2
+      x = self.x + w
+      y = self.x + h
+      ang_st_rad = -Math.degrees_to_radians(self.start)
+      ext = -self.extent
+      if ext >= 360.0 || ext <= -360
+        arc_segs = 4
+        increment = Math::PI / 2
+        cv = 0.5522847498307933
+        if ext < 0
+          increment = -increment
+          cv = -cv
+        end
+      else
+        arc_segs = (ext.abs / 90.0).ceil
+        increment = Math.degrees_to_radians(ext / arc_segs)
+        cv = btan(increment)
+        arc_segs = 0 if cv == 0
+      end
+      line_segs = nil
+      case self.type
+      when :open
+        line_segs = 0
+      when :chord
+        line_segs = 1
+      when :pie
+        line_segs = 2
+      end
+      arc_segs = line_segs = -1 if w < 0 || h < 0
+      
+      first_point_x = first_point_y = nil
+      last_point_x = last_point_y = nil
+      (arc_segs + line_segs + 1).to_i.times.map do |index|
+        coords = []
+        angle = ang_st_rad
+        if index == 0
+          first_point_x = coords[0] = x + Math.cos(angle) * w
+          first_point_y = coords[1] = y + Math.sin(angle) * h
+          Point.new(*coords)
+        elsif (index > arc_segs) && (extent - start) != 0 && ((extent - start)%360 == 0)
+          nil
+        elsif (index > arc_segs) && (index < arc_segs + line_segs) && (extent - start) == 0
+          nil
+        elsif (index > arc_segs) && (index == arc_segs + line_segs)
+          Line.new(points: [[first_point_x, first_point_y]])
+        elsif index > arc_segs
+          coords[0] = x
+          coords[1] = y
+          if line_segs == 2
+            last_point_x = coords[0]
+            last_point_y = coords[1]
+          end
+          Line.new(points: coords)
+        else
+          angle += increment * (index - 1)
+          relx = Math.cos(angle)
+          rely = Math.sin(angle)
+          coords[0] = x + (relx - cv * rely) * w
+          coords[1] = y + (rely + cv * relx) * h
+          angle += increment
+          relx = Math.cos(angle)
+          rely = Math.sin(angle)
+          coords[2] = x + (relx + cv * rely) * w
+          coords[3] = y + (rely - cv * relx) * h
+          coords[4] = x + relx * w
+          coords[5] = y + rely * h
+          if line_segs == 1
+            last_point_x = coords[4]
+            last_point_y = coords[5]
+          end
+          CubicBezierCurve.new(points: coords)
+        end
+      end.compact
+    end
+    
+    # btan computes the length (k) of the control segments at
+    # the beginning and end of a cubic bezier that approximates
+    # a segment of an arc with extent less than or equal to
+    # 90 degrees.  This length (k) will be used to generate the
+    # 2 bezier control points for such a segment.
+    #
+    #   Assumptions:
+    #     a) arc is centered on 0,0 with radius of 1.0
+    #     b) arc extent is less than 90 degrees
+    #     c) control points should preserve tangent
+    #     d) control segments should have equal length
+    #
+    #   Initial data:
+    #     start angle: ang1
+    #     end angle:   ang2 = ang1 + extent
+    #     start point: P1 = (x1, y1) = (cos(ang1), sin(ang1))
+    #     end point:   P4 = (x4, y4) = (cos(ang2), sin(ang2))
+    #
+    #   Control points:
+    #     P2 = (x2, y2)
+    #     | x2 = x1 - k * sin(ang1) = cos(ang1) - k * sin(ang1)
+    #     | y2 = y1 + k * cos(ang1) = sin(ang1) + k * cos(ang1)
+    #
+    #     P3 = (x3, y3)
+    #     | x3 = x4 + k * sin(ang2) = cos(ang2) + k * sin(ang2)
+    #     | y3 = y4 - k * cos(ang2) = sin(ang2) - k * cos(ang2)
+    #
+    # The formula for this length (k) can be found using the
+    # following derivations:
+    #
+    #   Midpoints:
+    #     a) bezier (t = 1/2)
+    #        bPm = P1 * (1-t)^3 +
+    #              3 * P2 * t * (1-t)^2 +
+    #              3 * P3 * t^2 * (1-t) +
+    #              P4 * t^3 =
+    #            = (P1 + 3P2 + 3P3 + P4)/8
+    #
+    #     b) arc
+    #        aPm = (cos((ang1 + ang2)/2), sin((ang1 + ang2)/2))
+    #
+    #   Let angb = (ang2 - ang1)/2; angb is half of the angle
+    #   between ang1 and ang2.
+    #
+    #   Solve the equation bPm == aPm
+    #
+    #     a) For xm coord:
+    #        x1 + 3*x2 + 3*x3 + x4 = 8*cos((ang1 + ang2)/2)
+    #
+    #        cos(ang1) + 3*cos(ang1) - 3*k*sin(ang1) +
+    #        3*cos(ang2) + 3*k*sin(ang2) + cos(ang2) =
+    #        = 8*cos((ang1 + ang2)/2)
+    #
+    #        4*cos(ang1) + 4*cos(ang2) + 3*k*(sin(ang2) - sin(ang1)) =
+    #        = 8*cos((ang1 + ang2)/2)
+    #
+    #        8*cos((ang1 + ang2)/2)*cos((ang2 - ang1)/2) +
+    #        6*k*sin((ang2 - ang1)/2)*cos((ang1 + ang2)/2) =
+    #        = 8*cos((ang1 + ang2)/2)
+    #
+    #        4*cos(angb) + 3*k*sin(angb) = 4
+    #
+    #        k = 4 / 3 * (1 - cos(angb)) / sin(angb)
+    #
+    #     b) For ym coord we derive the same formula.
+    #
+    # Since this formula can generate "NaN" values for small
+    # angles, we will derive a safer form that does not involve
+    # dividing by very small values:
+    #     (1 - cos(angb)) / sin(angb) =
+    #     = (1 - cos(angb))*(1 + cos(angb)) / sin(angb)*(1 + cos(angb)) =
+    #     = (1 - cos(angb)^2) / sin(angb)*(1 + cos(angb)) =
+    #     = sin(angb)^2 / sin(angb)*(1 + cos(angb)) =
+    #     = sin(angb) / (1 + cos(angb))
+    #
+    def btan(increment)
+      return 0 if increment.nan?
+      increment /= BigDecimal('2.0')
+      BigDecimal('4.0') / BigDecimal('3.0') * Math.sin(increment) / (BigDecimal('1.0') + Math.cos(increment))
+    end
   end
 end

data/lib/perfect_shape/circle.rb

@@ -52,40 +52,40 @@ module PerfectShape
     def diameter=(value)
       @diameter = BigDecimal(value.to_s)
       @radius = nil
-      self.width = value unless width == value
-      self.height = value unless height == value
+      self.width = @diameter unless width == @diameter
+      self.height = @diameter unless height == @diameter
     end
     
     # Sets radius, normalizing to BigDecimal
     def radius=(value)
       @radius = BigDecimal(value.to_s)
       @diameter = nil
-      self.radius_x = value unless width == value
-      self.radius_y = value unless height == value
+      self.radius_x = @radius unless @width == @radius
+      self.radius_y = @radius unless @height == @radius
     end
     
     def width=(value)
       super
-      self.diameter = value unless diameter == value
-      self.height = value unless height == value
+      self.diameter = @width unless diameter == @width
+      self.height = @width unless height == @width
     end
     
     def height=(value)
       super
-      self.diameter = value unless diameter == value
-      self.width = value unless width == value
+      self.diameter = @height unless diameter == @height
+      self.width = @height unless width == @height
     end
     
     def radius_x=(value)
       super
-      self.radius = value unless radius == value
-      self.radius_y = value unless radius_y == value
+      self.radius = @radius_x unless radius == @radius_x
+      self.radius_y = @radius_x unless radius_y == @radius_x
     end
     
     def radius_y=(value)
       super
-      self.radius = value unless radius == value
-      self.radius_x = value unless radius_x == value
+      self.radius = @radius_y unless radius == @radius_y
+      self.radius_x = @radius_y unless radius_x == @radius_y
     end
   end
 end

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

@@ -32,28 +32,34 @@ module PerfectShape
     include Equalizer.new(:shapes, :closed, :winding_rule)
     
     # Available class types for path shapes
-    SHAPE_TYPES = [Array, PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, PerfectShape::CubicBezierCurve]
+    SHAPE_TYPES = [Array, PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, PerfectShape::CubicBezierCurve, PerfectShape::Arc, PerfectShape::Ellipse, PerfectShape::Circle]
     
     # 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
+    attr_accessor :shapes, :closed, :line_to_complex_shapes
     alias closed? closed
+    alias line_to_complex_shapes? line_to_complex_shapes
     
-    # Constructs Path with winding rule, closed status, and shapes (must always start with PerfectShape::Point or Array of [x,y] coordinates)
-    # Shape class types can be any of SHAPE_TYPES: Array (x,y coordinates), PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, or PerfectShape::CubicBezierCurve
+    # Constructs Path with winding rule, closed status, line_to_complex_shapes option, and shapes (must always start with PerfectShape::Point or Array of [x,y] coordinates)
+    # Shape class types can be any of SHAPE_TYPES: Array (x,y coordinates), PerfectShape::Point, PerfectShape::Line, PerfectShape::QuadraticBezierCurve, PerfectShape::CubicBezierCurve
+    # PerfectShape::Arc, PerfectShape::Ellipse, or PerfectShape::Circle
+    # Complex shapes, meaning Arc, Ellipse, and Circle, are decomposed into basic path shapes, meaning Point, Line, QuadraticBezierCurve, and 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)
+    # closed can be true or false (default)
+    # line_to_complex_shapes can be true or false (default), indicating whether to connect to complex shapes,
+    # meaning Arc, Ellipse, and Circle, with a line, or otherwise move to their start point instead.
+    def initialize(shapes: [], closed: false, winding_rule: :wind_even_odd, line_to_complex_shapes: false)
       self.closed = closed
       self.winding_rule = winding_rule
       self.shapes = shapes
+      self.line_to_complex_shapes = line_to_complex_shapes
     end
     
     def points
       the_points = []
-      @shapes.each do |shape|
+      basic_shapes.each do |shape|
         case shape
         when Point
           the_points << shape.to_a
@@ -71,7 +77,7 @@ module PerfectShape
           end
         end
       end
-      the_points << @shapes.first.to_a if closed?
+      the_points << basic_shapes.first.to_a if closed?
       the_points
     end
     
@@ -80,7 +86,7 @@ module PerfectShape
     end
     
     def drawing_types
-      the_drawing_shapes = @shapes.map do |shape|
+      the_drawing_shapes = basic_shapes.map do |shape|
         case shape
         when Point
           :move_to
@@ -99,7 +105,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 +181,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 +194,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 +211,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]])
@@ -233,9 +239,9 @@ module PerfectShape
     # 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)}
+      initial_point = start_point = basic_shapes.first.to_a.map {|n| BigDecimal(n.to_s)}
       final_point = nil
-      the_disconnected_shapes = @shapes.drop(1).map do |shape|
+      the_disconnected_shapes = basic_shapes.drop(1).map do |shape|
         case shape
         when Point
           disconnected_shape = Point.new(*shape.to_a)
@@ -267,5 +273,130 @@ 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
+    
+    # Returns basic shapes (i.e. Point, Line, QuadraticBezierCurve, and CubicBezierCurve),
+    # decomposed from complex shapes like Arc, Ellipse, and Circle by calling their `#to_path_shapes` method
+    def basic_shapes
+      the_shapes = []
+      @shapes.each do |shape|
+        if shape.respond_to?(:to_path_shapes)
+          shape_basic_shapes = shape.to_path_shapes
+          if @line_to_complex_shapes
+            first_basic_shape = shape_basic_shapes.shift
+            new_first_basic_shape = PerfectShape::Line.new(points: [first_basic_shape.to_a])
+            shape_basic_shapes.unshift(new_first_basic_shape)
+          end
+          the_shapes += shape_basic_shapes
+        else
+          the_shapes << shape
+        end
+      end
+      the_shapes
+    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/lib/perfect_shape/square.rb

@@ -40,21 +40,21 @@ module PerfectShape
     # Sets length, normalizing to BigDecimal
     def length=(value)
       @length = BigDecimal(value.to_s)
-      self.width = value unless width == value
-      self.height = value unless height == value
+      self.width = @length unless width == @length
+      self.height = @length unless height == @length
     end
     alias size= length=
     
     def width=(value)
       super
-      self.length = value unless length == value
-      self.height = value unless height == value
+      self.length = @width unless length == @width
+      self.height = @width unless height == @width
     end
     
     def height=(value)
       super
-      self.length = value unless length == value
-      self.width = value unless width == value
+      self.length = @height unless length == @height
+      self.width = @height unless width == @height
     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.5.5 ruby lib
+# stub: perfect-shape 1.0.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.5.5"
+  s.version = "1.0.2"
 
   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.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.date = "2022-04-03"
+  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 the Ray Casting Algorithm, aka Even-odd Rule, and the 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",
@@ -55,14 +55,14 @@ Gem::Specification.new do |s|
   end
 
   if s.respond_to? :add_runtime_dependency then
-    s.add_runtime_dependency(%q<equalizer>.freeze, ["= 0.0.11"])
+    s.add_runtime_dependency(%q<equalizer>.freeze, [">= 0.0.11", "< 1.1.0"])
     s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
     s.add_development_dependency(%q<minitest>.freeze, ["~> 5.14.4"])
     s.add_development_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13.1"])
     s.add_development_dependency(%q<rake-tui>.freeze, ["> 0"])
   else
-    s.add_dependency(%q<equalizer>.freeze, ["= 0.0.11"])
+    s.add_dependency(%q<equalizer>.freeze, [">= 0.0.11", "< 1.1.0"])
     s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
     s.add_dependency(%q<minitest>.freeze, ["~> 5.14.4"])

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 1.0.2
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-22 00:00:00.000000000 Z
+date: 2022-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.11
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.11
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -100,9 +106,9 @@ description: Perfect Shape is a collection of pure Ruby geometric algorithms tha
   square, arc (open, chord, and pie), ellipse, circle, polygon, and paths containing
   lines, quadratic bézier 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).
+  (including both the Ray Casting Algorithm, aka Even-odd Rule, and the 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
 executables: []
 extensions: []