perfect-shape 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f13ff7665704c6183553e3ba4391c1890b9ac9846177e8c31226689da7a13bf
-  data.tar.gz: 427d591daa1567bd4336aef61b35423cf63a8c41d9b8e9d7d3099b07db14ec41
+  metadata.gz: 165108ad6899bfc0e001ba5ebbf2447a82e8173b03cdb3b08cf16b79f4287147
+  data.tar.gz: b2357efaa2e903edd66a212b06add8e6b3f6cec4a060f36b43eeb2f16bdb8072
 SHA512:
-  metadata.gz: 87314aced3ca151bdefcf6e23af5ba3c3b340503d0b194c93e4b46cce2d1f7375fe79edecc588d394ccfcb7d915282dde45c6eb1f7c7ad8e8e22608876dd05ad
-  data.tar.gz: ad32f360bc0d2a3bab95b826a7946dc81f6fa0900c29fabbe93a67d238d0b449adc3d46ec26324bdfb9f3a3d61373192cc27b5ffa169c103dfcf1865dede58e5
+  metadata.gz: ded5da995dd9517acf3987c18f1410b1704c23b349a082791fdae91dd3f63bab91df89d5aa0b7b63b67f8d699e86b98905f80f30ef741e8570252f321ed7f7b8
+  data.tar.gz: 33f27f98eef7fee0f370f7f9003b73b26b27fb0c5c596b9a325bef6566669be6710b4fab5f4ab67e2be9728470b0b08369079b0924ca89544813b3b386e31f7d

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 0.0.4
+
+- `PerfectShape::Arc#center_x` / `PerfectShape::Arc#center_y` / `PerfectShape::Arc#radius_x` / `PerfectShape::Arc#radius_y`
+- `PerfectShape::Rectangle#center_x` / `PerfectShape::Arc#center_y`
+- `PerfectShape::Square#center_x` / `PerfectShape::Square#center_y`
+- `PerfectShape::Arc#initialize(center_x: , center_y: , radius_x: , radius_y: )`
+- `PerfectShape::Math::normalize_degrees(degrees)` extracted from `PerfectShape::Arc`
+
 ## 0.0.3
 
 - `PerfectShape::Square`

data/README.md

@@ -1,8 +1,8 @@
-# Perfect Shape 0.0.3
+# Perfect Shape 0.0.4
 ## Geometric Algorithms
 [![Gem Version](https://badge.fury.io/rb/perfect-shape.svg)](http://badge.fury.io/rb/perfect-shape)
 
-`PerfectShape` 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 in popular geometry shapes such as rectangle, square, arc, ellipse, circle, polygon, polyline, polybezier, and paths containing lines, bezier curves, and quadratic curves.
+`PerfectShape` 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 in popular geometry shapes such as rectangle, square, arc (open, chord, and pie), ellipse, circle, polygon, polyline, polybezier, and paths containing lines, bezier curves, and quadratic curves.
 
 Additionally, `PerfectShape::Math` contains some purely mathematical algorithms.
 
@@ -13,13 +13,13 @@ To ensure high accuracy, this library does all its mathematical operations with
 Run:
 
 ```
-gem install perfect-shape -v 0.0.3
+gem install perfect-shape -v 0.0.4
 ```
 
 Or include in Bundler `Gemfile`:
 
 ```ruby
-gem 'perfect-shape', '~> 0.0.3'
+gem 'perfect-shape', '~> 0.0.4'
 ```
 
 And, run:
@@ -32,9 +32,10 @@ bundle
 
 ### `PerfectShape::Math`
 
-- `::degrees_to_radians(angle)`
-- `::radians_to_degrees(angle)`
-- `::ieee_remainder(x, y)` (alias: `ieee754_remainder`)
+- `::degrees_to_radians(angle)`: converts degrees to radians
+- `::radians_to_degrees(angle)`: converts radians to degrees
+- `::normalize_degrees(angle)`: normalizes the specified angle into the range -180 to 180.
+- `::ieee_remainder(x, y)` (alias: `ieee754_remainder`): [IEEE 754-1985 Remainder](https://en.wikipedia.org/wiki/IEEE_754-1985) (different from standard % modulo operator as it operates on floats and could return a negative result)
 
 ### `PerfectShape::Line`
 
@@ -42,32 +43,50 @@ bundle
 
 ### `PerfectShape::Rectangle`
 
+![rectangle](images/rectangle.png)
+
 - `::new(x: 0, y: 0, width: 1, height: 1)`: constructs a rectangle
 - `#x`: top-left x
 - `#y`: top-left y
 - `#width`: width
 - `#height`: height
+- `#center_x`: center x
+- `#center_y`: center y
 - `#contain?(x_or_point, y=nil)`: checks if point is inside
 
 ### `PerfectShape::Square`
 
+![square](images/square.png)
+
 - `::new(x: 0, y: 0, length: 1)`: constructs a square
 - `#x`: top-left x
 - `#y`: top-left y
 - `#length`: length
 - `#width`: width (equal to length)
 - `#height`: height (equal to length)
+- `#center_x`: center x
+- `#center_y`: center y
 - `#contain?(x_or_point, y=nil)`: checks if point is inside
 
 ### `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`
+Arcs can be of type `:open`, `:chord`, or `:pie`
+
+Open Arc | Chord Arc | Pie Arc
+---------|-----------|--------
+![arc-open](images/arc-open.png) | ![arc-chord](images/arc-chord.png) | ![arc-pie](images/arc-pie.png)
+
+- `::new(type: :open, x: 0, y: 0, width: 1, height: 1, start: 0, extent: 360, center_x: nil, center_y: nil, radius_x: nil, radius_y: nil)`: 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
+- `#center_x`: center x
+- `#center_y`: center y
+- `#radius_x`: radius along the x-axis
+- `#radius_y`: radius along the y-axis
 - `#contain?(x_or_point, y=nil)`: checks if point is inside
 
 ## Process

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/perfect_shape/arc.rb

@@ -32,8 +32,15 @@ module PerfectShape
     attr_accessor :type
     attr_reader :start, :extent
     
-    def initialize(type: :open, x: 0, y: 0, width: 1, height: 1, start: 0, extent: 360)
-      super(x: x, y: y, width: width, height: height)
+    def initialize(type: :open, x: 0, y: 0, width: 1, height: 1, start: 0, extent: 360, center_x: nil, center_y: nil, radius_x: nil, radius_y: nil)
+      if center_x && center_y && radius_x && radius_y
+        self.center_x = center_x
+        self.center_y = center_y
+        self.radius_x = radius_x
+        self.radius_y = radius_y
+      else
+        super(x: x, y: y, width: width, height: height)
+      end
       @type = type
       self.start = start
       self.extent = extent
@@ -47,6 +54,86 @@ module PerfectShape
       @extent = BigDecimal(value.to_s)
     end
     
+    def x
+      @center_x && @radius_x ? @center_x - @radius_x : super
+    end
+    
+    def y
+      @center_y && @radius_y ? @center_y - @radius_y : super
+    end
+    
+    def width
+      @radius_x ? @radius_x * BigDecimal('2.0') : super
+    end
+    
+    def height
+      @radius_y ? @radius_y * BigDecimal('2.0') : super
+    end
+    
+    # Sets x, normalizing to BigDecimal
+    def x=(value)
+      super
+      @center_x = nil
+      self.width = width if @radius_x
+    end
+    
+    # Sets y, normalizing to BigDecimal
+    def y=(value)
+      super
+      @center_y = nil
+      self.height = height if @radius_y
+    end
+    
+    # Sets width, normalizing to BigDecimal
+    def width=(value)
+      super
+      @radius_x = nil
+    end
+    
+    # Sets height, normalizing to BigDecimal
+    def height=(value)
+      super
+      @radius_y = nil
+    end
+    
+    def center_x
+      super || @center_x
+    end
+    
+    def center_y
+      super || @center_y
+    end
+    
+    def radius_x
+      @width ? @width/BigDecimal('2.0') : @radius_x
+    end
+    
+    def radius_y
+      @height ? @height/BigDecimal('2.0') : @radius_y
+    end
+    
+    def center_x=(value)
+      @center_x = BigDecimal(value.to_s)
+      @x = nil
+      self.radius_x = radius_x if @width
+    end
+    
+    def center_y=(value)
+      @center_y = BigDecimal(value.to_s)
+      @y = nil
+      self.radius_y = radius_y if @height
+    end
+    
+    def radius_x=(value)
+      @radius_x = BigDecimal(value.to_s)
+      @width = nil
+    end
+    
+    def radius_y=(value)
+      @radius_y = BigDecimal(value.to_s)
+      @height = nil
+    end
+    
     # Checks if arc contains point denoted by point (two-number Array or x, y args)
     #
     # @param x The X coordinate of the point to test.
@@ -103,34 +190,11 @@ module PerfectShape
       ang_ext = -ang_ext if backwards
       return true if ang_ext >= 360.0
 
-      angle = normalize_degrees(angle) - normalize_degrees(start)
+      angle = Math.normalize_degrees(angle) - Math.normalize_degrees(start)
       angle = -angle if backwards
       angle += 360.0 if angle < 0.0
 
       (angle >= 0.0) && (angle < ang_ext)
     end
-    
-    # Normalizes the specified angle into the range -180 to 180.
-    # TODO refactor/extract to Math class
-    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/math.rb

@@ -15,6 +15,28 @@ module PerfectShape
       def degrees_to_radians(degrees)
         (Math::PI/180)*degrees
       end
+        
+      # Normalizes the specified angle into the range -180 to 180.
+      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
 
       # Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.
       #

data/lib/perfect_shape/rectangular_shape.rb

@@ -53,5 +53,13 @@ module PerfectShape
     def height=(value)
       @height = BigDecimal(value.to_s)
     end
+    
+    def center_x
+      @x + (@width/BigDecimal('2.0')) if @x && @width
+    end
+    
+    def center_y
+      @y + (@height/BigDecimal('2.0')) if @y && @height
+    end
   end
 end

data/lib/perfect_shape/square.rb

@@ -37,22 +37,20 @@ module PerfectShape
     # Sets length, normalizing to BigDecimal
     def length=(value)
       @length = BigDecimal(value.to_s)
+      self.width = value unless width == value
+      self.height = value unless height == value
     end
     
     def width=(value)
-      self.length = value
+      super
+      self.length = value unless length == value
+      self.height = value unless height == value
     end
     
     def height=(value)
-      self.length = value
-    end
-    
-    def width
-      length
-    end
-    
-    def height
-      length
+      super
+      self.length = value unless length == value
+      self.width = value unless width == value
     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.0.3 ruby lib
+# stub: perfect-shape 0.0.4 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "perfect-shape".freeze
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   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-13"
-  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, ellipse, circle, polygon, polyline, polybezier, 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.date = "2021-12-15"
+  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, polyline, polybezier, 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",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perfect-shape
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -82,10 +82,10 @@ dependencies:
         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, ellipse, circle,
-  polygon, polyline, polybezier, and paths containing lines, bezier curves, and quadratic
-  curves. Additionally, it contains some purely mathematical algorithms like IEEEremainder
-  (also known as IEEE-754 remainder).
+  point in popular geometry shapes such as rectangle, square, arc (open, chord, and
+  pie), ellipse, circle, polygon, polyline, polybezier, 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: []