perfect-shape 0.5.4 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98226e1aac4fbac06b162630c2dbaa5ca2f749d24590cc0bd0cca9924f760635
-  data.tar.gz: 3d7d5be2905838db9ff1b3f2876e8437e0df90d9ac6b2316c1347aa4f58db626
+  metadata.gz: f32696a2e0ecd7c1aceb16d9211b38e977b4dd15c7ba57acb8ac99a769d75036
+  data.tar.gz: 50c458cfcf134ce86bc11e0b22f1650b2faf2146c79c288d7b2501a2d7d9264c
 SHA512:
-  metadata.gz: 686a5054b13bd3adf1176e779e80d2ef758c4cf9cc25625633151628a724c1b802c03847301a447fb14155b570ee0fe0fdf8fe4d357b92186bdd7df83d6de240
-  data.tar.gz: e05c4a2eb8d2efa7feef615dc5dd3d522778d8aa98b60845726de0d3a0e68bf84ffa173984d0a907401838a16432b725ed1e0ac5ac1d4239ed66596181dac324
+  metadata.gz: 1e15378328df2eaad3769ce087118f7990fcb834963cbc56b738ea1cc292a92df0f86d77506e1a2f94985bc03211b5436b9965e8b6b5c97c80f9d7ad59f6cb20
+  data.tar.gz: cb64f0b3951ca4628f96e265070a88684060be6ffa38b5a45deea611bce0b2d20b72e43ef6c5d70b969925a31fe0017f4ec84407927f23a1b7824e0352bc9732

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 0.5.5
+
+- `PerfectShape::Arc#intersect?(rectangle)`
+- `PerfectShape::Ellipse#intersect?(rectangle)`
+- `PerfectShape::Circle#intersect?(rectangle)`
+
 ## 0.5.4
 
 - `PerfectShape::Rectangle#intersect?(rectangle)`

data/README.md

@@ -1,4 +1,4 @@
-# Perfect Shape 0.5.4
+# Perfect Shape 0.5.5
 ## 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.4
+gem install perfect-shape -v 0.5.5
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.5.4'
+gem 'perfect-shape', '~> 0.5.5'
 ```
 
 And, run:
@@ -253,7 +253,7 @@ Includes `PerfectShape::MultiPoint`
 
 - `::tag(coord, low, high)`: Determine where coord lies with respect to the range from low to high.  It is assumed that low < high.  The return value is one of the 5 values BELOW, LOWEDGE, INSIDE, HIGHEDGE, or ABOVE.
 - `::eqn(val, c1, cp, c2)`: Fill an array with the coefficients of the parametric equation in t, ready for solving against val with solve_quadratic. We currently have: val = Py(t) = C1*(1-t)^2 + 2*CP*t*(1-t) + C2*t^2 = C1 - 2*C1*t + C1*t^2 + 2*CP*t - 2*CP*t^2 + C2*t^2 = C1 + (2*CP - 2*C1)*t + (C1 - 2*CP + C2)*t^2; 0 = (C1 - val) + (2*CP - 2*C1)*t + (C1 - 2*CP + C2)*t^2; 0 = C + Bt + At^2; C = C1 - val; B = 2*CP - 2*C1; A = C1 - 2*CP + C2
-- `::solve_quadratic(eqn)`: Solves the quadratic whose coefficients are in the eqn array and places the non-complex roots into the res array, returning the number of roots. The quadratic solved is represented by the equation: <pre>eqn = {C, B, A}; ax^2 + bx + c = 0</pre> A return value of {@code -1} is used to distinguish a constant equation, which might be always 0 or never 0, from an equation that has no zeroes.
+- `::solve_quadratic(eqn)`: Solves the quadratic whose coefficients are in the eqn array and places the non-complex roots into the res array, returning the number of roots. The quadratic solved is represented by the equation: <pre>eqn = {C, B, A}; ax^2 + bx + c = 0</pre> A return value of `-1` is used to distinguish a constant equation, which might be always 0 or never 0, from an equation that has no zeroes.
 - `::eval_quadratic(vals, num, include0, include1, inflect, c1, ctrl, c2)`: Evaluate the t values in the first num slots of the vals[] array and place the evaluated values back into the same array.  Only evaluate t values that are within the range <, >, including the 0 and 1 ends of the range iff the include0 or include1 booleans are true.  If an "inflection" equation is handed in, then any points which represent a point of inflection for that quadratic equation are also ignored.
 - `::new(points: [])`: constructs a quadratic bézier curve with three `points` (start point, control point, and end point) as `Array` of `Array`s of `[x,y]` pairs or flattened `Array` of alternating x and y coordinates
 - `#points`: points (start point, control point, and end point)
@@ -477,6 +477,8 @@ Open Arc | Chord Arc | Pie Arc
 - `#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)`: 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
 
 Example:
 
@@ -600,6 +602,7 @@ Extends `PerfectShape::Arc`
 - `#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)`: 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
 
 Example:
 
@@ -661,6 +664,7 @@ Extends `PerfectShape::Ellipse`
 - `#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)`: 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
 
 Example:
 

data/VERSION

@@ -1 +1 @@
-0.5.4
+0.5.5

data/lib/perfect_shape/arc.rb

@@ -141,8 +141,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the arc, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the arc, false if the point lies outside of the
     # arc's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)
@@ -212,5 +212,105 @@ module PerfectShape
 
       (angle >= 0.0) && (angle < ang_ext)
     end
+    
+    def intersect?(rectangle)
+      x = rectangle.x
+      y = rectangle.y
+      w = rectangle.width
+      h = rectangle.height
+      aw = self.width
+      ah = self.height
+
+      return false if w <= 0 || h <= 0 || aw <= 0 || ah <= 0
+      ext = self.extent
+      return false if ext == 0
+
+      ax  = self.x
+      ay  = self.y
+      axw = ax + aw
+      ayh = ay + ah
+      xw  = x + w
+      yh  = y + h
+
+      # check bbox
+      return false if x >= axw || y >= ayh || xw <= ax || yh <= ay
+
+      # extract necessary data
+      axc = self.center_x
+      ayc = self.center_y
+      sx, sy = self.start_point
+      ex, ey = self.end_point
+
+      # Try to catch rectangles that intersect arc in areas
+      # outside of rectagle with left top corner coordinates
+      # (min(center x, start point x, end point x),
+      #  min(center y, start point y, end point y))
+      # and rigth bottom corner coordinates
+      # (max(center x, start point x, end point x),
+      #  max(center y, start point y, end point y)).
+      # So we'll check axis segments outside of rectangle above.
+      if ayc >= y && ayc <= yh # 0 and 180
+        return true if (sx < xw && ex < xw && axc < xw &&
+             axw > x && contain_angle?(0)) ||
+            (sx > x && ex > x && axc > x &&
+             ax < xw && contain_angle?(180))
+      end
+      if axc >= x && axc <= xw # 90 and 270
+        return true if (sy > y && ey > y && ayc > y &&
+             ay < yh && contain_angle?(90)) ||
+            (sy < yh && ey < yh && ayc < yh &&
+             ayh > y && contain_angle?(270))
+      end
+
+      # For PIE we should check intersection with pie slices
+      # also we should do the same for arcs with extent is greater
+      # than 180, because we should cover case of rectangle, which
+      # situated between center of arc and chord, but does not
+      # intersect the chord.
+      rect = PerfectShape::Rectangle.new(x: x, y: y, width: w, height: h)
+      if type == :pie || ext.abs > 180
+        # for PIE: try to find intersections with pie slices
+        line1 = PerfectShape::Line.new(points: [[axc, ayc], [sx, sy]])
+        line2 = PerfectShape::Line.new(points: [[axc, ayc], [ex, ey]])
+        return true if line1.intersect?(rect) || line2.intersect?(rect)
+      else
+        # for CHORD and OPEN: try to find intersections with chord
+        line = PerfectShape::Line.new(points: [[sx, sy], [ex, ey]])
+        return true if line.intersect?(rect)
+      end
+
+      # finally check the rectangle corners inside the arc
+      return true if contain?(x, y) || contain?(x + w, y) ||
+                     contain?(x, y + h) || contain?(x + w, y + h)
+
+      false
+    end
+    
+    # Returns the starting point of the arc.  This point is the
+    # intersection of the ray from the center defined by the
+    # starting angle and the elliptical boundary of the arc.
+    #
+    # @return An (x,y) pair Array object representing the
+    # x,y coordinates of the starting point of the arc.
+    def start_point
+      angle = Math.degrees_to_radians(-self.start)
+      x = self.x + (Math.cos(angle) * 0.5 + 0.5) * self.width
+      y = self.y + (Math.sin(angle) * 0.5 + 0.5) * self.height
+      [x, y]
+    end
+
+    # Returns the ending point of the arc.  This point is the
+    # intersection of the ray from the center defined by the
+    # starting angle plus the angular extent of the arc and the
+    # elliptical boundary of the arc.
+    #
+    # @return An (x,y) pair Array object representing the
+    # x,y coordinates  of the ending point of the arc.
+    def end_point
+      angle = Math.degrees_to_radians(-self.start - self.extent)
+      x = self.x + (Math.cos(angle) * 0.5 + 0.5) * self.width
+      y = self.y + (Math.sin(angle) * 0.5 + 0.5) * self.height
+      [x, y]
+    end
   end
 end

data/lib/perfect_shape/cubic_bezier_curve.rb

@@ -82,8 +82,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the cubic bézier curve, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the cubic bézier curve, false if the point lies outside of the
     # cubic bézier curve's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)

data/lib/perfect_shape/ellipse.rb

@@ -59,8 +59,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the ellipse, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the ellipse, false if the point lies outside of the
     # ellipse's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       # This is implemented again even though super would have just worked to have an optimized algorithm for Ellipse.

data/lib/perfect_shape/line.rb

@@ -209,8 +209,8 @@ module PerfectShape
     # @param y The Y coordinate of the point to test.
     # @param distance_tolerance The distance from line to tolerate (0 by default)
     #
-    # @return {@code true} if the point lies within the bound of
-    # the line, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the line, false if the point lies outside of the
     # line's bounds.
     def contain?(x_or_point, y = nil, outline: true, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)

data/lib/perfect_shape/point.rb

@@ -80,8 +80,8 @@ module PerfectShape
     # @param y The Y coordinate of the point to test.
     # @param distance_tolerance The distance from point to tolerate (0 by default)
     #
-    # @return {@code true} if the point is close enough within distance tolerance,
-    # {@code false} if the point is too far.
+    # @return true if the point is close enough within distance tolerance,
+    # false if the point is too far.
     def contain?(x_or_point, y = nil, outline: true, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)
       return unless x && y

data/lib/perfect_shape/polygon.rb

@@ -34,8 +34,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the polygon, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the polygon, false if the point lies outside of the
     # polygon's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)

data/lib/perfect_shape/quadratic_bezier_curve.rb

@@ -94,22 +94,22 @@ module PerfectShape
         ]
       end
       
-      # Solves the quadratic whose coefficients are in the {@code eqn}
-      # array and places the non-complex roots into the {@code res}
+      # Solves the quadratic whose coefficients are in the eqn
+      # array and places the non-complex roots into the res
       # array, returning the number of roots.
       # The quadratic solved is represented by the equation:
       # <pre>
       #     eqn = {C, B, A}
       #     ax^2 + bx + c = 0
       # </pre>
-      # A return value of {@code -1} is used to distinguish a constant
+      # A return value of -1 is used to distinguish a constant
       # equation, which might be always 0 or never 0, from an equation that
       # has no zeroes.
       # @param eqn the specified array of coefficients to use to solve
       #        the quadratic equation
       # @param res the array that contains the non-complex roots
       #        resulting from the solution of the quadratic equation
-      # @return the number of roots, or {@code -1} if the equation is
+      # @return the number of roots, or -1 if the equation is
       #  a constant.
       def solve_quadratic(eqn, res)
         a = eqn[2]
@@ -187,8 +187,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the quadratic bézier curve, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the quadratic bézier curve, false if the point lies outside of the
     # quadratic bézier curve's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)

data/lib/perfect_shape/rectangle.rb

@@ -48,8 +48,8 @@ module PerfectShape
     # @param x The X coordinate of the point to test.
     # @param y The Y coordinate of the point to test.
     #
-    # @return {@code true} if the point lies within the bound of
-    # the rectangle, {@code false} if the point lies outside of the
+    # @return true if the point lies within the bound of
+    # the rectangle, false if the point lies outside of the
     # rectangle's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
       x, y = Point.normalize_point(x_or_point, y)

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.4 ruby lib
+# stub: perfect-shape 0.5.5 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.5.4"
+  s.version = "0.5.5"
 
   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-21"
+  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.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.4
+  version: 0.5.5
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer