perfect-shape 0.3.3 → 0.5.0

data/lib/perfect_shape/path.rb

@@ -27,7 +27,6 @@ require 'perfect_shape/cubic_bezier_curve'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Path2D.html
   class Path < Shape
     include MultiPoint
     include Equalizer.new(:shapes, :closed, :winding_rule)
@@ -114,21 +113,26 @@ module PerfectShape
     # @return true if the point lies within the bound of
     # the path or false if the point lies outside of the
     # path's bounds.
-    def contain?(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
-      if (x * 0.0 + y * 0.0) == 0.0
-        # N * 0.0 is 0.0 only if N is finite.
-        # Here we know that both x and y are finite.
-        return false if shapes.count < 2
-        mask = winding_rule == :wind_non_zero ? -1 : 1
-        (point_crossings(x, y) & mask) != 0
+      
+      if outline
+        disconnected_shapes.any? {|shape| shape.contain?(x, y, outline: true, distance_tolerance: distance_tolerance) }
       else
-        # Either x or y was infinite or NaN.
-        # A NaN always produces a negative response to any test
-        # and Infinity values cannot be "inside" any path so
-        # they should return false as well.
-        false
+        if (x * 0.0 + y * 0.0) == 0.0
+          # N * 0.0 is 0.0 only if N is finite.
+          # Here we know that both x and y are finite.
+          return false if shapes.count < 2
+          mask = winding_rule == :wind_non_zero ? -1 : 1
+          (point_crossings(x, y) & mask) != 0
+        else
+          # Either x or y was infinite or NaN.
+          # A NaN always produces a negative response to any test
+          # and Infinity values cannot be "inside" any path so
+          # they should return false as well.
+          false
+        end
       end
     end
     
@@ -144,7 +148,7 @@ module PerfectShape
     # The caller must check for NaN values.
     # The caller may also reject infinite values as well.
     def point_crossings(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       return 0 if shapes.count == 0
       movx = movy = curx = cury = endx = endy = 0
@@ -218,5 +222,50 @@ module PerfectShape
       end
       crossings
     end
+    
+    # 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
+    def disconnected_shapes
+      initial_point = start_point = @shapes.first.to_a.map {|n| BigDecimal(n.to_s)}
+      final_point = nil
+      the_disconnected_shapes = @shapes.drop(1).map do |shape|
+        case shape
+        when Point
+          disconnected_shape = Point.new(*shape.to_a)
+          start_point = shape.to_a
+          final_point = disconnected_shape.to_a
+          nil
+        when Array
+          disconnected_shape = Point.new(*shape.map {|n| BigDecimal(n.to_s)})
+          start_point = shape.map {|n| BigDecimal(n.to_s)}
+          final_point = disconnected_shape.to_a
+          nil
+        when Line
+          disconnected_shape = Line.new(points: [start_point.to_a, shape.points.last])
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        when QuadraticBezierCurve
+          disconnected_shape = QuadraticBezierCurve.new(points: [start_point.to_a] + shape.points)
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        when CubicBezierCurve
+          disconnected_shape = CubicBezierCurve.new(points: [start_point.to_a] + shape.points)
+          start_point = shape.points.last.to_a
+          final_point = disconnected_shape.points.last.to_a
+          disconnected_shape
+        end
+      end
+      the_disconnected_shapes << Line.new(points: [final_point, initial_point]) if closed?
+      the_disconnected_shapes.compact
+    end
   end
 end

data/lib/perfect_shape/point.rb

@@ -27,12 +27,27 @@ module PerfectShape
   class Point < Shape
     class << self
       def point_distance(x, y, px, py)
-        x = BigDecimal(x.to_s)
-        y = BigDecimal(y.to_s)
-        px = BigDecimal(px.to_s)
-        py = BigDecimal(py.to_s)
+        x = x.is_a?(BigDecimal) ? x : BigDecimal(x.to_s)
+        y = y.is_a?(BigDecimal) ? y : BigDecimal(y.to_s)
+        px = px.is_a?(BigDecimal) ? px : BigDecimal(px.to_s)
+        py = py.is_a?(BigDecimal) ? py : BigDecimal(py.to_s)
         BigDecimal(Math.sqrt((px - x)**2 + (py - y)**2).to_s)
       end
+      
+      # Normalizes point args whether two-number Array or x, y args returning
+      # normalized point array of two BigDecimal's
+      #
+      # @param x_or_point The point or X coordinate of the point to test.
+      # @param y The Y coordinate of the point to test.
+      #
+      # @return Array of x and y BigDecimal's representing point
+      def normalize_point(x_or_point, y = nil)
+        x = x_or_point
+        x, y = x if y.nil? && x_or_point.is_a?(Array) && x_or_point.size == 2
+        x = x.is_a?(BigDecimal) ? x : BigDecimal(x.to_s)
+        y = y.is_a?(BigDecimal) ? y : BigDecimal(y.to_s)
+        [x, y]
+      end
     end
     
     include PointLocation
@@ -67,16 +82,17 @@ module PerfectShape
     #
     # @return {@code true} if the point is close enough within distance tolerance,
     # {@code false} if the point is too far.
-    def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
-      x, y = normalize_point(x_or_point, y)
+    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
       distance_tolerance = BigDecimal(distance_tolerance.to_s)
       point_distance(x, y) <= distance_tolerance
     end
     
     def point_distance(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
+      
       Point.point_distance(self.x, self.y, x, y)
     end
     

data/lib/perfect_shape/polygon.rb

@@ -20,10 +20,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'perfect_shape/shape'
+require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/Polygon.html
   class Polygon < Shape
     include MultiPoint
     include Equalizer.new(:points)
@@ -38,7 +38,7 @@ module PerfectShape
     # the polygon, {@code 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 = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       if outline
         edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }

data/lib/perfect_shape/quadratic_bezier_curve.rb

@@ -20,10 +20,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'perfect_shape/shape'
+require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/QuadCurve2D.html
   class QuadraticBezierCurve < Shape
     class << self
       # Calculates the number of times the quadratic bézier curve from (x1,y1) to (x2,y2)
@@ -80,7 +80,7 @@ module PerfectShape
     # the quadratic bézier curve, {@code false} if the point lies outside of the
     # quadratic bézier curve's bounds.
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
 
       x1 = points[0][0]
@@ -91,8 +91,9 @@ module PerfectShape
       y2 = points[2][1]
       
       if outline
+        distance_tolerance = BigDecimal(distance_tolerance.to_s)
         minimum_distance_threshold = OUTLINE_MINIMUM_DISTANCE_THRESHOLD + distance_tolerance
-        point_segment_distance(x, y, minimum_distance_threshold: minimum_distance_threshold) < minimum_distance_threshold
+        point_distance(x, y, minimum_distance_threshold: minimum_distance_threshold) < minimum_distance_threshold
       else
         # We have a convex shape bounded by quad curve Pc(t)
         # and ine Pl(t).
@@ -189,13 +190,13 @@ module PerfectShape
     # +1 is added for each crossing where the Y coordinate is increasing
     # -1 is added for each crossing where the Y coordinate is decreasing
     def point_crossings(x_or_point, y = nil, level = 0)
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       QuadraticBezierCurve.point_crossings(points[0][0], points[0][1], points[1][0], points[1][1], points[2][0], points[2][1], x, y, level)
     end
     
-    
     # The center point on the outline of the curve
+    # in Array format as pair of (x, y) coordinates
     def curve_center_point
       subdivisions.last.points[0]
     end
@@ -226,12 +227,12 @@ module PerfectShape
       ctrly = points[1][1]
       x2 = points[2][0]
       y2 = points[2][1]
-      ctrlx1 = (x1 + ctrlx) / 2.0
-      ctrly1 = (y1 + ctrly) / 2.0
-      ctrlx2 = (x2 + ctrlx) / 2.0
-      ctrly2 = (y2 + ctrly) / 2.0
-      centerx = (ctrlx1 + ctrlx2) / 2.0
-      centery = (ctrly1 + ctrly2) / 2.0
+      ctrlx1 = BigDecimal((x1 + ctrlx).to_s) / 2
+      ctrly1 = BigDecimal((y1 + ctrly).to_s) / 2
+      ctrlx2 = BigDecimal((x2 + ctrlx).to_s) / 2
+      ctrly2 = BigDecimal((y2 + ctrly).to_s) / 2
+      centerx = BigDecimal((ctrlx1 + ctrlx2).to_s) / 2
+      centery = BigDecimal((ctrly1 + ctrly2).to_s) / 2
       
       default_subdivisions = [
         QuadraticBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, centerx, centery]),
@@ -245,8 +246,8 @@ module PerfectShape
       end
     end
     
-    def point_segment_distance(x_or_point, y = nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)
-      x, y = normalize_point(x_or_point, y)
+    def point_distance(x_or_point, y = nil, minimum_distance_threshold: OUTLINE_MINIMUM_DISTANCE_THRESHOLD)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       
       point = Point.new(x, y)

data/lib/perfect_shape/rectangle.rb

@@ -21,13 +21,25 @@
 
 require 'perfect_shape/shape'
 require 'perfect_shape/rectangular_shape'
+require 'perfect_shape/point'
 require 'perfect_shape/line'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Rectangle2D.html
   class Rectangle < Shape
     include RectangularShape
     include Equalizer.new(:x, :y, :width, :height)
+    
+    # bitmask indicating a point lies to the left
+    OUT_LEFT = 1
+
+    # bitmask indicating a point lies above
+    OUT_TOP = 2
+
+    # bitmask indicating a point lies to the right
+    OUT_RIGHT = 4
+
+    # bitmask indicating a point lies below
+    OUT_BOTTOM = 8
         
     # Checks if rectangle contains point (two-number Array or x, y args)
     #
@@ -38,8 +50,9 @@ module PerfectShape
     # the rectangle, {@code 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 = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
+      
       if outline
         edges.any? { |edge| edge.contain?(x, y, distance_tolerance: distance_tolerance) }
       else
@@ -55,5 +68,32 @@ module PerfectShape
         Line.new(points: [[self.x, self.y + height], [self.x, self.y]])
       ]
     end
+    
+    # Returns out state for specified point (x,y): (left, right, top, bottom)
+    #
+    # It can be 0 meaning not outside the rectangle,
+    # or if outside the rectangle, then a bit mask
+    # combination of OUT_LEFT, OUT_RIGHT, OUT_TOP, or OUT_BOTTOM
+    def out_state(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
+      return unless x && y
+      
+      out = 0
+      if self.width <= 0
+          out |= OUT_LEFT | OUT_RIGHT
+      elsif x < self.x
+          out |= OUT_LEFT
+      elsif x > self.x + self.width
+          out |= OUT_RIGHT
+      end
+      if self.height <= 0
+          out |= OUT_TOP | OUT_BOTTOM
+      elsif y < self.y
+          out |= OUT_TOP
+      elsif y > self.y + self.height
+          out |= OUT_BOTTOM
+      end
+      out
+    end
   end
 end

data/lib/perfect_shape/shape.rb

@@ -51,6 +51,12 @@ module PerfectShape
       max_y - min_y if max_y && min_y
     end
     
+    # Center point is `[center_x, center_y]`
+    # Returns `nil` if either center_x or center_y are `nil`
+    def center_point
+      [center_x, center_y] unless center_x.nil? || center_y.nil?
+    end
+    
     # center_x is min_x + width/2.0 by default
     # Returns nil if min_x or width are nil
     def center_x
@@ -69,21 +75,6 @@ module PerfectShape
       Rectangle.new(x: min_x, y: min_y, width: width, height: height)
     end
   
-    # Normalizes point args whether two-number Array or x, y args returning
-    # normalized point array of two BigDecimal's
-    #
-    # @param x_or_point The point or X coordinate of the point to test.
-    # @param y The Y coordinate of the point to test.
-    #
-    # @return Array of x and y BigDecimal's representing point
-    def normalize_point(x_or_point, y = nil)
-      x = x_or_point
-      x, y = x if y.nil? && x_or_point.is_a?(Array) && x_or_point.size == 2
-      x = BigDecimal(x.to_s)
-      y = BigDecimal(y.to_s)
-      [x, y]
-    end
-    
     # Subclasses must implement
     def contain?(x_or_point, y = nil, outline: false, distance_tolerance: 0)
     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.3.3 ruby lib
+# stub: perfect-shape 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.3.3"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Andy Maleh".freeze]
-  s.date = "2022-01-10"
-  s.description = "Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking containment of a mouse click point in popular geometry shapes such as rectangle, square, arc (open, chord, and pie), ellipse, circle, polygon, and paths containing lines, quadratic b\u00E9zier curves, and cubic bezier curves (including both Ray Casting Algorithm, aka Even-odd Rule, and Winding Number Algorithm, aka Nonzero Rule). Additionally, it contains some purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).".freeze
+  s.date = "2022-01-18"
+  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 = [
     "CHANGELOG.md",
@@ -25,6 +25,7 @@ Gem::Specification.new do |s|
     "README.md",
     "VERSION",
     "lib/perfect-shape.rb",
+    "lib/perfect_shape/affine_transform.rb",
     "lib/perfect_shape/arc.rb",
     "lib/perfect_shape/circle.rb",
     "lib/perfect_shape/composite_shape.rb",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-10 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer
@@ -95,12 +95,14 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Perfect Shape is a collection of pure Ruby geometric algorithms that
-  are mostly useful for GUI manipulation like checking containment of a mouse click
-  point in popular geometry shapes such as rectangle, square, arc (open, chord, and
-  pie), ellipse, circle, polygon, and paths containing lines, quadratic bézier curves,
-  and cubic bezier curves (including both Ray Casting Algorithm, aka Even-odd Rule,
-  and Winding Number Algorithm, aka Nonzero Rule). Additionally, it contains some
-  purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).
+  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é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).
 email: andy.am@gmail.com
 executables: []
 extensions: []
@@ -114,6 +116,7 @@ files:
 - README.md
 - VERSION
 - lib/perfect-shape.rb
+- lib/perfect_shape/affine_transform.rb
 - lib/perfect_shape/arc.rb
 - lib/perfect_shape/circle.rb
 - lib/perfect_shape/composite_shape.rb