aurora-geometry 0.0.2

data/lib/geometry/regular_polygon.rb

@@ -0,0 +1,136 @@
+require_relative 'cluster_factory'
+require_relative 'polygon'
+
+module Geometry
+=begin rdoc
+A {RegularPolygon} is a lot like a {Polygon}, but more regular.
+
+{http://en.wikipedia.org/wiki/Regular_polygon}
+
+== Usage
+    polygon = Geometry::RegularPolygon.new sides:4, center:[1,2], radius:3
+    polygon = Geometry::RegularPolygon.new sides:6, center:[1,2], diameter:6
+=end
+
+    class RegularPolygon < Polygon
+	include ClusterFactory
+
+	# @return [Point]   The {RegularPolygon}'s center point
+	attr_reader :center
+
+	# @return [Number]  The {RegularPolygon}'s number of sides
+	attr_reader :edge_count
+
+	# @return [Number]  The {RegularPolygon}'s radius
+	attr_reader :radius
+
+	# @overload new(sides, center, radius)
+	#   Construct a {RegularPolygon} using a center point and radius
+	#   @option options [Number]	:sides	The number of edges
+	#   @option options [Point]	:center	(PointZero) The center point of the {RegularPolygon}
+	#   @option options [Number]	:radius The radius of the {RegularPolygon}
+	# @overload new(sides, center, diameter)
+	#   Construct a {RegularPolygon} using a center point and diameter
+	#   @option options [Number]	:sides  The number of edges
+	#   @option options [Point]	:center	(PointZero) The center point of the {RegularPolygon}
+	#   @option options [Number]	:diameter   The diameter of the {RegularPolygon}
+	def self.new(options={}, &block)
+	    raise ArgumentError, "RegularPolygon requires an edge count" unless options[:sides]
+
+	    center = options[:center]
+	    center = center ? Point[center] : Point.zero
+
+	    if options.has_key?(:radius)
+		self.allocate.tap {|polygon| polygon.send :initialize, options[:sides], center, options[:radius], &block }
+	    elsif options.has_key?(:diameter)
+		DiameterRegularPolygon.new options[:sides], center, options[:diameter], &block
+	    else
+		raise ArgumentError, "RegularPolygon.new requires a radius or a diameter"
+	    end
+	end
+
+	# Construct a new {RegularPolygon} from a centerpoint and radius
+	# @param    [Number]	edge_count  The number of edges
+	# @param    [Point]	center  The center point of the {Circle}
+	# @param    [Number]	radius  The radius of the {Circle}
+	# @return   [RegularPolygon]	A new {RegularPolygon} object
+	def initialize(edge_count, center, radius)
+	    @center = Point[center]
+	    @edge_count = edge_count
+	    @radius = radius
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.edge_count == other.edge_count) && (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 {RegularPolygon}
+	def diameter
+	    @radius*2
+	end
+
+	# !@attribute [r] edges
+	def edges
+	    points = self.vertices
+	    points.each_cons(2).map {|p1,p2| Edge.new(p1,p2) } + [Edge.new(points.last, points.first)]
+	end
+
+	# !@attribute [r] vertices
+	#   @return [Array]
+	def vertices
+	    (0...2*Math::PI).step(2*Math::PI/edge_count).map {|angle| center + Point[Math::cos(angle), Math::sin(angle)]*radius }
+	end
+
+	# @return [Point]   The upper right corner of the bounding {Rectangle}
+	def max
+	    @center+Point[radius, radius]
+	end
+
+	# @return [Point]   The lower left corner of the bounding {Rectangle}
+	def min
+	    @center-Point[radius, 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 DiameterRegularPolygon < RegularPolygon
+	# @return [Number]  The {RegularPolygon}'s diameter
+	attr_reader :diameter
+
+	# Construct a new {RegularPolygon} from a centerpoint and a diameter
+	# @param    [Number]	edge_count  The number of edges
+	# @param    [Point]	center  The center point of the {RegularPolygon}
+	# @param    [Number]	diameter  The radius of the {RegularPolygon}
+	# @return   [RegularPolygon]	A new {RegularPolygon} object
+	def initialize(edge_count, center, diameter)
+	    @center = center ? Point[center] : nil
+	    @edge_count = edge_count
+	    @diameter = diameter
+	end
+
+	def eql?(other)
+	    (self.center == other.center) && (self.edge_count == other.edge_count) && (self.diameter == other.diameter)
+	end
+	alias :== :eql?
+
+# @!group Accessors
+	# @return [Number] The {RegularPolygon}'s radius
+	def radius
+	    @diameter/2
+	end
+# @!endgroup
+    end
+end

data/lib/geometry/rotation.rb

@@ -0,0 +1,190 @@
+require 'matrix'
+
+require_relative 'cluster_factory'
+require_relative 'point'
+
+module Geometry
+=begin
+A generalized representation of a rotation transformation.
+
+== Usage
+    Rotation.new angle:45*Math.PI/180	# Rotate 45 degrees counterclockwise
+    Rotation.new x:[0,1]		# Rotate 90 degrees counterclockwise
+=end
+    class Rotation
+	include ClusterFactory
+
+	# @return [Integer] dimensions
+	attr_reader :dimensions
+	attr_reader :x, :y, :z
+
+	# @overload new(angle)
+	#   Create a planar {Rotation} with an angle
+	def self.new(*args)
+	    options = args.select {|a| a.is_a? Hash}.reduce({}, :merge)
+
+	    if options.has_key? :angle
+		RotationAngle.new options[:angle]
+	elsif options.has_key?(:x) && [:x, :y, :z].one? {|k| options.has_key? k }
+		RotationAngle.new x:options[:x]
+	    else
+		self.allocate.tap {|rotation| rotation.send :initialize, *args }
+	    end
+	end
+
+	# @overload initialize(options={})
+	# @option options [Radians]	:angle	    Planar rotation angle
+	# @option options [Integer]	:dimensions Dimensionality of the rotation
+	# @option options [Vector]	:x	    X-axis
+	# @option options [Vector]	:y	    Y-axis
+	# @option options [Vector]	:z	    Z-axis
+	def initialize(*args)
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    @dimensions = options[:dimensions] || nil
+
+	    axis_options = [options[:x], options[:y], options[:z]]
+	    all_axes_options = [options[:x], options[:y], options[:z]].select {|a| a}
+	    if all_axes_options.count != 0
+		@x = options[:x] || nil
+		@y = options[:y] || nil
+		@z = options[:z] || nil
+
+		raise ArgumentError, "All axis options must be Vectors" unless all_axes_options.all? {|a| a.is_a?(Vector) or a.is_a?(Array) }
+
+		raise ArgumentError, "All provided axes must be the same size" unless all_axes_options.all? {|a| a.size == all_axes_options.first.size}
+
+		@dimensions ||= all_axes_options.first.size
+
+		raise ArgumentError, "Dimensionality mismatch" unless all_axes_options.first.size <= @dimensions
+		if all_axes_options.first.size < @dimensions
+		    @x, @y, @z = [@x, @y, @z].map {|a| (a && (a.size != 0) && (a.size < @dimensions)) ? Array.new(@dimensions) {|i| a[i] || 0 } : a }
+		end
+
+		raise ArgumentError, "Too many axes specified (expected #{@dimensions - 1} but got #{all_axes_options.size}" unless all_axes_options.size == (@dimensions - 1)
+	    end
+	end
+
+	def eql?(other)
+	    (self.x.eql? other.x) && (self.y.eql? other.y) && (self.z.eql? other.z)
+	end
+	alias :== :eql?
+
+	def identity?
+	    (!@x && !@y && !@z) || ([@x, @y, @z].select {|a| a}.all? {|a| a.respond_to?(:magnitude) ? (1 == a.magnitude) : (1 == a.size)})
+	end
+
+	# @attribute [r] matrix
+	# @return [Matrix] the transformation {Matrix} representing the {Rotation}
+	def matrix
+	    return nil unless [@x, @y, @z].compact.size >= 2
+
+	    # Force all axes to be Vectors
+	    x,y,z = [@x, @y, @z].map {|a| a.is_a?(Array) ? Vector[*a] : a}
+
+	    # Force all axes to exist
+	    if x and y
+		z = x ** y
+	    elsif x and z
+		y = x ** z
+	    elsif y and z
+		x = y ** z
+	    end
+
+	    rows = []
+	    [x, y, z].each_with_index {|a, i| rows.push(a.to_a) if i < @dimensions }
+
+	    raise ArgumentError, "Number of axes must match the dimensions of each axis" unless @dimensions == rows.size
+
+	    Matrix[*rows]
+	end
+
+
+	# Transform and return a new {Point}
+	# @param [Point] point	the {Point} to rotate into the parent coordinate frame
+	# @return [Point]   the rotated {Point}
+	def transform(point)
+	    m = matrix
+	    m ? Point[m * Point[point]] : point
+	end
+    end
+
+    class RotationAngle < Rotation
+	# @return [Radians] the planar rotation angle
+	attr_accessor :angle
+
+	# @option options [Radians] :angle	the rotation angle from the parent coordinate frame
+	# @option options [Point]   :x		the X-axis expressed in the parent coordinate frame
+	def initialize(*args)
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    angle = options[:angle] || args[0]
+
+	    if angle
+		@angle = angle
+	    elsif options.has_key? :x
+		@angle = Math.atan2(*options[:x].to_a.reverse)
+	    else
+		@angle = 0
+	    end
+	end
+
+	def eql?(other)
+	    case other
+		when RotationAngle then angle.eql? other.angle
+		else
+		    false
+	    end
+	end
+	alias :== :eql?
+
+# @group Accessors
+	# !@attribute [r] matrix
+	#   @return [Matrix] the transformation {Matrix} representing the {Rotation}
+	def matrix
+	    return nil unless angle
+
+	    c, s = Math.cos(angle), Math.sin(angle)
+	    Matrix[[c, -s], [s, c]]
+	end
+
+	# !@attribute [r] x
+	#   @return [Point] the X-axis expressed in the parent coordinate frame
+	def x
+	    Point[Math.cos(angle), Math.sin(angle)]
+	end
+
+	# !@attribute [r] y
+	#   @return [Point] the Y-axis expressed in the parent coordinate frame
+	def y
+	    Point[-Math.sin(angle), Math.cos(angle)]
+	end
+# @endgroup
+
+# @group Composition
+	def -@
+	    RotationAngle.new(-angle)
+	end
+
+	def +(other)
+	    case other
+		when RotationAngle
+		    RotationAngle.new(angle + other.angle)
+		else
+		    raise TypeError, "Can't compose a #{self.class} with a #{other.class}"
+	    end
+	end
+
+	def -(other)
+	    case other
+		when RotationAngle
+		    RotationAngle.new(angle - other.angle)
+		else
+		    raise TypeError, "Can't subtract #{other.class} from #{self.class}"
+	    end
+	end
+# @endgroup
+    end
+end

data/lib/geometry/size.rb

@@ -0,0 +1,75 @@
+require 'matrix'
+
+module Geometry
+=begin
+An object representing the size of something.
+ 
+Supports all of the familiar {Vector} methods as well as a few convenience 
+methods (width, height and depth).
+ 
+== Usage
+ 
+=== Constructor
+   size = Geometry::Size[x,y,z]
+=end
+
+    class Size < Vector
+	attr_reader :x, :y, :z
+	
+	# Allow vector-style initialization, but override to support copy-init
+	# from Vector, Point or another Size
+	#
+	# @overload [](x,y,z,...)
+	# @overload [](Point)
+	# @overload [](Size)
+	# @overload [](Vector)
+	# @return [Size]    A new {Size} object
+	def self.[](*array)
+	    array = array[0].to_a unless array[0].is_a?(Numeric)
+	    super *array
+	end
+	
+	# Allow comparison with an Array, otherwise do the normal thing
+	def ==(other)
+	    return @elements == other if other.is_a?(Array)
+	    super other
+	end
+
+	def inspect
+	    'Size' + @elements.inspect
+	end
+	def to_s
+	    'Size' + @elements.to_s
+	end
+
+	# @return [Number]  The size along the Z axis
+	def depth
+	    z
+	end
+
+	# @return [Number]  The size along the Y axis
+	def height
+	    y
+	end
+
+	# @return [Number]  The size along the X axis
+	def width
+	    x
+	end
+
+	# @return [Number] X-component (width)
+	def x
+	    @elements[0]
+	end
+
+	# @return [Number] Y-component (height)
+	def y
+	    @elements[1]
+	end
+
+	# @return [Number] Z-component (depth)
+	def z
+	    @elements[2]
+	end
+    end
+end

data/lib/geometry/size_zero.rb

@@ -0,0 +1,70 @@
+require_relative 'point'
+
+module Geometry
+=begin rdoc
+An object repesenting a zero {Size} in N-dimensional space
+
+A {SizeZero} object is a {Size} that will always compare equal to zero and unequal to
+everything else, regardless of dimensionality. You can think of it as an application of the
+{http://en.wikipedia.org/wiki/Null_Object_pattern Null Object Pattern}.
+=end
+    class SizeZero
+	def eql?(other)
+	    if other.respond_to? :all?
+		other.all? {|e| e.eql? 0}
+	    else
+		other == 0
+	    end
+	end
+	alias == eql?
+
+	def coerce(other)
+	    if other.is_a? Numeric
+		[other, 0]
+	    elsif other.is_a? Array
+		[other, Array.new(other.size,0)]
+	    elsif other.is_a? Vector
+		[other, Vector[*Array.new(other.size,0)]]
+	    else
+		[Size[other], Size[Array.new(other.size,0)]]
+	    end
+	end
+
+# @group Arithmetic
+
+# @group Unary operators
+	def +@
+	    self
+	end
+
+	def -@
+	    self
+	end
+# @endgroup
+
+	def +(other)
+	    other
+	end
+
+	def -(other)
+	    if other.respond_to? :-@
+		-other
+	    elsif other.respond_to? :map
+		other.map {|a| -a }
+	    end
+	end
+
+	def *(other)
+	    self
+	end
+
+	def /(other)
+	    raise OperationNotDefined unless other.is_a? Numeric
+	    raise ZeroDivisionError if 0 == other
+	    self
+	end
+# @endgroup
+
+    end
+end
+