euclidean 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a73c24a00cc5b70d91928313b88a92fd4b7b911
+  data.tar.gz: 90fc4f8ec1974af5a8e7663e89d99564791ad673
+SHA512:
+  metadata.gz: 5ec8e7d0cc9e81d4d974cd7b3d0a0bef4f636d2e0c17981937ab8fbeb48c8814763af0d61ec426536ffe2e0ffd300b497b12bc437d2aeca68c3f9f06e2db83c8
+  data.tar.gz: b31be403bbaaa9510a7efe67d3a40427fd7440488445955cc32ec938c18b5c3315f4e2ce3c809c94a4b19ad5d9d26332d4026cd8eb6c9a1c98ea4ed199091d81

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in euclidean.gemspec
+gemspec
+
+group :development, :test do
+  gem 'guard-rspec', require: false
+end

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', cmd: 'bundle exec rspec', all_on_start: false, all_after_pass: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jeremy Ward
+
+MIT License
+
+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,90 @@
+# Euclidean
+
+Euclidean adds classes and methods to handle basic geometry in Ruby.
+
+The classes in this library are based on the Vector class provided in the Ruby Standard Library.
+Geometric primitives are generally assumed to lie in 2-Dimensional space but are not necessarily
+restricted to it.
+
+Like Euclid himself, the work in this gem builds upon the work of others. Most notably:
+   * [geometry](https://github.com/bfoz/geometry)
+   * [ruby-geometry](https://github.com/DanielVartanov/ruby-geometry)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'euclidean'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install euclidean
+
+## Defined Geometric Primitives
+* Circle
+* Edge
+* Point
+* Rectangle
+* Size
+* Vector
+
+## Usage
+
+### Point
+```ruby
+point = Euclidean::Point[3,4]    # 2D Point at coordinate 3, 4
+
+# Copy constructors
+point2 = Euclidean::Point[point]
+point2 = Euclidean::Point[Vector[5,6]]
+
+# Accessors
+point.x
+point.y
+point[2]	# Same as point.z
+
+# Zero
+Euclidean::PointZero.new   # A Point full of zeros of unspecified length
+Euclidean::Point.zero      # Another way to do the same thing
+Euclidean::Point.zero(3)   # => Point[0,0,0]
+```
+
+### Circle
+```ruby
+# A circle at Point[1,2] with a radius of 3
+circle = Euclidean::Circle.new [1,2], 3
+circle = Euclidean::Circle.new center:[1,2], radius: 3
+
+# A circle at Point[1,2] with a diameter of 3
+circle = Euclidean::Circle.new center:[1,2], diameter: 3
+
+# A circle at Point[0,0] with a diameter of 4
+circle = Euclidean::Circle.new diameter: 4
+```
+
+### Rectangle
+```ruby
+# A Rectangle made from two corner points
+rectangle = Euclidean::Rectangle.new [1,2], [2,3]
+rectangle = Euclidean::Rectangle.new from:[1,2], to:[2,3]
+
+rectangle = Euclidean::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
+rectangle = Euclidean::Rectangle.new origin:[1,2], size:[1,1]	# Using an origin point and a size
+
+# A Rectangle with its origin at [0, 0] and a size of [10, 20]
+rectangle = Euclidean::Rectangle.new size: [10, 20]
+rectangle = Euclidean::Rectangle.new size: Euclidean::Size[10, 20]
+rectangle = Euclidean::Rectangle.new width: 10, height: 20
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/euclidean/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/euclidean.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'euclidean/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "euclidean"
+  spec.version       = Euclidean::VERSION
+  spec.authors       = ["Jeremy Ward"]
+  spec.email         = ["jeremy.ward@digital-ocd.com"]
+  spec.summary       = %q{Basic Geometric primitives and algoritms for Ruby}
+  spec.description   = %q{Basic Geometric primitives and algoritms for Ruby}
+  spec.homepage      = "https://github.com/jrmyward/euclidean"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec'
+end

data/lib/euclidean.rb

@@ -0,0 +1,12 @@
+require 'euclidean/cluster_factory'
+require 'euclidean/circle'
+require 'euclidean/point'
+require 'euclidean/point_zero'
+require 'euclidean/rectangle'
+require 'euclidean/size'
+require "euclidean/vector"
+require "euclidean/version"
+
+module Euclidean
+
+end

data/lib/euclidean/circle.rb

@@ -0,0 +1,118 @@
+module Euclidean
+=begin rdoc
+Circles come in all shapes and sizes, but they're usually round.
+
+== Usage
+    circle = Euclidean::Circle.new [1,2], 3
+    circle = Euclidean::Circle.new center:[1,2], radius:3
+    circle = Euclidean::Circle.new center:[1,2], diameter:6
+    circle = Euclidean::Circle.new diameter:6
+=end
+
+  class Circle
+    include ClusterFactory
+
+    # @return [Point]   The {Circle}'s center point
+    attr_reader :center
+    # @return [Number]  The {Circle}'s radius
+    attr_reader :radius
+
+  	# @overload new(center, radius)
+  	#   Construct a {Circle} using a centerpoint and radius
+  	#   @param [Point]	center  The center point of the {Circle}
+  	#   @param [Number]	radius	The radius of the {Circle}
+  	# @overload new(center, radius)
+  	#   Construct a circle using named center and radius parameters
+  	#   @option options [Point]	:center (PointZero)
+  	#   @option options [Number]	:radius
+  	# @overload new(center, diameter)
+  	#   Construct a circle using named center and diameter parameters
+  	#   @option options [Point]	:center (PointZero)
+  	#   @option options [Number]	:diameter
+  	def self.new(*args, &block)
+      options, args = args.partition {|a| a.is_a? Hash}
+      options = options.reduce({}, :merge)
+      center, radius = args[0..1]
+
+      center ||= (options[:center] || PointZero.new)
+      radius ||= options[:radius]
+
+      if radius
+        self.allocate.tap {|circle| circle.send :initialize, center, radius, &block }
+      elsif options.has_key?(:diameter)
+        CenterDiameterCircle.new center, options[:diameter], &block
+      else
+        raise ArgumentError, "Circle.new requires a radius or a diameter"
+      end
+  	end
+
+  	# Construct a new {Circle} from a centerpoint and radius
+  	# @param    [Point]	center  The center point of the {Circle}
+  	# @param    [Number]	radius  The radius of the {Circle}
+  	# @return   [Circle]	A new {Circle} object
+  	def initialize(center, radius)
+	    @center = Point[center]
+	    @radius = radius
+  	end
+
+    def eql?(other)
+      (self.center == other.center) && (self.radius == other.radius)
+    end
+    alias :== :eql?
+
+    # @!group Accessors
+	   # @return [Rectangle]	The smallest axis-aligned {Rectangle} that bounds the receiver
+    def bounds
+      return Euclidean::Rectangle.new(self.min, self.max)
+    end
+
+    # @!attribute [r] diameter
+    #   @return [Numeric] The diameter of the {Circle}
+    def diameter
+      @radius*2
+    end
+
+    # @return [Point]   The upper right corner of the bounding {Rectangle}
+    def max
+      @center+radius
+    end
+
+    # @return [Point]   The lower left corner of the bounding {Rectangle}
+    def min
+      @center-radius
+    end
+
+    # @return [Array<Point>]    The lower left and upper right corners of the bounding {Rectangle}
+    def minmax
+      [self.min, self.max]
+    end
+    # @!endgroup
+  end
+
+  class CenterDiameterCircle < Circle
+  	# @return [Number]  The {Circle}'s diameter
+  	attr_reader :diameter
+
+  	# Construct a new {Circle} from a centerpoint and a diameter
+  	# @param    [Point]	center  The center point of the {Circle}
+  	# @param    [Number]	diameter  The radius of the {Circle}
+  	# @return   [Circle]	A new {Circle} object
+    def initialize(center, diameter)
+      @center = Point[center]
+      @diameter = diameter
+    end
+
+    def eql?(other)
+      (self.center == other.center) && (self.diameter == other.diameter)
+    end
+    alias :== :eql?
+
+    # @!group Accessors
+  	# @return [Number] The {Circle}'s radius
+  	def radius
+      @diameter/2
+  	end
+    # @!endgroup
+  end
+
+end

data/lib/euclidean/cluster_factory.rb

@@ -0,0 +1,15 @@
+# Include this module in the base class of a class cluster to handle swizzling
+# of ::new
+module ClusterFactory
+  def self.included(parent)
+    class << parent
+      alias :original_new :new
+
+      def inherited(subclass)
+        class << subclass
+          alias :new :original_new
+        end
+      end
+    end
+  end
+end

data/lib/euclidean/edge.rb

@@ -0,0 +1,143 @@
+require 'mathn'
+require_relative 'point'
+
+module Euclidean
+=begin rdoc
+An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
+
+== Usage
+    edge = Geometry::Edge([1,1], [2,2])
+
+=end
+  class Edge
+    attr_reader :first, :last
+
+    # Construct a new {Edge} object from any two things that can be converted
+    # to a {Point}.
+    def initialize(point0, point1)
+      @first, @last = [Point[point0], Point[point1]]
+    end
+
+    # Two Edges are equal if both have equal {Point}s in the same order
+    def ==(other)
+      (@first == other.first) && (@last == other.last)
+    end
+
+    # @param [Point] point	A {Point} to spaceship with
+    # @return [Boolean]	Returns 1 if the {Point} is strictly to the left of the receiver, -1 to the right, and 0 if the point is on the receiver
+    def <=>(point)
+      case point
+      when Point
+        k = (@last.x - @first.x) * (point.y - @first.y) - (point.x - @first.x) * (@last.y - @first.y)
+        if 0 == k
+      (((@first.x <=> point.x) + (@last.x <=> point.x)).abs <= 1) && (((@first.y <=> point.y) + (@last.y <=> point.y)).abs <= 1) ? 0 : nil
+        else
+      k <=> 0
+        end
+      else
+        raise ArgumentError, "Can't spaceship with #{point.class}"
+      end
+    end
+
+    # @param [Edge] other	The other {Edge} to check
+    # @return [Bool] Returns true if the receiver and the passed {Edge} share an endpoint
+    def connected?(other)
+      (@first == other.last) || (@last == other.first) || (@first == other.first) || (@last == other.last)
+    end
+
+    # @return [Vector]  A unit {Vector} pointing from first to last
+    def direction
+      self.vector.normalize
+    end
+
+    # Return the {Edge}'s length along the Y axis
+    def height
+      (@first.y - @last.y).abs
+    end
+
+    def inspect
+      'Edge(' + @first.inspect + ', ' + @last.inspect + ')'
+    end
+    alias :to_s :inspect
+
+  	# Find the intersection of two {Edge}s (http://bloggingmath.wordpress.com/2009/05/29/line-segment-intersection/)
+  	# @param [Edge] other	The other {Edge}
+  	# @return [Point] The intersection of the two {Edge}s, nil if they don't intersect, true if they're collinear and overlapping, and false if they're collinear and non-overlapping
+  	def intersection(other)
+      return self.first if (self.first == other.first) or (self.first == other.last)
+      return self.last if (self.last == other.first) or (self.last == other.last)
+
+      p0, p1 = self.first, self.last
+      p2, p3 = other.first, other.last
+      v1, v2 = self.vector, other.vector
+
+      denominator = v1[0] * v2[1] - v2[0] * v1[1]		# v1 x v2
+      p = p0 - p2
+
+      if denominator == 0	    # collinear, so check for overlap
+        if 0 == (-v1[1] * p.x + v1[0] * p.y)	# collinear?
+          # The edges are collinear, but do they overlap?
+          # Project them onto the x and y axes to find out
+          left1, right1 = [self.first[0], self.last[0]].sort
+          bottom1, top1 = [self.first[1], self.last[1]].sort
+          left2, right2 = [other.first[0], other.last[0]].sort
+          bottom2, top2 = [other.first[1], other.last[1]].sort
+
+          !((left2 > right1) || (right2 < left1) || (top2 < bottom1) || (bottom2 > top1))
+        else
+          nil
+        end
+      else
+        s = (-v1[1] * p.x + v1[0] * p.y) / denominator	# v1 x (p0 - p2) / denominator
+        t = ( v2[0] * p.y - v2[1] * p.x) / denominator	# v2 x (p0 - p2) / denominator
+
+        p0 + v1 * t if ((0..1) === s) && ((0..1) === t)
+      end
+  	end
+
+    # @return [Bool] Returns true if the passed {Edge} is parallel to the receiver
+    def parallel?(edge)
+      v1, v2   = self.direction, edge.direction
+      winding  = v1[0]*v2[1] - v1[1]*v2[0]
+      if 0 == winding	# collinear?
+        if v1 == v2
+          true # 1  # same direction
+        else
+          true # -1 # opposite direction
+        end
+      else
+        false
+      end
+    end
+
+    # Return a new {Edge} with swapped endpoints
+    def reverse
+      Edge.new(@last, @first)
+    end
+
+    # In-place swap the endpoints
+    def reverse!
+      @first, @last = @last, @first
+      self
+    end
+
+    def to_a
+      [@first, @last]
+    end
+
+    # @return [Vector]  A {Vector} pointing from first to last
+    def vector
+      Vector[*((last-first).to_a)]
+    end
+
+    # Return the {Edge}'s length along the X axis
+    def width
+      (@first.x - @last.x).abs
+    end
+
+  end
+end
+
+def Edge(*args)
+  Euclidean::Edge.new(*args)
+end