geometry-in-ruby 0.0.1

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

data/lib/geometry/path.rb

@@ -0,0 +1,67 @@
+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
+	    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 push Edge.new(previous, n)
+			    when Arc, Edge  then push Edge.new(previous.last, n) unless previous.last == n
+			end
+			last
+		    when Edge
+			case previous
+			    when Point	    then push Edge.new(previous, n.first)
+			    when Arc, Edge  then push Edge.new(previous.last, n.first) unless previous.last == n.first
+			end
+			push(n).last
+		    when Arc
+			case previous
+			    when Point
+				if previous == n.first
+				    raise ArgumentError, "Duplicated point before an Arc"
+				else
+				    push Edge.new(previous, n.first)
+				end
+			    when Arc, Edge
+				push Edge.new(previous.last, n.first) unless previous.last == n.first
+			end
+			push(n).last
+		    else
+			raise ArgumentError, "Unsupported argument type: #{n}"
+		end
+	    end
+	end
+
+	# @return [Geometry]	The last element in the {Path}
+	def last
+	    @elements.last
+	end
+
+	# Append a new geometry element to the {Path}
+	# @return [Path]
+	def push(arg)
+	    @elements.push arg
+	    self
+	end
+    end
+end

data/lib/geometry/point.rb

@@ -0,0 +1,163 @@
+require 'matrix'
+
+require_relative 'point_zero'
+
+module Geometry
+    DimensionMismatch = Class.new(StandardError)
+    OperationNotDefined = Class.new(StandardError)
+
+=begin rdoc
+An object repesenting a Point in N-dimensional space
+
+Supports all of the familiar Vector methods and adds convenience
+accessors for those variables you learned to hate in your high school
+geometry class (x, y, z).
+
+== Usage
+
+=== Constructor
+    point = Geometry::Point[x,y]
+=end
+    class Point < Vector
+	attr_reader :x, :y, :z
+
+	# Allow vector-style initialization, but override to support copy-init
+	# from Vector or another Point
+	#
+	# @overload [](x,y,z,...)
+	# @overload [](Array)
+	# @overload [](Point)
+	# @overload [](Vector)
+	def self.[](*array)
+	    return array[0] if array[0].is_a?(Point) or array[0].is_a?(PointZero)
+	    array = array[0] if array[0].is_a?(Array)
+	    array = array[0].to_a if array[0].is_a?(Vector)
+	    super *array
+	end
+
+	# Creates and returns a new {PointZero} instance. Or, a {Point} full of zeros if the size argument is given.
+	# @param size [Number] the size of the new {Point} full of zeros
+	# @return [PointZero] A new {PointZero} instance
+	def self.zero(size=nil)
+	    size ? Point[Array.new(size, 0)] : PointZero.new
+	end
+
+	# Return a copy of the {Point}
+	def clone
+	    Point[@elements.clone]
+	end
+
+	# Allow comparison with an Array, otherwise do the normal thing
+	def eql?(other)
+	    if other.is_a?(Array)
+		@elements.eql? other
+	    elsif other.is_a?(PointZero)
+		@elements.all? {|e| e.eql? 0 }
+	    else
+		super other
+	    end
+	end
+
+	# Allow comparison with an Array, otherwise do the normal thing
+	def ==(other)
+	    if other.is_a?(Array)
+		@elements.eql? other
+	    elsif other.is_a?(PointZero)
+		@elements.all? {|e| e.eql? 0 }
+	    else
+		super other
+	    end
+	end
+
+	# 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
+		when Array then [Point[*other], self]
+		when Numeric then [Point[Array.new(self.size, other)], self]
+		when Vector then [Point[*other], self]
+		else
+		    raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+	    end
+	end
+
+	def inspect
+	    'Point' + @elements.inspect
+	end
+	def to_s
+	    'Point' + @elements.to_s
+	end
+
+# @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
+	# @return [Numeric] X-component
+	def x
+	    @elements[0]
+	end
+
+	# @attribute [r] y
+	# @return [Numeric] Y-component
+	def y
+	    @elements[1]
+	end
+
+	# @attribute [r] z
+	# @return [Numeric] Z-component
+	def z
+	    @elements[2]
+	end
+# @endgroup
+
+# @group Arithmetic
+
+# @group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    Point[@elements.map {|e| -e }]
+	end
+# @endgroup
+
+	def +(other)
+	    case other
+		when Numeric
+		    Point[@elements.map {|e| e + other}]
+		when PointZero, NilClass
+		    self.dup
+		else
+		    raise OperationNotDefined, "#{other.class} must respond to :size and :[]" unless other.respond_to?(:size) && other.respond_to?(:[])
+		    raise DimensionMismatch,  "Can't add #{other} to #{self}" if size != other.size
+		    Point[Array.new(size) {|i| @elements[i] + other[i] }]
+	    end
+	end
+
+	def -(other)
+	    case other
+		when Numeric
+		    Point[@elements.map {|e| e - other}]
+		when PointZero, NilClass
+		    self.dup
+		else
+		    raise OperationNotDefined, "#{other.class} must respond to :size and :[]" unless other.respond_to?(:size) && other.respond_to?(:[])
+		    raise DimensionMismatch, "Can't subtract #{other} from #{self}" if size != other.size
+		    Point[Array.new(size) {|i| @elements[i] - other[i] }]
+	    end
+	end
+
+# @endgroup
+
+    end
+end
+