geometry-in-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.yardoc
+Gemfile.lock
+pkg/*
+doc

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+    gem 'rake'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012, Brandon Fosdick <bfoz@bfoz.net>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided 
+that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the
+    following disclaimer.
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+    the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,105 @@
+Geometry for Ruby
+=================
+
+[![Build Status](https://travis-ci.org/bfoz/geometry.png)](https://travis-ci.org/bfoz/geometry)
+
+Classes and methods for the handling of all of the basic geometry that you 
+learned in high school (and then forgot).
+
+The classes in this libary are based on the Vector class provided by the Ruby 
+standard library. Geometric primitives are generally assumed to lie in 2D space,
+but aren't necessarily restricted to it. Please let me know if you find cases 
+that don't work in higher dimensions and I'll do my best to fix them.
+
+License
+-------
+
+Copyright 2012-2014 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+
+Primitives
+----------
+
+- Point
+- Size
+- Line
+- Edge
+- [Arc](http://en.wikipedia.org/wiki/Arc_(geometry)), Circle
+- Rectangle, Square
+- Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon), [RegularPolygon](http://en.wikipedia.org/wiki/Regular_polygon)
+- Transformation
+- [Triangle](http://en.wikipedia.org/wiki/Triangle)
+- [Obround](http://en.wiktionary.org/wiki/obround)
+
+Examples
+--------
+
+### Point
+```ruby
+    point = Geometry::Point[3,4]    # 2D Point at coordinate 3, 4
+
+    # Copy constructors
+    point2 = Geometry::Point[point]
+    point2 = Geometry::Point[Vector[5,6]]
+
+    # Accessors
+    point.x
+    point.y
+    point[2]	# Same as point.z
+
+    # Zero
+    PointZero.new   # A Point full of zeros of unspecified length
+    Point.zero      # Another way to do the same thing
+    Point.zero(3)   # => Point[0,0,0]
+```
+
+### Line
+```ruby
+    # Two-point constructors
+    line = Geometry::Line[[0,0], [10,10]]
+    line = Geometry::Line[Geometry::Point[0,0], Geometry::Point[10,10]]
+    line = Geometry::Line[Vector[0,0], Vector[10,10]]
+
+    # Slope-intercept constructors
+    Geometry::Line[Rational(3,4), 5]	# Slope = 3/4, Intercept = 5
+    Geometry::Line[0.75, 5]
+
+    # Point-slope constructors
+    Geometry::Line(Geometry::Point[0,0], 0.75)
+    Geometry::Line(Vector[0,0], Rational(3,4))
+
+    # Special constructors (2D only)
+    Geometry::Line.horizontal(y=0)
+    Geometry::Line.vertical(x=0)
+```
+
+### Rectangle
+```ruby
+    # A Rectangle made from two corner points
+    Geometry::Rectangle.new [1,2], [2,3]
+    Geometry::Rectangle.new from:[1,2], to:[2,3]
+
+    Geometry::Rectangle.new center:[1,2], size:[1,1]	# Using a center point and a size
+    Geometry::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]
+    Geometry::Rectangle.new size: [10, 20]
+    Geometry::Rectangle.new size: Size[10, 20]
+    Geometry::Rectangle.new width: 10, height: 20
+```
+
+### Circle
+```ruby
+    # A circle at Point[1,2] with a radius of 3
+    circle = Geometry::Circle.new center:[1,2], radius:3
+```
+
+### Polygon
+```ruby
+    # A polygon that looks a lot like a square
+    polygon = Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
+```
+### Regular Polygon
+```ruby
+    # Everyone loves a good hexagon
+    hexagon = Geometry::RegularPolygon.new 6, :diameter => 3
+```

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList['test/**/*.rb']
+    t.verbose = true
+end
+
+task :fixdates do
+    branch = `git branch --no-color -r --merged`.strip
+    `git fix-dates #{branch}..HEAD`
+end
+
+task :fixdates_f do
+    branch = `git branch --no-color -r --merged`.strip
+    `git fix-dates -f #{branch}..HEAD`
+end
+
+task :trim_whitespace do
+  system(%Q[git status --short | awk '{if ($1 != "D" && $1 != "R") print $2}' | grep -e '.*\.rb$' | xargs sed -i '' -e 's/[ \t]*$//g;'])
+end

data/geometry-in-ruby.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "geometry-in-ruby"
+  s.version     = '0.0.1'
+  s.authors     = ["Brandon Fosdick", "Meseker Yohannes"]
+  s.email       = ["meseker.yohannes@gmail.com"]
+  s.homepage    = "http://github.com/meseker/geometry"
+  s.summary     = %q{Geometric primitives and algoritms}
+  s.description = %q{Geometric primitives and algorithms for Ruby}
+
+  s.rubyforge_project = "aurora_geometry"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/geometry/arc.rb

@@ -0,0 +1,94 @@
+require_relative 'point'
+
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+{http://en.wikipedia.org/wiki/Arc_(geometry) Arcs} are Circles that don't quite go all the way around
+
+== Usage
+An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis and goes to the Y-axis (counter-clockwise)
+    arc = Geometry::Arc.new center:[1,1], radius:2, start:0, end:90
+=end
+
+    class Arc
+	include ClusterFactory
+
+	attr_reader :center
+	attr_reader :radius
+	attr_reader :start_angle, :end_angle
+
+	# @overload new(center, start, end)
+	#  Create a new {Arc} given center, start and end {Point}s
+	# @option options [Point] :center (PointZero)   The {Point} at the center
+	# @option options [Point] :start    The {Arc} starts at the start {Point}
+	# @option options [Point] :end	    The {Point} where it all ends
+	# @return [Arc]
+	# @overload new(center, radius, start, end)
+	#  Create a new {Arc} given a center {Point}, a radius and start and end angles
+	# @option options [Point]   :center (PointZero)	The {Point} at the center of it all
+	# @option options [Numeric] :radius	Radius
+	# @option options [Numeric] :start	Starting angle
+	# @option options [Numeric] :end	Ending angle
+	# @return [ThreePointArc]
+	def self.new(options={})
+	    center = options.delete(:center) || PointZero.new
+
+	    if options.has_key?(:radius)
+		original_new(center, options[:radius], options[:start], options[:end])
+	    else
+		ThreePointArc.new(center, options[:start], options[:end])
+	    end
+	end
+
+	# Construct a new {Arc}
+	# @overload initialize(center, radius, start_angle, end_angle)
+	# @param [Point]    center	The {Point} at the center of it all
+	# @param [Numeric]  radius	Radius
+	# @param [Numeric]  start_angle	Starting angle
+	# @param [Numeric]  end_angle	Ending angle
+	def initialize(center, radius, start_angle, end_angle)
+	    @center = Point[center]
+	    @radius = radius
+	    @start_angle = start_angle
+	    @end_angle = end_angle
+	end
+
+	# @return [Point]   The starting point of the {Arc}
+	def first
+	    @center + @radius * Vector[Math.cos(@start_angle), Math.sin(@start_angle)]
+	end
+
+	# @return [Point]   The end point of the {Arc}
+	def last
+	    @center + @radius * Vector[Math.cos(@end_angle), Math.sin(@end_angle)]
+	end
+    end
+
+    class ThreePointArc < Arc
+	attr_reader :center
+	attr_reader :start, :end
+
+	# Contruct a new {Arc} given center, start and end {Point}s
+	#  Always assumes that the {Arc} is counter-clockwise. Reverse the order
+	#  of the start and end points to get an {Arc} that goes around the other way.
+	# @overload initialize(center_point, start_point, end_point)
+	# @param [Point]    center_point    The {Point} at the center
+	# @param [Point]    start_point	    The {Arc} starts at the start {Point}
+	# @param [Point]    end_point	    The {Point} where it all ends
+	def initialize(center_point, start_point, end_point)
+	    @center, @start, @end = [center_point, start_point, end_point].map {|p| Point[p]}
+	    raise ArgumentError unless [@center, @start, @end].all? {|p| p.is_a?(Point)}
+	end
+
+	# The starting point of the {Arc}
+	# @return [Point]
+	alias :first :start
+
+	# The end point of the {Arc}
+	# @return [Point]
+	alias :last :end
+    end
+end

data/lib/geometry/circle.rb

@@ -0,0 +1,122 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+Circles come in all shapes and sizes, but they're usually round.
+
+== Usage
+    circle = Geometry::Circle.new [1,2], 3
+    circle = Geometry::Circle.new center:[1,2], radius:3
+    circle = Geometry::Circle.new center:[1,2], diameter:6
+    circle = Geometry::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 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/geometry/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/geometry/edge.rb

@@ -0,0 +1,140 @@
+require 'mathn'
+
+require_relative 'point'
+
+module Geometry
+
+=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
+
+	# 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
+
+	# Return the {Edge}'s length along the Y axis
+	def height
+	    (@first.y - @last.y).abs
+	end
+
+	# Return the {Edge}'s length along the X axis
+	def width
+	    (@first.x - @last.x).abs
+	end
+
+	def inspect
+	    'Edge(' + @first.inspect + ', ' + @last.inspect + ')'
+	end
+	alias :to_s :inspect
+
+	# @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
+		    1		# same direction
+		else
+		    -1		# opposite direction
+		end
+	    else
+		false
+	    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
+
+	# 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 [Vector]  A {Vector} pointing from first to last
+	def vector
+	    Vector[*((last-first).to_a)]
+	end
+
+	def to_a
+	    [@first, @last]
+	end
+    end
+end