aurora-geometry 0.0.2

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

data/lib/geometry/line.rb

@@ -0,0 +1,154 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin rdoc
+A cluster of objects representing a Line of infinite length
+
+Supports two-point, slope-intercept, and point-slope initializer forms
+
+== Usage
+
+=== 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)
+=end
+
+    class Line
+	include ClusterFactory
+
+	# @overload [](Array, Array)
+	#   @return [TwoPointLine]
+	# @overload [](Point, Point)
+	#   @return [TwoPointLine]
+	# @overload [](Vector, Vector)
+	#   @return [TwoPointLine]
+	# @overload [](y-intercept, slope)
+	#   @return [SlopeInterceptLine]
+	# @overload [](point, slope)
+	#   @return [PointSlopeLine]
+	def self.[](*args)
+	    if( 2 == args.size )
+		args.map! {|x| x.is_a?(Array) ? Point[*x] : x}
+
+		# If both args are Points, create a TwoPointLine
+		return TwoPointLine.new(*args) if args.all? {|x| x.is_a?(Vector)}
+
+		# If only the first arg is a Point, create a PointSlopeLine
+		return PointSlopeLine.new(*args) if args.first.is_a?(Vector)
+
+		# Otherise, create a SlopeInterceptLine
+		return SlopeInterceptLine.new(*args)
+	    else
+		nil
+	    end
+	end
+
+	# @overload new(from, to)
+	# @option options [Point] :from	A starting {Point}
+	# @option options [Point] :to	An end {Point}
+	# @return [TwoPointLine]
+	# @overload new(start, end)
+	# @option options [Point] :start	A starting {Point}
+	# @option options [Point] :end	An end {Point}
+	# @return [TwoPointLine]
+	def self.new(options={})
+	    from = options[:from] || options[:start]
+	    to = options[:end] || options[:to]
+
+	    if from and to
+		TwoPointLine.new(from, to)
+	    else
+		raise ArgumentError, "Start and end Points must be provided"
+	    end
+	end
+
+	def self.horizontal(y_intercept=0)
+	    SlopeInterceptLine.new(0, y_intercept)
+	end
+	def self.vertical(x_intercept=0)
+	    SlopeInterceptLine.new(1/0.0, x_intercept)
+	end
+    end
+
+    # @private
+    class PointSlopeLine < Line
+	# @return [Number]  the slope of the {Line}
+	attr_reader :slope
+
+	def initialize(point, slope)
+	    @point = Point[point]
+	    @slope = slope
+	end
+	def to_s
+	    'Line(' + @slope.to_s + ',' + @point.to_s + ')'
+	end
+    end
+
+    # @private
+    class SlopeInterceptLine < Line
+	# @return [Number]  the slope of the {Line}
+	attr_reader :slope
+
+	def initialize(slope, intercept)
+	    @slope = slope
+	    @intercept = intercept
+	end
+
+	def horizontal?
+	    0 == @slope
+	end
+	def vertical?
+	    (1/0.0) == @slope
+	end
+
+	def intercept(axis=:y)
+	    case axis
+		when :x
+		    vertical? ? @intercept : (horizontal? ? nil : (-@intercept/@slope))
+		when :y
+		    vertical? ? nil : @intercept
+	    end
+	end
+
+	def to_s
+	    'Line(' + @slope.to_s + ',' + @intercept.to_s + ')'
+	end
+    end
+
+    # @private
+    class TwoPointLine < Line
+	attr_reader :first, :last
+
+	def initialize(point0, point1)
+	    @first, @last = [Point[point0], Point[point1]]
+	end
+	def inspect
+	    'Line(' + @first.inspect + ', ' + @last.inspect + ')'
+	end
+	alias :to_s :inspect
+
+# @group Accessors
+	# !@attribute [r[ slope
+	#   @return [Number]	the slope of the {Line}
+	def slope
+	    (last.y - first.y)/(last.x - first.x)
+	end
+# @endgroup
+    end
+end
+

data/lib/geometry/obround.rb

@@ -0,0 +1,238 @@
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+
+=begin
+The {Obround} class cluster represents a rectangle with semicircular end caps
+
+{http://en.wiktionary.org/wiki/obround}
+=end
+
+    class Obround
+	include ClusterFactory
+
+	# @overload new(width, height)
+	#   Creates a {Obround} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredObround]
+	# @overload new(size)
+	#   Creates a {Obround} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredObround]
+	# @overload new(point0, point1)
+	#   Creates a {Obround} using the given {Point}s
+	#   @param [Point]    point0	A corner
+	#   @param [Point]    point1	The other corner
+	# @overload new(origin, size)
+	#   Creates a {Obround} from the given origin and size
+	#   @param [Point]	origin	Lower-left corner
+	#   @param [Size]	size	Width and height
+	#   @return [SizedObround]
+	# @overload new(left, bottom, right, top)
+	#   Creates a {Obround} from the locations of each side
+	#   @param [Number]	left	X-coordinate of the left side
+	#   @param [Number]	bottom	Y-coordinate of the bottom edge
+	#   @param [Number]	right	X-coordinate of the right side
+	#   @param [Number]	top	Y-coordinate of the top edge
+	#   @return [Obround]
+	def self.new(*args)
+	    case args.size
+		when 1
+		    CenteredObround.new(args[0])
+		when 2
+		    if args.all? {|a| a.is_a?(Numeric) }
+			CenteredObround.new(Size[*args])
+		    elsif args.all? {|a| a.is_a?(Array) || a.is_a?(Point) }
+			original_new(*args)
+		    elsif (args[0].is_a?(Point) or args[0].is_a?(Array))and args[1].is_a?(Size)
+			SizedObround.new(*args)
+		    else
+			raise ArgumentError, "Invalid arguments #{args}"
+		    end
+		when 4
+		    raise ArgumentError unless args.all? {|a| a.is_a?(Numeric)}
+		    left, bottom, right, top = *args
+		    original_new(Point[left, bottom], Point[right, top])
+	    end
+	end
+
+	# Create a {Obround} using the given {Point}s
+	#  @param [Point0]  point0  The bottom-left corner (closest to the origin)
+	#  @param [Point1]  point1  The top-right corner (farthest from the origin)
+	def initialize(point0, point1)
+	    point0, point1 = Point[point0], Point[point1]
+	    raise(ArgumentError, "Point sizes must match") unless point0.size == point1.size
+
+	    # Reorder the points to get lower-left and upper-right
+	    if (point0.x > point1.x) && (point0.y > point1.y)
+		point0, point1 = point1, point0
+	    else
+		p0x, p1x = [point0.x, point1.x].minmax
+		p0y, p1y = [point0.y, point1.y].minmax
+		point0 = Point[p0x, p0y]
+		point1 = Point[p1x, p1y]
+	    end
+	    @points = [point0, point1]
+	end
+
+	def eql?(other)
+	    self.points == other.points
+	end
+	alias :== :eql?
+
+# @group Accessors
+
+	# @return [Point]   The {Obround}'s center
+	def center
+	    min, max = @points.minmax {|a,b| a.y <=> b.y}
+	    Point[(max.x+min.x)/2, (max.y+min.y)/2]
+	end
+
+	# @return [Array<Point>]    The {Obround}'s four points (counterclockwise)
+	def points
+	    point0, point2 = *@points
+	    point1 = Point[point2.x, point0.y]
+	    point3 = Point[point0.x, point2.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def origin
+	    minx = @points.min {|a,b| a.x <=> b.x}
+	    miny = @points.min {|a,b| a.y <=> b.y}
+	    Point[minx.x, miny.y]
+	end
+
+	def height
+	    min, max = @points.minmax {|a,b| a.y <=> b.y}
+	    max.y - min.y
+	end
+
+	def width
+	    min, max = @points.minmax {|a,b| a.x <=> b.x}
+	    max.x - min.x
+	end
+# @endgroup
+    end
+
+    class CenteredObround < Obround
+	# @return [Point]	The {Obround}'s center
+	attr_accessor :center
+	attr_reader :origin
+	# @return [Size]	The {Size} of the {Obround}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates a {Obround} of the given width and height, centered on the origin
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return [CenteredObround]
+	# @overload new(size)
+	#   Creates a {Obround} of the given {Size} centered on the origin
+	#   @param [Size]	size	Width and height
+	#   @return [CenteredObround]
+	# @overload new(center, size)
+	#   Creates a {Obround} with the given center point and size
+	#   @param [Point]	center
+	#   @param [Size]	size
+	def initialize(*args)
+	    if args[0].is_a?(Size)
+		@center = Point[0,0]
+		@size = args[0]
+	    elsif args[0].is_a?(Geometry::Point) and args[1].is_a?(Geometry::Size)
+		@center, @size = args[0,1]
+	    elsif (2 == args.size) and args.all? {|a| a.is_a?(Numeric)}
+		@center = Point[0,0]
+		@size = Geometry::Size[*args]
+	    end
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.size == other.size)
+	end
+	alias :== :eql?
+
+# @group Accessors
+	# @return [Array<Point>]    The {Obround}'s four points (clockwise)
+	def points
+	    point0 = @center - @size/2.0
+	    point2 = @center + @size/2.0
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    end
+
+    class SizedObround < Obround
+	# @return [Point]   The {Obround}'s center
+	attr_reader :center
+	# @return [Point]	The {Obround}'s origin
+	attr_accessor :origin
+	# @return [Size]	The {Size} of the {Obround}
+	attr_accessor :size
+
+	# @overload new(width, height)
+	#   Creates an {Obround} of the given width and height with its origin at [0,0]
+	#   @param [Number]   height  Height
+	#   @param [Number]   width   Width
+	#   @return SizedObround
+	# @overload new(size)
+	#   Creates an {Obround} of the given {Size} with its origin at [0,0]
+	#   @param [Size]	size	Width and height
+	#   @return SizedObround
+	# @overload new(origin, size)
+	#   Creates an {Obround} with the given origin point and size
+	#   @param [Point]	origin
+	#   @param [Size]	size
+	#   @return SizedObround
+	def initialize(*args)
+	    if args[0].is_a?(Size)
+		@origin = Point[0,0]
+		@size = args[0]
+	    elsif (args[0].is_a?(Point) or args[0].is_a?(Array)) and args[1].is_a?(Geometry::Size)
+		@origin, @size = Point[args[0]], args[1]
+	    elsif (2 == args.size) and args.all? {|a| a.is_a?(Numeric)}
+		@origin = Point[0,0]
+		@size = Geometry::Size[*args]
+	    end
+	end
+
+	def eql?(other)
+	    (self.origin == other.origin) && (self.size == other.size)
+	end
+	alias :== :eql?
+
+# @group Accessors
+	def center
+	    @origin + @size/2
+	end
+
+	# @return [Array<Point>]    The {Obround}'s four points (clockwise)
+	def points
+	    point0 = @origin
+	    point2 = @origin + @size
+	    point1 = Point[point0.x,point2.y]
+	    point3 = Point[point2.x, point0.y]
+	    [point0, point1, point2, point3]
+	end
+
+	def height
+	    @size.height
+	end
+
+	def width
+	    @size.width
+	end
+# @endgroup
+    end
+end