perfect-shape 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00c1add66582b68b1c6ec2d15b91c9af7840daf97b7e40662210683690d1a082
+  data.tar.gz: 2b789617e71a321cd7b736abfcfd59d7c46dbbf91fa0b4e2e5f581704e28527a
+SHA512:
+  metadata.gz: 6c7b3efef675a42f6d33aae8d2d208e7224c44f9d8e64064dc9f18b0a3594b4cf2b3addb360376e5837f9478c5e61b18d85b989a16c122ed1d762f88c849075a
+  data.tar.gz: 6b87d053a77eab1900c67ffb1a5800a878f9f06de7e9713d72f9ecedf5fc6e463e2cb885d1f6e1cfd7eca9eeb08b1321e6e97009564d6c4082a7a542db2d8ea2

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.ruby-gemset

@@ -0,0 +1 @@
+perfect-shape

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.0.2

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Change Log
+
+## 0.0.1
+
+- `PerfectShape::Math`
+- `PerfectShape::Math::ieee_remainder` (alias: `ieee754_remainder`)
+- `PerfectShape::Math::degrees_to_radians(angle)`
+- `PerfectShape::Math::radians_to_degrees(angle)`
+- `PerfectShape::Line`
+- `PerfectShape::Line::relative_ccw(x1, y1, x2, y2, px, py)`
+- `PerfectShape::Arc`
+- `PerfectShape::Arc#contain?(x_or_point, y=nil)`

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rdoc", "~> 3.12"
+  gem "juwelier", "~> 2.1.0"
+  gem 'minitest', '~> 5.14.4'
+  gem 'puts_debuggerer', '~> 0.13.1'
+  gem 'rake-tui', '> 0'
+end

data/Gemfile.lock

@@ -0,0 +1,102 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    awesome_print (1.9.2)
+    builder (3.2.4)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    faraday (1.8.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0.1)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      multipart-post (>= 1.2, < 3)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    git (1.9.1)
+      rchardet (~> 1.8)
+    github_api (0.19.0)
+      addressable (~> 2.4)
+      descendants_tracker (~> 0.0.4)
+      faraday (>= 0.8, < 2)
+      hashie (~> 3.5, >= 3.5.2)
+      oauth2 (~> 1.0)
+    hashie (3.6.0)
+    highline (2.0.3)
+    json (1.8.6)
+    juwelier (2.1.3)
+      builder
+      bundler (>= 1.13)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+      semver
+    jwt (2.3.0)
+    minitest (5.14.4)
+    multi_json (1.15.0)
+    multi_xml (0.6.0)
+    multipart-post (2.1.1)
+    nokogiri (1.12.5-x86_64-darwin)
+      racc (~> 1.4)
+    oauth2 (1.4.7)
+      faraday (>= 0.8, < 2.0)
+      jwt (>= 1.0, < 3.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    pastel (0.8.0)
+      tty-color (~> 0.5)
+    public_suffix (4.0.6)
+    puts_debuggerer (0.13.1)
+      awesome_print (~> 1.9.2)
+    racc (1.6.0)
+    rack (2.2.3)
+    rake (13.0.6)
+    rake-tui (0.2.3)
+      tty-prompt
+    rchardet (1.8.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    ruby2_keywords (0.0.5)
+    semver (1.0.1)
+    thread_safe (0.3.6)
+    tty-color (0.6.0)
+    tty-cursor (0.7.1)
+    tty-prompt (0.23.1)
+      pastel (~> 0.8)
+      tty-reader (~> 0.8)
+    tty-reader (0.9.0)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      wisper (~> 2.0)
+    tty-screen (0.8.1)
+    wisper (2.0.1)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  juwelier (~> 2.1.0)
+  minitest (~> 5.14.4)
+  puts_debuggerer (~> 0.13.1)
+  rake-tui (> 0)
+  rdoc (~> 3.12)
+
+BUNDLED WITH
+   2.2.31

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2021 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.

data/README.md

@@ -0,0 +1,82 @@
+# Perfect Shape 0.0.1
+## Geometric Algorithms
+
+`PerfectShape` is a collection of pure Ruby geometric algorithms that are mostly useful for GUI (Graphical User Interface) manipulation like checking containment of a point in popular geometric shapes such as rectangle, square, arc, circle, polygon, polyline, and paths containing lines, bezier curves, and quadratic curves.
+
+Additionally, `PerfectShape::Math` contains some purely mathematical algorithms.
+
+To ensure high accuracy, this library does all its mathematical operations with `BigDecimal` numbers.
+
+## Setup
+
+Run:
+
+```
+gem install perfect-shape -v 0.0.1
+```
+
+Or include in Bundler `Gemfile`:
+
+```ruby
+gem 'perfect-shape', '~> 0.0.1'
+```
+
+And, run:
+
+```
+bundle
+```
+
+## API
+
+### `PerfectShape::Math`
+
+- `::degrees_to_radians(angle)`
+- `::radians_to_degrees(angle)`
+- `::ieee_remainder(x, y)` (alias: `ieee754_remainder`)
+
+### `PerfectShape::Line`
+
+- `::relative_ccw(x1, y1, x2, y2, px, py)`: Returns an indicator of where the specified point px,py lies with respect to the line segment from x1,y1 to x2,y2
+
+### `PerfectShape::Arc`
+
+- `::new(type: :open, x: 0, y: 0, width: 1, height: 1, start: 0, extent: 360)`: constructs an arc of type  `:open` (default), `:chord`, or `:pie`
+- `#x`: top-left x of arc
+- `#y`: top-left y of arc
+- `#width`: width of arc
+- `#height`: height of arc
+- `#start`: start angle in degrees
+- `#extent`: extent angle in degrees
+- `#contain?(x_or_point, y=0)`: checks if point is in arc
+
+## TODO
+
+[TODO.md](TODO.md)
+
+## Change Log
+
+[CHANGELOG.md](CHANGELOG.md)
+
+## Contributing to perfect-shape
+
+-   Check out the latest master to make sure the feature hasn't been
+    implemented or the bug hasn't been fixed yet.
+-   Check out the issue tracker to make sure someone already hasn't
+    requested it and/or contributed it.
+-   Fork the project.
+-   Start a feature/bugfix branch.
+-   Commit and push until you are happy with your contribution.
+-   Make sure to add tests for it. This is important so I don't break it
+    in a future version unintentionally.
+-   Please try not to mess with the Rakefile, version, or history. If
+    you want to have your own version, or is otherwise necessary, that
+    is fine, but please isolate to its own commit so I can cherry-pick
+    around it.
+
+## Copyright
+
+[MIT](LICENSE.txt)
+
+Copyright (c) 2021 Andy Maleh. See
+[LICENSE.txt](LICENSE.txt) for further details.

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "perfect-shape"
+  gem.homepage = "http://github.com/AndyObtiva/perfect-shape"
+  gem.license = "MIT"
+  gem.summary = %Q{Perfect Shape - Geometric Algorithms}
+  gem.description = %Q{Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking containment of a point in popular geometric shapes such as rectangle, square, arc, circle, polygon, polyline, and paths containing lines, bezier curves, and quadratic curves. Additionally, it contains some purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).}
+  gem.email = "andy.am@gmail.com"
+  gem.authors = ["Andy Maleh"]
+
+  # dependencies defined in Gemfile
+end
+Juwelier::RubygemsDotOrgTasks.new
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "perfect-shape #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO.md

@@ -0,0 +1,31 @@
+# TODO
+
+## Geometry
+
+Mostly inspired by java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/package-summary.html
+
+- Polygon
+- CubicCurve
+- QuadCurve
+- Line
+- Path: flexible shape which represents an arbitrary geometric path
+- GeneralPath: represents a geometric path constructed from straight lines, and quadratic and cubic (Bézier) curves. It can contain multiple subpaths.
+- Rectangle
+- RoundRectangle
+- Point
+- Ellipse
+- Polybezier
+- Polyline
+- Area: aggregate of multiple shapes
+- AffineTransform: represents a 2D affine transform that performs a linear mapping from 2D coordinates to other 2D coordinates that preserves the "straightness" and "parallelness" of lines.
+
+## Miscellaneous
+
+- Include screenshots of the supported shapes in README
+
+## Maybe
+
+- Consider the idea of having tests run in JRuby and check against java.awt.geom and compare result with perfect-shape
+- Consider contributing IEEEremainder to Ruby
+- Contribute this type of expectation: _(arc).must_be :contain?, *point to Minitest Expectations
+- Maybe contribute xit to minitest expectations

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/perfect-shape.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2021 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 'bigdecimal'
+
+# Perfect Shape algorithms are mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/package-summary.html
+module PerfectShape
+end
+
+Dir[File.expand_path('./perfect_shape/*.rb', __dir__)].each {|f| require f}

data/lib/perfect_shape/arc.rb

@@ -0,0 +1,142 @@
+# Copyright (c) 2021 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_relative 'line'
+
+module PerfectShape
+  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Arc2D.html
+  class Arc
+    TYPES = [:open, :chord, :pie]
+    attr_accessor :type, :x, :y, :width, :height, :start, :extent
+    
+    def initialize(type: :open, x: 0, y: 0, width: 1, height: 1, start: 0, extent: 360)
+      @type = type
+      self.x = x
+      self.y = y
+      self.width = width
+      self.height = height
+      self.start = start
+      self.extent = extent
+    end
+    
+    def x=(value)
+      @x = BigDecimal(value.to_s)
+    end
+    
+    def y=(value)
+      @y = BigDecimal(value.to_s)
+    end
+    
+    def width=(value)
+      @width = BigDecimal(value.to_s)
+    end
+    
+    def height=(value)
+      @height = BigDecimal(value.to_s)
+    end
+    
+    def start=(value)
+      @start = BigDecimal(value.to_s)
+    end
+    
+    def extent=(value)
+      @extent = BigDecimal(value.to_s)
+    end
+    
+    # Checks if arc contains point denoted by point (two-number Array or x, y args)
+    def contain?(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)
+      return unless x && y
+      # Normalize the coordinates compared to the ellipse
+      # having a center at 0,0 and a radius of 0.5.
+      ellw = width
+      return false if (ellw <= 0.0)
+      normx = (x - self.x) / ellw - 0.5
+      ellh = height
+      return false if (ellh <= 0.0)
+      normy = (y - self.y) / ellh - 0.5
+      dist_sq = (normx * normx) + (normy * normy)
+      return false if (dist_sq >= 0.25)
+      ang_ext = self.extent.abs
+      return true if (ang_ext >= 360.0)
+      inarc = contain_angle?(-1*Math.radians_to_degrees(Math.atan2(normy, normx)))
+      
+      return inarc if type == :pie
+      # CHORD and OPEN behave the same way
+      if inarc
+        return true if ang_ext >= 180.0
+        # point must be outside the "pie triangle"
+      else
+        return false if ang_ext <= 180.0
+        # point must be inside the "pie triangle"
+      end
+      
+      # The point is inside the pie triangle iff it is on the same
+      # side of the line connecting the ends of the arc as the center.
+      angle = Math.degrees_to_radians(-start)
+      x1 = Math.cos(angle)
+      y1 = Math.sin(angle)
+      angle += Math.degrees_to_radians(-extent)
+      x2 = Math.cos(angle)
+      y2 = Math.sin(angle)
+      inside = (Line.relative_ccw(x1, y1, x2, y2, 2*normx, 2*normy) *
+                        Line.relative_ccw(x1, y1, x2, y2, 0, 0) >= 0)
+      inarc ? !inside : inside
+    end
+    
+    def contain_angle?(angle)
+      ang_ext = self.extent
+      backwards = ang_ext < 0.0
+      ang_ext = -ang_ext if backwards
+      return true if ang_ext >= 360.0
+
+      angle = normalize_degrees(angle) - normalize_degrees(start)
+      angle = -angle if backwards
+      angle += 360.0 if angle < 0.0
+
+      (angle >= 0.0) && (angle < ang_ext)
+    end
+    
+    def normalize_degrees(angle)
+      if angle > 180.0
+        if angle <= (180.0 + 360.0)
+          angle = angle - 360.0
+        else
+          angle = Math.ieee_remainder(angle, 360.0)
+          # IEEEremainder can return -180 here for some input values...
+          angle = 180.0 if angle == -180.0
+        end
+      elsif angle <= -180.0
+        if angle > (-180.0 - 360.0)
+          angle = angle + 360.0
+        else
+          angle = Math.ieee_remainder(angle, 360.0)
+          # IEEEremainder can return -180 here for some input values...
+          angle = 180.0 if angle == -180.0
+        end
+      end
+      angle
+    end
+  end
+end

data/lib/perfect_shape/line.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2021 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.
+
+module PerfectShape
+  # Mostly ported from java.awt.geom: https://docs.oracle.com/javase/8/docs/api/java/awt/geom/Line2D.html
+  class Line
+    class << self
+      # Returns an indicator of where the specified point
+      # {@code (px,py)} lies with respect to the line segment from
+      # {@code (x1,y1)} to {@code (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, {@code (x1,y1)}, in order to point at the
+      # specified point {@code (px,py)}.
+      # <p>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 used by
+      # Java 2D, this direction is counterclockwise.
+      # <p>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.
+      # <p>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.
+      # <p>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 {@code (x1,y1)}" or 1 if the point lies
+      # "beyond {@code (x2,y2)}".
+      #
+      # @param x1 the X coordinate of the start point of the
+      #           specified line segment
+      # @param y1 the Y coordinate of the start point of the
+      #           specified line segment
+      # @param x2 the X coordinate of the end point of the
+      #           specified line segment
+      # @param y2 the Y coordinate of the end point of the
+      #           specified line segment
+      # @param px the X coordinate of the specified point to be
+      #           compared with the specified line segment
+      # @param py the Y coordinate of the specified point to be
+      #           compared with the specified line segment
+      # @return an integer that indicates the position of the third specified
+      #                  coordinates with respect to the line segment formed
+      #                  by the first two specified coordinates.
+      # @since 1.2
+      def relative_ccw(x1, y1, x2, y2, px, py)
+        x2 -= x1;
+        y2 -= y1;
+        px -= x1;
+        py -= y1;
+        ccw = px * y2 - py * x2;
+        if ccw == 0.0
+          # The point is colinear, classify based on which side of
+          # the segment the point falls on.  We can calculate a
+          # relative value using the projection of px,py onto the
+          # segment - a negative value indicates the point projects
+          # outside of the segment in the direction of the particular
+          # endpoint used as the origin for the projection.
+          ccw = px * x2 + py * y2;
+          if ccw > 0.0
+            # Reverse the projection to be relative to the original x2,y2
+            # x2 and y2 are simply negated.
+            # px and py need to have (x2 - x1) or (y2 - y1) subtracted
+            #    from them (based on the original values)
+            # Since we really want to get a positive answer when the
+            #    point is "beyond (x2,y2)", then we want to calculate
+            #    the inverse anyway - thus we leave x2 & y2 negated.
+            px -= x2;
+            py -= y2;
+            ccw = px * x2 + py * y2;
+            ccw = 0.0 if ccw < 0.0
+          end
+        end
+        (ccw < 0.0) ? -1 : ((ccw > 0.0) ? 1 : 0);
+      end
+    end
+  end
+end

data/lib/perfect_shape/math.rb

@@ -0,0 +1,63 @@
+module PerfectShape
+  # Perfect Shape Math utility methods
+  # Mostly ported from java.lang.Math: https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html
+  # Also includes standard Ruby ::Math utility methods
+  module Math
+    class << self
+      # converts angle from radians to degrees
+      def radians_to_degrees(radians)
+        (180/Math::PI)*radians
+      end
+
+      # converts angle from degrees to radians
+      def degrees_to_radians(degrees)
+        (Math::PI/180)*degrees
+      end
+
+      # Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.
+      # Algorithm: x – (round(x/y)*y).
+      # The `round` part rounds to the nearest even number when it is a halfway between n & y (integer + 0.5 number)
+      # The remainder value is mathematically equal to x - y × n, where n is the mathematical integer closest to the exact mathematical value of the quotient x/y, and if two mathematical integers are equally close to x/y, then n is the integer that is even. If the remainder is zero, its sign is the same as the sign of the first argument. Special cases:
+      # If either argument is NaN, or the first argument is infinite, or the second argument is positive zero or negative zero, then the result is NaN.
+      # If the first argument is finite and the second argument is infinite, then the result is the same as the first argument.
+      # Parameters:
+      # x - the dividend.
+      # y - the divisor.
+      # Returns:
+      # the remainder when x is divided by y.
+      def ieee754_remainder(x, y)
+        x = BigDecimal(x.to_s)
+        y = BigDecimal(y.to_s)
+        return BigDecimal::NAN if x.nan? || y.nan? || x.infinite? || y.zero?
+        return x if x.finite? && y.infinite?
+        division = x / y
+        rounded_division_low = BigDecimal(division.floor)
+        rounded_division_high = BigDecimal(division.ceil)
+        rounded_division_half = rounded_division_low + 0.5
+        rounded_division = if division == rounded_division_half
+          rounded_division_low.to_i.even? ? rounded_division_low : rounded_division_high
+        else
+          BigDecimal(division.round)
+        end
+        (x - (rounded_division * y))
+      end
+      alias ieee_remainder ieee754_remainder
+      
+      def respond_to?(method_name, include_private = false)
+        super || ::Math.respond_to?(method_name, include_private)
+      end
+      
+      def method_missing(method_name, *args, **kwargs, &block)
+        if ::Math.respond_to?(method_name, true)
+          ::Math.send(method_name, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+      
+      def const_missing(constant)
+        ::Math::const_get(constant)
+      end
+    end
+  end
+end

data/perfect-shape.gemspec

@@ -0,0 +1,65 @@
+# Generated by juwelier
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: perfect-shape 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "perfect-shape".freeze
+  s.version = "0.0.1"
+
+  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 = "2021-12-06"
+  s.description = "Perfect Shape is a collection of pure Ruby geometric algorithms that are mostly useful for GUI manipulation like checking containment of a point in popular geometric shapes such as rectangle, square, arc, circle, polygon, polyline, and paths containing lines, bezier curves, and quadratic curves. 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",
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".ruby-gemset",
+    ".ruby-version",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "TODO.md",
+    "VERSION",
+    "lib/perfect-shape.rb",
+    "lib/perfect_shape/arc.rb",
+    "lib/perfect_shape/line.rb",
+    "lib/perfect_shape/math.rb",
+    "perfect-shape.gemspec",
+    "test/lib/perfect_shape/test_arc.rb",
+    "test/lib/perfect_shape/test_math.rb"
+  ]
+  s.homepage = "http://github.com/AndyObtiva/perfect-shape".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "3.2.31".freeze
+  s.summary = "Perfect Shape - Geometric Algorithms".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_development_dependency(%q<minitest>.freeze, ["~> 5.14.4"])
+    s.add_development_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13.1"])
+    s.add_development_dependency(%q<rake-tui>.freeze, ["> 0"])
+  else
+    s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_dependency(%q<minitest>.freeze, ["~> 5.14.4"])
+    s.add_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13.1"])
+    s.add_dependency(%q<rake-tui>.freeze, ["> 0"])
+  end
+end
+

data/test/lib/perfect_shape/test_arc.rb

@@ -0,0 +1,184 @@
+require 'puts_debuggerer'
+require 'minitest/autorun'
+
+require_relative '../../../lib/perfect-shape'
+
+describe PerfectShape do
+  describe PerfectShape::Arc do
+    it 'constructs with chord type and dimensions' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50, height: 60, start: 30, extent: 90)
+
+      _(arc.type).must_equal :chord
+      _(arc.y).must_equal 3
+      _(arc.y).must_equal 3
+      _(arc.width).must_equal 50
+      _(arc.height).must_equal 60
+      _(arc.start).must_equal 30
+      _(arc.extent).must_equal 90
+    end
+
+    it 'constructs with open type defaults' do
+      arc = PerfectShape::Arc.new
+
+      _(arc.type).must_equal :open
+      _(arc.x).must_equal 0
+      _(arc.y).must_equal 0
+      _(arc.width).must_equal 1
+      _(arc.height).must_equal 1
+      _(arc.start).must_equal 0
+      _(arc.extent).must_equal 360
+    end
+
+    it 'updates attributes' do
+      arc = PerfectShape::Arc.new
+      arc.type = :chord
+      arc.x = 2
+      arc.y = 3
+      arc.width = 50
+      arc.height = 60
+      arc.start = 30
+      arc.extent = 90
+
+      _(arc.type).must_equal :chord
+      _(arc.y).must_equal 3
+      _(arc.y).must_equal 3
+      _(arc.width).must_equal 50
+      _(arc.height).must_equal 60
+      _(arc.start).must_equal 30
+      _(arc.extent).must_equal 90
+    end
+
+    it 'contains point with chord type circle' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'contains point with chord type arc' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50.5, height: 60.75, start: 45, extent: 270)
+      point = [arc.x + arc.width*3/4.0, arc.y + (arc.height / 2.0)]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+    
+    it 'does not contain point within bounding box with chord type arc' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 67, height: 46, start: 45, extent: 270)
+      point = [arc.x + arc.width*(3.9/4.0), arc.y + (arc.height / 2.0)]
+      
+      _(arc.contain?(point)).must_equal false
+    end
+    
+    it 'does not contain point in center of chord type arc' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 145)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point within bounding box with chord type circle' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [3.0, 4.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point outside bounding box with chord type circle' do
+      arc = PerfectShape::Arc.new(type: :chord, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [1.0, 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'contains point with open type circle' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'contains point with open type arc' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 50.5, height: 60.75, start: 45, extent: 270)
+      point = [arc.x + arc.width*3/4.0, arc.y + (arc.height / 2.0)]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'does not contain point within bounding box with open type arc' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 67, height: 46, start: 45, extent: 270)
+      point = [arc.x + arc.width*(3.9/4.0), arc.y + (arc.height / 2.0)]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point in center of open type arc' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 145)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point within bounding box with open type circle' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [3.0, 4.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point outside bounding box with open type circle' do
+      arc = PerfectShape::Arc.new(type: :open, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [1.0, 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'contains point with pie type circle' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'contains point in center of pie type arc' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 145)
+      point = [arc.x + arc.width / 2.0, arc.y + arc.height / 2.0]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'contains point with pie type arc' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 145)
+      point = [arc.x + arc.width / 2.0 + (arc.width / 4.0), arc.y + (arc.height / 2.0) - (arc.height / 4.0)]
+
+      _(arc).must_be :contain?, point
+      _(arc.contain?(point)).must_equal arc.contain?(*point)
+    end
+
+    it 'does not contain point within bounding box with pie type arc' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 145)
+      point = [arc.x + (arc.width / 2.0) - (arc.width / 4.0), arc.y + arc.height / 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point within bounding box with pie type circle' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [3.0, 4.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+
+    it 'does not contain point outside bounding box with pie type circle' do
+      arc = PerfectShape::Arc.new(type: :pie, x: 2, y: 3, width: 50.5, height: 60.75, start: 0, extent: 360)
+      point = [1.0, 2.0]
+
+      _(arc.contain?(point)).must_equal false
+    end
+  end
+end

data/test/lib/perfect_shape/test_math.rb

@@ -0,0 +1,76 @@
+require 'puts_debuggerer'
+require 'minitest/autorun'
+
+require_relative '../../../lib/perfect-shape'
+
+describe PerfectShape do
+  describe PerfectShape::Math do
+    describe '#ieee754_remainder' do
+      it 'returns a negative number rounding ceiling' do
+        result = PerfectShape::Math.ieee754_remainder(7.5, 4.5)
+        
+        _(result).must_equal -1.5
+      end
+      
+      it 'returns a positive number rounding floor' do
+        result = PerfectShape::Math.ieee754_remainder(7.5, 3.5)
+        
+        _(result).must_equal 0.5
+      end
+      
+      it 'returns a positive number rounding halfway to floor even number' do
+        result = PerfectShape::Math.ieee754_remainder(5, 10)
+        
+        _(result).must_equal 5
+      end
+      
+      it 'returns a negative number rounding halfway to ceiling even number' do
+        result = PerfectShape::Math.ieee754_remainder(15, 10)
+        
+        _(result).must_equal -5
+      end
+      
+      it 'returns NaN for x=NaN' do
+        result = PerfectShape::Math.ieee754_remainder(Float::NAN, 10)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns NaN for x=Infinity' do
+        result = PerfectShape::Math.ieee754_remainder(Float::INFINITY, 10)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns NaN for y=NaN' do
+        result = PerfectShape::Math.ieee754_remainder(10, Float::NAN)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns NaN for y=0' do
+        result = PerfectShape::Math.ieee754_remainder(10, 0)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns NaN for y=+0.0' do
+        result = PerfectShape::Math.ieee754_remainder(10, 0.0)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns NaN for y=-0.0' do
+        result = PerfectShape::Math.ieee754_remainder(10, -0.0)
+
+        _(result).must_be :nan?
+      end
+      
+      it 'returns x for y=Infinity' do
+        result = PerfectShape::Math.ieee754_remainder(10, Float::INFINITY)
+
+        _(result).must_equal 10
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: perfect-shape
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Maleh
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: juwelier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+- !ruby/object:Gem::Dependency
+  name: puts_debuggerer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: rake-tui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !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 point in popular
+  geometric shapes such as rectangle, square, arc, circle, polygon, polyline, and
+  paths containing lines, bezier curves, and quadratic curves. Additionally, it contains
+  some purely mathematical algorithms like IEEEremainder (also known as IEEE-754 remainder).
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".ruby-gemset"
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- VERSION
+- lib/perfect-shape.rb
+- lib/perfect_shape/arc.rb
+- lib/perfect_shape/line.rb
+- lib/perfect_shape/math.rb
+- perfect-shape.gemspec
+- test/lib/perfect_shape/test_arc.rb
+- test/lib/perfect_shape/test_math.rb
+homepage: http://github.com/AndyObtiva/perfect-shape
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.31
+signing_key:
+specification_version: 4
+summary: Perfect Shape - Geometric Algorithms
+test_files: []