perfect-shape 0.3.3 → 0.5.0

data/lib/perfect_shape/affine_transform.rb

@@ -0,0 +1,235 @@
+# Copyright (c) 2021-2022 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'perfect_shape/math'
+require 'perfect_shape/shape'
+require 'perfect_shape/point'
+require 'perfect_shape/multi_point'
+
+module PerfectShape
+  # Represents an affine transform
+  class AffineTransform
+    include Equalizer.new(:xxp, :xyp, :yxp, :yyp, :xt, :yt)
+  
+    attr_reader :xxp, :xyp, :yxp, :yyp, :xt, :yt
+    alias m11 xxp
+    alias m12 xyp
+    alias m21 yxp
+    alias m22 yyp
+    alias m13 xt
+    alias m23 yt
+  
+    # Creates a new AffineTransform with the following Matrix:
+    #
+    # [ xxp xyp xt ]
+    # [ yxp yyp yt ]
+    #
+    # The Matrix is used to transform (x,y) point coordinates as follows:
+    #
+    # [ xxp xyp xt ] * [x] = [ xxp * x + xyp * y + xt ]
+    # [ yxp yyp yt ] * [y] = [ yxp * x + yyp * y + yt ]
+    #
+    # xxp is the x coordinate x product (m11)
+    # xyp is the x coordinate y product (m12)
+    # yxp is the y coordinate x product (m21)
+    # yyp is the y coordinate y product (m22)
+    # xt is the x coordinate translation (m13)
+    # yt is the y coordinate translation (m23)
+    #
+    # The constructor accepts either the (x,y)-operation related argument/kwarg names
+    # or traditional Matrix element kwarg names
+    #
+    # Example with (x,y)-operation kwarg names:
+    #
+    # AffineTransform.new(xxp: 2, xyp: 3, yxp: 4, yyp: 5, xt: 6, yt: 7)
+    #
+    # Example with traditional Matrix element kwarg names:
+    #
+    # AffineTransform.new(m11: 2, m12: 3, m21: 4, m22: 5, m13: 6, m23: 7)
+    #
+    # Example with standard arguments:
+    #
+    # AffineTransform.new(2, 3, 4, 5, 6, 7)
+    #
+    # If no arguments are supplied, it constructs an identity matrix
+    # (i.e. like calling `::new(xxp: 1, xyp: 0, yxp: 0, yyp: 1, xt: 0, yt: 0)`)
+    def initialize(xxp_element = nil, xyp_element = nil, yxp_element = nil, yyp_element = nil, xt_element = nil, yt_element = nil,
+                   xxp: nil, xyp: nil, yxp: nil, yyp: nil, xt: nil, yt: nil,
+                   m11: nil, m12: nil, m21: nil, m22: nil, m13: nil, m23: nil)
+      self.xxp = xxp_element || xxp || m11 || 1
+      self.xyp = xyp_element || xyp || m12 || 0
+      self.yxp = yxp_element || yxp || m21 || 0
+      self.yyp = yyp_element || yyp || m22 || 1
+      self.xt  = xt_element  || xt  || m13 || 0
+      self.yt  = yt_element  || yt  || m23 || 0
+    end
+    
+    def xxp=(value)
+      @xxp = BigDecimal(value.to_s)
+    end
+    alias m11= xxp=
+    
+    def xyp=(value)
+      @xyp = BigDecimal(value.to_s)
+    end
+    alias m12= xyp=
+    
+    def yxp=(value)
+      @yxp = BigDecimal(value.to_s)
+    end
+    alias m21= yxp=
+    
+    def yyp=(value)
+      @yyp = BigDecimal(value.to_s)
+    end
+    alias m22= yyp=
+    
+    def xt=(value)
+      @xt = BigDecimal(value.to_s)
+    end
+    alias m13= xt=
+    
+    def yt=(value)
+      @yt = BigDecimal(value.to_s)
+    end
+    alias m23= yt=
+    
+    # Resets to identity matrix
+    # Returns self to support fluent interface chaining
+    def identity!
+      self.xxp = 1
+      self.xyp = 0
+      self.yxp = 0
+      self.yyp = 1
+      self.xt  = 0
+      self.yt  = 0
+      
+      self
+    end
+    alias reset! identity!
+
+    # Inverts AffineTransform matrix if invertible
+    # Raises an error if affine transform matrix is not invertible
+    # Returns self to support fluent interface chaining
+    def invert!
+      raise 'Cannot invert (matrix is not invertible)!' if !invertible?
+      
+      self.matrix_3d = matrix_3d.inverse
+      
+      self
+    end
+    
+    def invertible?
+      (m11 * m22 - m12 * m21) != 0
+    end
+    
+    # Multiplies by other AffineTransform
+    def multiply!(other_affine_transform)
+      self.matrix_3d = matrix_3d*other_affine_transform.matrix_3d
+      
+      self
+    end
+    
+    # Translates AffineTransform
+    def translate!(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
+      return unless x && y
+      
+      translation_affine_transform = AffineTransform.new(xxp: 1, xyp: 0, yxp: 0, yyp: 1, xt: x, yt: y)
+      multiply!(translation_affine_transform)
+      
+      self
+    end
+    
+    # Scales AffineTransform
+    def scale!(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
+      return unless x && y
+      
+      scale_affine_transform = AffineTransform.new(xxp: x, xyp: 0, yxp: 0, yyp: y, xt: 0, yt: 0)
+      multiply!(scale_affine_transform)
+      
+      self
+    end
+    
+    # Rotates AffineTransform counter-clockwise for positive angle value in degrees
+    # or clockwise for negative angle value in degrees
+    def rotate!(degrees)
+      degrees = Math.normalize_degrees(degrees)
+      radians = Math.degrees_to_radians(degrees)
+      
+      rotation_affine_transform = AffineTransform.new(xxp: Math.cos(radians), xyp: -Math.sin(radians), yxp: Math.sin(radians), yyp: Math.cos(radians), xt: 0, yt: 0)
+      multiply!(rotation_affine_transform)
+      
+      self
+    end
+    
+    # Shears AffineTransform by (x,y) amount
+    def shear!(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
+      return unless x && y
+      
+      shear_affine_transform = AffineTransform.new(xxp: 1 + x*y, xyp: x, yxp: y, yyp: 1, xt: 0, yt: 0)
+      multiply!(shear_affine_transform)
+      
+      self
+    end
+    alias skew! shear!
+    
+    # Sets elements from a Ruby Matrix representing Affine Transform matrix elements in 3D
+    def matrix_3d=(the_matrix_3d)
+      self.xxp = the_matrix_3d[0, 0]
+      self.xyp = the_matrix_3d[0, 1]
+      self.xt = the_matrix_3d[0, 2]
+      self.yxp = the_matrix_3d[1, 0]
+      self.yyp = the_matrix_3d[1, 1]
+      self.yt = the_matrix_3d[1, 2]
+    end
+    
+    # Returns Ruby Matrix representing Affine Transform matrix elements in 3D
+    def matrix_3d
+      Matrix[[xxp, xyp, xt], [yxp, yyp, yt], [0, 0, 1]]
+    end
+    
+    def transform_point(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
+      return unless x && y
+      
+      [xxp*x + xyp*y + xt, yxp*x + yyp*y + yt]
+    end
+    
+    def inverse_transform_point(x_or_point, y = nil)
+      clone.invert!.transform_point(x_or_point, y)
+    end
+    
+    def transform_points(*xy_coordinates_or_points)
+      points = xy_coordinates_or_points.first.is_a?(Array) ? xy_coordinates_or_points.first : xy_coordinates_or_points
+      points = MultiPoint.normalize_point_array(points)
+      points.map { |point| transform_point(point) }
+    end
+    
+    def inverse_transform_points(*xy_coordinates_or_points)
+      points = xy_coordinates_or_points.first.is_a?(Array) ? xy_coordinates_or_points.first : xy_coordinates_or_points
+      points = MultiPoint.normalize_point_array(points)
+      points.map { |point| inverse_transform_point(point) }
+    end
+  end
+end

data/lib/perfect_shape/arc.rb

@@ -21,10 +21,10 @@
 
 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/Arc2D.html
   class Arc < Shape
     include RectangularShape
     include Equalizer.new(:type, :x, :y, :width, :height, :start, :extent)
@@ -145,15 +145,15 @@ module PerfectShape
     # the arc, {@code 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 = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       if outline
         if type == :pie && x == center_x && y == center_y
           true
         else
           distance_tolerance = BigDecimal(distance_tolerance.to_s)
-          outside_inside_radius_difference = DEFAULT_OUTLINE_RADIUS + distance_tolerance * 2.0
-          outside_radius_difference = inside_radius_difference = outside_inside_radius_difference / 2.0
+          outside_inside_radius_difference = DEFAULT_OUTLINE_RADIUS + distance_tolerance * 2
+          outside_radius_difference = inside_radius_difference = outside_inside_radius_difference / 2
           outside_shape = Arc.new(type: type, center_x: center_x, center_y: center_y, radius_x: radius_x + outside_radius_difference, radius_y: radius_y + outside_radius_difference, start: start, extent: extent)
           inside_shape = Arc.new(type: type, center_x: center_x, center_y: center_y, radius_x: radius_x - inside_radius_difference, radius_y: radius_y - inside_radius_difference, start: start, extent: extent)
           outside_shape.contain?(x, y, outline: false) and

data/lib/perfect_shape/composite_shape.rb

@@ -63,10 +63,11 @@ module PerfectShape
     # @return true if the point lies within the bound of
     # the composite shape 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
-      shapes.any? {|shape| shape.contain?(x, y) }
+      
+      shapes.any? { |shape| shape.contain?(x, y, outline: outline, distance_tolerance: distance_tolerance) }
     end
   end
 end

data/lib/perfect_shape/cubic_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 CubicBezierCurve < Shape
     class << self
       # Calculates the number of times the cubic bézier curve from (x1,y1) to (x2,y2)
@@ -51,18 +51,18 @@ module PerfectShape
         end
         # double precision only has 52 bits of mantissa
         return PerfectShape::Line.point_crossings(x1, y1, x2, y2, px, py) if (level > 52)
-        xmid = BigDecimal((xc1 + xc2).to_s) / 2;
-        ymid = BigDecimal((yc1 + yc2).to_s) / 2;
-        xc1 = BigDecimal((x1 + xc1).to_s) / 2;
-        yc1 = BigDecimal((y1 + yc1).to_s) / 2;
-        xc2 = BigDecimal((xc2 + x2).to_s) / 2;
-        yc2 = BigDecimal((yc2 + y2).to_s) / 2;
-        xc1m = BigDecimal((xc1 + xmid).to_s) / 2;
-        yc1m = BigDecimal((yc1 + ymid).to_s) / 2;
-        xmc1 = BigDecimal((xmid + xc2).to_s) / 2;
-        ymc1 = BigDecimal((ymid + yc2).to_s) / 2;
-        xmid = BigDecimal((xc1m + xmc1).to_s) / 2;
-        ymid = BigDecimal((yc1m + ymc1).to_s) / 2;
+        xmid = BigDecimal((xc1 + xc2).to_s) / 2
+        ymid = BigDecimal((yc1 + yc2).to_s) / 2
+        xc1 = BigDecimal((x1 + xc1).to_s) / 2
+        yc1 = BigDecimal((y1 + yc1).to_s) / 2
+        xc2 = BigDecimal((xc2 + x2).to_s) / 2
+        yc2 = BigDecimal((yc2 + y2).to_s) / 2
+        xc1m = BigDecimal((xc1 + xmid).to_s) / 2
+        yc1m = BigDecimal((yc1 + ymid).to_s) / 2
+        xmc1 = BigDecimal((xmid + xc2).to_s) / 2
+        ymc1 = BigDecimal((ymid + yc2).to_s) / 2
+        xmid = BigDecimal((xc1m + xmc1).to_s) / 2
+        ymid = BigDecimal((yc1m + ymc1).to_s) / 2
         # [xy]mid are NaN if any of [xy]c0m or [xy]mc1 are NaN
         # [xy]c0m or [xy]mc1 are NaN if any of [xy][c][01] are NaN
         # These values are also NaN if opposing infinities are added
@@ -86,12 +86,13 @@ module PerfectShape
     # the cubic bézier curve, {@code 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 = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       
       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
         # Either x or y was infinite or NaN.
         # A NaN always produces a negative response to any test
@@ -105,7 +106,7 @@ module PerfectShape
         x2 = points[3][0]
         y2 = points[3][1]
         line = PerfectShape::Line.new(points: [[x1, y1], [x2, y2]])
-        crossings = line.point_crossings(x, y) + point_crossings(x, y);
+        crossings = line.point_crossings(x, y) + point_crossings(x, y)
         (crossings & 1) == 1
       end
     end
@@ -119,7 +120,7 @@ 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
       CubicBezierCurve.point_crossings(points[0][0], points[0][1], points[1][0], points[1][1], points[2][0], points[2][1], points[3][0], points[3][1], x, y, level)
     end
@@ -148,6 +149,7 @@ module PerfectShape
     # for level=1, 4 subdivisions for level=2, and 8 subdivisions for level=3)
     def subdivisions(level = 1)
       level -= 1 # consume 1 level
+      
       x1 = points[0][0]
       y1 = points[0][1]
       ctrlx1 = points[1][0]
@@ -156,22 +158,23 @@ module PerfectShape
       ctrly2 = points[2][1]
       x2 = points[3][0]
       y2 = points[3][1]
-      centerx = (ctrlx1 + ctrlx2) / 2.0
-      centery = (ctrly1 + ctrly2) / 2.0
-      ctrlx1 = (x1 + ctrlx1) / 2.0
-      ctrly1 = (y1 + ctrly1) / 2.0
-      ctrlx2 = (x2 + ctrlx2) / 2.0
-      ctrly2 = (y2 + ctrly2) / 2.0
-      ctrlx12 = (ctrlx1 + centerx) / 2.0
-      ctrly12 = (ctrly1 + centery) / 2.0
-      ctrlx21 = (ctrlx2 + centerx) / 2.0
-      ctrly21 = (ctrly2 + centery) / 2.0
-      centerx = (ctrlx12 + ctrlx21) / 2.0
-      centery = (ctrly12 + ctrly21) / 2.0
-      default_subdivisions = [
-        CubicBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerx, centery]),
-        CubicBezierCurve.new(points: [centerx, centery, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2])
-      ]
+      centerx = BigDecimal((ctrlx1 + ctrlx2).to_s) / 2
+      centery = BigDecimal((ctrly1 + ctrly2).to_s) / 2
+      ctrlx1 = BigDecimal((x1 + ctrlx1).to_s) / 2
+      ctrly1 = BigDecimal((y1 + ctrly1).to_s) / 2
+      ctrlx2 = BigDecimal((x2 + ctrlx2).to_s) / 2
+      ctrly2 = BigDecimal((y2 + ctrly2).to_s) / 2
+      ctrlx12 = BigDecimal((ctrlx1 + centerx).to_s) / 2
+      ctrly12 = BigDecimal((ctrly1 + centery).to_s) / 2
+      ctrlx21 = BigDecimal((ctrlx2 + centerx).to_s) / 2
+      ctrly21 = BigDecimal((ctrly2 + centery).to_s) / 2
+      centerx = BigDecimal((ctrlx12 + ctrlx21).to_s) / 2
+      centery = BigDecimal((ctrly12 + ctrly21).to_s) / 2
+      
+      first_curve = CubicBezierCurve.new(points: [x1, y1, ctrlx1, ctrly1, ctrlx12, ctrly12, centerx, centery])
+      second_curve = CubicBezierCurve.new(points: [centerx, centery, ctrlx21, ctrly21, ctrlx2, ctrly2, x2, y2])
+      default_subdivisions = [first_curve, second_curve]
+      
       if level == 0
         default_subdivisions
       else
@@ -179,8 +182,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)
@@ -189,8 +192,10 @@ module PerfectShape
       last_minimum_distance = minimum_distance + 1 # start bigger to ensure going through loop once at least
       while minimum_distance >= minimum_distance_threshold && minimum_distance < last_minimum_distance
         curve1, curve2 = current_curve.subdivisions
-        distance1 = point.point_distance(curve1.curve_center_point)
-        distance2 = point.point_distance(curve2.curve_center_point)
+        curve1_center_point = curve1.curve_center_point
+        distance1 = point.point_distance(curve1_center_point)
+        curve2_center_point = curve2.curve_center_point
+        distance2 = point.point_distance(curve2_center_point)
         last_minimum_distance = minimum_distance
         if distance1 < distance2
           minimum_distance = distance1

data/lib/perfect_shape/ellipse.rb

@@ -22,7 +22,6 @@
 require 'perfect_shape/arc'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Ellipse2D.html
   class Ellipse < Arc
     MESSAGE_CANNOT_UPDATE_ATTRIUBTE = "Ellipse %s cannot be updated. If you want to update type, use Arc instead!"
     
@@ -65,7 +64,7 @@ module PerfectShape
     # 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.
-      x, y = normalize_point(x_or_point, y)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
       if outline
         super(x, y, outline: true, distance_tolerance: distance_tolerance)

data/lib/perfect_shape/line.rb

@@ -20,10 +20,11 @@
 # 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'
+require 'perfect_shape/rectangle'
 
 module PerfectShape
-  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Line2D.html
   class Line < Shape
     class << self
       # Returns an indicator of where the specified point (px,py) lies with respect to the line segment from
@@ -104,7 +105,7 @@ module PerfectShape
       #           measured against the specified line segment
       # @return a double value that is the square of the distance from the
       #                  specified point to the specified line segment.
-      def point_segment_distance_square(x1, y1,
+      def point_distance_square(x1, y1,
                                        x2, y2,
                                        px, py)
         x1 = BigDecimal(x1.to_s)
@@ -177,10 +178,10 @@ module PerfectShape
       #           measured against the specified line segment
       # @return a double value that is the distance from the specified point
       #                          to the specified line segment.
-      def point_segment_distance(x1, y1,
+      def point_distance(x1, y1,
                                  x2, y2,
                                  px, py)
-        BigDecimal(::Math.sqrt(point_segment_distance_square(x1, y1, x2, y2, px, py)).to_s)
+        BigDecimal(::Math.sqrt(point_distance_square(x1, y1, x2, y2, px, py)).to_s)
       end
       
       # Calculates the number of times the line from (x1,y1) to (x2,y2)
@@ -212,21 +213,21 @@ module PerfectShape
     # @return {@code true} if the point lies within the bound of
     # the line, {@code false} if the point lies outside of the
     # line's bounds.
-    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_segment_distance(x, y) <= distance_tolerance
+      point_distance(x, y) <= distance_tolerance
     end
     
-    def point_segment_distance(x_or_point, y = nil)
-      x, y = normalize_point(x_or_point, y)
+    def point_distance(x_or_point, y = nil)
+      x, y = Point.normalize_point(x_or_point, y)
       return unless x && y
-      Line.point_segment_distance(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
+      Line.point_distance(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
     end
     
     def relative_counterclockwise(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
       Line.relative_counterclockwise(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
     end
@@ -237,9 +238,33 @@ module PerfectShape
     # +1 is returned for a crossing where the Y coordinate is increasing
     # -1 is returned for a crossing where the Y coordinate is decreasing
     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
       Line.point_crossings(points[0][0], points[0][1], points[1][0], points[1][1], x, y)
     end
+    
+    def intersect?(rectangle)
+      x1 = points[0][0]
+      y1 = points[0][1]
+      x2 = points[1][0]
+      y2 = points[1][1]
+      out1 = out2 = nil
+      return true if (out2 = rectangle.out_state(x2, y2)) == 0
+      while (out1 = rectangle.out_state(x1, y1)) != 0
+        return false if (out1 & out2) != 0
+        if (out1 & (Rectangle::OUT_LEFT | Rectangle::OUT_RIGHT)) != 0
+          x = rectangle.x
+          x += rectangle.width if (out1 & Rectangle::OUT_RIGHT) != 0
+          y1 = y1 + (x - x1) * (y2 - y1) / (x2 - x1)
+          x1 = x
+        else
+          y = rectangle.y
+          y += rectangle.height if (out1 & Rectangle::OUT_BOTTOM) != 0
+          x1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1)
+          y1 = y
+        end
+      end
+      true
+    end
   end
 end

data/lib/perfect_shape/multi_point.rb

@@ -24,6 +24,19 @@ require 'perfect_shape/shape'
 module PerfectShape
   # Represents multi-point shapes like Line, Polygon, and Polyline
   module MultiPoint
+    class << self
+      def normalize_point_array(the_points)
+        if the_points.all? {|the_point| the_point.is_a?(Array)}
+          the_points
+        else
+          the_points = the_points.flatten
+          xs = the_points.each_with_index.select {|n, i| i.even?}.map(&:first)
+          ys = the_points.each_with_index.select {|n, i| i.odd?}.map(&:first)
+          xs.zip(ys)
+        end
+      end
+    end
+  
     attr_reader :points
     
     def initialize(points: [])
@@ -32,12 +45,14 @@ module PerfectShape
     
     # Sets points, normalizing to an Array of Arrays of (x,y) pairs as BigDecimal
     def points=(the_points)
-      unless the_points.first.is_a?(Array)
-        xs = the_points.each_with_index.select {|n, i| i.even?}.map(&:first)
-        ys = the_points.each_with_index.select {|n, i| i.odd?}.map(&:first)
-        the_points = xs.zip(ys)
+      the_points = MultiPoint.normalize_point_array(the_points)
+      @points = the_points.map do |pair|
+        [
+          pair.first.is_a?(BigDecimal) ? pair.first : BigDecimal(pair.first.to_s),
+          pair.last.is_a?(BigDecimal) ? pair.last : BigDecimal(pair.last.to_s)
+        ]
       end
-      @points = the_points.map {|pair| [BigDecimal(pair.first.to_s), BigDecimal(pair.last.to_s)]}
+      @points
     end
     
     def min_x