perfect-shape 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f257899f946daccf27fa951ed4208ce8143d2060b24fcb6198ba0e8f738646
-  data.tar.gz: 1f9a0d7a1f210da0ee0e7b88514352b7d90c7893b05fe9b84145672989cd8eae
+  metadata.gz: ea11a066d120228aeb5889877909e17d93022e44e9c46899088bf97e52a328a6
+  data.tar.gz: 2d9f3031bd0edfa073d20c6c8f8d56541aa473ef92335f6606b88fbe0a9b39f4
 SHA512:
-  metadata.gz: 2af7d835fdaf126b8ebb630fbc08400aab9a7b464c5d18ad3f09035f142940bb1db1fbe4c0a2a1bc33bf4a773f2ce920fb34e36d57a191143020cdd36357b483
-  data.tar.gz: 693a20f1d100e70a8d429c8c02fddcfbdb0b2f2507cff92a0ddbc8c962db7758be5cee94df954ba5a89bba7619bdd9b2ee95b31b17896289e31d90a22d7eeb53
+  metadata.gz: 8025f51a536223a337d10b8a3b0bb9cd66aefe37543d24108aa002d719c4eb123a5b19d89b00157a85054bd614f92bdaf944562efbbecf14a93ab6d9c0a6481c
+  data.tar.gz: 06701161fbe42ec6afe1f19d9ece0db38d44db679702ea0db420fc260fa19526a2d2b4475c5aaa0d6f0500260ad48ad7267b4da1ec626153749d70175c50e523

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## 0.5.0
+
+- `Line#intersect?(rectangle)`
+- `Rectangle#out_state(x_or_point, y = nil)`
+
 ## 0.4.0
 
 - `PerfectShape::AffineTransform#new`

data/README.md

@@ -1,9 +1,9 @@
-# Perfect Shape 0.4.0
+# Perfect Shape 0.5.0
 ## 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 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 [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)).
 
 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.4.0
+gem install perfect-shape -v 0.5.0
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.4.0'
+gem 'perfect-shape', '~> 0.5.0'
 ```
 
 And, run:
@@ -220,6 +220,7 @@ Includes `PerfectShape::MultiPoint`
 - `#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: true, distance_tolerance: 0)`: checks if point lies on line, with a distance tolerance (0 by default). Distance tolerance provides a fuzz factor that for example enables GUI users to mouse-click-select a line shape more successfully. `outline` option makes no difference on line
+- `#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
 - `#relative_counterclockwise(x_or_point, y=nil)`: Returns an indicator of where the specified point (px,py) lies with respect to the line segment from (x1,y1) to (x2,y2). The return value can be either 1, -1, or 0 and indicates in which direction the specified line must pivot around its first end point, (x1,y1), in order to point at the specified point (px,py). A return value of 1 indicates that the line segment must turn in the direction that takes the positive X axis towards the negative Y axis. In the default coordinate system, this direction is counterclockwise. A return value of -1 indicates that the line segment must turn in the direction that takes the positive X axis towards the positive Y axis. In the default coordinate system, this direction is clockwise. A return value of 0 indicates that the point lies exactly on the line segment. Note that an indicator value of 0 is rare and not useful for determining collinearity because of floating point rounding issues. If the point is colinear with the line segment, but not between the end points, then the value will be -1 if the point lies “beyond (x1,y1)” or 1 if the point lies “beyond (x2,y2)”.
 - `#point_distance(x_or_point, y=nil)`: Returns the distance from a point to a line segment.
 
@@ -362,6 +363,7 @@ Includes `PerfectShape::RectangularShape`
 - `#==(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 rectangle shape from its outline more successfully
 - `#edges`: edges of rectangle as `PerfectShape::Line` objects
+- `#out_state(x_or_point, y = nil)`: Returns "out state" of specified point (x,y) (whether it lies to the left, right, top, bottom of rectangle). If point is outside rectangle, it returns a bit mask combination of `Rectangle::OUT_LEFT`, `Rectangle::OUT_RIGHT`, `Rectangle::OUT_TOP`, or `Rectangle::OUT_BOTTOM`. Otherwise, it returns `0` if point is inside the rectangle.
 
 Example:
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lib/perfect_shape/line.rb

@@ -22,6 +22,7 @@
 require 'perfect_shape/shape'
 require 'perfect_shape/point'
 require 'perfect_shape/multi_point'
+require 'perfect_shape/rectangle'
 
 module PerfectShape
   class Line < Shape
@@ -241,5 +242,29 @@ module PerfectShape
       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/rectangle.rb

@@ -28,6 +28,18 @@ module PerfectShape
   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)
     #
@@ -56,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/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.4.0 ruby lib
+# stub: perfect-shape 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.4.0"
+  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-16"
-  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, 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-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",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: equalizer
@@ -95,14 +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, 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).
+  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: []