perfect-shape 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e83221df061b944acb69abfec2536a0c0bc3c8176d6f5b4929c68bb6283e7f82
-  data.tar.gz: 5f778729c9b39a259708a0e6995b370f040442b4864f7594418fafdfd1208d12
+  metadata.gz: 73a1e3f4816ce8829788f6ad76e83a88429301000bb49aca7bab878148d90527
+  data.tar.gz: f2628350798a4f5285f3c82941154e21a52aa72b401f3a3fdd889e720554eade
 SHA512:
-  metadata.gz: 9e18a4d841f70f938c220c21e1d928273d5a24a6f114a4a2b8c0f2c0c6ca020a80510f9dd698a092582607d5bd8a224e5c6c6aea875a443a740d64982ae4f2d4
-  data.tar.gz: 5712f83712d505f3c7156dfd9e194735b73215542c9012bda5359544f72eac4743f00d9e39f97c98a2bee22c43dd45f808554abad3a5ea6f2b983e925f3cadb2
+  metadata.gz: d79de0f8201d530f55792faea84bb8e9d47608a06f234d305aeb5dcf8ca8fefc612c9eebda0b449ece028a3d281f6b5d8824c41c6b7703d9e575e9cb6cabaa55
+  data.tar.gz: 861950d0dd6107a7de5f5d5f59e192770eb6255024881d67a4e67b3ca229fdc1ff29f176f40223bdb0c8ef67e38cfc46a33313c1d9adb9b37c7fb84f688dc491

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # 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

data/README.md

@@ -1,9 +1,9 @@
-# Perfect Shape 1.0.1
+# 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 1.0.1
+gem install perfect-shape -v 1.0.2
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 1.0.1'
+gem 'perfect-shape', '~> 1.0.2'
 ```
 
 And, run:
@@ -467,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
@@ -480,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:
 
@@ -604,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:
 
@@ -666,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:
 
@@ -754,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
@@ -786,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

data/VERSION

@@ -1 +1 @@
-1.0.1
+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/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_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_even_odd)
+    # 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
@@ -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)
@@ -372,5 +378,25 @@ module PerfectShape
       # 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/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 1.0.1 ruby lib
+# stub: perfect-shape 1.0.2 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "1.0.1"
+  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-02-16"
-  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",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer
@@ -106,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: []