geometry 4 → 5

data/.gitignore

@@ -4,6 +4,3 @@
 Gemfile.lock
 pkg/*
 doc
-
-.DS_Store
-*.xcodeproj

data/README.markdown

@@ -23,9 +23,11 @@ Primitives
 - Line
 - Edge
 - Circle
-- Rectangle
-- Polygon
+- Rectangle, Square
+- Path, [Polyline](http://en.wikipedia.org/wiki/Polyline), [Polygon](http://en.wikipedia.org/wiki/Polygon)
 - Transformation
+- [Triangle](http://en.wikipedia.org/wiki/Triangle)
+- [Obround](http://en.wiktionary.org/wiki/obround)
 
 Examples
 --------

data/Rakefile

@@ -20,11 +20,3 @@ 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
-
-task :docs do
-    `yard`
-end
-
-task :uninstall do
-    `gem uninstall geometry`
-end

data/geometry.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "geometry"
-  s.version     = '4'
+  s.version     = '5'
   s.authors     = ["Brandon Fosdick"]
   s.email       = ["bfoz@bfoz.net"]
   s.homepage    = "http://github.com/bfoz/geometry"

data/lib/geometry.rb

@@ -1,15 +1,18 @@
 require_relative 'geometry/arc'
 require_relative 'geometry/circle'
 require_relative 'geometry/line'
+require_relative 'geometry/path'
 require_relative 'geometry/point'
 require_relative 'geometry/point_zero'
 require_relative 'geometry/polygon'
+require_relative 'geometry/polyline'
 require_relative 'geometry/rectangle'
 require_relative 'geometry/rotation'
 require_relative 'geometry/size'
 require_relative 'geometry/size_zero'
 require_relative 'geometry/square'
 require_relative 'geometry/transformation'
+require_relative 'geometry/triangle'
 require_relative 'geometry/vector'
 
 module Geometry

data/lib/geometry/arc.rb

@@ -1,5 +1,8 @@
 require_relative 'point'
 
+require_relative 'cluster_factory'
+require_relative 'point'
+
 module Geometry
 
 =begin rdoc
@@ -11,10 +14,31 @@ An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis an
 =end
 
     class Arc
+	include ClusterFactory
+
 	attr_reader :center
 	attr_reader :radius
 	attr_reader :start_angle, :end_angle
 
+	# @overload new(center_point, start_point, end_point)
+	#  Create a new {Arc} given center, start and end {Point}s
+	# @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
+	# @overload initialize(center, radius, start_angle, end_angle)
+	#  Create a new {Arc} given a center, a radius and start and end angles
+	# @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 self.new(*args)
+	    if 4 == args.size
+		original_new(*args)
+	    elsif 3 == args.size
+		ThreePointArc.new(*args)
+	    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
@@ -27,5 +51,40 @@ An {Arc} with its center at [1,1] and a radius of 2 that starts at the X-axis an
 	    @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

@@ -1,3 +1,4 @@
+require_relative 'cluster_factory'
 require_relative 'point'
 
 module Geometry
@@ -6,23 +7,88 @@ module Geometry
 Circles come in all shapes and sizes, but they're usually round.
 
 == Usage
-    circle = Geometry::Circle.new [1,1], 2
+    circle = Geometry::Circle.new [1,2], 3
+    circle = Geometry::Circle.new [1,2], :radius => 3
+    circle = Geometry::Circle.new [1,2], :diameter => 6
+    circle = Geometry::Circle.new :center => [1,2], :diameter => 6
 =end
 
     class Circle
-	# @return [Point]   The Circle's center point
+	include ClusterFactory
+
+	# @return [Point]   The {Circle}'s center point
 	attr_reader :center
 
-	# @return [Number]  The Circle's radius
+	# @return [Number]  The {Circle}'s radius
 	attr_reader :radius
 
+	# @overload new(circle, 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(options)
+	#   Construct a circle using named center and radius parameters
+	#   @option options [Point]	:center
+	#   @option options [Number]	:radius
+	# @overload new(options)
+	#   Construct a circle using named center and diameter parameters
+	#   @option options [Point]	:center
+	#   @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 = Point[center || options[:center]]
+	    raise ArgumentError, "Circle.new requires a center" unless center
+
+	    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
+	# @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
+
+# @!group Accessors
+	# @!attribute [r] diameter
+	#   @return [Numeric] The diameter of the {Circle}
+	def diameter
+	    @radius*2
+	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
+
+# @!group Accessors
+	# @return 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

@@ -50,6 +50,67 @@ An edge. It's a line segment between 2 points. Generally part of a {Polygon}.
 	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/)
+	# @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)
+	    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

data/lib/geometry/path.rb

@@ -0,0 +1,55 @@
+require 'geometry/arc'
+require 'geometry/edge'
+
+module Geometry
+=begin
+An object representing a set of connected elements, each of which could be an
+{Edge} or an {Arc}. Unlike a {Polygon}, a {Path} is not guaranteed to be closed.
+=end
+    class Path
+	attr_reader :elements
+
+	# Construct a new Path from {Point}s, {Edge}s, and {Arc}s
+	#  Successive {Point}s will be converted to {Edge}s.
+	def initialize(*args)
+	    args.map! {|a| (a.is_a?(Array) or a.is_a?(Vector)) ? Point[a] : a}
+	    args.each {|a| raise ArgumentError, "Unknown argument type #{a.class}" unless a.is_a?(Point) or a.is_a?(Edge) or a.is_a?(Arc) }
+
+	    @elements = []
+
+	    first = args.shift
+	    @elements.push first if first.is_a?(Edge) or first.is_a?(Arc)
+
+	    args.reduce(first) do |previous, n|
+		case n
+		    when Point
+			case previous
+			    when Point	    then @elements.push Edge.new(previous, n)
+			    when Arc, Edge  then @elements.push Edge.new(previous.last, n) unless previous.last == n
+			end
+			@elements.last
+		    when Edge
+			case previous
+			    when Point	    then @elements.push Edge.new(previous, n.first)
+			    when Arc, Edge  then @elements.push Edge.new(previous.last, n.first) unless previous.last == n.first
+			end
+			@elements.push(n).last
+		    when Arc
+			case previous
+			    when Point
+				if previous == n.first
+				    raise ArgumentError, "Duplicated point before an Arc"
+				else
+				    @elements.push Edge.new(previous, n.first)
+				end
+			    when Arc, Edge
+				@elements.push Edge.new(previous.last, n.first) unless previous.last == n.first
+			end
+			@elements.push(n).last
+		    else
+			raise ArgumentError, "Unsupported argument type: #{n}"
+		end
+	    end
+	end
+    end
+end

data/lib/geometry/point.rb

@@ -40,10 +40,21 @@ geometry class (x, y, z).
 
 	# Allow comparison with an Array, otherwise do the normal thing
 	def eql?(other)
+	    return @elements.eql? other if other.is_a?(Array)
+	    super other
+	end
+
+	# Allow comparison with an Array, otherwise do the normal thing
+	def ==(other)
 	    return @elements == other if other.is_a?(Array)
 	    super other
 	end
-	alias == eql?
+
+	# Combined comparison operator
+	# @return [Point]   The <=> operator is applied to the elements of the arguments pairwise and the results are returned in a Point
+	def <=>(other)
+	    Point[self.to_a.zip(other.to_a).map {|a,b| a <=> b}.compact]
+	end
 
 	def coerce(other)
 	    case other
@@ -61,35 +72,35 @@ geometry class (x, y, z).
 	    'Point' + @elements.to_s
 	end
 
-# !@group Accessors
+# @group Accessors
 	# @param [Integer]  i	Index into the {Point}'s elements
 	# @return [Numeric] Element i (starting at 0)
 	def [](i)
 	    @elements[i]
 	end
 
-	# !@attribute [r] x
+	# @attribute [r] x
 	# @return [Numeric] X-component
 	def x
 	    @elements[0]
 	end
 
-	# !@attribute [r] y
+	# @attribute [r] y
 	# @return [Numeric] Y-component
 	def y
 	    @elements[1]
 	end
 
-	# !@attribute [r] z
+	# @attribute [r] z
 	# @return [Numeric] Z-component
 	def z
 	    @elements[2]
 	end
-# !@endgroup
+# @endgroup
 
-# !@group Arithmetic
+# @group Arithmetic
 
-# !@group Unary operators
+# @group Unary operators
 	def +@
 	    self
 	end
@@ -97,7 +108,7 @@ geometry class (x, y, z).
 	def -@
 	    Point[@elements.map {|e| -e }]
 	end
-# !@endgroup
+# @endgroup
 
 	def +(other)
 	    case other
@@ -127,7 +138,7 @@ geometry class (x, y, z).
 	    end
 	end
 
-# !@endgroup
+# @endgroup
 
     end
 end